@replit/river 0.8.0 → 0.8.1

package/README.md

@@ -8,6 +8,8 @@ It's like tRPC but...
 - with Result types and error handling
 - over WebSockets
 
+To use River, you must be on least Typescript 5 with `"moduleResolution": "bundler"`.
+
 ## Developing
 
 [![Run on Repl.it](https://replit.com/badge/github/replit/river)](https://replit.com/new/github/replit/river)

package/dist/__tests__/bandwidth.bench.js

@@ -1,7 +1,7 @@
 import http from 'http';
 import { assert, bench, describe } from 'vitest';
 import { createWebSocketServer, createWsTransports, onServerReady, } from '../util/testHelpers';
-import largePayload from './largePayload.json';
+import largePayload from './fixtures/largePayload.json';
 import { TestServiceConstructor } from './fixtures/services';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';

package/dist/__tests__/e2e.test.js

@@ -8,15 +8,14 @@ import { UNCAUGHT_ERROR } from '../router/result';
 import { codecs } from '../codec/codec.test';
 import { WebSocketClientTransport } from '../transport/impls/ws/client';
 import { WebSocketServerTransport } from '../transport/impls/ws/server';
+import { testFinishesCleanly } from './fixtures/cleanup';
 describe.each(codecs)('client <-> server integration test ($name codec)', async ({ codec }) => {
     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();
-        });
+        webSocketServer.close();
         httpServer.close();
     });
     test('rpc', async () => {
@@ -27,6 +26,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const result = await client.test.add.rpc({ n: 3 });
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 3 });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('fallible rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -45,6 +49,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
                 test: 'abc',
             },
         });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('rpc with binary (uint8array)', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -55,6 +64,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         assert(result.ok);
         assert(result.payload.contents instanceof Uint8Array);
         expect(new TextDecoder().decode(result.payload.contents)).toStrictEqual('contents for file test.py');
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -65,6 +79,7 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         input.push({ msg: 'abc', ignore: false });
         input.push({ msg: 'def', ignore: true });
         input.push({ msg: 'ghi', ignore: false });
+        input.push({ msg: 'end', ignore: false, end: true });
         input.end();
         const result1 = await iterNext(output);
         assert(result1.ok);
@@ -72,7 +87,18 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const result2 = await iterNext(output);
         assert(result2.ok);
         expect(result2.payload).toStrictEqual({ response: 'ghi' });
+        const result3 = await iterNext(output);
+        assert(result3.ok);
+        expect(result3.payload).toStrictEqual({ response: 'end' });
+        // after the server stream is ended, the client stream should be ended too
+        const result4 = await output.next();
+        assert(result4.done);
         close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('fallible stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -96,6 +122,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             message: 'some message',
         });
         close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('subscription', async () => {
         const options = { codec };
@@ -132,6 +163,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         expect(result.payload).toStrictEqual({ result: 4 });
         close1();
         close2();
+        await testFinishesCleanly({
+            clientTransports: [client1Transport, client2Transport],
+            serverTransport,
+            server,
+        });
     });
     test('message order is preserved in the face of disconnects', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -153,7 +189,12 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         }
         const res = await client.test.getAll.rpc({});
         assert(res.ok);
-        return expect(res.payload.msgs).toStrictEqual(expected);
+        expect(res.payload.msgs).toStrictEqual(expected);
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     const CONCURRENCY = 10;
     test('concurrent rpcs', async () => {
@@ -170,6 +211,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             assert(result.ok);
             expect(result.payload).toStrictEqual({ n: i });
         }
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('concurrent streams', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -198,5 +244,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             const [_input, _output, close] = openStreams[i];
             close();
         }
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
 });

package/dist/__tests__/fixtures/cleanup.d.ts

@@ -0,0 +1,12 @@
+import { Connection, Transport } from '../../transport';
+import { Server } from '../../router';
+export declare function ensureTransportIsClean(t: Transport<Connection>): Promise<void>;
+export declare function waitUntil<T>(valueGetter: () => T, expected: T, message?: string): Promise<boolean>;
+export declare function ensureTransportQueuesAreEventuallyEmpty(t: Transport<Connection>): Promise<void>;
+export declare function ensureServerIsClean(s: Server<unknown>): Promise<boolean>;
+export declare function testFinishesCleanly({ clientTransports, serverTransport, server, }: Partial<{
+    clientTransports: Array<Transport<Connection>>;
+    serverTransport: Transport<Connection>;
+    server: Server<unknown>;
+}>): Promise<void>;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/__tests__/fixtures/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/cleanup.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAOtC,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,iBAapE;AAED,wBAAsB,SAAS,CAAC,CAAC,EAC/B,WAAW,EAAE,MAAM,CAAC,EACpB,QAAQ,EAAE,CAAC,EACX,OAAO,CAAC,EAAE,MAAM,oBAOjB;AAED,wBAAsB,uCAAuC,CAC3D,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,iBAazB;AAED,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,oBAM3D;AAED,wBAAsB,mBAAmB,CAAC,EACxC,gBAAgB,EAChB,eAAe,EACf,MAAM,GACP,EAAE,OAAO,CAAC;IACT,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IAC/C,eAAe,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;CACzB,CAAC,iBAgBD"}

package/dist/__tests__/fixtures/cleanup.js

