starpc 0.49.11 → 0.49.13

package/dist/srpc/channel.d.ts

@@ -4,6 +4,7 @@ export interface ChannelStreamMessage<T> {
     ack?: true;
     opened?: true;
     closed?: true;
+    teardown?: true;
     error?: Error;
     data?: T;
 }
@@ -32,6 +33,8 @@ export declare class ChannelStream<T = Uint8Array> implements Duplex<AsyncGenera
     private keepAlive?;
     private idleWatchdog?;
     private closed;
+    private localWriteClosed;
+    private remoteWriteClosed;
     get isAcked(): boolean;
     get isOpen(): boolean;
     get isIdlePaused(): boolean;
@@ -40,6 +43,9 @@ export declare class ChannelStream<T = Uint8Array> implements Duplex<AsyncGenera
     private idleElapsed;
     private keepAliveElapsed;
     private finish;
+    private finishIfBothDirectionsClosed;
+    private clearKeepAlive;
+    private clearIdleWatchdog;
     close(error?: Error): void;
     pauseIdle(): void;
     resumeIdle(): void;

package/dist/srpc/channel.js

@@ -39,6 +39,10 @@ export class ChannelStream {
     idleWatchdog;
     // closed indicates the local channel has been torn down.
     closed = false;
+    // localWriteClosed indicates the local sink finished normally.
+    localWriteClosed = false;
+    // remoteWriteClosed indicates the remote sink finished normally.
+    remoteWriteClosed = false;
     // isAcked checks if the stream is acknowledged by the remote.
     get isAcked() {
         return this.remoteAck ?? false;
@@ -151,13 +155,15 @@ export class ChannelStream {
         }
         if (notifyRemote) {
             try {
-                this.postMessage({ closed: true, error });
+                this.postMessage({ closed: true, error, teardown: true });
             }
             catch {
                 // Ignore close races while tearing down the local channel.
             }
         }
         this.closed = true;
+        this.localWriteClosed = true;
+        this.remoteWriteClosed = true;
         // close channels
         if (this.channel instanceof MessagePort) {
             this.channel.onmessage = null;
@@ -186,6 +192,26 @@ export class ChannelStream {
         }
         this._source.end(error);
     }
+    // finishIfBothDirectionsClosed tears down after a clean bidirectional EOF.
+    finishIfBothDirectionsClosed() {
+        if (this.localWriteClosed && this.remoteWriteClosed) {
+            this.finish(undefined, false);
+        }
+    }
+    // clearKeepAlive stops local write keep-alives after the write side closes.
+    clearKeepAlive() {
+        if (this.keepAlive) {
+            this.keepAlive.clear();
+            delete this.keepAlive;
+        }
+    }
+    // clearIdleWatchdog stops receive watchdogs after the peer write side closes.
+    clearIdleWatchdog() {
+        if (this.idleWatchdog) {
+            this.idleWatchdog.clear();
+            delete this.idleWatchdog;
+        }
+    }
     // close closes the broadcast channels.
     close(error) {
         this.finish(error, true);
@@ -235,10 +261,13 @@ export class ChannelStream {
                 for await (const msg of source) {
                     this.postMessage({ data: msg });
                 }
+                this.localWriteClosed = true;
+                this.clearKeepAlive();
                 this.postMessage({ closed: true });
+                this.finishIfBothDirectionsClosed();
             }
             catch (error) {
-                this.postMessage({ closed: true, error: error });
+                this.finish(error instanceof Error ? error : new Error(String(error)), true);
             }
         };
     }
@@ -254,16 +283,19 @@ export class ChannelStream {
         if (msg.opened) {
             this.onRemoteOpened();
         }
-        const { data, closed, error: err } = msg;
-        if (data) {
+        const { data, closed, error: err, teardown } = msg;
+        if (data !== undefined) {
             this._source.push(data);
         }
-        if (err) {
+        if (err || teardown) {
             this.finish(err, false);
             return;
         }
         if (closed) {
-            this.finish(undefined, false);
+            this.remoteWriteClosed = true;
+            this.clearIdleWatchdog();
+            this._source.end();
+            this.finishIfBothDirectionsClosed();
         }
     }
 }

package/dist/srpc/channel.test.d.ts

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

package/dist/srpc/channel.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import { pushable } from 'it-pushable';
+import { ChannelStream } from './channel.js';
+describe('ChannelStream', () => {
+    it('keeps MessagePort peer writes open after local source completes normally', async () => {
+        const { port1, port2 } = new MessageChannel();
+        const client = new ChannelStream('client', port1);
+        const server = new ChannelStream('server', port2);
+        await expectPeerWriteAfterLocalSourceCompletes(client, server);
+    });
+    it('keeps BroadcastChannel peer writes open after local source completes normally', async () => {
+        const channelName = `channel-stream-${Date.now()}-${Math.random()}`;
+        const clientToServer = `${channelName}-client-to-server`;
+        const serverToClient = `${channelName}-server-to-client`;
+        const client = new ChannelStream('client', {
+            tx: new BroadcastChannel(clientToServer),
+            rx: new BroadcastChannel(serverToClient),
+        });
+        const server = new ChannelStream('server', {
+            tx: new BroadcastChannel(serverToClient),
+            rx: new BroadcastChannel(clientToServer),
+        });
+        await expectPeerWriteAfterLocalSourceCompletes(client, server);
+    });
+    it('propagates explicit close errors as full teardown', async () => {
+        const { port1, port2 } = new MessageChannel();
+        const active = new ChannelStream('active', port1);
+        const passive = new ChannelStream('passive', port2);
+        const next = passive.source[Symbol.asyncIterator]().next();
+        try {
+            active.close(new Error('boom'));
+            await expect(next).rejects.toThrow('boom');
+            expect(passive.closed).toBe(true);
+            expect(port2.onmessage).toBe(null);
+        }
+        finally {
+            active.close();
+            passive.close();
+        }
+    });
+});
+async function expectPeerWriteAfterLocalSourceCompletes(client, server) {
+    const clientWrites = pushable({ objectMode: true });
+    const serverWrites = pushable({ objectMode: true });
+    const clientSink = client.sink(clientWrites);
+    const serverSink = server.sink(serverWrites);
+    const clientReads = client.source[Symbol.asyncIterator]();
+    const serverReads = server.source[Symbol.asyncIterator]();
+    try {
+        const request = new Uint8Array([1, 2, 3]);
+        clientWrites.push(request);
+        await expect(readNext(serverReads)).resolves.toEqual({
+            done: false,
+            value: request,
+        });
+        clientWrites.end();
+        await expect(readNext(serverReads)).resolves.toEqual({
+            done: true,
+            value: undefined,
+        });
+        const response = new Uint8Array([4, 5, 6]);
+        serverWrites.push(response);
+        await expect(readNext(clientReads)).resolves.toEqual({
+            done: false,
+            value: response,
+        });
+        serverWrites.end();
+        await expect(clientSink).resolves.toBeUndefined();
+        await expect(serverSink).resolves.toBeUndefined();
+        await expect(readNext(clientReads)).resolves.toEqual({
+            done: true,
+            value: undefined,
+        });
+        expect(client.closed).toBe(true);
+        expect(server.closed).toBe(true);
+    }
+    finally {
+        client.close();
+        server.close();
+    }
+}
+function readNext(source) {
+    return Promise.race([
+        source.next(),
+        new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('timed out waiting for stream data')), 100);
+        }),
+    ]);
+}

