starpc 0.25.4 → 0.26.0

package/dist/e2e/e2e.js

@@ -13,7 +13,7 @@ async function runRPC() {
     const serverConn = new StreamConn(server, { direction: 'inbound' });
     // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
     const { port1: clientPort, port2: serverPort } = new MessageChannel();
-    const opts = { idleTimeoutMs: 250, keepAliveMs: 100 };
+    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.
@@ -30,6 +30,10 @@ async function runRPC() {
     await runClientTest(client);
     await runAbortControllerTest(client);
     await runRpcStreamTest(client);
+    // Make sure we have no uncaught promises
+    await new Promise((resolve) => {
+        setTimeout(resolve, 500);
+    });
     // Close cleanly
     clientConn.close();
     serverConn.close();
@@ -40,6 +44,6 @@ runRPC()
     process.exit(0);
 })
     .catch((err) => {
-    console.error(err);
+    console.error('e2e tests failed', err);
     process.exit(1);
 });

package/dist/echo/client-test.js

@@ -29,24 +29,44 @@ export async function runAbortControllerTest(client) {
     const demoServiceClient = new EchoerClientImpl(client);
     console.log('Testing EchoClientStream with AbortController...');
     let errorReturned = false;
-    const clientAbort = new AbortController();
-    const clientNoopStream = pushable({ objectMode: true });
-    new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
-        clientAbort.abort();
+    const testRpc = async (rpc) => {
+        const clientAbort = new AbortController();
+        new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
+            clientAbort.abort();
+        });
+        try {
+            await rpc(clientAbort.signal);
+        }
+        catch (err) {
+            const errMsg = err.message;
+            errorReturned = true;
+            if (errMsg !== ERR_RPC_ABORT) {
+                throw new Error('unexpected error: ' + errMsg);
+            }
+        }
+        if (!errorReturned) {
+            throw new Error('expected aborted rpc to throw error');
+        }
+    };
+    await testRpc(async (signal) => {
+        const clientNoopStream = pushable({ objectMode: true });
+        await demoServiceClient.EchoClientStream(clientNoopStream, signal);
     });
