@replit/river 0.5.2 → 0.6.1

package/README.md

@@ -5,4 +5,13 @@ It's like tRPC but...
 - with JSON Schema Support
 - with full-duplex streaming
 - with support for service multiplexing
+- with Result types and error handling
 - over WebSockets
+
+## Developing
+
+- `npm i` -- install dependencies
+- `npm check` -- lint
+- `npm format` -- format
+- `npm test` -- run tests
+- `npm publish` -- cut a new release (should bump version in package.json first)

package/dist/__tests__/e2e.test.js

@@ -3,12 +3,14 @@ import { createWebSocketServer, createWsTransports, onServerReady, } from '../te
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import http from 'http';
-import { DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, TestServiceConstructor, } from './fixtures';
+import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, TestServiceConstructor, } from './fixtures';
 import { UNCAUGHT_ERROR } from '../router/result';
-describe('client <-> server integration test', async () => {
+import { codecs } from '../codec/codec.test';
+describe.each(codecs)('client <-> server integration test ($name codec)', async ({ codec }) => {
     const server = http.createServer();
     const port = await onServerReady(server);
     const webSocketServer = await createWebSocketServer(server);
+    const getTransports = () => createWsTransports(port, webSocketServer, codec);
     afterAll(() => {
         webSocketServer.clients.forEach((socket) => {
             socket.close();
@@ -16,7 +18,7 @@ describe('client <-> server integration test', async () => {
         server.close();
     });
     test('rpc', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -25,7 +27,7 @@ describe('client <-> server integration test', async () => {
         expect(result.payload).toStrictEqual({ result: 3 });
     });
     test('fallible rpc', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: FallibleServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -42,8 +44,18 @@ describe('client <-> server integration test', async () => {
             },
         });
     });
+    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' });
+        assert(result.ok);
+        assert(result.payload.contents instanceof Uint8Array);
+        expect(new TextDecoder().decode(result.payload.contents)).toStrictEqual('contents for file test.py');
+    });
     test('stream', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -61,7 +73,7 @@ describe('client <-> server integration test', async () => {
         close();
     });
     test('fallible stream', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: FallibleServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -84,7 +96,7 @@ describe('client <-> server integration test', async () => {
         close();
     });
     test('message order is preserved in the face of disconnects', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: OrderingServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -107,7 +119,7 @@ describe('client <-> server integration test', async () => {
     });
     const CONCURRENCY = 10;
     test('concurrent rpcs', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: OrderingServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
@@ -122,7 +134,7 @@ describe('client <-> server integration test', async () => {
         }
     });
     test('concurrent streams', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);

package/dist/__tests__/fixtures.d.ts

@@ -89,6 +89,27 @@ export declare const OrderingServiceConstructor: () => {
         };
     };
 };
+export declare const BinaryFileServiceConstructor: () => {
+    name: "bin";
+    state: {};
+    procedures: {
+        getFile: {
+            input: import("@sinclair/typebox").TObject<{
+                file: import("@sinclair/typebox").TString;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                contents: import("@sinclair/typebox").TUint8Array;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../router").ServiceContextWithState<{}>, input: import("../transport/message").TransportMessage<{
+                file: string;
+            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                contents: Uint8Array;
+            }, never>>>;
+            type: "rpc";
+        };
+    };
+};
 export declare const DIV_BY_ZERO = "DIV_BY_ZERO";
 export declare const STREAM_ERROR = "STREAM_ERROR";
 export declare const FallibleServiceConstructor: () => {

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../__tests__/fixtures.ts"],"names":[],"mappings":"AAKA,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,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../__tests__/fixtures.ts"],"names":[],"mappings":"AAKA,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"}

package/dist/__tests__/fixtures.js

@@ -62,6 +62,18 @@ export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
     },
 })
     .finalize();
+export const BinaryFileServiceConstructor = () => ServiceBuilder.create('bin')
+    .defineProcedure('getFile', {
+    type: 'rpc',
+    input: Type.Object({ file: Type.String() }),
+    output: Type.Object({ contents: Type.Uint8Array() }),
+    errors: Type.Never(),
+    async handler(_ctx, msg) {
+        const bytes = new TextEncoder().encode(`contents for file ${msg.payload.file}`);
+        return reply(msg, Ok({ contents: bytes }));
+    },
+})
+    .finalize();
 export const DIV_BY_ZERO = 'DIV_BY_ZERO';
 export const STREAM_ERROR = 'STREAM_ERROR';
 export const FallibleServiceConstructor = () => ServiceBuilder.create('fallible')

package/dist/__tests__/serialize.test.js

@@ -1,6 +1,6 @@
 import { expect, describe, test } from 'vitest';
 import { serializeService } from '../router/builder';
-import { FallibleServiceConstructor, TestServiceConstructor } from './fixtures';
+import { BinaryFileServiceConstructor, FallibleServiceConstructor, TestServiceConstructor, } from './fixtures';
 describe('serialize service to jsonschema', () => {
     test('serialize basic service', () => {
         const service = TestServiceConstructor();
@@ -48,6 +48,39 @@ describe('serialize service to jsonschema', () => {
             },
         });
     });
+    test('serialize service with binary', () => {
+        const service = BinaryFileServiceConstructor();
+        expect(serializeService(service)).toStrictEqual({
+            name: 'bin',
+            procedures: {
+                getFile: {
+                    errors: {
+                        not: {},
+                    },
+                    input: {
+                        properties: {
+                            file: {
+                                type: 'string',
+                            },
+                        },
+                        required: ['file'],
+                        type: 'object',
+                    },
+                    output: {
+                        properties: {
+                            contents: {
+                                type: 'Uint8Array',
+                            },
+                        },
+                        required: ['contents'],
+                        type: 'object',
+                    },
+                    type: 'rpc',
+                },
+            },
+            state: {},
+        });
+    });
     test('serialize service with errors', () => {
         const service = FallibleServiceConstructor();
         expect(serializeService(service)).toStrictEqual({

package/dist/codec/binary.d.ts

@@ -0,0 +1,7 @@
+import { Codec } from './types';
+/**
+ * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
+ * @type {Codec}
+ */
+export declare const BinaryCodec: Codec;
+//# sourceMappingURL=binary.d.ts.map

package/dist/codec/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../codec/binary.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,KAczB,CAAC"}

package/dist/codec/binary.js

@@ -0,0 +1,20 @@
+import { decode, encode } from '@msgpack/msgpack';
+/**
+ * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
+ * @type {Codec}
+ */
+export const BinaryCodec = {
+    toBuffer: encode,
+    fromBuffer: (buff) => {
+        try {
+            const res = decode(buff);
+            if (typeof res !== 'object') {
+                return null;
+            }
+            return res;
+        }
+        catch {
+            return null;
+        }
+    },
+};

package/dist/codec/codec.test.d.ts

@@ -1,2 +1,5 @@
-export {};
+export declare const codecs: {
+    name: string;
+    codec: import("./types").Codec;
+}[];
 //# sourceMappingURL=codec.test.d.ts.map

package/dist/codec/codec.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codec.test.d.ts","sourceRoot":"","sources":["../../codec/codec.test.ts"],"names":[],"mappings":""}
+{"version":3,"file":"codec.test.d.ts","sourceRoot":"","sources":["../../codec/codec.test.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;GAGlB,CAAC"}

package/dist/codec/codec.test.js

@@ -1,13 +1,18 @@
+import { BinaryCodec } from './binary';
 import { NaiveJsonCodec } from './json';
 import { describe, test, expect } from 'vitest';
-describe('naive json codec', () => {
+export const codecs = [
+    { name: 'naive', codec: NaiveJsonCodec },
+    { name: 'binary', codec: BinaryCodec },
+];
+describe.each(codecs)('codec -- $name', ({ codec }) => {
     test('empty object', () => {
         const msg = {};
-        expect(NaiveJsonCodec.fromStringBuf(NaiveJsonCodec.toStringBuf(msg))).toStrictEqual(msg);
+        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
     });
     test('simple test', () => {
         const msg = { abc: 123, def: 'cool' };
-        expect(NaiveJsonCodec.fromStringBuf(NaiveJsonCodec.toStringBuf(msg))).toStrictEqual(msg);
+        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
     });
     test('deeply nested test', () => {
         const msg = {
@@ -18,12 +23,19 @@ describe('naive json codec', () => {
                 },
             },
         };
-        expect(NaiveJsonCodec.fromStringBuf(NaiveJsonCodec.toStringBuf(msg))).toStrictEqual(msg);
+        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
+    });
+    test('buffer test', () => {
+        const msg = {
+            buff: Uint8Array.from([0, 42, 100, 255]),
+        };
+        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
     });
     test('invalid json returns null', () => {
-        expect(NaiveJsonCodec.fromStringBuf('')).toBeNull();
-        expect(NaiveJsonCodec.fromStringBuf('[')).toBeNull();
-        expect(NaiveJsonCodec.fromStringBuf('[{}')).toBeNull();
-        expect(NaiveJsonCodec.fromStringBuf('{"a":1}[]')).toBeNull();
+        const encoder = new TextEncoder();
+        expect(codec.fromBuffer(encoder.encode(''))).toBeNull();
+        expect(codec.fromBuffer(encoder.encode('['))).toBeNull();
+        expect(codec.fromBuffer(encoder.encode('[{}'))).toBeNull();
+        expect(codec.fromBuffer(encoder.encode('{"a":1}[]'))).toBeNull();
     });
 });

package/dist/codec/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../codec/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,KAS5B,CAAC"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../codec/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAwBhC;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,KA0B5B,CAAC"}

package/dist/codec/json.js

@@ -1,12 +1,48 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+// Convert Uint8Array to base64
+function uint8ArrayToBase64(uint8Array) {
+    let binary = '';
+    uint8Array.forEach((byte) => {
+        binary += String.fromCharCode(byte);
+    });
+    return btoa(binary);
+}
+// Convert base64 to Uint8Array
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const uint8Array = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        uint8Array[i] = binaryString.charCodeAt(i);
+    }
+    return uint8Array;
+}
 /**
  * Naive JSON codec implementation using JSON.stringify and JSON.parse.
  * @type {Codec}
  */
 export const NaiveJsonCodec = {
-    toStringBuf: JSON.stringify,
-    fromStringBuf: (s) => {
+    toBuffer: (obj) => {
+        return encoder.encode(JSON.stringify(obj, function replacer(key) {
+            let val = this[key];
+            if (val instanceof Uint8Array) {
+                return { $t: uint8ArrayToBase64(val) };
+            }
+            else {
+                return val;
+            }
+        }));
+    },
+    fromBuffer: (buff) => {
         try {
-            return JSON.parse(s);
+            return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
+                if (val?.$t) {
+                    return base64ToUint8Array(val.$t);
+                }
+                else {
+                    return val;
+                }
+            });
         }
         catch {
             return null;

package/dist/codec/types.d.ts

@@ -1,19 +1,19 @@
 /**
- * Codec interface for encoding and decoding objects to and from string buffers.
+ * Codec interface for encoding and decoding objects to and from Uint8 buffers.
  * Used to prepare messages for use by the transport layer.
  */
 export interface Codec {
     /**
-     * Encodes an object to a string buffer.
+     * Encodes an object to a Uint8 buffer.
      * @param obj - The object to encode.
-     * @returns The encoded string buffer.
+     * @returns The encoded Uint8 buffer.
      */
-    toStringBuf(obj: object): string;
+    toBuffer(obj: object): Uint8Array;
     /**
-     * Decodes an object from a string buffer.
-     * @param buf - The string buffer to decode.
+     * Decodes an object from a Uint8 buffer.
+     * @param buf - The Uint8 buffer to decode.
      * @returns The decoded object, or null if decoding failed.
      */
-    fromStringBuf(buf: string): object | null;
+    fromBuffer(buf: Uint8Array): object | null;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/codec/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../codec/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC;;;;OAIG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CAC3C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../codec/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;CAC5C"}

package/dist/router/client.js

@@ -39,9 +39,9 @@ export const createClient = (transport) => _createRecursiveProxy(async (opts) =>
     const [input] = opts.args;
     const streamId = nanoid();
     function belongsToSameStream(msg) {
-        return (msg.streamId === streamId &&
-            msg.serviceName === serviceName &&
-            msg.procedureName === procName);
+        return (msg.serviceName === serviceName &&
+            msg.procedureName === procName &&
+            (msg.streamId === streamId || msg.streamId === 'global'));
     }
     if (input === undefined) {
         // stream case (stream methods are called with zero arguments)

package/dist/testUtils.d.ts

@@ -8,6 +8,7 @@ import { Procedure, ServiceContext } from './router';
 import { OpaqueTransportMessage, TransportMessage } from './transport';
 import { Pushable } from 'it-pushable';
 import { Result, RiverError, RiverUncaughtSchema } from './router/result';
+import { Codec } from './codec';
 /**
  * Creates a WebSocket server instance using the provided HTTP server.
  * Only used as helper for testing.
@@ -36,7 +37,7 @@ export declare function createLocalWebSocketClient(port: number): Promise<WebSoc
  * @param wss - The WebSocketServer instance to use for the server transport.
  * @returns An array containing the client and server {@link WebSocketTransport} instances.
  */
-export declare function createWsTransports(port: number, wss: WebSocketServer): [WebSocketTransport, WebSocketTransport];
+export declare function createWsTransports(port: number, wss: WebSocketServer, codec?: Codec): [WebSocketTransport, WebSocketTransport];
 /**
  * Transforms an RPC procedure definition into a normal function call.
  * This should only be used for testing.

package/dist/testUtils.d.ts.map

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

package/dist/testUtils.js

@@ -48,11 +48,12 @@ export async function createLocalWebSocketClient(port) {
  * @param wss - The WebSocketServer instance to use for the server transport.
  * @returns An array containing the client and server {@link WebSocketTransport} instances.
  */
-export function createWsTransports(port, wss) {
+export function createWsTransports(port, wss, codec) {
+    const options = codec ? { codec } : undefined;
     return [
         new WebSocketTransport(async () => {
             return createLocalWebSocketClient(port);
-        }, 'client'),
+        }, 'client', options),
         new WebSocketTransport(async () => {
             return new Promise((resolve) => {
                 wss.on('connection', async function onConnect(serverSock) {
@@ -60,7 +61,7 @@ export function createWsTransports(port, wss) {
                     resolve(serverSock);
                 });
             });
-        }, 'SERVER'),
+        }, 'SERVER', options),
     ];
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../transport/impls/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGrC,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAE9B;;;;;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;IAapC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,MAAM;IAMzC;;OAEG;IACG,KAAK;CACZ"}
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../transport/impls/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGrC,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAQD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAE9B;;;;;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;IAcpC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,MAAM;IAWzC;;OAEG;IACG,KAAK;CACZ"}

package/dist/transport/impls/stdio.js

@@ -4,6 +4,7 @@ import readline from 'readline';
 const defaultOptions = {
     codec: NaiveJsonCodec,
 };
+const newlineBuff = new TextEncoder().encode('\n');
 /**
  * A transport implementation that uses standard input and output streams.
  * @extends Transport
@@ -31,7 +32,8 @@ export class StdioTransport extends Transport {
         const rl = readline.createInterface({
             input: this.input,
         });
-        rl.on('line', (msg) => this.onMessage(msg));
+        const encoder = new TextEncoder();
+        rl.on('line', (msg) => this.onMessage(encoder.encode(msg)));
     }
     /**
      * Sends a message over the transport.
@@ -40,7 +42,11 @@ export class StdioTransport extends Transport {
      */
     send(msg) {
         const id = msg.id;
-        this.output.write(this.codec.toStringBuf(msg) + '\n');
+        const payload = this.codec.toBuffer(msg);
+        const out = new Uint8Array(payload.length + newlineBuff.length);
+        out.set(payload, 0);
+        out.set(newlineBuff, payload.length);
+        this.output.write(out);
         return id;
     }
     /**

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

@@ -6,6 +6,7 @@ import { type Codec } from '../../codec';
 interface Options {
     retryIntervalMs: number;
     codec: Codec;
+    binaryType: 'arraybuffer' | 'blob';
 }
 type WebSocketResult = {
     ws: WebSocket;

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

@@ -1 +1 @@
-{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../../transport/impls/ws.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EACL,SAAS,EACT,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;CACd;AAOD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC;IACnC,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAE5C;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAE5B;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC;;OAEG;YACW,UAAU;IAkExB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IAyB5C;;OAEG;IACG,KAAK;CAKZ"}
+{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../../transport/impls/ws.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EACL,SAAS,EACT,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,aAAa,GAAG,MAAM,CAAC;CACpC;AAQD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC;IACnC,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAE5C;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAE5B;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC;;OAEG;YACW,UAAU;IAmExB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IAyB5C;;OAEG;IACG,KAAK;CAKZ"}

package/dist/transport/impls/ws.js

@@ -4,6 +4,7 @@ import { log } from '../../logging';
 const defaultOptions = {
     retryIntervalMs: 250,
     codec: NaiveJsonCodec,
+    binaryType: 'arraybuffer',
 };
 /**
  * A transport implementation that uses a WebSocket connection with automatic reconnection.
@@ -79,7 +80,8 @@ export class WebSocketTransport extends Transport {
         if ('ws' in res && res.ws.readyState === res.ws.OPEN) {
             log?.info(`${this.clientId} -- websocket ok`);
             this.ws = res.ws;
-            this.ws.onmessage = (msg) => this.onMessage(msg.data.toString());
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.onmessage = (msg) => this.onMessage(msg.data);
             this.ws.onclose = () => {
                 this.reconnectPromise = undefined;
                 this.tryConnect().catch();
@@ -93,7 +95,7 @@ export class WebSocketTransport extends Transport {
                     throw new Error(err);
                 }
                 log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-                this.ws.send(this.codec.toStringBuf(msg));
+                this.ws.send(this.codec.toBuffer(msg));
             }
             this.sendQueue = [];
             return;
@@ -119,7 +121,7 @@ export class WebSocketTransport extends Transport {
         this.sendBuffer.set(id, msg);
         if (this.ws && this.ws.readyState === this.ws.OPEN) {
             log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-            this.ws.send(this.codec.toStringBuf(msg));
+            this.ws.send(this.codec.toBuffer(msg));
         }
         else {
             log?.info(`${this.clientId} -- transport not ready, queuing ${JSON.stringify(msg)}`);

package/dist/transport/types.d.ts

@@ -33,7 +33,7 @@ export declare abstract class Transport {
      * You generally shouldn't need to override this in downstream transport implementations.
      * @param msg The received message.
      */
-    onMessage(msg: string): void;
+    onMessage(msg: Uint8Array): void;
     /**
      * Adds a message listener to this transport.
      * @param handler The message handler to add.

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../transport/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAEL,SAAS,EACT,sBAAsB,EAGtB,iBAAiB,EAGlB,MAAM,WAAW,CAAC;AAGnB;;;;GAIG;AACH,8BAAsB,SAAS;IAC7B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC,CAAC;IAGrD;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAEnD;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB;IAOrD;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM;IAuCrB;;;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,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IACrD,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAChC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../transport/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAEL,SAAS,EACT,sBAAsB,EAGtB,iBAAiB,EAGlB,MAAM,WAAW,CAAC;AAGnB;;;;GAIG;AACH,8BAAsB,SAAS;IAC7B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC,CAAC;IAGrD;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAEnD;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB;IAOrD;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU;IAuCzB;;;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,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IACrD,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAChC"}

package/dist/transport/types.js

@@ -41,7 +41,7 @@ export class Transport {
      * @param msg The received message.
      */
     onMessage(msg) {
-        const parsedMsg = this.codec.fromStringBuf(msg);
+        const parsedMsg = this.codec.fromBuffer(msg);
         if (parsedMsg === null) {
             log?.warn(`${this.clientId} -- received malformed msg: ${msg}`);
             return;

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.5.2",
+  "version": "0.6.1",
   "type": "module",
   "exports": {
     ".": "./dist/router/index.js",
@@ -17,6 +17,7 @@
     "dist"
   ],
   "dependencies": {
+    "@msgpack/msgpack": "^3.0.0-beta2",
     "@sinclair/typebox": "^0.31.8",
     "isomorphic-ws": "^5.0.0",
     "it-pushable": "^3.2.1",