@@ -0,0 +1,39 @@
+import { expect, vi } from 'vitest';
+const waitUntilOptions = {
+    timeout: 250,
+    interval: 5, // check every 5ms
+};
+export async function ensureTransportIsClean(t) {
+    expect(t.state, `transport ${t.clientId} should be closed after the test`).to.not.equal('open');
+    expect(t.connections, `transport ${t.clientId} should not have open connections after the test`).toStrictEqual(new Map());
+    expect(t.messageHandlers, `transport ${t.clientId} should not have open message handlers after the test`).toStrictEqual(new Set());
+}
+export async function waitUntil(valueGetter, expected, message) {
+    return vi
+        .waitUntil(() => valueGetter() === expected, waitUntilOptions)
+        .finally(() => {
+        expect(valueGetter(), message).toEqual(expected);
+    });
+}
+export async function ensureTransportQueuesAreEventuallyEmpty(t) {
+    await waitUntil(() => t.sendQueue.size, 0, `transport ${t.clientId} should not have any messages waiting to send after the test`);
+    await waitUntil(() => t.sendBuffer.size, 0, `transport ${t.clientId} should not have any un-acked messages after the test`);
+}
+export async function ensureServerIsClean(s) {
+    return waitUntil(() => s.streams.size, 0, `server should not have any open streams after the test`);
+}
+export async function testFinishesCleanly({ clientTransports, serverTransport, server, }) {
+    if (clientTransports) {
+        await Promise.all(clientTransports.map((t) => t.close()));
+        await Promise.all(clientTransports.map(ensureTransportIsClean));
+    }
+    // server sits on top of server transport so we clean it up first
+    if (server) {
+        await ensureServerIsClean(server);
+        await server.close();
+    }
+    if (serverTransport) {
+        await serverTransport.close();
+        await ensureTransportIsClean(serverTransport);
+    }
+}

package/dist/__tests__/fixtures/services.d.ts

@@ -2,6 +2,7 @@ import { Observable } from './observable';
 export declare const EchoRequest: import("@sinclair/typebox").TObject<{
     msg: import("@sinclair/typebox").TString;
     ignore: import("@sinclair/typebox").TBoolean;
+    end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>;
 export declare const EchoResponse: import("@sinclair/typebox").TObject<{
     response: import("@sinclair/typebox").TString;
@@ -34,6 +35,7 @@ export declare const TestServiceConstructor: () => {
             input: import("@sinclair/typebox").TObject<{
                 msg: import("@sinclair/typebox").TString;
                 ignore: import("@sinclair/typebox").TBoolean;
+                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
             }>;
             output: import("@sinclair/typebox").TObject<{
                 response: import("@sinclair/typebox").TString;
@@ -42,6 +44,7 @@ export declare const TestServiceConstructor: () => {
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
             }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                end?: boolean | undefined;
                 msg: string;
                 ignore: boolean;
             }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{

package/dist/__tests__/fixtures/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;EAGtB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B5B,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B5B,CAAC"}

package/dist/__tests__/fixtures/services.js

@@ -6,6 +6,7 @@ import { Observable } from './observable';
 export const EchoRequest = Type.Object({
     msg: Type.String(),
     ignore: Type.Boolean(),
+    end: Type.Optional(Type.Boolean()),
 });
 export const EchoResponse = Type.Object({ response: Type.String() });
 export const TestServiceConstructor = () => ServiceBuilder.create('test')
@@ -34,6 +35,9 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
             if (!req.ignore) {
                 returnStream.push(reply(msg, Ok({ response: req.msg })));
             }
+            if (req.end) {
+                returnStream.end();
+            }
         }
     },
 })

package/dist/__tests__/invariants.test.d.ts

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

package/dist/__tests__/invariants.test.d.ts.map

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

package/dist/__tests__/invariants.test.js

@@ -0,0 +1,136 @@
+import { afterAll, assert, describe, expect, test } from 'vitest';
+import http from 'http';
+import { createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
+import { SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+import { createClient, createServer } from '../router';
+import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitUntil, } from './fixtures/cleanup';
+describe('procedures should leave no trace after finishing', async () => {
+    const httpServer = http.createServer();
+    const port = await onServerReady(httpServer);
+    const webSocketServer = await createWebSocketServer(httpServer);
+    const getTransports = () => createWsTransports(port, webSocketServer);
+    afterAll(() => {
+        webSocketServer.close();
+        httpServer.close();
+    });
+    test('closing a transport from the client cleans up connection on the server', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        expect(clientTransport.connections.size).toEqual(0);
+        expect(serverTransport.connections.size).toEqual(0);
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        // should be back to 0 connections after client closes
+        clientTransport.close();
+        expect(clientTransport.connections.size).toEqual(0);
+        await waitUntil(() => serverTransport.connections.size, 0, 'server should cleanup connection after client closes');
+    });
+    test('closing a transport from the server cleans up connection on the client', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        expect(clientTransport.connections.size).toEqual(0);
+        expect(serverTransport.connections.size).toEqual(0);
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        // should be back to 0 connections after client closes
+        serverTransport.close();
+        expect(serverTransport.connections.size).toEqual(0);
+        await waitUntil(() => clientTransport.connections.size, 0, 'client should cleanup connection after server closes');
+    });
+    test('rpc', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.messageHandlers.size;
+        let clientListeners = clientTransport.messageHandlers.size;
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        // number of message handlers shouldn't increase after rpc
+        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
+        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+    test('stream', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.messageHandlers.size;
+        let clientListeners = clientTransport.messageHandlers.size;
+        // start procedure
+        const [input, output, close] = await client.test.echo.stream();
+        input.push({ msg: '1', ignore: false });
+        input.push({ msg: '2', ignore: false, end: true });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1.ok);
+        expect(result1.payload).toStrictEqual({ response: '1' });
+        const result2 = await iterNext(output);
+        assert(result2.ok);
+        expect(result2.payload).toStrictEqual({ response: '2' });
+        // ensure we exactly have one stream even after we send multiple messages
+        expect(server.streams.size).toEqual(1);
+        const result3 = await output.next();
+        assert(result3.done);
+        close();
+        // end procedure
+        // number of message handlers shouldn't increase after stream ends
+        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
+        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+    test('subscription', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: SubscribableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.messageHandlers.size;
+        let clientListeners = clientTransport.messageHandlers.size;
+        // start procedure
+        const [subscription, close] = await client.test.value.subscribe({});
+        let result = await iterNext(subscription);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        const add1 = await client.test.add.rpc({ n: 1 });
+        assert(add1.ok);
+        result = await iterNext(subscription);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 1 });
+        close();
+        // end procedure
+        // number of message handlers shouldn't increase after stream ends
+        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
+        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+});

