starpc 0.49.20 → 0.51.0

package/srpc/accept.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net"
 
-	"github.com/libp2p/go-yamux/v4"
+	"github.com/libp2p/go-yamux/v5"
 )
 
 // AcceptMuxedListener accepts incoming connections from a net.Listener.

package/srpc/client-prefix.go

@@ -55,4 +55,4 @@ func (i *PrefixClient) stripCheckServiceIDPrefix(service string) (string, error)
 }
 
 // _ is a type assertion
-var _ Client = ((*PrefixClient)(nil))
+var _ Client = (*PrefixClient)(nil)

package/srpc/client-set.go

@@ -75,4 +75,4 @@ func (c *ClientSet) execCall(ctx context.Context, doCall func(client Client) err
 }
 
 // _ is a type assertion
-var _ Client = ((*ClientSet)(nil))
+var _ Client = (*ClientSet)(nil)

package/srpc/client.go

@@ -97,4 +97,4 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 }
 
 // _ is a type assertion
-var _ Client = ((*client)(nil))
+var _ Client = (*client)(nil)

package/srpc/client.ts

@@ -8,10 +8,9 @@ import { ClientRPC } from './client-rpc.js'
 import { writeToPushable } from './pushable.js'
 import { decodePacketSource, encodePacketSource } from './packet.js'
 import { OpenStreamCtr } from './open-stream-ctr.js'
