@replit/river 0.3.1 → 0.5.0

package/dist/__tests__/bandwidth.bench.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=bandwidth.bench.d.ts.map

package/dist/__tests__/bandwidth.bench.d.ts.map

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

package/dist/__tests__/bandwidth.bench.js

@@ -1,8 +1,8 @@
 import http from 'http';
-import { bench, describe } from 'vitest';
+import { assert, bench, describe } from 'vitest';
 import { createWebSocketServer, createWsTransports, onServerReady, } from '../testUtils';
 import largePayload from './largePayload.json';
-import { TestServiceConstructor } from './integration.test';
+import { TestServiceConstructor } from './fixtures';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import { StupidlyLargeService } from './typescript-stress.test';
@@ -15,6 +15,8 @@ const dummyPayloadSmall = () => ({
     to: 'SERVER',
     serviceName: 'test',
     procedureName: 'test',
+    streamId: 'test',
+    controlFlags: 0,
     payload: {
         msg: 'cool',
     },
@@ -25,6 +27,8 @@ const dummyPayloadLarge = () => ({
     to: 'SERVER',
     serviceName: 'test',
     procedureName: 'test',
+    streamId: 'test',
+    controlFlags: 0,
     payload: largePayload,
 });
 const BENCH_DURATION = 1000;
@@ -53,12 +57,14 @@ describe('simple router level bandwidth', async () => {
     const server = await createServer(serverTransport, serviceDefs);
     const client = createClient(clientTransport);
     bench('rpc (wait for response)', async () => {
-        await client.test.add({ n: 1 });
+        const result = await client.test.add({ n: 1 });
+        assert(result.ok);
     }, { time: BENCH_DURATION });
     const [input, output] = await client.test.echo();
     bench('stream (wait for response)', async () => {
         input.push({ msg: 'abc', ignore: false });
-        await output.next();
+        const result = await output.next();
+        assert(result.value && result.value.ok);
     }, { time: BENCH_DURATION });
     bench('stream', async () => {
         input.push({ msg: 'abc', ignore: false });
@@ -78,6 +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 () => {
-        await client.b.f35({ a: 1 });
+        const result = await client.b.f35({ a: 1 });
+        assert(result.ok);
     }, { time: BENCH_DURATION });
 });

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

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

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

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

package/dist/__tests__/e2e.test.js

@@ -0,0 +1,153 @@
+import { afterAll, assert, describe, expect, test } from 'vitest';
+import { createWebSocketServer, createWsTransports, onServerReady, } from '../testUtils';
+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 { UNCAUGHT_ERROR } from '../router/result';
+describe('client <-> server integration test', async () => {
+    const server = http.createServer();
+    const port = await onServerReady(server);
+    const webSocketServer = await createWebSocketServer(server);
+    afterAll(() => {
+        webSocketServer.clients.forEach((socket) => {
+            socket.close();
+        });
+        server.close();
+    });
+    test('rpc', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const result = await client.test.add({ n: 3 });
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+    });
+    test('fallible rpc', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: FallibleServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const result = await client.test.divide({ a: 10, b: 2 });
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 5 });
+        const result2 = await client.test.divide({ a: 10, b: 0 });
+        assert(!result2.ok);
+        expect(result2.payload).toStrictEqual({
+            code: DIV_BY_ZERO,
+            message: 'Cannot divide by zero',
+            extras: {
+                test: 'abc',
+            },
+        });
+    });
+    test('stream', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [input, output, close] = await client.test.echo();
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await output.next().then((res) => res.value);
+        assert(result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'abc' });
+        const result2 = await output.next().then((res) => res.value);
+        assert(result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'ghi' });
+        close();
+    });
+    test('fallible stream', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: FallibleServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [input, output, close] = await client.test.echo();
+        input.push({ msg: 'abc', throwResult: false, throwError: false });
+        const result1 = await output.next().then((res) => res.value);
+        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);
+        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);
+        assert(result3 && !result3.ok);
+        expect(result3.payload).toStrictEqual({
+            code: UNCAUGHT_ERROR,
+            message: 'some message',
+        });
+        close();
+    });
+    test('message order is preserved in the face of disconnects', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: OrderingServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const expected = [];
+        for (let i = 0; i < 50; i++) {
+            expected.push(i);
+            if (i == 10) {
+                clientTransport.ws?.close();
+            }
+            if (i == 42) {
+                clientTransport.ws?.terminate();
+            }
+            await client.test.add({
+                n: i,
+            });
+        }
+        const res = await client.test.getAll({});
+        assert(res.ok);
+        return expect(res.payload.msgs).toStrictEqual(expected);
+    });
+    const CONCURRENCY = 10;
+    test('concurrent rpcs', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: OrderingServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const promises = [];
+        for (let i = 0; i < CONCURRENCY; i++) {
+            promises.push(client.test.add({ n: i }));
+        }
+        for (let i = 0; i < CONCURRENCY; i++) {
+            const result = await promises[i];
+            assert(result.ok);
+            expect(result.payload).toStrictEqual({ n: i });
+        }
+    });
+    test('concurrent streams', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const openStreams = [];
+        for (let i = 0; i < CONCURRENCY; i++) {
+            const streamHandle = await client.test.echo();
+            const input = streamHandle[0];
+            input.push({ msg: `${i}-1`, ignore: false });
+            input.push({ msg: `${i}-2`, ignore: false });
+            openStreams.push(streamHandle);
+        }
+        for (let i = 0; i < CONCURRENCY; i++) {
+            const output = openStreams[i][1];
+            const result1 = await output.next().then((res) => res.value);
+            assert(result1.ok);
+            expect(result1.payload).toStrictEqual({ response: `${i}-1` });
+            const result2 = await output.next().then((res) => res.value);
+            assert(result2.ok);
+            expect(result2.payload).toStrictEqual({ response: `${i}-2` });
+        }
+        // cleanup
+        for (let i = 0; i < CONCURRENCY; i++) {
+            const [input, _output, close] = openStreams[i];
+            input.end();
+            close();
+        }
+    });
+});