package/dist/srpc/server.test.js

@@ -1,6 +1,6 @@
 import { describe, it, beforeEach, expect, vi } from 'vitest';
 import { pipe } from 'it-pipe';
-import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, } from '../srpc/index.js';
+import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, Packet, } from '../srpc/index.js';
 import { EchoerDefinition, EchoerServer, EchoerServiceName, runClientTest, } from '../echo/index.js';
 import { runAbortControllerTest, runRpcStreamTest, } from '../echo/client-test.js';
 describe('srpc server', () => {
@@ -39,6 +39,61 @@ describe('srpc server', () => {
     it('should pass rpc stream tests', async () => {
         await runRpcStreamTest(client);
     });
+    it('keeps detached server-streaming responses open after request source completes', async () => {
+        const mux = createMux();
+        const response = new TextEncoder().encode('delayed init');
+        mux.registerLookupMethod(async (service, method) => {
+            if (service !== 'test.ResourceService' || method !== 'ResourceClient') {
+                return null;
+            }
+            return async (_dataSource, dataSink) => {
+                await dataSink((async function* () {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                    yield response;
+                })());
+            };
+        });
+        const server = new Server(mux.lookupMethod);
+        const firstResponse = new Promise((resolve, reject) => {
+            server.handlePacketStream({
+                source: (async function* () {
+                    yield Packet.toBinary({
+                        body: {
+                            case: 'callStart',
+                            value: {
+                                rpcService: 'test.ResourceService',
+                                rpcMethod: 'ResourceClient',
+                                data: new Uint8Array(0),
+                                dataIsZero: true,
+                            },
+                        },
+                    });
+                })(),
+                sink: async (source) => {
+                    try {
+                        for await (const packetData of source) {
+                            const packet = Packet.fromBinary(packetData);
+                            if (packet.body?.case === 'callData') {
+                                resolve(packet);
+                                return;
+                            }
+                        }
+                        reject(new Error('server response stream ended before call data'));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                },
+            });
+        });
+        const packet = await promiseWithTimeout(firstResponse, 'detached server-streaming response');
+        const body = packet.body;
+        expect(body?.case).toBe('callData');
+        if (body?.case !== 'callData' || !body.value?.data) {
+            throw new Error('expected callData packet');
+        }
+        expect([...body.value.data]).toEqual([...response]);
+    });
     it('removes abort listeners after a request completes', async () => {
         const controller = new AbortController();
         const removeEventListener = vi.spyOn(controller.signal, 'removeEventListener');
@@ -60,3 +115,11 @@ describe('srpc server', () => {
         expect(port2.onmessage).toBe(null);
     });
 });
+function promiseWithTimeout(promise, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), 100);
+        }),
+    ]);
+}

