starpc 0.10.9 → 0.11.0

package/dist/srpc/rpcproto.pb.js

@@ -1,16 +1,16 @@
 /* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-export const protobufPackage = "srpc";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+export const protobufPackage = 'srpc';
 function createBasePacket() {
     return { body: undefined };
 }
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === "callStart") {
+        if (message.body?.$case === 'callStart') {
             CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
         }
-        if (message.body?.$case === "callData") {
+        if (message.body?.$case === 'callData') {
             CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
         }
         return writer;
@@ -23,10 +23,16 @@ export const Packet = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.body = { $case: "callStart", callStart: CallStart.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'callStart',
+                        callStart: CallStart.decode(reader, reader.uint32()),
+                    };
                     break;
                 case 2:
-                    message.body = { $case: "callData", callData: CallData.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'callData',
+                        callData: CallData.decode(reader, reader.uint32()),
+                    };
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -66,40 +72,62 @@ export const Packet = {
     fromJSON(object) {
         return {
             body: isSet(object.callStart)
-                ? { $case: "callStart", callStart: CallStart.fromJSON(object.callStart) }
+                ? {
+                    $case: 'callStart',
+                    callStart: CallStart.fromJSON(object.callStart),
+                }
                 : isSet(object.callData)
-                    ? { $case: "callData", callData: CallData.fromJSON(object.callData) }
+                    ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
                     : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        message.body?.$case === "callStart" &&
-            (obj.callStart = message.body?.callStart ? CallStart.toJSON(message.body?.callStart) : undefined);
-        message.body?.$case === "callData" &&
-            (obj.callData = message.body?.callData ? CallData.toJSON(message.body?.callData) : undefined);
+        message.body?.$case === 'callStart' &&
+            (obj.callStart = message.body?.callStart
+                ? CallStart.toJSON(message.body?.callStart)
+                : undefined);
+        message.body?.$case === 'callData' &&
+            (obj.callData = message.body?.callData
+                ? CallData.toJSON(message.body?.callData)
+                : undefined);
         return obj;
     },
     fromPartial(object) {
         const message = createBasePacket();
-        if (object.body?.$case === "callStart" && object.body?.callStart !== undefined && object.body?.callStart !== null) {
-            message.body = { $case: "callStart", callStart: CallStart.fromPartial(object.body.callStart) };
+        if (object.body?.$case === 'callStart' &&
+            object.body?.callStart !== undefined &&
+            object.body?.callStart !== null) {
+            message.body = {
+                $case: 'callStart',
+                callStart: CallStart.fromPartial(object.body.callStart),
+            };
         }
-        if (object.body?.$case === "callData" && object.body?.callData !== undefined && object.body?.callData !== null) {
-            message.body = { $case: "callData", callData: CallData.fromPartial(object.body.callData) };
+        if (object.body?.$case === 'callData' &&
+            object.body?.callData !== undefined &&
+            object.body?.callData !== null) {
+            message.body = {
+                $case: 'callData',
+                callData: CallData.fromPartial(object.body.callData),
+            };
         }
         return message;
     },
 };
 function createBaseCallStart() {
-    return { rpcService: "", rpcMethod: "", data: new Uint8Array(), dataIsZero: false };
+    return {
+        rpcService: '',
+        rpcMethod: '',
+        data: new Uint8Array(),
+        dataIsZero: false,
+    };
 }
 export const CallStart = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.rpcService !== "") {
+        if (message.rpcService !== '') {
             writer.uint32(10).string(message.rpcService);
         }
-        if (message.rpcMethod !== "") {
+        if (message.rpcMethod !== '') {
             writer.uint32(18).string(message.rpcMethod);
         }
         if (message.data.length !== 0) {
@@ -166,9 +194,11 @@ export const CallStart = {
     },
     fromJSON(object) {
         return {
-            rpcService: isSet(object.rpcService) ? String(object.rpcService) : "",
-            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : "",
-            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+            rpcService: isSet(object.rpcService) ? String(object.rpcService) : '',
+            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : '',
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
         };
     },
@@ -183,15 +213,20 @@ export const CallStart = {
     },
     fromPartial(object) {
         const message = createBaseCallStart();
-        message.rpcService = object.rpcService ?? "";
-        message.rpcMethod = object.rpcMethod ?? "";
+        message.rpcService = object.rpcService ?? '';
+        message.rpcMethod = object.rpcMethod ?? '';
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         return message;
     },
 };
 function createBaseCallData() {
-    return { data: new Uint8Array(), dataIsZero: false, complete: false, error: "" };
+    return {
+        data: new Uint8Array(),
+        dataIsZero: false,
+        complete: false,
+        error: '',
+    };
 }
 export const CallData = {
     encode(message, writer = _m0.Writer.create()) {
@@ -204,7 +239,7 @@ export const CallData = {
         if (message.complete === true) {
             writer.uint32(24).bool(message.complete);
         }
-        if (message.error !== "") {
+        if (message.error !== '') {
             writer.uint32(34).string(message.error);
         }
         return writer;
@@ -265,10 +300,12 @@ export const CallData = {
     },
     fromJSON(object) {
         return {
-            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
             complete: isSet(object.complete) ? Boolean(object.complete) : false,
-            error: isSet(object.error) ? String(object.error) : "",
+            error: isSet(object.error) ? String(object.error) : '',
         };
     },
     toJSON(message) {
@@ -285,28 +322,28 @@ export const CallData = {
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         message.complete = object.complete ?? false;
-        message.error = object.error ?? "";
+        message.error = object.error ?? '';
         return message;
     },
 };
 var globalThis = (() => {
-    if (typeof globalThis !== "undefined") {
+    if (typeof globalThis !== 'undefined') {
         return globalThis;
     }
-    if (typeof self !== "undefined") {
+    if (typeof self !== 'undefined') {
         return self;
     }
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
         return window;
     }
-    if (typeof global !== "undefined") {
+    if (typeof global !== 'undefined') {
         return global;
     }
-    throw "Unable to locate global object";
+    throw 'Unable to locate global object';
 })();
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
     }
     else {
         const bin = globalThis.atob(b64);
@@ -319,14 +356,14 @@ function bytesFromBase64(b64) {
 }
 function base64FromBytes(arr) {
     if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString("base64");
+        return globalThis.Buffer.from(arr).toString('base64');
     }
     else {
         const bin = [];
         arr.forEach((byte) => {
             bin.push(String.fromCharCode(byte));
         });
-        return globalThis.btoa(bin.join(""));
+        return globalThis.btoa(bin.join(''));
     }
 }
 if (_m0.util.Long !== Long) {

package/echo/echo.pb.ts

@@ -1,57 +1,60 @@
 /* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-import { RpcStreamPacket } from "../rpcstream/rpcstream.pb.js";
+import Long from 'long'
+import _m0 from 'protobufjs/minimal.js'
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
 
-export const protobufPackage = "echo";
+export const protobufPackage = 'echo'
 
 /** EchoMsg is the message body for Echo. */
 export interface EchoMsg {
-  body: string;
+  body: string
 }
 
 function createBaseEchoMsg(): EchoMsg {
-  return { body: "" };
+  return { body: '' }
 }
 
 export const EchoMsg = {
-  encode(message: EchoMsg, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.body !== "") {
-      writer.uint32(10).string(message.body);
+  encode(
+    message: EchoMsg,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.body !== '') {
+      writer.uint32(10).string(message.body)
     }
-    return writer;
+    return writer
   },
 
   decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseEchoMsg();
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    let end = length === undefined ? reader.len : reader.pos + length
+    const message = createBaseEchoMsg()
     while (reader.pos < end) {
-      const tag = reader.uint32();
+      const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
-          message.body = reader.string();
-          break;
+          message.body = reader.string()
+          break
         default:
-          reader.skipType(tag & 7);
-          break;
+          reader.skipType(tag & 7)
+          break
       }
     }
