starpc 0.40.0 → 0.41.0

package/README.md

@@ -1,8 +1,8 @@
-# Stream RPC (starpc)
+# starpc
 
 [![GoDoc Widget]][GoDoc] [![Go Report Card Widget]][Go Report Card]
 
-> A high-performance Protobuf 3 RPC framework supporting bidirectional streaming over any multiplexer.
+> Streaming Protobuf RPC with bidirectional streaming over any multiplexed transport.
 
 [GoDoc]: https://godoc.org/github.com/aperturerobotics/starpc
 [GoDoc Widget]: https://godoc.org/github.com/aperturerobotics/starpc?status.svg
@@ -18,20 +18,22 @@
   - [Protobuf Definition](#protobuf)
   - [Go Implementation](#go)
   - [TypeScript Implementation](#typescript)
+- [Debugging](#debugging)
 - [Development Setup](#development-setup)
 - [Support](#support)
 
 ## Features
 
-- Full [Proto3 services] implementation for both TypeScript and Go
-- Bidirectional streaming support in web browsers
-- Built on libp2p streams with `@chainsafe/libp2p-yamux`
-- Efficient RPC multiplexing over single connections
-- Zero-reflection Go code via [protobuf-go-lite]
-- TypeScript interfaces via [protobuf-es-lite]
-- Sub-streams support through [rpcstream]
+- Full [Proto3 services] support for TypeScript and Go
+- Bidirectional streaming in browsers via WebSocket or WebRTC
+- Built on libp2p streams with [@chainsafe/libp2p-yamux]
+- Efficient multiplexing of RPCs over single connections
+- Zero-reflection Go via [protobuf-go-lite]
+- Lightweight TypeScript via [protobuf-es-lite]
+- Sub-stream support via [rpcstream]
 
 [Proto3 services]: https://developers.google.com/protocol-buffers/docs/proto3#services
+[@chainsafe/libp2p-yamux]: https://github.com/ChainSafe/js-libp2p-yamux
 [protobuf-go-lite]: https://github.com/aperturerobotics/protobuf-go-lite
 [protobuf-es-lite]: https://github.com/aperturerobotics/protobuf-es-lite
 [rpcstream]: ./rpcstream
@@ -119,118 +121,115 @@ if out.GetBody() != bodyTxt {
 }
 ```
 
-[e2e test]: ./e2e/e2e_test.go
-
 ### TypeScript
 
-See the ts-proto README to generate the TypeScript for your protobufs.
-
-For an example of Go <-> TypeScript interop, see the [integration] test. For an
-example of TypeScript <-> TypeScript interop, see the [e2e] test.
+For Go <-> TypeScript interop, see the [integration] test.
+For TypeScript <-> TypeScript, see the [e2e] test.
 
 [e2e]: ./e2e/e2e.ts
 [integration]: ./integration/integration.ts
 
-Supports any AsyncIterable communication channel.
-
 #### WebSocket Example
 
-This examples demonstrates connecting to a WebSocket server:
+Connect to a WebSocket server:
 
 ```typescript
-import { WebSocketConn } from 'srpc'
-import { EchoerClient } from 'srpc/echo'
+import { WebSocketConn } from 'starpc'
+import { EchoerClient } from './echo/index.js'
 
-const ws = new WebSocket('ws://localhost:1347/demo')
-const channel = new WebSocketConn(ws)
-const client = channel.buildClient()
-const demoServiceClient = new EchoerClient(client)
+const ws = new WebSocket('ws://localhost:8080/api')
+const conn = new WebSocketConn(ws)
+const client = conn.buildClient()
+const echoer = new EchoerClient(client)
 
-const result = await demoServiceClient.Echo({
-  body: "Hello world!"
-})
-console.log('output', result.body)
+const result = await echoer.Echo({ body: 'Hello world!' })
+console.log('result:', result.body)
 ```
 
-#### In-memory Demo with TypeScript Server and Client
+#### In-Memory Example
 
-This example demonstrates both the server and client with an in-memory pipe:
+Server and client with an in-memory pipe:
 
 ```typescript
 import { pipe } from 'it-pipe'
-import { createHandler, createMux, Server, Client, Conn } from 'srpc'
-import { EchoerDefinition, EchoerServer, runClientTest } from 'srpc/echo'
-import { pushable } from 'it-pushable'
+import { createHandler, createMux, Server, StreamConn } from 'starpc'
+import { EchoerDefinition, EchoerServer } from './echo/index.js'
 
-// Create the server and register the handlers.
+// Create server with registered handlers
 const mux = createMux()
 const echoer = new EchoerServer()
 mux.register(createHandler(EchoerDefinition, echoer))
 const server = new Server(mux.lookupMethod)
 
-// Create the client connection to the server with an in-memory pipe.
-const clientConn = new Conn()
-const serverConn = new Conn(server)
+// Create client and server connections, pipe together
+const clientConn = new StreamConn()
+const serverConn = new StreamConn(server)
 pipe(clientConn, serverConn, clientConn)
-const client = new Client(clientConn.buildOpenStreamFunc())
 
-// Examples of different types of RPC calls:
+// Build client and make RPC calls
+const client = clientConn.buildClient()
+const echoerClient = new EchoerClient(client)
 
-// One-shot request/response (unary):
-console.log('Calling Echo: unary call...')
-let result = await demoServiceClient.Echo({
-  body: 'Hello world!',
-})
-console.log('success: output', result.body)
-
-// Streaming from client->server with a single server response:
-const clientRequestStream = pushable<EchoMsg>({objectMode: true})
-clientRequestStream.push({body: 'Hello world from streaming request.'})
-clientRequestStream.end()
-console.log('Calling EchoClientStream: client -> server...')
-result = await demoServiceClient.EchoClientStream(clientRequestStream)
-console.log('success: output', result.body)
-
-// Streaming from server -> client with a single client message.
-console.log('Calling EchoServerStream: server -> client...')
-const serverStream = demoServiceClient.EchoServerStream({
-  body: 'Hello world from server to client streaming request.',
-})
-for await (const msg of serverStream) {
-  console.log('server: output', msg.body)
+// Unary call
+const result = await echoerClient.Echo({ body: 'Hello world!' })
+console.log('result:', result.body)
+
+// Client streaming
+import { pushable } from 'it-pushable'
+const stream = pushable({ objectMode: true })
+stream.push({ body: 'Message 1' })
+stream.push({ body: 'Message 2' })
+stream.end()
+const response = await echoerClient.EchoClientStream(stream)
+console.log('response:', response.body)
+
+// Server streaming
+for await (const msg of echoerClient.EchoServerStream({ body: 'Hello' })) {
+  console.log('server msg:', msg.body)
 }
 ```
 
+## Debugging
+
+Enable debug logging in TypeScript using the `DEBUG` environment variable:
+
+```bash
+# Enable all starpc logs
+DEBUG=starpc:* node app.js
+
+# Enable specific component logs
+DEBUG=starpc:stream-conn node app.js
+```
+
 ## Attribution
 
 `protoc-gen-go-starpc` is a heavily modified version of `protoc-gen-go-drpc`.
-
-Be sure to check out [drpc] as well: it's compatible with grpc, twirp, and more.
+Check out [drpc] as well - it's compatible with grpc, twirp, and more.
 
 [drpc]: https://github.com/storj/drpc
 
-Uses [vtprotobuf] to generate Go Protobuf marshal / unmarshal code.
+Uses [vtprotobuf] to generate Protobuf marshal/unmarshal code for Go.
 
 [vtprotobuf]: https://github.com/planetscale/vtprotobuf
 
-Uses [protobuf-es-lite] (fork of [protobuf-es]) to generate TypeScript Protobuf marshal / unmarshal code.
+`protoc-gen-es-starpc` is a modified version of `protoc-gen-connect-es`.
+Uses [protobuf-es-lite] (fork of [protobuf-es]) for TypeScript.
 
 [protobuf-es]: https://github.com/bufbuild/protobuf-es
-[protobuf-es-lite]: https://github.com/aperturerobotics/protobuf-es-lite
-
-`protoc-gen-es-starpc` is a heavily modified version of `protoc-gen-connect-es`.
 
 ## Development Setup
 
-### MacOS Requirements
+### MacOS
+
+Install required packages:
 
-1. Install required packages:
 ```bash
 brew install bash make coreutils gnu-sed findutils protobuf
 brew link --overwrite protobuf
 ```
 
-2. Add to your .bashrc or .zshrc:
+Add to your shell rc file (.bashrc, .zshrc):
+
 ```bash
 export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
 export PATH="/opt/homebrew/opt/gnu-sed/libexec/gnubin:$PATH"
@@ -238,23 +237,12 @@ export PATH="/opt/homebrew/opt/findutils/libexec/gnubin:$PATH"
 export PATH="/opt/homebrew/opt/make/libexec/gnubin:$PATH"
 ```
 
-## Attribution
-
-- `protoc-gen-go-starpc`: Modified version of `protoc-gen-go-drpc`
-- `protoc-gen-es-starpc`: Modified version of `protoc-gen-connect-es`
-- Uses [vtprotobuf] for Go Protobuf marshaling
-- Uses [protobuf-es-lite] for TypeScript Protobuf interfaces
-
-[vtprotobuf]: https://github.com/planetscale/vtprotobuf
-
 ## Support
 
-Need help? We're here:
-
-- [File a GitHub Issue][GitHub issue]
-- [Join our Discord][Join Discord]
-- [Matrix Chat][Matrix Chat]
+- [GitHub Issues][issues]
+- [Discord][discord]
+- [Matrix][matrix]
 
-[GitHub issue]: https://github.com/aperturerobotics/starpc/issues/new
-[Join Discord]: https://discord.gg/KJutMESRsT
-[Matrix Chat]: https://matrix.to/#/#aperturerobotics:matrix.org
+[issues]: https://github.com/aperturerobotics/starpc/issues/new
+[discord]: https://discord.gg/KJutMESRsT
+[matrix]: https://matrix.to/#/#aperturerobotics:matrix.org

package/dist/srpc/conn.d.ts

@@ -1,27 +1,26 @@
 import { YamuxMuxerInit } from '@chainsafe/libp2p-yamux';
-import type { MessageStreamDirection, Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface';
-import type { Duplex, Source } from 'it-stream-types';
+import type { ComponentLogger, Direction, Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface';
+import type { Duplex } from 'it-stream-types';
 import { Uint8ArrayList } from 'uint8arraylist';
 import { type OpenStreamFunc, type PacketStream } from './stream.js';
 import { Client } from './client.js';
 export interface StreamConnParams {
-    loggerName?: string;
+    logger?: ComponentLogger;
     muxerFactory?: StreamMuxerFactory;
-    direction?: MessageStreamDirection;
+    direction?: Direction;
     yamuxParams?: YamuxMuxerInit;
 }
 export interface StreamHandler {
     handlePacketStream(strm: PacketStream): void;
 }
-export declare class StreamConn implements Duplex<AsyncIterable<Uint8Array | Uint8ArrayList>, Source<Uint8Array | Uint8ArrayList>, Promise<void>> {
+export declare class StreamConn implements Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
     private _muxer;
-    private _messageStream;
     private _server?;
     constructor(server?: StreamHandler, connParams?: StreamConnParams);
-    get sink(): (source: Source<Uint8Array | Uint8ArrayList>) => Promise<void>;
-    get source(): AsyncIterable<Uint8Array | Uint8ArrayList>;
+    get sink(): import("it-stream-types").Sink<AsyncGenerator<Uint8Array<ArrayBufferLike> | Uint8ArrayList, any, any>, unknown>;
+    get source(): AsyncGenerator<Uint8Array<ArrayBufferLike> | Uint8ArrayList, any, any>;
     get streams(): Stream[];
-    get muxer(): StreamMuxer<Stream>;
+    get muxer(): StreamMuxer;
     get server(): StreamHandler | undefined;
     buildClient(): Client;
     openStream(): Promise<PacketStream>;

package/dist/srpc/conn.js

@@ -1,7 +1,7 @@
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { streamToPacketStream, } from './stream.js';
 import { Client } from './client.js';
-import { createDuplexMessageStream, } from './duplex-message-stream.js';
+import { createDisabledComponentLogger } from './log.js';
 // StreamConn implements a generic connection with a two-way stream.
 // The stream is not expected to manage packet boundaries.
 // Packets will be sent with uint32le length prefixes.
@@ -13,37 +13,28 @@ import { createDuplexMessageStream, } from './duplex-message-stream.js';
 export class StreamConn {
     // muxer is the stream muxer.
     _muxer;
-    // messageStream wraps the duplex as a MessageStream for the muxer.
-    _messageStream;
     // server is the server side, if set.
     _server;
     constructor(server, connParams) {
         if (server) {
             this._server = server;
         }
-        // Create the MessageStream adapter
-        const direction = connParams?.direction || 'outbound';
-        this._messageStream = createDuplexMessageStream({
-            loggerName: connParams?.loggerName,
-            direction,
-        });
-        // Create the muxer factory - yamux(init)() returns a StreamMuxerFactory
         const muxerFactory = connParams?.muxerFactory ??
-            yamux({ enableKeepAlive: false, ...connParams?.yamuxParams })();
-        // Create the muxer with the MessageStream
-        this._muxer = muxerFactory.createStreamMuxer(this._messageStream);
-        // Listen for incoming streams
-        this._muxer.addEventListener('stream', (evt) => {
-            this.handleIncomingStream(evt.detail);
+            yamux({ enableKeepAlive: false, ...connParams?.yamuxParams })({
+                logger: connParams?.logger ?? createDisabledComponentLogger(),
+            });
+        this._muxer = muxerFactory.createStreamMuxer({
+            onIncomingStream: this.handleIncomingStream.bind(this),
+            direction: connParams?.direction || 'outbound',
         });
     }
     // sink returns the message sink.
     get sink() {
-        return this._messageStream.sink;
+        return this._muxer.sink;
     }
     // source returns the outgoing message source.
     get source() {
-        return this._messageStream.source;
+        return this._muxer.source;
     }
     // streams returns the set of all ongoing streams.
     get streams() {
@@ -63,7 +54,7 @@ export class StreamConn {
     }
     // openStream implements the client open stream function.
     async openStream() {
-        const strm = await this.muxer.createStream();
+        const strm = await this.muxer.newStream();
         return streamToPacketStream(strm);
     }
     // buildOpenStreamFunc returns openStream bound to this conn.

package/dist/srpc/index.d.ts

@@ -20,4 +20,3 @@ export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } from './pushable.js';
 export { Watchdog } from './watchdog.js';
 export { ProtoRpc } from './proto-rpc.js';
-export { DuplexMessageStream, DuplexMessageStreamInit, createDuplexMessageStream, } from './duplex-message-stream.js';

package/dist/srpc/index.js

@@ -18,4 +18,3 @@ export { OpenStreamCtr } from './open-stream-ctr.js';
 export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } from './pushable.js';
 export { Watchdog } from './watchdog.js';
-export { DuplexMessageStream, createDuplexMessageStream, } from './duplex-message-stream.js';

package/dist/srpc/log.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentLogger, Logger } from '@libp2p/interface';
+export declare function createDisabledLogger(namespace: string): Logger;
+export declare function createDisabledComponentLogger(): ComponentLogger;

package/dist/srpc/log.js

@@ -0,0 +1,22 @@
+// https://github.com/libp2p/js-libp2p/issues/2276
+// https://github.com/libp2p/js-libp2p/blob/bca8d6e689b47d85dda74082ed72e671139391de/packages/logger/src/index.ts#L86
+// https://github.com/libp2p/js-libp2p/issues/2275
+// https://github.com/ChainSafe/js-libp2p-yamux/issues/69
+export function createDisabledLogger(namespace) {
+    const logger = () => { };
+    logger.enabled = false;
+    logger.color = '';
+    logger.diff = 0;
+    logger.log = () => { };
+    logger.namespace = namespace;
+    logger.destroy = () => true;
+    logger.extend = () => logger;
+    logger.debug = logger;
+    logger.error = logger;
+    logger.trace = logger;
+    logger.newScope = () => logger;
+    return logger;
+}
+export function createDisabledComponentLogger() {
+    return { forComponent: createDisabledLogger };
+}

package/dist/srpc/stream.d.ts

@@ -1,5 +1,5 @@
 import type { Duplex, Source } from 'it-stream-types';
-import type { Stream } from '@libp2p/interface';
+import { Stream } from '@libp2p/interface';
 import type { Packet } from './rpcproto.pb.js';
 export type PacketHandler = (packet: Packet) => Promise<void>;
 export type PacketStream = Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>;

package/dist/srpc/stream.js

@@ -8,17 +8,9 @@ export function streamToPacketStream(stream) {
     return {
         source: pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform()),
         sink: async (source) => {
-            try {
-                for await (const data of pipe(source, prependLengthPrefixTransform())) {
-                    stream.send(data);
-                }
-                await stream.close();
-            }
-            catch (err) {
-                await stream
-                    .close({ signal: AbortSignal.timeout(1000) })
-                    .catch(() => { });
-            }
+            await pipe(source, prependLengthPrefixTransform(), stream)
+                .catch((err) => stream.close(err))
+                .then(() => stream.close());
         },
     };
 }

package/dist/srpc/websocket.d.ts

@@ -1,9 +1,9 @@
-import type { MessageStreamDirection } from '@libp2p/interface';
+import { Direction } from '@libp2p/interface';
 import type WebSocket from '@aptre/it-ws/web-socket';
 import { StreamConn } from './conn.js';
 import { Server } from './server.js';
 export declare class WebSocketConn extends StreamConn {
     private socket;
-    constructor(socket: WebSocket, direction: MessageStreamDirection, server?: Server);
+    constructor(socket: WebSocket, direction: Direction, server?: Server);
     getSocket(): WebSocket;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -85,27 +85,26 @@
     "./{srpc,echo,e2e,integration,rpcstream,cmd}/**/(*.ts|*.tsx|*.html|*.css)": "prettier --config .prettierrc.yaml --write"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.39.1",
-    "@typescript-eslint/parser": "^8.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.0",
+    "@typescript-eslint/parser": "^8.48.0",
     "depcheck": "^1.4.6",
     "esbuild": "^0.27.0",
-    "eslint": "^9.33.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.0.2",
+    "happy-dom": "^20.0.10",
     "husky": "^9.1.7",
-    "lint-staged": "^16.1.5",
+    "lint-staged": "^16.2.7",
     "prettier": "^3.5.3",
-    "rimraf": "^6.0.1",
+    "rimraf": "^6.1.2",
     "tsx": "^4.20.4",
     "typescript": "^5.8.2",
-    "vitest": "^4.0.0"
+    "vitest": "^4.0.14"
   },
   "dependencies": {
     "@aptre/it-ws": "^1.1.2",
     "@aptre/protobuf-es-lite": "^0.5.2",
-    "@chainsafe/libp2p-yamux": "^8.0.0",
-    "@libp2p/interface": "^3.0.0",
-    "@libp2p/logger": "^6.2.2",
-    "@libp2p/utils": "^7.0.9",
+    "@chainsafe/libp2p-yamux": "^7.0.1",
+    "@libp2p/interface": "^2.6.1",
     "event-iterator": "^2.0.0",
     "isomorphic-ws": "^5.0.0",
     "it-first": "^3.0.6",

package/srpc/conn.ts

@@ -1,11 +1,12 @@
 import { YamuxMuxerInit, yamux } from '@chainsafe/libp2p-yamux'
 import type {
-  MessageStreamDirection,
+  ComponentLogger,
+  Direction,
   Stream,
   StreamMuxer,
   StreamMuxerFactory,
 } from '@libp2p/interface'
-import type { Duplex, Source } from 'it-stream-types'
+import type { Duplex } from 'it-stream-types'
 import { Uint8ArrayList } from 'uint8arraylist'
 
 import {
@@ -14,20 +15,17 @@ import {
   type PacketStream,
 } from './stream.js'
 import { Client } from './client.js'
-import {
-  DuplexMessageStream,
-  createDuplexMessageStream,
-} from './duplex-message-stream.js'
+import { createDisabledComponentLogger } from './log.js'
 
 // ConnParams are parameters that can be passed to the StreamConn constructor.
 export interface StreamConnParams {
-  // loggerName is the debug-style logger name (e.g. 'starpc:conn').
-  loggerName?: string
+  // logger is the logger to use, defaults to disabled logger.
+  logger?: ComponentLogger
   // muxerFactory overrides using the default yamux factory.
   muxerFactory?: StreamMuxerFactory
   // direction is the muxer connection direction.
   // defaults to outbound (client).
-  direction?: MessageStreamDirection
+  direction?: Direction
   // yamuxParams are parameters to pass to yamux.
   // only used if muxerFactory is unset
   yamuxParams?: YamuxMuxerInit
@@ -50,17 +48,10 @@ export interface StreamHandler {
 // Implements the server by handling incoming streams.
 // If the server is unset, rejects any incoming streams.
 export class StreamConn
-  implements
-    Duplex<
-      AsyncIterable<Uint8Array | Uint8ArrayList>,
-      Source<Uint8Array | Uint8ArrayList>,
-      Promise<void>
-    >
+  implements Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>>
 {
   // muxer is the stream muxer.
   private _muxer: StreamMuxer
-  // messageStream wraps the duplex as a MessageStream for the muxer.
-  private _messageStream: DuplexMessageStream
   // server is the server side, if set.
   private _server?: StreamHandler
 
@@ -68,36 +59,25 @@ export class StreamConn
     if (server) {
       this._server = server
     }
-
-    // Create the MessageStream adapter
-    const direction = connParams?.direction || 'outbound'
-    this._messageStream = createDuplexMessageStream({
-      loggerName: connParams?.loggerName,
-      direction,
-    })
-
-    // Create the muxer factory - yamux(init)() returns a StreamMuxerFactory
     const muxerFactory =
       connParams?.muxerFactory ??
-      yamux({ enableKeepAlive: false, ...connParams?.yamuxParams })()
-
-    // Create the muxer with the MessageStream
-    this._muxer = muxerFactory.createStreamMuxer(this._messageStream)
-
-    // Listen for incoming streams
-    this._muxer.addEventListener('stream', (evt) => {
-      this.handleIncomingStream(evt.detail)
+      yamux({ enableKeepAlive: false, ...connParams?.yamuxParams })({
+        logger: connParams?.logger ?? createDisabledComponentLogger(),
+      })
+    this._muxer = muxerFactory.createStreamMuxer({
+      onIncomingStream: this.handleIncomingStream.bind(this),
+      direction: connParams?.direction || 'outbound',
     })
   }
 
   // sink returns the message sink.
-  get sink(): (source: Source<Uint8Array | Uint8ArrayList>) => Promise<void> {
-    return this._messageStream.sink
+  get sink() {
+    return this._muxer.sink
   }
 
   // source returns the outgoing message source.
-  get source(): AsyncIterable<Uint8Array | Uint8ArrayList> {
-    return this._messageStream.source
+  get source() {
+    return this._muxer.source
   }
 
   // streams returns the set of all ongoing streams.
@@ -122,7 +102,7 @@ export class StreamConn
 
   // openStream implements the client open stream function.
   public async openStream(): Promise<PacketStream> {
-    const strm = await this.muxer.createStream()
+    const strm = await this.muxer.newStream()
     return streamToPacketStream(strm)
   }
 

package/srpc/index.ts

@@ -81,8 +81,3 @@ export {
 } from './pushable.js'
 export { Watchdog } from './watchdog.js'
 export { ProtoRpc } from './proto-rpc.js'
-export {
-  DuplexMessageStream,
-  DuplexMessageStreamInit,
-  createDuplexMessageStream,
-} from './duplex-message-stream.js'

package/srpc/log.ts

@@ -0,0 +1,26 @@
+import type { ComponentLogger, Logger } from '@libp2p/interface'
+
+// https://github.com/libp2p/js-libp2p/issues/2276
+// https://github.com/libp2p/js-libp2p/blob/bca8d6e689b47d85dda74082ed72e671139391de/packages/logger/src/index.ts#L86
+// https://github.com/libp2p/js-libp2p/issues/2275
+// https://github.com/ChainSafe/js-libp2p-yamux/issues/69
+export function createDisabledLogger(namespace: string): Logger {
+  const logger = (): void => {}
+  logger.enabled = false
+  logger.color = ''
+  logger.diff = 0
+  logger.log = (): void => {}
+  logger.namespace = namespace
+  logger.destroy = () => true
+  logger.extend = () => logger
+  logger.debug = logger
+  logger.error = logger
+  logger.trace = logger
+  logger.newScope = () => logger
+
+  return logger
+}
+
+export function createDisabledComponentLogger(): ComponentLogger {
+  return { forComponent: createDisabledLogger }
+}

package/srpc/stream.ts

@@ -1,6 +1,6 @@
 import type { Duplex, Source } from 'it-stream-types'
 import { pipe } from 'it-pipe'
-import type { Stream } from '@libp2p/interface'
+import { Stream } from '@libp2p/interface'
 
 import type { Packet } from './rpcproto.pb.js'
 import { combineUint8ArrayListTransform } from './array-list.js'
@@ -38,16 +38,9 @@ export function streamToPacketStream(stream: Stream): PacketStream {
       combineUint8ArrayListTransform(),
     ),
     sink: async (source: Source<Uint8Array>): Promise<void> => {
-      try {
-        for await (const data of pipe(source, prependLengthPrefixTransform())) {
-          stream.send(data)
-        }
-        await stream.close()
-      } catch (err: unknown) {
-        await stream
-          .close({ signal: AbortSignal.timeout(1000) })
-          .catch(() => {})
-      }
+      await pipe(source, prependLengthPrefixTransform(), stream)
+        .catch((err) => stream.close(err))
+        .then(() => stream.close())
     },
   }
 }

package/srpc/websocket.ts

@@ -1,5 +1,5 @@
 import { pipe } from 'it-pipe'
-import type { MessageStreamDirection } from '@libp2p/interface'
+import { Direction } from '@libp2p/interface'
 
 import duplex from '@aptre/it-ws/duplex'
 import type WebSocket from '@aptre/it-ws/web-socket'
@@ -13,11 +13,7 @@ export class WebSocketConn extends StreamConn {
   // socket is the web socket
   private socket: WebSocket
 
-  constructor(
-    socket: WebSocket,
-    direction: MessageStreamDirection,
-    server?: Server,
-  ) {
+  constructor(socket: WebSocket, direction: Direction, server?: Server) {
     super(server, { direction })
     this.socket = socket
     const socketDuplex = duplex(socket)

package/dist/srpc/duplex-message-stream.d.ts

@@ -1,22 +0,0 @@
-import type { AbortOptions, MessageStreamDirection } from '@libp2p/interface';
-import { AbstractMessageStream, type SendResult } from '@libp2p/utils';
-import type { Duplex, Source } from 'it-stream-types';
-import { Uint8ArrayList } from 'uint8arraylist';
-export interface DuplexMessageStreamInit {
-    direction?: MessageStreamDirection;
-    loggerName?: string;
-    inactivityTimeout?: number;
-    maxReadBufferLength?: number;
-}
-export declare class DuplexMessageStream extends AbstractMessageStream {
-    private readonly _outgoing;
-    constructor(init?: DuplexMessageStreamInit);
-    get source(): AsyncIterable<Uint8Array | Uint8ArrayList>;
-    get sink(): (source: Source<Uint8Array | Uint8ArrayList>) => Promise<void>;
-    sendData(data: Uint8ArrayList): SendResult;
-    sendReset(_err: Error): void;
-    sendPause(): void;
-    sendResume(): void;
-    close(_options?: AbortOptions): Promise<void>;
-}
-export declare function createDuplexMessageStream(init?: DuplexMessageStreamInit): DuplexMessageStream & Duplex<AsyncIterable<Uint8Array | Uint8ArrayList>>;

package/dist/srpc/duplex-message-stream.js

@@ -1,95 +0,0 @@
-import { logger } from '@libp2p/logger';
-import { AbstractMessageStream, } from '@libp2p/utils';
-import { pushable } from 'it-pushable';
-// DuplexMessageStream wraps a Duplex stream as a MessageStream.
-// This allows using duplex streams with the new libp2p StreamMuxer API.
-//
-// Extends AbstractMessageStream to get proper read/write buffer management,
-// backpressure handling, and event semantics from libp2p.
-export class DuplexMessageStream extends AbstractMessageStream {
-    // _outgoing is a pushable that collects data to be sent out.
-    _outgoing;
-    constructor(init) {
-        // Create the MessageStreamInit required by AbstractMessageStream
-        const streamInit = {
-            log: logger(init?.loggerName ?? 'starpc:duplex-message-stream'),
-            direction: init?.direction ?? 'outbound',
-            inactivityTimeout: init?.inactivityTimeout,
-            maxReadBufferLength: init?.maxReadBufferLength,
-        };
-        super(streamInit);
-        this._outgoing = pushable();
-    }
-    // source returns an async iterable that yields data to be sent to the remote.
-    get source() {
-        return this._outgoing;
-    }
-    // sink consumes data from the remote and feeds it into the stream.
-    // This is the receiving end of the duplex.
-    get sink() {
-        return async (source) => {
-            try {
-                for await (const data of source) {
-                    if (this.status === 'closed' ||
-                        this.status === 'aborted' ||
-                        this.status === 'reset') {
-                        break;
-                    }
-                    // Use the parent's onData method which handles buffering and events
-                    this.onData(data);
-                }
-                // Remote closed their write side
-                this.onRemoteCloseWrite();
-            }
-            catch (err) {
-                this.abort(err);
-            }
-        };
-    }
-    // sendData implements AbstractMessageStream.sendData
-    // Called by the parent class when processing the write queue.
-    sendData(data) {
-        // Push data to the outgoing pushable
-        this._outgoing.push(data);
-        return {
-            sentBytes: data.byteLength,
-            canSendMore: true, // Our pushable can always accept more
-        };
-    }
-    // sendReset implements AbstractMessageStream.sendReset
-    // Called when the stream is aborted locally.
-    sendReset(_err) {
-        // End the outgoing pushable - we can't send a reset over a generic duplex
-        this._outgoing.end();
-    }
-    // sendPause implements AbstractMessageStream.sendPause
-    // Called when the stream is paused.
-    sendPause() {
-        // No-op: generic duplex streams don't support pause signaling
-        this.log.trace('pause requested (no-op for duplex stream)');
-    }
-    // sendResume implements AbstractMessageStream.sendResume
-    // Called when the stream is resumed.
-    sendResume() {
-        // No-op: generic duplex streams don't support resume signaling
-        this.log.trace('resume requested (no-op for duplex stream)');
-    }
-    // close gracefully closes the stream.
-    async close(_options) {
-        if (this.status === 'closed' || this.status === 'closing') {
-            return;
-        }
-        this.status = 'closing';
-        this.writeStatus = 'closing';
-        // End the outgoing pushable to signal we're done writing
-        this._outgoing.end();
-        this.writeStatus = 'closed';
-        if (this.readStatus === 'closed') {
-            this.onTransportClosed();
-        }
-    }
-}
-// createDuplexMessageStream creates a new DuplexMessageStream.
-export function createDuplexMessageStream(init) {
-    return new DuplexMessageStream(init);
-}

package/srpc/duplex-message-stream.ts

@@ -1,132 +0,0 @@
-import type { AbortOptions, MessageStreamDirection } from '@libp2p/interface'
-import { logger } from '@libp2p/logger'
-import {
-  AbstractMessageStream,
-  type MessageStreamInit,
-  type SendResult,
-} from '@libp2p/utils'
-import type { Duplex, Source } from 'it-stream-types'
-import { pushable, type Pushable } from 'it-pushable'
-import { Uint8ArrayList } from 'uint8arraylist'
-
-// DuplexMessageStreamInit are parameters for DuplexMessageStream.
-export interface DuplexMessageStreamInit {
-  // direction is the stream direction.
-  direction?: MessageStreamDirection
-  // loggerName is the name to use for the logger.
-  loggerName?: string
-  // inactivityTimeout is the inactivity timeout in ms.
-  inactivityTimeout?: number
-  // maxReadBufferLength is the max read buffer length.
-  maxReadBufferLength?: number
-}
-
-// DuplexMessageStream wraps a Duplex stream as a MessageStream.
-// This allows using duplex streams with the new libp2p StreamMuxer API.
-//
-// Extends AbstractMessageStream to get proper read/write buffer management,
-// backpressure handling, and event semantics from libp2p.
-export class DuplexMessageStream extends AbstractMessageStream {
-  // _outgoing is a pushable that collects data to be sent out.
-  private readonly _outgoing: Pushable<Uint8Array | Uint8ArrayList>
-
-  constructor(init?: DuplexMessageStreamInit) {
-    // Create the MessageStreamInit required by AbstractMessageStream
-    const streamInit: MessageStreamInit = {
-      log: logger(init?.loggerName ?? 'starpc:duplex-message-stream'),
-      direction: init?.direction ?? 'outbound',
-      inactivityTimeout: init?.inactivityTimeout,
-      maxReadBufferLength: init?.maxReadBufferLength,
-    }
-    super(streamInit)
-    this._outgoing = pushable<Uint8Array | Uint8ArrayList>()
-  }
-
-  // source returns an async iterable that yields data to be sent to the remote.
-  get source(): AsyncIterable<Uint8Array | Uint8ArrayList> {
-    return this._outgoing
-  }
-
-  // sink consumes data from the remote and feeds it into the stream.
-  // This is the receiving end of the duplex.
-  get sink(): (source: Source<Uint8Array | Uint8ArrayList>) => Promise<void> {
-    return async (
-      source: Source<Uint8Array | Uint8ArrayList>,
-    ): Promise<void> => {
-      try {
-        for await (const data of source) {
-          if (
-            this.status === 'closed' ||
-            this.status === 'aborted' ||
-            this.status === 'reset'
-          ) {
-            break
-          }
-          // Use the parent's onData method which handles buffering and events
-          this.onData(data)
-        }
-        // Remote closed their write side
-        this.onRemoteCloseWrite()
-      } catch (err) {
-        this.abort(err as Error)
-      }
-    }
-  }
-
-  // sendData implements AbstractMessageStream.sendData
-  // Called by the parent class when processing the write queue.
-  sendData(data: Uint8ArrayList): SendResult {
-    // Push data to the outgoing pushable
-    this._outgoing.push(data)
-    return {
-      sentBytes: data.byteLength,
-      canSendMore: true, // Our pushable can always accept more
-    }
-  }
-
-  // sendReset implements AbstractMessageStream.sendReset
-  // Called when the stream is aborted locally.
-  sendReset(_err: Error): void {
-    // End the outgoing pushable - we can't send a reset over a generic duplex
-    this._outgoing.end()
-  }
-
-  // sendPause implements AbstractMessageStream.sendPause
-  // Called when the stream is paused.
-  sendPause(): void {
-    // No-op: generic duplex streams don't support pause signaling
-    this.log.trace('pause requested (no-op for duplex stream)')
-  }
-
-  // sendResume implements AbstractMessageStream.sendResume
-  // Called when the stream is resumed.
-  sendResume(): void {
-    // No-op: generic duplex streams don't support resume signaling
-    this.log.trace('resume requested (no-op for duplex stream)')
-  }
-
-  // close gracefully closes the stream.
-  async close(_options?: AbortOptions): Promise<void> {
-    if (this.status === 'closed' || this.status === 'closing') {
-      return
-    }
-    this.status = 'closing'
-    this.writeStatus = 'closing'
-
-    // End the outgoing pushable to signal we're done writing
-    this._outgoing.end()
-
-    this.writeStatus = 'closed'
-    if (this.readStatus === 'closed') {
-      this.onTransportClosed()
-    }
-  }
-}
-
-// createDuplexMessageStream creates a new DuplexMessageStream.
-export function createDuplexMessageStream(
-  init?: DuplexMessageStreamInit,
-): DuplexMessageStream & Duplex<AsyncIterable<Uint8Array | Uint8ArrayList>> {
-  return new DuplexMessageStream(init) as DuplexMessageStream &
-    Duplex<AsyncIterable<Uint8Array | Uint8ArrayList>>
-}