starpc 0.12.1 → 0.12.3

package/Makefile

@@ -2,7 +2,7 @@
 
 PROTOWRAP=hack/bin/protowrap
 PROTOC_GEN_GO=hack/bin/protoc-gen-go
-PROTOC_GEN_GO_STARPC=hack/bin/protoc-gen-go-starpc
+PROTOC_GEN_STARPC=hack/bin/protoc-gen-go-starpc
 PROTOC_GEN_VTPROTO=hack/bin/protoc-gen-go-vtproto
 GOIMPORTS=hack/bin/goimports
 GOLANGCI_LINT=hack/bin/golangci-lint
@@ -24,18 +24,18 @@ $(PROTOC_GEN_GO):
 		-o ./bin/protoc-gen-go \
 		google.golang.org/protobuf/cmd/protoc-gen-go
 
-$(PROTOC_GEN_GO_STARPC):
-	cd ./hack; \
-	go build -v \
-		-o ./bin/protoc-gen-go-starpc \
-		github.com/aperturerobotics/starpc/cmd/protoc-gen-go-starpc
-
 $(PROTOC_GEN_VTPROTO):
 	cd ./hack; \
 	go build -v \
 		-o ./bin/protoc-gen-go-vtproto \
 		github.com/planetscale/vtprotobuf/cmd/protoc-gen-go-vtproto
 
+$(PROTOC_GEN_STARPC):
+	cd ./hack; \
+	go build -v \
+		-o ./bin/protoc-gen-go-starpc \
+		github.com/aperturerobotics/starpc/cmd/protoc-gen-go-starpc
+
 $(GOIMPORTS):
 	cd ./hack; \
 	go build -v \
@@ -46,7 +46,7 @@ $(PROTOWRAP):
 	cd ./hack; \
 	go build -v \
 		-o ./bin/protowrap \
-		github.com/square/goprotowrap/cmd/protowrap
+		github.com/aperturerobotics/goprotowrap/cmd/protowrap
 
 $(GOLANGCI_LINT):
 	cd ./hack; \
@@ -61,7 +61,7 @@ $(GO_MOD_OUTDATED):
 		github.com/psampaz/go-mod-outdated
 
 .PHONY: gengo
-gengo: $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTOC_GEN_GO_STARPC) $(PROTOC_GEN_VTPROTO)
+gengo: $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTOC_GEN_VTPROTO) $(PROTOC_GEN_STARPC)
 	go mod vendor
 	shopt -s globstar; \
 	set -eo pipefail; \
