starpc 0.22.7 → 0.23.0

package/dist/integration/integration.js

@@ -7,12 +7,12 @@ async function runRPC() {
     const ws = new WebSocket(addr);
     const channel = new WebSocketConn(ws, 'outbound');
     const client = channel.buildClient();
-    console.log('Running RpcStream test via WebSocket..');
-    await runRpcStreamTest(client);
     console.log('Running client test via WebSocket..');
     await runClientTest(client);
     console.log('Running abort controller test via WebSocket..');
     await runAbortControllerTest(client);
+    console.log('Running RpcStream test via WebSocket..');
+    await runRpcStreamTest(client);
 }
 process.on('unhandledRejection', (ev) => {
     console.error('Unhandled rejection', ev);

package/dist/srpc/client.js

@@ -44,7 +44,7 @@ export class Client {
             .then(async (call) => {
             return writeToPushable(call.rpcDataSource, serverData);
         })
-            .catch(err => serverData.end(err));
+            .catch((err) => serverData.end(err));
         return serverData;
     }
     // bidirectionalStreamingRequest starts a two-way streaming request.
@@ -63,7 +63,7 @@ export class Client {
                 serverData.end(err);
             }
         })
-            .catch(err => serverData.end(err));
+            .catch((err) => serverData.end(err));
         return serverData;
     }
     // startRpc is a common utility function to begin a rpc call.

package/dist/srpc/conn.d.ts

@@ -1,5 +1,4 @@
-import type { Direction, Stream } from '@libp2p/interface/connection';
-import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer';
+import type { Direction, Stream, StreamMuxerFactory } from '@libp2p/interface';
 import type { Duplex, Source } from 'it-stream-types';
 import { Uint8ArrayList } from 'uint8arraylist';
 import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js';
@@ -16,8 +15,8 @@ export declare class Conn implements Duplex<AsyncGenerator<Uint8Array | Uint8Arr
     private muxer;
     private server?;
     constructor(server?: StreamHandler, connParams?: ConnParams);
-    get sink(): import("it-stream-types").Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>>;
-    get source(): AsyncGenerator<Uint8Array, any, unknown>;
+    get sink(): import("it-stream-types").Sink<AsyncGenerator<Uint8Array | Uint8ArrayList, any, unknown>, unknown>;
+    get source(): AsyncGenerator<Uint8Array | Uint8ArrayList, any, unknown>;
     get streams(): Stream[];
     buildClient(): Client;
     openStream(): Promise<SRPCStream>;

package/dist/srpc/conn.js

@@ -2,6 +2,7 @@ import { yamux } from '@chainsafe/libp2p-yamux';
 import { pipe } from 'it-pipe';
 import isPromise from 'is-promise';
 import { pushable } from 'it-pushable';
+import { defaultLogger } from '@libp2p/logger';
 import { Client } from './client.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
 import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
@@ -25,7 +26,10 @@ export class Conn {
         if (server) {
             this.server = server;
         }
-        const muxerFactory = connParams?.muxerFactory ?? yamux()();
+        const muxerFactory = connParams?.muxerFactory ??
+            yamux({ enableKeepAlive: false })({
+                logger: defaultLogger(),
+            });
         this.muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),
             direction: connParams?.direction || 'outbound',

package/dist/srpc/index.d.ts

@@ -11,7 +11,7 @@ export { Mux, StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortDuplex, newMessagePortDuplex, MessagePortConn, } from './message-port.js';
 export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
-export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
+export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, uint32LEDecode, uint32LEEncode, decodeUint32Le, encodeUint32Le, lengthPrefixDecode, lengthPrefixEncode, prependPacketLen, } from './packet.js';
 export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';

package/dist/srpc/index.js

@@ -10,7 +10,7 @@ export { StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortDuplex, newMessagePortDuplex, MessagePortConn, } from './message-port.js';
 export { buildDecodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
-export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
+export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, uint32LEDecode, uint32LEEncode, decodeUint32Le, encodeUint32Le, lengthPrefixDecode, lengthPrefixEncode, prependPacketLen, } from './packet.js';
 export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';