package/dist/srpc/stream.js

@@ -2,15 +2,19 @@ import { pipe } from 'it-pipe';
 import { combineUint8ArrayListTransform } from './array-list.js';
 import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
 // streamToPacketStream converts a Stream into a PacketStream using length-prefix framing.
-//
-// The stream is closed when the source writing to the sink ends.
 export function streamToPacketStream(stream) {
     return {
         source: pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform()),
         sink: async (source) => {
-            await pipe(source, prependLengthPrefixTransform(), stream)
-                .catch((err) => stream.close(err))
-                .then(() => stream.close());
+            try {
+                await pipe(source, prependLengthPrefixTransform(), stream);
+                await stream.closeWrite();
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                stream.abort(error);
+                throw error;
+            }
         },
     };
 }

package/dist/srpc/stream.test.d.ts

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

package/dist/srpc/stream.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest';
+import { pipe } from 'it-pipe';
+import { ChannelStream, combineUint8ArrayListTransform, StreamConn, } from '../srpc/index.js';
+describe('StreamConn packet stream', () => {
+    it('keeps yamux peer writes open after local packet source completes normally', async () => {
+        const request = new TextEncoder().encode('request');
+        const response = new TextEncoder().encode('response');
+        let serverError;
+        const serverDone = new Promise((resolve, reject) => {
+            const { clientConn, cleanup } = connectStreamConns({
+                handlePacketStream(stream) {
+                    void (async () => {
+                        const packets = stream.source[Symbol.asyncIterator]();
+                        const first = await nextWithTimeout(packets, 'server request packet');
+                        expect(first.done).toBe(false);
+                        expect([...first.value]).toEqual([...request]);
+                        const done = await nextWithTimeout(packets, 'server request eof');
+                        expect(done.done).toBe(true);
+                        await stream.sink((async function* () {
+                            yield response;
+                        })());
+                    })()
+                        .then(resolve)
+                        .catch((err) => {
+                        serverError = err;
+                        reject(err);
+                    });
+                },
+            });
+            void (async () => {
+                try {
+                    const clientStream = await clientConn.openStream();
+                    await clientStream.sink((async function* () {
+                        yield request;
+                    })());
+                    const packets = clientStream.source[Symbol.asyncIterator]();
+                    const first = await nextWithTimeout(packets, 'client response packet');
+                    expect(first.done).toBe(false);
+                    expect([...first.value]).toEqual([...response]);
+                    const done = await nextWithTimeout(packets, 'client response eof');
+                    expect(done.done).toBe(true);
+                }
+                finally {
+                    cleanup();
+                }
+            })().catch(reject);
+        });
+        await serverDone;
+        expect(serverError).toBeUndefined();
+    });
+    it('aborts the yamux stream when the packet source errors', async () => {
+        const request = new TextEncoder().encode('request');
+        const sourceError = new Error('source failed');
+        let resolveReset = () => { };
+        const resetSeen = new Promise((resolve) => {
+            resolveReset = resolve;
+        });
+        const { clientConn, cleanup } = connectStreamConns({
+            handlePacketStream(stream) {
+                void (async () => {
+                    try {
+                        for await (const _packet of stream.source) {
+                            // Drain until the reset arrives.
+                        }
+                        resolveReset(new Error('server stream ended without reset'));
+                    }
+                    catch (err) {
+                        resolveReset(err);
+                    }
+                })();
+            },
+        });
+        try {
+            const clientStream = await clientConn.openStream();
+            await expect(clientStream.sink((async function* () {
+                yield request;
+                throw sourceError;
+            })())).rejects.toThrow('source failed');
+            const resetErr = await promiseWithTimeout(resetSeen, 'server reset');
+            expect(resetErr).toBeInstanceOf(Error);
+            expect(resetErr.message).toBe('stream reset');
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+function connectStreamConns(server) {
+    const clientConn = new StreamConn();
+    const serverConn = new StreamConn(server, { direction: 'inbound' });
+    const { port1: clientPort, port2: serverPort } = new MessageChannel();
+    const opts = {};
+    const clientChannelStream = new ChannelStream('client', clientPort, opts);
+    const serverChannelStream = new ChannelStream('server', serverPort, opts);
+    pipe(clientChannelStream, clientConn, combineUint8ArrayListTransform(), clientChannelStream)
+        .catch((err) => clientConn.close(err))
+        .then(() => clientConn.close());
+    pipe(serverChannelStream, serverConn, combineUint8ArrayListTransform(), serverChannelStream)
+        .catch((err) => serverConn.close(err))
+        .then(() => serverConn.close());
+    return {
+        clientConn,
+        cleanup() {
+            clientConn.close();
+            serverConn.close();
+            clientChannelStream.close();
+            serverChannelStream.close();
+        },
+    };
+}
+async function nextWithTimeout(source, label) {
+    return promiseWithTimeout(source.next(), label);
+}
+async function promiseWithTimeout(promise, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), 500);
+        }),
+    ]);
+}

