starpc 0.25.1 → 0.25.3

package/dist/e2e/e2e.js

@@ -1,5 +1,5 @@
 import { pipe } from 'it-pipe';
-import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform } from '../srpc';
+import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, } from '../srpc';
 import { EchoerDefinition, EchoerServer, runClientTest } from '../echo';
 import { runAbortControllerTest, runRpcStreamTest } from '../echo/client-test';
 async function runRPC() {
@@ -13,8 +13,9 @@ async function runRPC() {
     const serverConn = new StreamConn(server, { direction: 'inbound' });
     // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
     const { port1: clientPort, port2: serverPort } = new MessageChannel();
-    const clientChannelStream = new ChannelStream('client', clientPort);
-    const serverChannelStream = new ChannelStream('server', serverPort);
+    const opts = { idleTimeoutMs: 250, keepAliveMs: 100 };
+    const clientChannelStream = new ChannelStream('client', clientPort, opts);
+    const serverChannelStream = new ChannelStream('server', serverPort, opts);
     // Pipe the client traffic via the client end of the MessageChannel.
     pipe(clientChannelStream, clientConn, combineUint8ArrayListTransform(), clientChannelStream)
         .catch((err) => clientConn.close(err))

package/dist/rpcstream/rpcstream.d.ts

@@ -5,7 +5,7 @@ import { OpenStreamFunc, PacketStream } from '../srpc/stream.js';
 export type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
 export declare function openRpcStream(componentId: string, caller: RpcStreamCaller, waitAck?: boolean): Promise<PacketStream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
-export type RpcStreamHandler = (stream: PacketStream) => void;
+export type RpcStreamHandler = (stream: PacketStream) => Promise<void>;
 export type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
 export declare function handleRpcStream(packetRx: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements PacketStream {

package/dist/rpcstream/rpcstream.js

@@ -86,7 +86,9 @@ export async function* handleRpcStream(packetRx, getter) {
     const packetTx = pushable({ objectMode: true });
     // start the handler
     const rpcStream = new RpcStream(packetTx, packetRx);
-    handler(rpcStream);
+    handler(rpcStream)
+        .catch((err) => packetTx.end(err))
+        .then(() => packetTx.end());
     // process packets
     for await (const packet of packetTx) {
         yield* [packet];

package/dist/srpc/channel.d.ts

@@ -3,7 +3,6 @@ export interface ChannelStreamMessage<T> {
     from: string;
     ack?: true;
     opened?: true;
-    alive?: true;
     closed?: true;
     error?: Error;
     data?: T;
@@ -14,6 +13,8 @@ export type ChannelPort = MessagePort | {
 };
 export interface ChannelStreamOpts {
     remoteOpen?: boolean;
+    keepAliveMs?: number;
+    idleTimeoutMs?: number;
 }
 export declare class ChannelStream<T = Uint8Array> implements Duplex<AsyncGenerator<T>, Source<T>, Promise<void>> {
     readonly channel: ChannelPort;
@@ -28,10 +29,14 @@ export declare class ChannelStream<T = Uint8Array> implements Duplex<AsyncGenera
     private remoteAck;
     readonly waitRemoteAck: Promise<void>;
     private _remoteAck?;
+    private keepAlive?;
+    private idleWatchdog?;
     get isAcked(): boolean;
     get isOpen(): boolean;
     constructor(localId: string, channel: ChannelPort, opts?: ChannelStreamOpts);
     private postMessage;
+    private idleElapsed;
+    private keepAliveElapsed;
     close(error?: Error): void;
     private onLocalOpened;
     private onRemoteAcked;

package/dist/srpc/channel.js

@@ -1,9 +1,12 @@
 import { pushable } from 'it-pushable';
+import { Watchdog } from './watchdog.js';
+import { ERR_STREAM_IDLE } from './errors.js';
 // ChannelStream implements a Stream over a BroadcastChannel duplex or MessagePort.
 //
 // NOTE: there is no way to tell if a BroadcastChannel or MessagePort is closed.
 // This implementation sends a "closed" message when close() is called.
 // However: if the remote is removed w/o closing cleanly, the stream will be left open!
+// Enable keepAliveMs and idleTimeoutMs to mitigate this issue with keep-alive messages.
 export class ChannelStream {
     // isAcked checks if the stream is acknowledged by the remote.
     get isAcked() {
@@ -15,12 +18,13 @@ export class ChannelStream {
     }
     // remoteOpen indicates that we know the remote has already opened the stream.
     constructor(localId, channel, opts) {
+        // initial state
         this.localId = localId;
         this.channel = channel;
-        this.sink = this._createSink();
         this.localOpen = false;
         this.remoteOpen = opts?.remoteOpen ?? false;
         this.remoteAck = this.remoteOpen;
+        // wire up the promises for remote ack and remote open
         if (this.remoteOpen) {
             this.waitRemoteOpen = Promise.resolve();
             this.waitRemoteAck = Promise.resolve();
@@ -49,9 +53,13 @@ export class ChannelStream {
             });
             this.waitRemoteAck.catch(() => { });
         }
+        // create the sink
+        this.sink = this._createSink();
+        // create the pushable source
         const source = pushable({ objectMode: true });
         this.source = source;
         this._source = source;
+        // wire up the message handlers
         const onMessage = this.onMessage.bind(this);
         if (channel instanceof MessagePort) {
             // MessagePort
@@ -62,6 +70,14 @@ export class ChannelStream {
             // BroadcastChannel
             channel.rx.onmessage = onMessage;
         }
+        // handle the keep alive or idle timeout opts
+        if (opts?.idleTimeoutMs != null) {
+            this.idleWatchdog = new Watchdog(opts.idleTimeoutMs, () => this.idleElapsed());
+        }
+        if (opts?.keepAliveMs != null) {
+            this.keepAlive = new Watchdog(opts.keepAliveMs, () => this.keepAliveElapsed());
+        }
+        // broadcast ack to start the stream
         this.postMessage({ ack: true });
     }
     // postMessage writes a message to the stream.
@@ -73,6 +89,23 @@ export class ChannelStream {
         else {
             this.channel.tx.postMessage(msg);
         }
+        if (!msg.closed) {
+            this.keepAlive?.feed();
+        }
+    }
+    // idleElapsed is called if the idle timeout was elapsed.
+    idleElapsed() {
+        if (this.idleWatchdog) {
+            delete this.idleWatchdog;
+            this.close(new Error(ERR_STREAM_IDLE));
+        }
+    }
+    // keepAliveElapsed is called if the keep alive timeout was elapsed.
+    keepAliveElapsed() {
+        if (this.keepAlive) {
+            // send a keep-alive message
+            this.postMessage({});
+        }
     }
     // close closes the broadcast channels.
     close(error) {
@@ -92,6 +125,15 @@ export class ChannelStream {
         if (!this.remoteAck && this._remoteAck) {
             this._remoteAck(error || new Error('closed'));
         }
+        if (this.idleWatchdog) {
+            this.idleWatchdog.clear();
+            delete this.idleWatchdog;
+        }
+        if (this.keepAlive) {
+            this.keepAlive.clear();
+            delete this.keepAlive;
+        }
+        this._source.end(error);
     }
     // onLocalOpened indicates the local side has opened the read stream.
     onLocalOpened() {
@@ -140,6 +182,7 @@ export class ChannelStream {
         if (!msg || msg.from === this.localId || !msg.from) {
             return;
         }
+        this.idleWatchdog?.feed();
         if (msg.ack || msg.opened) {
             this.onRemoteAcked();
         }

package/dist/srpc/client.js

@@ -85,8 +85,8 @@ export class Client {
             call.close(new Error(ERR_RPC_ABORT));
         });
         pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-            .then(() => call.close())
-            .catch((err) => call.close(err));
+            .catch((err) => call.close(err))
+            .then(() => call.close());
         await call.writeCallStart(data || undefined);
         return call;
     }

package/dist/srpc/errors.d.ts

@@ -1,3 +1,5 @@
 export declare const ERR_RPC_ABORT = "ERR_RPC_ABORT";
 export declare function isAbortError(err: unknown): boolean;
+export declare const ERR_STREAM_IDLE = "ERR_STREAM_IDLE";
+export declare function isStreamIdleError(err: unknown): boolean;
 export declare function castToError(err: any, defaultMsg?: string): Error;

package/dist/srpc/errors.js

@@ -8,6 +8,16 @@ export function isAbortError(err) {
     const message = err.message;
     return message === ERR_RPC_ABORT;
 }
+// ERR_STREAM_IDLE is returned if the stream idle timeout was exceeded.
+export const ERR_STREAM_IDLE = 'ERR_STREAM_IDLE';
+// isStreamIdleError checks if the error object is ERR_STREAM_IDLE.
+export function isStreamIdleError(err) {
+    if (typeof err !== 'object') {
+        return false;
+    }
+    const message = err.message;
+    return message === ERR_STREAM_IDLE;
+}
 // castToError casts an object to an Error.
 // if err is a string, uses it as the message.
 // if err is undefined, returns new Error(defaultMsg)

package/dist/srpc/index.d.ts

@@ -1,4 +1,4 @@
-export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { StreamConn, StreamConnParams, StreamHandler } from './conn.js';
@@ -8,7 +8,7 @@ export { Handler, InvokeFn, MethodMap, StaticHandler, createHandler, } from './h
 export { MethodProto, createInvokeFn } from './invoker.js';
 export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { Mux, StaticMux, LookupMethod, createMux } from './mux.js';
-export { ChannelStreamMessage, ChannelPort, ChannelStream, newBroadcastChannelStream, } from './channel.js';
+export { ChannelStreamMessage, ChannelPort, ChannelStream, ChannelStreamOpts, newBroadcastChannelStream, } from './channel.js';
 export { BroadcastChannelDuplex, BroadcastChannelConn, newBroadcastChannelDuplex, } from './broadcast-channel.js';
 export { MessagePortDuplex, MessagePortConn, newMessagePortDuplex, } from './message-port.js';
 export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
@@ -17,3 +17,4 @@ export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable, buildPushableSink } from './pushable.js';
+export { Watchdog } from './watchdog.js';

package/dist/srpc/index.js

@@ -1,4 +1,4 @@
-export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
@@ -16,3 +16,4 @@ export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable, buildPushableSink } from './pushable.js';
+export { Watchdog } from './watchdog.js';

package/dist/srpc/server.js

@@ -9,7 +9,12 @@ export class Server {
     // rpcStreamHandler implements the RpcStreamHandler interface.
     // uses handlePacketDuplex (expects 1 buf = 1 Packet)
     get rpcStreamHandler() {
-        return this.handlePacketStream.bind(this);
+        return async (stream) => {
+            const rpc = this.startRpc();
+            return pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+                .catch((err) => rpc.close(err))
+                .then(() => rpc.close());
+        };
     }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.

package/dist/srpc/watchdog.d.ts

@@ -0,0 +1,35 @@
+export declare class Watchdog {
+    private timeoutDuration;
+    private expiredCallback;
+    private timerId;
+    private lastFeedTimestamp;
+    /**
+     * Constructs a Watchdog instance.
+     * The Watchdog will not start ticking until feed() is called.
+     * @param timeoutDuration The duration in milliseconds after which the watchdog should expire if not fed.
+     * @param expiredCallback The callback function to be called when the watchdog expires.
+     */
+    constructor(timeoutDuration: number, expiredCallback: () => void);
+    /**
+     * Feeds the watchdog, preventing it from expiring.
+     * This resets the timeout and reschedules the next tick.
+     */
+    feed(): void;
+    /**
+     * Clears the current timeout, effectively stopping the watchdog.
+     * This prevents the expired callback from being called until the watchdog is fed again.
+     */
+    clear(): void;
+    /**
+     * Schedules the next tick of the watchdog.
+     * This method calculates the delay for the next tick based on the last feed time
+     * and schedules a call to tickWatchdog after that delay.
+     */
+    private scheduleTickWatchdog;
+    /**
+     * Handler for the watchdog tick.
+     * Checks if the time since the last feed is greater than the timeout duration.
+     * If so, it calls the expired callback. Otherwise, it reschedules the tick.
+     */
+    private tickWatchdog;
+}

package/dist/srpc/watchdog.js

@@ -0,0 +1,64 @@
+// Watchdog must be fed every timeoutDuration or it will call the expired callback.
+export class Watchdog {
+    /**
+     * Constructs a Watchdog instance.
+     * The Watchdog will not start ticking until feed() is called.
+     * @param timeoutDuration The duration in milliseconds after which the watchdog should expire if not fed.
+     * @param expiredCallback The callback function to be called when the watchdog expires.
+     */
+    constructor(timeoutDuration, expiredCallback) {
+        this.timerId = null;
+        this.lastFeedTimestamp = null;
+        this.timeoutDuration = timeoutDuration;
+        this.expiredCallback = expiredCallback;
+    }
+    /**
+     * Feeds the watchdog, preventing it from expiring.
+     * This resets the timeout and reschedules the next tick.
+     */
+    feed() {
+        this.lastFeedTimestamp = Date.now();
+        this.scheduleTickWatchdog(this.timeoutDuration);
+    }
+    /**
+     * Clears the current timeout, effectively stopping the watchdog.
+     * This prevents the expired callback from being called until the watchdog is fed again.
+     */
+    clear() {
+        if (this.timerId != null) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+        this.lastFeedTimestamp = null;
+    }
+    /**
+     * Schedules the next tick of the watchdog.
+     * This method calculates the delay for the next tick based on the last feed time
+     * and schedules a call to tickWatchdog after that delay.
+     */
+    scheduleTickWatchdog(delay) {
+        if (this.timerId != null) {
+            clearTimeout(this.timerId);
+        }
+        this.timerId = setTimeout(() => this.tickWatchdog(), delay);
+    }
+    /**
+     * Handler for the watchdog tick.
+     * Checks if the time since the last feed is greater than the timeout duration.
+     * If so, it calls the expired callback. Otherwise, it reschedules the tick.
+     */
+    tickWatchdog() {
+        this.timerId = null;
+        if (this.lastFeedTimestamp == null) {
+            this.expiredCallback();
+            return;
+        }
+        const elapsedSinceLastFeed = Date.now() - this.lastFeedTimestamp;
+        if (elapsedSinceLastFeed >= this.timeoutDuration) {
+            this.expiredCallback();
+        }
+        else {
+            this.scheduleTickWatchdog(this.timeoutDuration - elapsedSinceLastFeed);
+        }
+    }
+}

package/dist/srpc/websocket.js

@@ -10,7 +10,9 @@ export class WebSocketConn extends StreamConn {
         const socketDuplex = duplex(socket);
         pipe(socketDuplex, this, 
         // it-ws only supports sending Uint8Array.
-        combineUint8ArrayListTransform(), socketDuplex);
+        combineUint8ArrayListTransform(), socketDuplex)
+            .catch((err) => this.close(err))
+            .then(() => this.close());
     }
     // getSocket returns the websocket.
     getSocket() {

package/e2e/e2e.ts

@@ -1,5 +1,14 @@
 import { pipe } from 'it-pipe'
-import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform } from '../srpc'
+import {
+  createHandler,
+  createMux,
+  Server,
+  Client,
+  StreamConn,
+  ChannelStream,
+  combineUint8ArrayListTransform,
+  ChannelStreamOpts,
+} from '../srpc'
 import { EchoerDefinition, EchoerServer, runClientTest } from '../echo'
 import { runAbortControllerTest, runRpcStreamTest } from '../echo/client-test'
 
@@ -15,17 +24,28 @@ async function runRPC() {
   const serverConn = new StreamConn(server, { direction: 'inbound' })
 
   // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
-  const {port1: clientPort, port2: serverPort} = new MessageChannel()
-  const clientChannelStream = new ChannelStream('client', clientPort)
-  const serverChannelStream = new ChannelStream('server', serverPort)
+  const { port1: clientPort, port2: serverPort } = new MessageChannel()
+  const opts: ChannelStreamOpts = { idleTimeoutMs: 250, keepAliveMs: 100 }
+  const clientChannelStream = new ChannelStream('client', clientPort, opts)
+  const serverChannelStream = new ChannelStream('server', serverPort, opts)
 
   // Pipe the client traffic via the client end of the MessageChannel.
-  pipe(clientChannelStream, clientConn, combineUint8ArrayListTransform(), clientChannelStream)
+  pipe(
+    clientChannelStream,
+    clientConn,
+    combineUint8ArrayListTransform(),
+    clientChannelStream,
+  )
     .catch((err: Error) => clientConn.close(err))
     .then(() => clientConn.close())
 
   // Pipe the server traffic via the server end of the MessageChannel.
-  pipe(serverChannelStream, serverConn, combineUint8ArrayListTransform(), serverChannelStream)
+  pipe(
+    serverChannelStream,
+    serverConn,
+    combineUint8ArrayListTransform(),
+    serverChannelStream,
+  )
     .catch((err: Error) => serverConn.close(err))
     .then(() => serverConn.close())
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/channel.ts

@@ -1,5 +1,7 @@
 import type { Sink, Source, Duplex } from 'it-stream-types'
 import { pushable, Pushable } from 'it-pushable'
+import { Watchdog } from './watchdog.js'
+import { ERR_STREAM_IDLE } from './errors.js'
 
 // ChannelStreamMessage is a message sent over the stream.
 export interface ChannelStreamMessage<T> {
@@ -9,9 +11,6 @@ export interface ChannelStreamMessage<T> {
   ack?: true
   // opened indicates the remote has opened the stream.
   opened?: true
-  // alive indicates this is a keep-alive packet.
-  // not set unless keep-alives are enabled.
-  alive?: true
   // closed indicates the stream is closed.
   closed?: true
   // error indicates the stream has an error.
@@ -30,6 +29,12 @@ export interface ChannelStreamOpts {
   // remoteOpen indicates that the remote already knows the channel is open.
   // this skips sending and waiting for the open+ack messages.
   remoteOpen?: boolean
+  // keepAliveMs is the maximum time between sending before we send a keep-alive.
+  // if idleTimeoutMs is set on the remote end, this should be less by some margin.
+  keepAliveMs?: number
+  // idleTimeoutMs is the maximum time between receiving before we close the stream.
+  // if keepAliveMs is set on the remote end, this should be more by some margin.
+  idleTimeoutMs?: number
 }
 
 // ChannelStream implements a Stream over a BroadcastChannel duplex or MessagePort.
@@ -37,6 +42,7 @@ export interface ChannelStreamOpts {
 // NOTE: there is no way to tell if a BroadcastChannel or MessagePort is closed.
 // This implementation sends a "closed" message when close() is called.
 // However: if the remote is removed w/o closing cleanly, the stream will be left open!
+// Enable keepAliveMs and idleTimeoutMs to mitigate this issue with keep-alive messages.
 export class ChannelStream<T = Uint8Array>
   implements Duplex<AsyncGenerator<T>, Source<T>, Promise<void>>
 {
@@ -67,6 +73,10 @@ export class ChannelStream<T = Uint8Array>
   public readonly waitRemoteAck: Promise<void>
   // _remoteAck fulfills the waitRemoteAck promise.
   private _remoteAck?: (err?: Error) => void
+  // keepAliveWatchdog is the transmission timeout watchdog.
+  private keepAlive?: Watchdog
+  // idleWatchdog is the receive timeout watchdog.
+  private idleWatchdog?: Watchdog
 
   // isAcked checks if the stream is acknowledged by the remote.
   public get isAcked() {
@@ -80,13 +90,14 @@ export class ChannelStream<T = Uint8Array>
 
   // remoteOpen indicates that we know the remote has already opened the stream.
   constructor(localId: string, channel: ChannelPort, opts?: ChannelStreamOpts) {
+    // initial state
     this.localId = localId
     this.channel = channel
-    this.sink = this._createSink()
-
     this.localOpen = false
     this.remoteOpen = opts?.remoteOpen ?? false
     this.remoteAck = this.remoteOpen
+
+    // wire up the promises for remote ack and remote open
     if (this.remoteOpen) {
       this.waitRemoteOpen = Promise.resolve()
       this.waitRemoteAck = Promise.resolve()
@@ -113,10 +124,15 @@ export class ChannelStream<T = Uint8Array>
       this.waitRemoteAck.catch(() => {})
     }
 
+    // create the sink
+    this.sink = this._createSink()
+
+    // create the pushable source
     const source: Pushable<T> = pushable({ objectMode: true })
     this.source = source
     this._source = source
 
+    // wire up the message handlers
     const onMessage = this.onMessage.bind(this)
     if (channel instanceof MessagePort) {
       // MessagePort
@@ -126,6 +142,20 @@ export class ChannelStream<T = Uint8Array>
       // BroadcastChannel
       channel.rx.onmessage = onMessage
     }
+
+    // handle the keep alive or idle timeout opts
+    if (opts?.idleTimeoutMs != null) {
+      this.idleWatchdog = new Watchdog(opts.idleTimeoutMs, () =>
+        this.idleElapsed(),
+      )
+    }
+    if (opts?.keepAliveMs != null) {
+      this.keepAlive = new Watchdog(opts.keepAliveMs, () =>
+        this.keepAliveElapsed(),
+      )
+    }
+
+    // broadcast ack to start the stream
     this.postMessage({ ack: true })
   }
 
@@ -137,6 +167,25 @@ export class ChannelStream<T = Uint8Array>
     } else {
       this.channel.tx.postMessage(msg)
     }
+    if (!msg.closed) {
+      this.keepAlive?.feed()
+    }
+  }
+
+  // idleElapsed is called if the idle timeout was elapsed.
+  private idleElapsed() {
+    if (this.idleWatchdog) {
+      delete this.idleWatchdog
+      this.close(new Error(ERR_STREAM_IDLE))
+    }
+  }
+
+  // keepAliveElapsed is called if the keep alive timeout was elapsed.
+  private keepAliveElapsed() {
+    if (this.keepAlive) {
+      // send a keep-alive message
+      this.postMessage({})
+    }
   }
 
   // close closes the broadcast channels.
@@ -156,6 +205,15 @@ export class ChannelStream<T = Uint8Array>
     if (!this.remoteAck && this._remoteAck) {
       this._remoteAck(error || new Error('closed'))
     }
+    if (this.idleWatchdog) {
+      this.idleWatchdog.clear()
+      delete this.idleWatchdog
+    }
+    if (this.keepAlive) {
+      this.keepAlive.clear()
+      delete this.keepAlive
+    }
+    this._source.end(error)
   }
 
   // onLocalOpened indicates the local side has opened the read stream.
@@ -209,6 +267,7 @@ export class ChannelStream<T = Uint8Array>
     if (!msg || msg.from === this.localId || !msg.from) {
       return
     }
+    this.idleWatchdog?.feed()
     if (msg.ack || msg.opened) {
       this.onRemoteAcked()
     }

package/srpc/client.ts

@@ -122,8 +122,8 @@ export class Client implements TsProtoRpc {
       call.close(new Error(ERR_RPC_ABORT))
     })
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-      .then(() => call.close())
       .catch((err) => call.close(err))
+      .then(() => call.close())
     await call.writeCallStart(data || undefined)
     return call
   }

package/srpc/errors.ts

@@ -10,6 +10,18 @@ export function isAbortError(err: unknown): boolean {
   return message === ERR_RPC_ABORT
 }
 
+// ERR_STREAM_IDLE is returned if the stream idle timeout was exceeded.
+export const ERR_STREAM_IDLE = 'ERR_STREAM_IDLE'
+
+// isStreamIdleError checks if the error object is ERR_STREAM_IDLE.
+export function isStreamIdleError(err: unknown): boolean {
+  if (typeof err !== 'object') {
+    return false
+  }
+  const message = (err as Error).message
+  return message === ERR_STREAM_IDLE
+}
+
 // castToError casts an object to an Error.
 // if err is a string, uses it as the message.
 // if err is undefined, returns new Error(defaultMsg)

package/srpc/index.ts

@@ -1,4 +1,10 @@
-export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js'
+export {
+  ERR_RPC_ABORT,
+  isAbortError,
+  ERR_STREAM_IDLE,
+  isStreamIdleError,
+  castToError,
+} from './errors.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
 export { StreamConn, StreamConnParams, StreamHandler } from './conn.js'
@@ -23,6 +29,7 @@ export {
   ChannelStreamMessage,
   ChannelPort,
   ChannelStream,
+  ChannelStreamOpts,
   newBroadcastChannelStream,
 } from './channel.js'
 export {
@@ -61,3 +68,4 @@ export { combineUint8ArrayListTransform } from './array-list.js'
 export { ValueCtr } from './value-ctr.js'
 export { OpenStreamCtr } from './open-stream-ctr.js'
 export { writeToPushable, buildPushableSink } from './pushable.js'
+export { Watchdog } from './watchdog.js'

package/srpc/server.ts

@@ -19,7 +19,12 @@ export class Server implements StreamHandler {
   // rpcStreamHandler implements the RpcStreamHandler interface.
   // uses handlePacketDuplex (expects 1 buf = 1 Packet)
   public get rpcStreamHandler(): RpcStreamHandler {
-    return this.handlePacketStream.bind(this)
+    return async (stream: PacketStream) => {
+      const rpc = this.startRpc()
+      return pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+        .catch((err: Error) => rpc.close(err))
+        .then(() => rpc.close())
+    }
   }
 
   // startRpc starts a new server-side RPC.

package/srpc/watchdog.ts

@@ -0,0 +1,70 @@
+// Watchdog must be fed every timeoutDuration or it will call the expired callback.
+export class Watchdog {
+  private timeoutDuration: number
+  private expiredCallback: () => void
+  private timerId: NodeJS.Timeout | null = null
+  private lastFeedTimestamp: number | null = null
+
+  /**
+   * Constructs a Watchdog instance.
+   * The Watchdog will not start ticking until feed() is called.
+   * @param timeoutDuration The duration in milliseconds after which the watchdog should expire if not fed.
+   * @param expiredCallback The callback function to be called when the watchdog expires.
+   */
+  constructor(timeoutDuration: number, expiredCallback: () => void) {
+    this.timeoutDuration = timeoutDuration
+    this.expiredCallback = expiredCallback
+  }
+
+  /**
+   * Feeds the watchdog, preventing it from expiring.
+   * This resets the timeout and reschedules the next tick.
+   */
+  public feed(): void {
+    this.lastFeedTimestamp = Date.now()
+    this.scheduleTickWatchdog(this.timeoutDuration)
+  }
+
+  /**
+   * Clears the current timeout, effectively stopping the watchdog.
+   * This prevents the expired callback from being called until the watchdog is fed again.
+   */
+  public clear(): void {
+    if (this.timerId != null) {
+      clearTimeout(this.timerId)
+      this.timerId = null
+    }
+    this.lastFeedTimestamp = null
+  }
+
+  /**
+   * Schedules the next tick of the watchdog.
+   * This method calculates the delay for the next tick based on the last feed time
+   * and schedules a call to tickWatchdog after that delay.
+   */
+  private scheduleTickWatchdog(delay: number): void {
+    if (this.timerId != null) {
+      clearTimeout(this.timerId)
+    }
+    this.timerId = setTimeout(() => this.tickWatchdog(), delay)
+  }
+
+  /**
+   * Handler for the watchdog tick.
+   * Checks if the time since the last feed is greater than the timeout duration.
+   * If so, it calls the expired callback. Otherwise, it reschedules the tick.
+   */
+  private tickWatchdog(): void {
+    this.timerId = null
+    if (this.lastFeedTimestamp == null) {
+      this.expiredCallback()
+      return
+    }
+    const elapsedSinceLastFeed = Date.now() - this.lastFeedTimestamp
+    if (elapsedSinceLastFeed >= this.timeoutDuration) {
+      this.expiredCallback()
+    } else {
+      this.scheduleTickWatchdog(this.timeoutDuration - elapsedSinceLastFeed)
+    }
+  }
+}

package/srpc/websocket.ts

@@ -24,6 +24,8 @@ export class WebSocketConn extends StreamConn {
       combineUint8ArrayListTransform(),
       socketDuplex,
     )
+      .catch((err) => this.close(err))
+      .then(() => this.close())
   }
 
   // getSocket returns the websocket.