package/dist/__tests__/fixtures.d.ts

@@ -0,0 +1,155 @@
+export declare const EchoRequest: import("@sinclair/typebox").TObject<{
+    msg: import("@sinclair/typebox").TString;
+    ignore: import("@sinclair/typebox").TBoolean;
+}>;
+export declare const EchoResponse: import("@sinclair/typebox").TObject<{
+    response: import("@sinclair/typebox").TString;
+}>;
+export declare const TestServiceConstructor: () => {
+    name: "test";
+    state: {
+        count: 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: number;
+            }>, input: import("../transport/message").TransportMessage<{
+                n: number;
+            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                result: number;
+            }, never>>>;
+            type: "rpc";
+        };
+    } & {
+        echo: {
+            input: import("@sinclair/typebox").TObject<{
+                msg: import("@sinclair/typebox").TString;
+                ignore: import("@sinclair/typebox").TBoolean;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                response: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../router").ServiceContextWithState<{
+                count: number;
+            }>, input: AsyncIterable<import("../transport/message").TransportMessage<{
+                msg: string;
+                ignore: boolean;
+            }>>, output: import("it-pushable").Pushable<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                response: string;
+            }, never>>, void, unknown>) => Promise<void>;
+            type: "stream";
+        };
+    };
+};
+export declare const OrderingServiceConstructor: () => {
+    name: "test";
+    state: {
+        msgs: number[];
+    };
+    procedures: {
+        add: {
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../router").ServiceContextWithState<{
+                msgs: number[];
+            }>, input: import("../transport/message").TransportMessage<{
+                n: number;
+            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                n: number;
+            }, never>>>;
+            type: "rpc";
+        };
+    } & {
+        getAll: {
+            input: import("@sinclair/typebox").TObject<{}>;
+            output: import("@sinclair/typebox").TObject<{
+                msgs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../router").ServiceContextWithState<{
+                msgs: number[];
+            }>, input: import("../transport/message").TransportMessage<{}>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                msgs: number[];
+            }, never>>>;
+            type: "rpc";
+        };
+    };
+};
+export declare const DIV_BY_ZERO = "DIV_BY_ZERO";
+export declare const STREAM_ERROR = "STREAM_ERROR";
+export declare const FallibleServiceConstructor: () => {
+    name: "fallible";
+    state: {};
+    procedures: {
+        divide: {
+            input: import("@sinclair/typebox").TObject<{
+                a: import("@sinclair/typebox").TNumber;
+                b: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TObject<{
+                code: import("@sinclair/typebox").TLiteral<"DIV_BY_ZERO">;
+                message: import("@sinclair/typebox").TString;
+                extras: import("@sinclair/typebox").TObject<{
+                    test: import("@sinclair/typebox").TString;
+                }>;
+            }>;
+            handler: (context: import("../router").ServiceContextWithState<{}>, input: import("../transport/message").TransportMessage<{
+                a: number;
+                b: number;
+            }>) => Promise<import("../transport/message").TransportMessage<import("../router/result").Result<{
+                result: number;
+            }, {
+                message: string;
+                code: "DIV_BY_ZERO";
+                extras: {
+                    test: string;
+                };
+            }>>>;
+            type: "rpc";
+        };
+    } & {
+        echo: {
+            input: import("@sinclair/typebox").TObject<{
+                msg: import("@sinclair/typebox").TString;
+                throwResult: import("@sinclair/typebox").TBoolean;
+                throwError: import("@sinclair/typebox").TBoolean;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                response: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TObject<{
+                code: import("@sinclair/typebox").TLiteral<"STREAM_ERROR">;
+                message: import("@sinclair/typebox").TString;
+            }>;
+            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<{
+                response: string;
+            }, {
+                message: string;
+                code: "STREAM_ERROR";
+            }>>, void, unknown>) => Promise<void>;
+            type: "stream";
+        };
+    };
+};
+//# sourceMappingURL=fixtures.d.ts.map

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

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

package/dist/__tests__/fixtures.js

@@ -0,0 +1,129 @@
+import { Type } from '@sinclair/typebox';
+import { ServiceBuilder } from '../router/builder';
+import { reply } from '../transport/message';
+import { Err, Ok } from '../router/result';
+export const EchoRequest = Type.Object({
+    msg: Type.String(),
+    ignore: Type.Boolean(),
+});
+export const EchoResponse = Type.Object({ response: Type.String() });
+export const TestServiceConstructor = () => ServiceBuilder.create('test')
+    .initialState({
+    count: 0,
+})
+    .defineProcedure('add', {
+    type: 'rpc',
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ result: Type.Number() }),
+    errors: Type.Never(),
+    async handler(ctx, msg) {
+        const { n } = msg.payload;
+        ctx.state.count += n;
+        return reply(msg, Ok({ result: ctx.state.count }));
+    },
+})
+    .defineProcedure('echo', {
+    type: 'stream',
+    input: EchoRequest,
+    output: EchoResponse,
+    errors: Type.Never(),
+    async handler(_ctx, msgStream, returnStream) {
+        for await (const msg of msgStream) {
+            const req = msg.payload;
+            if (!req.ignore) {
+                returnStream.push(reply(msg, Ok({ response: req.msg })));
+            }
+        }
+    },
+})
+    .finalize();
+export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
+    .initialState({
+    msgs: [],
+})
+    .defineProcedure('add', {
+    type: 'rpc',
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ n: Type.Number() }),
+    errors: Type.Never(),
+    async handler(ctx, msg) {
+        const { n } = msg.payload;
+        ctx.state.msgs.push(n);
+        return reply(msg, Ok({ n }));
+    },
+})
+    .defineProcedure('getAll', {
+    type: 'rpc',
+    input: Type.Object({}),
+    output: Type.Object({ msgs: Type.Array(Type.Number()) }),
+    errors: Type.Never(),
+    async handler(ctx, msg) {
+        return reply(msg, Ok({ msgs: ctx.state.msgs }));
+    },
+})
+    .finalize();
+export const DIV_BY_ZERO = 'DIV_BY_ZERO';
+export const STREAM_ERROR = 'STREAM_ERROR';
+export const FallibleServiceConstructor = () => ServiceBuilder.create('fallible')
+    .initialState({})
+    .defineProcedure('divide', {
+    type: 'rpc',
+    input: Type.Object({ a: Type.Number(), b: Type.Number() }),
+    output: Type.Object({ result: Type.Number() }),
+    errors: Type.Union([
+        Type.Object({
+            code: Type.Literal(DIV_BY_ZERO),
+            message: Type.String(),
+            extras: Type.Object({ test: Type.String() }),
+        }),
+    ]),
+    async handler(_ctx, msg) {
+        const { a, b } = msg.payload;
+        if (b === 0) {
+            return reply(msg, {
+                ok: false,
+                payload: {
+                    code: DIV_BY_ZERO,
+                    message: 'Cannot divide by zero',
+                    extras: { test: 'abc' },
+                },
+            });
+        }
+        else {
+            return reply(msg, Ok({ result: a / b }));
+        }
+    },
+})
+    .defineProcedure('echo', {
+    type: 'stream',
+    input: Type.Object({
+        msg: Type.String(),
+        throwResult: Type.Boolean(),
+        throwError: Type.Boolean(),
+    }),
+    output: Type.Object({ response: Type.String() }),
+    errors: Type.Union([
+        Type.Object({
+            code: Type.Literal(STREAM_ERROR),
+            message: Type.String(),
+        }),
+    ]),
+    async handler(_ctx, msgStream, returnStream) {
+        for await (const msg of msgStream) {
+            const req = msg.payload;
+            if (req.throwError) {
+                throw new Error('some message');
+            }
+            else if (req.throwResult) {
+                returnStream.push(reply(msg, Err({
+                    code: STREAM_ERROR,
+                    message: 'field throwResult was set to true',
+                })));
+            }
+            else {
+                returnStream.push(reply(msg, Ok({ response: req.msg })));
+            }
+        }
+    },
+})
+    .finalize();

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

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

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

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