-import { CallReceipt } from './call-receipt.js'
-import type { HeldCall, ReceiptRpc } from './call-receipt.js'
+
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
-export class Client implements ProtoRpc, ReceiptRpc {
+export class Client implements ProtoRpc {
   // openStreamCtr contains the OpenStreamFunc.
   private openStreamCtr: OpenStreamCtr
 
@@ -41,32 +40,6 @@ export class Client implements ProtoRpc, ReceiptRpc {
     throw err
   }
 
-  // requestWithReceipt reads one response and retains the call terminal.
-  public async requestWithReceipt(
-    service: string,
-    method: string,
-    data: Uint8Array,
-    abortSignal?: AbortSignal,
-  ): Promise<HeldCall> {
-    const call = await this.startRpc(service, method, data, abortSignal)
-    const iterator = call.rpcDataSource[Symbol.asyncIterator]()
-    try {
-      const result = await iterator.next()
-      if (result.done) {
-        throw new Error('empty response')
-      }
-      return {
-        response: result.value,
-        receipt: new CallReceipt(call, iterator),
-      }
-    } catch (err) {
-      await call.close(
-        err instanceof Error ? err : new Error('receipt read failed'),
-      )
-      throw err
-    }
-  }
-
   // clientStreamingRequest starts a client side streaming request.
   public async clientStreamingRequest(
     service: string,
@@ -144,8 +117,8 @@ export class Client implements ProtoRpc, ReceiptRpc {
     const stream = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     const onAbort = () => {
-      call.writeCallCancel()
-      call.close(new Error(ERR_RPC_ABORT))
+      void call.writeCallCancel().catch(() => undefined)
+      void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined)
     }
     abortSignal?.addEventListener('abort', onAbort, { once: true })
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)

package/srpc/common-rpc.go

@@ -31,8 +31,8 @@ type commonRPC struct {
 	writer PacketWriter
 	// writerClosed is set after writer has been closed locally.
 	writerClosed bool
-	// localCompleting is set while the local handler is publishing its terminal
-	// packet and closing the writer.
+	// localCompleting is set while the local handler is publishing its
+	// completion packet and closing the writer.
 	localCompleting bool
 	// localActive is set while the local handler goroutine may still be inside
 	// user code. Resource owners use Wait as a lifetime barrier, so cancellation
@@ -48,14 +48,8 @@ type commonRPC struct {
 	dataClosed bool
 	// remoteErr is an error set by the remote.
 	remoteErr error
-	// remoteCanceled distinguishes a received CallCancel from transport loss.
-	remoteCanceled bool
 	// remoteCompleted is set only by an explicit remote CallData completion.
 	remoteCompleted bool
-	// remoteTerminal is the first valid remote terminal.
-	remoteTerminal TerminalKind
-	// remoteTerminalSet records whether remoteTerminal is valid.
-	remoteTerminalSet bool
 }
 
 // initCommonRPC initializes the commonRPC.
@@ -124,41 +118,6 @@ func (c *commonRPC) Wait(ctx context.Context) error {
 	}
 }
 
-// WaitTerminal waits for and classifies the remote terminal of a held unary
-// invocation.
-func (c *commonRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error) {
-	var ownerDone bool
-	for {
-		locked := c.bcast.Lock()
-		if c.remoteTerminalSet {
-			terminal := c.remoteTerminal
-			locked.Unlock()
-			return terminal, nil
-		}
-		if ownerDone {
-			err := ownerCtx.Err()
-			locked.Unlock()
-			return TerminalAbandoned, err
-		}
-		waitCh := locked.WaitCh()
-		locked.Unlock()
-
-		select {
-		case <-ownerCtx.Done():
-			ownerDone = true
-		case <-waitCh:
-		}
-	}
-}
-
-// receiptTerminalKind returns the first valid remote terminal.
-func (c *commonRPC) receiptTerminalKind() (TerminalKind, bool) {
-	locked := c.bcast.Lock()
-	terminal, ok := c.remoteTerminal, c.remoteTerminalSet
-	locked.Unlock()
-	return terminal, ok
-}
-
 // ReadOne reads a single message and returns.
 //
 // returns io.EOF if the stream ended without a packet.
@@ -236,9 +195,6 @@ func (c *commonRPC) HandleStreamClose(closeErr error) {
 // HandleCallCancel handles the call cancel packet.
 func (c *commonRPC) HandleCallCancel() error {
 	locked := c.bcast.Lock()
-	if (!c.dataClosed || !c.writerClosed) && !c.remoteTerminalSet {
-		c.remoteCanceled = true
-	}
 	writer := c.handleStreamCloseLocked(&locked, context.Canceled)
 	locked.Unlock()
 	if writer != nil {
@@ -277,11 +233,7 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	if complete {
 		c.dataClosed = true
 		if len(pktErr) == 0 {
-			if c.recordRemoteTerminalLocked(TerminalCommitted) {
-				c.remoteCompleted = true
-			}
-		} else {
-			c.recordRemoteTerminalLocked(TerminalLost)
+			c.remoteCompleted = true
 		}
 	}
 
@@ -291,15 +243,6 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	return err
 }
 
-func (c *commonRPC) recordRemoteTerminalLocked(kind TerminalKind) bool {
-	if c.remoteTerminalSet {
-		return false
-	}
-	c.remoteTerminal = kind
-	c.remoteTerminalSet = true
-	return true
-}
-
 func (c *commonRPC) handleStreamCloseLocked(
 	locked *broadcast.Locked,
 	closeErr error,
@@ -307,19 +250,22 @@ func (c *commonRPC) handleStreamCloseLocked(
 	if c.dataClosed && c.writerClosed {
 		return nil
 	}
+	// A peer that closes its side reports the end of the stream. Transports
+	// disagree on whether they surface that as io.EOF or as no error at all,
+	// and it means the same thing either way, so settle it here rather than in
+	// each transport. It says nothing about whether a completion preceded it.
+	if errors.Is(closeErr, io.EOF) {
+		closeErr = nil
+	}
 	normalRemoteCloseAfterLocalComplete := closeErr == nil && (c.localCompleting || c.localDone)
 	if closeErr != nil && c.remoteErr == nil {
 		c.remoteErr = closeErr
 	}
-	if !normalRemoteCloseAfterLocalComplete && !c.remoteTerminalSet {
-		terminal := TerminalClosed
-		if closeErr != nil {
-			terminal = TerminalLost
-			if c.remoteCanceled {
-				terminal = TerminalCanceled
-			}
-		}
-		c.recordRemoteTerminalLocked(terminal)
+	// A clean close that arrives with no completion behind it leaves the call
+	// without a verdict. Reading io.EOF there says the stream ended in good
+	// order, which is the one thing we do not know.
+	if closeErr == nil && !normalRemoteCloseAfterLocalComplete && !c.remoteCompleted && c.remoteErr == nil {
+		c.remoteErr = ErrClosedBeforeCompletion
 	}
 	c.dataClosed = true
 	if !normalRemoteCloseAfterLocalComplete {

package/srpc/common-rpc.ts

@@ -3,10 +3,8 @@ import type { Sink, Source } from 'it-stream-types'
 import { pushable, type Pushable } from 'it-pushable'
 import { CompleteMessage } from '@aptre/protobuf-es-lite'
 
-import type { CallData, CallStart } from './rpcproto.pb.js'
-import { Packet } from './rpcproto.pb.js'
+import { Packet, type CallData, type CallStart } from './rpcproto.pb.js'
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js'
-import type { TerminalKind } from './server-invocation.js'
 
 const maxBufferedOutgoingPackets = 1
 
@@ -36,27 +34,15 @@ export class CommonRPC {
 
   // closed indicates this rpc has been closed already.
   private closed?: true | Error
-  // remoteCompleted is set only by an explicit remote CallData completion.
-  private remoteCompleted = false
   // remoteError records a remote error or transport failure.
   private remoteError?: Error
-  // remoteSourceClosed records an incoming source ending without a packet error.
-  private remoteSourceClosed = false
-  // remoteTerminal is the first valid remote terminal.
-  private remoteTerminal?: TerminalKind
-  // invocationController cancels the server invocation on a remote terminal.
+  // invocationController cancels the server invocation when the RPC closes.
   private readonly invocationController = new AbortController()
-  // terminalPromise resolves when a remote terminal is recorded.
-  private readonly terminalPromise: Promise<void>
-  private resolveTerminal!: () => void
 
   // writeDrainAbort wakes writers waiting for outbound stream drain on close.
   private readonly writeDrainAbort = new AbortController()
 
   constructor() {
-    const { promise, resolve } = Promise.withResolvers<void>()
-    this.terminalPromise = promise
-    this.resolveTerminal = resolve
     this.sink = this._createSink()
     this.source = this._source
     this.rpcDataSource = this._rpcDataSource
@@ -67,57 +53,11 @@ export class CommonRPC {
     return this.closed ?? false
   }
 
-  // invocationSignal is canceled when the RPC reaches a terminal.
+  // invocationSignal is canceled when the RPC closes.
   protected get invocationSignal(): AbortSignal {
     return this.invocationController.signal
   }
 
-  // waitTerminal waits for the remote terminal or external owner cancellation.
-  protected async waitTerminal(
-    ownerSignal: AbortSignal,
-  ): Promise<TerminalKind> {
-    const { promise: ownerDone, resolve: resolveOwnerDone } =
-      Promise.withResolvers<void>()
-    const onAbort = () => resolveOwnerDone()
-    ownerSignal.addEventListener('abort', onAbort, { once: true })
-    let ownerAborted = ownerSignal.aborted
-    try {
-      for (;;) {
-        const terminal = this.getTerminalKind()
-        if (terminal !== undefined) {
-          if (
-            terminal === 'closed' &&
-            this.remoteSourceClosed &&
-            !this.closed
-          ) {
-            await this.close()
-          }
-          return terminal
-        }
-        if (ownerAborted) {
-          return 'abandoned'
-        }
-        await Promise.race([this.terminalPromise, ownerDone])
-        ownerAborted = ownerSignal.aborted
-      }
-    } finally {
-      ownerSignal.removeEventListener('abort', onAbort)
-    }
-  }
-
-  // getTerminalKind returns the observed remote terminal, if any.
-  public getTerminalKind(): TerminalKind | undefined {
-    return this.remoteTerminal
-  }
-
-  private recordRemoteTerminal(kind: TerminalKind) {
-    if (this.remoteTerminal !== undefined) {
-      return
-    }
-    this.remoteTerminal = kind
-    this.resolveTerminal()
-  }
-
   // writeCallData writes the call data packet.
   public async writeCallData(
     data?: Uint8Array,
@@ -267,27 +207,21 @@ export class CommonRPC {
     }
 
     this.pushRpcData(packet.data, packet.dataIsZero)
-    const remoteError =
-      packet.error ?
-        new RemoteRPCError(this.service, this.method, packet.error)
+    const remoteError = packet.error
+      ? new RemoteRPCError(this.service, this.method, packet.error)
       : undefined
     if (remoteError) {
       this.remoteError ??= remoteError
       this.invocationController.abort()
-      this.recordRemoteTerminal('transportLost')
     }
     if (packet.complete && !remoteError) {
-      this.remoteCompleted = true
-      this.recordRemoteTerminal('committed')
       this._rpcDataSource.end(remoteError)
     } else if (remoteError) {
       this._rpcDataSource.end(remoteError)
     }
   }
-
-  // handleCallCancel handles a CallCancel packet.
+  // handleCallCancel aborts the invocation and closes the call.
   public async handleCallCancel() {
-    this.recordRemoteTerminal('canceled')
     await this.close(new Error(ERR_RPC_ABORT))
   }
 
@@ -300,7 +234,6 @@ export class CommonRPC {
     if (!this.remoteError && err) {
       this.remoteError = err
     }
-    this.recordRemoteTerminal(err ? 'transportLost' : 'closed')
     this.invocationController.abort()
     // note: this does nothing if _source is already ended.
     if (err && err.message) {
@@ -314,23 +247,18 @@ export class CommonRPC {
     this._rpcDataSource.end(err)
   }
 
-  // _createSink returns a value for the sink field.
   private _createSink(): Sink<Source<Packet>> {
     return async (source: Source<Packet>) => {
       try {
         if (Symbol.asyncIterator in source) {
-          // Handle async source
           for await (const msg of source) {
             await this.handlePacket(msg)
           }
         } else {
-          // Handle sync source
           for (const msg of source) {
             await this.handlePacket(msg)
           }
         }
-        this.remoteSourceClosed = true
-        this.recordRemoteTerminal('closed')
       } catch (err) {
         this.close(err as Error)
       }

package/srpc/common-rpc_test.go

@@ -3,6 +3,7 @@ package srpc
 import (
 	"bytes"
 	"context"
+	"errors"
 	"io"
 	"sync"
 	"sync/atomic"
@@ -423,3 +424,83 @@ func TestCommonRPCReadOneQueuedDoesNotAllocate(t *testing.T) {
 		t.Fatalf("expected queued ReadOne to avoid allocations, got %f", allocs)
 	}
 }
+
+func TestRemoteCloseWithoutCompletionNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// the transport ends the stream in good order with nothing behind it,
+	// which is what a dropped completion packet looks like from here.
+	rpc.HandleStreamClose(nil)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after a truncated stream reported %v, want the missing completion", err)
+	}
+	if errors.Is(err, io.EOF) {
+		t.Fatalf("read after a truncated stream claims the call ended in good order: %v", err)
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a truncated stream stopped satisfying a cancellation check: %v", err)
+	}
+	if got := err.Error(); got == context.Canceled.Error() {
+		t.Fatalf("read after a truncated stream still claims a cancellation happened: %q", got)
+	}
+	if err := rpc.Wait(context.Background()); !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("wait after a truncated stream reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseReportingEOFNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// rpcstream surfaces the peer's close as io.EOF rather than as no error.
+	rpc.HandleStreamClose(io.EOF)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after an EOF close reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseAfterCompletionStillEndsTheStream(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	if err := rpc.HandleCallData(&CallData{Complete: true}); err != nil {
+		t.Fatalf("handle completion: %v", err)
+	}
+	rpc.HandleStreamClose(nil)
+
+	if _, err := rpc.ReadOne(); !errors.Is(err, io.EOF) {
+		t.Fatalf("read after a completed call reported %v, want the end of the stream", err)
+	}
+}
+
+func TestClientRPCCloseReportsALocalCancellation(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	rpc.Close()
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a local close reported %v, want a cancellation", err)
+	}
+	if errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("a close this side performed was blamed on the remote: %v", err)
+	}
+}

package/srpc/errors.go

@@ -1,6 +1,9 @@
 package srpc
 
-import "errors"
+import (
+	"context"
+	"errors"
+)
 
 var (
 	// ErrReset is returned when a stream is reset.
@@ -24,3 +27,25 @@ var (
 	// ErrNilWriter is returned if the rpc writer is nil.
 	ErrNilWriter = errors.New("writer cannot be nil")
 )
+
+// ErrClosedBeforeCompletion is the error a call reports when its stream closed
+// without the remote sending a completion or an error. The call has no verdict:
+// the handler may have finished with its answer lost in the transport, or it may
+// never have run. Anything read from the call after that point fails with this.
+//
+// It unwraps to context.Canceled, which is what this case reported before the
+// distinction existed, so a caller that tests for cancellation keeps working.
+var ErrClosedBeforeCompletion error = closedBeforeCompletion{}
+
+// closedBeforeCompletion carries ErrClosedBeforeCompletion.
+type closedBeforeCompletion struct{}
+
+// Error returns the error message.
+func (closedBeforeCompletion) Error() string {
+	return "stream closed before the remote reported completion"
+}
+
+// Unwrap returns the cancellation this case reported historically.
+func (closedBeforeCompletion) Unwrap() error {
+	return context.Canceled
+}

package/srpc/handler.ts

@@ -1,13 +1,12 @@
 import type { Sink, Source } from 'it-stream-types'
 import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js'
 import { createInvokeFn } from './invoker.js'
-import type { ServerInvocation } from './server-invocation.js'
 
 // InvokeFn describes an SRPC call method invoke function.
 export type InvokeFn = (
   dataSource: Source<Uint8Array>,
   dataSink: Sink<Source<Uint8Array>>,
-  invocation?: ServerInvocation,
+  invocation?: AbortSignal,
 ) => Promise<void>
 
 // Handler describes a SRPC call handler implementation.

package/srpc/index.ts

@@ -6,10 +6,6 @@ export {
   castToError,
 } from './errors.js'
 export { Client } from './client.js'
-export { CallReceipt } from './call-receipt.js'
-export type { HeldCall, ReceiptRpc } from './call-receipt.js'
-export { ServerInvocation } from './server-invocation.js'
-export type { TerminalKind } from './server-invocation.js'
 export { Server } from './server.js'
 export { StreamConn } from './conn.js'
 export type { StreamConnParams, StreamHandler } from './conn.js'

package/srpc/invoker-prefix.go

@@ -37,4 +37,4 @@ func (i *PrefixInvoker) InvokeMethod(serviceID, methodID string, strm Stream) (b
 }
 
 // _ is a type assertion
-var _ Invoker = ((*PrefixInvoker)(nil))
+var _ Invoker = (*PrefixInvoker)(nil)

package/srpc/invoker.go

@@ -37,7 +37,7 @@ func (s InvokerSlice) InvokeMethod(serviceID, methodID string, strm Stream) (boo
 }
 
 // _ is a type assertion
-var _ Invoker = (InvokerSlice)(nil)
+var _ Invoker = InvokerSlice(nil)
 
 // InvokerFunc is a function implementing InvokeMethod.
 type InvokerFunc func(serviceID, methodID string, strm Stream) (bool, error)
@@ -52,4 +52,4 @@ func (f InvokerFunc) InvokeMethod(serviceID, methodID string, strm Stream) (bool
 	return f(serviceID, methodID, strm)
 }
 
-var _ Invoker = (InvokerFunc)(nil)
+var _ Invoker = InvokerFunc(nil)

package/srpc/invoker.ts

@@ -11,16 +11,12 @@ import { writeToPushable } from './pushable.js'
 import type { MessageType, Message } from '@aptre/protobuf-es-lite'
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite'
 
-import type { ServerInvocation } from './server-invocation.js'
 // MethodProto is a function which matches one of the RPC signatures.
 export type MethodProto<R extends Message<R>, O extends Message<O>> =
-  | ((request: R, invocation?: ServerInvocation) => Promise<O>)
-  | ((request: R, invocation?: ServerInvocation) => AsyncIterable<O>)
-  | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => Promise<O>)
-  | ((
-      request: AsyncIterable<R>,
-      invocation?: ServerInvocation,
-    ) => AsyncIterable<O>)
+  | ((request: R, invocation?: AbortSignal) => Promise<O>)
+  | ((request: R, invocation?: AbortSignal) => AsyncIterable<O>)
+  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => Promise<O>)
+  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => AsyncIterable<O>)
 
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
@@ -36,7 +32,7 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
   return async (
     dataSource: Source<Uint8Array>,
     dataSink: Sink<Source<Uint8Array>>,
-    invocation?: ServerInvocation,
+    invocation?: AbortSignal,
   ) => {
     // responseSink is a Sink for response messages.
     const responseSink = pushable<O>({

package/srpc/message.go

@@ -86,4 +86,4 @@ func (m *RawMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 }
 
 // _ is a type assertion
-var _ Message = ((*RawMessage)(nil))
+var _ Message = (*RawMessage)(nil)

package/srpc/msg-stream.go

@@ -86,13 +86,5 @@ func (r *MsgStream) Close() error {
 	return err
 }
 
-func (r *MsgStream) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := r.rw.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // _ is a type assertion
-var _ Stream = ((*MsgStream)(nil))
+var _ Stream = (*MsgStream)(nil)

package/srpc/mux-verbose.go

@@ -93,4 +93,4 @@ func (v *VMux) HasServiceMethod(serviceID, methodID string) (has bool) {
 }
 
 // _ is a type assertion
-var _ Mux = ((*VMux)(nil))
+var _ Mux = (*VMux)(nil)

package/srpc/mux.go

@@ -134,4 +134,4 @@ func (m *mux) InvokeMethod(serviceID, methodID string, strm Stream) (bool, error
 }
 
 // _ is a type assertion
-var _ Mux = ((*mux)(nil))
+var _ Mux = (*mux)(nil)

package/srpc/muxed-conn.go

@@ -6,7 +6,7 @@ import (
 	"math"
 	"net"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 )
 
 var yamuxConfigTemplate = func() yamux.Config {

package/srpc/muxed-yamux.go

@@ -3,7 +3,7 @@ package srpc
 import (
 	"context"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 )
 
 // yamuxConn wraps a yamux.Session to implement MuxedConn.