@replit/river 0.9.2 → 0.10.0

package/dist/__tests__/bandwidth.bench.js

@@ -1,12 +1,12 @@
 import http from 'http';
 import { assert, bench, describe } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady, } from '../util/testHelpers';
+import { createWebSocketServer, createWsTransports, onServerReady, waitForMessage, } from '../util/testHelpers';
 import largePayload from './fixtures/largePayload.json';
 import { TestServiceConstructor } from './fixtures/services';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import { StupidlyLargeService } from './typescript-stress.test';
-import { waitForMessage } from '../transport';
+import { buildServiceDefs } from '../router/defs';
 let smallId = 0;
 let largeId = 0;
 const dummyPayloadSmall = () => ({
@@ -53,8 +53,8 @@ describe('simple router level bandwidth', async () => {
     const port = await onServerReady(httpServer);
     const webSocketServer = await createWebSocketServer(httpServer);
     const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-    const serviceDefs = { test: TestServiceConstructor() };
-    const server = await createServer(serverTransport, serviceDefs);
+    const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+    const server = createServer(serverTransport, serviceDefs);
     const client = createClient(clientTransport);
     bench('rpc (wait for response)', async () => {
         const result = await client.test.add.rpc({ n: 1 });
@@ -75,13 +75,13 @@ describe('complex (50 procedures) router level bandwidth', async () => {
     const port = await onServerReady(httpServer);
     const webSocketServer = await createWebSocketServer(httpServer);
     const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-    const serviceDefs = {
-        a: StupidlyLargeService(),
-        b: StupidlyLargeService(),
-        c: StupidlyLargeService(),
-        d: StupidlyLargeService(),
-    };
-    const server = await createServer(serverTransport, serviceDefs);
+    const serviceDefs = buildServiceDefs([
+        StupidlyLargeService('a'),
+        StupidlyLargeService('b'),
+        StupidlyLargeService('c'),
+        StupidlyLargeService('d'),
+    ]);
+    const server = createServer(serverTransport, serviceDefs);
     const client = createClient(clientTransport);
     bench('rpc (wait for response)', async () => {
         const result = await client.b.f35.rpc({ a: 1 });

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

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

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

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

package/dist/__tests__/{invariants.test.js → cleanup.test.js}

@@ -1,9 +1,10 @@
 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 { SubscribableServiceConstructor, TestServiceConstructor, UploadableServiceConstructor, } from './fixtures/services';
 import { createClient, createServer } from '../router';
-import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitUntil, } from './fixtures/cleanup';
+import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitFor, } from './fixtures/cleanup';
+import { buildServiceDefs } from '../router/defs';
 describe('procedures should leave no trace after finishing', async () => {
     const httpServer = http.createServer();
     const port = await onServerReady(httpServer);
@@ -15,8 +16,8 @@ describe('procedures should leave no trace after finishing', async () => {
     });
     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 serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         expect(clientTransport.connections.size).toEqual(0);
         expect(serverTransport.connections.size).toEqual(0);
@@ -28,12 +29,12 @@ describe('procedures should leave no trace after finishing', async () => {
         // 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');
+        await waitFor(() => expect(serverTransport.connections.size, 'server should cleanup connection after client closes').toEqual(0));
     });
     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 serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         expect(clientTransport.connections.size).toEqual(0);
         expect(serverTransport.connections.size).toEqual(0);
@@ -45,12 +46,12 @@ describe('procedures should leave no trace after finishing', async () => {
         // 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');
+        await waitFor(() => expect(clientTransport.connections.size, 'client should cleanup connection after server closes').toEqual(0));
     });
     test('rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
         let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
@@ -70,8 +71,8 @@ describe('procedures should leave no trace after finishing', async () => {
     });
     test('stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
         let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
@@ -83,10 +84,10 @@ describe('procedures should leave no trace after finishing', async () => {
         assert(result1.ok);
         expect(result1.payload).toStrictEqual({ response: '1' });
         // ensure we only have one stream despite pushing multiple messages.
-        await waitUntil(() => server.streams.size, 1);
+        await waitFor(() => expect(server.streams.size).toEqual(1));
         input.end();
         // ensure we no longer have any streams since the input was closed.
-        await waitUntil(() => server.streams.size, 0);
+        await waitFor(() => expect(server.streams.size).toEqual(0));
         const result2 = await iterNext(output);
         assert(result2.ok);
         expect(result2.payload).toStrictEqual({ response: '2' });
@@ -107,24 +108,50 @@ describe('procedures should leave no trace after finishing', async () => {
     });
     test('subscription', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: SubscribableServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([SubscribableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
         let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
         // start procedure
-        const [subscription, close] = await client.test.value.subscribe({});
+        const [subscription, close] = await client.subscribable.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 });
+        const add1 = await client.subscribable.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
+        // number of message handlers shouldn't increase after subscription ends
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).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('upload', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
+        // start procedure
+        const [addStream, addResult] = await client.uploadable.addMultiple.upload();
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        addStream.end();
+        const result = await addResult;
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+        // end procedure
+        // number of message handlers shouldn't increase after upload ends
         expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
         expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
         // check number of connections

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

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

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

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

package/dist/__tests__/disconnects.test.js

@@ -0,0 +1,163 @@
+import { afterAll, afterEach, assert, beforeEach, describe, expect, test, vi, } from 'vitest';
+import http from 'http';
+import { createLocalWebSocketClient, createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
+import { SubscribableServiceConstructor, TestServiceConstructor, UploadableServiceConstructor, } from './fixtures/services';
+import { createClient, createServer } from '../router';
+import { ensureServerIsClean, waitFor } from './fixtures/cleanup';
+import { CONNECTION_GRACE_PERIOD_MS } from '../router/client';
+import { Err, UNEXPECTED_DISCONNECT } from '../router/result';
+import { WebSocketServerTransport } from '../transport/impls/ws/server';
+import { WebSocketClientTransport } from '../transport/impls/ws/client';
+import { buildServiceDefs } from '../router/defs';
+describe('procedures should handle unexpected disconnects', 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();
+    });
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    test('rpc', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        clientTransport.connections.forEach((conn) => conn.ws.close());
+        clientTransport.tryReconnecting = false;
+        const procPromise = client.test.add.rpc({ n: 4 });
+        // end procedure
+        // after we've disconnected, hit end of grace period
+        await vi.runOnlyPendingTimersAsync();
+        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
+        // we should get an error + expect the streams to be cleaned up
+        await expect(procPromise).resolves.toMatchObject(Err({
+            code: UNEXPECTED_DISCONNECT,
+        }));
+        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
+        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
+        await ensureServerIsClean(server);
+    });
+    test('stream', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        // start procedure
+        const [input, output] = await client.test.echo.stream();
+        input.push({ msg: 'abc', ignore: false });
+        const result = await iterNext(output);
+        assert(result.ok);
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        clientTransport.connections.forEach((conn) => conn.ws.close());
+        clientTransport.tryReconnecting = false;
+        const nextResPromise = iterNext(output);
+        // end procedure
+        // after we've disconnected, hit end of grace period
+        await vi.runOnlyPendingTimersAsync();
+        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
+        // we should get an error + expect the streams to be cleaned up
+        await expect(nextResPromise).resolves.toMatchObject(Err({
+            code: UNEXPECTED_DISCONNECT,
+        }));
+        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
+        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
+        await ensureServerIsClean(server);
+    });
+    test('subscription', async () => {
+        const serverTransport = new WebSocketServerTransport(webSocketServer, 'SERVER');
+        const client1Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client1', 'SERVER');
+        const client2Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client2', 'SERVER');
+        const serviceDefs = buildServiceDefs([SubscribableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
+        const client1 = createClient(client1Transport);
+        const client2 = createClient(client2Transport);
+        // start procedure
+        // client1 and client2 both subscribe
+        const [subscription1, close1] = await client1.subscribable.value.subscribe({});
+        let result = await iterNext(subscription1);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        const [subscription2, _close2] = await client2.subscribable.value.subscribe({});
+        result = await iterNext(subscription2);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        // client2 adds a value
+        const add1 = await client2.subscribable.add.rpc({ n: 1 });
+        assert(add1.ok);
+        // both clients should receive the updated value
+        result = await iterNext(subscription1);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 1 });
+        result = await iterNext(subscription2);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 1 });
+        // all clients are connected
+        expect(client1Transport.connections.size).toEqual(1);
+        expect(client2Transport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(2);
+        // kill the connection for client2
+        client2Transport.connections.forEach((conn) => conn.ws.close());
+        client2Transport.tryReconnecting = false;
+        // client1 who is still connected can still add values and receive updates
+        const add2Promise = client1.subscribable.add.rpc({ n: 2 });
+        // after we've disconnected, hit end of grace period
+        await vi.runOnlyPendingTimersAsync();
+        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
+        // we should get an error from the subscription on client2
+        const nextResPromise = iterNext(subscription2);
+        await expect(nextResPromise).resolves.toMatchObject(Err({
+            code: UNEXPECTED_DISCONNECT,
+        }));
+        // client1 who is still connected can still add values and receive updates
+        assert((await add2Promise).ok);
+        result = await iterNext(subscription1);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+        // at this point, only client1 is connected
+        expect(client1Transport.connections.size).toEqual(1);
+        expect(client2Transport.connections.size).toEqual(0);
+        expect(serverTransport.connections.size).toEqual(1);
+        // cleanup client1 (client2 is already disconnected)
+        close1();
+        await client1Transport.close();
+        await ensureServerIsClean(server);
+    });
+    test('upload', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        // start procedure
+        const [addStream, addResult] = await client.uploadable.addMultiple.upload();
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        // end procedure
+        // need to wait for connection to be established
+        await waitFor(() => expect(clientTransport.connections.size).toEqual(1));
+        await waitFor(() => expect(serverTransport.connections.size).toEqual(1));
+        clientTransport.connections.forEach((conn) => conn.ws.close());
+        clientTransport.tryReconnecting = false;
+        // after we've disconnected, hit end of grace period
+        await vi.runOnlyPendingTimersAsync();
+        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
+        // we should get an error + expect the streams to be cleaned up
+        await expect(addResult).resolves.toMatchObject(Err({
+            code: UNEXPECTED_DISCONNECT,
+        }));
+        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
+        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
+        await ensureServerIsClean(server);
+    });
+});

package/dist/__tests__/e2e.test.js

@@ -9,6 +9,7 @@ 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';
+import { buildServiceDefs } from '../router/defs';
 describe.each(codecs)('client <-> server integration test ($name codec)', async ({ codec }) => {
     const httpServer = http.createServer();
     const port = await onServerReady(httpServer);
@@ -20,8 +21,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const result = await client.test.add.rpc({ n: 3 });
         assert(result.ok);
@@ -34,13 +35,13 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('fallible rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: FallibleServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([FallibleServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const result = await client.test.divide.rpc({ a: 10, b: 2 });
+        const result = await client.fallible.divide.rpc({ a: 10, b: 2 });
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 5 });
-        const result2 = await client.test.divide.rpc({ a: 10, b: 0 });
+        const result2 = await client.fallible.divide.rpc({ a: 10, b: 0 });
         assert(!result2.ok);
         expect(result2.payload).toStrictEqual({
             code: DIV_BY_ZERO,
@@ -57,10 +58,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('rpc with binary (uint8array)', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: BinaryFileServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([BinaryFileServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const result = await client.test.getFile.rpc({ file: 'test.py' });
+        const result = await client.bin.getFile.rpc({ file: 'test.py' });
         assert(result.ok);
         assert(result.payload.contents instanceof Uint8Array);
         expect(new TextDecoder().decode(result.payload.contents)).toStrictEqual('contents for file test.py');
@@ -72,8 +73,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const [input, output, close] = await client.test.echo.stream();
         input.push({ msg: 'abc', ignore: false });
@@ -102,8 +103,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('stream with init message', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const [input, output, close] = await client.test.echoWithPrefix.stream({
             prefix: 'test',
@@ -127,10 +128,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('fallible stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: FallibleServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([FallibleServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const [input, output, close] = await client.test.echo.stream();
+        const [input, output, close] = await client.fallible.echo.stream();
         input.push({ msg: 'abc', throwResult: false, throwError: false });
         const result1 = await iterNext(output);
         assert(result1 && result1.ok);
@@ -158,19 +159,19 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const serverTransport = new WebSocketServerTransport(webSocketServer, 'SERVER', options);
         const client1Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client1', 'SERVER', options);
         const client2Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client2', 'SERVER', options);
-        const serviceDefs = { test: SubscribableServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([SubscribableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client1 = createClient(client1Transport);
         const client2 = createClient(client2Transport);
-        const [subscription1, close1] = await client1.test.value.subscribe({});
+        const [subscription1, close1] = await client1.subscribable.value.subscribe({});
         let result = await iterNext(subscription1);
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 0 });
-        const [subscription2, close2] = await client2.test.value.subscribe({});
+        const [subscription2, close2] = await client2.subscribable.value.subscribe({});
         result = await iterNext(subscription2);
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 0 });
-        const add1 = await client1.test.add.rpc({ n: 1 });
+        const add1 = await client1.subscribable.add.rpc({ n: 1 });
         assert(add1.ok);
         result = await iterNext(subscription1);
         assert(result.ok);
@@ -178,7 +179,7 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         result = await iterNext(subscription2);
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 1 });
-        const add2 = await client2.test.add.rpc({ n: 3 });
+        const add2 = await client2.subscribable.add.rpc({ n: 3 });
         assert(add2.ok);
         result = await iterNext(subscription1);
         assert(result.ok);
@@ -196,8 +197,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('upload', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { uploadable: UploadableServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const [addStream, addResult] = await client.uploadable.addMultiple.upload();
         addStream.push({ n: 1 });
@@ -214,8 +215,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('upload with init message', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { uploadable: UploadableServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const [addStream, addResult] = await client.uploadable.addMultipleWithPrefix.upload({
             prefix: 'test',
@@ -234,8 +235,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('message order is preserved in the face of disconnects', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: OrderingServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([OrderingServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const expected = [];
         for (let i = 0; i < 50; i++) {
@@ -262,8 +263,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     const CONCURRENCY = 10;
     test('concurrent rpcs', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: OrderingServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([OrderingServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const promises = [];
         for (let i = 0; i < CONCURRENCY; i++) {
@@ -282,8 +283,8 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
     });
     test('concurrent streams', async () => {
         const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
+        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
+        const server = createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
         const openStreams = [];
         for (let i = 0; i < CONCURRENCY; i++) {

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

@@ -1,9 +1,9 @@
 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 waitFor<T>(cb: () => T | Promise<T>): Promise<T>;
 export declare function ensureTransportQueuesAreEventuallyEmpty(t: Transport<Connection>): Promise<void>;
-export declare function ensureServerIsClean(s: Server<unknown>): Promise<boolean>;
+export declare function ensureServerIsClean(s: Server<unknown>): Promise<void>;
 export declare function testFinishesCleanly({ clientTransports, serverTransport, server, }: Partial<{
     clientTransports: Array<Transport<Connection>>;
     serverTransport: Transport<Connection>;

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

@@ -1 +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"}
+{"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,iBAiBpE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,cAElD;AAED,wBAAsB,uCAAuC,CAC3D,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,iBAczB;AAED,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,iBAO3D;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

@@ -7,20 +7,17 @@ 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.eventDispatcher.numberOfListeners('message'), `transport ${t.clientId} should not have open message handlers after the test`).equal(0);
+    expect(t.eventDispatcher.numberOfListeners('connectionStatus'), `transport ${t.clientId} should not have open connection handlers after the test`).equal(0);
 }
-export async function waitUntil(valueGetter, expected, message) {
-    return vi
-        .waitUntil(() => valueGetter() === expected, waitUntilOptions)
-        .finally(() => {
-        expect(valueGetter(), message).toEqual(expected);
-    });
+export function waitFor(cb) {
+    return vi.waitFor(cb, waitUntilOptions);
 }
 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`);
+    await waitFor(() => expect(t.sendQueue.size, `transport ${t.clientId} should not have any messages waiting to send after the test`).toEqual(0));
+    await waitFor(() => expect(t.sendBuffer.size, `transport ${t.clientId} should not have any un-acked messages after the test`).toEqual(0));
 }
 export async function ensureServerIsClean(s) {
-    return waitUntil(() => s.streams.size, 0, `server should not have any open streams after the test`);
+    return waitFor(() => expect(s.streams.size, `server should not have any open streams after the test`).toEqual(0));
 }
 export async function testFinishesCleanly({ clientTransports, serverTransport, server, }) {
     if (clientTransports) {