-    return message;
+    return message
   },
 
   // encodeTransform encodes a source of message objects.
   // Transform<EchoMsg, Uint8Array>
   async *encodeTransform(
-    source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>,
+    source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>
   ): AsyncIterable<Uint8Array> {
     for await (const pkt of source) {
       if (Array.isArray(pkt)) {
         for (const p of pkt) {
-          yield* [EchoMsg.encode(p).finish()];
+          yield* [EchoMsg.encode(p).finish()]
         }
       } else {
-        yield* [EchoMsg.encode(pkt).finish()];
+        yield* [EchoMsg.encode(pkt).finish()]
       }
     }
   },
@@ -59,100 +62,122 @@ export const EchoMsg = {
   // decodeTransform decodes a source of encoded messages.
   // Transform<Uint8Array, EchoMsg>
   async *decodeTransform(
-    source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>,
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
   ): AsyncIterable<EchoMsg> {
     for await (const pkt of source) {
       if (Array.isArray(pkt)) {
         for (const p of pkt) {
-          yield* [EchoMsg.decode(p)];
+          yield* [EchoMsg.decode(p)]
         }
       } else {
-        yield* [EchoMsg.decode(pkt)];
+        yield* [EchoMsg.decode(pkt)]
       }
     }
   },
 
   fromJSON(object: any): EchoMsg {
-    return { body: isSet(object.body) ? String(object.body) : "" };
+    return { body: isSet(object.body) ? String(object.body) : '' }
   },
 
   toJSON(message: EchoMsg): unknown {
-    const obj: any = {};
-    message.body !== undefined && (obj.body = message.body);
-    return obj;
+    const obj: any = {}
+    message.body !== undefined && (obj.body = message.body)
+    return obj
   },
 
   fromPartial<I extends Exact<DeepPartial<EchoMsg>, I>>(object: I): EchoMsg {
-    const message = createBaseEchoMsg();
-    message.body = object.body ?? "";
-    return message;
+    const message = createBaseEchoMsg()
+    message.body = object.body ?? ''
+    return message
   },
-};
+}
 
 /** Echoer service returns the given message. */
 export interface Echoer {
   /** Echo returns the given message. */
-  Echo(request: EchoMsg): Promise<EchoMsg>;
+  Echo(request: EchoMsg): Promise<EchoMsg>
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>
   /** RpcStream opens a nested rpc call stream. */
-  RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket>
 }
 
 export class EchoerClientImpl implements Echoer {
-  private readonly rpc: Rpc;
+  private readonly rpc: Rpc
   constructor(rpc: Rpc) {
-    this.rpc = rpc;
-    this.Echo = this.Echo.bind(this);
-    this.EchoServerStream = this.EchoServerStream.bind(this);
-    this.EchoClientStream = this.EchoClientStream.bind(this);
-    this.EchoBidiStream = this.EchoBidiStream.bind(this);
-    this.RpcStream = this.RpcStream.bind(this);
+    this.rpc = rpc
+    this.Echo = this.Echo.bind(this)
+    this.EchoServerStream = this.EchoServerStream.bind(this)
+    this.EchoClientStream = this.EchoClientStream.bind(this)
+    this.EchoBidiStream = this.EchoBidiStream.bind(this)
+    this.RpcStream = this.RpcStream.bind(this)
   }
   Echo(request: EchoMsg): Promise<EchoMsg> {
-    const data = EchoMsg.encode(request).finish();
-    const promise = this.rpc.request("echo.Echoer", "Echo", data);
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+    const data = EchoMsg.encode(request).finish()
+    const promise = this.rpc.request('echo.Echoer', 'Echo', data)
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
   EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
-    const data = EchoMsg.encode(request).finish();
-    const result = this.rpc.serverStreamingRequest("echo.Echoer", "EchoServerStream", data);
-    return EchoMsg.decodeTransform(result);
+    const data = EchoMsg.encode(request).finish()
+    const result = this.rpc.serverStreamingRequest(
+      'echo.Echoer',
+      'EchoServerStream',
+      data
+    )
+    return EchoMsg.decodeTransform(result)
   }
 
   EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
-    const data = EchoMsg.encodeTransform(request);
-    const promise = this.rpc.clientStreamingRequest("echo.Echoer", "EchoClientStream", data);
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+    const data = EchoMsg.encodeTransform(request)
+    const promise = this.rpc.clientStreamingRequest(
+      'echo.Echoer',
+      'EchoClientStream',
+      data
+    )
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
   EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
-    const data = EchoMsg.encodeTransform(request);
-    const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "EchoBidiStream", data);
-    return EchoMsg.decodeTransform(result);
+    const data = EchoMsg.encodeTransform(request)
+    const result = this.rpc.bidirectionalStreamingRequest(
+      'echo.Echoer',
+      'EchoBidiStream',
+      data
+    )
+    return EchoMsg.decodeTransform(result)
   }
 
