starpc 0.23.2 → 0.24.0

package/dist/e2e/e2e.js

@@ -1,18 +1,19 @@
 import { pipe } from 'it-pipe';
-import { createHandler, createMux, Server, Client, Conn } from '../srpc';
+import { createHandler, createMux, Server, Client, StreamConn } from '../srpc';
 import { EchoerDefinition, EchoerServer, runClientTest } from '../echo';
-import { runRpcStreamTest } from '../echo/client-test';
+import { runAbortControllerTest, runRpcStreamTest } from '../echo/client-test';
 async function runRPC() {
     const mux = createMux();
     const server = new Server(mux.lookupMethodFunc);
     const echoer = new EchoerServer(server);
     mux.register(createHandler(EchoerDefinition, echoer));
-    const clientConn = new Conn();
-    const serverConn = new Conn(server, { direction: 'inbound' });
+    const clientConn = new StreamConn();
+    const serverConn = new StreamConn(server, { direction: 'inbound' });
     pipe(clientConn, serverConn, clientConn);
     const client = new Client(clientConn.buildOpenStreamFunc());
-    await runRpcStreamTest(client);
     await runClientTest(client);
+    await runAbortControllerTest(client);
+    await runRpcStreamTest(client);
 }
 runRPC()
     .then(() => {

package/dist/rpcstream/rpcstream.d.ts

@@ -1,14 +1,14 @@
-import { RpcStreamPacket } from './rpcstream.pb.js';
-import { OpenStreamFunc, Stream } from '../srpc/stream.js';
 import { Pushable } from 'it-pushable';
 import { Source, Sink } from 'it-stream-types';
+import { RpcStreamPacket } from './rpcstream.pb.js';
+import { OpenStreamFunc, PacketStream } from '../srpc/stream.js';
 export type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
-export declare function openRpcStream(componentId: string, caller: RpcStreamCaller, waitAck?: boolean): Promise<Stream>;
+export declare function openRpcStream(componentId: string, caller: RpcStreamCaller, waitAck?: boolean): Promise<PacketStream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
-export type RpcStreamHandler = (stream: Stream) => void;
+export type RpcStreamHandler = (stream: PacketStream) => void;
 export type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
 export declare function handleRpcStream(packetRx: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
-export declare class RpcStream implements Stream {
+export declare class RpcStream implements PacketStream {
     readonly source: AsyncGenerator<Uint8Array>;
     readonly sink: Sink<Source<Uint8Array>, Promise<void>>;
     private readonly _packetRx;

package/dist/rpcstream/rpcstream.js

@@ -92,7 +92,7 @@ export async function* handleRpcStream(packetRx, getter) {
         yield* [packet];
     }
 }
-// RpcStream implements the Stream on top of a RPC call.
+// RpcStream implements the PacketStream on top of a RPC call.
 // Note: expects the stream to already have been negotiated.
 export class RpcStream {
     // packetTx writes packets to the remote.

package/dist/srpc/broadcast-channel.d.ts

@@ -1,23 +1,19 @@
-import type { Source } from 'it-stream-types';
-import { ConnParams } from './conn.js';
+import type { Duplex, Source } from 'it-stream-types';
+import { StreamConn, StreamConnParams } from './conn.js';
 import { Server } from './server.js';
-import { StreamConn } from './conn-stream.js';
-import { Stream } from './stream.js';
-export declare class BroadcastChannelDuplex<T> implements Stream<T> {
-    readonly readChannel: BroadcastChannel;
-    readonly writeChannel: BroadcastChannel;
+export declare class BroadcastChannelDuplex<T> implements Duplex<AsyncGenerator<T>, Source<T>, Promise<void>> {
+    readonly read: BroadcastChannel;
+    readonly write: BroadcastChannel;
     sink: (source: Source<T>) => Promise<void>;
     source: AsyncGenerator<T>;
-    constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel);
+    constructor(read: BroadcastChannel, write: BroadcastChannel);
     close(): void;
     private _createSink;
     private _createSource;
 }
 export declare function newBroadcastChannelDuplex<T>(readName: string, writeName: string): BroadcastChannelDuplex<T>;
 export declare class BroadcastChannelConn extends StreamConn {
-    private broadcastChannel;
-    constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel, server?: Server, connParams?: ConnParams);
-    getReadChannel(): BroadcastChannel;
-    getWriteChannel(): BroadcastChannel;
-    close(): void;
+    readonly duplex: BroadcastChannelDuplex<Uint8Array>;
+    constructor(duplex: BroadcastChannelDuplex<Uint8Array>, server?: Server, connParams?: StreamConnParams);
+    close(err?: Error): void;
 }

package/dist/srpc/broadcast-channel.js

@@ -1,42 +1,67 @@
 import { EventIterator } from 'event-iterator';
-import { StreamConn } from './conn-stream.js';
+import { StreamConn } from './conn.js';
+import { combineUint8ArrayListTransform } from './array-list.js';
+import { pipe } from 'it-pipe';
 // BroadcastChannelDuplex is a AsyncIterable wrapper for BroadcastChannel.
+//
+// When the sink is closed, the broadcast channel also be closed.
+// Note: there is no way to know when a BroadcastChannel is closed!
+// You will need an additional keep-alive on top of BroadcastChannelDuplex.
 export class BroadcastChannelDuplex {
-    constructor(readChannel, writeChannel) {
-        this.readChannel = readChannel;
-        this.writeChannel = writeChannel;
+    constructor(read, write) {
+        this.read = read;
+        this.write = write;
         this.sink = this._createSink();
         this.source = this._createSource();
     }
-    // close closes the broadcast channels.
+    // close closes the message port.
     close() {
-        this.readChannel.close();
-        this.writeChannel.close();
+        this.write.postMessage(null);
+        this.write.close();
+        this.read.close();
     }
     // _createSink initializes the sink field.
     _createSink() {
         return async (source) => {
-            for await (const msg of source) {
-                this.writeChannel.postMessage(msg);
+            try {
+                for await (const msg of source) {
+                    this.write.postMessage(msg);
+                }
+            }
+            catch (err) {
+                this.close();
+                throw err;
             }
+            this.close();
         };
     }
     // _createSource initializes the source field.
     async *_createSource() {
         const iterator = new EventIterator((queue) => {
             const messageListener = (ev) => {
-                if (ev.data) {
-                    queue.push(ev.data);
+                const data = ev.data;
+                if (data !== null) {
+                    queue.push(data);
+                }
+                else {
+                    queue.stop();
                 }
             };
-            this.readChannel.addEventListener('message', messageListener);
+            this.read.addEventListener('message', messageListener);
             return () => {
-                this.readChannel.removeEventListener('message', messageListener);
+                this.read.removeEventListener('message', messageListener);
             };
         });
-        for await (const value of iterator) {
-            yield value;
+        try {
+            for await (const value of iterator) {
+                yield value;
+            }
         }
+        catch (err) {
+            this.close();
+            throw err;
+        }
+        this.close();
     }
 }
 // newBroadcastChannelDuplex constructs a BroadcastChannelDuplex with a channel name.
@@ -46,22 +71,31 @@ export function newBroadcastChannelDuplex(readName, writeName) {
 // BroadcastChannelConn implements a connection with a BroadcastChannel.
 //
 // expects Uint8Array objects over the BroadcastChannel.
+// uses Yamux to mux streams over the port.
 export class BroadcastChannelConn extends StreamConn {
-    constructor(readChannel, writeChannel, server, connParams) {
-        const broadcastChannel = new BroadcastChannelDuplex(readChannel, writeChannel);
-        super(broadcastChannel, server, connParams);
-        this.broadcastChannel = broadcastChannel;
-    }
-    // getReadChannel returns the read BroadcastChannel.
-    getReadChannel() {
-        return this.broadcastChannel.readChannel;
-    }
-    // getWriteChannel returns the write BroadcastChannel.
-    getWriteChannel() {
-        return this.broadcastChannel.writeChannel;
+    constructor(duplex, server, connParams) {
+        super(server, {
+            ...connParams,
+            yamuxParams: {
+                // There is no way to tell when a BroadcastChannel is closed.
+                // We will send an undefined object through the BroadcastChannel to indicate closed.
+                // We still need a way to detect when the connection is not cleanly terminated.
+                // Enable keep-alive to detect this on the other end.
+                enableKeepAlive: true,
+                keepAliveInterval: 1500,
+                ...connParams?.yamuxParams,
+            },
+        });
+        this.duplex = duplex;
+        pipe(duplex, this, 
+        // Uint8ArrayList usually cannot be sent over BroadcastChannel, so we combine to a Uint8Array as part of the pipe.
+        combineUint8ArrayListTransform(), duplex)
+            .catch((err) => this.close(err))
+            .then(() => this.close());
     }
-    // close closes the read and write channels.
-    close() {
-        this.broadcastChannel.close();
+    // close closes the message port.
+    close(err) {
+        super.close(err);
+        this.duplex.close();
     }
 }

package/dist/srpc/client.js

@@ -42,7 +42,9 @@ export class Client {
         const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, data, abortSignal)
             .then(async (call) => {
-            return writeToPushable(call.rpcDataSource, serverData);
+            const result = writeToPushable(call.rpcDataSource, serverData);
+            result.finally(() => call.close());
+            return result;
         })
             .catch((err) => serverData.end(err));
         return serverData;
@@ -52,15 +54,17 @@ export class Client {
         const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, null, abortSignal)
             .then(async (call) => {
-            call.writeCallDataFromSource(data);
+            call.writeCallDataFromSource(data).catch((err) => call.close(err));
             try {
                 for await (const message of call.rpcDataSource) {
                     serverData.push(message);
                 }
                 serverData.end();
+                call.close();
             }
             catch (err) {
-                serverData.end(err);
+                call.close(err);
+                throw err;
             }
         })
             .catch((err) => serverData.end(err));
@@ -77,9 +81,12 @@ export class Client {
         const stream = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         abortSignal?.addEventListener('abort', () => {
+            call.writeCallCancel();
             call.close(new Error(ERR_RPC_ABORT));
         });
-        pipe(stream, decodePacketSource, call, encodePacketSource, stream);
+        pipe(stream, decodePacketSource, call, encodePacketSource, stream)
+            .then(() => call.close())
+            .catch((err) => call.close(err));
         await call.writeCallStart(data || undefined);
         return call;
     }

package/dist/srpc/common-rpc.d.ts

@@ -2,8 +2,8 @@ import type { Sink, Source } from 'it-stream-types';
 import type { CallData, CallStart } from './rpcproto.pb.js';
 import { Packet } from './rpcproto.pb.js';
 export declare class CommonRPC {
-    sink: Sink<Source<Packet>>;
-    source: AsyncIterable<Packet>;
+    readonly sink: Sink<Source<Packet>>;
+    readonly source: AsyncIterable<Packet>;
     readonly rpcDataSource: AsyncIterable<Uint8Array>;
     private readonly _source;
     private readonly _rpcDataSource;
@@ -20,6 +20,8 @@ export declare class CommonRPC {
     handleCallStart(packet: Partial<CallStart>): Promise<void>;
     protected pushRpcData(data: Uint8Array | undefined, dataIsZero: boolean | undefined): void;
     handleCallData(packet: Partial<CallData>): Promise<void>;
+    handleCallCancel(): Promise<void>;
     close(err?: Error): Promise<void>;
+    closeWrite(): void;
     private _createSink;
 }

package/dist/srpc/common-rpc.js

@@ -1,5 +1,6 @@
 import { pushable } from 'it-pushable';
 import { Packet } from './rpcproto.pb.js';
+import { ERR_RPC_ABORT } from './errors.js';
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {
     constructor() {
@@ -65,6 +66,7 @@ export class CommonRPC {
     //
     // note: closes the stream if any error is thrown.
     async handlePacket(packet) {
+        // console.log('handlePacket', packet)
         try {
             switch (packet?.body?.$case) {
                 case 'callStart':
@@ -73,6 +75,11 @@ export class CommonRPC {
                 case 'callData':
                     await this.handleCallData(packet.body.callData);
                     break;
+                case 'callCancel':
+                    if (packet.body.callCancel) {
+                        await this.handleCallCancel();
+                    }
+                    break;
             }
         }
         catch (err) {
@@ -114,20 +121,26 @@ export class CommonRPC {
             this._rpcDataSource.end();
         }
     }
+    // handleCallCancel handles a CallCancel packet.
+    async handleCallCancel() {
+        this.close(new Error(ERR_RPC_ABORT));
+    }
     // close closes the call, optionally with an error.
     async close(err) {
         if (this.closed) {
             return;
         }
         this.closed = true;
-        this._rpcDataSource.end(err);
-        try {
+        // note: don't pass error to _source here.
+        if (err) {
             await this.writeCallCancel();
         }
-        finally {
-            // note: don't pass error to _source here.
-            this._source.end();
-        }
+        this._source.end();
+        this._rpcDataSource.end(err);
+    }
+    // closeWrite closes the call for writing.
+    closeWrite() {
+        this._source.end();
     }
     // _createSink returns a value for the sink field.
     _createSink() {
@@ -145,7 +158,6 @@ export class CommonRPC {
                         await this.handlePacket(msg);
                     }
                 }
-                this._rpcDataSource.end();
             }
             catch (err) {
                 this.close(err);

package/dist/srpc/conn.d.ts

@@ -1,25 +1,29 @@
-import type { Direction, Stream, StreamMuxerFactory } from '@libp2p/interface';
-import type { Duplex, Source } from 'it-stream-types';
+import { YamuxMuxerInit } from '@chainsafe/libp2p-yamux';
+import type { Direction, Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface';
+import type { Duplex } from 'it-stream-types';
 import { Uint8ArrayList } from 'uint8arraylist';
-import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js';
+import { type OpenStreamFunc, type PacketStream } from './stream.js';
 import { Client } from './client.js';
-export interface ConnParams {
+export interface StreamConnParams {
     muxerFactory?: StreamMuxerFactory;
     direction?: Direction;
+    yamuxParams?: YamuxMuxerInit;
 }
 export interface StreamHandler {
-    handlePacketStream(strm: SRPCStream): void;
+    handlePacketStream(strm: PacketStream): void;
 }
-export declare function streamToSRPCStream(stream: Duplex<AsyncIterable<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>): SRPCStream;
-export declare class Conn implements Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
-    private muxer;
-    private server?;
-    constructor(server?: StreamHandler, connParams?: ConnParams);
+export declare class StreamConn implements Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
+    private _muxer;
+    private _server?;
+    constructor(server?: StreamHandler, connParams?: StreamConnParams);
     get sink(): import("it-stream-types").Sink<AsyncGenerator<Uint8Array | Uint8ArrayList, any, unknown>, unknown>;
     get source(): AsyncGenerator<Uint8Array | Uint8ArrayList, any, unknown>;
     get streams(): Stream[];
+    get muxer(): StreamMuxer;
+    get server(): StreamHandler | undefined;
     buildClient(): Client;
-    openStream(): Promise<SRPCStream>;
+    openStream(): Promise<PacketStream>;
     buildOpenStreamFunc(): OpenStreamFunc;
-    private handleIncomingStream;
+    handleIncomingStream(strm: Stream): void;
+    close(err?: Error): void;
 }

package/dist/srpc/conn.js

@@ -1,51 +1,48 @@
 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 { streamToPacketStream, } from './stream.js';
 import { Client } from './client.js';
-import { combineUint8ArrayListTransform } from './array-list.js';
-import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
-import { buildPushableSink } from './pushable.js';
-// streamToSRPCStream converts a Stream to a SRPCStream.
-// uses length-prefix for packet framing
-export function streamToSRPCStream(stream) {
-    const pushSink = pushable({ objectMode: true });
-    pipe(pushSink, prependLengthPrefixTransform(), stream.sink);
-    return {
-        source: pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform()),
-        sink: buildPushableSink(pushSink),
-    };
-}
-// Conn implements a generic connection with a two-way stream.
+// 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.
+// Uses Yamux to manage streams over the connection.
+//
 // Implements the client by opening streams with the remote.
 // Implements the server by handling incoming streams.
 // If the server is unset, rejects any incoming streams.
-export class Conn {
+export class StreamConn {
     constructor(server, connParams) {
         if (server) {
-            this.server = server;
+            this._server = server;
         }
         const muxerFactory = connParams?.muxerFactory ??
-            yamux({ enableKeepAlive: false })({
+            yamux({ enableKeepAlive: false, ...connParams?.yamuxParams })({
                 logger: defaultLogger(),
             });
-        this.muxer = muxerFactory.createStreamMuxer({
+        this._muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),
             direction: connParams?.direction || 'outbound',
         });
     }
     // sink returns the message sink.
     get sink() {
-        return this.muxer.sink;
+        return this._muxer.sink;
     }
     // source returns the outgoing message source.
     get source() {
-        return this.muxer.source;
+        return this._muxer.source;
     }
     // streams returns the set of all ongoing streams.
     get streams() {
-        return this.muxer.streams;
+        return this._muxer.streams;
+    }
+    // muxer returns the muxer
+    get muxer() {
+        return this._muxer;
+    }
+    // server returns the server, if any.
+    get server() {
+        return this._server;
     }
     // buildClient builds a new client from the connection.
     buildClient() {
@@ -53,26 +50,30 @@ export class Conn {
     }
     // openStream implements the client open stream function.
     async openStream() {
-        const streamPromise = this.muxer.newStream();
-        let stream;
-        if (isPromise(streamPromise)) {
-            stream = await streamPromise;
-        }
-        else {
-            stream = streamPromise;
-        }
-        return streamToSRPCStream(stream);
+        const strm = await this.muxer.newStream();
+        return streamToPacketStream(strm);
     }
     // buildOpenStreamFunc returns openStream bound to this conn.
     buildOpenStreamFunc() {
         return this.openStream.bind(this);
     }
     // handleIncomingStream handles an incoming stream.
+    //
+    // this is usually called by the muxer when streams arrive.
     handleIncomingStream(strm) {
         const server = this.server;
         if (!server) {
             return strm.abort(new Error('server not implemented'));
         }
-        server.handlePacketStream(streamToSRPCStream(strm));
+        server.handlePacketStream(streamToPacketStream(strm));
+    }
+    // close closes or aborts the muxer with an optional error.
+    close(err) {
+        if (err) {
+            this.muxer.abort(err);
+        }
+        else {
+            this.muxer.close();
+        }
     }
 }

package/dist/srpc/handler.d.ts

@@ -1,5 +1,5 @@
 import type { Sink, Source } from 'it-stream-types';
-import { Definition, MethodDefinition } from './definition.js';
+import { Definition } from './definition.js';
 export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>) => Promise<void>;
 export interface Handler {
     getServiceID(): string;
@@ -17,7 +17,4 @@ export declare class StaticHandler implements Handler {
     getMethodIDs(): string[];
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
 }
-type MethodProto<R, O> = ((request: R) => Promise<O>) | ((request: R) => AsyncIterable<O>) | ((request: AsyncIterable<R>) => Promise<O>) | ((request: AsyncIterable<R>) => AsyncIterable<O>);
-export declare function createInvokeFn<R, O>(methodInfo: MethodDefinition<R, O>, methodProto: MethodProto<R, O>): InvokeFn;
 export declare function createHandler(definition: Definition, impl: any, serviceID?: string): Handler;
-export {};

package/dist/srpc/handler.js

@@ -1,7 +1,4 @@
-import { pipe } from 'it-pipe';
-import { pushable } from 'it-pushable';
-import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
-import { writeToPushable } from './pushable.js';
+import { createInvokeFn } from './invoker.js';
 // StaticHandler is a handler with a definition and implementation.
 export class StaticHandler {
     constructor(serviceID, methods) {
@@ -25,69 +22,6 @@ export class StaticHandler {
         return this.methods[methodID] || null;
     }
 }
-// createInvokeFn builds an InvokeFn from a method definition and a function prototype.
-export function createInvokeFn(methodInfo, methodProto) {
-    const requestDecode = buildDecodeMessageTransform(methodInfo.requestType);
-    return async (dataSource, dataSink) => {
-        // responseSink is a Sink for response messages.
-        const responseSink = pushable({
-            objectMode: true,
-        });
-        // pipe responseSink to dataSink.
-        pipe(responseSink, buildEncodeMessageTransform(methodInfo.responseType), dataSink);
-        // requestSource is a Source of decoded request messages.
-        const requestSource = pipe(dataSource, requestDecode);
-        // build the request argument.
-        let requestArg;
-        if (methodInfo.requestStream) {
-            // use the request source as the argument.
-            requestArg = requestSource;
-        }
-        else {
-            // receive a single message for the argument.
-            for await (const msg of requestSource) {
-                if (msg) {
-                    requestArg = msg;
-                    break;
-                }
-            }
-        }
-        if (!requestArg) {
-            throw new Error('request object was empty');
-        }
-        // Call the implementation.
-        try {
-            const responseObj = methodProto(requestArg);
-            if (!responseObj) {
-                throw new Error('return value was undefined');
-            }
-            if (methodInfo.responseStream) {
-                const response = responseObj;
-                return writeToPushable(response, responseSink);
-            }
-            else {
-                const responsePromise = responseObj;
-                if (!responsePromise.then) {
-                    throw new Error('expected return value to be a Promise');
-                }
-                const responseMsg = await responsePromise;
-                if (!responseMsg) {
-                    throw new Error('expected non-empty response object');
-                }
-                responseSink.push(responseMsg);
-                responseSink.end();
-            }
-        }
-        catch (err) {
-            let asError = err;
-            if (!asError?.message) {
-                asError = new Error('error calling implementation: ' + err);
-            }
-            // mux will return the error to the rpc caller.
-            throw asError;
-        }
-    };
-}
 // createHandler creates a handler from a definition and an implementation.
 // if serviceID is not set, uses the fullName of the service as the identifier.
 export function createHandler(definition, impl, serviceID) {

package/dist/srpc/index.d.ts

@@ -1,15 +1,15 @@
 export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
-export { Conn, ConnParams } from './conn.js';
+export { StreamConn, StreamConnParams, StreamHandler } from './conn.js';
 export { WebSocketConn } from './websocket.js';
-export { StreamConn } from './conn-stream.js';
-export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
-export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
+export type { PacketHandler, OpenStreamFunc, PacketStream, streamToPacketStream, } from './stream.js';
+export { Handler, InvokeFn, MethodMap, StaticHandler, createHandler, } from './handler.js';
+export { MethodProto, createInvokeFn } from './invoker.js';
 export { Packet, CallStart, CallData } from './rpcproto.pb.js';
-export { Mux, StaticMux, createMux } from './mux.js';
-export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
-export { MessagePortDuplex, newMessagePortDuplex, MessagePortConn, } from './message-port.js';
+export { Mux, StaticMux, LookupMethod, createMux } from './mux.js';
+export { BroadcastChannelDuplex, BroadcastChannelConn, newBroadcastChannelDuplex, } from './broadcast-channel.js';
+export { MessagePortDuplex, MessagePortConn, newMessagePortDuplex, } from './message-port.js';
 export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
 export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, uint32LEDecode, uint32LEEncode, decodeUint32Le, encodeUint32Le, lengthPrefixDecode, lengthPrefixEncode, prependPacketLen, } from './packet.js';
 export { combineUint8ArrayListTransform } from './array-list.js';

package/dist/srpc/index.js

@@ -1,14 +1,14 @@
 export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
-export { Conn } from './conn.js';
+export { StreamConn } from './conn.js';
 export { WebSocketConn } from './websocket.js';
-export { StreamConn } from './conn-stream.js';
-export { createHandler, createInvokeFn } from './handler.js';
+export { StaticHandler, createHandler, } from './handler.js';
+export { createInvokeFn } from './invoker.js';
 export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { StaticMux, createMux } from './mux.js';
-export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
-export { MessagePortDuplex, newMessagePortDuplex, MessagePortConn, } from './message-port.js';
+export { BroadcastChannelDuplex, BroadcastChannelConn, newBroadcastChannelDuplex, } from './broadcast-channel.js';
+export { MessagePortDuplex, MessagePortConn, newMessagePortDuplex, } from './message-port.js';
 export { buildDecodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
 export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, uint32LEDecode, uint32LEEncode, decodeUint32Le, encodeUint32Le, lengthPrefixDecode, lengthPrefixEncode, prependPacketLen, } from './packet.js';
 export { combineUint8ArrayListTransform } from './array-list.js';