starpc 0.5.0 → 0.6.0

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

@@ -1,5 +1,4 @@
 import Long from 'long';
-import { EchoMsg as EchoMsg1 } from './echo.pb.js';
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import * as _m0 from 'protobufjs/minimal';
 export declare const protobufPackage = "echo";
@@ -23,23 +22,23 @@ export declare const EchoMsg: {
 /** Echoer service returns the given message. */
 export interface Echoer {
     /** Echo returns the given message. */
-    Echo(request: EchoMsg1): Promise<EchoMsg1>;
+    Echo(request: EchoMsg): Promise<EchoMsg>;
     /** EchoServerStream is an example of a server -> client one-way stream. */
-    EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>;
+    EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
     /** EchoClientStream is an example of client->server one-way stream. */
-    EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>;
+    EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
     /** EchoBidiStream is an example of a two-way stream. */
-    EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
     /** RpcStream opens a nested rpc call stream. */
     RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }
 export declare class EchoerClientImpl implements Echoer {
     private readonly rpc;
     constructor(rpc: Rpc);
-    Echo(request: EchoMsg1): Promise<EchoMsg1>;
-    EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>;
-    EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>;
-    EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>;
+    Echo(request: EchoMsg): Promise<EchoMsg>;
+    EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
+    EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
     RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }
 /** Echoer service returns the given message. */

package/dist/echo/echo.pb.js

@@ -1,6 +1,5 @@
 /* eslint-disable */
 import Long from 'long';
-import { EchoMsg as EchoMsg1 } from './echo.pb.js';
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import * as _m0 from 'protobufjs/minimal';
 export const protobufPackage = 'echo';
@@ -85,24 +84,24 @@ export class EchoerClientImpl {
         this.RpcStream = this.RpcStream.bind(this);
     }
     Echo(request) {
-        const data = EchoMsg1.encode(request).finish();
+        const data = EchoMsg.encode(request).finish();
         const promise = this.rpc.request('echo.Echoer', 'Echo', data);
-        return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoServerStream(request) {
-        const data = EchoMsg1.encode(request).finish();
+        const data = EchoMsg.encode(request).finish();
         const result = this.rpc.serverStreamingRequest('echo.Echoer', 'EchoServerStream', data);
-        return EchoMsg1.decodeTransform(result);
+        return EchoMsg.decodeTransform(result);
     }
     EchoClientStream(request) {
-        const data = EchoMsg1.encodeTransform(request);
+        const data = EchoMsg.encodeTransform(request);
         const promise = this.rpc.clientStreamingRequest('echo.Echoer', 'EchoClientStream', data);
-        return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoBidiStream(request) {
-        const data = EchoMsg1.encodeTransform(request);
+        const data = EchoMsg.encodeTransform(request);
         const result = this.rpc.bidirectionalStreamingRequest('echo.Echoer', 'EchoBidiStream', data);
-        return EchoMsg1.decodeTransform(result);
+        return EchoMsg.decodeTransform(result);
     }
     RpcStream(request) {
         const data = RpcStreamPacket.encodeTransform(request);
@@ -117,36 +116,36 @@ export const EchoerDefinition = {
         /** Echo returns the given message. */
         echo: {
             name: 'Echo',
-            requestType: EchoMsg1,
+            requestType: EchoMsg,
             requestStream: false,
-            responseType: EchoMsg1,
+            responseType: EchoMsg,
             responseStream: false,
             options: {},
         },
         /** EchoServerStream is an example of a server -> client one-way stream. */
         echoServerStream: {
             name: 'EchoServerStream',
-            requestType: EchoMsg1,
+            requestType: EchoMsg,
             requestStream: false,
-            responseType: EchoMsg1,
+            responseType: EchoMsg,
             responseStream: true,
             options: {},
         },
         /** EchoClientStream is an example of client->server one-way stream. */
         echoClientStream: {
             name: 'EchoClientStream',
-            requestType: EchoMsg1,
+            requestType: EchoMsg,
             requestStream: true,
-            responseType: EchoMsg1,
+            responseType: EchoMsg,
             responseStream: false,
             options: {},
         },
         /** EchoBidiStream is an example of a two-way stream. */
         echoBidiStream: {
             name: 'EchoBidiStream',
-            requestType: EchoMsg1,
+            requestType: EchoMsg,
             requestStream: true,
-            responseType: EchoMsg1,
+            responseType: EchoMsg,
             responseStream: true,
             options: {},
         },

package/dist/echo/server.js

@@ -36,7 +36,7 @@ export class EchoerServer {
             if (!this.proxyServer) {
                 throw new Error('rpc stream proxy server not set');
             }
-            return this.proxyServer;
+            return this.proxyServer.rpcStreamHandler;
         });
     }
 }

package/dist/rpcstream/rpcstream.d.ts

@@ -1,12 +1,12 @@
 import { RpcStreamPacket } from './rpcstream.pb.js';
-import { Server } from '../srpc/server.js';
 import { OpenStreamFunc, Stream } from '../srpc/stream.js';
 import { Pushable } from 'it-pushable';
-import { Source, Sink } from 'it-stream-types';
+import { Duplex, Source, Sink } from 'it-stream-types';
 export declare type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
 export declare function openRpcStream(componentId: string, caller: RpcStreamCaller): Promise<Stream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
-export declare type RpcStreamGetter = (componentId: string) => Promise<Server>;
+export declare type RpcStreamHandler = (stream: Duplex<Uint8Array>) => void;
+export declare type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
 export declare function handleRpcStream(packetStream: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements Stream {
     readonly source: Source<Uint8Array>;

package/dist/rpcstream/rpcstream.js

@@ -49,10 +49,10 @@ export async function* handleRpcStream(packetStream, getter) {
         throw new Error('expected init packet');
     }
     // lookup the server for the component id.
-    let server;
+    let handler = null;
     let err;
     try {
-        server = await getter(initRpcStreamPacket.body.init.componentId);
+        handler = await getter(initRpcStreamPacket.body.init.componentId);
     }
     catch (errAny) {
         err = errAny;
@@ -63,7 +63,7 @@ export async function* handleRpcStream(packetStream, getter) {
             err = new Error(`rpc getter failed: ${err}`);
         }
     }
-    if (!server && !err) {
+    if (!handler && !err) {
         err = new Error('not implemented');
     }
     yield* [
@@ -81,9 +81,11 @@ export async function* handleRpcStream(packetStream, getter) {
     }
     // build the outgoing packet sink & the packet source
     const packetSink = pushable({ objectMode: true });
-    // handle the stream
+    // handle the stream in the next event queue tick.
     const rpcStream = new RpcStream(packetSink, packetStream);
-    server.handleDuplex(rpcStream);
+    setTimeout(() => {
+        handler(rpcStream);
+    }, 1);
     // process packets
     for await (const packet of packetSink) {
         yield* [packet];

package/dist/rpcstream/rpcstream.pb.d.ts

@@ -1,15 +1,14 @@
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
-import { RpcStreamInit as RpcStreamInit1, RpcAck as RpcAck2 } from './rpcstream.pb.js';
 export declare const protobufPackage = "rpcstream";
 /** RpcStreamPacket is a packet encapsulating data for a RPC stream. */
 export interface RpcStreamPacket {
     body?: {
         $case: 'init';
-        init: RpcStreamInit1;
+        init: RpcStreamInit;
     } | {
         $case: 'ack';
-        ack: RpcAck2;
+        ack: RpcAck;
     } | {
         $case: 'data';
         data: Uint8Array;

package/dist/rpcstream/rpcstream.pb.js

@@ -1,7 +1,6 @@
 /* eslint-disable */
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
-import { RpcStreamInit as RpcStreamInit1, RpcAck as RpcAck2, } from './rpcstream.pb.js';
 export const protobufPackage = 'rpcstream';
 function createBaseRpcStreamPacket() {
     return { body: undefined };
@@ -9,10 +8,10 @@ function createBaseRpcStreamPacket() {
 export const RpcStreamPacket = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.body?.$case === 'init') {
-            RpcStreamInit1.encode(message.body.init, writer.uint32(10).fork()).ldelim();
+            RpcStreamInit.encode(message.body.init, writer.uint32(10).fork()).ldelim();
         }
         if (message.body?.$case === 'ack') {
-            RpcAck2.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
+            RpcAck.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
         }
         if (message.body?.$case === 'data') {
             writer.uint32(26).bytes(message.body.data);
@@ -29,13 +28,13 @@ export const RpcStreamPacket = {
                 case 1:
                     message.body = {
                         $case: 'init',
-                        init: RpcStreamInit1.decode(reader, reader.uint32()),
+                        init: RpcStreamInit.decode(reader, reader.uint32()),
                     };
                     break;
                 case 2:
                     message.body = {
                         $case: 'ack',
-                        ack: RpcAck2.decode(reader, reader.uint32()),
+                        ack: RpcAck.decode(reader, reader.uint32()),
                     };
                     break;
                 case 3:
@@ -79,9 +78,9 @@ export const RpcStreamPacket = {
     fromJSON(object) {
         return {
             body: isSet(object.init)
-                ? { $case: 'init', init: RpcStreamInit1.fromJSON(object.init) }
+                ? { $case: 'init', init: RpcStreamInit.fromJSON(object.init) }
                 : isSet(object.ack)
-                    ? { $case: 'ack', ack: RpcAck2.fromJSON(object.ack) }
+                    ? { $case: 'ack', ack: RpcAck.fromJSON(object.ack) }
                     : isSet(object.data)
                         ? { $case: 'data', data: bytesFromBase64(object.data) }
                         : undefined,
@@ -91,11 +90,11 @@ export const RpcStreamPacket = {
         const obj = {};
         message.body?.$case === 'init' &&
             (obj.init = message.body?.init
-                ? RpcStreamInit1.toJSON(message.body?.init)
+                ? RpcStreamInit.toJSON(message.body?.init)
                 : undefined);
         message.body?.$case === 'ack' &&
             (obj.ack = message.body?.ack
-                ? RpcAck2.toJSON(message.body?.ack)
+                ? RpcAck.toJSON(message.body?.ack)
                 : undefined);
         message.body?.$case === 'data' &&
             (obj.data =
@@ -111,13 +110,13 @@ export const RpcStreamPacket = {
             object.body?.init !== null) {
             message.body = {
                 $case: 'init',
-                init: RpcStreamInit1.fromPartial(object.body.init),
+                init: RpcStreamInit.fromPartial(object.body.init),
             };
         }
         if (object.body?.$case === 'ack' &&
             object.body?.ack !== undefined &&
             object.body?.ack !== null) {
-            message.body = { $case: 'ack', ack: RpcAck2.fromPartial(object.body.ack) };
+            message.body = { $case: 'ack', ack: RpcAck.fromPartial(object.body.ack) };
         }
         if (object.body?.$case === 'data' &&
             object.body?.data !== undefined &&

package/dist/srpc/index.d.ts

@@ -4,7 +4,7 @@ export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';
 export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
 export { Packet, CallStart, CallData } from './rpcproto.pb.js';
-export { Mux, createMux } from './mux.js';
+export { Mux, StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/index.js

@@ -3,7 +3,7 @@ export { Server } from './server.js';
 export { Conn } from './conn.js';
 export { createHandler, createInvokeFn } from './handler.js';
 export { Packet, CallStart, CallData } from './rpcproto.pb.js';
-export { createMux } from './mux.js';
+export { StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/rpcproto.pb.d.ts

@@ -1,15 +1,14 @@
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
-import { CallStart as CallStart1, CallData as CallData2 } from './rpcproto.pb.js';
 export declare const protobufPackage = "srpc";
 /** Packet is a message sent over a srpc packet connection. */
 export interface Packet {
     body?: {
         $case: 'callStart';
-        callStart: CallStart1;
+        callStart: CallStart;
     } | {
         $case: 'callData';
-        callData: CallData2;
+        callData: CallData;
     };
 }
 /** CallStart requests starting a new RPC call. */
@@ -94,7 +93,7 @@ export declare const Packet: {
                 rpcMethod?: string | undefined;
                 data?: Uint8Array | undefined;
                 dataIsZero?: boolean | undefined;
-            } & Record<Exclude<keyof I["body"]["callStart"], keyof CallStart1>, never>) | undefined;
+            } & Record<Exclude<keyof I["body"]["callStart"], keyof CallStart>, never>) | undefined;
             $case: "callStart";
         } & Record<Exclude<keyof I["body"], "callStart" | "$case">, never>) | ({
             callData?: {
@@ -116,7 +115,7 @@ export declare const Packet: {
                 dataIsZero?: boolean | undefined;
                 complete?: boolean | undefined;
                 error?: string | undefined;
-            } & Record<Exclude<keyof I["body"]["callData"], keyof CallData2>, never>) | undefined;
+            } & Record<Exclude<keyof I["body"]["callData"], keyof CallData>, never>) | undefined;
             $case: "callData";
         } & Record<Exclude<keyof I["body"], "callData" | "$case">, never>) | undefined;
     } & Record<Exclude<keyof I, "body">, never>>(object: I): Packet;
@@ -138,7 +137,7 @@ export declare const CallStart: {
         rpcMethod?: string | undefined;
         data?: Uint8Array | undefined;
         dataIsZero?: boolean | undefined;
-    } & Record<Exclude<keyof I, keyof CallStart1>, never>>(object: I): CallStart;
+    } & Record<Exclude<keyof I, keyof CallStart>, never>>(object: I): CallStart;
 };
 export declare const CallData: {
     encode(message: CallData, writer?: _m0.Writer): _m0.Writer;
@@ -157,7 +156,7 @@ export declare const CallData: {
         dataIsZero?: boolean | undefined;
         complete?: boolean | undefined;
         error?: string | undefined;
-    } & Record<Exclude<keyof I, keyof CallData2>, never>>(object: I): CallData;
+    } & Record<Exclude<keyof I, keyof CallData>, never>>(object: I): CallData;
 };
 declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {

package/dist/srpc/rpcproto.pb.js

@@ -1,7 +1,6 @@
 /* eslint-disable */
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
-import { CallStart as CallStart1, CallData as CallData2, } from './rpcproto.pb.js';
 export const protobufPackage = 'srpc';
 function createBasePacket() {
     return { body: undefined };
@@ -9,10 +8,10 @@ function createBasePacket() {
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.body?.$case === 'callStart') {
-            CallStart1.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
+            CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
         }
         if (message.body?.$case === 'callData') {
-            CallData2.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
+            CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
         }
         return writer;
     },
@@ -26,13 +25,13 @@ export const Packet = {
                 case 1:
                     message.body = {
                         $case: 'callStart',
-                        callStart: CallStart1.decode(reader, reader.uint32()),
+                        callStart: CallStart.decode(reader, reader.uint32()),
                     };
                     break;
                 case 2:
                     message.body = {
                         $case: 'callData',
-                        callData: CallData2.decode(reader, reader.uint32()),
+                        callData: CallData.decode(reader, reader.uint32()),
                     };
                     break;
                 default:
@@ -75,10 +74,10 @@ export const Packet = {
             body: isSet(object.callStart)
                 ? {
                     $case: 'callStart',
-                    callStart: CallStart1.fromJSON(object.callStart),
+                    callStart: CallStart.fromJSON(object.callStart),
                 }
                 : isSet(object.callData)
-                    ? { $case: 'callData', callData: CallData2.fromJSON(object.callData) }
+                    ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
                     : undefined,
         };
     },
@@ -86,11 +85,11 @@ export const Packet = {
         const obj = {};
         message.body?.$case === 'callStart' &&
             (obj.callStart = message.body?.callStart
-                ? CallStart1.toJSON(message.body?.callStart)
+                ? CallStart.toJSON(message.body?.callStart)
                 : undefined);
         message.body?.$case === 'callData' &&
             (obj.callData = message.body?.callData
-                ? CallData2.toJSON(message.body?.callData)
+                ? CallData.toJSON(message.body?.callData)
                 : undefined);
         return obj;
     },
@@ -101,7 +100,7 @@ export const Packet = {
             object.body?.callStart !== null) {
             message.body = {
                 $case: 'callStart',
-                callStart: CallStart1.fromPartial(object.body.callStart),
+                callStart: CallStart.fromPartial(object.body.callStart),
             };
         }
         if (object.body?.$case === 'callData' &&
@@ -109,7 +108,7 @@ export const Packet = {
             object.body?.callData !== null) {
             message.body = {
                 $case: 'callData',
-                callData: CallData2.fromPartial(object.body.callData),
+                callData: CallData.fromPartial(object.body.callData),
             };
         }
         return message;

package/dist/srpc/server.d.ts

@@ -4,9 +4,11 @@ import { Mux } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
 import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
+import { RpcStreamHandler } from '../rpcstream/rpcstream.js';
 export declare class Server implements StreamHandler {
     private mux;
     constructor(mux: Mux);
+    get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;
     handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;

package/dist/srpc/server.js

@@ -6,6 +6,10 @@ export class Server {
     constructor(mux) {
         this.mux = mux;
     }
+    // rpcStreamHandler implements the RpcStreamHandler interface.
+    get rpcStreamHandler() {
+        return this.handleDuplex.bind(this);
+    }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.
     startRpc() {

package/echo/echo.pb.ts

@@ -1,6 +1,5 @@
 /* eslint-disable */
 import Long from 'long'
-import { EchoMsg as EchoMsg1 } from './echo.pb.js'
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
 import * as _m0 from 'protobufjs/minimal'
 
@@ -100,13 +99,13 @@ export const EchoMsg = {
 /** Echoer service returns the given message. */
 export interface Echoer {
   /** Echo returns the given message. */
-  Echo(request: EchoMsg1): Promise<EchoMsg1>
+  Echo(request: EchoMsg): Promise<EchoMsg>
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>
   /** RpcStream opens a nested rpc call stream. */
   RpcStream(
     request: AsyncIterable<RpcStreamPacket>
@@ -123,40 +122,40 @@ export class EchoerClientImpl implements Echoer {
     this.EchoBidiStream = this.EchoBidiStream.bind(this)
     this.RpcStream = this.RpcStream.bind(this)
   }
-  Echo(request: EchoMsg1): Promise<EchoMsg1> {
-    const data = EchoMsg1.encode(request).finish()
+  Echo(request: EchoMsg): Promise<EchoMsg> {
+    const data = EchoMsg.encode(request).finish()
     const promise = this.rpc.request('echo.Echoer', 'Echo', data)
-    return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)))
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1> {
-    const data = EchoMsg1.encode(request).finish()
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
+    const data = EchoMsg.encode(request).finish()
     const result = this.rpc.serverStreamingRequest(
       'echo.Echoer',
       'EchoServerStream',
       data
     )
-    return EchoMsg1.decodeTransform(result)
+    return EchoMsg.decodeTransform(result)
   }
 
-  EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1> {
-    const data = EchoMsg1.encodeTransform(request)
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
+    const data = EchoMsg.encodeTransform(request)
     const promise = this.rpc.clientStreamingRequest(
       'echo.Echoer',
       'EchoClientStream',
       data
     )
-    return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)))
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1> {
-    const data = EchoMsg1.encodeTransform(request)
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
+    const data = EchoMsg.encodeTransform(request)
     const result = this.rpc.bidirectionalStreamingRequest(
       'echo.Echoer',
       'EchoBidiStream',
       data
     )
-    return EchoMsg1.decodeTransform(result)
+    return EchoMsg.decodeTransform(result)
   }
 
   RpcStream(
@@ -181,36 +180,36 @@ export const EchoerDefinition = {
     /** Echo returns the given message. */
     echo: {
       name: 'Echo',
-      requestType: EchoMsg1,
+      requestType: EchoMsg,
       requestStream: false,
-      responseType: EchoMsg1,
+      responseType: EchoMsg,
       responseStream: false,
       options: {},
     },
     /** EchoServerStream is an example of a server -> client one-way stream. */
     echoServerStream: {
       name: 'EchoServerStream',
-      requestType: EchoMsg1,
+      requestType: EchoMsg,
       requestStream: false,
-      responseType: EchoMsg1,
+      responseType: EchoMsg,
       responseStream: true,
       options: {},
     },
     /** EchoClientStream is an example of client->server one-way stream. */
     echoClientStream: {
       name: 'EchoClientStream',
-      requestType: EchoMsg1,
+      requestType: EchoMsg,
       requestStream: true,
-      responseType: EchoMsg1,
+      responseType: EchoMsg,
       responseStream: false,
       options: {},
     },
     /** EchoBidiStream is an example of a two-way stream. */
     echoBidiStream: {
       name: 'EchoBidiStream',
-      requestType: EchoMsg1,
+      requestType: EchoMsg,
       requestStream: true,
-      responseType: EchoMsg1,
+      responseType: EchoMsg,
       responseStream: true,
       options: {},
     },

package/echo/server.ts

@@ -4,7 +4,7 @@ import first from 'it-first'
 import { Server } from '../srpc/server.js'
 import { writeToPushable } from '../srpc/pushable.js'
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
-import { handleRpcStream } from '../rpcstream/rpcstream.js'
+import { handleRpcStream, RpcStreamHandler } from '../rpcstream/rpcstream.js'
 
 // EchoServer implements the Echoer server.
 export class EchoerServer implements Echoer {
@@ -52,11 +52,11 @@ export class EchoerServer implements Echoer {
   ): AsyncIterable<RpcStreamPacket> {
     return handleRpcStream(
       request[Symbol.asyncIterator](),
-      async (_componentId: string): Promise<Server> => {
+      async (_componentId: string): Promise<RpcStreamHandler> => {
         if (!this.proxyServer) {
           throw new Error('rpc stream proxy server not set')
         }
-        return this.proxyServer
+        return this.proxyServer.rpcStreamHandler
       }
     )
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -35,7 +35,7 @@
   "scripts": {
     "build": "rimraf ./dist && tsc --project tsconfig.build.json --outDir ./dist/",
     "check": "tsc",
-    "deps": "depcheck",
+    "deps": "depcheck --ignores 'bufferutil,utf-8-validate'",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
     "format": "prettier --write './{srpc,echo,e2e,integration,rpcstream}/**/(*.ts|*.tsx|*.html|*.css)'",
@@ -58,16 +58,18 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.30.0",
-    "@typescript-eslint/parser": "^5.30.0",
+    "@typescript-eslint/eslint-plugin": "^5.30.3",
+    "@typescript-eslint/parser": "^5.30.3",
+    "bufferutil": "^4.0.6",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.14.47",
+    "esbuild": "^0.14.48",
     "eslint": "^8.18.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.115.5",
-    "typescript": "^4.7.4"
+    "ts-proto": "^1.116.1",
+    "typescript": "^4.7.4",
+    "utf-8-validate": "^5.0.9"
   },
   "dependencies": {
     "@libp2p/interface-connection": "^2.1.1",