@quantform/core 0.7.0-beta.32 → 0.7.0-beta.34

package/dist/replay/use-replay-storage.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const make_test_module_1 = require("../make-test-module");
+const storage_1 = require("../storage");
+const use_replay_storage_1 = require("./use-replay-storage");
+jest.mock('@lib/storage', () => (Object.assign(Object.assign({}, jest.requireActual('@lib/storage')), { useStorage: jest.fn() })));
+describe(use_replay_storage_1.useReplayStorage.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    describe('query', () => {
+        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fixtures.given.stored(fixtures.sample);
+            const sample = yield fixtures.when.queried({});
+            expect(sample).toEqual(fixtures.sample);
+        }));
+    });
+    describe('save', () => {
+        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fixtures.when.saved(fixtures.sample);
+            yield fixtures.then.stored(fixtures.sample);
+        }));
+    });
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
+        const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+        const save = jest.fn();
+        const query = jest.fn();
+        (0, make_test_module_1.mockedFunc)(storage_1.useStorage).mockReturnValue({ save, query });
+        return {
+            sample: [
+                { timestamp: 1, payload: { o: 1.1, h: 1.1, l: 1.1, c: 1.1 } },
+                { timestamp: 2, payload: { o: 1.1, h: 2.2, l: 1.1, c: 2.2 } },
+                { timestamp: 3, payload: { o: 1.1, h: 3.3, l: 1.1, c: 3.3 } }
+            ],
+            given: {
+                stored(sample) {
+                    return query.mockReturnValue(Promise.resolve(sample.map(it => ({
+                        timestamp: it.timestamp,
+                        payload: JSON.stringify(it.payload)
+                    }))));
+                }
+            },
+            when: {
+                saved(sample) {
+                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).save(sample));
+                },
+                queried(query) {
+                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).query(query));
+                }
+            },
+            then: {
+                stored(sample) {
+                    expect(save).toHaveBeenCalledWith(expect.anything(), sample.map(it => ({
+                        timestamp: it.timestamp,
+                        payload: JSON.stringify(it.payload)
+                    })));
+                }
+            }
+        };
+    });
+}

package/dist/replay/use-replay.d.ts

@@ -1,9 +1,9 @@
 import { Observable } from 'rxjs';
 import { dependency } from '../use-hash';