package/package.json

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

package/srpc/channel.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import { pushable } from 'it-pushable'
+
+import { ChannelStream } from './channel.js'
+
+describe('ChannelStream', () => {
+  it('keeps MessagePort peer writes open after local source completes normally', async () => {
+    const { port1, port2 } = new MessageChannel()
+    const client = new ChannelStream<Uint8Array>('client', port1)
+    const server = new ChannelStream<Uint8Array>('server', port2)
+    await expectPeerWriteAfterLocalSourceCompletes(client, server)
+  })
+
+  it('keeps BroadcastChannel peer writes open after local source completes normally', async () => {
+    const channelName = `channel-stream-${Date.now()}-${Math.random()}`
+    const clientToServer = `${channelName}-client-to-server`
+    const serverToClient = `${channelName}-server-to-client`
+    const client = new ChannelStream<Uint8Array>('client', {
+      tx: new BroadcastChannel(clientToServer),
+      rx: new BroadcastChannel(serverToClient),
+    })
+    const server = new ChannelStream<Uint8Array>('server', {
+      tx: new BroadcastChannel(serverToClient),
+      rx: new BroadcastChannel(clientToServer),
+    })
+    await expectPeerWriteAfterLocalSourceCompletes(client, server)
+  })
+
+  it('propagates explicit close errors as full teardown', async () => {
+    const { port1, port2 } = new MessageChannel()
+    const active = new ChannelStream<Uint8Array>('active', port1)
+    const passive = new ChannelStream<Uint8Array>('passive', port2)
+    const next = passive.source[Symbol.asyncIterator]().next()
+
+    try {
+      active.close(new Error('boom'))
+
+      await expect(next).rejects.toThrow('boom')
+      expect((passive as any).closed).toBe(true)
+      expect(port2.onmessage).toBe(null)
+    } finally {
+      active.close()
+      passive.close()
+    }
+  })
+})
+
+async function expectPeerWriteAfterLocalSourceCompletes(
+  client: ChannelStream<Uint8Array>,
+  server: ChannelStream<Uint8Array>,
+) {
+  const clientWrites = pushable<Uint8Array>({ objectMode: true })
+  const serverWrites = pushable<Uint8Array>({ objectMode: true })
+  const clientSink = client.sink(clientWrites)
+  const serverSink = server.sink(serverWrites)
+  const clientReads = client.source[Symbol.asyncIterator]()
+  const serverReads = server.source[Symbol.asyncIterator]()
+
+  try {
+    const request = new Uint8Array([1, 2, 3])
+    clientWrites.push(request)
+
+    await expect(readNext(serverReads)).resolves.toEqual({
+      done: false,
+      value: request,
+    })
+
+    clientWrites.end()
+    await expect(readNext(serverReads)).resolves.toEqual({
+      done: true,
+      value: undefined,
+    })
+
+    const response = new Uint8Array([4, 5, 6])
+    serverWrites.push(response)
+    await expect(readNext(clientReads)).resolves.toEqual({
+      done: false,
+      value: response,
+    })
+
+    serverWrites.end()
+    await expect(clientSink).resolves.toBeUndefined()
+    await expect(serverSink).resolves.toBeUndefined()
+    await expect(readNext(clientReads)).resolves.toEqual({
+      done: true,
+      value: undefined,
+    })
+    expect((client as any).closed).toBe(true)
+    expect((server as any).closed).toBe(true)
+  } finally {
+    client.close()
+    server.close()
+  }
+}
+
+function readNext<T>(
+  source: AsyncIterator<T>,
+): Promise<IteratorResult<T, undefined>> {
+  return Promise.race([
+    source.next(),
+    new Promise<IteratorResult<T, undefined>>((_, reject) => {
+      setTimeout(
+        () => reject(new Error('timed out waiting for stream data')),
+        100,
+      )
+    }),
+  ])
+}