package/dist/__tests__/serialize.test.js

@@ -31,6 +31,7 @@ describe('serialize service to jsonschema', () => {
                         properties: {
                             msg: { type: 'string' },
                             ignore: { type: 'boolean' },
+                            end: { type: 'boolean' },
                         },
                         required: ['msg', 'ignore'],
                         type: 'object',

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,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,GACX;QACE,GAAG,EAAE,CACH,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,CAAC;KACH,GACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,QAAQ,GAC3C;QACE,MAAM,EAAE,MAAM,OAAO,CACnB;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,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;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,cAAc,GACjD;QACE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,OAAO,CAChE;YACE,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;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD,KAAK;CACV,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,sBAmHA,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,EAGlB,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,GACX;QACE,GAAG,EAAE,CACH,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,CAAC;KACH,GACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,QAAQ,GAC3C;QACE,MAAM,EAAE,MAAM,OAAO,CACnB;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,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;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,cAAc,GACjD;QACE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,OAAO,CAChE;YACE,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;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD,KAAK;CACV,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,sBAoIA,CAAC"}

package/dist/router/client.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { msg, } from '../transport/message';
+import { msg, isStreamClose, closeStream, } from '../transport/message';
 import { waitForMessage } from '../transport';
 import { nanoid } from 'nanoid';
 const noop = () => { };
@@ -49,18 +49,25 @@ export const createClient = (transport, serverId = 'SERVER') => _createRecursive
     if (procType === 'stream') {
         const inputStream = pushable({ objectMode: true });
         const outputStream = pushable({ objectMode: true });
+        let firstMessage = true;
         // input -> transport
         // this gets cleaned up on i.end() which is called by closeHandler
         (async () => {
             for await (const rawIn of inputStream) {
                 const m = msg(transport.clientId, serverId, serviceName, procName, streamId, rawIn);
-                m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
+                if (firstMessage) {
+                    m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
+                    firstMessage = false;
+                }
                 transport.send(m);
             }
         })();
         // transport -> output
         const listener = (msg) => {
-            if (belongsToSameStream(msg)) {
+            if (isStreamClose(msg.controlFlags)) {
+                outputStream.end();
+            }
+            else if (belongsToSameStream(msg)) {
                 outputStream.push(msg.payload);
             }
         };
@@ -68,9 +75,7 @@ export const createClient = (transport, serverId = 'SERVER') => _createRecursive
         const closeHandler = () => {
             inputStream.end();
             outputStream.end();
-            const closeMessage = msg(transport.clientId, serverId, serviceName, procName, streamId, { type: 'CLOSE' });
-            closeMessage.controlFlags |= 4 /* ControlFlags.StreamClosedBit */;
-            transport.send(closeMessage);
+            transport.send(closeStream(transport.clientId, serverId, serviceName, procName, streamId));
             transport.removeMessageListener(listener);
         };
         return [inputStream, outputStream, closeHandler];
@@ -93,10 +98,14 @@ export const createClient = (transport, serverId = 'SERVER') => _createRecursive
             if (belongsToSameStream(msg)) {
                 outputStream.push(msg.payload);
             }
+            if (isStreamClose(msg.controlFlags)) {
+                outputStream.end();
+            }
         };
         transport.addMessageListener(listener);
         const closeHandler = () => {
             outputStream.end();
+            transport.send(closeStream(transport.clientId, serverId, serviceName, procName, streamId));
             transport.removeMessageListener(listener);
         };
         return [outputStream, closeHandler];

package/dist/router/server.d.ts

@@ -1,14 +1,27 @@
+import { Static, TObject } from '@sinclair/typebox';
 import { Connection, Transport } from '../transport/transport';
 import { AnyService } from './builder';
+import type { Pushable } from 'it-pushable';
+import { TransportMessage } from '../transport/message';
 import { ServiceContext } from './context';
+import { Result, RiverError } from './result';
 /**
  * Represents a server with a set of services. Use {@link createServer} to create it.
  * @template Services - The type of services provided by the server.
  */
 export interface Server<Services> {
     services: Services;
+    streams: Map<string, ProcStream>;
     close(): Promise<void>;
 }
+interface ProcStream {
+    incoming: Pushable<TransportMessage>;
+    outgoing: Pushable<TransportMessage<Result<Static<TObject>, Static<RiverError>>>>;
+    promises: {
+        outputHandler: Promise<unknown>;
+        inputHandler: Promise<unknown>;
+    };
+}
 /**
  * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
  * The server tracks the state of each service along with open streams and the extended context object.
@@ -18,4 +31,5 @@ export interface Server<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<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Promise<Server<Services>>;
+export {};
 //# 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,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,CA0K3B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../router/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAgB,UAAU,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAGL,gBAAgB,EAKjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAA2B,MAAM,WAAW,CAAC;AAGpE,OAAO,EAEL,MAAM,EACN,UAAU,EAGX,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,QAAQ;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,UAAU,UAAU;IAClB,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAChB,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAC9D,CAAC;IACF,QAAQ,EAAE;QACR,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;KAChC,CAAC;CACH;AAED;;;;;;;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,CAuM3B"}

package/dist/router/server.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { ControlMessagePayloadSchema, isStreamClose, isStreamOpen, reply, } from '../transport/message';
+import { ControlMessagePayloadSchema, isStreamClose, isStreamOpen, reply, closeStream, } from '../transport/message';
 import { log } from '../logging';
 import { Value } from '@sinclair/typebox/value';
 import { Err, UNCAUGHT_ERROR, } from './result';
@@ -15,6 +15,16 @@ export async function createServer(transport, services, extendedContext) {
     const contextMap = new Map();
     // map of streamId to ProcStream
     const streamMap = new Map();
+    async function cleanupStream(id) {
+        const stream = streamMap.get(id);
+        if (stream) {
+            stream.incoming.end();
+            await stream.promises.inputHandler;
+            stream.outgoing.end();
+            await stream.promises.outputHandler;
+            streamMap.delete(id);
+        }
+    }
     function getContext(service) {
         const context = contextMap.get(service);
         if (!context) {
@@ -28,50 +38,57 @@ export async function createServer(transport, services, extendedContext) {
     for (const service of Object.values(services)) {
         contextMap.set(service, { ...extendedContext, state: service.state });
     }
-    const handler = async (msg) => {
-        if (msg.to !== transport.clientId) {
+    const handler = async (message) => {
+        if (message.to !== transport.clientId) {
             log?.info(`${transport.clientId} -- got msg with destination that isn't the server, ignoring`);
             return;
         }
-        if (!(msg.serviceName in services)) {
-            log?.warn(`${transport.clientId} -- couldn't find service ${msg.serviceName}`);
+        if (!(message.serviceName in services)) {
+            log?.warn(`${transport.clientId} -- couldn't find service ${message.serviceName}`);
             return;
         }
-        const service = services[msg.serviceName];
+        const service = services[message.serviceName];
         const serviceContext = getContext(service);
-        if (!(msg.procedureName in service.procedures)) {
-            log?.warn(`${transport.clientId} -- couldn't find a matching procedure for ${msg.serviceName}.${msg.procedureName}`);
+        if (!(message.procedureName in service.procedures)) {
+            log?.warn(`${transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`);
             return;
         }
-        const procedure = service.procedures[msg.procedureName];
-        const streamIdx = `${msg.serviceName}.${msg.procedureName}:${msg.streamId}`;
-        if (isStreamOpen(msg.controlFlags) && !streamMap.has(streamIdx)) {
+        const procedure = service.procedures[message.procedureName];
+        const streamIdx = `${message.serviceName}.${message.procedureName}:${message.streamId}`;
+        if (isStreamOpen(message.controlFlags) && !streamMap.has(streamIdx)) {
             const incoming = pushable({ objectMode: true });
             const outgoing = pushable({ objectMode: true });
-            const openPromises = [
-                // sending outgoing messages back to client
-                (async () => {
-                    for await (const response of outgoing) {
-                        transport.send(response);
-                    }
-                })(),
-            ];
+            const outputHandler = 
+            // sending outgoing messages back to client
+            (async () => {
+                for await (const response of outgoing) {
+                    transport.send(response);
+                }
+                // we ended, send a close bit back to the client
+                // only subscriptions and streams have streams the
+                // handler can close
+                if (procedure.type === 'subscription' ||
+                    procedure.type === 'stream') {
+                    transport.send(closeStream(transport.clientId, message.from, message.serviceName, message.procedureName, message.streamId));
+                }
+            })();
             function errorHandler(err) {
                 const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-                log?.error(`${transport.clientId} -- procedure ${msg.serviceName}.${msg.procedureName}:${msg.streamId} threw an error: ${errorMsg}`);
-                outgoing.push(reply(msg, Err({
+                log?.error(`${transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`);
+                outgoing.push(reply(message, Err({
                     code: UNCAUGHT_ERROR,
                     message: errorMsg,
                 })));
             }
             // pump incoming message stream -> handler -> outgoing message stream
+            let inputHandler;
             if (procedure.type === 'stream') {
-                openPromises.push(procedure
+                inputHandler = procedure
                     .handler(serviceContext, incoming, outgoing)
-                    .catch(errorHandler));
+                    .catch(errorHandler);
             }
             else if (procedure.type === 'rpc') {
-                openPromises.push((async () => {
+                inputHandler = (async () => {
                     const inputMessage = await incoming.next();
                     if (inputMessage.done) {
                         return;
@@ -83,10 +100,10 @@ export async function createServer(transport, services, extendedContext) {
                     catch (err) {
                         errorHandler(err);
                     }
-                })());
+                })();
             }
             else if (procedure.type === 'subscription') {
-                openPromises.push((async () => {
+                inputHandler = (async () => {
                     const inputMessage = await incoming.next();
                     if (inputMessage.done) {
                         return;
@@ -97,40 +114,43 @@ export async function createServer(transport, services, extendedContext) {
                     catch (err) {
                         errorHandler(err);
                     }
-                })());
+                })();
+            }
+            else {
+                // procedure is inferred to be never here as this is not a valid procedure type
+                // we cast just to log
+                log?.warn(`${transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`);
+                return;
             }
             streamMap.set(streamIdx, {
                 incoming,
                 outgoing,
-                openPromises,
+                promises: { inputHandler, outputHandler },
             });
         }
         const procStream = streamMap.get(streamIdx);
         if (!procStream) {
-            log?.warn(`${transport.clientId} -- couldn't find a matching procedure stream for ${msg.serviceName}.${msg.procedureName}:${msg.streamId}`);
+            log?.warn(`${transport.clientId} -- couldn't find a matching procedure stream for ${message.serviceName}.${message.procedureName}:${message.streamId}`);
             return;
         }
-        if (Value.Check(procedure.input, msg.payload)) {
-            procStream.incoming.push(msg);
+        if (Value.Check(procedure.input, message.payload)) {
+            procStream.incoming.push(message);
         }
-        else if (!Value.Check(ControlMessagePayloadSchema, msg.payload)) {
-            log?.error(`${transport.clientId} -- procedure ${msg.serviceName}.${msg.procedureName} received invalid payload: ${JSON.stringify(msg.payload)}`);
+        else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
+            log?.error(`${transport.clientId} -- procedure ${message.serviceName}.${message.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`);
         }
-        if (isStreamClose(msg.controlFlags)) {
-            procStream.incoming.end();
-            await Promise.all(procStream.openPromises);
-            procStream.outgoing.end();
+        if (isStreamClose(message.controlFlags)) {
+            await cleanupStream(streamIdx);
         }
     };
     transport.addMessageListener(handler);
     return {
         services,
+        streams: streamMap,
         async close() {
             transport.removeMessageListener(handler);
-            for (const [_, stream] of streamMap) {
-                stream.incoming.end();
-                await Promise.all(stream.openPromises);
-                stream.outgoing.end();
+            for (const streamIdx of streamMap.keys()) {
+                await cleanupStream(streamIdx);
             }
         },
     };

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

@@ -3,9 +3,6 @@ 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;
@@ -16,7 +13,6 @@ interface Options {
 }
 /**
  * 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> {

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

@@ -1 +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"}
+{"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,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;CAGZ;AAED,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD;;;GAGG;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

@@ -4,9 +4,6 @@ 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);
@@ -19,7 +16,6 @@ export class StdioConnection extends Connection {
         return this.output.write(out);
     }
     async close() {
-        this.transport.onDisconnect(this);
         this.output.end();
     }
 }
@@ -28,7 +24,6 @@ const defaultOptions = {
 };
 /**
  * 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 {

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

@@ -3,6 +3,7 @@ import stream from 'node:stream';
 import { StdioTransport } from './stdio';
 import { waitForMessage } from '../..';
 import { payloadToTransportMessage } from '../../../util/testHelpers';
+import { ensureTransportIsClean } from '../../../__tests__/fixtures/cleanup';
 describe('sending and receiving across node streams works', () => {
     test('basic send/receive', async () => {
         const clientToServer = new stream.PassThrough();
@@ -16,5 +17,9 @@ describe('sending and receiving across node streams works', () => {
         const p = waitForMessage(serverTransport);
         clientTransport.send(payloadToTransportMessage(msg, 'stream', clientTransport.clientId, serverTransport.clientId));
         await expect(p).resolves.toStrictEqual(msg);
+        await clientTransport.close();
+        await serverTransport.close();
+        await ensureTransportIsClean(clientTransport);
+        await ensureTransportIsClean(serverTransport);
     });
 });

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

@@ -1 +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"}
+{"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;IAuEjD;;OAEG;IACG,IAAI;CAGX"}

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

@@ -83,13 +83,13 @@ export class WebSocketClientTransport extends Transport {
             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;
+            throw new Error(`${this.clientId} -- websocket to ${to} failed after ${attempt} attempts, giving up`);
         }
         else {
             // linear backoff
+            log?.warn(`${this.clientId} -- websocket to ${to} failed, trying again in ${this.options.retryIntervalMs * attempt}ms`);
             setTimeout(() => this.createNewConnection(to, attempt + 1), this.options.retryIntervalMs * attempt);
         }
     }

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

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/connection.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,SAAS,MAAM,eAAe,CAAC;AAEtC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,EAAE,EAAE,SAAS,CAAC;gBAGZ,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,EACzC,WAAW,EAAE,iBAAiB,EAC9B,EAAE,EAAE,SAAS;IAQf,IAAI,CAAC,OAAO,EAAE,UAAU;IASlB,KAAK;CAGZ"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/connection.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,SAAS,MAAM,eAAe,CAAC;AAEtC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,EAAE,EAAE,SAAS,CAAC;gBAGZ,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,EACzC,WAAW,EAAE,iBAAiB,EAC9B,EAAE,EAAE,SAAS;IAUf,IAAI,CAAC,OAAO,EAAE,UAAU;IASlB,KAAK;CAGZ"}

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

@@ -5,7 +5,8 @@ export class WebSocketConnection extends Connection {
         super(transport, connectedTo);
         this.ws = ws;
         ws.binaryType = 'arraybuffer';
-        this.ws.onmessage = (msg) => this.onMessage(msg.data);
+        // take over the onmessage for this websocket
+        this.ws.onmessage = (msg) => transport.onMessage(msg.data);
     }
     send(payload) {
         if (this.ws.readyState === this.ws.OPEN) {

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

@@ -12,8 +12,6 @@ export declare class WebSocketServerTransport extends Transport<WebSocketConnect
     constructor(wss: Server, clientId: TransportClientId, providedOptions?: Partial<Options>);
     setupConnectionStatusListeners(): void;
     createNewConnection(to: string): Promise<void>;
-    destroy(): Promise<void>;
-    close(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=server.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;gBAG1B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IASpC,8BAA8B,IAAI,IAAI;IA8BhC,mBAAmB,CAAC,EAAE,EAAE,MAAM;IAM9B,OAAO;IAKP,KAAK;CAIZ"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;gBAG1B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IASpC,8BAA8B,IAAI,IAAI;IAiChC,mBAAmB,CAAC,EAAE,EAAE,MAAM;CAKrC"}

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

@@ -19,8 +19,11 @@ export class WebSocketServerTransport extends Transport {
         this.wss.on('connection', (ws) => {
             let conn = undefined;
             ws.onmessage = (msg) => {
+                // when we establish WebSocketConnection, ws.onmessage
+                // gets overriden so this only runs on the first valid message
+                // the websocket receives
                 const parsedMsg = this.parseMsg(msg.data);
-                if (parsedMsg) {
+                if (parsedMsg && !conn) {
                     conn = new WebSocketConnection(this, parsedMsg.from, ws);
                     this.onConnect(conn);
                     this.handleMsg(parsedMsg);
@@ -42,12 +45,4 @@ export class WebSocketServerTransport extends Transport {
         log?.warn(err);
         return;
     }
-    async destroy() {
-        super.destroy();
-        this.wss.close();
-    }
-    async close() {
-        super.close();
-        this.wss.close();
-    }
 }

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

@@ -4,21 +4,24 @@ import { createWebSocketServer, createWsTransports, createDummyTransportMessage,
 import { msg, waitForMessage } from '../..';
 import { WebSocketServerTransport } from './server';
 import { WebSocketClientTransport } from './client';
+import { testFinishesCleanly } from '../../../__tests__/fixtures/cleanup';
 describe('sending and receiving across websockets works', async () => {
     const server = http.createServer();
     const port = await onServerReady(server);
     const wss = await createWebSocketServer(server);
     afterAll(() => {
-        wss.clients.forEach((socket) => {
-            socket.close();
-        });
+        wss.close();
         server.close();
     });
     test('basic send/receive', async () => {
         const [clientTransport, serverTransport] = createWsTransports(port, wss);
         const msg = createDummyTransportMessage();
         clientTransport.send(msg);
-        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg.id)).resolves.toStrictEqual(msg.payload);
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg.id)).resolves.toStrictEqual(msg.payload);
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+        });
     });
     test('sending respects to/from fields', async () => {
         const makeDummyMessage = (from, to, message) => {
@@ -50,6 +53,10 @@ describe('sending and receiving across websockets works', async () => {
         serverTransport.send(msg1);
         serverTransport.send(msg2);
         await expect(promises).resolves.toStrictEqual([msg1.payload, msg2.payload]);
+        await testFinishesCleanly({
+            clientTransports: [client1, client2],
+            serverTransport,
+        });
     });
 });
 describe('retry logic', async () => {
@@ -57,9 +64,7 @@ describe('retry logic', async () => {
     const port = await onServerReady(server);
     const wss = await createWebSocketServer(server);
     afterAll(() => {
-        wss.clients.forEach((socket) => {
-            socket.close();
-        });
+        wss.close();
         server.close();
     });
     // TODO: right now, we only test client-side disconnects, we probably
@@ -73,7 +78,12 @@ describe('retry logic', async () => {
         await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
         clientTransport.connections.forEach((conn) => conn.ws.close());
         clientTransport.send(msg2);
-        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+        // by this point the client should have reconnected
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+        });
     });
     test('ws transport is recreated after unclean disconnect', async () => {
         const [clientTransport, serverTransport] = createWsTransports(port, wss);
@@ -83,7 +93,13 @@ describe('retry logic', async () => {
         await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
         clientTransport.connections.forEach((conn) => conn.ws.terminate());
         clientTransport.send(msg2);
-        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+        // by this point the client should have reconnected
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+        // this is not expected to be clean because we destroyed the transport
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+        });
     });
     test('ws transport is not recreated after destroy', async () => {
         const [clientTransport, serverTransport] = createWsTransports(port, wss);
@@ -92,6 +108,10 @@ describe('retry logic', async () => {
         clientTransport.send(msg1);
         await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
         clientTransport.destroy();
-        return expect(() => clientTransport.send(msg2)).toThrow(new Error('transport is destroyed, cant send'));
+        expect(() => clientTransport.send(msg2)).toThrow(new Error('transport is destroyed, cant send'));
+        // this is not expected to be clean because we destroyed the transport
+        expect(clientTransport.state).toEqual('destroyed');
+        await clientTransport.close();
+        await serverTransport.close();
     });
 });

package/dist/transport/index.d.ts

@@ -1,8 +1,8 @@
 import { OpaqueTransportMessage } from './message';
-import { Connection, Transport } from './transport';
-export { Transport } from './transport';
+import { Transport, Connection } from './transport';
+export { Transport, Connection } from './transport';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, msg, reply, } from './message';
-export type { TransportMessage, MessageId, OpaqueTransportMessage, TransportClientId, } from './message';
+export type { TransportMessage, MessageId, OpaqueTransportMessage, TransportClientId, isStreamOpen, isStreamClose, } from './message';
 /**
  * Waits for a message from the transport.
  * @param {Transport} t - The transport to listen to.

package/dist/transport/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../transport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,GAAG,EACH,KAAK,GACN,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,gBAAgB,EAChB,SAAS,EACT,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAEnB;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,EACxB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,OAAO,EACjD,cAAc,CAAC,EAAE,OAAO,oBAczB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../transport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,GAAG,EACH,KAAK,GACN,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,gBAAgB,EAChB,SAAS,EACT,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,aAAa,GACd,MAAM,WAAW,CAAC;AAEnB;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,EACxB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,OAAO,EACjD,cAAc,CAAC,EAAE,OAAO,oBAczB"}

package/dist/transport/index.js

@@ -1,5 +1,5 @@
 // re-export
-export { Transport } from './transport';
+export { Transport, Connection } from './transport';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, msg, reply, } from './message';
 /**
  * Waits for a message from the transport.

package/dist/transport/message.d.ts

@@ -103,6 +103,16 @@ export declare function msg<Payload extends object>(from: string, to: string, se
  * @returns A new transport message with appropriate to, from, and payload fields
  */
 export declare function reply<Payload extends object>(msg: OpaqueTransportMessage, response: Payload): TransportMessage<Payload>;
+/**
+ * Create a request to close a stream
+ * @param from The ID of the client initiating the close.
+ * @param to The ID of the client being closed.
+ * @param respondTo The transport message to respond to.
+ * @returns The close message
+ */
+export declare function closeStream(from: TransportClientId, to: TransportClientId, service: string, proc: string, stream: string): TransportMessage<{
+    type: "CLOSE";
+}>;
 /**
  * Checks if the given control flag (usually found in msg.controlFlag) is an ack message.
  * @param controlFlag - The control flag to check.

package/dist/transport/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../transport/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;GAMG;AACH,0BAAkB,YAAY;IAC5B,MAAM,IAAS;IACf,aAAa,IAAS;IACtB,eAAe,IAAS;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;EAU/B,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAI9B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;EAEtC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;EAExC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAC1B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzE;IACF,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,OAAO,SAAS,MAAM,EACxC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,GACf,gBAAgB,CAAC,OAAO,CAAC,CAW3B;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,OAAO,SAAS,MAAM,EAC1C,GAAG,EAAE,sBAAsB,EAC3B,QAAQ,EAAE,OAAO,GAChB,gBAAgB,CAAC,OAAO,CAAC,CAQ3B;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAK1D"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../transport/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAU,MAAM,mBAAmB,CAAC;AAG1D;;;;;;GAMG;AACH,0BAAkB,YAAY;IAC5B,MAAM,IAAS;IACf,aAAa,IAAS;IACtB,eAAe,IAAS;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;EAU/B,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAI9B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;EAEtC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;EAExC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAC1B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzE;IACF,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,OAAO,SAAS,MAAM,EACxC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,GACf,gBAAgB,CAAC,OAAO,CAAC,CAW3B;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,OAAO,SAAS,MAAM,EAC1C,GAAG,EAAE,sBAAsB,EAC3B,QAAQ,EAAE,OAAO,GAChB,gBAAgB,CAAC,OAAO,CAAC,CAS3B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,iBAAiB,EACvB,EAAE,EAAE,iBAAiB,EACrB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM;;GAOf;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAK1D"}

package/dist/transport/message.js

@@ -65,12 +65,27 @@ export function msg(from, to, service, proc, stream, payload) {
 export function reply(msg, response) {
     return {
         ...msg,
+        controlFlags: 0,
         id: nanoid(),
         to: msg.from,
         from: msg.to,
         payload: response,
     };
 }
+/**
+ * Create a request to close a stream
+ * @param from The ID of the client initiating the close.
+ * @param to The ID of the client being closed.
+ * @param respondTo The transport message to respond to.
+ * @returns The close message
+ */
+export function closeStream(from, to, service, proc, stream) {
+    const closeMessage = msg(from, to, service, proc, stream, {
+        type: 'CLOSE',
+    });
+    closeMessage.controlFlags |= 4 /* ControlFlags.StreamClosedBit */;
+    return closeMessage;
+}
 /**
  * Checks if the given control flag (usually found in msg.controlFlag) is an ack message.
  * @param controlFlag - The control flag to check.

package/dist/transport/transport.d.ts

@@ -1,26 +1,52 @@
 import { Codec } from '../codec/types';
 import { MessageId, OpaqueTransportMessage, TransportClientId } from './message';
 /**
- * Abstract base for a connection between two nodes in a River network.
- * A connection is responsible for sending and receiving messages on a 1:1
- * basis between nodes.
- * Connections can be reused across different transports.
- * @abstract
+ * A 1:1 connection between two transports. Once this is created,
+ * the {@link Connection} is expected to take over responsibility for
+ * reading and writing messages from the underlying connection.
+ *
+ * 1) Messages received on the {@link Connection} are dispatched back to the {@link Transport}
+ *    via {@link Transport.onMessage}. The {@link Transport} then notifies any registered message listeners.
+ * 2) When {@link Transport.send}(msg) is called, the transport looks up the appropriate
+ *    connection in the {@link connections} map via `msg.to` and calls {@link send}(bytes)
+ *    so the connection can send it.
  */
 export declare abstract class Connection {
     connectedTo: TransportClientId;
     transport: Transport<Connection>;
     constructor(transport: Transport<Connection>, connectedTo: TransportClientId);
-    onMessage(msg: Uint8Array): void;
     abstract send(msg: Uint8Array): boolean;
-    abstract close(): Promise<void>;
+    abstract close(): void;
 }
 export type TransportStatus = 'open' | 'closed' | 'destroyed';
 /**
- * Abstract base for a transport layer for communication between nodes in a River network.
- * A transport is responsible for handling the 1:n connection logic between nodes and
- * delegating sending/receiving to connections.
- * Any River transport methods need to implement this interface.
+ * Transports manage the lifecycle (creation/deletion) of connections. Its responsibilities include:
+ *
+ *  1) Constructing a new {@link Connection} on {@link TransportMessage}s from new clients.
+ *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
+ *  2) Delegating message listening of the connection to the newly created {@link Connection}.
+ *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
+ *     messages from the connection.
+ *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
+ *     connection via {@link Connection.close} and removes it from the {@link connections} map.
+
+ *
+ * ```plaintext
+ *            ▲
+ *  incoming  │
+ *  messages  │
+ *            ▼
+ *      ┌─────────────┐   1:N   ┌────────────┐
+ *      │  Transport  │ ◄─────► │ Connection │
+ *      └─────────────┘         └────────────┘
+ *            ▲
+ *            │
+ *            ▼
+ *      ┌───────────┐
+ *      │ Message   │
+ *      │ Listeners │
+ *      └───────────┘
+ * ```
  * @abstract
  */
 export declare abstract class Transport<ConnType extends Connection> {

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

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../transport/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAEL,SAAS,EACT,sBAAsB,EAGtB,iBAAiB,EAGlB,MAAM,WAAW,CAAC;AAGnB;;;;;;GAMG;AACH,8BAAsB,UAAU;IAC9B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;gBAG/B,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAChC,WAAW,EAAE,iBAAiB;IAMhC,SAAS,CAAC,GAAG,EAAE,UAAU;IAIzB,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IACvC,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAChC;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE9D;;;;;;GAMG;AACH,8BAAsB,SAAS,CAAC,QAAQ,SAAS,UAAU;IACzD;;;OAGG;IACH,KAAK,EAAE,eAAe,CAAC;IAEvB;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,eAAe,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC,CAAC;IAE5D;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAEpD;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAEnD;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IAE9C;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB;IAUrD;;;OAGG;IACH,QAAQ,CAAC,8BAA8B,IAAI,IAAI;IAE/C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAElE;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,QAAQ;IAyBxB;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,QAAQ;IAM3B;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU;IAIzB;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,sBAAsB,GAAG,IAAI;IAmBlE;;;;OAIG;IACH,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,sBAAsB,GAAG,IAAI;IAgCtD;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAIxE;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAI3E;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IA4C5C;;;;OAIG;IACG,KAAK;IAUX;;;;OAIG;IACG,OAAO;CASd"}
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../transport/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAEL,SAAS,EACT,sBAAsB,EAGtB,iBAAiB,EAGlB,MAAM,WAAW,CAAC;AAGnB;;;;;;;;;;GAUG;AACH,8BAAsB,UAAU;IAC9B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;gBAG/B,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAChC,WAAW,EAAE,iBAAiB;IAMhC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IACvC,QAAQ,CAAC,KAAK,IAAI,IAAI;CACvB;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8BAAsB,SAAS,CAAC,QAAQ,SAAS,UAAU;IACzD;;;OAGG;IACH,KAAK,EAAE,eAAe,CAAC;IAEvB;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,eAAe,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC,CAAC;IAE5D;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAEpD;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAEnD;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IAE9C;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB;IAUrD;;;OAGG;IACH,QAAQ,CAAC,8BAA8B,IAAI,IAAI;IAE/C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAElE;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,QAAQ;IAyBxB;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,QAAQ;IAM3B;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU;IAIzB;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,sBAAsB,GAAG,IAAI;IAmBlE;;;;OAIG;IACH,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,sBAAsB,GAAG,IAAI;IAgCtD;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAIxE;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAI3E;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IA4C5C;;;;OAIG;IACG,KAAK;IAUX;;;;OAIG;IACG,OAAO;CASd"}

package/dist/transport/transport.js

@@ -2,11 +2,15 @@ import { Value } from '@sinclair/typebox/value';
 import { OpaqueTransportMessageSchema, TransportAckSchema, isAck, reply, } from './message';
 import { log } from '../logging';
 /**
- * Abstract base for a connection between two nodes in a River network.
- * A connection is responsible for sending and receiving messages on a 1:1
- * basis between nodes.
- * Connections can be reused across different transports.
- * @abstract
+ * A 1:1 connection between two transports. Once this is created,
+ * the {@link Connection} is expected to take over responsibility for
+ * reading and writing messages from the underlying connection.
+ *
+ * 1) Messages received on the {@link Connection} are dispatched back to the {@link Transport}
+ *    via {@link Transport.onMessage}. The {@link Transport} then notifies any registered message listeners.
+ * 2) When {@link Transport.send}(msg) is called, the transport looks up the appropriate
+ *    connection in the {@link connections} map via `msg.to` and calls {@link send}(bytes)
+ *    so the connection can send it.
  */
 export class Connection {
     connectedTo;
@@ -15,15 +19,35 @@ export class Connection {
         this.connectedTo = connectedTo;
         this.transport = transport;
     }
-    onMessage(msg) {
-        return this.transport.onMessage(msg);
-    }
 }
 /**
- * Abstract base for a transport layer for communication between nodes in a River network.
- * A transport is responsible for handling the 1:n connection logic between nodes and
- * delegating sending/receiving to connections.
- * Any River transport methods need to implement this interface.
+ * Transports manage the lifecycle (creation/deletion) of connections. Its responsibilities include:
+ *
+ *  1) Constructing a new {@link Connection} on {@link TransportMessage}s from new clients.
+ *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
+ *  2) Delegating message listening of the connection to the newly created {@link Connection}.
+ *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
+ *     messages from the connection.
+ *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
+ *     connection via {@link Connection.close} and removes it from the {@link connections} map.
+
+ *
+ * ```plaintext
+ *            ▲
+ *  incoming  │
+ *  messages  │
+ *            ▼
+ *      ┌─────────────┐   1:N   ┌────────────┐
+ *      │  Transport  │ ◄─────► │ Connection │
+ *      └─────────────┘         └────────────┘
+ *            ▲
+ *            │
+ *            ▼
+ *      ┌───────────┐
+ *      │ Message   │
+ *      │ Listeners │
+ *      └───────────┘
+ * ```
  * @abstract
  */
 export class Transport {
@@ -91,7 +115,7 @@ export class Transport {
             }
             this.send(msg);
         }
-        this.sendQueue.set(conn.connectedTo, []);
+        this.sendQueue.delete(conn.connectedTo);
     }
     /**
      * The downstream implementation needs to call this when a connection is closed.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@replit/river",
   "sideEffects": false,
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "exports": {
     ".": "./dist/router/index.js",
@@ -40,7 +40,7 @@
     "prepack": "npm run build",
     "release": "npm publish --access public",
     "test:ui": "echo \"remember to go to /__vitest__ in the webview\" && vitest --ui --api.host 0.0.0.0 --api.port 3000",
-    "test": "vitest",
+    "test": "vitest --test-timeout=500",
     "bench": "vitest bench"
   },
   "engines": {