-export declare const useReplay: <T>(input: Observable<{
+export declare function useReplay<T>(input: Observable<{
     timestamp: number;
     payload: T;
-}>, dependencies: dependency[]) => Observable<{
+}>, dependencies: dependency[]): Observable<{
     timestamp: number;
     payload: T;
 }>;

package/dist/replay/use-replay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-replay.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,UAAU,EAAE,MAAM,MAAM,CAAC;AAIlD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,eAAO,MAAM,SAAS;eACW,MAAM;;kBACvB,UAAU,EAAE;eADK,MAAM;;EAwBtC,CAAC"}
+{"version":3,"file":"use-replay.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAO,MAAM,MAAM,CAAC;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,EACpD,YAAY,EAAE,UAAU,EAAE;eADK,MAAM;aAAW,CAAC;GAkBlD"}

package/dist/replay/use-replay.js

@@ -1,32 +1,20 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplay = void 0;
 const rxjs_1 = require("rxjs");
-const use_replay_coordinator_1 = require("../replay/use-replay-coordinator");
 const use_execution_mode_1 = require("../use-execution-mode");
-const use_replay_writer_1 = require("./use-replay-writer");
-const useReplay = (input, dependencies) => {
+const use_replay_manager_1 = require("./use-replay-manager");
+const use_replay_storage_1 = require("./use-replay-storage");
+function useReplay(input, dependencies) {
     const { isReplay, recording } = (0, use_execution_mode_1.useExecutionMode)();
     if (isReplay) {
-        const { subscribe } = (0, use_replay_coordinator_1.useReplayCoordinator)();
-        return subscribe(dependencies).pipe((0, rxjs_1.map)(it => it));
+        const { when } = (0, use_replay_manager_1.useReplayManager)();
+        return when(dependencies);
     }
     if (recording) {
-        const writer = (0, use_replay_writer_1.useReplayWriter)(dependencies);
-        return input.pipe((0, rxjs_1.concatMap)((it) => __awaiter(void 0, void 0, void 0, function* () {
-            yield writer([it]);
-            return it;
-        })));
+        const { save } = (0, use_replay_storage_1.useReplayStorage)(dependencies);
+        return input.pipe((0, rxjs_1.tap)(it => save([it])));
     }
     return input;
-};
+}
 exports.useReplay = useReplay;

package/dist/replay/use-replay.spec.js

@@ -1,106 +1,130 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const rxjs_1 = require("rxjs");
-const make_test_module_1 = require("../make-test-module");
-const use_replay_coordinator_1 = require("../replay/use-replay-coordinator");
-const use_execution_mode_1 = require("../use-execution-mode");
-const __1 = require("..");
 const use_replay_1 = require("./use-replay");
-const use_replay_options_1 = require("./use-replay-options");
-const use_replay_reader_1 = require("./use-replay-reader");
-const use_replay_writer_1 = require("./use-replay-writer");
-describe.skip(use_replay_coordinator_1.useReplayCoordinator.name, () => {
-    let fixtures;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures = yield getFixtures();
-    }));
-    test('return single data stream for single data source', () => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures.givenRecordingEnabled(false);
-        yield fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
-        const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample']);
-        yield fixtures.whenUseSampleStreamerStarted();
-        expect(yield sample1).toEqual(fixtures.sample1);
-    }));
-    test('return combined data stream for multiple data sources', () => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures.givenRecordingEnabled(false);
-        yield fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
-        yield fixtures.givenSampleStored(fixtures.sample2, ['sample2']);
-        const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1']);
-        const sample2 = fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2']);
-        yield fixtures.whenUseSampleStreamerStarted();
-        expect(yield sample1).toEqual(fixtures.sample1);
-        expect(yield sample2).toEqual(fixtures.sample2);
-    }));
-    test('record and write data stream into storage', () => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures.givenRecordingEnabled(true);
-        const sample1 = yield fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1x']);
-        const sample2 = yield fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2x']);
-        fixtures.thenReplaySampleStored(sample1, ['sample1x']);
-        fixtures.thenReplaySampleStored(sample2, ['sample2x']);
-    }));
-});
-function getFixtures() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const executionMode = (0, use_execution_mode_1.replayExecutionMode)();
-        const { act } = yield (0, make_test_module_1.makeTestModule)([
-            executionMode,
-            (0, use_replay_options_1.replayOptions)({ from: 0, to: Number.MAX_VALUE })
-        ]);
-        return {
-            sample1: [
-                { timestamp: 1, payload: { o: 111, h: 112, l: 113, c: 114 } },
-                { timestamp: 2, payload: { o: 121, h: 122, l: 123, c: 124 } },
-                { timestamp: 3, payload: { o: 131, h: 132, l: 133, c: 134 } }
-            ],
-            sample2: [
-                { timestamp: 1, payload: { o: 211, h: 212, l: 213, c: 214 } },
-                { timestamp: 2, payload: { o: 221, h: 222, l: 223, c: 224 } },
-                { timestamp: 3, payload: { o: 231, h: 232, l: 233, c: 234 } }
-            ],
-            givenRecordingEnabled(recording) {
-                executionMode.useValue.recording = recording;
-            },
-            givenSampleStored(sample, dependencies) {
-                return act(() => {
-                    const writer = (0, use_replay_writer_1.useReplayWriter)(dependencies);
-                    return writer(sample);
-                });
-            },
-            whenUseReplayCalled(input, dependencies) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const sample = Array.of();
-                    yield act(() => (0, rxjs_1.lastValueFrom)((0, use_replay_1.useReplay)((0, rxjs_1.from)(input), dependencies).pipe((0, rxjs_1.tap)(it => sample.push(it)))));
-                    return sample;
-                });
-            },
-            whenUseSampleStreamerStarted() {
-                act(() => {
-                    const { tryContinue } = (0, use_replay_coordinator_1.useReplayCoordinator)();
-                    tryContinue();
-                });
-            },
-            thenReplaySampleStored(sample, dependencies) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const stored = yield act(() => {
-                        const reader = (0, use_replay_reader_1.useReplayReader)(dependencies);
-                        return reader({
-                            where: {
-                                timestamp: (0, __1.between)(sample[0].timestamp, sample[sample.length - 1].timestamp + 1)
-                            }
-                        });
-                    });
-                    expect(stored).toEqual(sample);
-                });
-            }
-        };
+describe(use_replay_1.useReplay.name, () => {
+    test('happy path', () => {
+        expect(true).toBe(true);
     });
+});
+/*
+
+describe.skip(useReplayCoordinator.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('return single data stream for single data source', async () => {
+    fixtures.givenRecordingEnabled(false);
+    await fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
+
+    const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample']);
+    await fixtures.whenUseSampleStreamerStarted();
+
+    expect(await sample1).toEqual(fixtures.sample1);
+  });
+
+  test('return combined data stream for multiple data sources', async () => {
+    fixtures.givenRecordingEnabled(false);
+    await fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
+    await fixtures.givenSampleStored(fixtures.sample2, ['sample2']);
+
+    const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1']);
+    const sample2 = fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2']);
+    await fixtures.whenUseSampleStreamerStarted();
+
+    expect(await sample1).toEqual(fixtures.sample1);
+    expect(await sample2).toEqual(fixtures.sample2);
+  });
+
+  test('record and write data stream into storage', async () => {
+    fixtures.givenRecordingEnabled(true);
+    const sample1 = await fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1x']);
+    const sample2 = await fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2x']);
+
+    fixtures.thenReplaySampleStored(sample1, ['sample1x']);
+    fixtures.thenReplaySampleStored(sample2, ['sample2x']);
+  });
+});
+
+async function getFixtures() {
+  const executionMode = replayExecutionMode();
+
+  const { act } = await makeTestModule([
+    executionMode,
+    replayOptions({ from: 0, to: Number.MAX_VALUE })
+  ]);
+
+  return {
+    sample1: [
+      { timestamp: 1, payload: { o: 111, h: 112, l: 113, c: 114 } },
+      { timestamp: 2, payload: { o: 121, h: 122, l: 123, c: 124 } },
+      { timestamp: 3, payload: { o: 131, h: 132, l: 133, c: 134 } }
+    ],
+    sample2: [
+      { timestamp: 1, payload: { o: 211, h: 212, l: 213, c: 214 } },
+      { timestamp: 2, payload: { o: 221, h: 222, l: 223, c: 224 } },
+      { timestamp: 3, payload: { o: 231, h: 232, l: 233, c: 234 } }
+    ],
+
+    givenRecordingEnabled(recording: boolean) {
+      executionMode.useValue.recording = recording;
+    },
+
+    givenSampleStored<T>(
+      sample: { timestamp: number; payload: T }[],
+      dependencies: dependency[]
+    ) {
+      return act(() => {
+        const writer = useReplayWriter(dependencies);
+
+        return writer(sample);
+      });
+    },
+
+    async whenUseReplayCalled<T>(
+      input: { timestamp: number; payload: T }[],
+      dependencies: dependency[]
+    ) {
+      const sample = Array.of<{ timestamp: number; payload: T }>();
+
+      await act(() =>
+        lastValueFrom(
+          useReplay<T>(from(input), dependencies).pipe(tap(it => sample.push(it)))
+        )
+      );
+
+      return sample;
+    },
+
+    whenUseSampleStreamerStarted() {
+      act(() => {
+        const { tryContinue } = useReplayCoordinator();
+
+        tryContinue();
+      });
+    },
+
+    async thenReplaySampleStored<T extends { timestamp: number }>(
+      sample: T[],
+      dependencies: dependency[]
+    ) {
+      const stored = await act(() => {
+        const reader = useReplayReader(dependencies);
+
+        return reader({
+          where: {
+            timestamp: between(
+              sample[0].timestamp,
+              sample[sample.length - 1].timestamp + 1
+            )
+          }
+        });
+      });
+
+      expect(stored).toEqual(sample);
+    }
+  };
 }
+*/