package/srpc/channel.ts

@@ -13,6 +13,8 @@ export interface ChannelStreamMessage<T> {
   opened?: true
   // closed indicates the stream is closed.
   closed?: true
+  // teardown indicates the whole channel should be torn down.
+  teardown?: true
   // error indicates the stream has an error.
   error?: Error
   // data is any message data.
@@ -82,6 +84,10 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
   private idleWatchdog?: Watchdog
   // closed indicates the local channel has been torn down.
   private closed = false
+  // localWriteClosed indicates the local sink finished normally.
+  private localWriteClosed = false
+  // remoteWriteClosed indicates the remote sink finished normally.
+  private remoteWriteClosed = false
 
   // isAcked checks if the stream is acknowledged by the remote.
   public get isAcked() {
@@ -207,12 +213,14 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
     }
     if (notifyRemote) {
       try {
-        this.postMessage({ closed: true, error })
+        this.postMessage({ closed: true, error, teardown: true })
       } catch {
         // Ignore close races while tearing down the local channel.
       }
     }
     this.closed = true
+    this.localWriteClosed = true
+    this.remoteWriteClosed = true
     // close channels
     if (this.channel instanceof MessagePort) {
       this.channel.onmessage = null
@@ -241,6 +249,29 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
     this._source.end(error)
   }
 
+  // finishIfBothDirectionsClosed tears down after a clean bidirectional EOF.
+  private finishIfBothDirectionsClosed() {
+    if (this.localWriteClosed && this.remoteWriteClosed) {
+      this.finish(undefined, false)
+    }
+  }
+
+  // clearKeepAlive stops local write keep-alives after the write side closes.
+  private clearKeepAlive() {
+    if (this.keepAlive) {
+      this.keepAlive.clear()
+      delete this.keepAlive
+    }
+  }
+
+  // clearIdleWatchdog stops receive watchdogs after the peer write side closes.
+  private clearIdleWatchdog() {
+    if (this.idleWatchdog) {
+      this.idleWatchdog.clear()
+      delete this.idleWatchdog
+    }
+  }
+
   // close closes the broadcast channels.
   public close(error?: Error) {
     this.finish(error, true)
@@ -297,9 +328,15 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
         for await (const msg of source) {
           this.postMessage({ data: msg })
         }
+        this.localWriteClosed = true
+        this.clearKeepAlive()
         this.postMessage({ closed: true })
+        this.finishIfBothDirectionsClosed()
       } catch (error) {
-        this.postMessage({ closed: true, error: error as Error })
+        this.finish(
+          error instanceof Error ? error : new Error(String(error)),
+          true,
+        )
       }
     }
   }
@@ -316,16 +353,19 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
     if (msg.opened) {
       this.onRemoteOpened()
     }
