starpc 0.49.10 → 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/go.mod

@@ -3,9 +3,9 @@ module github.com/aperturerobotics/starpc
 go 1.25.0
 
 require (
-	github.com/aperturerobotics/common v0.33.0 // latest
+	github.com/aperturerobotics/common v0.33.1-0.20260516193515-675cfc5a0c12 // latest
 	github.com/aperturerobotics/protobuf-go-lite v0.13.0 // latest
-	github.com/aperturerobotics/util v1.34.5-0.20260516103104-cbfc6d6a0589 // latest
+	github.com/aperturerobotics/util v1.34.5 // latest
 )
 
 require (

package/go.sum

@@ -2,8 +2,8 @@ github.com/aperturerobotics/abseil-cpp v0.0.0-20260131110040-4bb56e2f9017 h1:3U7
 github.com/aperturerobotics/abseil-cpp v0.0.0-20260131110040-4bb56e2f9017/go.mod h1:lNSJTKECIUFAnfeSqy01kXYTYe1BHubW7198jNX3nEw=
 github.com/aperturerobotics/cli v1.1.0 h1:7a+YRC+EY3npAnTzhHV5gLCiw91KS0Ts3XwLILGOsT8=
 github.com/aperturerobotics/cli v1.1.0/go.mod h1:M7BFP9wow5ytTzMyJQOOO991fGfsUqdTI7gGEsHfTQ8=
-github.com/aperturerobotics/common v0.33.0 h1:IheETbaQPmvUpkm6Z+/1jbuAQOXZF5REnRRMXTaIeVk=
-github.com/aperturerobotics/common v0.33.0/go.mod h1:xabIJydWovkzjs5YZD8ru/BgFTAXekgHwV8DrTl3R2w=
+github.com/aperturerobotics/common v0.33.1-0.20260516193515-675cfc5a0c12 h1:KQiFEDyu5//G8JZ3yTN92kF2P3F+LHjSKsQikgROncU=
+github.com/aperturerobotics/common v0.33.1-0.20260516193515-675cfc5a0c12/go.mod h1:pW7BhBpKzVrTxN8XIz6jb3MJERZ15GDxaGQ7jcIl0Xg=
 github.com/aperturerobotics/go-protoc-gen-prost v0.0.0-20260329113538-218ccd8f20e0 h1:6/3RSSlPEQ6LeidslB1ZCJkxW+MnfYDkvdWMDklDXw4=
 github.com/aperturerobotics/go-protoc-gen-prost v0.0.0-20260329113538-218ccd8f20e0/go.mod h1:OBb/beWmr/pDIZAUfi86j/4tBh2v5ctTxKMqSnh9c/4=
 github.com/aperturerobotics/go-protoc-wasi v0.0.0-20260329113540-600516012db3 h1:lp+V8RYcBwTX1p81swkpZn5fhw1wn2xLorzETIxRyZQ=
@@ -16,10 +16,8 @@ github.com/aperturerobotics/protobuf v0.0.0-20260203024654-8201686529c4 h1:4Dy3B
 github.com/aperturerobotics/protobuf v0.0.0-20260203024654-8201686529c4/go.mod h1:tMgO7y6SJo/d9ZcvrpNqIQtdYT9de+QmYaHOZ4KnhOg=
 github.com/aperturerobotics/protobuf-go-lite v0.13.0 h1:jEvCJhHaJEikDY/va2AUnS0DOb/0n82aISLAqxSh4Sk=
 github.com/aperturerobotics/protobuf-go-lite v0.13.0/go.mod h1:lGH3s5ArCTXKI4wJdlNpaybUtwSjfAG0vdWjxOfMcF8=
-github.com/aperturerobotics/util v1.34.5-0.20260515183346-68f9eac1d69f h1:xISFLs00h441uZcMVxhZbLIZsMRcjOM5Yont18i7WjA=
-github.com/aperturerobotics/util v1.34.5-0.20260515183346-68f9eac1d69f/go.mod h1:mDe7WnncVuV7yjeeVSsagyfrw4xfncu7d+f0+d70niY=
-github.com/aperturerobotics/util v1.34.5-0.20260516103104-cbfc6d6a0589 h1:8B9O13He1sz8Spr2pc+RL3hBzAMveLgUCXT7BpAfvEY=
-github.com/aperturerobotics/util v1.34.5-0.20260516103104-cbfc6d6a0589/go.mod h1:mDe7WnncVuV7yjeeVSsagyfrw4xfncu7d+f0+d70niY=
+github.com/aperturerobotics/util v1.34.5 h1:007MaOJrrsiGm5o1c8Tt7p8nVwUAxkM6pmGflrBww/U=
+github.com/aperturerobotics/util v1.34.5/go.mod h1:mDe7WnncVuV7yjeeVSsagyfrw4xfncu7d+f0+d70niY=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.49.10",
+  "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,
+      )
+    }),
+  ])
+}