-    try {
-        await demoServiceClient.EchoClientStream(clientNoopStream, clientAbort.signal);
-    }
-    catch (err) {
-        const errMsg = err.message;
-        errorReturned = true;
-        if (errMsg !== ERR_RPC_ABORT) {
-            throw new Error('unexpected error: ' + errMsg);
+    await testRpc(async (signal) => {
+        const stream = demoServiceClient.EchoServerStream({ body: 'test' }, signal);
+        const msgs = [];
+        try {
+            for await (const msg of stream) {
+                msgs.push(msg);
+            }
         }
-    }
-    if (!errorReturned) {
-        throw new Error('expected aborted rpc to throw error');
-    }
+        catch (err) {
+            if (msgs.length < 3) {
+                throw new Error('expected at least three messages before error');
+            }
+            throw err;
+        }
+    });
 }
 // runRpcStreamTest tests a RPCStream.
 export async function runRpcStreamTest(client) {

package/dist/srpc/channel.js

@@ -7,6 +7,7 @@ import { ERR_STREAM_IDLE } from './errors.js';
 // 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.
+// NOTE: Browsers will throttle setTimeout in background tabs.
 export class ChannelStream {
     // isAcked checks if the stream is acknowledged by the remote.
     get isAcked() {

package/dist/srpc/client.js

@@ -28,8 +28,7 @@ export class Client {
     // clientStreamingRequest starts a client side streaming request.
     async clientStreamingRequest(service, method, data, abortSignal) {
         const call = await this.startRpc(service, method, null, abortSignal);
-        call.writeCallDataFromSource(data)
-            .catch(err => call.close(err));
+        call.writeCallDataFromSource(data).catch((err) => call.close(err));
         for await (const data of call.rpcDataSource) {
             call.close();
             return data;
@@ -42,12 +41,7 @@ export class Client {
     serverStreamingRequest(service, method, data, abortSignal) {
         const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, data, abortSignal)
-            .then(async (call) => {
-            const result = writeToPushable(call.rpcDataSource, serverData);
-            result.catch((err) => call.close(err));
-            result.then(() => call.close());
-            return result;
-        })
+            .then(async (call) => writeToPushable(call.rpcDataSource, serverData))
             .catch((err) => serverData.end(err));
         return serverData;
     }
@@ -92,7 +86,7 @@ export class Client {
         pipe(stream, decodePacketSource, call, encodePacketSource, stream)
             .catch((err) => call.close(err))
             .then(() => call.close());
-        await call.writeCallStart(data || undefined);
+        await call.writeCallStart(data ?? undefined);
         return call;
     }
 }

package/dist/srpc/common-rpc.d.ts

@@ -11,6 +11,7 @@ export declare class CommonRPC {
     protected method?: string;
     private closed?;
     constructor();
+    get isClosed(): boolean | Error;
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     writeCallCancel(): Promise<void>;
     writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>): Promise<void>;
@@ -22,6 +23,5 @@ export declare class CommonRPC {
     handleCallData(packet: Partial<CallData>): Promise<void>;
     handleCallCancel(): Promise<void>;
     close(err?: Error): Promise<void>;
-    closeWrite(): void;
     private _createSink;
 }

package/dist/srpc/common-rpc.js

@@ -16,6 +16,10 @@ export class CommonRPC {
         this.source = this._source;
         this.rpcDataSource = this._rpcDataSource;
     }
+    // isClosed returns one of: true (closed w/o error), Error (closed w/ error), or false (not closed).
+    get isClosed() {
+        return this.closed ?? false;
+    }
     // writeCallData writes the call data packet.
     async writeCallData(data, complete, error) {
         const callData = {
@@ -130,18 +134,12 @@ export class CommonRPC {
         if (this.closed) {
             return;
         }
-        this.closed = true;
-        // note: don't pass error to _source here.
-        if (err) {
-            await this.writeCallCancel();
-        }
+        this.closed = err ?? true;
+        // note: this does nothing if _source is already ended.
+        await this.writeCallCancel();
         this._source.end();
         this._rpcDataSource.end(err);
     }
-    // closeWrite closes the call for writing.
-    closeWrite() {
-        this._source.end();
-    }
     // _createSink returns a value for the sink field.
     _createSink() {
         return async (source) => {

package/dist/srpc/pushable.js

@@ -1,4 +1,6 @@
 // writeToPushable writes the incoming server data to the pushable.
+//
+// this will not throw an error: it instead ends out w/ the error.
 export async function writeToPushable(dataSource, out) {
     try {
         for await (const data of dataSource) {
@@ -8,7 +10,6 @@ export async function writeToPushable(dataSource, out) {
     }
     catch (err) {
         out.end(err);
-        throw err;
     }
 }
 export function buildPushableSink(target) {

package/dist/srpc/watchdog.js

@@ -1,4 +1,5 @@
 // Watchdog must be fed every timeoutDuration or it will call the expired callback.
+// NOTE: Browsers will throttle setTimeout in background tabs.
 export class Watchdog {
     /**
      * Constructs a Watchdog instance.

package/e2e/e2e.ts

@@ -25,7 +25,7 @@ async function runRPC() {
 
   // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
   const { port1: clientPort, port2: serverPort } = new MessageChannel()
-  const opts: ChannelStreamOpts = { idleTimeoutMs: 250, keepAliveMs: 100 }
+  const opts: ChannelStreamOpts = {} // { idleTimeoutMs: 250, keepAliveMs: 100 }
   const clientChannelStream = new ChannelStream('client', clientPort, opts)
   const serverChannelStream = new ChannelStream('server', serverPort, opts)
 
@@ -57,6 +57,11 @@ async function runRPC() {
   await runAbortControllerTest(client)
   await runRpcStreamTest(client)
 
+  // Make sure we have no uncaught promises
+  await new Promise<void>((resolve) => {
+    setTimeout(resolve, 500)
+  })
+
   // Close cleanly
   clientConn.close()
   serverConn.close()
@@ -68,6 +73,6 @@ runRPC()
     process.exit(0)
   })
   .catch((err) => {
-    console.error(err)
+    console.error('e2e tests failed', err)
     process.exit(1)
   })

package/echo/client-test.ts

@@ -36,26 +36,45 @@ export async function runAbortControllerTest(client: Client) {
 
   console.log('Testing EchoClientStream with AbortController...')
   let errorReturned = false
-  const clientAbort = new AbortController()
-  const clientNoopStream = pushable<EchoMsg>({ objectMode: true })
-  new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
-    clientAbort.abort()
-  })
-  try {
-    await demoServiceClient.EchoClientStream(
-      clientNoopStream,
-      clientAbort.signal,
-    )
-  } catch (err) {
-    const errMsg = (err as Error).message
-    errorReturned = true
-    if (errMsg !== ERR_RPC_ABORT) {
-      throw new Error('unexpected error: ' + errMsg)
+
+  const testRpc = async (rpc: (signal: AbortSignal) => Promise<void>) => {
+    const clientAbort = new AbortController()
+    new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
+      clientAbort.abort()
+    })
+    try {
+      await rpc(clientAbort.signal)
+    } catch (err) {
+      const errMsg = (err as Error).message
+      errorReturned = true
+      if (errMsg !== ERR_RPC_ABORT) {
+        throw new Error('unexpected error: ' + errMsg)
+      }
+    }
+    if (!errorReturned) {
+      throw new Error('expected aborted rpc to throw error')
     }
   }
-  if (!errorReturned) {
-    throw new Error('expected aborted rpc to throw error')
-  }
+
+  await testRpc(async (signal) => {
+    const clientNoopStream = pushable<EchoMsg>({ objectMode: true })
+    await demoServiceClient.EchoClientStream(clientNoopStream, signal)
+  })
+
+  await testRpc(async (signal) => {
+    const stream = demoServiceClient.EchoServerStream({ body: 'test' }, signal)
+    const msgs = []
+    try {
+      for await (const msg of stream) {
+        msgs.push(msg)
+      }
+    } catch (err) {
+      if (msgs.length < 3) {
+        throw new Error('expected at least three messages before error')
+      }
+      throw err
+    }
+  })
 }
 
 // runRpcStreamTest tests a RPCStream.

package/go.mod

@@ -9,7 +9,7 @@ require (
 )
 
 require (
-	github.com/aperturerobotics/util v1.13.5 // latest
+	github.com/aperturerobotics/util v1.13.6 // latest
 	github.com/libp2p/go-libp2p v0.32.2 // latest
 	github.com/libp2p/go-yamux/v4 v4.0.2-0.20240206065824-7222fbc3459d // master
 	github.com/sirupsen/logrus v1.9.3 // latest

package/go.sum

@@ -4,6 +4,8 @@ github.com/aperturerobotics/util v1.13.3 h1:N4JXKYql0R/A2hMuV79SZ2vaftf8tiN8DUJ8
 github.com/aperturerobotics/util v1.13.3/go.mod h1:JdziNd9tR6lWqc9bSMIe1At8Gagrg986rmtZuPCv6+w=
 github.com/aperturerobotics/util v1.13.5 h1:g8Q9VKBUYR5Nu5Ee/ZygVbe0JkGXeNq1fBkT0ipLBMY=
 github.com/aperturerobotics/util v1.13.5/go.mod h1:8AfpGb9RJqUItLBb5ec3sprpl9swYyHlgOw0HzkE+S8=
+github.com/aperturerobotics/util v1.13.6 h1:8FKBjj+vs23QZBiwkGod5WUY19Cisda48Rbg1zaqzZU=
+github.com/aperturerobotics/util v1.13.6/go.mod h1:8AfpGb9RJqUItLBb5ec3sprpl9swYyHlgOw0HzkE+S8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.25.4",
+  "version": "0.26.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -67,7 +67,7 @@
     "esbuild": "^0.20.0",
     "prettier": "^3.2.4",
     "rimraf": "^5.0.1",
-    "ts-poet": "6.6.0",
+    "ts-poet": "6.7.0",
     "ts-proto": "^1.166.1",
     "typescript": "^5.3.2",
     "utf-8-validate": "^6.0.3"

package/srpc/channel.ts

@@ -43,6 +43,7 @@ export interface ChannelStreamOpts {
 // 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.
+// NOTE: Browsers will throttle setTimeout in background tabs.
 export class ChannelStream<T = Uint8Array>
   implements Duplex<AsyncGenerator<T>, Source<T>, Promise<void>>
 {

package/srpc/client-prefix.go

@@ -57,7 +57,7 @@ func (i *PrefixClient) stripCheckServiceIDPrefix(service string) (string, error)
 // NewRawStream opens a new raw stream with the remote.
 // Implements OpenStreamFunc.
 // msgHandler must not be called concurrently.
-func (i *PrefixClient) NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error) {
+func (i *PrefixClient) NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (PacketWriter, error) {
 	return i.client.NewRawStream(ctx, msgHandler, closeHandler)
 }
 

package/srpc/client-rpc.go

@@ -25,7 +25,7 @@ func NewClientRPC(ctx context.Context, service, method string) *ClientRPC {
 
 // Start sets the writer and writes the MsgSend message.
 // must only be called once!
-func (r *ClientRPC) Start(writer Writer, writeFirstMsg bool, firstMsg []byte) error {
+func (r *ClientRPC) Start(writer PacketWriter, writeFirstMsg bool, firstMsg []byte) error {
 	select {
 	case <-r.ctx.Done():
 		r.ctxCancel()

package/srpc/client-set.go

@@ -48,7 +48,7 @@ func (c *ClientSet) NewRawStream(
 	ctx context.Context,
 	msgHandler PacketDataHandler,
 	closeHandler CloseHandler,
-) (Writer, error) {
+) (PacketWriter, error) {
 	for _, client := range c.clients {
 		if client == nil {
 			continue

package/srpc/client-verbose.go

@@ -65,7 +65,7 @@ func (c *VClient) NewStream(ctx context.Context, service, method string, firstMs
 // NewRawStream opens a new raw stream with the remote.
 // Implements OpenStreamFunc.
 // msgHandler must not be called concurrently.
-func (c *VClient) NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (writer Writer, err error) {
+func (c *VClient) NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (writer PacketWriter, err error) {
 	t1 := time.Now()
 
 	defer func() {

package/srpc/client.go

@@ -18,7 +18,7 @@ type Client interface {
 	// NewRawStream opens a new raw stream with the remote.
 	// Implements OpenStreamFunc.
 	// msgHandler must not be called concurrently.
-	NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error)
+	NewRawStream(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (PacketWriter, error)
 }
 
 // OpenStreamFunc opens a stream with a remote.
@@ -27,7 +27,7 @@ type OpenStreamFunc = func(
 	ctx context.Context,
 	msgHandler PacketDataHandler,
 	closeHandler CloseHandler,
-) (Writer, error)
+) (PacketWriter, error)
 
 // client implements Client with a transport.
 type client struct {
@@ -102,7 +102,7 @@ func (c *client) NewRawStream(
 	ctx context.Context,
 	msgHandler PacketDataHandler,
 	closeHandler CloseHandler,
-) (Writer, error) {
+) (PacketWriter, error) {
 	return c.openStream(ctx, msgHandler, closeHandler)
 }
 

package/srpc/client.ts

@@ -48,8 +48,7 @@ export class Client implements TsProtoRpc {
     abortSignal?: AbortSignal,
   ): Promise<Uint8Array> {
     const call = await this.startRpc(service, method, null, abortSignal)
-    call.writeCallDataFromSource(data)
-      .catch(err => call.close(err))
+    call.writeCallDataFromSource(data).catch((err) => call.close(err))
     for await (const data of call.rpcDataSource) {
       call.close()
       return data
@@ -68,12 +67,7 @@ export class Client implements TsProtoRpc {
   ): AsyncIterable<Uint8Array> {
     const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
     this.startRpc(service, method, data, abortSignal)
-      .then(async (call) => {
-        const result = writeToPushable(call.rpcDataSource, serverData)
-        result.catch((err) => call.close(err))
-        result.then(() => call.close())
-        return result
-      })
+      .then(async (call) => writeToPushable(call.rpcDataSource, serverData))
       .catch((err) => serverData.end(err))
     return serverData
   }
@@ -129,7 +123,7 @@ export class Client implements TsProtoRpc {
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)
       .catch((err) => call.close(err))
       .then(() => call.close())
-    await call.writeCallStart(data || undefined)
+    await call.writeCallStart(data ?? undefined)
     return call
   }
 }

package/srpc/common-rpc.go

@@ -24,7 +24,7 @@ type commonRPC struct {
 	// bcast broadcasts when below fields change
 	bcast broadcast.Broadcast
 	// writer is the writer to write messages to
-	writer Writer
+	writer PacketWriter
 	// dataQueue contains incoming data packets.
 	// note: packets may be len() == 0
 	dataQueue [][]byte

package/srpc/common-rpc.ts

@@ -30,7 +30,7 @@ export class CommonRPC {
   protected method?: string
 
   // closed indicates this rpc has been closed already.
-  private closed?: boolean
+  private closed?: true | Error
 
   constructor() {
     this.sink = this._createSink()
@@ -38,6 +38,11 @@ export class CommonRPC {
     this.rpcDataSource = this._rpcDataSource
   }
 
+  // isClosed returns one of: true (closed w/o error), Error (closed w/ error), or false (not closed).
+  public get isClosed(): boolean | Error {
+    return this.closed ?? false
+  }
+
   // writeCallData writes the call data packet.
   public async writeCallData(
     data?: Uint8Array,
@@ -168,20 +173,13 @@ export class CommonRPC {
     if (this.closed) {
       return
     }
-    this.closed = true
-    // note: don't pass error to _source here.
-    if (err) {
-      await this.writeCallCancel()
-    }
+    this.closed = err ?? true
+    // note: this does nothing if _source is already ended.
+    await this.writeCallCancel()
     this._source.end()
     this._rpcDataSource.end(err)
   }
 
-  // closeWrite closes the call for writing.
-  public closeWrite() {
-    this._source.end()
-  }
-
   // _createSink returns a value for the sink field.
   private _createSink(): Sink<Source<Packet>> {
     return async (source: Source<Packet>) => {

package/srpc/muxed-conn.go

@@ -72,7 +72,7 @@ func NewClientWithMuxedConn(conn network.MuxedConn) Client {
 
 // NewOpenStreamWithMuxedConn constructs a OpenStream func with a MuxedConn.
 func NewOpenStreamWithMuxedConn(conn network.MuxedConn) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (PacketWriter, error) {
 		mstrm, err := conn.OpenStream(ctx)
 		if err != nil {
 			return nil, err

package/srpc/packet-rw.go

@@ -146,4 +146,4 @@ func (r *PacketReadWriter) readLengthPrefix(b []byte) uint32 {
 }
 
 // _ is a type assertion
-var _ Writer = (*PacketReadWriter)(nil)
+var _ PacketWriter = (*PacketReadWriter)(nil)

package/srpc/packet.go

@@ -1,6 +1,7 @@
 package srpc
 
-import "context"
+// CloseHandler handles the stream closing with an optional error.
+type CloseHandler = func(closeErr error)
 
 // PacketHandler handles a packet.
 //
@@ -11,12 +12,6 @@ type PacketHandler = func(pkt *Packet) error
 // PacketDataHandler handles a packet before it is parsed.
 type PacketDataHandler = func(data []byte) error
 
-// CloseHandler handles the stream closing with an optional error.
-type CloseHandler = func(closeErr error)
-
-// RawStreamCtor is a function that builds a raw stream.
-type RawStreamCtor func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error)
-
 // NewPacketDataHandler wraps a PacketHandler with a decoding step.
 func NewPacketDataHandler(handler PacketHandler) PacketDataHandler {
 	return func(data []byte) error {

package/srpc/pushable.ts

@@ -2,6 +2,8 @@ import { Pushable } from 'it-pushable'
 import { Sink, Source } from 'it-stream-types'
 
 // writeToPushable writes the incoming server data to the pushable.
+//
+// this will not throw an error: it instead ends out w/ the error.
 export async function writeToPushable<T>(
   dataSource: AsyncIterable<T>,
   out: Pushable<T>,
@@ -13,7 +15,6 @@ export async function writeToPushable<T>(
     out.end()
   } catch (err) {
     out.end(err as Error)
-    throw err
   }
 }
 

package/srpc/server-pipe.go

@@ -9,7 +9,7 @@ import (
 // Stream with the given Server. Starts read pumps for both. Starts the
 // HandleStream function on the server in a separate goroutine.
 func NewServerPipe(server *Server) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (PacketWriter, error) {
 		srvPipe, clientPipe := net.Pipe()
 		go server.HandleStream(ctx, srvPipe)
 		clientPrw := NewPacketReadWriter(clientPipe)

package/srpc/server-rpc.go

@@ -15,7 +15,7 @@ type ServerRPC struct {
 
 // NewServerRPC constructs a new ServerRPC session.
 // note: call SetWriter before handling any incoming messages.
-func NewServerRPC(ctx context.Context, invoker Invoker, writer Writer) *ServerRPC {
+func NewServerRPC(ctx context.Context, invoker Invoker, writer PacketWriter) *ServerRPC {
 	rpc := &ServerRPC{invoker: invoker}
 	initCommonRPC(ctx, &rpc.commonRPC)
 	rpc.writer = writer

package/srpc/watchdog.ts

@@ -1,4 +1,5 @@
 // Watchdog must be fed every timeoutDuration or it will call the expired callback.
+// NOTE: Browsers will throttle setTimeout in background tabs.
 export class Watchdog {
   private timeoutDuration: number
   private expiredCallback: () => void

package/srpc/writer.go

@@ -1,9 +1,7 @@
 package srpc
 
-// Writer is the interface used to write messages to the remote.
-type Writer interface {
-	// Write writes raw data to the remote.
-	Write(p []byte) (n int, err error)
+// PacketWriter is the interface used to write messages to a PacketStream.
+type PacketWriter interface {
 	// WritePacket writes a packet to the remote.
 	WritePacket(p *Packet) error
 	// Close closes the writer.

package/srpc/raw-stream-rwc.go

@@ -1,161 +0,0 @@
-package srpc
-
-import (
-	"context"
-	"io"
-	"sync"
-
-	"github.com/aperturerobotics/util/broadcast"
-)
-
-// RawStreamRwc implements io.ReadWriteCloser with a raw stream.
-type RawStreamRwc struct {
-	// writer is used to write messages to the remote.
-	writer Writer
-	// mtx guards below fields
-	mtx sync.Mutex
-	// bcast is broadcasted when data is added to readQueue
-	bcast broadcast.Broadcast
-	// readQueue holds incoming data to read
-	readQueue [][]byte
-	// closed indicates whether the stream is closed
-	closed bool
-	// closeErr stores the error, if any, when closing the stream
-	closeErr error
-}
-
-func NewRawStreamRwc(ctx context.Context, ctorFn RawStreamCtor) (*RawStreamRwc, error) {
-	rwc := &RawStreamRwc{}
-	var err error
-	rwc.writer, err = ctorFn(ctx, rwc.handlePacketData, rwc.handleClose)
-	if err != nil {
-		return nil, err
-	}
-	return rwc, nil
-}
-
-// handlePacketData implements PacketDataHandler.
-func (r *RawStreamRwc) handlePacketData(pkt []byte) error {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-
-	if r.closed {
-		return io.ErrClosedPipe
-	}
-
-	r.readQueue = append(r.readQueue, pkt)
-	r.bcast.Broadcast()
-	return nil
-}
-
-// handleClose handles the stream closing with an optional error.
-func (r *RawStreamRwc) handleClose(closeErr error) {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	if r.closed {
-		return
-	}
-	r.closed = true
-	r.closeErr = closeErr
-	r.bcast.Broadcast()
-}
-
-// Read reads data from the stream to p.
-// Implements io.Reader.
-func (r *RawStreamRwc) Read(p []byte) (n int, err error) {
-	readBuf := p
-	for len(readBuf) != 0 && err == nil {
-		// if the buffer has data, read from it.
-		var rn int
-		var read []byte
-
-		r.mtx.Lock()
-		if len(r.readQueue) != 0 {
-			nrq := r.readQueue[0]
-			// rn = amount of data to read
-			// minimum of len(readBuf) (length of space remaining in p) and len(nrq) (size of next pkt in read queue)
-			rn = min(len(readBuf), len(nrq))
-			// read the contents of nrq up to rn bytes
-			read = nrq[:rn]
-			// get the remainder of the packet that we won't read this time
-			nrq = nrq[rn:]
-			// if there is no more to read drop the pkt from the queue
-			if len(nrq) == 0 {
-				r.readQueue[0] = nil
-				r.readQueue = r.readQueue[1:]
-			} else {
-				// otherwise update the queued packet to be just the remainder
-				r.readQueue[0] = nrq
-			}
-		}
-
-		// check if the stream is closed
-		closed, closedErr := r.closed, r.closeErr
-		var wait <-chan struct{}
-
-		// if we didn't read anything and !closed, wait till something changes.
-		if rn == 0 && !closed {
-			wait = r.bcast.GetWaitCh()
-		}
-		r.mtx.Unlock()
-
-		// if we read data, copy it to the output buf
-		if rn != 0 {
-			// copy data to output buf
-			copy(readBuf, read)
-			n += rn
-			// advance readBuf by rn
-			readBuf = readBuf[rn:]
-			continue
-		}
-
-		// if we read data to p already, return now.
-		if n != 0 {
-			break
-		}
-
-		// if closed or error, return.
-		if closed {
-			if closedErr != nil {
-				return n, closedErr
-			}
-			return n, io.EOF
-		}
-
-		// wait for data or closed
-		<-wait
-	}
-
-	return n, err
-}
-
-// Write writes data to the stream.
-func (r *RawStreamRwc) Write(p []byte) (int, error) {
-	return r.writer.Write(p)
-}
-
-// WritePacket writes a packet to the remote.
-func (r *RawStreamRwc) WritePacket(p *Packet) error {
-	return r.writer.WritePacket(p)
-}
-
-// Close closes the stream.
-func (r *RawStreamRwc) Close() error {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-
-	if r.closed {
-		return r.closeErr
-	}
-
-	r.closed = true
-	r.closeErr = r.writer.Close()
-	r.bcast.Broadcast()
-	return r.closeErr
-}
-
-// _ is a type assertion
-var (
-	_ io.ReadWriteCloser = ((*RawStreamRwc)(nil))
-	_ Writer             = ((*RawStreamRwc)(nil))
-)