-    const { data, closed, error: err } = msg
-    if (data) {
+    const { data, closed, error: err, teardown } = msg
+    if (data !== undefined) {
       this._source.push(data)
     }
-    if (err) {
+    if (err || teardown) {
       this.finish(err, false)
       return
     }
     if (closed) {
-      this.finish(undefined, false)
+      this.remoteWriteClosed = true
+      this.clearIdleWatchdog()
+      this._source.end()
+      this.finishIfBothDirectionsClosed()
     }
   }
 }

package/srpc/server.test.ts

@@ -9,6 +9,7 @@ import {
   ChannelStream,
   combineUint8ArrayListTransform,
   ChannelStreamOpts,
+  Packet,
 } from '../srpc/index.js'
 import {
   EchoerDefinition,
@@ -77,6 +78,68 @@ describe('srpc server', () => {
     await runRpcStreamTest(client)
   })
 
+  it('keeps detached server-streaming responses open after request source completes', async () => {
+    const mux = createMux()
+    const response = new TextEncoder().encode('delayed init')
+    mux.registerLookupMethod(async (service, method) => {
+      if (service !== 'test.ResourceService' || method !== 'ResourceClient') {
+        return null
+      }
+      return async (_dataSource, dataSink) => {
+        await dataSink(
+          (async function* () {
+            await new Promise((resolve) => setTimeout(resolve, 10))
+            yield response
+          })(),
+        )
+      }
+    })
+
+    const server = new Server(mux.lookupMethod)
+    const firstResponse = new Promise<Packet>((resolve, reject) => {
+      server.handlePacketStream({
+        source: (async function* () {
+          yield Packet.toBinary({
+            body: {
+              case: 'callStart',
+              value: {
+                rpcService: 'test.ResourceService',
+                rpcMethod: 'ResourceClient',
+                data: new Uint8Array(0),
+                dataIsZero: true,
+              },
+            },
+          })
+        })(),
+        sink: async (source) => {
+          try {
+            for await (const packetData of source) {
+              const packet = Packet.fromBinary(packetData)
+              if (packet.body?.case === 'callData') {
+                resolve(packet)
+                return
+              }
+            }
+            reject(new Error('server response stream ended before call data'))
+          } catch (err) {
+            reject(err as Error)
+          }
+        },
+      })
+    })
+
+    const packet = await promiseWithTimeout(
+      firstResponse,
+      'detached server-streaming response',
+    )
+    const body = packet.body
+    expect(body?.case).toBe('callData')
+    if (body?.case !== 'callData' || !body.value?.data) {
+      throw new Error('expected callData packet')
+    }
+    expect([...body.value.data]).toEqual([...response])
+  })
+
   it('removes abort listeners after a request completes', async () => {
     const controller = new AbortController()
     const removeEventListener = vi.spyOn(
@@ -114,3 +177,12 @@ describe('srpc server', () => {
     expect(port2.onmessage).toBe(null)
   })
 })
+
+function promiseWithTimeout<T>(promise: Promise<T>, label: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => {
+      setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), 100)
+    }),
+  ])
+}