package/dist/__tests__/handler.test.js

@@ -0,0 +1,71 @@
+import { asClientRpc, asClientStream } from '../testUtils';
+import { assert, describe, expect, test } from 'vitest';
+import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, TestServiceConstructor, } from './fixtures';
+import { UNCAUGHT_ERROR } from '../router/result';
+describe('server-side test', () => {
+    const service = TestServiceConstructor();
+    const initialState = { count: 0 };
+    test('rpc basic', async () => {
+        const add = asClientRpc(initialState, service.procedures.add);
+        const result = await add({ n: 3 });
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+    });
+    test('rpc initial state', async () => {
+        const add = asClientRpc({ count: 5 }, service.procedures.add);
+        const result = await add({ n: 6 });
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 11 });
+    });
+    test('fallible rpc', async () => {
+        const service = FallibleServiceConstructor();
+        const divide = asClientRpc({}, service.procedures.divide);
+        const result = await divide({ a: 10, b: 2 });
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 5 });
+        const result2 = await divide({ a: 10, b: 0 });
+        assert(!result2.ok);
+        expect(result2.payload).toStrictEqual({
+            code: DIV_BY_ZERO,
+            message: 'Cannot divide by zero',
+            extras: {
+                test: 'abc',
+            },
+        });
+    });
+    test('stream basic', async () => {
+        const [input, output] = asClientStream(initialState, service.procedures.echo);
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await output.next().then((res) => res.value);
+        assert(result1 && result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'abc' });
+        const result2 = await output.next().then((res) => res.value);
+        assert(result2 && result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'ghi' });
+        expect(output.readableLength).toBe(0);
+    });
+    test('fallible stream', async () => {
+        const service = FallibleServiceConstructor();
+        const [input, output] = asClientStream({}, service.procedures.echo);
+        input.push({ msg: 'abc', throwResult: false, throwError: false });
+        const result1 = await output.next().then((res) => res.value);
+        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);
+        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);
+        assert(result3 && !result3.ok);
+        expect(result3.payload).toStrictEqual({
+            code: UNCAUGHT_ERROR,
+            message: 'some message',
+        });
+        input.end();
+        expect(output.readableLength).toBe(0);
+    });
+});

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

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

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

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