starpc 0.40.1 → 0.41.0

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 {
-                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.1",
+  "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 {
-        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,23 +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;
-    private readonly _sink;
-    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,98 +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;
-    // _sink is the bound sink function
-    _sink;
-    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();
-        this._sink = 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);
-            }
-        };
-    }
-    // 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 this._sink;
-    }
-    // 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,137 +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>
-  // _sink is the bound sink function
-  private readonly _sink: (
-    source: Source<Uint8Array | Uint8ArrayList>,
-  ) => Promise<void>
-
-  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>()
-    this._sink = 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)
-      }
-    }
-  }
-
-  // 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 this._sink
-  }
-
-  // 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>>
-}