package/srpc/stream.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest'
+import { pipe } from 'it-pipe'
+
+import {
+  ChannelStream,
+  combineUint8ArrayListTransform,
+  StreamConn,
+  type ChannelStreamOpts,
+  type PacketStream,
+  type StreamHandler,
+} from '../srpc/index.js'
+
+describe('StreamConn packet stream', () => {
+  it('keeps yamux peer writes open after local packet source completes normally', async () => {
+    const request = new TextEncoder().encode('request')
+    const response = new TextEncoder().encode('response')
+
+    let serverError: unknown
+    const serverDone = new Promise<void>((resolve, reject) => {
+      const { clientConn, cleanup } = connectStreamConns({
+        handlePacketStream(stream: PacketStream) {
+          void (async () => {
+            const packets = stream.source[Symbol.asyncIterator]()
+            const first = await nextWithTimeout(
+              packets,
+              'server request packet',
+            )
+            expect(first.done).toBe(false)
+            expect([...first.value]).toEqual([...request])
+
+            const done = await nextWithTimeout(packets, 'server request eof')
+            expect(done.done).toBe(true)
+
+            await stream.sink(
+              (async function* () {
+                yield response
+              })(),
+            )
+          })()
+            .then(resolve)
+            .catch((err) => {
+              serverError = err
+              reject(err)
+            })
+        },
+      })
+
+      void (async () => {
+        try {
+          const clientStream = await clientConn.openStream()
+          await clientStream.sink(
+            (async function* () {
+              yield request
+            })(),
+          )
+
+          const packets = clientStream.source[Symbol.asyncIterator]()
+          const first = await nextWithTimeout(packets, 'client response packet')
+          expect(first.done).toBe(false)
+          expect([...first.value]).toEqual([...response])
+
+          const done = await nextWithTimeout(packets, 'client response eof')
+          expect(done.done).toBe(true)
+        } finally {
+          cleanup()
+        }
+      })().catch(reject)
+    })
+
+    await serverDone
+    expect(serverError).toBeUndefined()
+  })
+
+  it('aborts the yamux stream when the packet source errors', async () => {
+    const request = new TextEncoder().encode('request')
+    const sourceError = new Error('source failed')
+    let resolveReset: (err: unknown) => void = () => {}
+    const resetSeen = new Promise<unknown>((resolve) => {
+      resolveReset = resolve
+    })
+    const { clientConn, cleanup } = connectStreamConns({
+      handlePacketStream(stream: PacketStream) {
+        void (async () => {
+          try {
+            for await (const _packet of stream.source) {
+              // Drain until the reset arrives.
+            }
+            resolveReset(new Error('server stream ended without reset'))
+          } catch (err) {
+            resolveReset(err)
+          }
+        })()
+      },
+    })
+
+    try {
+      const clientStream = await clientConn.openStream()
+      await expect(
+        clientStream.sink(
+          (async function* () {
+            yield request
+            throw sourceError
+          })(),
+        ),
+      ).rejects.toThrow('source failed')
+
+      const resetErr = await promiseWithTimeout(resetSeen, 'server reset')
+      expect(resetErr).toBeInstanceOf(Error)
+      expect((resetErr as Error).message).toBe('stream reset')
+    } finally {
+      cleanup()
+    }
+  })
+})
+
+function connectStreamConns(server: StreamHandler): {
+  clientConn: StreamConn
+  cleanup: () => void
+} {
+  const clientConn = new StreamConn()
+  const serverConn = new StreamConn(server, { direction: 'inbound' })
+
+  const { port1: clientPort, port2: serverPort } = new MessageChannel()
+  const opts: ChannelStreamOpts = {}
+  const clientChannelStream = new ChannelStream('client', clientPort, opts)
+  const serverChannelStream = new ChannelStream('server', serverPort, opts)
+
+  pipe(
+    clientChannelStream,
+    clientConn,
+    combineUint8ArrayListTransform(),
+    clientChannelStream,
+  )
+    .catch((err: Error) => clientConn.close(err))
+    .then(() => clientConn.close())
+
+  pipe(
+    serverChannelStream,
+    serverConn,
+    combineUint8ArrayListTransform(),
+    serverChannelStream,
+  )
+    .catch((err: Error) => serverConn.close(err))
+    .then(() => serverConn.close())
+
+  return {
+    clientConn,
+    cleanup() {
+      clientConn.close()
+      serverConn.close()
+      clientChannelStream.close()
+      serverChannelStream.close()
+    },
+  }
+}
+
+async function nextWithTimeout<T>(
+  source: AsyncIterator<T>,
+  label: string,
+): Promise<IteratorResult<T>> {
+  return promiseWithTimeout(source.next(), label)
+}
+
+async function promiseWithTimeout<T>(
+  promise: Promise<T>,
+  label: string,
+): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => {
+      setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), 500)
+    }),
+  ])
+}

package/srpc/stream.ts

@@ -28,8 +28,6 @@ export type OpenStreamFunc = () => Promise<PacketStream>
 export type HandleStreamFunc = (ch: PacketStream) => Promise<void>
 
 // streamToPacketStream converts a Stream into a PacketStream using length-prefix framing.
-//
-// The stream is closed when the source writing to the sink ends.
 export function streamToPacketStream(stream: Stream): PacketStream {
   return {
     source: pipe(
@@ -38,9 +36,14 @@ export function streamToPacketStream(stream: Stream): PacketStream {
       combineUint8ArrayListTransform(),
     ),
     sink: async (source: Source<Uint8Array>): Promise<void> => {
-      await pipe(source, prependLengthPrefixTransform(), stream)
-        .catch((err) => stream.close(err))
-        .then(() => stream.close())
+      try {
+        await pipe(source, prependLengthPrefixTransform(), stream)
+        await stream.closeWrite()
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err))
+        stream.abort(error)
+        throw error
+      }
     },
   }
 }