@replit/river 0.7.2 → 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,8 +1,8 @@
 import http from 'http';
 import { assert, bench, describe } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady, } from '../testUtils';
-import largePayload from './largePayload.json';
-import { TestServiceConstructor } from './fixtures';
+import { createWebSocketServer, createWsTransports, onServerReady, } 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';
@@ -57,10 +57,10 @@ describe('simple router level bandwidth', async () => {
     const server = await createServer(serverTransport, serviceDefs);
     const client = createClient(clientTransport);
     bench('rpc (wait for response)', async () => {
-        const result = await client.test.add({ n: 1 });
+        const result = await client.test.add.rpc({ n: 1 });
         assert(result.ok);
     }, { time: BENCH_DURATION });
-    const [input, output] = await client.test.echo();
+    const [input, output] = await client.test.echo.stream();
     bench('stream (wait for response)', async () => {
         input.push({ msg: 'abc', ignore: false });
         const result = await output.next();
@@ -84,7 +84,7 @@ describe('complex (50 procedures) router level bandwidth', async () => {
     const server = await createServer(serverTransport, serviceDefs);
     const client = createClient(clientTransport);
     bench('rpc (wait for response)', async () => {
-        const result = await client.b.f35({ a: 1 });
+        const result = await client.b.f35.rpc({ a: 1 });
         assert(result.ok);
     }, { time: BENCH_DURATION });
 });

package/dist/__tests__/e2e.test.js

@@ -1,20 +1,21 @@
 import { afterAll, assert, describe, expect, test } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady, } from '../testUtils';
+import { createLocalWebSocketClient, createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import http from 'http';
-import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, TestServiceConstructor, } from './fixtures';
+import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
 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 () => {
@@ -22,19 +23,24 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const result = await client.test.add({ n: 3 });
+        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();
         const serviceDefs = { test: FallibleServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const result = await client.test.divide({ a: 10, b: 2 });
+        const result = await client.test.divide.rpc({ a: 10, b: 2 });
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 5 });
-        const result2 = await client.test.divide({ a: 10, b: 0 });
+        const result2 = await client.test.divide.rpc({ a: 10, b: 0 });
         assert(!result2.ok);
         expect(result2.payload).toStrictEqual({
             code: DIV_BY_ZERO,
@@ -43,57 +49,125 @@ 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();
         const serviceDefs = { test: BinaryFileServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const result = await client.test.getFile({ file: 'test.py' });
+        const result = await client.test.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');
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const [input, output, close] = await client.test.echo();
+        const [input, output, close] = await client.test.echo.stream();
         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 output.next().then((res) => res.value);
+        const result1 = await iterNext(output);
         assert(result1.ok);
         expect(result1.payload).toStrictEqual({ response: 'abc' });
-        const result2 = await output.next().then((res) => res.value);
+        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();
         const serviceDefs = { test: FallibleServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        const [input, output, close] = await client.test.echo();
+        const [input, output, close] = await client.test.echo.stream();
         input.push({ msg: 'abc', throwResult: false, throwError: false });
-        const result1 = await output.next().then((res) => res.value);
+        const result1 = await iterNext(output);
         assert(result1 && result1.ok);
         expect(result1.payload).toStrictEqual({ response: 'abc' });
         input.push({ msg: 'def', throwResult: true, throwError: false });
-        const result2 = await output.next().then((res) => res.value);
+        const result2 = await iterNext(output);
         assert(result2 && !result2.ok);
         expect(result2.payload.code).toStrictEqual(STREAM_ERROR);
         input.push({ msg: 'ghi', throwResult: false, throwError: true });
-        const result3 = await output.next().then((res) => res.value);
+        const result3 = await iterNext(output);
         assert(result3 && !result3.ok);
         expect(result3.payload).toStrictEqual({
             code: UNCAUGHT_ERROR,
             message: 'some message',
         });
         close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
+    test('subscription', async () => {
+        const options = { codec };
+        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 client1 = createClient(client1Transport);
+        const client2 = createClient(client2Transport);
+        const [subscription1, close1] = await client1.test.value.subscribe({});
+        let result = await iterNext(subscription1);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        const [subscription2, close2] = await client2.test.value.subscribe({});
+        result = await iterNext(subscription2);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        const add1 = await client1.test.add.rpc({ n: 1 });
+        assert(add1.ok);
+        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 });
+        const add2 = await client2.test.add.rpc({ n: 3 });
+        assert(add2.ok);
+        result = await iterNext(subscription1);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 4 });
+        result = await iterNext(subscription2);
+        assert(result.ok);
+        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();
@@ -109,13 +183,18 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             if (i == 42) {
                 clientTransport.connections.forEach((conn) => conn.ws.terminate());
             }
-            await client.test.add({
+            await client.test.add.rpc({
                 n: i,
             });
         }
-        const res = await client.test.getAll({});
+        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 () => {
@@ -125,13 +204,18 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const client = createClient(clientTransport);
         const promises = [];
         for (let i = 0; i < CONCURRENCY; i++) {
-            promises.push(client.test.add({ n: i }));
+            promises.push(client.test.add.rpc({ n: i }));
         }
         for (let i = 0; i < CONCURRENCY; i++) {
             const result = await promises[i];
             assert(result.ok);
             expect(result.payload).toStrictEqual({ n: i });
         }
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('concurrent streams', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -140,7 +224,7 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const client = createClient(clientTransport);
         const openStreams = [];
         for (let i = 0; i < CONCURRENCY; i++) {
-            const streamHandle = await client.test.echo();
+            const streamHandle = await client.test.echo.stream();
             const input = streamHandle[0];
             input.push({ msg: `${i}-1`, ignore: false });
             input.push({ msg: `${i}-2`, ignore: false });
@@ -148,10 +232,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         }
         for (let i = 0; i < CONCURRENCY; i++) {
             const output = openStreams[i][1];
-            const result1 = await output.next().then((res) => res.value);
+            const result1 = await iterNext(output);
             assert(result1.ok);
             expect(result1.payload).toStrictEqual({ response: `${i}-1` });
-            const result2 = await output.next().then((res) => res.value);
+            const result2 = await iterNext(output);
             assert(result2.ok);
             expect(result2.payload).toStrictEqual({ response: `${i}-2` });
         }
@@ -160,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/observable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Represents an observable value that can be subscribed to for changes.
+ * This should only be used in tests
+ * @template T - The type of the value being observed.
+ */
+export declare class Observable<T> {
+    value: T;
+    private listeners;
+    constructor(initialValue: T);
+    /**
+     * Gets the current value of the observable.
+     */
+    get(): T;
+    /**
+     * Sets the current value of the observable. All listeners will get an update with this value.
+     * @param newValue - The new value to set.
+     */
+    set(tx: (preValue: T) => T): void;
+    /**
+     * Subscribes to changes in the observable value.
+     * @param listener - A callback function that will be called when the value changes.
+     * @returns A function that can be called to unsubscribe from further notifications.
+     */
+    observe(listener: (val: T) => void): () => boolean;
+}
+//# sourceMappingURL=observable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/observable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,UAAU,CAAC,CAAC;IACvB,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,CAAC,SAAS,CAAwB;gBAE7B,YAAY,EAAE,CAAC;IAK3B;;OAEG;IACH,GAAG;IAIH;;;OAGG;IACH,GAAG,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC;IAM1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI;CAKnC"}

package/dist/__tests__/fixtures/observable.js

@@ -0,0 +1,38 @@
+/**
+ * Represents an observable value that can be subscribed to for changes.
+ * This should only be used in tests
+ * @template T - The type of the value being observed.
+ */
+export class Observable {
+    value;
+    listeners;
+    constructor(initialValue) {
+        this.value = initialValue;
+        this.listeners = new Set();
+    }
+    /**
+     * Gets the current value of the observable.
+     */
+    get() {
+        return this.value;
+    }
+    /**
+     * Sets the current value of the observable. All listeners will get an update with this value.
+     * @param newValue - The new value to set.
+     */
+    set(tx) {
+        const newValue = tx(this.value);
+        this.value = newValue;
+        this.listeners.forEach((listener) => listener(newValue));
+    }
+    /**
+     * Subscribes to changes in the observable value.
+     * @param listener - A callback function that will be called when the value changes.
+     * @returns A function that can be called to unsubscribe from further notifications.
+     */
+    observe(listener) {
+        this.listeners.add(listener);
+        listener(this.get());
+        return () => this.listeners.delete(listener);
+    }
+}

package/dist/__tests__/fixtures/observable.test.d.ts

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

package/dist/__tests__/fixtures/observable.test.d.ts.map

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

package/dist/__tests__/fixtures/observable.test.js

@@ -0,0 +1,39 @@
+import { Observable } from './observable';
+import { describe, expect, test, vitest } from 'vitest';
+describe('Observable', () => {
+    test('should set initial value correctly', () => {
+        const initialValue = 10;
+        const observable = new Observable(initialValue);
+        expect(observable.value).toBe(initialValue);
+    });
+    test('should update value correctly', () => {
+        const observable = new Observable(10);
+        const newValue = 20;
+        observable.set(() => newValue);
+        expect(observable.value).toBe(newValue);
+    });
+    test('should notify listeners when value changes', () => {
+        const observable = new Observable(10);
+        const listener = vitest.fn();
+        observable.observe(listener);
+        expect(listener).toHaveBeenCalledTimes(1);
+        const newValue = 20;
+        observable.set(() => newValue);
+        expect(listener).toHaveBeenCalledTimes(2);
+        expect(listener).toHaveBeenCalledWith(newValue);
+    });
+    test('should unsubscribe from notifications', () => {
+        const observable = new Observable(10);
+        const listener = vitest.fn();
+        const unsubscribe = observable.observe(listener);
+        expect(listener).toHaveBeenCalledTimes(1);
+        const newValue = 20;
+        observable.set(() => newValue);
+        expect(listener).toHaveBeenCalledTimes(2);
+        expect(listener).toHaveBeenCalledWith(newValue);
+        unsubscribe();
+        const anotherValue = 30;
+        observable.set(() => anotherValue);
+        expect(listener).toHaveBeenCalledTimes(2); // should not be called again after unsubscribing
+    });
+});

package/dist/__tests__/{fixtures.d.ts → fixtures/services.d.ts}

@@ -1,6 +1,8 @@
+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;
@@ -19,11 +21,11 @@ export declare const TestServiceConstructor: () => {
                 result: import("@sinclair/typebox").TNumber;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../router").ServiceContextWithState<{
+            handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
-            }>, input: import("../transport/message").TransportMessage<{
+            }>, input: import("../../transport/message").TransportMessage<{
                 n: number;
-            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 result: number;
             }, never>>>;
             type: "rpc";
@@ -33,17 +35,19 @@ 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;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../router").ServiceContextWithState<{
+            handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
-            }>, input: AsyncIterable<import("../transport/message").TransportMessage<{
+            }>, 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<{
+            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 response: string;
             }, never>>, void, unknown>) => Promise<void>;
             type: "stream";
@@ -64,11 +68,11 @@ export declare const OrderingServiceConstructor: () => {
                 n: import("@sinclair/typebox").TNumber;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../router").ServiceContextWithState<{
+            handler: (context: import("../../router").ServiceContextWithState<{
                 msgs: number[];
-            }>, input: import("../transport/message").TransportMessage<{
+            }>, input: import("../../transport/message").TransportMessage<{
                 n: number;
-            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 n: number;
             }, never>>>;
             type: "rpc";
@@ -80,9 +84,9 @@ export declare const OrderingServiceConstructor: () => {
                 msgs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../router").ServiceContextWithState<{
+            handler: (context: import("../../router").ServiceContextWithState<{
                 msgs: number[];
-            }>, input: import("../transport/message").TransportMessage<{}>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>, input: import("../../transport/message").TransportMessage<{}>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 msgs: number[];
             }, never>>>;
             type: "rpc";
@@ -101,9 +105,9 @@ export declare const BinaryFileServiceConstructor: () => {
                 contents: import("@sinclair/typebox").TUint8Array;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../router").ServiceContextWithState<{}>, input: import("../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: import("../../transport/message").TransportMessage<{
                 file: string;
-            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 contents: Uint8Array;
             }, never>>>;
             type: "rpc";
@@ -131,10 +135,10 @@ export declare const FallibleServiceConstructor: () => {
                     test: import("@sinclair/typebox").TString;
                 }>;
             }>;
-            handler: (context: import("../router").ServiceContextWithState<{}>, input: import("../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: import("../../transport/message").TransportMessage<{
                 a: number;
                 b: number;
-            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 result: number;
             }, {
                 message: string;
@@ -159,11 +163,11 @@ export declare const FallibleServiceConstructor: () => {
                 code: import("@sinclair/typebox").TLiteral<"STREAM_ERROR">;
                 message: import("@sinclair/typebox").TString;
             }>;
-            handler: (context: import("../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
                 msg: string;
                 throwResult: boolean;
                 throwError: boolean;
-            }>>, output: import("it-pushable").Pushable<import("../transport/message").TransportMessage<import("../router/result").Result<{
+            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
                 response: string;
             }, {
                 message: string;
@@ -173,4 +177,43 @@ export declare const FallibleServiceConstructor: () => {
         };
     };
 };
-//# sourceMappingURL=fixtures.d.ts.map
+export declare const SubscribableServiceConstructor: () => {
+    name: "subscribable";
+    state: {
+        count: Observable<number>;
+    };
+    procedures: {
+        add: {
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{
+                count: Observable<number>;
+            }>, input: import("../../transport/message").TransportMessage<{
+                n: number;
+            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: number;
+            }, never>>>;
+            type: "rpc";
+        };
+    } & {
+        value: {
+            input: import("@sinclair/typebox").TObject<{}>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{
+                count: Observable<number>;
+            }>, input: import("../../transport/message").TransportMessage<{}>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: number;
+            }, never>>, void, unknown>) => Promise<void>;
+            type: "subscription";
+        };
+    };
+};
+//# sourceMappingURL=services.d.ts.map

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

@@ -0,0 +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;;;;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"}