starpc 0.50.0 → 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, 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/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>;

package/dist/srpc/common-rpc.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { Packet, TerminalKind, } from './rpcproto.pb.js';
+import { Packet } from './rpcproto.pb.js';
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js';
 const maxBufferedOutgoingPackets = 1;
 // CommonRPC is common logic between server and client RPCs.
@@ -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 === TerminalKind.CLOSED &&
-                        this.remoteSourceClosed &&
-                        !this.closed) {
-                        await this.close();
-                    }
-                    return terminal;
-                }
-                if (ownerAborted) {
-                    return TerminalKind.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);
@@ -221,20 +170,16 @@ export class CommonRPC {
         if (remoteError) {
             this.remoteError ??= remoteError;
             this.invocationController.abort();
-            this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST);
         }
         if (packet.complete && !remoteError) {
-            this.remoteCompleted = true;
-            this.recordRemoteTerminal(TerminalKind.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(TerminalKind.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 ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED);
         this.invocationController.abort();
         // note: this does nothing if _source is already ended.
         if (err && err.message) {
@@ -272,8 +216,6 @@ export class CommonRPC {
                         await this.handlePacket(msg);
                     }
                 }
-                this.remoteSourceClosed = true;
-                this.recordRemoteTerminal(TerminalKind.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 { TerminalKind } from './rpcproto.pb.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export type { StreamConnParams, StreamHandler } from './conn.js';

package/dist/srpc/index.js

@@ -1,8 +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 { TerminalKind } from './rpcproto.pb.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/rpcproto.pb.d.ts

@@ -1,49 +1,5 @@
 import type { MessageType } from '@aptre/protobuf-es-lite/message';
 export declare const protobufPackage = "srpc";
-/**
- * TerminalKind is the terminal state of a held unary invocation.
- *
- * @generated from enum srpc.TerminalKind
- */
-export declare enum TerminalKind {
-    /**
-     * TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
-     *
-     * @generated from enum value: TERMINAL_KIND_UNSPECIFIED = 0;
-     */
-    UNSPECIFIED = 0,
-    /**
-     * TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_COMMITTED = 1;
-     */
-    COMMITTED = 1,
-    /**
-     * TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
-     *
-     * @generated from enum value: TERMINAL_KIND_CANCELED = 2;
-     */
-    CANCELED = 2,
-    /**
-     * TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
-     *
-     * @generated from enum value: TERMINAL_KIND_TRANSPORT_LOST = 3;
-     */
-    TRANSPORT_LOST = 3,
-    /**
-     * TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_CLOSED = 4;
-     */
-    CLOSED = 4,
-    /**
-     * TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
-     *
-     * @generated from enum value: TERMINAL_KIND_ABANDONED = 5;
-     */
-    ABANDONED = 5
-}
-export declare const TerminalKind_Enum: import("@aptre/protobuf-es-lite/enum").EnumType;
 /**
  * CallStart requests starting a new RPC call.
  *

package/dist/srpc/rpcproto.pb.js

@@ -1,62 +1,9 @@
 // @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
-import { createEnumType } from '@aptre/protobuf-es-lite/enum';
 import { createMessageType } from '@aptre/protobuf-es-lite/message';
 import { ScalarType } from '@aptre/protobuf-es-lite/scalar';
 export const protobufPackage = 'srpc';
-/**
- * TerminalKind is the terminal state of a held unary invocation.
- *
- * @generated from enum srpc.TerminalKind
- */
-export var TerminalKind;
-(function (TerminalKind) {
-    /**
-     * TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
-     *
-     * @generated from enum value: TERMINAL_KIND_UNSPECIFIED = 0;
-     */
-    TerminalKind[TerminalKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    /**
-     * TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_COMMITTED = 1;
-     */
-    TerminalKind[TerminalKind["COMMITTED"] = 1] = "COMMITTED";
-    /**
-     * TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
-     *
-     * @generated from enum value: TERMINAL_KIND_CANCELED = 2;
-     */
-    TerminalKind[TerminalKind["CANCELED"] = 2] = "CANCELED";
-    /**
-     * TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
-     *
-     * @generated from enum value: TERMINAL_KIND_TRANSPORT_LOST = 3;
-     */
-    TerminalKind[TerminalKind["TRANSPORT_LOST"] = 3] = "TRANSPORT_LOST";
-    /**
-     * TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_CLOSED = 4;
-     */
-    TerminalKind[TerminalKind["CLOSED"] = 4] = "CLOSED";
-    /**
-     * TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
-     *
-     * @generated from enum value: TERMINAL_KIND_ABANDONED = 5;
-     */
-    TerminalKind[TerminalKind["ABANDONED"] = 5] = "ABANDONED";
-})(TerminalKind || (TerminalKind = {}));
-export const TerminalKind_Enum = /* @__PURE__ */ createEnumType('srpc.TerminalKind', [
-    [0, 'TERMINAL_KIND_UNSPECIFIED'],
-    [1, 'TERMINAL_KIND_COMMITTED'],
-    [2, 'TERMINAL_KIND_CANCELED'],
-    [3, 'TERMINAL_KIND_TRANSPORT_LOST'],
-    [4, 'TERMINAL_KIND_CLOSED'],
-    [5, 'TERMINAL_KIND_ABANDONED'],
-]);
 export const CallStart = 
 /* @__PURE__ */ createMessageType({
     typeName: 'srpc.CallStart',

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);