starpc 0.49.20 → 0.51.0

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

@@ -1,25 +1,10 @@
 import net from 'net';
-import { closeSync, openSync, writeSync } from 'node:fs';
 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 { EchoMsg, runClientTest } from '../../echo/index.js';
-function emitReceiptEvent(line) {
-    console.log(line);
-    const fifo = process.env.RECEIPT_EVENT_FIFO;
-    if (!fifo) {
-        return;
-    }
-    const fd = openSync(fifo, 'w');
-    try {
-        writeSync(fd, `${line}\n`);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
+import { runClientTest } from '../../echo/index.js';
 // tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
 function tcpSocketToPacketStream(socket) {
     const socketSource = async function* () {
@@ -51,85 +36,26 @@ function tcpSocketToPacketStream(socket) {
     };
 }
 async function main() {
-    const receiptMode = process.argv[2] === 'receipt';
-    const receiptCase = receiptMode ? process.argv[3] : undefined;
-    const addr = receiptMode ? process.argv[4] : process.argv[2];
+    const addr = process.argv[2];
     if (!addr) {
-        console.error('usage: ts-client [receipt <case>] <host:port>');
+        console.error('usage: ts-client <host:port>');
         process.exit(1);
     }
-    if (receiptMode &&
-        !['commit', 'abort', 'loss', 'bare-close'].includes(receiptCase ?? '')) {
-        throw new Error(`unknown receipt case: ${receiptCase}`);
-    }
     const [host, portStr] = addr.split(':');
     const port = parseInt(portStr, 10);
-    let activeSocket;
     const openStream = async () => {
         const { promise, resolve, reject } = Promise.withResolvers();
         const socket = net.connect(port, host, () => {
-            activeSocket = socket;
             resolve(tcpSocketToPacketStream(socket));
         });
         socket.on('error', reject);
         return promise;
     };
     const client = new Client(openStream);
-    if (receiptMode) {
-        console.log(`Running held receipt test via TCP (${receiptCase})...`);
-        const request = EchoMsg.create({ body: 'held receipt' });
-        const held = await client.requestWithReceipt('echo.Echoer', 'Echo', EchoMsg.toBinary(request));
-        const result = EchoMsg.fromBinary(held.response);
-        if (result.body !== request.body) {
-            throw new Error(`expected ${request.body}, got ${result.body}`);
-        }
-        switch (receiptCase) {
-            case 'commit':
-                await held.receipt.commit();
-                break;
-            case 'abort':
-                await held.receipt.abort();
-                break;
-            case 'loss':
-                activeSocket?.resetAndDestroy();
-                await expectReceiptFailure(held.receipt);
-                break;
-            case 'bare-close':
-                activeSocket?.end();
-                await expectReceiptFailure(held.receipt);
-                break;
-        }
-        emitReceiptEvent(`CLIENT_RECEIPT_RESOLVED ${receiptTerminalName(receiptCase ?? '')}`);
-    }
-    else {
-        console.log('Running client test via TCP...');
-        await runClientTest(client);
-    }
+    console.log('Running client test via TCP...');
+    await runClientTest(client);
     console.log('All tests passed.');
 }
-function receiptTerminalName(receiptCase) {
-    switch (receiptCase) {
-        case 'commit':
-            return 'committed';
-        case 'abort':
-            return 'canceled';
-        case 'loss':
-            return 'transportLost';
-        case 'bare-close':
-            return 'closed';
-        default:
-            return 'unknown';
-    }
-}
-async function expectReceiptFailure(receipt) {
-    try {
-        await receipt.commit();
-    }
-    catch {
-        return;
-    }
-    throw new Error('receipt commit unexpectedly succeeded');
-}
 process.on('unhandledRejection', (ev) => {
     console.error('Unhandled rejection', ev);
     process.exit(1);

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

@@ -1,27 +1,11 @@
 import net from 'net';
-import { closeSync, openSync, writeSync } from 'node:fs';
 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, EchoMsg } from '../../echo/index.js';
+import { EchoerServer } from '../../echo/index.js';
 import { EchoerDefinition } from '../../echo/echo_srpc.pb.js';
-import { Packet } from '../../srpc/rpcproto.pb.js';
-function emitReceiptEvent(line) {
-    console.log(line);
-    const fifo = process.env.RECEIPT_EVENT_FIFO;
-    if (!fifo) {
-        return;
-    }
-    const fd = openSync(fifo, 'w');
-    try {
-        writeSync(fd, `${line}\n`);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
 // tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
 // Each Uint8Array in source/sink is one packet (no length prefix).
 function tcpSocketToPacketStream(socket) {
@@ -41,12 +25,7 @@ function tcpSocketToPacketStream(socket) {
         sink: async (source) => {
             for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
                 const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
-                const packet = Packet.fromBinary(data.subarray(4));
-                const receiptCompletion = receiptMode &&
-                    packet.body?.case === 'callData' &&
-                    packet.body.value.complete &&
-                    !packet.body.value.error;
-                const writeDone = new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     socket.write(data, (err) => {
                         if (err)
                             reject(err);
@@ -54,69 +33,15 @@ function tcpSocketToPacketStream(socket) {
                             resolve();
                     });
                 });
-                if (receiptCompletion) {
-                    emitReceiptEvent('SERVER_RECEIPT_ACK committed');
-                }
-                await writeDone;
-                if (receiptCompletion) {
-                    finishReceiptServer();
-                }
             }
             socket.end();
         },
     };
 }
 const mux = createMux();
-const receiptMode = process.argv[2] === 'receipt';
-const receiptCase = receiptMode ? process.argv[3] : undefined;
-if (receiptMode &&
-    !['commit', 'abort', 'loss', 'bare-close'].includes(receiptCase ?? '')) {
-    console.error(`unknown receipt case: ${receiptCase}`);
-    process.exit(1);
-}
-const receiptServerDone = Promise.withResolvers();
-let receiptServerFinished = false;
-function finishReceiptServer() {
-    if (!receiptServerFinished) {
-        receiptServerFinished = true;
-        receiptServerDone.resolve();
-    }
-}
-if (receiptMode) {
-    mux.registerLookupMethod(async (serviceID, methodID) => {
-        if (serviceID !== 'echo.Echoer' || methodID !== 'Echo') {
-            return null;
-        }
-        return async (dataSource, dataSink, invocation) => {
-            let requestData;
-            for await (const data of dataSource) {
-                requestData = data;
-                break;
-            }
-            if (!requestData) {
-                throw new Error('receipt request was empty');
-            }
-            const requestMsg = EchoMsg.fromBinary(requestData);
-            await dataSink((async function* () {
-                yield EchoMsg.toBinary(requestMsg);
-                if (!invocation) {
-                    throw new Error('receipt invocation was missing');
-                }
-                emitReceiptEvent('SERVER_RECEIPT_WAITING');
-                const terminal = await invocation.waitTerminal(new AbortController().signal);
-                emitReceiptEvent(`SERVER_RECEIPT_TERMINAL ${terminal}`);
-                if (terminal !== 'committed') {
-                    finishReceiptServer();
-                }
-            })());
-        };
-    });
-}
 const server = new Server(mux.lookupMethod);
-if (!receiptMode) {
-    const echoer = new EchoerServer(server);
-    mux.register(createHandler(EchoerDefinition, echoer));
-}
+const echoer = new EchoerServer(server);
+mux.register(createHandler(EchoerDefinition, echoer));
 const tcpServer = net.createServer((socket) => {
     const stream = tcpSocketToPacketStream(socket);
     server.handlePacketStream(stream);
@@ -125,11 +50,6 @@ tcpServer.listen(0, '127.0.0.1', () => {
     const addr = tcpServer.address();
     console.log(`LISTENING ${addr.address}:${addr.port}`);
 });
-if (receiptMode) {
-    void receiptServerDone.promise.then(() => {
-        tcpServer.close();
-    });
-}
 process.on('SIGINT', () => {
     tcpServer.close();
     process.exit(0);

package/dist/mock/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./mock.pb.js";
-export * from "./mock_srpc.pb.js";
+export * from './mock.pb.js';
+export * from './mock_srpc.pb.js';

package/dist/mock/index.js

@@ -1,2 +1,2 @@
-export * from "./mock.pb.js";
-export * from "./mock_srpc.pb.js";
+export * from './mock.pb.js';
+export * from './mock_srpc.pb.js';

package/dist/srpc/client.d.ts

@@ -1,12 +1,10 @@
 import type { ProtoRpc } from './proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
-import type { HeldCall, ReceiptRpc } from './call-receipt.js';
-export declare class Client implements ProtoRpc, ReceiptRpc {
+export declare class Client implements ProtoRpc {
     private openStreamCtr;
     constructor(openStreamFn?: OpenStreamFunc);
     setOpenStreamFn(openStreamFn?: OpenStreamFunc): void;
     request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
-    requestWithReceipt(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<HeldCall>;
     clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
     bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;

package/dist/srpc/client.js

@@ -5,7 +5,6 @@ import { ClientRPC } from './client-rpc.js';
 import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource } from './packet.js';
 import { OpenStreamCtr } from './open-stream-ctr.js';
-import { CallReceipt } from './call-receipt.js';
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
     // openStreamCtr contains the OpenStreamFunc.
@@ -28,25 +27,6 @@ export class Client {
         call.close(err);
         throw err;
     }
-    // requestWithReceipt reads one response and retains the call terminal.
-    async requestWithReceipt(service, method, data, abortSignal) {
-        const call = await this.startRpc(service, method, data, abortSignal);
-        const iterator = call.rpcDataSource[Symbol.asyncIterator]();
-        try {
-            const result = await iterator.next();
-            if (result.done) {
-                throw new Error('empty response');
-            }
-            return {
-                response: result.value,
-                receipt: new CallReceipt(call, iterator),
-            };
-        }
-        catch (err) {
-            await call.close(err instanceof Error ? err : new Error('receipt read failed'));
-            throw err;
-        }
-    }
     // clientStreamingRequest starts a client side streaming request.
     async clientStreamingRequest(service, method, data, abortSignal) {
         const call = await this.startRpc(service, method, null, abortSignal);
@@ -102,8 +82,8 @@ export class Client {
         const stream = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         const onAbort = () => {
-            call.writeCallCancel();
-            call.close(new Error(ERR_RPC_ABORT));
+            void call.writeCallCancel().catch(() => undefined);
+            void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined);
         };
         abortSignal?.addEventListener('abort', onAbort, { once: true });
         pipe(stream, decodePacketSource, call, encodePacketSource, stream)

package/dist/srpc/common-rpc.d.ts

@@ -1,7 +1,5 @@
 import type { Sink, Source } from 'it-stream-types';
-import type { CallData, CallStart } from './rpcproto.pb.js';
-import { Packet } from './rpcproto.pb.js';
-import type { TerminalKind } from './server-invocation.js';
+import { Packet, type CallData, type CallStart } from './rpcproto.pb.js';
 export declare class CommonRPC {
     readonly sink: Sink<Source<Packet>>;
     readonly source: AsyncIterable<Packet>;
@@ -11,20 +9,12 @@ export declare class CommonRPC {
     protected service?: string;
     protected method?: string;
     private closed?;
-    private remoteCompleted;
     private remoteError?;
-    private remoteSourceClosed;
-    private remoteTerminal?;
     private readonly invocationController;
-    private readonly terminalPromise;
-    private resolveTerminal;
     private readonly writeDrainAbort;
     constructor();
     get isClosed(): boolean | Error;
     protected get invocationSignal(): AbortSignal;
-    protected waitTerminal(ownerSignal: AbortSignal): Promise<TerminalKind>;
-    getTerminalKind(): TerminalKind | undefined;
-    private recordRemoteTerminal;
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     private writeCallDataPacket;
     writeCallCancel(waitForDrain?: boolean): Promise<void>;

package/dist/srpc/common-rpc.js

@@ -24,25 +24,13 @@ export class CommonRPC {
     method;
     // closed indicates this rpc has been closed already.
     closed;
-    // remoteCompleted is set only by an explicit remote CallData completion.
-    remoteCompleted = false;
     // remoteError records a remote error or transport failure.
     remoteError;
-    // remoteSourceClosed records an incoming source ending without a packet error.
-    remoteSourceClosed = false;
-    // remoteTerminal is the first valid remote terminal.
-    remoteTerminal;
-    // invocationController cancels the server invocation on a remote terminal.
+    // invocationController cancels the server invocation when the RPC closes.
     invocationController = new AbortController();
-    // terminalPromise resolves when a remote terminal is recorded.
-    terminalPromise;
-    resolveTerminal;
     // writeDrainAbort wakes writers waiting for outbound stream drain on close.
     writeDrainAbort = new AbortController();
     constructor() {
-        const { promise, resolve } = Promise.withResolvers();
-        this.terminalPromise = promise;
-        this.resolveTerminal = resolve;
         this.sink = this._createSink();
         this.source = this._source;
         this.rpcDataSource = this._rpcDataSource;
@@ -51,49 +39,10 @@ export class CommonRPC {
     get isClosed() {
         return this.closed ?? false;
     }
-    // invocationSignal is canceled when the RPC reaches a terminal.
+    // invocationSignal is canceled when the RPC closes.
     get invocationSignal() {
         return this.invocationController.signal;
     }
-    // waitTerminal waits for the remote terminal or external owner cancellation.
-    async waitTerminal(ownerSignal) {
-        const { promise: ownerDone, resolve: resolveOwnerDone } = Promise.withResolvers();
-        const onAbort = () => resolveOwnerDone();
-        ownerSignal.addEventListener('abort', onAbort, { once: true });
-        let ownerAborted = ownerSignal.aborted;
-        try {
-            for (;;) {
-                const terminal = this.getTerminalKind();
-                if (terminal !== undefined) {
-                    if (terminal === 'closed' &&
-                        this.remoteSourceClosed &&
-                        !this.closed) {
-                        await this.close();
-                    }
-                    return terminal;
-                }
-                if (ownerAborted) {
-                    return 'abandoned';
-                }
-                await Promise.race([this.terminalPromise, ownerDone]);
-                ownerAborted = ownerSignal.aborted;
-            }
-        }
-        finally {
-            ownerSignal.removeEventListener('abort', onAbort);
-        }
-    }
-    // getTerminalKind returns the observed remote terminal, if any.
-    getTerminalKind() {
-        return this.remoteTerminal;
-    }
-    recordRemoteTerminal(kind) {
-        if (this.remoteTerminal !== undefined) {
-            return;
-        }
-        this.remoteTerminal = kind;
-        this.resolveTerminal();
-    }
     // writeCallData writes the call data packet.
     async writeCallData(data, complete, error) {
         await this.writeCallDataPacket(data, complete, error);
@@ -215,26 +164,22 @@ export class CommonRPC {
             throw new Error('call start must be sent before call data');
         }
         this.pushRpcData(packet.data, packet.dataIsZero);
-        const remoteError = packet.error ?
-            new RemoteRPCError(this.service, this.method, packet.error)
+        const remoteError = packet.error
+            ? new RemoteRPCError(this.service, this.method, packet.error)
             : undefined;
         if (remoteError) {
             this.remoteError ??= remoteError;
             this.invocationController.abort();
-            this.recordRemoteTerminal('transportLost');
         }
         if (packet.complete && !remoteError) {
-            this.remoteCompleted = true;
-            this.recordRemoteTerminal('committed');
             this._rpcDataSource.end(remoteError);
         }
         else if (remoteError) {
             this._rpcDataSource.end(remoteError);
         }
     }
-    // handleCallCancel handles a CallCancel packet.
+    // handleCallCancel aborts the invocation and closes the call.
     async handleCallCancel() {
-        this.recordRemoteTerminal('canceled');
         await this.close(new Error(ERR_RPC_ABORT));
     }
     // close closes the call, optionally with an error.
@@ -246,7 +191,6 @@ export class CommonRPC {
         if (!this.remoteError && err) {
             this.remoteError = err;
         }
-        this.recordRemoteTerminal(err ? 'transportLost' : 'closed');
         this.invocationController.abort();
         // note: this does nothing if _source is already ended.
         if (err && err.message) {
@@ -259,24 +203,19 @@ export class CommonRPC {
         this._source.end();
         this._rpcDataSource.end(err);
     }
-    // _createSink returns a value for the sink field.
     _createSink() {
         return async (source) => {
             try {
                 if (Symbol.asyncIterator in source) {
-                    // Handle async source
                     for await (const msg of source) {
                         await this.handlePacket(msg);
                     }
                 }
                 else {
-                    // Handle sync source
                     for (const msg of source) {
                         await this.handlePacket(msg);
                     }
                 }
-                this.remoteSourceClosed = true;
-                this.recordRemoteTerminal('closed');
             }
             catch (err) {
                 this.close(err);

package/dist/srpc/handler.d.ts

@@ -1,7 +1,6 @@
 import type { Sink, Source } from 'it-stream-types';
 import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js';
-import type { ServerInvocation } from './server-invocation.js';
-export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, invocation?: ServerInvocation) => Promise<void>;
+export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, invocation?: AbortSignal) => Promise<void>;
 export interface Handler {
     getServiceID(): string;
     getMethodIDs(): string[];

package/dist/srpc/index.d.ts

@@ -1,9 +1,5 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
-export { CallReceipt } from './call-receipt.js';
-export type { HeldCall, ReceiptRpc } from './call-receipt.js';
-export { ServerInvocation } from './server-invocation.js';
-export type { TerminalKind } from './server-invocation.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export type { StreamConnParams, StreamHandler } from './conn.js';

package/dist/srpc/index.js

@@ -1,7 +1,5 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
-export { CallReceipt } from './call-receipt.js';
-export { ServerInvocation } from './server-invocation.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export { WebSocketConn } from './websocket.js';

package/dist/srpc/invoker.d.ts

@@ -2,6 +2,5 @@ import type { MethodDefinition } from './definition.js';
 import { InvokeFn } from './handler.js';
 import type { MessageType, Message } from '@aptre/protobuf-es-lite';
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite';
-import type { ServerInvocation } from './server-invocation.js';
-export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R, invocation?: ServerInvocation) => Promise<O>) | ((request: R, invocation?: ServerInvocation) => AsyncIterable<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => Promise<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => AsyncIterable<O>);
+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 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/server-rpc.js

@@ -1,5 +1,4 @@
 import { CommonRPC } from './common-rpc.js';
-import { ServerInvocation } from './server-invocation.js';
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
     // lookupMethod looks up the incoming RPC methods.
@@ -38,9 +37,8 @@ export class ServerRPC extends CommonRPC {
     // invokeRPC starts invoking the RPC handler.
     async invokeRPC(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, this.invocationSignal);
         }
         catch (err) {
             this.close(err);

package/dist/srpc/server.test.js

@@ -1,7 +1,7 @@
 import { describe, it, beforeEach, expect, vi } from 'vitest';
 import { pipe } from 'it-pipe';
 import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, Packet, } from '../srpc/index.js';
-import { EchoerDefinition, EchoerServer, EchoerServiceName, runClientTest, } from '../echo/index.js';
+import { EchoerDefinition, EchoerServer, EchoerServiceName, EchoMsg, runClientTest, } from '../echo/index.js';
 import { runAbortControllerTest, runRpcStreamTest, } from '../echo/client-test.js';
 describe('srpc server', () => {
     let client;
@@ -39,6 +39,33 @@ describe('srpc server', () => {
     it('should pass rpc stream tests', async () => {
         await runRpcStreamTest(client);
     });
+    it('passes the exact invocation signal after async request decode', async () => {
+        const controller = new AbortController();
+        let observedSignal;
+        const handler = createHandler(EchoerDefinition, {
+            Echo: async (request, signal) => {
+                observedSignal = signal;
+                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();
+        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();
+        }, controller.signal);
+        await drained.promise;
+        expect(observedSignal).toBe(controller.signal);
+    });
     it('keeps detached server-streaming responses open after request source completes', async () => {
         const mux = createMux();
         const response = new TextEncoder().encode('delayed init');
@@ -166,6 +193,13 @@ describe('srpc server', () => {
         await new Promise((resolve) => setTimeout(resolve, 50));
         expect(removeEventListener).toHaveBeenCalledWith('abort', expect.any(Function));
     });
+    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 = { idleTimeoutMs: 1000, keepAliveMs: 1000 };

package/echo/echo.go

@@ -7,15 +7,15 @@ import (
 
 // _ is a type assertion
 var (
-	_ srpc.StreamRecv[*EchoMsg] = (SRPCEchoer_EchoBidiStreamClient)(nil)
-	_ srpc.StreamRecv[*EchoMsg] = (SRPCEchoer_EchoServerStreamClient)(nil)
+	_ srpc.StreamRecv[*EchoMsg] = SRPCEchoer_EchoBidiStreamClient(nil)
+	_ srpc.StreamRecv[*EchoMsg] = SRPCEchoer_EchoServerStreamClient(nil)
 
-	_ srpc.StreamSend[*EchoMsg] = (SRPCEchoer_EchoBidiStreamClient)(nil)
-	_ srpc.StreamSend[*EchoMsg] = (SRPCEchoer_EchoClientStreamClient)(nil)
+	_ srpc.StreamSend[*EchoMsg] = SRPCEchoer_EchoBidiStreamClient(nil)
+	_ srpc.StreamSend[*EchoMsg] = SRPCEchoer_EchoClientStreamClient(nil)
 
-	_ srpc.StreamSendAndClose[*EchoMsg] = (SRPCEchoer_EchoBidiStreamStream)(nil)
-	_ srpc.StreamSendAndClose[*EchoMsg] = (SRPCEchoer_EchoServerStreamStream)(nil)
+	_ srpc.StreamSendAndClose[*EchoMsg] = SRPCEchoer_EchoBidiStreamStream(nil)
+	_ srpc.StreamSendAndClose[*EchoMsg] = SRPCEchoer_EchoServerStreamStream(nil)
 
-	_ srpc.StreamRecv[*rpcstream.RpcStreamPacket]         = (SRPCEchoer_RpcStreamStream)(nil)
-	_ srpc.StreamSendAndClose[*rpcstream.RpcStreamPacket] = (SRPCEchoer_RpcStreamStream)(nil)
+	_ srpc.StreamRecv[*rpcstream.RpcStreamPacket]         = SRPCEchoer_RpcStreamStream(nil)
+	_ srpc.StreamSendAndClose[*rpcstream.RpcStreamPacket] = SRPCEchoer_RpcStreamStream(nil)
 )