@@ -73,9 +73,9 @@ gengo: $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTOC_GEN_GO_STARPC) $(PROT
 	$(PROTOWRAP) \
 		-I $$(pwd)/vendor \
 		--go_out=$$(pwd)/vendor \
-		--go-starpc_out=$$(pwd)/vendor \
 		--go-vtproto_out=$$(pwd)/vendor \
-		--go-vtproto_opt=features=marshal+unmarshal+size+equal \
+		--go-vtproto_opt=features=marshal+unmarshal+size+equal+clone \
+		--go-starpc_out=$$(pwd)/vendor \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \
 		--only_specified_files \
@@ -110,6 +110,7 @@ gents: $(PROTOWRAP) node_modules
 		--ts_proto_opt=forceLong=long \
 		--ts_proto_opt=oneof=unions \
 		--ts_proto_opt=outputServices=default,outputServices=generic-definitions \
+		--ts_proto_opt=useDate=true \
 		--ts_proto_opt=useAsyncIterable=true \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \

package/README.md

@@ -185,7 +185,7 @@ const result = await demoServiceClient.Echo({
 console.log('output', result.body)
 ```
 
-# Attribution
+## Attribution
 
 `protoc-gen-go-starpc` is a heavily modified version of `protoc-gen-go-drpc`.
 
@@ -199,15 +199,11 @@ Uses [vtprotobuf] to generate Protobuf marshal / unmarshal code.
 
 ## Support
 
-Starpc is built & supported by Aperture Robotics, LLC.
-
-Community contributions and discussion are welcomed!
-
-Please open a [GitHub issue] with any questions / issues.
+Please file a [GitHub issue] and/or [Join Discord] with any questions.
 
 [GitHub issue]: https://github.com/aperturerobotics/starpc/issues/new
 
-... or feel free to reach out on [Matrix Chat] or [Discord].
+... or feel free to reach out on [Matrix Chat].
 
-[Discord]: https://discord.gg/KJutMESRsT
+[Join Discord]: https://discord.gg/KJutMESRsT
 [Matrix Chat]: https://matrix.to/#/#aperturerobotics:matrix.org

package/dist/echo/echo.pb.d.ts

@@ -35,7 +35,9 @@ export interface Echoer {
 export declare class EchoerClientImpl implements Echoer {
     private readonly rpc;
     private readonly service;
-    constructor(rpc: Rpc, service?: string);
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
     Echo(request: EchoMsg): Promise<EchoMsg>;
     EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
     EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;

package/dist/echo/echo.pb.js

@@ -73,8 +73,8 @@ export const EchoMsg = {
     },
 };
 export class EchoerClientImpl {
-    constructor(rpc, service) {
-        this.service = service || "echo.Echoer";
+    constructor(rpc, opts) {
+        this.service = opts?.service || "echo.Echoer";
         this.rpc = rpc;
         this.Echo = this.Echo.bind(this);
         this.EchoServerStream = this.EchoServerStream.bind(this);

package/dist/srpc/conn.js

@@ -1,5 +1,5 @@
 import { pipe } from 'it-pipe';
-import { Mplex } from '@libp2p/mplex';
+import { mplex } from '@libp2p/mplex';
 import isPromise from 'is-promise';
 import { Client } from './client.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
@@ -21,7 +21,7 @@ export class Conn {
         }
         let muxerFactory = connParams?.muxerFactory;
         if (!muxerFactory) {
-            muxerFactory = new Mplex();
+            muxerFactory = mplex()();
         }
         this.muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),

package/dist/srpc/websocket.js

@@ -1,13 +1,13 @@
 import { duplex } from 'it-ws';
 import { pipe } from 'it-pipe';
-import { Mplex } from '@libp2p/mplex';
+import { mplex } from '@libp2p/mplex';
 import { Conn } from './conn.js';
 // WebSocketConn implements a connection with a WebSocket and optional Server.
 export class WebSocketConn extends Conn {
     constructor(socket, direction, server) {
         super(server, {
             direction,
-            muxerFactory: new Mplex(),
+            muxerFactory: mplex()(),
         });
         this.socket = socket;
         const socketDuplex = duplex(socket);

package/echo/echo.pb.ts

@@ -106,8 +106,8 @@ export interface Echoer {
 export class EchoerClientImpl implements Echoer {
   private readonly rpc: Rpc;
   private readonly service: string;
-  constructor(rpc: Rpc, service?: string) {
-    this.service = service || "echo.Echoer";
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || "echo.Echoer";
     this.rpc = rpc;
     this.Echo = this.Echo.bind(this);
     this.EchoServerStream = this.EchoServerStream.bind(this);

package/echo/echo_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.9.2
+// protoc-gen-srpc version: v0.12.3-0.20221016080028-3e0cb248fdee
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/echo/echo_vtproto.pb.go

@@ -9,6 +9,7 @@ import (
 	io "io"
 	bits "math/bits"
 
+	proto "google.golang.org/protobuf/proto"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
@@ -19,6 +20,24 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+func (m *EchoMsg) CloneVT() *EchoMsg {
+	if m == nil {
+		return (*EchoMsg)(nil)
+	}
+	r := &EchoMsg{
+		Body: m.Body,
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *EchoMsg) CloneGenericVT() proto.Message {
+	return m.CloneVT()
+}
+
 func (this *EchoMsg) EqualVT(that *EchoMsg) bool {
 	if this == nil {
 		return that == nil

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -59,36 +59,36 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.40.0",
-    "@typescript-eslint/parser": "^5.40.0",
-    "bufferutil": "^4.0.6",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.41.0",
+    "bufferutil": "^4.0.7",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.15.10",
-    "eslint": "^8.25.0",
+    "esbuild": "^0.15.12",
+    "eslint": "^8.26.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.126.1",
+    "ts-proto": "^1.130.0",
     "typescript": "^4.8.4",
-    "utf-8-validate": "^5.0.9"
+    "utf-8-validate": "^5.0.10"
   },
   "dependencies": {
     "@libp2p/interface-connection": "^3.0.2",
     "@libp2p/interface-stream-muxer": "^3.0.0",
-    "@libp2p/mplex": "^6.0.2",
+    "@libp2p/mplex": "^7.0.0",
     "event-iterator": "^2.0.0",
     "is-promise": "^4.0.0",
     "isomorphic-ws": "^5.0.0",
-    "it-first": "^1.0.7",
-    "it-length-prefixed": "^8.0.2",
+    "it-first": "^2.0.0",
+    "it-length-prefixed": "^8.0.3",
     "it-pipe": "^2.0.4",
     "it-pushable": "^3.1.0",
     "it-stream-types": "^1.0.4",
-    "it-ws": "^5.0.2",
+    "it-ws": "^5.0.3",
     "long": "^5.2.0",
-    "patch-package": "^6.4.7",
+    "patch-package": "^6.5.0",
     "protobufjs": "^7.1.2",
-    "uint8arraylist": "^2.3.2",
-    "ws": "^8.9.0"
+    "uint8arraylist": "^2.3.3",
+    "ws": "^8.10.0"
   }
 }

package/srpc/client-rpc.go

@@ -185,5 +185,7 @@ func (r *ClientRPC) HandleCallData(pkt *CallData) error {
 // not concurrency safe with HandlePacket.
 func (r *ClientRPC) Close() {
 	r.ctxCancel()
-	_ = r.writer.Close()
+	if r.writer != nil {
+		_ = r.writer.Close()
+	}
 }

package/srpc/client-set.go

@@ -0,0 +1,79 @@
+package srpc
+
+import (
+	"context"
+	"errors"
+)
+
+// ClientSet wraps a list of clients into one Client.
+type ClientSet struct {
+	clients []Client
+}
+
+// NewClientSet constructs a new client set.
+func NewClientSet(clients []Client) *ClientSet {
+	return &ClientSet{clients: clients}
+}
+
+// ExecCall executes a request/reply RPC with the remote.
+func (c *ClientSet) ExecCall(
+	ctx context.Context,
+	service, method string,
+	in, out Message,
+) error {
+	return c.execCall(ctx, func(client Client) error {
+		return client.ExecCall(ctx, service, method, in, out)
+	})
+}
+
+// NewStream starts a streaming RPC with the remote & returns the stream.
+// firstMsg is optional.
+func (c *ClientSet) NewStream(
+	ctx context.Context,
+	service, method string,
+	firstMsg Message,
+) (Stream, error) {
+	var strm Stream
+	err := c.execCall(ctx, func(client Client) error {
+		var err error
+		strm, err = client.NewStream(ctx, service, method, firstMsg)
+		return err
+	})
+	return strm, err
+}
+
+// execCall executes the call conditionally retrying against subsequent client handles.
+func (c *ClientSet) execCall(ctx context.Context, doCall func(client Client) error) error {
+	var any bool
+	for _, client := range c.clients {
+		if client == nil {
+			continue
+		}
+		err := doCall(client)
+		any = true
+		if err == nil {
+			return nil
+		}
+		if err == context.Canceled {
+			select {
+			case <-ctx.Done():
+				return context.Canceled
+			default:
+				continue
+			}
+		}
+		if err.Error() == ErrUnimplemented.Error() {
+			continue
+		}
+		return err
+	}
+
+	if !any {
+		return errors.New("no available rpc clients")
+	}
+
+	return ErrUnimplemented
+}
+
+// _ is a type assertion
+var _ Client = ((*ClientSet)(nil))

package/srpc/client.go

@@ -87,7 +87,7 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 		return nil, err
 	}
 
-	return NewMsgStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
+	return NewMsgStream(ctx, clientRPC.writer, clientRPC.dataCh, clientRPC.ctxCancel), nil
 }
 
 // _ is a type assertion

package/srpc/conn.ts

@@ -5,7 +5,7 @@ import type {
 } from '@libp2p/interface-stream-muxer'
 import { pipe } from 'it-pipe'
 import type { Duplex } from 'it-stream-types'
-import { Mplex } from '@libp2p/mplex'
+import { mplex } from '@libp2p/mplex'
 import { Uint8ArrayList } from 'uint8arraylist'
 import isPromise from 'is-promise'
 
@@ -55,7 +55,7 @@ export class Conn implements Duplex<Uint8Array> {
     }
     let muxerFactory = connParams?.muxerFactory
     if (!muxerFactory) {
-      muxerFactory = new Mplex()
+      muxerFactory = mplex()()
     }
     this.muxer = muxerFactory.createStreamMuxer({
       onIncomingStream: this.handleIncomingStream.bind(this),

package/srpc/msg-stream.go

@@ -3,6 +3,7 @@ package srpc
 import (
 	"context"
 	"io"
+	"sync/atomic"
 )
 
 // MsgStream implements the stream interface passed to implementations.
@@ -13,15 +14,25 @@ type MsgStream struct {
 	writer Writer
 	// dataCh is the incoming data channel.
 	dataCh chan []byte
+	// closeCb is the close callback
+	closeCb func()
+	// sendClosed indicates sending is closed.
+	sendClosed atomic.Bool
 }
 
 // NewMsgStream constructs a new Stream with a ClientRPC.
 // dataCh should be closed when no more messages will arrive.
-func NewMsgStream(ctx context.Context, writer Writer, dataCh chan []byte) *MsgStream {
+func NewMsgStream(
+	ctx context.Context,
+	writer Writer,
+	dataCh chan []byte,
+	closeCb func(),
+) *MsgStream {
 	return &MsgStream{
-		ctx:    ctx,
-		writer: writer,
-		dataCh: dataCh,
+		ctx:     ctx,
+		writer:  writer,
+		dataCh:  dataCh,
+		closeCb: closeCb,
 	}
 }
 
@@ -32,6 +43,9 @@ func (r *MsgStream) Context() context.Context {
 
 // MsgSend sends the message to the remote.
 func (r *MsgStream) MsgSend(msg Message) error {
+	if r.sendClosed.Load() {
+		return context.Canceled
+	}
 	select {
 	case <-r.ctx.Done():
 		return context.Canceled
@@ -62,14 +76,34 @@ func (r *MsgStream) MsgRecv(msg Message) error {
 
 // CloseSend signals to the remote that we will no longer send any messages.
 func (r *MsgStream) CloseSend() error {
-	outPkt := NewCallDataPacket(nil, false, true, nil)
-	return r.writer.WritePacket(outPkt)
+	// if already closed, return
+	if r.sendClosed.Swap(true) {
+		return nil
+	}
+
+	return r.closeSend()
 }
 
 // Close closes the stream.
 func (r *MsgStream) Close() error {
-	_ = r.writer.Close()
-	return nil
+	// if already closed, return
+	if r.sendClosed.Swap(true) {
+		return nil
+	}
+
+	// don't close the writer: we will need to write the call result after the
+	// RPC function returns.
+	if r.closeCb != nil {
+		r.closeCb()
+	}
+
+	return r.closeSend()
+}
+
+// closeSend writes the CloseSend packet.
+func (r *MsgStream) closeSend() error {
+	outPkt := NewCallDataPacket(nil, false, true, nil)
+	return r.writer.WritePacket(outPkt)
 }
 
 // _ is a type assertion

package/srpc/mux.go

@@ -20,6 +20,9 @@ type muxMethods map[string]Handler
 
 // mux is the default implementation of Mux.
 type mux struct {
+	// fallback is the list of fallback invokers
+	// if the mux doesn't match the service, calls the invokers.
+	fallback []Invoker
 	// rmtx guards below fields
 	rmtx sync.RWMutex
 	// services contains a mapping from services to handlers.
@@ -27,8 +30,14 @@ type mux struct {
 }
 
 // NewMux constructs a new Mux.
-func NewMux() Mux {
-	return &mux{services: make(map[string]muxMethods)}
+//
+// fallbackInvokers is the list of fallback Invokers to call in the case that
+// the service/method is not found on this mux.
+func NewMux(fallbackInvokers ...Invoker) Mux {
+	return &mux{
+		fallback: fallbackInvokers,
+		services: make(map[string]muxMethods),
+	}
 }
 
 // Register registers a new RPC method handler (service).
@@ -95,17 +104,34 @@ func (m *mux) HasServiceMethod(serviceID, methodID string) bool {
 func (m *mux) InvokeMethod(serviceID, methodID string, strm Stream) (bool, error) {
 	var handler Handler
 	m.rmtx.RLock()
-	svcMethods := m.services[serviceID]
-	if svcMethods != nil {
-		handler = svcMethods[methodID]
+	if serviceID == "" {
+		for _, svc := range m.services {
+			if handler = svc[methodID]; handler != nil {
+				break
+			}
+		}
+	} else {
+		svcMethods := m.services[serviceID]
+		if svcMethods != nil {
+			handler = svcMethods[methodID]
+		}
 	}
 	m.rmtx.RUnlock()
 
-	if handler == nil {
-		return false, nil
+	if handler != nil {
+		return handler.InvokeMethod(serviceID, methodID, strm)
+	}
+
+	for _, invoker := range m.fallback {
+		if invoker != nil {
+			handled, err := invoker.InvokeMethod(serviceID, methodID, strm)
+			if err != nil || handled {
+				return handled, err
+			}
+		}
 	}
 
-	return handler.InvokeMethod(serviceID, methodID, strm)
+	return false, nil
 }
 
 // _ is a type assertion

package/srpc/packet-rw.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/binary"
 	"io"
+	"sync"
 
 	"github.com/pkg/errors"
 )
@@ -19,6 +20,8 @@ type PacketReaderWriter struct {
 	rw io.ReadWriteCloser
 	// buf is the buffered data
 	buf bytes.Buffer
+	// writeMtx is the write mutex
+	writeMtx sync.Mutex
 }
 
 // NewPacketReadWriter constructs a new read/writer.
@@ -28,6 +31,9 @@ func NewPacketReadWriter(rw io.ReadWriteCloser) *PacketReaderWriter {
 
 // WritePacket writes a packet to the writer.
 func (r *PacketReaderWriter) WritePacket(p *Packet) error {
+	r.writeMtx.Lock()
+	defer r.writeMtx.Unlock()
+
 	msgSize := p.SizeVT()
 	data := make([]byte, 4+msgSize)
 	binary.LittleEndian.PutUint32(data, uint32(msgSize))

package/srpc/rpcproto_vtproto.pb.go

@@ -9,6 +9,7 @@ import (
 	io "io"
 	bits "math/bits"
 
+	proto "google.golang.org/protobuf/proto"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
@@ -19,6 +20,95 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+func (m *Packet) CloneVT() *Packet {
+	if m == nil {
+		return (*Packet)(nil)
+	}
+	r := &Packet{}
+	if m.Body != nil {
+		r.Body = m.Body.(interface{ CloneVT() isPacket_Body }).CloneVT()
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Packet) CloneGenericVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Packet_CallStart) CloneVT() isPacket_Body {
+	if m == nil {
+		return (*Packet_CallStart)(nil)
+	}
+	r := &Packet_CallStart{
+		CallStart: m.CallStart.CloneVT(),
+	}
+	return r
+}
+
+func (m *Packet_CallData) CloneVT() isPacket_Body {
+	if m == nil {
+		return (*Packet_CallData)(nil)
+	}
+	r := &Packet_CallData{
+		CallData: m.CallData.CloneVT(),
+	}
+	return r
+}
+
+func (m *CallStart) CloneVT() *CallStart {
+	if m == nil {
+		return (*CallStart)(nil)
+	}
+	r := &CallStart{
+		RpcService: m.RpcService,
+		RpcMethod:  m.RpcMethod,
+		DataIsZero: m.DataIsZero,
+	}
+	if rhs := m.Data; rhs != nil {
+		tmpBytes := make([]byte, len(rhs))
+		copy(tmpBytes, rhs)
+		r.Data = tmpBytes
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CallStart) CloneGenericVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *CallData) CloneVT() *CallData {
+	if m == nil {
+		return (*CallData)(nil)
+	}
+	r := &CallData{
+		DataIsZero: m.DataIsZero,
+		Complete:   m.Complete,
+		Error:      m.Error,
+	}
+	if rhs := m.Data; rhs != nil {
+		tmpBytes := make([]byte, len(rhs))
+		copy(tmpBytes, rhs)
+		r.Data = tmpBytes
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *CallData) CloneGenericVT() proto.Message {
+	return m.CloneVT()
+}
+
 func (this *Packet) EqualVT(that *Packet) bool {
 	if this == nil {
 		return that == nil

package/srpc/server-rpc.go

@@ -164,7 +164,7 @@ func (r *ServerRPC) HandleCallData(pkt *CallData) error {
 func (r *ServerRPC) invokeRPC() {
 	// ctx := r.ctx
 	serviceID, methodID := r.service, r.method
-	strm := NewMsgStream(r.ctx, r.writer, r.dataCh)
+	strm := NewMsgStream(r.ctx, r.writer, r.dataCh, r.ctxCancel)
 	ok, err := r.invoker.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented
@@ -181,7 +181,7 @@ func (r *ServerRPC) Close() {
 	if r.clientErr == nil {
 		r.clientErr = context.Canceled
 	}
-	if r.service == "" {
+	if r.writer != nil && r.service == "" {
 		// invokeRPC has not been called, otherwise it would call Close()
 		_ = r.writer.Close()
 	}

package/srpc/websocket.ts

@@ -1,6 +1,6 @@
 import { duplex } from 'it-ws'
 import { pipe } from 'it-pipe'
-import { Mplex } from '@libp2p/mplex'
+import { mplex } from '@libp2p/mplex'
 import { Direction } from '@libp2p/interface-connection'
 import type WebSocket from 'isomorphic-ws'
 
@@ -15,7 +15,7 @@ export class WebSocketConn extends Conn {
   constructor(socket: WebSocket, direction: Direction, server?: Server) {
     super(server, {
       direction,
-      muxerFactory: new Mplex(),
+      muxerFactory: mplex()(),
     })
     this.socket = socket
     const socketDuplex = duplex(socket)