package/dist/storage/index.d.ts

@@ -1,4 +1,5 @@
 export * from './storage';
+export * from './use-cache';
 export * from './use-storage';
 export * from './use-storage-factory';
 export * from './in-memory';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/storage/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./storage"), exports);
+__exportStar(require("./use-cache"), exports);
 __exportStar(require("./use-storage"), exports);
 __exportStar(require("./use-storage-factory"), exports);
 __exportStar(require("./in-memory"), exports);

package/dist/use-execution-mode.d.ts

@@ -1,5 +1,5 @@
 type ExecutionMode = {
-    mode: 'REPLAY' | 'PAPER' | 'LIVE';
+    mode: 'replay' | 'paper' | 'live';
     recording: boolean;
 };
 export declare function replayExecutionMode(): {

package/dist/use-execution-mode.js

@@ -6,31 +6,31 @@ const injectionToken = Symbol('execution-mode');
 function replayExecutionMode() {
     return {
         provide: injectionToken,
-        useValue: { mode: 'REPLAY', recording: false }
+        useValue: { mode: 'replay', recording: false }
     };
 }
 exports.replayExecutionMode = replayExecutionMode;
 function paperExecutionMode(options) {
     return {
         provide: injectionToken,
-        useValue: Object.assign({ mode: 'PAPER' }, options)
+        useValue: Object.assign({ mode: 'paper' }, options)
     };
 }
 exports.paperExecutionMode = paperExecutionMode;
 function liveExecutionMode(options) {
     return {
         provide: injectionToken,
-        useValue: Object.assign({ mode: 'LIVE' }, options)
+        useValue: Object.assign({ mode: 'live' }, options)
     };
 }
 exports.liveExecutionMode = liveExecutionMode;
 const useExecutionMode = () => {
     const mode = (0, module_1.useContext)(injectionToken);
     return {
-        isReplay: mode.mode === 'REPLAY',
-        isPaper: mode.mode === 'PAPER',
-        isLive: mode.mode === 'LIVE',
-        isSimulation: mode.mode !== 'LIVE',
+        isReplay: mode.mode === 'replay',
+        isPaper: mode.mode === 'paper',
+        isLive: mode.mode === 'live',
+        isSimulation: mode.mode !== 'live',
         recording: mode.recording
     };
 };

package/dist/use-timestamp.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTimestamp = void 0;
-const use_replay_coordinator_1 = require("./replay/use-replay-coordinator");
+const replay_1 = require("./replay");
 const use_execution_mode_1 = require("./use-execution-mode");
 function useTimestamp() {
     const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
     if (isReplay) {
-        return (0, use_replay_coordinator_1.useReplayCoordinator)().timestamp();
+        return (0, replay_1.useReplayManager)().timestamp();
     }
     return Date.now();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantform/core",
-  "version": "0.7.0-beta.32",
+  "version": "0.7.0-beta.34",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",

package/src/cli/dev.ts

@@ -9,7 +9,7 @@ export default async function (name: string, options: any) {
   }
 
   const script = new Script(name, [paperExecutionMode({ recording: false })]);
-  const output = await script.runWhileFinished();
+  const output = await script.run();
 
   console.log(output);
 }

package/src/cli/internal/script.ts

@@ -1,5 +1,14 @@
 import { join } from 'path';
-import { lastValueFrom } from 'rxjs';
+import {
+  finalize,
+  firstValueFrom,
+  fromEvent,
+  last,
+  merge,
+  of,
+  switchMap,
+  take
+} from 'rxjs';
 
 import { core } from '@lib/core';
 import { Dependency, Module } from '@lib/module';
@@ -12,12 +21,29 @@ export class Script {
     private readonly dependencies: Dependency[]
   ) {}
 
-  async runWhileFinished() {
+  async run() {
     const script = await import(join(buildDirectory(), this.name));
     const module = new Module([...core(), ...script.onInstall(), ...this.dependencies]);
 
     const { act } = await module.awake();
 
-    return await act(() => lastValueFrom(script.onAwake()));
+    return await act(() => {
+      process.stdin.resume();
+
+      return firstValueFrom(
+        merge(
+          script.onAwake().pipe(last()),
+          fromEvent(process, 'exit'),
+          fromEvent(process, 'SIGINT'),
+          fromEvent(process, 'SIGUSR1'),
+          fromEvent(process, 'SIGUSR2'),
+          fromEvent(process, 'uncaughtException')
+        ).pipe(
+          take(1),
+          switchMap(it => script.onExit() ?? of(it)),
+          finalize(() => process.exit(0))
+        )
+      );
+    });
   }
 }

package/src/cli/replay.ts

@@ -1,31 +1,19 @@
-import { join } from 'path';
-import { lastValueFrom } from 'rxjs';
-
 import build from '@lib/cli/build';
-import { buildDirectory } from '@lib/cli/internal/workspace';
-import { core } from '@lib/core';
-import { Dependency, Module } from '@lib/module';
 import { replayOptions } from '@lib/replay';
 import { replayExecutionMode } from '@lib/use-execution-mode';
 
+import { Script } from './internal/script';
+
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
-
-  const module = new Module([
-    ...core(),
-    ...dependencies,
+  const script = new Script(name, [
     replayOptions({ from: 0, to: Number.MAX_VALUE }),
     replayExecutionMode()
   ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const output = await script.run();
 
   console.log(output);
 }

package/src/cli/run.ts

@@ -1,29 +1,15 @@
-import { join } from 'path';
-import { lastValueFrom } from 'rxjs';
-
 import build from '@lib/cli/build';
-import { buildDirectory } from '@lib/cli/internal/workspace';
-import { core } from '@lib/core';
-import { Dependency, Module } from '@lib/module';
 import { liveExecutionMode } from '@lib/use-execution-mode';
 
+import { Script } from './internal/script';
+
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
-
-  const module = new Module([
-    ...core(),
-    ...dependencies,
-    liveExecutionMode({ recording: true })
-  ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const script = new Script(name, [liveExecutionMode({ recording: true })]);
+  const output = await script.run();
 
   console.log(output);
 }

package/src/index.ts

@@ -7,13 +7,10 @@ export * from '@lib/use-timestamp';
 export * from '@lib/simulator';
 export * from '@lib/make-test-module';
 export * from '@lib/core';
-export * from '@lib/replay/use-replay-coordinator';
 export * from '@lib/use-execution-mode';
-export * from '@lib/storage/use-storage';
-export * from '@lib/storage/use-cache';
+export * from '@lib/storage';
 export * from '@lib/use-logger';
 export * from '@lib/replay';
-export * from '@lib/replay/use-replay-coordinator';
 export * from '@lib/when-socket';
 export * from '@lib/with-request';
 export * from '@lib/with-memo';

package/src/replay/index.ts

@@ -1,6 +1,8 @@
 export * from './use-replay';
-export * from './use-replay-coordinator';
+export * from './use-replay-breakpoint';
 export * from './use-replay-options';
-export * from './use-replay-reader';
-export * from './use-replay-writer';
-export * from './with-replay';
+export * from './use-replay-storage';
+export * from './use-replay-storage-buffer';
+export * from './use-replay-manager';
+export * from './replay';
+export * from './replay-guard';

package/src/replay/replay-guard.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+
+import { dependency } from '@lib/use-hash';
+
+import { useReplayBreakpoint } from './use-replay-breakpoint';
+
+export function replayGuard<T extends Array<dependency>, K>(
+  fn: (...args: T) => Observable<{ timestamp: number; payload: K }>
+): (...args: T) => Observable<{ timestamp: number; payload: K }> {
+  return (...args: T) => useReplayBreakpoint(fn(...args));
+}

package/src/replay/replay.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+
+import { dependency } from '@lib/use-hash';
+import { withMemo } from '@lib/with-memo';
+
+import { useReplay } from './use-replay';
+
+export function replay<T extends Array<dependency>, K>(
+  fn: (...args: T) => Observable<{ timestamp: number; payload: K }>,
+  dependencies: dependency[]
+): (...args: T) => Observable<{ timestamp: number; payload: K }> {
+  return withMemo((...args: T) => useReplay(fn(...args), [...dependencies, ...args]));
+}