@replit/river 0.6.4 → 0.7.0

package/dist/__tests__/e2e.test.js

@@ -7,15 +7,15 @@ import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor,
 import { UNCAUGHT_ERROR } from '../router/result';
 import { codecs } from '../codec/codec.test';
 describe.each(codecs)('client <-> server integration test ($name codec)', async ({ codec }) => {
-    const server = http.createServer();
-    const port = await onServerReady(server);
-    const webSocketServer = await createWebSocketServer(server);
+    const httpServer = http.createServer();
+    const port = await onServerReady(httpServer);
+    const webSocketServer = await createWebSocketServer(httpServer);
     const getTransports = () => createWsTransports(port, webSocketServer, codec);
     afterAll(() => {
         webSocketServer.clients.forEach((socket) => {
             socket.close();
         });
-        server.close();
+        httpServer.close();
     });
     test('rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -104,10 +104,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         for (let i = 0; i < 50; i++) {
             expected.push(i);
             if (i == 10) {
-                clientTransport.ws?.close();
+                clientTransport.connections.forEach((conn) => conn.ws.close());
             }
             if (i == 42) {
-                clientTransport.ws?.terminate();
+                clientTransport.connections.forEach((conn) => conn.ws.terminate());
             }
             await client.test.add({
                 n: i,
@@ -157,8 +157,7 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         }
         // cleanup
         for (let i = 0; i < CONCURRENCY; i++) {
-            const [input, _output, close] = openStreams[i];
-            input.end();
+            const [_input, _output, close] = openStreams[i];
             close();
         }
     });

package/dist/__tests__/typescript-stress.test.d.ts

@@ -1,5 +1,5 @@
 import { MessageId, OpaqueTransportMessage } from '../transport/message';
-import { Transport } from '../transport/types';
+import { Connection, Transport } from '../transport/transport';
 export declare const StupidlyLargeService: () => {
     name: "test";
     state: {};
@@ -1377,9 +1377,11 @@ export declare const StupidlyLargeService: () => {
         };
     };
 };
-export declare class MockTransport extends Transport {
+export declare class MockTransport extends Transport<Connection> {
     constructor(clientId: string);
     send(msg: OpaqueTransportMessage): MessageId;
+    setupConnectionStatusListeners(): void;
+    createNewConnection(): Promise<void>;
     close(): Promise<void>;
 }
 //# sourceMappingURL=typescript-stress.test.d.ts.map

package/dist/__tests__/typescript-stress.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript-stress.test.d.ts","sourceRoot":"","sources":["../../__tests__/typescript-stress.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAS,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AA8B/C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDlB,CAAC;AAGhB,qBAAa,aAAc,SAAQ,SAAS;gBAC9B,QAAQ,EAAE,MAAM;IAI5B,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IAKtC,KAAK;CACZ"}
+{"version":3,"file":"typescript-stress.test.d.ts","sourceRoot":"","sources":["../../__tests__/typescript-stress.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAS,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AA8B/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDlB,CAAC;AAGhB,qBAAa,aAAc,SAAQ,SAAS,CAAC,UAAU,CAAC;gBAC1C,QAAQ,EAAE,MAAM;IAI5B,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IAK5C,8BAA8B;IACxB,mBAAmB;IACnB,KAAK;CACZ"}

package/dist/__tests__/typescript-stress.test.js

@@ -3,7 +3,7 @@ import { ServiceBuilder, serializeService } from '../router/builder';
 import { Type } from '@sinclair/typebox';
 import { reply } from '../transport/message';
 import { createServer } from '../router/server';
-import { Transport } from '../transport/types';
+import { Transport } from '../transport/transport';
 import { NaiveJsonCodec } from '../codec/json';
 import { createClient } from '../router/client';
 import { Ok } from '../router/result';
@@ -90,6 +90,8 @@ export class MockTransport extends Transport {
         const id = msg.id;
         return id;
     }
+    setupConnectionStatusListeners() { }
+    async createNewConnection() { }
     async close() { }
 }
 describe("ensure typescript doesn't give up trying to infer the types for large services", () => {

package/dist/router/client.d.ts

@@ -1,7 +1,8 @@
-import { Transport } from '../transport/types';
+import { Connection, Transport } from '../transport/transport';
 import { AnyService, ProcErrors, ProcInput, ProcOutput, ProcType } from './builder';
 import type { Pushable } from 'it-pushable';
 import { Server } from './server';
+import { TransportClientId } from '../transport/message';
 import { Static } from '@sinclair/typebox';
 import { Result } from './result';
 type AsyncIter<T> = AsyncGenerator<T, T, unknown>;
@@ -37,6 +38,6 @@ export type ServerClient<Srv extends Server<Record<string, AnyService>>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-export declare const createClient: <Srv extends Server<Record<string, AnyService>>>(transport: Transport) => ServerClient<Srv>;
+export declare const createClient: <Srv extends Server<Record<string, AnyService>>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
 export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/router/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../router/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EACL,UAAU,EACV,UAAU,EACV,SAAS,EACT,UAAU,EACV,QAAQ,EACT,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAMlC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,KAAK,SAAS,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AAElD;;;;GAIG;AACH,KAAK,aAAa,CAAC,MAAM,SAAS,UAAU,IAAI;KAC7C,QAAQ,IAAI,MAAM,MAAM,CAAC,YAAY,CAAC,GAAG,QAAQ,CAChD,MAAM,EACN,QAAQ,CACT,SAAS,KAAK,GAEX,CACE,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KACvC,OAAO,CACV,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF,GAED,MAAM,OAAO,CACX;QACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC7C,SAAS,CACP,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;QACD,MAAM,IAAI;KACX,CACF;CACN,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,IAAI;KACxE,OAAO,IAAI,MAAM,GAAG,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC;CAC5E,CAAC;AAgCF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,8DACZ,SAAS,sBAgFO,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../router/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EACL,UAAU,EACV,UAAU,EACV,SAAS,EACT,UAAU,EACV,QAAQ,EACT,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAIL,iBAAiB,EAElB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,KAAK,SAAS,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AAElD;;;;GAIG;AACH,KAAK,aAAa,CAAC,MAAM,SAAS,UAAU,IAAI;KAC7C,QAAQ,IAAI,MAAM,MAAM,CAAC,YAAY,CAAC,GAAG,QAAQ,CAChD,MAAM,EACN,QAAQ,CACT,SAAS,KAAK,GAEX,CACE,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KACvC,OAAO,CACV,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF,GAED,MAAM,OAAO,CACX;QACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC7C,SAAS,CACP,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;QACD,MAAM,IAAI;KACX,CACF;CACN,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,IAAI;KACxE,OAAO,IAAI,MAAM,GAAG,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC;CAC5E,CAAC;AAgCF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,8DACZ,UAAU,UAAU,CAAC,aACtB,iBAAiB,sBAkFA,CAAC"}

package/dist/router/client.js

@@ -34,14 +34,14 @@ function _createRecursiveProxy(callback, path) {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-export const createClient = (transport) => _createRecursiveProxy(async (opts) => {
+export const createClient = (transport, serverId = 'SERVER') => _createRecursiveProxy(async (opts) => {
     const [serviceName, procName] = [...opts.path];
     const [input] = opts.args;
     const streamId = nanoid();
     function belongsToSameStream(msg) {
         return (msg.serviceName === serviceName &&
             msg.procedureName === procName &&
-            (msg.streamId === streamId || msg.streamId === 'global'));
+            msg.streamId === streamId);
     }
     if (input === undefined) {
         // stream case (stream methods are called with zero arguments)
@@ -51,7 +51,7 @@ export const createClient = (transport) => _createRecursiveProxy(async (opts) =>
         // this gets cleaned up on i.end() which is called by closeHandler
         (async () => {
             for await (const rawIn of inputStream) {
-                const m = msg(transport.clientId, 'SERVER', serviceName, procName, streamId, rawIn);
+                const m = msg(transport.clientId, serverId, serviceName, procName, streamId, rawIn);
                 m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
                 transport.send(m);
             }
@@ -66,7 +66,7 @@ export const createClient = (transport) => _createRecursiveProxy(async (opts) =>
         const closeHandler = () => {
             inputStream.end();
             outputStream.end();
-            const closeMessage = msg(transport.clientId, 'SERVER', serviceName, procName, streamId, {});
+            const closeMessage = msg(transport.clientId, serverId, serviceName, procName, streamId, { type: 'CLOSE' });
             closeMessage.controlFlags |= 4 /* ControlFlags.StreamClosedBit */;
             transport.send(closeMessage);
             transport.removeMessageListener(listener);
@@ -75,7 +75,7 @@ export const createClient = (transport) => _createRecursiveProxy(async (opts) =>
     }
     else {
         // rpc case
-        const m = msg(transport.clientId, 'SERVER', serviceName, procName, streamId, input);
+        const m = msg(transport.clientId, serverId, serviceName, procName, streamId, input);
         // rpc is a stream open + close
         m.controlFlags |=
             2 /* ControlFlags.StreamOpenBit */ | 4 /* ControlFlags.StreamClosedBit */;

package/dist/router/server.d.ts

@@ -1,4 +1,4 @@
-import { Transport } from '../transport/types';
+import { Connection, Transport } from '../transport/transport';
 import { AnyService } from './builder';
 import { ServiceContext } from './context';
 /**
@@ -17,5 +17,5 @@ export interface Server<Services> {
  * @param extendedContext - An optional object containing additional context to be passed to all services.
  * @returns A promise that resolves to a server instance with the registered services.
  */
-export declare function createServer<Services extends Record<string, AnyService>>(transport: Transport, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Promise<Server<Services>>;
+export declare function createServer<Services extends Record<string, AnyService>>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Promise<Server<Services>>;
 //# sourceMappingURL=server.d.ts.map

package/dist/router/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../router/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAgB,UAAU,EAAE,MAAM,WAAW,CAAC;AAUrD,OAAO,EAAE,cAAc,EAA2B,MAAM,WAAW,CAAC;AAWpE;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,QAAQ;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAWD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAC5E,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,QAAQ,EAClB,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAoJ3B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../router/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAgB,UAAU,EAAE,MAAM,WAAW,CAAC;AAWrD,OAAO,EAAE,cAAc,EAA2B,MAAM,WAAW,CAAC;AAWpE;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,QAAQ;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAWD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAC5E,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAChC,QAAQ,EAAE,QAAQ,EAClB,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAqJ3B"}

package/dist/router/server.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { isStreamClose, isStreamOpen, reply, } from '../transport/message';
+import { ControlMessagePayloadSchema, isStreamClose, isStreamOpen, reply, } from '../transport/message';
 import { log } from '../logging';
 import { Value } from '@sinclair/typebox/value';
 import { Err, UNCAUGHT_ERROR, } from './result';
@@ -29,7 +29,7 @@ export async function createServer(transport, services, extendedContext) {
         contextMap.set(service, { ...extendedContext, state: service.state });
     }
     const handler = async (msg) => {
-        if (msg.to !== 'SERVER') {
+        if (msg.to !== transport.clientId) {
             log?.info(`${transport.clientId} -- got msg with destination that isn't the server, ignoring`);
             return;
         }
@@ -44,12 +44,7 @@ export async function createServer(transport, services, extendedContext) {
             return;
         }
         const procedure = service.procedures[msg.procedureName];
-        if (!Value.Check(procedure.input, msg.payload)) {
-            log?.error(`${transport.clientId} -- procedure ${msg.serviceName}.${msg.procedureName} received invalid payload: ${msg.payload}`);
-            return;
-        }
-        const inputMessage = msg;
-        if (isStreamOpen(inputMessage.controlFlags)) {
+        if (isStreamOpen(msg.controlFlags)) {
             const incoming = pushable({ objectMode: true });
             const outgoing = pushable({ objectMode: true });
             const openPromises = [
@@ -98,8 +93,13 @@ export async function createServer(transport, services, extendedContext) {
             log?.warn(`${transport.clientId} -- couldn't find a matching procedure stream for ${msg.serviceName}.${msg.procedureName}:${msg.streamId}`);
             return;
         }
-        procStream.incoming.push(inputMessage);
-        if (isStreamClose(inputMessage.controlFlags)) {
+        if (Value.Check(procedure.input, msg.payload)) {
+            procStream.incoming.push(msg);
+        }
+        else if (!Value.Check(ControlMessagePayloadSchema, msg.payload)) {
+            log?.error(`${transport.clientId} -- procedure ${msg.serviceName}.${msg.procedureName} received invalid payload: ${JSON.stringify(msg.payload)}`);
+        }
+        if (isStreamClose(msg.controlFlags)) {
             procStream.incoming.end();
             await Promise.all(procStream.openPromises);
             procStream.outgoing.end();

package/dist/testUtils.d.ts

@@ -2,13 +2,14 @@
 import WebSocket from 'isomorphic-ws';
 import { WebSocketServer } from 'ws';
 import http from 'http';
-import { WebSocketTransport } from './transport/impls/ws';
+import { WebSocketClientTransport } from './transport/impls/ws/client';
 import { Static, TObject } from '@sinclair/typebox';
 import { Procedure, ServiceContext } from './router';
-import { OpaqueTransportMessage, TransportMessage } from './transport';
+import { OpaqueTransportMessage, TransportClientId, TransportMessage } from './transport';
 import { Pushable } from 'it-pushable';
 import { Result, RiverError, RiverUncaughtSchema } from './router/result';
 import { Codec } from './codec';
+import { WebSocketServerTransport } from './transport/impls/ws/server';
 /**
  * Creates a WebSocket server instance using the provided HTTP server.
  * Only used as helper for testing.
@@ -35,9 +36,9 @@ export declare function createLocalWebSocketClient(port: number): Promise<WebSoc
  * Creates a pair of WebSocket transports for testing purposes.
  * @param port - The port number to use for the client transport. This should be acquired after starting a server via {@link createWebSocketServer}.
  * @param wss - The WebSocketServer instance to use for the server transport.
- * @returns An array containing the client and server {@link WebSocketTransport} instances.
+ * @returns An array containing the client and server {@link WebSocketClientTransport} instances.
  */
-export declare function createWsTransports(port: number, wss: WebSocketServer, codec?: Codec): [WebSocketTransport, WebSocketTransport];
+export declare function createWsTransports(port: number, wss: WebSocketServer, codec?: Codec): [WebSocketClientTransport, WebSocketServerTransport];
 /**
  * Transforms an RPC procedure definition into a normal function call.
  * This should only be used for testing.
@@ -73,7 +74,7 @@ export declare function asClientStream<State extends object | unknown, I extends
  * @param streamId - The optional stream ID.
  * @returns The transport message.
  */
-export declare function payloadToTransportMessage<Payload extends object>(payload: Payload, streamId?: string): TransportMessage<Payload>;
+export declare function payloadToTransportMessage<Payload extends object>(payload: Payload, streamId?: string, from?: TransportClientId, to?: TransportClientId): TransportMessage<Payload>;
 /**
  * Creates a dummy opaque transport message for testing purposes.
  * @returns The created opaque transport message.

package/dist/testUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../testUtils.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AACrC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAGjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AACjD,OAAO,EAEL,MAAM,EACN,UAAU,EACV,mBAAmB,EAEpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,4EAE9D;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWxE;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,MAAM,sBAI5D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,KAAK,CAAC,EAAE,KAAK,GACZ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAwB1C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,KAAK,SAAS,MAAM,GAAG,OAAO,EAC9B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,UAAU,EAEpB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACtC,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,SAGxC,OAAO,CAAC,CAAC,KACb,QACD,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,0BAA0B,CAAC,CAAC,CAClE,CAYF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,KAAK,SAAS,MAAM,GAAG,OAAO,EAC9B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,UAAU,EAEpB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACzC,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAC9C;IACD,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC;CAC5E,CAuDA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,SAAS,MAAM,EAC9D,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,MAAM,6BAUlB;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,sBAAsB,CAKpE"}
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../testUtils.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AACrC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,gBAAgB,EAGjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AACjD,OAAO,EAEL,MAAM,EACN,UAAU,EACV,mBAAmB,EAEpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,4EAE9D;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWxE;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,MAAM,sBAI5D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,KAAK,CAAC,EAAE,KAAK,GACZ,CAAC,wBAAwB,EAAE,wBAAwB,CAAC,CAWtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,KAAK,SAAS,MAAM,GAAG,OAAO,EAC9B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,UAAU,EAEpB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACtC,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,SAGxC,OAAO,CAAC,CAAC,KACb,QACD,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,0BAA0B,CAAC,CAAC,CAClE,CAYF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,KAAK,SAAS,MAAM,GAAG,OAAO,EAC9B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,UAAU,EAEpB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACzC,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAC9C;IACD,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC;CAC5E,CAuDA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,SAAS,MAAM,EAC9D,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,GAAE,iBAA4B,EAClC,EAAE,GAAE,iBAA4B,GAC/B,gBAAgB,CAAC,OAAO,CAAC,CAE3B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,sBAAsB,CAKpE"}

package/dist/testUtils.js

@@ -1,9 +1,10 @@
 import WebSocket from 'isomorphic-ws';
 import { WebSocketServer } from 'ws';
-import { WebSocketTransport } from './transport/impls/ws';
+import { WebSocketClientTransport } from './transport/impls/ws/client';
 import { msg, reply, } from './transport';
 import { pushable } from 'it-pushable';
 import { Err, UNCAUGHT_ERROR, } from './router/result';
+import { WebSocketServerTransport } from './transport/impls/ws/server';
 /**
  * Creates a WebSocket server instance using the provided HTTP server.
  * Only used as helper for testing.
@@ -48,23 +49,13 @@ export async function createLocalWebSocketClient(port) {
  * Creates a pair of WebSocket transports for testing purposes.
  * @param port - The port number to use for the client transport. This should be acquired after starting a server via {@link createWebSocketServer}.
  * @param wss - The WebSocketServer instance to use for the server transport.
- * @returns An array containing the client and server {@link WebSocketTransport} instances.
+ * @returns An array containing the client and server {@link WebSocketClientTransport} instances.
  */
 export function createWsTransports(port, wss, codec) {
     const options = codec ? { codec } : undefined;
     return [
-        new WebSocketTransport(async () => {
-            return createLocalWebSocketClient(port);
-        }, 'client', options),
-        new WebSocketTransport(async () => {
-            return new Promise((resolve) => {
-                wss.on('connection', async function onConnect(serverSock) {
-                    wss.removeListener('connection', onConnect);
-                    serverSock.binaryType = 'arraybuffer';
-                    resolve(serverSock);
-                });
-            });
-        }, 'SERVER', options),
+        new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client', 'SERVER', options),
+        new WebSocketServerTransport(wss, 'SERVER', options),
     ];
 }
 /**
@@ -149,8 +140,8 @@ export function asClientStream(state, proc, extendedContext) {
  * @param streamId - The optional stream ID.
  * @returns The transport message.
  */
-export function payloadToTransportMessage(payload, streamId) {
-    return msg('client', 'SERVER', 'service', 'procedure', streamId ?? 'stream', payload);
+export function payloadToTransportMessage(payload, streamId, from = 'client', to = 'SERVER') {
+    return msg(from, to, 'service', 'procedure', streamId ?? 'stream', payload);
 }
 /**
  * Creates a dummy opaque transport message for testing purposes.

package/dist/transport/impls/stdio/stdio.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Codec } from '../../../codec';
+import { TransportClientId } from '../../message';
+import { Connection, Transport } from '../../transport';
+export declare class StdioConnection extends Connection {
+    /**
+     * The writable stream to use as output.
+     */
+    output: NodeJS.WritableStream;
+    constructor(transport: Transport<StdioConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+interface Options {
+    codec: Codec;
+}
+/**
+ * A transport implementation that uses standard input and output streams.
+ * Can only be used 1:1, not N:1
+ * @extends Transport
+ */
+export declare class StdioTransport extends Transport<StdioConnection> {
+    clientId: TransportClientId;
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    /**
+     * Constructs a new StdioTransport instance.
+     * @param clientId - The ID of the client associated with this transport.
+     * @param input - The readable stream to use as input. Defaults to process.stdin.
+     * @param output - The writable stream to use as output. Defaults to process.stdout.
+     */
+    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream, providedOptions?: Partial<Options>);
+    setupConnectionStatusListeners(): void;
+    createNewConnection(to: TransportClientId): Promise<void>;
+}
+export {};
+//# sourceMappingURL=stdio.d.ts.map

package/dist/transport/impls/stdio/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKxD,qBAAa,eAAgB,SAAQ,UAAU;IAC7C;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;gBAG5B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,EACrC,WAAW,EAAE,iBAAiB,EAC9B,MAAM,EAAE,MAAM,CAAC,cAAc;IAM/B,IAAI,CAAC,OAAO,EAAE,UAAU;IAOlB,KAAK;CAIZ;AAED,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC5D,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC,cAAc,CAAiB;IAC7C,MAAM,EAAE,MAAM,CAAC,cAAc,CAAkB;IAE/C;;;;;OAKG;gBAED,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,EAC9C,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAUpC,8BAA8B,IAAI,IAAI;IAwBhC,mBAAmB,CAAC,EAAE,EAAE,iBAAiB;CAShD"}

package/dist/transport/impls/stdio/stdio.js

@@ -0,0 +1,80 @@
+import { NaiveJsonCodec } from '../../../codec/json';
+import { log } from '../../../logging';
+import { Connection, Transport } from '../../transport';
+import readline from 'readline';
+const newlineBuff = new TextEncoder().encode('\n');
+export class StdioConnection extends Connection {
+    /**
+     * The writable stream to use as output.
+     */
+    output;
+    constructor(transport, connectedTo, output) {
+        super(transport, connectedTo);
+        this.output = output;
+    }
+    send(payload) {
+        const out = new Uint8Array(payload.length + newlineBuff.length);
+        out.set(payload, 0);
+        out.set(newlineBuff, payload.length);
+        return this.output.write(out);
+    }
+    async close() {
+        this.transport.onDisconnect(this);
+        this.output.end();
+    }
+}
+const defaultOptions = {
+    codec: NaiveJsonCodec,
+};
+/**
+ * A transport implementation that uses standard input and output streams.
+ * Can only be used 1:1, not N:1
+ * @extends Transport
+ */
+export class StdioTransport extends Transport {
+    clientId;
+    input = process.stdin;
+    output = process.stdout;
+    /**
+     * Constructs a new StdioTransport instance.
+     * @param clientId - The ID of the client associated with this transport.
+     * @param input - The readable stream to use as input. Defaults to process.stdin.
+     * @param output - The writable stream to use as output. Defaults to process.stdout.
+     */
+    constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
+        const options = { ...defaultOptions, ...providedOptions };
+        super(options.codec, clientId);
+        this.clientId = clientId;
+        this.input = input;
+        this.output = output;
+        this.setupConnectionStatusListeners();
+    }
+    setupConnectionStatusListeners() {
+        let conn = undefined;
+        const rl = readline.createInterface({
+            input: this.input,
+        });
+        const encoder = new TextEncoder();
+        rl.on('line', (msg) => {
+            const parsedMsg = this.parseMsg(encoder.encode(msg));
+            if (parsedMsg && !this.connections.has(parsedMsg.from)) {
+                conn = new StdioConnection(this, parsedMsg.from, this.output);
+                this.onConnect(conn);
+            }
+            this.handleMsg(parsedMsg);
+        });
+        rl.on('close', () => {
+            if (conn) {
+                this.onDisconnect(conn);
+            }
+        });
+    }
+    async createNewConnection(to) {
+        if (this.state === 'destroyed') {
+            throw new Error('cant reopen a destroyed connection');
+        }
+        log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
+        const conn = new StdioConnection(this, to, this.output);
+        this.onConnect(conn);
+    }
+}

package/dist/transport/impls/stdio/stdio.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stdio.test.d.ts.map

package/dist/transport/impls/stdio/stdio.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.test.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.test.ts"],"names":[],"mappings":""}

package/dist/transport/impls/stdio/stdio.test.js

@@ -0,0 +1,20 @@
+import { describe, test, expect } from 'vitest';
+import stream from 'node:stream';
+import { StdioTransport } from './stdio';
+import { waitForMessage } from '../..';
+import { payloadToTransportMessage } from '../../../testUtils';
+describe('sending and receiving across node streams works', () => {
+    test('basic send/receive', async () => {
+        const clientToServer = new stream.PassThrough();
+        const serverToClient = new stream.PassThrough();
+        const serverTransport = new StdioTransport('abc', clientToServer, serverToClient);
+        const clientTransport = new StdioTransport('def', serverToClient, clientToServer);
+        const msg = {
+            msg: 'cool',
+            test: 123,
+        };
+        const p = waitForMessage(serverTransport);
+        clientTransport.send(payloadToTransportMessage(msg, 'stream', clientTransport.clientId, serverTransport.clientId));
+        await expect(p).resolves.toStrictEqual(msg);
+    });
+});

package/dist/transport/impls/ws/client.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="ws" />
+import WebSocket from 'isomorphic-ws';
+import { Transport } from '../../transport';
+import { TransportClientId } from '../../message';
+import { type Codec } from '../../../codec';
+import { WebSocketConnection } from './connection';
+interface Options {
+    retryIntervalMs: number;
+    retryAttemptsMax: number;
+    codec: Codec;
+}
+type WebSocketResult = {
+    ws: WebSocket;
+} | {
+    err: string;
+};
+/**
+ * A transport implementation that uses a WebSocket connection with automatic reconnection.
+ * @class
+ * @extends Transport
+ */
+export declare class WebSocketClientTransport extends Transport<WebSocketConnection> {
+    /**
+     * A function that returns a Promise that resolves to a WebSocket instance.
+     */
+    wsGetter: (to: TransportClientId) => Promise<WebSocket>;
+    options: Options;
+    serverId: TransportClientId;
+    reconnectPromises: Map<TransportClientId, Promise<WebSocketResult>>;
+    /**
+     * Creates a new WebSocketTransport instance.
+     * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
+     * @param clientId The ID of the client using the transport.
+     * @param providedOptions An optional object containing configuration options for the transport.
+     */
+    constructor(wsGetter: () => Promise<WebSocket>, clientId: TransportClientId, serverId: TransportClientId, providedOptions?: Partial<Options>);
+    setupConnectionStatusListeners(): void;
+    createNewConnection(to: string, attempt?: number): Promise<void>;
+    /**
+     * Begins a new attempt to establish a WebSocket connection.
+     */
+    open(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/transport/impls/ws/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/client.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;CACd;AAQD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E;;OAEG;IACH,QAAQ,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAE5B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;IAEpE;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC,8BAA8B,IAAI,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,SAAI;IAmEjD;;OAEG;IACG,IAAI;CAGX"}

package/dist/transport/impls/ws/client.js

@@ -0,0 +1,102 @@
+import { Transport } from '../../transport';
+import { NaiveJsonCodec } from '../../../codec/json';
+import { log } from '../../../logging';
+import { WebSocketConnection } from './connection';
+const defaultOptions = {
+    retryIntervalMs: 250,
+    retryAttemptsMax: 5,
+    codec: NaiveJsonCodec,
+};
+/**
+ * A transport implementation that uses a WebSocket connection with automatic reconnection.
+ * @class
+ * @extends Transport
+ */
+export class WebSocketClientTransport extends Transport {
+    /**
+     * A function that returns a Promise that resolves to a WebSocket instance.
+     */
+    wsGetter;
+    options;
+    serverId;
+    reconnectPromises;
+    /**
+     * Creates a new WebSocketTransport instance.
+     * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
+     * @param clientId The ID of the client using the transport.
+     * @param providedOptions An optional object containing configuration options for the transport.
+     */
+    constructor(wsGetter, clientId, serverId, providedOptions) {
+        const options = { ...defaultOptions, ...providedOptions };
+        super(options.codec, clientId);
+        this.wsGetter = wsGetter;
+        this.serverId = serverId;
+        this.options = options;
+        this.reconnectPromises = new Map();
+        this.setupConnectionStatusListeners();
+    }
+    setupConnectionStatusListeners() {
+        this.createNewConnection(this.serverId);
+    }
+    async createNewConnection(to, attempt = 0) {
+        if (this.state === 'destroyed') {
+            throw new Error('cant reopen a destroyed connection');
+        }
+        let reconnectPromise = this.reconnectPromises.get(to);
+        if (!reconnectPromise) {
+            reconnectPromise = new Promise(async (resolve) => {
+                log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
+                const ws = await this.wsGetter(to);
+                if (ws.readyState === ws.OPEN) {
+                    return resolve({ ws });
+                }
+                if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
+                    return resolve({ err: 'ws is closing or closed' });
+                }
+                ws.addEventListener('open', function onOpen() {
+                    ws.removeEventListener('open', onOpen);
+                    resolve({ ws });
+                });
+                ws.addEventListener('close', function onClose(evt) {
+                    ws.removeEventListener('close', onClose);
+                    resolve({ err: evt.reason });
+                });
+            });
+            this.reconnectPromises.set(to, reconnectPromise);
+        }
+        const res = await reconnectPromise;
+        if ('ws' in res && res.ws.readyState === res.ws.OPEN) {
+            if (res.ws === this.connections.get(to)?.ws) {
+                // this is our current connection
+                // we reach this state when createNewConnection is called multiple times
+                // concurrently
+                return;
+            }
+            log?.info(`${this.clientId} -- websocket ok`);
+            const conn = new WebSocketConnection(this, to, res.ws);
+            this.onConnect(conn);
+            res.ws.onclose = () => {
+                this.reconnectPromises.delete(to);
+                this.onDisconnect(conn);
+            };
+            this.state = 'open';
+            return;
+        }
+        // otherwise try and reconnect again
+        log?.warn(`${this.clientId} -- websocket failed, trying again in ${this.options.retryIntervalMs}ms`);
+        this.reconnectPromises.delete(to);
+        if (attempt >= this.options.retryAttemptsMax) {
+            return;
+        }
+        else {
+            // linear backoff
+            setTimeout(() => this.createNewConnection(to, attempt + 1), this.options.retryIntervalMs * attempt);
+        }
+    }
+    /**
+     * Begins a new attempt to establish a WebSocket connection.
+     */
+    async open() {
+        return this.createNewConnection(this.serverId);
+    }
+}