starpc 0.50.0 → 0.52.0

package/cmd/protoc-gen-es-starpc/typescript.ts

@@ -26,6 +26,7 @@ import {
 } from '@aptre/protobuf-es-lite/protoplugin/ecmascript'
 
 const MessageStream = createImportSymbol('MessageStream', 'starpc')
+const ServerContext = createImportSymbol('ServerContext', 'starpc')
 const RuntimeMethodKind = createImportSymbol(
   'MethodKind',
   '@aptre/protobuf-es-lite',
@@ -128,6 +129,42 @@ function generateService(
   f.print("}");
   f.print();
 
+  // Generate the server implementation interface.
+  f.print(f.jsDoc(service));
+  f.print("export interface ", localName(service), "Handler {");
+  for (let i = 0; i < service.methods.length; i++) {
+    const method = service.methods[i];
+    f.print(f.jsDoc(method, "  "));
+    if (method.methodKind === MethodKind.Unary) {
+      f.print(
+        "  ", method.name,
+        "(request: ", method.input, ", abortSignal: AbortSignal, context: ", ServerContext, "): ",
+        "Promise<", method.output, ">;"
+      );
+    } else if (method.methodKind === MethodKind.ServerStreaming) {
+      f.print(
+        "  ", method.name,
+        "(request: ", method.input, ", abortSignal: AbortSignal, context: ", ServerContext, "): ",
+        MessageStream, "<", method.output, ">;"
+      );
+    } else if (method.methodKind === MethodKind.ClientStreaming) {
+      f.print(
+        "  ", method.name,
+        "(request: ", MessageStream, "<", method.input, ">, abortSignal: AbortSignal, context: ", ServerContext, "): ",
+        "Promise<", method.output, ">;"
+      );
+    } else if (method.methodKind === MethodKind.BiDiStreaming) {
+      f.print(
+        "  ", method.name,
+        "(request: ", MessageStream, "<", method.input, ">, abortSignal: AbortSignal, context: ", ServerContext, "): ",
+        MessageStream, "<", method.output, ">;"
+      );
+    }
+    if (i < service.methods.length - 1) f.print();
+  }
+  f.print("}");
+  f.print();
+
 
   // Generate the service name constant
   f.print("export const ", localName(service), "ServiceName = ", localName(service), "Definition.typeName");

package/dist/cmd/protoc-gen-es-starpc/typescript.js

@@ -15,6 +15,7 @@
 import { MethodIdempotency, MethodKind, localName, } from '@aptre/protobuf-es-lite';
 import { createImportSymbol, } from '@aptre/protobuf-es-lite/protoplugin/ecmascript';
 const MessageStream = createImportSymbol('MessageStream', 'starpc');
+const ServerContext = createImportSymbol('ServerContext', 'starpc');
 const RuntimeMethodKind = createImportSymbol('MethodKind', '@aptre/protobuf-es-lite');
 const RuntimeMethodIdempotency = createImportSymbol('MethodIdempotency', '@aptre/protobuf-es-lite');
 // const Message = createImportSymbol('Message', '@aptre/protobuf-es-lite')
@@ -74,6 +75,29 @@ function generateService(f, service) {
     }
     f.print("}");
     f.print();
+    // Generate the server implementation interface.
+    f.print(f.jsDoc(service));
+    f.print("export interface ", localName(service), "Handler {");
+    for (let i = 0; i < service.methods.length; i++) {
+        const method = service.methods[i];
+        f.print(f.jsDoc(method, "  "));
+        if (method.methodKind === MethodKind.Unary) {
+            f.print("  ", method.name, "(request: ", method.input, ", abortSignal: AbortSignal, context: ", ServerContext, "): ", "Promise<", method.output, ">;");
+        }
+        else if (method.methodKind === MethodKind.ServerStreaming) {
+            f.print("  ", method.name, "(request: ", method.input, ", abortSignal: AbortSignal, context: ", ServerContext, "): ", MessageStream, "<", method.output, ">;");
+        }
+        else if (method.methodKind === MethodKind.ClientStreaming) {
+            f.print("  ", method.name, "(request: ", MessageStream, "<", method.input, ">, abortSignal: AbortSignal, context: ", ServerContext, "): ", "Promise<", method.output, ">;");
+        }
+        else if (method.methodKind === MethodKind.BiDiStreaming) {
+            f.print("  ", method.name, "(request: ", MessageStream, "<", method.input, ">, abortSignal: AbortSignal, context: ", ServerContext, "): ", MessageStream, "<", method.output, ">;");
+        }
+        if (i < service.methods.length - 1)
+            f.print();
+    }
+    f.print("}");
+    f.print();
     // Generate the service name constant
     f.print("export const ", localName(service), "ServiceName = ", localName(service), "Definition.typeName");
     f.print();

package/dist/echo/echo_srpc.pb.d.ts

@@ -2,7 +2,7 @@ import { EchoMsg } from './echo.pb.js';
 import { MethodKind } from '@aptre/protobuf-es-lite';
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import { Empty } from '@aptre/protobuf-es-lite/google/protobuf/empty';
-import { MessageStream, ProtoRpc } from 'starpc';
+import { MessageStream, ProtoRpc, ServerContext } from 'starpc';
 /**
  * Echoer service returns the given message.
  *
@@ -122,6 +122,49 @@ export interface Echoer {
      */
     DoNothing(request: Empty, abortSignal?: AbortSignal): Promise<Empty>;
 }
+/**
+ * Echoer service returns the given message.
+ *
+ * @generated from service echo.Echoer
+ */
+export interface EchoerHandler {
+    /**
+     * Echo returns the given message.
+     *
+     * @generated from rpc echo.Echoer.Echo
+     */
+    Echo(request: EchoMsg, abortSignal: AbortSignal, context: ServerContext): Promise<EchoMsg>;
+    /**
+     * EchoServerStream is an example of a server -> client one-way stream.
+     *
+     * @generated from rpc echo.Echoer.EchoServerStream
+     */
+    EchoServerStream(request: EchoMsg, abortSignal: AbortSignal, context: ServerContext): MessageStream<EchoMsg>;
+    /**
+     * EchoClientStream is an example of client->server one-way stream.
+     *
+     * @generated from rpc echo.Echoer.EchoClientStream
+     */
+    EchoClientStream(request: MessageStream<EchoMsg>, abortSignal: AbortSignal, context: ServerContext): Promise<EchoMsg>;
+    /**
+     * EchoBidiStream is an example of a two-way stream.
+     *
+     * @generated from rpc echo.Echoer.EchoBidiStream
+     */
+    EchoBidiStream(request: MessageStream<EchoMsg>, abortSignal: AbortSignal, context: ServerContext): MessageStream<EchoMsg>;
+    /**
+     * RpcStream opens a nested rpc call stream.
+     *
+     * @generated from rpc echo.Echoer.RpcStream
+     */
+    RpcStream(request: MessageStream<RpcStreamPacket>, abortSignal: AbortSignal, context: ServerContext): MessageStream<RpcStreamPacket>;
+    /**
+     * DoNothing does nothing.
+     *
+     * @generated from rpc echo.Echoer.DoNothing
+     */
+    DoNothing(request: Empty, abortSignal: AbortSignal, context: ServerContext): Promise<Empty>;
+}
 export declare const EchoerServiceName: "echo.Echoer";
 export declare class EchoerClient implements Echoer {
     private readonly rpc;

package/dist/echo/server.d.ts

@@ -2,16 +2,17 @@ import { Message } from '@aptre/protobuf-es-lite';
 import { Empty } from '@aptre/protobuf-es-lite/google/protobuf/empty';
 import { EchoMsg } from './echo.pb.js';
 import { Server } from '../srpc/server.js';
+import type { ServerContext } from '../srpc/server-context.js';
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import { MessageStream } from '../srpc/message.js';
-import { Echoer } from './echo_srpc.pb.js';
-export declare class EchoerServer implements Echoer {
+import type { EchoerHandler } from './echo_srpc.pb.js';
+export declare class EchoerServer implements EchoerHandler {
     private proxyServer?;
     constructor(proxyServer?: Server);
-    Echo(request: EchoMsg): Promise<Message<EchoMsg>>;
-    EchoServerStream(request: EchoMsg): MessageStream<EchoMsg>;
-    EchoClientStream(request: MessageStream<EchoMsg>): Promise<Message<EchoMsg>>;
-    EchoBidiStream(request: MessageStream<EchoMsg>): MessageStream<EchoMsg>;
-    RpcStream(request: MessageStream<RpcStreamPacket>): MessageStream<RpcStreamPacket>;
-    DoNothing(): Promise<Empty>;
+    Echo(request: EchoMsg, _abortSignal: AbortSignal, _context: ServerContext): Promise<Message<EchoMsg>>;
+    EchoServerStream(request: EchoMsg, _abortSignal: AbortSignal, _context: ServerContext): MessageStream<EchoMsg>;
+    EchoClientStream(request: MessageStream<EchoMsg>, _abortSignal: AbortSignal, _context: ServerContext): Promise<Message<EchoMsg>>;
+    EchoBidiStream(request: MessageStream<EchoMsg>, _abortSignal: AbortSignal, _context: ServerContext): MessageStream<EchoMsg>;
+    RpcStream(request: MessageStream<RpcStreamPacket>, _abortSignal: AbortSignal, _context: ServerContext): MessageStream<RpcStreamPacket>;
+    DoNothing(_request: Empty, _abortSignal: AbortSignal, _context: ServerContext): Promise<Empty>;
 }

package/dist/echo/server.js

@@ -8,16 +8,16 @@ export class EchoerServer {
     constructor(proxyServer) {
         this.proxyServer = proxyServer;
     }
-    async Echo(request) {
+    async Echo(request, _abortSignal, _context) {
         return request;
     }
-    async *EchoServerStream(request) {
+    async *EchoServerStream(request, _abortSignal, _context) {
         for (let i = 0; i < 5; i++) {
             yield request;
             await new Promise((resolve) => setTimeout(resolve, 200));
         }
     }
-    async EchoClientStream(request) {
+    async EchoClientStream(request, _abortSignal, _context) {
         // return the first message sent by the client.
         const message = await first(request);
         if (!message) {
@@ -25,14 +25,14 @@ export class EchoerServer {
         }
         return message;
     }
-    EchoBidiStream(request) {
+    EchoBidiStream(request, _abortSignal, _context) {
         // build result observable
         const result = messagePushable();
         result.push({ body: 'hello from server' });
         writeToPushable(request, result);
         return result;
     }
-    RpcStream(request) {
+    RpcStream(request, _abortSignal, _context) {
         return handleRpcStream(request[Symbol.asyncIterator](), async () => {
             if (!this.proxyServer) {
                 throw new Error('rpc stream proxy server not set');
@@ -40,7 +40,7 @@ export class EchoerServer {
             return this.proxyServer.rpcStreamHandler;
         });
     }
-    async DoNothing() {
+    async DoNothing(_request, _abortSignal, _context) {
         return {};
     }
 }

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, TerminalKind } 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,15 +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;
-                if (receiptCompletion) {
-                    emitReceiptEvent('SERVER_RECEIPT_ACK_WRITE committed');
-                }
-                const writeDone = new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     socket.write(data, (err) => {
                         if (err)
                             reject(err);
@@ -57,82 +33,15 @@ function tcpSocketToPacketStream(socket) {
                             resolve();
                     });
                 });
-                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 ${terminalName(terminal)}`);
-                if (terminal !== TerminalKind.COMMITTED) {
-                    finishReceiptServer();
-                }
-            })());
-        };
-    });
-}
-function terminalName(terminal) {
-    switch (terminal) {
-        case TerminalKind.COMMITTED:
-            return 'committed';
-        case TerminalKind.CANCELED:
-            return 'canceled';
-        case TerminalKind.TRANSPORT_LOST:
-            return 'transportLost';
-        case TerminalKind.CLOSED:
-            return 'closed';
-        case TerminalKind.ABANDONED:
-            return 'abandoned';
-        default:
-            return 'unknown';
-    }
-}
 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);
@@ -141,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/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/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.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,5 +1,5 @@
 import type { Sink, Source } from 'it-stream-types';
-import { Packet, TerminalKind, type CallData, type CallStart } from './rpcproto.pb.js';
+import { Packet, type CallData, type CallStart } from './rpcproto.pb.js';
 export declare class CommonRPC {
     readonly sink: Sink<Source<Packet>>;
     readonly source: AsyncIterable<Packet>;
@@ -9,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>;