-  RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket> {
-    const data = RpcStreamPacket.encodeTransform(request);
-    const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "RpcStream", data);
-    return RpcStreamPacket.decodeTransform(result);
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket> {
+    const data = RpcStreamPacket.encodeTransform(request)
+    const result = this.rpc.bidirectionalStreamingRequest(
+      'echo.Echoer',
+      'RpcStream',
+      data
+    )
+    return RpcStreamPacket.decodeTransform(result)
   }
 }
 
 /** Echoer service returns the given message. */
-export type EchoerDefinition = typeof EchoerDefinition;
+export type EchoerDefinition = typeof EchoerDefinition
 export const EchoerDefinition = {
-  name: "Echoer",
-  fullName: "echo.Echoer",
+  name: 'Echoer',
+  fullName: 'echo.Echoer',
   methods: {
     /** Echo returns the given message. */
     echo: {
-      name: "Echo",
+      name: 'Echo',
       requestType: EchoMsg,
       requestStream: false,
       responseType: EchoMsg,
@@ -161,7 +186,7 @@ export const EchoerDefinition = {
     },
     /** EchoServerStream is an example of a server -> client one-way stream. */
     echoServerStream: {
-      name: "EchoServerStream",
+      name: 'EchoServerStream',
       requestType: EchoMsg,
       requestStream: false,
       responseType: EchoMsg,
@@ -170,7 +195,7 @@ export const EchoerDefinition = {
     },
     /** EchoClientStream is an example of client->server one-way stream. */
     echoClientStream: {
-      name: "EchoClientStream",
+      name: 'EchoClientStream',
       requestType: EchoMsg,
       requestStream: true,
       responseType: EchoMsg,
@@ -179,7 +204,7 @@ export const EchoerDefinition = {
     },
     /** EchoBidiStream is an example of a two-way stream. */
     echoBidiStream: {
-      name: "EchoBidiStream",
+      name: 'EchoBidiStream',
       requestType: EchoMsg,
       requestStream: true,
       responseType: EchoMsg,
@@ -188,7 +213,7 @@ export const EchoerDefinition = {
     },
     /** RpcStream opens a nested rpc call stream. */
     rpcStream: {
-      name: "RpcStream",
+      name: 'RpcStream',
       requestType: RpcStreamPacket,
       requestStream: true,
       responseType: RpcStreamPacket,
@@ -196,37 +221,68 @@ export const EchoerDefinition = {
       options: {},
     },
   },
-} as const;
+} as const
 
 interface Rpc {
-  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
-  clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
-  serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Promise<Uint8Array>
+  clientStreamingRequest(
+    service: string,
+    method: string,
+    data: AsyncIterable<Uint8Array>
+  ): Promise<Uint8Array>
+  serverStreamingRequest(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): AsyncIterable<Uint8Array>
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>,
-  ): AsyncIterable<Uint8Array>;
+    data: AsyncIterable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
 }
 
-type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined
 
-export 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 { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
-  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>;
+export 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 { $case: string }
+  ? { [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]> } & {
+      $case: T['$case']
+    }
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>
 
-type KeysOfUnion<T> = T extends T ? keyof T : never;
-export type Exact<P, I extends P> = P extends Builtin ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+type KeysOfUnion<T> = T extends T ? keyof T : never
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & {
+      [K in Exclude<keyof I, KeysOfUnion<P>>]: never
+    }
 
 if (_m0.util.Long !== Long) {
-  _m0.util.Long = Long as any;
-  _m0.configure();
+  _m0.util.Long = Long as any
+  _m0.configure()
 }
 
 function isSet(value: any): boolean {
-  return value !== null && value !== undefined;
+  return value !== null && value !== undefined
 }

package/echo/echo_srpc.pb.go

@@ -220,10 +220,25 @@ func (s *SRPCEchoerUnimplementedServer) RpcStream(SRPCEchoer_RpcStreamStream) er
 const SRPCEchoerServiceID = "echo.Echoer"
 
 type SRPCEchoerHandler struct {
-	impl SRPCEchoerServer
+	serviceID string
+	impl      SRPCEchoerServer
 }
 
-func (SRPCEchoerHandler) GetServiceID() string { return SRPCEchoerServiceID }
+// NewSRPCEchoerHandler constructs a new RPC handler.
+// serviceID: if empty, uses default: echo.Echoer
+func NewSRPCEchoerHandler(impl SRPCEchoerServer, serviceID string) srpc.Handler {
+	if serviceID == "" {
+		serviceID = SRPCEchoerServiceID
+	}
+	return &SRPCEchoerHandler{impl: impl, serviceID: serviceID}
+}
+
+// SRPCRegisterEchoer registers the implementation with the mux.
+// Uses the default serviceID: echo.Echoer
+func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
+	return mux.Register(NewSRPCEchoerHandler(impl, ""))
+}
+func (d *SRPCEchoerHandler) GetServiceID() string { return d.serviceID }
 
 func (SRPCEchoerHandler) GetMethodIDs() []string {
 	return []string{
@@ -295,14 +310,6 @@ func (SRPCEchoerHandler) InvokeMethod_RpcStream(impl SRPCEchoerServer, strm srpc
 	return impl.RpcStream(clientStrm)
 }
 
-func NewSRPCEchoerHandler(impl SRPCEchoerServer) srpc.Handler {
-	return &SRPCEchoerHandler{impl: impl}
-}
-
-func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
-	return mux.Register(&SRPCEchoerHandler{impl: impl})
-}
-
 type SRPCEchoer_EchoStream interface {
 	srpc.Stream
 	SendAndClose(*EchoMsg) error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.10.9",
+  "version": "0.11.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/conn.ts

@@ -29,7 +29,9 @@ export interface StreamHandler {
 }
 
 // streamToSRPCStream converts a Stream to a SRPCStream.
-export function streamToSRPCStream(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): SRPCStream {
+export function streamToSRPCStream(
+  stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>
+): SRPCStream {
   return {
     source: pipe(stream, combineUint8ArrayListTransform()),
     sink: stream.sink,

package/srpc/definition.ts

@@ -7,6 +7,7 @@ export interface Definition {
   // e.x.: Echo
   name: string
   // fullName is the fully qualified name of the service
+  // this is also referred to as the "service ID"
   // e.x.: echoer.Echoer
   fullName: string
   // methods is the set of RPC methods.