starpc 0.52.0 → 0.52.1

package/srpc/client.ts

@@ -117,13 +117,29 @@ export class Client implements ProtoRpc {
     const stream = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     const onAbort = () => {
+      if (call.isClosed) return
+      const error = new Error(ERR_RPC_ABORT)
       void call.writeCallCancel().catch(() => undefined)
-      void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined)
+      stream.abort(error)
+      void call.close(error).catch(() => undefined)
     }
     abortSignal?.addEventListener('abort', onAbort, { once: true })
-    pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-      .catch((err) => call.close(err))
-      .then(() => call.close())
+    void pipe(stream, decodePacketSource, call, encodePacketSource, stream)
+      .then(
+        async () => {
+          if (call.isClosed instanceof Error) {
+            stream.abort(call.isClosed)
+            return
+          }
+          await stream.close()
+          await call.close()
+        },
+        async (err: unknown) => {
+          const error = err instanceof Error ? err : new Error(String(err))
+          stream.abort(error)
+          await call.close(error)
+        },
+      )
       .finally(() => {
         abortSignal?.removeEventListener('abort', onAbort)
       })

package/srpc/codec.rs

@@ -76,6 +76,9 @@ impl Encoder<Packet> for PacketCodec {
         let msg_size = item.encoded_len();
 
         // Validate message size.
+        if msg_size == 0 {
+            return Err(Error::MessageSizeZero);
+        }
         if msg_size > MAX_MESSAGE_SIZE {
             return Err(Error::MessageTooLarge(msg_size, MAX_MESSAGE_SIZE));
         }
@@ -96,6 +99,9 @@ impl Encoder<Packet> for PacketCodec {
 /// Encode a packet to bytes with length prefix.
 pub fn encode_packet(packet: &Packet) -> Result<Vec<u8>> {
     let msg_size = packet.encoded_len();
+    if msg_size == 0 {
+        return Err(Error::MessageSizeZero);
+    }
     if msg_size > MAX_MESSAGE_SIZE {
         return Err(Error::MessageTooLarge(msg_size, MAX_MESSAGE_SIZE));
     }

package/srpc/common-rpc.test.ts

@@ -152,6 +152,8 @@ describe('CommonRPC', () => {
     const responseGate = deferred()
     const response = new Uint8Array([7])
     const client = new Client(async () => ({
+      close: async () => {},
+      abort: () => {},
       source: (async function* () {
         await responseGate.promise
         yield Packet.toBinary({

package/srpc/packet-codec-vectors_test.go

@@ -0,0 +1,195 @@
+package srpc
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"testing"
+)
+
+type packetCodecVector struct {
+	Name      string `json:"name"`
+	PacketHex string `json:"packet_hex"`
+	FrameHex  string `json:"frame_hex"`
+}
+
+func TestPacketCodecGoldenVectors(t *testing.T) {
+	data, err := os.ReadFile("../testdata/packet-codec-vectors.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var document struct {
+		Cases []packetCodecVector `json:"cases"`
+	}
+	if err := json.Unmarshal(data, &document); err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range document.Cases {
+		if tc.PacketHex == "" || tc.FrameHex == "" {
+			continue
+		}
+		t.Run(tc.Name, func(t *testing.T) {
+			packet := goldenPacket(t, tc.Name)
+			packetData, err := packet.MarshalVT()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.PacketHex); !bytes.Equal(packetData, want) {
+				t.Fatalf("packet = %x, want %x", packetData, want)
+			}
+			stream := &packetTestStream{}
+			if err := NewPacketReadWriter(stream).WritePacket(packet); err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.FrameHex); !bytes.Equal(stream.writes, want) {
+				t.Fatalf("frame = %x, want %x", stream.writes, want)
+			}
+		})
+	}
+}
+
+func goldenPacket(t *testing.T, name string) *Packet {
+	t.Helper()
+	switch name {
+	case "call_start_data":
+		return NewCallStartPacket("svc", "method", []byte("abc"), false)
+	case "call_start_absent_empty":
+		return NewCallStartPacket("svc", "method", nil, false)
+	case "call_start_present_empty":
+		return NewCallStartPacket("svc", "method", nil, true)
+	case "call_data_terminal":
+		return NewCallDataPacket([]byte("out"), false, true, nil)
+	case "call_data_error":
+		return NewCallDataPacket(nil, false, false, errors.New("failed"))
+	case "call_cancel":
+		return NewCallCancelPacket()
+	default:
+		t.Fatalf("unknown golden packet %q", name)
+		return nil
+	}
+}
+
+func decodeHex(t *testing.T, value string) []byte {
+	t.Helper()
+	data, err := hex.DecodeString(value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data
+}
+
+func framePacket(t *testing.T, packet *Packet) []byte {
+	t.Helper()
+	packetSize := packet.SizeVT()
+	if packetSize > maxMessageSize {
+		t.Fatalf("packet size %d exceeds maximum %d", packetSize, maxMessageSize)
+	}
+	frame := make([]byte, 4+packetSize)
+	binary.LittleEndian.PutUint32(frame, uint32(packetSize)) //nolint:gosec // bounded by maxMessageSize
+	if _, err := packet.MarshalToSizedBufferVT(frame[4:]); err != nil {
+		t.Fatal(err)
+	}
+	return frame
+}
+
+type packetTestStream struct {
+	reads   bytes.Buffer
+	writes  []byte
+	maxRead int
+}
+
+func (s *packetTestStream) Read(data []byte) (int, error) {
+	if s.maxRead > 0 && len(data) > s.maxRead {
+		data = data[:s.maxRead]
+	}
+	return s.reads.Read(data)
+}
+
+func (s *packetTestStream) Write(data []byte) (int, error) {
+	s.writes = append(s.writes, data...)
+	return len(data), nil
+}
+
+func (s *packetTestStream) Close() error { return nil }
+
+func TestPacketCodecReadFragmentsAndCoalesces(t *testing.T) {
+	first := framePacket(t, NewCallCancelPacket())
+	second := framePacket(t, NewCallDataPacket([]byte("x"), false, true, nil))
+	input := append(first, second...)
+	stream := &packetTestStream{reads: *bytes.NewBuffer(input)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+		count++
+		return decode(data)
+	})
+	if err != nil || count != 2 {
+		t.Fatalf("ReadToHandler() = %v, packets=%d", err, count)
+	}
+}
+
+func TestPacketCodecReadEveryFragmentBoundary(t *testing.T) {
+	frame := framePacket(t, NewCallCancelPacket())
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	for size := 1; size <= len(frame); size++ {
+		stream := &packetTestStream{reads: *bytes.NewBuffer(frame), maxRead: size}
+		var count int
+		err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+			count++
+			return decode(data)
+		})
+		if err != nil || count != 1 {
+			t.Fatalf("chunk %d: err=%v count=%d", size, err, count)
+		}
+	}
+}
+
+func TestPacketCodecRejectsInvalidPrefixesAndMalformedPacket(t *testing.T) {
+	for name, frame := range map[string][]byte{
+		"zero":      {0, 0, 0, 0},
+		"oversized": {0x81, 0x96, 0x98, 0x00},
+	} {
+		t.Run(name, func(t *testing.T) {
+			stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+			if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err == nil {
+				t.Fatal("accepted invalid prefix")
+			}
+		})
+	}
+	frame := []byte{3, 0, 0, 0, 0x0a, 0x01, 0xff}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	if err := NewPacketReadWriter(stream).ReadToHandler(decode); err == nil {
+		t.Fatal("accepted malformed protobuf")
+	}
+}
+
+func TestPacketCodecCleanEOFReturnsNil(t *testing.T) {
+	stream := &packetTestStream{reads: *bytes.NewBuffer(nil)}
+	if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err != nil {
+		t.Fatalf("clean EOF: %v", err)
+	}
+}
+
+func TestPacketCodecTruncatedBodyAtEOF(t *testing.T) {
+	frame := []byte{4, 0, 0, 0, 0x0a, 0x01}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error {
+		count++
+		return nil
+	})
+	if err != io.ErrUnexpectedEOF || count != 0 {
+		t.Fatalf("err=%v count=%d", err, count)
+	}
+}
+
+func TestPacketCodecWriteRejectsZeroPacket(t *testing.T) {
+	if err := NewPacketReadWriter(&packetTestStream{}).WritePacket(&Packet{}); err == nil {
+		t.Fatal("accepted zero-size packet")
+	}
+}

package/srpc/packet-codec.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import vectors from '../testdata/packet-codec-vectors.json'
+import { Packet } from './rpcproto.pb.js'
+import {
+  decodePacketSource,
+  encodePacketSource,
+  lengthPrefixDecode,
+  prependLengthPrefixTransform,
+  uint32LEDecode,
+} from './packet.js'
+
+const bytes = (hex: string) =>
+  Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16))
+const hex = (
+  data: Uint8Array | { subarray: (start?: number, end?: number) => Uint8Array },
+) => Buffer.from(data.subarray()).toString('hex')
+const collect = async <T>(source: AsyncIterable<T> | Iterable<T>) => {
+  const out: T[] = []
+  for await (const value of source) out.push(value)
+  return out
+}
+
+type ValidVector = (typeof vectors.cases)[number] & {
+  packet_hex: string
+  frame_hex: string
+}
+const validCases: ValidVector[] = vectors.cases.filter(
+  (entry): entry is ValidVector => Boolean(entry.packet_hex && entry.frame_hex),
+)
+
+describe('packet codec golden vectors', () => {
+  it.each(validCases)(
+    '$name has exact protobuf and frame bytes',
+    async (entry) => {
+      const packet = Packet.fromBinary(bytes(entry.packet_hex))
+      const encoded = (
+        await collect(
+          encodePacketSource(
+            (async function* () {
+              yield packet
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(encoded)).toBe(entry.packet_hex)
+
+      const framed = (
+        await collect(
+          prependLengthPrefixTransform()(
+            (async function* () {
+              yield encoded
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(framed)).toBe(entry.frame_hex)
+    },
+  )
+
+  it('rejects zero and oversized encoded chunks', async () => {
+    const zero = (async function* () {
+      yield new Uint8Array()
+    })()
+    await expect(collect(prependLengthPrefixTransform()(zero))).rejects.toThrow(
+      'invalid packet length',
+    )
+    const oversized = (async function* () {
+      yield new Uint8Array(10_000_001)
+    })()
+    await expect(
+      collect(prependLengthPrefixTransform()(oversized)),
+    ).rejects.toThrow('invalid packet length')
+  })
+
+  it('rejects zero and oversized lengths, and truncated bodies', async () => {
+    const zero = (async function* () {
+      yield bytes('00000000')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(zero, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const oversized = (async function* () {
+      yield bytes('81969800')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(oversized, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const truncated = (async function* () {
+      yield bytes('040000000a01')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(truncated, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+
+  it('decodes fragmented and coalesced frames', async () => {
+    const frames = validCases.map((entry) => bytes(entry.frame_hex))
+    const combined = new Uint8Array(
+      frames.reduce((n, frame) => n + frame.length, 0),
+    )
+    let offset = 0
+    for (const frame of frames) {
+      combined.set(frame, offset)
+      offset += frame.length
+    }
+    const payloads = await collect(
+      lengthPrefixDecode(
+        (async function* () {
+          yield combined.subarray(0, 3)
+          yield combined.subarray(3, 11)
+          yield combined.subarray(11)
+        })(),
+        uint32LEDecode,
+      ),
+    )
+    expect(payloads.map(hex)).toEqual(
+      validCases.map((entry) => entry.packet_hex),
+    )
+    const decoded = await collect(
+      decodePacketSource(payloads.map((payload) => payload.slice())),
+    )
+    expect(decoded).toHaveLength(validCases.length)
+  })
+
+  it('rejects malformed protobuf and incomplete frame prefix', async () => {
+    const malformed = vectors.cases.find(
+      (entry) => entry.name === 'malformed_complete',
+    )!
+    expect(() =>
+      Packet.fromBinary(bytes(malformed.frame_hex!.slice(8))),
+    ).toThrow()
+    const incomplete = (async function* () {
+      yield bytes('010203')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(incomplete, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+})

package/srpc/packet-rw.go

@@ -65,7 +65,10 @@ func (r *PacketReadWriter) WritePacket(p *Packet) error {
 	defer r.writeMtx.Unlock()
 
 	msgSize := p.SizeVT()
-	if msgSize < 0 || msgSize > maxMessageSize {
+	if msgSize <= 0 {
+		return errors.New("unexpected zero message size")
+	}
+	if msgSize > maxMessageSize {
 		return errors.Errorf("message size %v greater than maximum %v", msgSize, maxMessageSize)
 	}
 
@@ -163,7 +166,11 @@ func (r *PacketReadWriter) ReadToHandler(cb PacketDataHandler) error {
 		}
 	}
 
-	// closed
+	// closed: a clean frame boundary has no buffered bytes; otherwise EOF
+	// ended a prefix or packet body before completion.
+	if currLen != 0 || r.buf.Len() != 0 {
+		return io.ErrUnexpectedEOF
+	}
 	return nil
 }
 

package/srpc/packet.ts

@@ -7,6 +7,8 @@ import {
   buildEncodeMessageTransform,
 } from './message.js'
 
+const MAX_MESSAGE_SIZE = 10_000_000
+
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform<Packet>(Packet)
 
@@ -39,6 +41,9 @@ export async function* lengthPrefixEncode(
   for await (const chunk of source) {
     // Encode the length of the chunk.
     const length = chunk instanceof Uint8Array ? chunk.length : chunk.byteLength
+    if (length === 0 || length > MAX_MESSAGE_SIZE) {
+      throw RangeError(`invalid packet length: ${length}`)
+    }
     const lengthEncoded = lengthEncoder(length)
 
     // Concatenate the length prefix and the data.
@@ -50,7 +55,7 @@ export async function* lengthPrefixEncode(
 export async function* lengthPrefixDecode(
   source: Source<Uint8Array | Uint8ArrayList>,
   lengthDecoder: typeof uint32LEDecode,
-) {
+): AsyncGenerator<Uint8ArrayList> {
   const buffer = new Uint8ArrayList()
 
   for await (const chunk of source) {
@@ -59,18 +64,26 @@ export async function* lengthPrefixDecode(
     // Continue extracting messages while buffer contains enough data for decoding.
     while (buffer.length >= lengthDecoder.bytes) {
       const messageLength = lengthDecoder(buffer)
+      if (messageLength === 0 || messageLength > MAX_MESSAGE_SIZE) {
+        throw RangeError(`invalid packet length: ${messageLength}`)
+      }
       const totalLength = lengthDecoder.bytes + messageLength
 
       if (buffer.length < totalLength) break // Wait for more data if the full message hasn't arrived.
 
       // Extract the message excluding the length prefix.
-      const message = buffer.sublist(lengthDecoder.bytes, totalLength)
+      const message = new Uint8ArrayList(
+        buffer.slice(lengthDecoder.bytes, totalLength),
+      )
       yield message
 
       // Remove the processed message from the buffer.
       buffer.consume(totalLength)
     }
   }
+  if (buffer.length !== 0) {
+    throw new RangeError('truncated packet frame')
+  }
 }
 
 // prependLengthPrefixTransform adds a length prefix to a message source.

package/srpc/rpcproto_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
+# Protobuf Python Version: 6.33.4
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    33,
+    4,
+    '',
+    'github.com/aperturerobotics/starpc/srpc/rpcproto.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n6github.com/aperturerobotics/starpc/srpc/rpcproto.proto\x12\x04srpc\"s\n\x06Packet\x12%\n\ncall_start\x18\x01 \x01(\x0b\x32\x0f.srpc.CallStartH\x00\x12#\n\tcall_data\x18\x02 \x01(\x0b\x32\x0e.srpc.CallDataH\x00\x12\x15\n\x0b\x63\x61ll_cancel\x18\x03 \x01(\x08H\x00\x42\x06\n\x04\x62ody\"X\n\tCallStart\x12\x13\n\x0brpc_service\x18\x01 \x01(\t\x12\x12\n\nrpc_method\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x04 \x01(\x08\"O\n\x08\x43\x61llData\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x02 \x01(\x08\x12\x10\n\x08\x63omplete\x18\x03 \x01(\x08\x12\r\n\x05\x65rror\x18\x04 \x01(\tb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'github.com.aperturerobotics.starpc.srpc.rpcproto_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_PACKET']._serialized_start=64
+  _globals['_PACKET']._serialized_end=179
+  _globals['_CALLSTART']._serialized_start=181
+  _globals['_CALLSTART']._serialized_end=269
+  _globals['_CALLDATA']._serialized_start=271
+  _globals['_CALLDATA']._serialized_end=350
+# @@protoc_insertion_point(module_scope)

package/srpc/rpcproto_pb2.pyi

@@ -0,0 +1,40 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Packet(_message.Message):
+    __slots__ = ("call_start", "call_data", "call_cancel")
+    CALL_START_FIELD_NUMBER: _ClassVar[int]
+    CALL_DATA_FIELD_NUMBER: _ClassVar[int]
+    CALL_CANCEL_FIELD_NUMBER: _ClassVar[int]
+    call_start: CallStart
+    call_data: CallData
+    call_cancel: bool
+    def __init__(self, call_start: _Optional[_Union[CallStart, _Mapping]] = ..., call_data: _Optional[_Union[CallData, _Mapping]] = ..., call_cancel: _Optional[bool] = ...) -> None: ...
+
+class CallStart(_message.Message):
+    __slots__ = ("rpc_service", "rpc_method", "data", "data_is_zero")
+    RPC_SERVICE_FIELD_NUMBER: _ClassVar[int]
+    RPC_METHOD_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    rpc_service: str
+    rpc_method: str
+    data: bytes
+    data_is_zero: bool
+    def __init__(self, rpc_service: _Optional[str] = ..., rpc_method: _Optional[str] = ..., data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ...) -> None: ...
+
+class CallData(_message.Message):
+    __slots__ = ("data", "data_is_zero", "complete", "error")
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    COMPLETE_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    data: bytes
+    data_is_zero: bool
+    complete: bool
+    error: str
+    def __init__(self, data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ..., complete: _Optional[bool] = ..., error: _Optional[str] = ...) -> None: ...

package/srpc/server.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, beforeEach, expect, vi } from 'vitest'
 import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
+import type { Source } from 'it-stream-types'
 import {
   createHandler,
   createMux,
@@ -175,6 +177,8 @@ describe('srpc server', () => {
     const server = new Server(mux.lookupMethod)
     const firstResponse = new Promise<Packet>((resolve, reject) => {
       server.handlePacketStream({
+        close: async () => {},
+        abort: () => {},
         source: (async function* () {
           yield Packet.toBinary({
             body: {
@@ -342,6 +346,52 @@ describe('srpc server', () => {
     await Promise.resolve()
   })
 
+  it('closes the packet stream when the server pipeline completes', async () => {
+    const server = new Server(createMux().lookupMethod)
+    const close = vi.fn(async () => {})
+    const source = pushable<Uint8Array>({ objectMode: true })
+    const stream = {
+      close,
+      abort: vi.fn(),
+      source,
+      sink: async (output: Source<Uint8Array>) => {
+        for await (const _packet of output) {
+          // Drain the response pipeline.
+        }
+      },
+    }
+    const rpc = server.handlePacketStream(stream)
+
+    await rpc.close()
+    source.end()
+
+    await vi.waitFor(() => expect(close).toHaveBeenCalledOnce())
+    expect(stream.abort).not.toHaveBeenCalled()
+  })
+
+  it('aborts the packet stream when the server pipeline fails', async () => {
+    const server = new Server(createMux().lookupMethod)
+    const error = new Error('input failed')
+    const abort = vi.fn()
+    const source = pushable<Uint8Array>({ objectMode: true })
+    const stream = {
+      close: vi.fn(async () => {}),
+      abort,
+      source,
+      sink: async (output: Source<Uint8Array>) => {
+        for await (const _packet of output) {
+          // Drain the response pipeline.
+        }
+      },
+    }
+
+    server.handlePacketStream(stream)
+    source.end(error)
+
+    await vi.waitFor(() => expect(abort).toHaveBeenCalledWith(error))
+    expect(stream.close).not.toHaveBeenCalled()
+  })
+
   it('tears down passive channel close state', async () => {
     const { port1, port2 } = new MessageChannel()
     const opts: ChannelStreamOpts = { idleTimeoutMs: 1000, keepAliveMs: 1000 }

package/srpc/server.ts

@@ -20,9 +20,7 @@ export class Server implements StreamHandler {
   public get rpcStreamHandler(): HandleStreamFunc {
     return async (stream: PacketStream) => {
       const rpc = this.startRpc()
-      return pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
-        .catch((err: Error) => rpc.close(err))
-        .then(() => rpc.close())
+      return runPacketStream(stream, rpc)
     }
   }
 
@@ -36,9 +34,27 @@ export class Server implements StreamHandler {
   // the stream has one Uint8Array per packet w/o length prefix.
   public handlePacketStream(stream: PacketStream): ServerRPC {
     const rpc = this.startRpc()
-    pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
-      .catch((err: Error) => rpc.close(err))
-      .then(() => rpc.close())
+    void runPacketStream(stream, rpc).catch(() => undefined)
     return rpc
   }
 }
+
+async function runPacketStream(
+  stream: PacketStream,
+  rpc: ServerRPC,
+): Promise<void> {
+  try {
+    await pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+    if (rpc.isClosed instanceof Error) {
+      stream.abort(rpc.isClosed)
+      throw rpc.isClosed
+    }
+    await stream.close()
+    await rpc.close()
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err))
+    stream.abort(error)
+    await rpc.close(error)
+    throw error
+  }
+}