starpc 0.9.1 → 0.10.1

package/dist/rpcstream/rpcstream.pb.js

@@ -1,19 +1,19 @@
 /* eslint-disable */
-import Long from 'long';
-import _m0 from 'protobufjs/minimal.js';
-export const protobufPackage = 'rpcstream';
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
+export const protobufPackage = "rpcstream";
 function createBaseRpcStreamPacket() {
     return { body: undefined };
 }
 export const RpcStreamPacket = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === 'init') {
+        if (message.body?.$case === "init") {
             RpcStreamInit.encode(message.body.init, writer.uint32(10).fork()).ldelim();
         }
-        if (message.body?.$case === 'ack') {
+        if (message.body?.$case === "ack") {
             RpcAck.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
         }
-        if (message.body?.$case === 'data') {
+        if (message.body?.$case === "data") {
             writer.uint32(26).bytes(message.body.data);
         }
         return writer;
@@ -26,19 +26,13 @@ export const RpcStreamPacket = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.body = {
-                        $case: 'init',
-                        init: RpcStreamInit.decode(reader, reader.uint32()),
-                    };
+                    message.body = { $case: "init", init: RpcStreamInit.decode(reader, reader.uint32()) };
                     break;
                 case 2:
-                    message.body = {
-                        $case: 'ack',
-                        ack: RpcAck.decode(reader, reader.uint32()),
-                    };
+                    message.body = { $case: "ack", ack: RpcAck.decode(reader, reader.uint32()) };
                     break;
                 case 3:
-                    message.body = { $case: 'data', data: reader.bytes() };
+                    message.body = { $case: "data", data: reader.bytes() };
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -78,60 +72,43 @@ export const RpcStreamPacket = {
     fromJSON(object) {
         return {
             body: isSet(object.init)
-                ? { $case: 'init', init: RpcStreamInit.fromJSON(object.init) }
+                ? { $case: "init", init: RpcStreamInit.fromJSON(object.init) }
                 : isSet(object.ack)
-                    ? { $case: 'ack', ack: RpcAck.fromJSON(object.ack) }
+                    ? { $case: "ack", ack: RpcAck.fromJSON(object.ack) }
                     : isSet(object.data)
-                        ? { $case: 'data', data: bytesFromBase64(object.data) }
+                        ? { $case: "data", data: bytesFromBase64(object.data) }
                         : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        message.body?.$case === 'init' &&
-            (obj.init = message.body?.init
-                ? RpcStreamInit.toJSON(message.body?.init)
-                : undefined);
-        message.body?.$case === 'ack' &&
-            (obj.ack = message.body?.ack
-                ? RpcAck.toJSON(message.body?.ack)
-                : undefined);
-        message.body?.$case === 'data' &&
-            (obj.data =
-                message.body?.data !== undefined
-                    ? base64FromBytes(message.body?.data)
-                    : undefined);
+        message.body?.$case === "init" &&
+            (obj.init = message.body?.init ? RpcStreamInit.toJSON(message.body?.init) : undefined);
+        message.body?.$case === "ack" && (obj.ack = message.body?.ack ? RpcAck.toJSON(message.body?.ack) : undefined);
+        message.body?.$case === "data" &&
+            (obj.data = message.body?.data !== undefined ? base64FromBytes(message.body?.data) : undefined);
         return obj;
     },
     fromPartial(object) {
         const message = createBaseRpcStreamPacket();
-        if (object.body?.$case === 'init' &&
-            object.body?.init !== undefined &&
-            object.body?.init !== null) {
-            message.body = {
-                $case: 'init',
-                init: RpcStreamInit.fromPartial(object.body.init),
-            };
+        if (object.body?.$case === "init" && object.body?.init !== undefined && object.body?.init !== null) {
+            message.body = { $case: "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: RpcAck.fromPartial(object.body.ack) };
+        if (object.body?.$case === "ack" && object.body?.ack !== undefined && object.body?.ack !== null) {
+            message.body = { $case: "ack", ack: RpcAck.fromPartial(object.body.ack) };
         }
-        if (object.body?.$case === 'data' &&
-            object.body?.data !== undefined &&
-            object.body?.data !== null) {
-            message.body = { $case: 'data', data: object.body.data };
+        if (object.body?.$case === "data" && object.body?.data !== undefined && object.body?.data !== null) {
+            message.body = { $case: "data", data: object.body.data };
         }
         return message;
     },
 };
 function createBaseRpcStreamInit() {
-    return { componentId: '' };
+    return { componentId: "" };
 }
 export const RpcStreamInit = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.componentId !== '') {
+        if (message.componentId !== "") {
             writer.uint32(10).string(message.componentId);
         }
         return writer;
@@ -182,9 +159,7 @@ export const RpcStreamInit = {
         }
     },
     fromJSON(object) {
-        return {
-            componentId: isSet(object.componentId) ? String(object.componentId) : '',
-        };
+        return { componentId: isSet(object.componentId) ? String(object.componentId) : "" };
     },
     toJSON(message) {
         const obj = {};
@@ -193,16 +168,16 @@ export const RpcStreamInit = {
     },
     fromPartial(object) {
         const message = createBaseRpcStreamInit();
-        message.componentId = object.componentId ?? '';
+        message.componentId = object.componentId ?? "";
         return message;
     },
 };
 function createBaseRpcAck() {
-    return { error: '' };
+    return { error: "" };
 }
 export const RpcAck = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.error !== '') {
+        if (message.error !== "") {
             writer.uint32(10).string(message.error);
         }
         return writer;
@@ -253,9 +228,7 @@ export const RpcAck = {
         }
     },
     fromJSON(object) {
-        return {
-            error: isSet(object.error) ? String(object.error) : '',
-        };
+        return { error: isSet(object.error) ? String(object.error) : "" };
     },
     toJSON(message) {
         const obj = {};
@@ -264,39 +237,49 @@ export const RpcAck = {
     },
     fromPartial(object) {
         const message = createBaseRpcAck();
-        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";
 })();
-const atob = globalThis.atob ||
-    ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
 function bytesFromBase64(b64) {
-    const bin = atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-        arr[i] = bin.charCodeAt(i);
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
     }
-    return arr;
 }
-const btoa = globalThis.btoa ||
-    ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
 function base64FromBytes(arr) {
-    const bin = [];
-    arr.forEach((byte) => {
-        bin.push(String.fromCharCode(byte));
-    });
-    return btoa(bin.join(''));
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
 }
 if (_m0.util.Long !== Long) {
     _m0.util.Long = Long;

package/dist/srpc/conn.d.ts

@@ -1,6 +1,7 @@
 import type { Direction, Stream } from '@libp2p/interface-connection';
 import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer';
 import type { Duplex } from 'it-stream-types';
+import { Uint8ArrayList } from 'uint8arraylist';
 import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js';
 import { Client } from './client.js';
 export interface ConnParams {
@@ -8,7 +9,7 @@ export interface ConnParams {
     direction?: Direction;
 }
 export interface StreamHandler {
-    handleStream(strm: Duplex<Uint8Array>): void;
+    handleStream(strm: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): void;
 }
 export declare class Conn implements Duplex<Uint8Array> {
     private muxer;

package/dist/srpc/packet.d.ts

@@ -3,7 +3,7 @@ import { Uint8ArrayList } from 'uint8arraylist';
 import { Transform } from 'it-pipe';
 export declare const decodePacketSource: (source: import("it-stream-types").Source<Uint8Array | Uint8Array[]>) => AsyncIterable<Packet>;
 export declare const encodePacketSource: (source: import("it-stream-types").Source<Packet | Packet[]>) => AsyncIterable<Uint8Array>;
-export declare function prependLengthPrefixTransform(): Transform<Uint8Array | Uint8ArrayList, Uint8ArrayList>;
+export declare function prependLengthPrefixTransform(): Transform<Uint8Array | Uint8ArrayList, Uint8Array>;
 export declare function parseLengthPrefixTransform(): Transform<Uint8Array | Uint8ArrayList, Uint8ArrayList>;
 export declare function encodeUint32Le(value: number): Uint8Array;
 export declare function decodeUint32Le(data: Uint8Array): number;

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

@@ -1,13 +1,13 @@
-import Long from 'long';
-import _m0 from 'protobufjs/minimal.js';
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
 export declare const protobufPackage = "srpc";
 /** Packet is a message sent over a srpc packet connection. */
 export interface Packet {
     body?: {
-        $case: 'callStart';
+        $case: "callStart";
         callStart: CallStart;
     } | {
-        $case: 'callData';
+        $case: "callData";
         callData: CallData;
     };
 }
@@ -93,9 +93,9 @@ export declare const Packet: {
                 rpcMethod?: string | undefined;
                 data?: Uint8Array | undefined;
                 dataIsZero?: boolean | undefined;
-            } & Record<Exclude<keyof I["body"]["callStart"], keyof CallStart>, never>) | undefined;
+            } & { [K in Exclude<keyof I["body"]["callStart"], keyof CallStart>]: never; }) | undefined;
             $case: "callStart";
-        } & Record<Exclude<keyof I["body"], "callStart" | "$case">, never>) | ({
+        } & { [K_1 in Exclude<keyof I["body"], "callStart" | "$case">]: never; }) | ({
             callData?: {
                 data?: Uint8Array | undefined;
                 dataIsZero?: boolean | undefined;
@@ -115,10 +115,10 @@ export declare const Packet: {
                 dataIsZero?: boolean | undefined;
                 complete?: boolean | undefined;
                 error?: string | undefined;
-            } & Record<Exclude<keyof I["body"]["callData"], keyof CallData>, never>) | undefined;
+            } & { [K_2 in 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;
+        } & { [K_3 in Exclude<keyof I["body"], "callData" | "$case">]: never; }) | undefined;
+    } & { [K_4 in Exclude<keyof I, "body">]: never; }>(object: I): Packet;
 };
 export declare const CallStart: {
     encode(message: CallStart, writer?: _m0.Writer): _m0.Writer;
@@ -137,7 +137,7 @@ export declare const CallStart: {
         rpcMethod?: string | undefined;
         data?: Uint8Array | undefined;
         dataIsZero?: boolean | undefined;
-    } & Record<Exclude<keyof I, keyof CallStart>, never>>(object: I): CallStart;
+    } & { [K in Exclude<keyof I, keyof CallStart>]: never; }>(object: I): CallStart;
 };
 export declare const CallData: {
     encode(message: CallData, writer?: _m0.Writer): _m0.Writer;
@@ -156,20 +156,22 @@ export declare const CallData: {
         dataIsZero?: boolean | undefined;
         complete?: boolean | undefined;
         error?: string | undefined;
-    } & Record<Exclude<keyof I, keyof CallData>, never>>(object: I): CallData;
+    } & { [K in 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 {
     $case: string;
 } ? {
-    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
 } & {
-    $case: T['$case'];
+    $case: T["$case"];
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
 declare type KeysOfUnion<T> = T extends T ? keyof T : never;
 export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
     [K in keyof P]: Exact<P[K], I[K]>;
-} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
 export {};

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,16 +23,10 @@ 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);
@@ -72,62 +66,40 @@ 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) {
@@ -194,11 +166,9 @@ 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,
         };
     },