package/dist/srpc/length-prefix.js

@@ -0,0 +1 @@
+"use strict";

package/dist/srpc/message.js

@@ -15,7 +15,7 @@ export function memoProtoDecode(def) {
 //
 // set memoize if you expect to repeatedly see the same message.
 export function buildDecodeMessageTransform(def, memoize) {
-    const decode = memoize ? memoProtoDecode(def) : def.decode.bind(def);
+    const decode = !memoize ? def.decode.bind(def) : memoProtoDecode(def);
     // decodeMessageSource unmarshals and async yields encoded Messages.
     return async function* decodeMessageSource(source) {
         for await (const pkt of source) {
@@ -33,11 +33,11 @@ export function buildDecodeMessageTransform(def, memoize) {
 // buildEncodeMessageTransform builds a source of decoded messages.
 // set memoize if you expect to repeatedly encode the same message.
 export function buildEncodeMessageTransform(def, memoize) {
-    const encode = memoize
-        ? memoProto(def)
-        : (msg) => {
+    const encode = !memoize
+        ? (msg) => {
             return def.encode(msg).finish();
-        };
+        }
+        : memoProto(def);
     // encodeMessageSource encodes messages to byte arrays.
     return async function* encodeMessageSource(source) {
         for await (const pkt of source) {

package/dist/srpc/packet.d.ts

@@ -1,11 +1,26 @@
 import { Uint8ArrayList } from 'uint8arraylist';
-import { Packet } from './rpcproto.pb.js';
 import { Source, Transform } from 'it-stream-types';
+import { Packet } from './rpcproto.pb.js';
 export declare const decodePacketSource: import("./message.js").DecodeMessageTransform<Packet>;
 export declare const encodePacketSource: import("./message.js").EncodeMessageTransform<Packet>;
-export declare function prependLengthPrefixTransform(): Transform<Source<Uint8Array | Uint8ArrayList>, AsyncGenerator<Uint8Array, void, undefined> | Generator<Uint8Array, void, undefined>>;
-export declare function parseLengthPrefixTransform(): Transform<Source<Uint8Array | Uint8ArrayList>, // Allow both AsyncIterable and Iterable
-AsyncGenerator<Uint8ArrayList, void, unknown> | Generator<Uint8ArrayList, void, unknown>>;
+export declare const uint32LEDecode: {
+    (data: Uint8ArrayList): number;
+    bytes: number;
+};
+export declare const uint32LEEncode: {
+    (value: number): Uint8ArrayList;
+    bytes: number;
+};
+export declare function lengthPrefixEncode(source: Source<Uint8Array | Uint8ArrayList>, lengthEncoder: typeof uint32LEEncode): AsyncGenerator<Uint8ArrayList, void, unknown>;
+export declare function lengthPrefixDecode(source: Source<Uint8Array | Uint8ArrayList>, lengthDecoder: typeof uint32LEDecode): AsyncGenerator<Uint8ArrayList, void, unknown>;
+export declare function prependLengthPrefixTransform(lengthEncoder?: {
+    (value: number): Uint8ArrayList;
+    bytes: number;
+}): Transform<Source<Uint8Array | Uint8ArrayList>, AsyncGenerator<Uint8ArrayList, void, undefined> | Generator<Uint8ArrayList, void, undefined>>;
+export declare function parseLengthPrefixTransform(lengthDecoder?: {
+    (data: Uint8ArrayList): number;
+    bytes: number;
+}): Transform<Source<Uint8Array | Uint8ArrayList>, AsyncGenerator<Uint8ArrayList, void, unknown> | Generator<Uint8ArrayList, void, unknown>>;
 export declare function encodeUint32Le(value: number): Uint8Array;
 export declare function decodeUint32Le(data: Uint8Array): number;
 export declare function prependPacketLen(msgData: Uint8Array): Uint8Array;

package/dist/srpc/packet.js

@@ -1,4 +1,3 @@
-import { encode as lengthPrefixEncode, decode as lengthPrefixDecode, } from 'it-length-prefixed';
 import { Uint8ArrayList } from 'uint8arraylist';
 import { Packet } from './rpcproto.pb.js';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
@@ -7,7 +6,7 @@ export const decodePacketSource = buildDecodeMessageTransform(Packet);
 // encodePacketSource encodes packets from a packet object stream.
 export const encodePacketSource = buildEncodeMessageTransform(Packet);
 // uint32LEDecode removes the length prefix.
-const uint32LEDecode = (data) => {
+export const uint32LEDecode = (data) => {
     if (data.length < 4) {
         throw RangeError('Could not decode int32BE');
     }
@@ -15,24 +14,53 @@ const uint32LEDecode = (data) => {
 };
 uint32LEDecode.bytes = 4;
 // uint32LEEncode adds the length prefix.
-const uint32LEEncode = (value) => {
+export const uint32LEEncode = (value) => {
     const data = new Uint8ArrayList(new Uint8Array(4));
     data.setUint32(0, value, true);
     return data;
 };
 uint32LEEncode.bytes = 4;
+// lengthPrefixEncode transforms a source to a length-prefixed Uint8ArrayList stream.
+export async function* lengthPrefixEncode(source, lengthEncoder) {
+    for await (const chunk of source) {
+        // Encode the length of the chunk.
+        const length = chunk instanceof Uint8Array ? chunk.length : chunk.byteLength;
+        const lengthEncoded = lengthEncoder(length);
+        // Concatenate the length prefix and the data.
+        yield new Uint8ArrayList(lengthEncoded, chunk);
+    }
+}
+// lengthPrefixDecode decodes a length-prefixed source to a Uint8ArrayList stream.
+export async function* lengthPrefixDecode(source, lengthDecoder) {
+    const buffer = new Uint8ArrayList();
+    for await (const chunk of source) {
+        buffer.append(chunk);
+        // Continue extracting messages while buffer contains enough data for decoding.
+        while (buffer.length >= lengthDecoder.bytes) {
+            const messageLength = lengthDecoder(buffer);
+            const totalLength = lengthDecoder.bytes + messageLength;
+            if (buffer.length < totalLength)
+                break; // Wait for more data if the full message hasn't arrived.
+            // Extract the message excluding the length prefix.
+            const message = buffer.sublist(lengthDecoder.bytes, totalLength);
+            yield message;
+            // Remove the processed message from the buffer.
+            buffer.consume(totalLength);
+        }
+    }
+}
 // prependLengthPrefixTransform adds a length prefix to a message source.
 // little-endian uint32
-export function prependLengthPrefixTransform() {
+export function prependLengthPrefixTransform(lengthEncoder = uint32LEEncode) {
     return (source) => {
-        return lengthPrefixEncode(source, { lengthEncoder: uint32LEEncode });
+        return lengthPrefixEncode(source, lengthEncoder);
     };
 }
 // parseLengthPrefixTransform parses the length prefix from a message source.
 // little-endian uint32
-export function parseLengthPrefixTransform() {
+export function parseLengthPrefixTransform(lengthDecoder = uint32LEDecode) {
     return (source) => {
-        return lengthPrefixDecode(source, { lengthDecoder: uint32LEDecode });
+        return lengthPrefixDecode(source, lengthDecoder);
     };
 }
 // encodeUint32Le encodes the number as a uint32 with little endian.

package/dist/srpc/websocket.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="ws" />
-import { Direction } from '@libp2p/interface/connection';
+import { Direction } from '@libp2p/interface';
 import type WebSocket from '@aptre/it-ws/web-socket';
 import { Conn } from './conn.js';
 import { Server } from './server.js';

package/dist/srpc/websocket.js

@@ -1,13 +1,16 @@
 import { pipe } from 'it-pipe';
 import duplex from '@aptre/it-ws/duplex';
 import { Conn } from './conn.js';
+import { combineUint8ArrayListTransform } from './array-list.js';
 // WebSocketConn implements a connection with a WebSocket and optional Server.
 export class WebSocketConn extends Conn {
     constructor(socket, direction, server) {
         super(server, { direction });
         this.socket = socket;
         const socketDuplex = duplex(socket);
-        pipe(socketDuplex, this, socketDuplex);
+        pipe(socketDuplex, this, 
+        // it-ws only supports sending Uint8Array.
+        combineUint8ArrayListTransform(), socketDuplex);
     }
     // getSocket returns the websocket.
     getSocket() {

package/e2e/mock/mock.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.31.0-devel
-// 	protoc        v4.25.1
+// 	protoc-gen-go v1.32.0-devel
+// 	protoc        v4.25.2
 // source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
 
 package e2e_mock

package/e2e/mock/mock_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.19.1
+// protoc-gen-srpc version: v0.22.7
 // source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
 
 package e2e_mock

package/e2e/mock/mock_vtproto.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
-// protoc-gen-go-vtproto version: v0.4.0
+// protoc-gen-go-vtproto version: v0.6.0
 // source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
 
 package e2e_mock
@@ -7,8 +7,8 @@ package e2e_mock
 import (
 	fmt "fmt"
 	io "io"
-	bits "math/bits"
 
+	protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
 	proto "google.golang.org/protobuf/proto"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
@@ -24,9 +24,8 @@ func (m *MockMsg) CloneVT() *MockMsg {
 	if m == nil {
 		return (*MockMsg)(nil)
 	}
-	r := &MockMsg{
-		Body: m.Body,
-	}
+	r := new(MockMsg)
+	r.Body = m.Body
 	if len(m.unknownFields) > 0 {
 		r.unknownFields = make([]byte, len(m.unknownFields))
 		copy(r.unknownFields, m.unknownFields)
@@ -90,24 +89,13 @@ func (m *MockMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if len(m.Body) > 0 {
 		i -= len(m.Body)
 		copy(dAtA[i:], m.Body)
-		i = encodeVarint(dAtA, i, uint64(len(m.Body)))
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Body)))
 		i--
 		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func encodeVarint(dAtA []byte, offset int, v uint64) int {
-	offset -= sov(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
 func (m *MockMsg) SizeVT() (n int) {
 	if m == nil {
 		return 0
@@ -116,18 +104,12 @@ func (m *MockMsg) SizeVT() (n int) {
 	_ = l
 	l = len(m.Body)
 	if l > 0 {
-		n += 1 + l + sov(uint64(l))
+		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
 	}
 	n += len(m.unknownFields)
 	return n
 }
 
-func sov(x uint64) (n int) {
-	return (bits.Len64(x|1) + 6) / 7
-}
-func soz(x uint64) (n int) {
-	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
 func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -136,7 +118,7 @@ func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
 			if shift >= 64 {
-				return ErrIntOverflow
+				return protohelpers.ErrIntOverflow
 			}
 			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
@@ -164,7 +146,7 @@ func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflow
+					return protohelpers.ErrIntOverflow
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -178,11 +160,11 @@ func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLength
+				return protohelpers.ErrInvalidLength
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLength
+				return protohelpers.ErrInvalidLength
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -191,12 +173,12 @@ func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
-			skippy, err := skip(dAtA[iNdEx:])
+			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
 			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLength
+				return protohelpers.ErrInvalidLength
 			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
@@ -211,88 +193,3 @@ func (m *MockMsg) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
-
-func skip(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflow
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflow
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflow
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLength
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroup
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLength
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
-)

package/echo/echo.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.31.0-devel
-// 	protoc        v4.25.1
+// 	protoc-gen-go v1.32.0-devel
+// 	protoc        v4.25.2
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/echo/echo_srpc.pb.go

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