@@ -213,20 +183,15 @@ 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()) {
@@ -239,7 +204,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;
@@ -300,12 +265,10 @@ 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) {
@@ -322,39 +285,49 @@ 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";
 })();
-const atob = globalThis.atob ||
-    ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
 function bytesFromBase64(b64) {
-    const bin = atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-        arr[i] = bin.charCodeAt(i);
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
     }
-    return arr;
 }
-const btoa = globalThis.btoa ||
-    ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
 function base64FromBytes(arr) {
-    const bin = [];
-    arr.forEach((byte) => {
-        bin.push(String.fromCharCode(byte));
-    });
-    return btoa(bin.join(''));
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
 }
 if (_m0.util.Long !== Long) {
     _m0.util.Long = Long;

package/dist/srpc/server-rpc.js

@@ -15,6 +15,9 @@ export class ServerRPC extends CommonRPC {
         if (!this.service || !this.method) {
             throw new Error('rpcService and rpcMethod cannot be empty');
         }
+        if (!this.lookupMethod) {
+            throw new Error('LookupMethod is not defined');
+        }
         const methodDef = await this.lookupMethod(this.service, this.method);
         if (!methodDef) {
             throw new Error(`not found: ${this.service}/${this.method}`);

package/dist/srpc/server.d.ts

@@ -1,5 +1,6 @@
 import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
+import { Uint8ArrayList } from 'uint8arraylist';
 import { LookupMethod } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
 import { Packet } from './rpcproto.pb.js';
@@ -11,7 +12,7 @@ export declare class Server implements StreamHandler {
     get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;
-    handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;
+    handleDuplex(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): ServerRPC;
     handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC;
     handlePacketStream(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/stream.d.ts

@@ -1,5 +1,6 @@
 import type { Packet } from './rpcproto.pb.js';
 import type { Duplex } from 'it-stream-types';
+import { Uint8ArrayList } from 'uint8arraylist';
 export declare type PacketHandler = (packet: Packet) => Promise<void>;
-export declare type Stream = Duplex<Uint8Array>;
+export declare type Stream = Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>;
 export declare type OpenStreamFunc = () => Promise<Stream>;

package/echo/echo.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.27.1-devel
+// 	protoc-gen-go v1.28.1-devel
 // 	protoc        v3.19.3
 // source: github.com/aperturerobotics/starpc/echo/echo.proto