@quantform/core 0.7.0-beta.48 → 0.7.0-beta.49

package/dist/cli/internal/script.d.ts

@@ -1,8 +1,8 @@
 import { Dependency } from '../../module';
 export declare class Script {
-    private readonly name;
+    private readonly filename;
     private readonly dependencies;
-    constructor(name: string, dependencies: Dependency[]);
+    constructor(filename: string, dependencies: Dependency[]);
     run(): Promise<unknown[]>;
 }
 //# sourceMappingURL=script.d.ts.map

package/dist/cli/internal/script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/script.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAU,MAAM,aAAa,CAAC;AAMjD,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,UAAU,EAAE;IAGvC,GAAG;CAmCV"}
+{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/script.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAU,MAAM,aAAa,CAAC;AAMjD,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,UAAU,EAAE;IAGvC,GAAG;CA0CV"}

package/dist/cli/internal/script.js

@@ -40,21 +40,24 @@ const module_1 = require("../../module");
 const replay_1 = require("../../replay");
 const workspace_1 = require("./workspace");
 class Script {
-    constructor(name, dependencies) {
-        this.name = name;
+    constructor(filename, dependencies) {
+        this.filename = filename;
         this.dependencies = dependencies;
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const script = yield Promise.resolve(`${(0, path_1.join)((0, workspace_1.buildDirectory)(), this.name)}`).then(s => __importStar(require(s)));
+            const script = yield Promise.resolve(`${(0, path_1.join)((0, workspace_1.buildDirectory)(), this.filename)}`).then(s => __importStar(require(s)));
             const { dependencies, description } = script.default;
             const module = new module_1.Module([...(0, core_1.core)(), ...dependencies, ...this.dependencies]);
             const { act } = yield module.awake();
             return yield act(() => {
                 process.stdin.resume();
-                return (0, rxjs_1.firstValueFrom)((0, rxjs_1.merge)((0, rxjs_1.forkJoin)(description.before.map(it => it()))
-                    .pipe((0, rxjs_1.switchMap)(() => (0, rxjs_1.forkJoin)(description.behavior.map(it => it())).pipe((0, rxjs_1.last)())))
-                    .pipe((0, rxjs_1.last)()), (0, replay_1.whenReplayFinished)().pipe((0, rxjs_1.last)()), (0, rxjs_1.fromEvent)(process, 'exit'), (0, rxjs_1.fromEvent)(process, 'SIGINT'), (0, rxjs_1.fromEvent)(process, 'SIGUSR1'), (0, rxjs_1.fromEvent)(process, 'SIGUSR2'), (0, rxjs_1.fromEvent)(process, 'uncaughtException')).pipe((0, rxjs_1.take)(1), (0, rxjs_1.switchMap)(it => { var _a; return (_a = (0, rxjs_1.forkJoin)(description.after.map(it => it())).pipe((0, rxjs_1.last)())) !== null && _a !== void 0 ? _a : (0, rxjs_1.of)(it); }), (0, rxjs_1.finalize)(() => process.exit(0))));
+                return (0, rxjs_1.firstValueFrom)((0, rxjs_1.merge)((0, rxjs_1.forkJoin)(description.before.map(before => before()))
+                    .pipe((0, rxjs_1.switchMap)(() => (0, rxjs_1.forkJoin)(description.behavior.map(behavior => behavior())).pipe((0, rxjs_1.last)())))
+                    .pipe((0, rxjs_1.last)()), (0, replay_1.whenReplayFinished)().pipe((0, rxjs_1.last)()), (0, rxjs_1.fromEvent)(process, 'exit'), (0, rxjs_1.fromEvent)(process, 'SIGINT'), (0, rxjs_1.fromEvent)(process, 'SIGUSR1'), (0, rxjs_1.fromEvent)(process, 'SIGUSR2'), (0, rxjs_1.fromEvent)(process, 'uncaughtException')).pipe((0, rxjs_1.catchError)(e => {
+                    console.error(e);
+                    return (0, rxjs_1.of)(e);
+                }), (0, rxjs_1.take)(1), (0, rxjs_1.switchMap)(it => { var _a; return (_a = (0, rxjs_1.forkJoin)(description.after.map(after => after())).pipe((0, rxjs_1.last)())) !== null && _a !== void 0 ? _a : (0, rxjs_1.of)(it); }), (0, rxjs_1.finalize)(() => process.exit(0))));
             });
         });
     }

package/dist/replay/index.d.ts

@@ -1,8 +1,8 @@
 export * from './use-replay';
 export * from './use-replay-breakpoint';
 export * from './use-replay-options';
-export * from './use-replay-storage';
-export * from './use-replay-storage-buffer';
+export * from './storage/use-replay-storage';
+export * from './storage/use-replay-storage-buffer';
 export * from './use-replay-manager';
 export * from './when-replay-finished';
 export * from './replay';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/replay/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/replay/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}

package/dist/replay/index.js

@@ -17,8 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./use-replay"), exports);
 __exportStar(require("./use-replay-breakpoint"), exports);
 __exportStar(require("./use-replay-options"), exports);
-__exportStar(require("./use-replay-storage"), exports);
-__exportStar(require("./use-replay-storage-buffer"), exports);
+__exportStar(require("./storage/use-replay-storage"), exports);
+__exportStar(require("./storage/use-replay-storage-buffer"), exports);
 __exportStar(require("./use-replay-manager"), exports);
 __exportStar(require("./when-replay-finished"), exports);
 __exportStar(require("./replay"), exports);

package/dist/replay/{use-replay-storage-buffer.d.ts → storage/use-replay-storage-buffer.d.ts}

@@ -1,4 +1,4 @@
-import { dependency } from '../use-hash';
+import { dependency } from '../../use-hash';
 export declare const useReplayStorageBuffer: <T>(dependencies: dependency[]) => {
     size(): number;
     peek(): {
@@ -10,6 +10,6 @@ export declare const useReplayStorageBuffer: <T>(dependencies: dependency[]) =>
         payload: T;
     };
     completed(): boolean;
-    fetchNextPage(from: number, to: number): Promise<void>;
+    fetchNextPage(): Promise<void>;
 };
 //# sourceMappingURL=use-replay-storage-buffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage-buffer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,eAAO,MAAM,sBAAsB;;;mBAIC,MAAM;;;;mBAAN,MAAM;;;;;CAsCxC,CAAC"}

package/dist/replay/{use-replay-storage-buffer.js → storage/use-replay-storage-buffer.js}

@@ -10,14 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplayStorageBuffer = void 0;
-const storage_1 = require("../storage");
-const with_memo_1 = require("../with-memo");
+const use_replay_options_1 = require("../../replay/use-replay-options");
+const storage_1 = require("../../storage");
+const with_memo_1 = require("../../with-memo");
 const use_replay_storage_1 = require("./use-replay-storage");
 exports.useReplayStorageBuffer = (0, with_memo_1.withMemo)((dependencies) => {
     const { query } = (0, use_replay_storage_1.useReplayStorage)(dependencies);
+    const { from, to } = (0, use_replay_options_1.useReplayOptions)();
     let page = new Array();
     let index = 0;
     let completed = false;
+    let count = 0;
     return {
         size() {
             return page.length - index;
@@ -31,7 +34,7 @@ exports.useReplayStorageBuffer = (0, with_memo_1.withMemo)((dependencies) => {
         completed() {
             return completed;
         },
-        fetchNextPage(from, to) {
+        fetchNextPage() {
             return __awaiter(this, void 0, void 0, function* () {
                 if (completed) {
                     return;
@@ -41,8 +44,11 @@ exports.useReplayStorageBuffer = (0, with_memo_1.withMemo)((dependencies) => {
                     where: {
                         timestamp: (0, storage_1.between)(from, to)
                     },
-                    limit: 10000
+                    limit: 10000,
+                    offset: count,
+                    orderBy: 'ASC'
                 });
+                count += page.length;
                 completed = page.length == 0;
             });
         }

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

@@ -0,0 +1,30 @@
+import { dependency } from '../../use-hash';
+export declare const useReplayStorageCursor: () => {
+    get<T>(dependencies: dependency[]): {
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: T;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: T;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    };
+    cursor(): Promise<{
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: any;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: any;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    } | undefined>;
+};
+//# sourceMappingURL=use-replay-storage-cursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage-cursor.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAMpD,eAAO,MAAM,sBAAsB;yBAKV,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCnC,CAAC"}

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

@@ -0,0 +1,49 @@
+"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.useReplayStorageCursor = void 0;
+const use_hash_1 = require("../../use-hash");
+const use_logger_1 = require("../../use-logger");
+const with_memo_1 = require("../../with-memo");
+const use_replay_storage_buffer_1 = require("./use-replay-storage-buffer");
+exports.useReplayStorageCursor = (0, with_memo_1.withMemo)(() => {
+    const { info } = (0, use_logger_1.useLogger)('useReplayStorageCursor');
+    const storages = Array.of();
+    return {
+        get(dependencies) {
+            const storage = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(dependencies);
+            if (!storages.includes(storage)) {
+                info('opening a new replay buffer', (0, use_hash_1.useHash)(dependencies));
+                storages.push(storage);
+            }
+            return storage;
+        },
+        cursor() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let current;
+                for (const storage of storages) {
+                    if (storage.completed()) {
+                        continue;
+                    }
+                    if (storage.size() == 0) {
+                        yield storage.fetchNextPage();
+                    }
+                    if (storage.peek()) {
+                        if (!current || current.peek().timestamp > storage.peek().timestamp) {
+                            current = storage;
+                        }
+                    }
+                }
+                return current;
+            });
+        }
+    };
+});

package/dist/replay/{use-replay-storage.d.ts → storage/use-replay-storage.d.ts}

@@ -1,5 +1,5 @@
-import { Query, QueryObject } from '../storage';
-import { dependency } from '../use-hash';
+import { Query, QueryObject } from '../../storage';
+import { dependency } from '../../use-hash';
 export declare function useReplayStorage<T>(dependencies: dependency[]): {
     query(query: Query<QueryObject>): Promise<{
         timestamp: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAuB,MAAM,cAAc,CAAC;AACvE,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE;iBASvC,MAAM,WAAW,CAAC;;;;kBAMvB;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE;EAUpD"}

package/dist/replay/{use-replay-storage.js → storage/use-replay-storage.js}

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplayStorage = void 0;
-const storage_1 = require("../storage");
-const use_hash_1 = require("../use-hash");
+const storage_1 = require("../../storage");
+const use_hash_1 = require("../../use-hash");
 function useReplayStorage(dependencies) {
     const storage = (0, storage_1.useStorage)(['replay']);
     const storageObjectKey = (0, use_hash_1.useHash)(dependencies);

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage.spec.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage.spec.ts"],"names":[],"mappings":""}

package/dist/replay/{use-replay-storage.spec.js → storage/use-replay-storage.spec.js}

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const make_test_module_1 = require("../make-test-module");
-const storage_1 = require("../storage");
+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, () => {

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

@@ -10,12 +10,12 @@ function useReplayBreakpoint(input) {
     if (!isReplay) {
         return input;
     }
-    const { info } = (0, use_logger_1.useLogger)('useReplayBreakpoint');
+    const { info } = (0, use_logger_1.useLogger)('replay');
     const { stop, tryContinue } = (0, use_replay_manager_1.useReplayManager)();
-    info('locking resource...');
+    info('breakpoint acquired');
     stop();
     return input.pipe((0, rxjs_1.finalize)(() => {
-        info('unlocking resource');
+        info('breakpoint released');
         tryContinue();
     }));
 }

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

@@ -12,7 +12,7 @@ export declare const useReplayManager: () => {
             payload: any;
         };
         completed(): boolean;
-        fetchNextPage(from: number, to: number): Promise<void>;
+        fetchNextPage(): Promise<void>;
     }, {
         timestamp: number;
         payload: any;
@@ -20,7 +20,7 @@ export declare const useReplayManager: () => {
     timestamp(): number;
     stop(): void;
     tryContinue: () => void;
-    when<T>(dependencies: dependency[]): Observable<{
+    watch<T>(dependencies: dependency[]): Observable<{
         timestamp: number;
         payload: T;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"use-replay-manager.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAOpD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;mBASqC,MAAM;iBAAW,GAAG;;;;;0BAsE5D,UAAU,EAAE;mBAA2B,MAAM;;;CAkBrE,CAAC"}
+{"version":3,"file":"use-replay-manager.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;mBAQqC,MAAM;iBAAW,GAAG;;;;;2BAoD3D,UAAU,EAAE;mBAA2B,MAAM;;;CAatE,CAAC"}

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

@@ -11,41 +11,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplayManager = void 0;
 const rxjs_1 = require("rxjs");
-const use_hash_1 = require("../use-hash");
-const use_logger_1 = require("../use-logger");
 const with_memo_1 = require("../with-memo");
+const use_replay_storage_cursor_1 = require("./storage/use-replay-storage-cursor");
 const use_replay_options_1 = require("./use-replay-options");
-const use_replay_storage_buffer_1 = require("./use-replay-storage-buffer");
 exports.useReplayManager = (0, with_memo_1.withMemo)(() => {
-    const { from, to } = (0, use_replay_options_1.useReplayOptions)();
-    const { info } = (0, use_logger_1.useLogger)('useReplayManager');
+    const { from } = (0, use_replay_options_1.useReplayOptions)();
+    const { get, cursor } = (0, use_replay_storage_cursor_1.useReplayStorageCursor)();
     let timestamp = from;
     let stopAcquire = 1;
-    const subscriptions = Array.of();
     const stream$ = new rxjs_1.Subject();
-    const getNextStorage = () => __awaiter(void 0, void 0, void 0, function* () {
-        let next;
-        for (const cursor of subscriptions) {
-            if (cursor.size() == 0 && !cursor.completed()) {
-                yield cursor.fetchNextPage(timestamp, to + 1);
-            }
-            if (cursor.peek()) {
-                if (!next || next.peek().timestamp > cursor.peek().timestamp) {
-                    next = cursor;
-                }
-            }
-        }
-        return next;
-    });
     const processNext = () => __awaiter(void 0, void 0, void 0, function* () {
-        const cursor = yield getNextStorage();
-        if (!cursor || !cursor.peek()) {
+        const storage = yield cursor();
+        if (!storage || !storage.peek()) {
             stream$.complete();
             return false;
         }
-        const sample = cursor.dequeue();
+        const sample = storage.dequeue();
         timestamp = sample.timestamp;
-        stream$.next([cursor, sample]);
+        stream$.next([storage, sample]);
         return true;
     });
     const next = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -74,12 +57,8 @@ exports.useReplayManager = (0, with_memo_1.withMemo)(() => {
             stopAcquire++;
         },
         tryContinue,
-        when(dependencies) {
-            const storage = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(dependencies);
-            if (!subscriptions.includes(storage)) {
-                info('subscribing to replay', (0, use_hash_1.useHash)(dependencies));
-                subscriptions.push(storage);
-            }
+        watch(dependencies) {
+            const storage = get(dependencies);
             return (0, rxjs_1.defer)(() => {
                 tryContinue();
                 return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === storage), (0, rxjs_1.map)(([, it]) => ({ timestamp: it.timestamp, payload: it.payload })));

package/dist/replay/use-replay.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplay = void 0;
 const rxjs_1 = require("rxjs");
 const use_execution_mode_1 = require("../use-execution-mode");
+const use_replay_storage_1 = require("./storage/use-replay-storage");
 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 { when } = (0, use_replay_manager_1.useReplayManager)();
-        return when(dependencies);
+        const { watch } = (0, use_replay_manager_1.useReplayManager)();
+        return watch(dependencies);
     }
     if (recording) {
         const { save } = (0, use_replay_storage_1.useReplayStorage)(dependencies);

package/dist/shared/decimals.d.ts

@@ -11,20 +11,4 @@ export declare function d(value: Decimal.Value): decimal;
 export declare namespace d {
     var Zero: decimal;
 }
-export declare function weightedMean(values: decimal[], weights: decimal[]): decimal;
-export declare function pnl(entryRate: decimal, exitRate: decimal, amount: decimal): Decimal;
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export declare function candledown(timestamp: number, timeframe: number): number;
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export declare function candleup(timestamp: number, timeframe: number): number;
 //# sourceMappingURL=decimals.d.ts.map

package/dist/shared/decimals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../src/shared/decimals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,OAAO;QACf,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;QACxC,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;KACxC;CACF;AAUD,qBAAa,OAAQ,SAAQ,OAAO;CAAG;AAOvC,wBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,WAErC;yBAFe,CAAC;;;AAMjB,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,CAc3E;AAED,wBAAgB,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,WAEzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAErE"}
+{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../src/shared/decimals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,OAAO;QACf,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;QACxC,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;KACxC;CACF;AAUD,qBAAa,OAAQ,SAAQ,OAAO;CAAG;AAEvC,wBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,WAErC;yBAFe,CAAC"}

package/dist/shared/decimals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.candleup = exports.candledown = exports.pnl = exports.weightedMean = exports.d = exports.decimal = void 0;
+exports.d = exports.decimal = void 0;
 const decimal_js_1 = require("decimal.js");
 decimal_js_1.Decimal.prototype.toFloor = function (decimalPlaces) {
     return this.toDecimalPlaces(decimalPlaces, decimal_js_1.Decimal.ROUND_FLOOR);
@@ -11,51 +11,8 @@ decimal_js_1.Decimal.prototype.toCeil = function (decimalPlaces) {
 class decimal extends decimal_js_1.Decimal {
 }
 exports.decimal = decimal;
-/*
-decimal.prototype.toJSON = function () {
-  return '444';
-};
-*/
 function d(value) {
     return new decimal(value);
 }
 exports.d = d;
 d.Zero = new decimal(0);
-function weightedMean(values, weights) {
-    const result = values
-        .map((value, i) => {
-        const weight = weights[i];
-        const sum = value.mul(weight);
-        return [sum, weight];
-    })
-        .reduce((p, c) => [p[0].add(c[0]), p[1].add(c[1])], [d.Zero, d.Zero]);
-    if (!result[1]) {
-        return d.Zero;
-    }
-    return result[0].div(result[1]);
-}
-exports.weightedMean = weightedMean;
-function pnl(entryRate, exitRate, amount) {
-    return exitRate.div(entryRate).minus(1).mul(amount);
-}
-exports.pnl = pnl;
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-function candledown(timestamp, timeframe) {
-    return timestamp - (timestamp % timeframe);
-}
-exports.candledown = candledown;
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-function candleup(timestamp, timeframe) {
-    return candledown(timestamp, timeframe) + timeframe;
-}
-exports.candleup = candleup;

package/dist/strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;AAEnD,eAAO,IAAI,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACpD,eAAO,IAAI,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACtD,eAAO,IAAI,KAAK,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AAEnD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,UAAU,EAAE;;;;;;;EAiBtD"}
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAM,MAAM,MAAM,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;AAEnD,eAAO,IAAI,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACpD,eAAO,IAAI,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACtD,eAAO,IAAI,KAAK,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AAEnD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,UAAU,EAAE;;;;;;;EAyBtD"}

package/dist/strategy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.strategy = exports.after = exports.behavior = exports.before = void 0;
+const rxjs_1 = require("rxjs");
 function strategy(descriptor) {
     const description = {
         before: Array.of(),
@@ -11,6 +12,12 @@ function strategy(descriptor) {
     exports.behavior = descriptor => description.behavior.push(descriptor);
     exports.after = descriptor => description.after.push(descriptor);
     const dependencies = descriptor();
+    if (!description.before.length) {
+        description.before.push(() => (0, rxjs_1.of)(true));
+    }
+    if (!description.after.length) {
+        description.after.push(() => (0, rxjs_1.of)(true));
+    }
     return {
         dependencies,
         description

package/dist/use-execution-mode.js

@@ -32,14 +32,14 @@ function idleExecutionMode() {
 }
 exports.idleExecutionMode = idleExecutionMode;
 const useExecutionMode = () => {
-    const mode = (0, module_1.useContext)(injectionToken);
+    const { mode, recording } = (0, module_1.useContext)(injectionToken);
     return {
-        isReplay: mode.mode === 'replay',
-        isPaper: mode.mode === 'paper',
-        isLive: mode.mode === 'live',
-        isIdle: mode.mode === 'idle',
-        isSimulation: mode.mode !== 'live',
-        recording: mode.recording
+        isReplay: mode === 'replay',
+        isPaper: mode === 'paper',
+        isLive: mode === 'live',
+        isIdle: mode === 'idle',
+        isSimulation: mode !== 'live',
+        recording
     };
 };
 exports.useExecutionMode = useExecutionMode;

package/dist/use-socket.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+export declare function useSocket(url: string, options?: {
+    pingInterval?: number;
+}): {
+    /**
+     * Observes socket events and handles connection health monitoring via ping/pong
+     * @returns observable emitting message events with timestamps and parsed payloads
+     */
+    watch(): Observable<{
+        timestamp: number;
+        payload: unknown;
+    }>;
+    send(message: {
+        payload: unknown;
+    }): Observable<{
+        timestamp: number;
+    }>;
+};
+//# sourceMappingURL=use-socket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-socket.d.ts","sourceRoot":"","sources":["../src/use-socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAM,MAAM,MAAM,CAAC;AAM7C,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAA2B;IAMzD;;;OAGG;aACM,WAAW;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;kBAmD9C;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,WAAW;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;EAQzE"}

package/dist/use-socket.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSocket = void 0;
+const rxjs_1 = require("rxjs");
+const ws_1 = require("ws");
+const use_logger_1 = require("./use-logger");
+const use_timestamp_1 = require("./use-timestamp");
+function useSocket(url, options = { pingInterval: 5000 }) {
+    const { debug } = (0, use_logger_1.useLogger)('useSocket');
+    const socket = new ws_1.WebSocket(url);
+    return {
+        /**
+         * Observes socket events and handles connection health monitoring via ping/pong
+         * @returns observable emitting message events with timestamps and parsed payloads
+         */
+        watch() {
+            let isAlive = false;
+            let interval;
+            return new rxjs_1.Observable(stream => {
+                socket.onmessage = it => stream.next({
+                    timestamp: (0, use_timestamp_1.useTimestamp)(),
+                    payload: JSON.parse(it.data)
+                });
+                socket.onerror = it => {
+                    clearInterval(interval);
+                    debug('errored', url);
+                    stream.error(it);
+                };
+                socket.onclose = () => {
+                    debug('closed', url);
+                    clearInterval(interval);
+                    stream.error();
+                };
+                socket.onopen = () => {
+                    debug('opened', url);
+                    isAlive = true;
+                    interval = setInterval(() => {
+                        if (isAlive) {
+                            isAlive = false;
+                            socket.ping();
+                        }
+                        else {
+                            socket.terminate();
+                            clearInterval(interval);
+                        }
+                    }, options.pingInterval);
+                    socket.on('pong', () => {
+                        isAlive = true;
+                    });
+                    socket.on('ping', () => {
+                        isAlive = true;
+                        socket.pong();
+                    });
+                };
+                return () => {
+                    clearInterval(interval);
+                    socket.terminate();
+                };
+            });
+        },
+        send(message) {
+            return (0, rxjs_1.defer)(() => {
+                socket.send(JSON.stringify(message.payload));
+                return (0, rxjs_1.of)({ timestamp: (0, use_timestamp_1.useTimestamp)() });
+            });
+        }
+    };
+}
+exports.useSocket = useSocket;

package/package.json

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

package/src/cli/internal/script.ts

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import {
+  catchError,
   finalize,
   firstValueFrom,
   forkJoin,
@@ -8,8 +9,7 @@ import {
   merge,
   of,
   switchMap,
-  take,
-  tap
+  take
 } from 'rxjs';
 
 import { core } from '@lib/core';
@@ -21,12 +21,12 @@ import { buildDirectory } from './workspace';
 
 export class Script {
   constructor(
-    private readonly name: string,
+    private readonly filename: string,
     private readonly dependencies: Dependency[]
   ) {}
 
   async run() {
-    const script = await import(join(buildDirectory(), this.name));
+    const script = await import(join(buildDirectory(), this.filename));
 
     const { dependencies, description } = script.default as ReturnType<typeof strategy>;
 
@@ -39,9 +39,11 @@ export class Script {
 
       return firstValueFrom(
         merge(
-          forkJoin(description.before.map(it => it()))
+          forkJoin(description.before.map(before => before()))
             .pipe(
-              switchMap(() => forkJoin(description.behavior.map(it => it())).pipe(last()))
+              switchMap(() =>
+                forkJoin(description.behavior.map(behavior => behavior())).pipe(last())
+              )
             )
             .pipe(last()),
           whenReplayFinished().pipe(last()),
@@ -51,9 +53,14 @@ export class Script {
           fromEvent(process, 'SIGUSR2'),
           fromEvent(process, 'uncaughtException')
         ).pipe(
+          catchError(e => {
+            console.error(e);
+
+            return of(e);
+          }),
           take(1),
           switchMap(
-            it => forkJoin(description.after.map(it => it())).pipe(last()) ?? of(it)
+            it => forkJoin(description.after.map(after => after())).pipe(last()) ?? of(it)
           ),
           finalize(() => process.exit(0))
         )

package/src/replay/index.ts

@@ -1,8 +1,8 @@
 export * from './use-replay';
 export * from './use-replay-breakpoint';
 export * from './use-replay-options';
-export * from './use-replay-storage';
-export * from './use-replay-storage-buffer';
+export * from './storage/use-replay-storage';
+export * from './storage/use-replay-storage-buffer';
 export * from './use-replay-manager';
 export * from './when-replay-finished';
 export * from './replay';

package/src/replay/{use-replay-storage-buffer.ts → storage/use-replay-storage-buffer.ts}

@@ -1,3 +1,4 @@
+import { useReplayOptions } from '@lib/replay/use-replay-options';
 import { between } from '@lib/storage';
 import { dependency } from '@lib/use-hash';
 import { withMemo } from '@lib/with-memo';
@@ -6,10 +7,12 @@ import { useReplayStorage } from './use-replay-storage';
 
 export const useReplayStorageBuffer = withMemo(<T>(dependencies: dependency[]) => {
   const { query } = useReplayStorage<T>(dependencies);
+  const { from, to } = useReplayOptions();
 
   let page = new Array<{ timestamp: number; payload: T }>();
   let index = 0;
   let completed = false;
+  let count = 0;
 
   return {
     size() {
@@ -24,7 +27,7 @@ export const useReplayStorageBuffer = withMemo(<T>(dependencies: dependency[]) =
     completed() {
       return completed;
     },
-    async fetchNextPage(from: number, to: number) {
+    async fetchNextPage() {
       if (completed) {
         return;
       }
@@ -35,8 +38,12 @@ export const useReplayStorageBuffer = withMemo(<T>(dependencies: dependency[]) =
         where: {
           timestamp: between(from, to)
         },
-        limit: 10000
+        limit: 10000,
+        offset: count,
+        orderBy: 'ASC'
       });
+
+      count += page.length;
       completed = page.length == 0;
     }
   };

package/src/replay/storage/use-replay-storage-cursor.ts

@@ -0,0 +1,44 @@
+import { dependency, useHash } from '@lib/use-hash';
+import { useLogger } from '@lib/use-logger';
+import { withMemo } from '@lib/with-memo';
+
+import { useReplayStorageBuffer } from './use-replay-storage-buffer';
+
+export const useReplayStorageCursor = withMemo(() => {
+  const { info } = useLogger('useReplayStorageCursor');
+  const storages = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
+
+  return {
+    get<T>(dependencies: dependency[]) {
+      const storage = useReplayStorageBuffer<T>(dependencies);
+
+      if (!storages.includes(storage)) {
+        info('opening a new replay buffer', useHash(dependencies));
+        storages.push(storage);
+      }
+
+      return storage;
+    },
+    async cursor() {
+      let current: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
+
+      for (const storage of storages) {
+        if (storage.completed()) {
+          continue;
+        }
+
+        if (storage.size() == 0) {
+          await storage.fetchNextPage();
+        }
+
+        if (storage.peek()) {
+          if (!current || current.peek().timestamp > storage.peek().timestamp) {
+            current = storage;
+          }
+        }
+      }
+
+      return current;
+    }
+  };
+});

package/src/replay/{use-replay-storage.spec.ts → storage/use-replay-storage.spec.ts}

@@ -69,7 +69,6 @@ async function getFixtures() {
         return act(() => useReplayStorage<T>(dependencies).query(query));
       }
     },
-
     then: {
       stored<T>(sample: { timestamp: number; payload: T }[]) {
         expect(save).toHaveBeenCalledWith(

package/src/replay/use-replay-breakpoint.ts

@@ -12,16 +12,16 @@ export function useReplayBreakpoint<T>(input: Observable<T>): Observable<T> {
     return input;
   }
 
-  const { info } = useLogger('useReplayBreakpoint');
+  const { info } = useLogger('replay');
   const { stop, tryContinue } = useReplayManager();
 
-  info('locking resource...');
+  info('breakpoint acquired');
 
   stop();
 
   return input.pipe(
     finalize(() => {
-      info('unlocking resource');
+      info('breakpoint released');
 
       tryContinue();
     })

package/src/replay/use-replay-manager.ts

@@ -1,56 +1,37 @@
 import { defer, filter, map, Observable, Subject } from 'rxjs';
 
-import { dependency, useHash } from '@lib/use-hash';
-import { useLogger } from '@lib/use-logger';
+import { dependency } from '@lib/use-hash';
 import { withMemo } from '@lib/with-memo';
 
+import { useReplayStorageBuffer } from './storage/use-replay-storage-buffer';
+import { useReplayStorageCursor } from './storage/use-replay-storage-cursor';
 import { useReplayOptions } from './use-replay-options';
-import { useReplayStorageBuffer } from './use-replay-storage-buffer';
 
 export const useReplayManager = withMemo(() => {
-  const { from, to } = useReplayOptions();
-  const { info } = useLogger('useReplayManager');
+  const { from } = useReplayOptions();
+  const { get, cursor } = useReplayStorageCursor();
 
   let timestamp = from;
   let stopAcquire = 1;
-  const subscriptions = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
 
   const stream$ = new Subject<
     [ReturnType<typeof useReplayStorageBuffer<any>>, { timestamp: number; payload: any }]
   >();
 
-  const getNextStorage = async () => {
-    let next: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
-
-    for (const cursor of subscriptions) {
-      if (cursor.size() == 0 && !cursor.completed()) {
-        await cursor.fetchNextPage(timestamp, to + 1);
-      }
-
-      if (cursor.peek()) {
-        if (!next || next.peek().timestamp > cursor.peek().timestamp) {
-          next = cursor;
-        }
-      }
-    }
-
-    return next;
-  };
-
   const processNext = async () => {
-    const cursor = await getNextStorage();
+    const storage = await cursor();
 
-    if (!cursor || !cursor.peek()) {
+    if (!storage || !storage.peek()) {
       stream$.complete();
 
       return false;
     }
 
-    const sample = cursor.dequeue();
+    const sample = storage.dequeue();
 
     timestamp = sample.timestamp;
 
-    stream$.next([cursor, sample]);
+    stream$.next([storage, sample]);
 
     return true;
   };
@@ -86,13 +67,8 @@ export const useReplayManager = withMemo(() => {
       stopAcquire++;
     },
     tryContinue,
-    when<T>(dependencies: dependency[]): Observable<{ timestamp: number; payload: T }> {
-      const storage = useReplayStorageBuffer<T>(dependencies);
-
-      if (!subscriptions.includes(storage)) {
-        info('subscribing to replay', useHash(dependencies));
-        subscriptions.push(storage);
-      }
+    watch<T>(dependencies: dependency[]): Observable<{ timestamp: number; payload: T }> {
+      const storage = get<T>(dependencies);
 
       return defer(() => {
         tryContinue();

package/src/replay/use-replay.ts

@@ -3,8 +3,8 @@ import { Observable, tap } from 'rxjs';
 import { useExecutionMode } from '@lib/use-execution-mode';
 import { dependency } from '@lib/use-hash';
 
+import { useReplayStorage } from './storage/use-replay-storage';
 import { useReplayManager } from './use-replay-manager';
-import { useReplayStorage } from './use-replay-storage';
 
 export function useReplay<T>(
   input: Observable<{ timestamp: number; payload: T }>,
@@ -13,9 +13,9 @@ export function useReplay<T>(
   const { isReplay, recording } = useExecutionMode();
 
   if (isReplay) {
-    const { when } = useReplayManager();
+    const { watch } = useReplayManager();
 
-    return when<T>(dependencies);
+    return watch<T>(dependencies);
   }
 
   if (recording) {

package/src/shared/decimals.ts

@@ -16,54 +16,9 @@ Decimal.prototype.toCeil = function (decimalPlaces: number) {
 };
 
 export class decimal extends Decimal {}
-/*
-decimal.prototype.toJSON = function () {
-  return '444';
-};
-*/
 
 export function d(value: Decimal.Value) {
   return new decimal(value);
 }
 
 d.Zero = new decimal(0);
-
-export function weightedMean(values: decimal[], weights: decimal[]): decimal {
-  const result = values
-    .map((value, i) => {
-      const weight = weights[i];
-      const sum = value.mul(weight);
-      return [sum, weight];
-    })
-    .reduce((p, c) => [p[0].add(c[0]), p[1].add(c[1])], [d.Zero, d.Zero]);
-
-  if (!result[1]) {
-    return d.Zero;
-  }
-
-  return result[0].div(result[1]);
-}
-
-export function pnl(entryRate: decimal, exitRate: decimal, amount: decimal) {
-  return exitRate.div(entryRate).minus(1).mul(amount);
-}
-
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export function candledown(timestamp: number, timeframe: number): number {
-  return timestamp - (timestamp % timeframe);
-}
-
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export function candleup(timestamp: number, timeframe: number): number {
-  return candledown(timestamp, timeframe) + timeframe;
-}

package/src/strategy.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { Observable, of } from 'rxjs';
 
 import { Dependency } from './module';
 
@@ -21,6 +21,14 @@ export function strategy(descriptor: () => Dependency[]) {
 
   const dependencies = descriptor();
 
+  if (!description.before.length) {
+    description.before.push(() => of(true));
+  }
+
+  if (!description.after.length) {
+    description.after.push(() => of(true));
+  }
+
   return {
     dependencies,
     description

package/src/use-execution-mode.ts

@@ -36,14 +36,14 @@ export function idleExecutionMode() {
 }
 
 export const useExecutionMode = () => {
-  const mode = useContext<ExecutionMode>(injectionToken);
+  const { mode, recording } = useContext<ExecutionMode>(injectionToken);
 
   return {
-    isReplay: mode.mode === 'replay',
-    isPaper: mode.mode === 'paper',
-    isLive: mode.mode === 'live',
-    isIdle: mode.mode === 'idle',
-    isSimulation: mode.mode !== 'live',
-    recording: mode.recording
+    isReplay: mode === 'replay',
+    isPaper: mode === 'paper',
+    isLive: mode === 'live',
+    isIdle: mode === 'idle',
+    isSimulation: mode !== 'live',
+    recording
   };
 };

package/src/use-socket.ts

@@ -0,0 +1,78 @@
+import { defer, Observable, of } from 'rxjs';
+import { WebSocket } from 'ws';
+
+import { useLogger } from './use-logger';
+import { useTimestamp } from './use-timestamp';
+
+export function useSocket(
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
+) {
+  const { debug } = useLogger('useSocket');
+  const socket = new WebSocket(url);
+
+  return {
+    /**
+     * Observes socket events and handles connection health monitoring via ping/pong
+     * @returns observable emitting message events with timestamps and parsed payloads
+     */
+    watch(): Observable<{ timestamp: number; payload: unknown }> {
+      let isAlive = false;
+      let interval: NodeJS.Timeout | undefined;
+
+      return new Observable(stream => {
+        socket.onmessage = it =>
+          stream.next({
+            timestamp: useTimestamp(),
+            payload: JSON.parse(it.data as string)
+          });
+        socket.onerror = it => {
+          clearInterval(interval);
+          debug('errored', url);
+          stream.error(it);
+        };
+        socket.onclose = () => {
+          debug('closed', url);
+          clearInterval(interval);
+          stream.error();
+        };
+        socket.onopen = () => {
+          debug('opened', url);
+          isAlive = true;
+          interval = setInterval(() => {
+            if (isAlive) {
+              isAlive = false;
+
+              socket.ping();
+            } else {
+              socket.terminate();
+              clearInterval(interval);
+            }
+          }, options.pingInterval);
+
+          socket.on('pong', () => {
+            isAlive = true;
+          });
+
+          socket.on('ping', () => {
+            isAlive = true;
+            socket.pong();
+          });
+        };
+
+        return () => {
+          clearInterval(interval);
+          socket.terminate();
+        };
+      });
+    },
+
+    send(message: { payload: unknown }): Observable<{ timestamp: number }> {
+      return defer(() => {
+        socket.send(JSON.stringify(message.payload));
+
+        return of({ timestamp: useTimestamp() });
+      });
+    }
+  };
+}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-buffer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,eAAO,MAAM,sBAAsB;;;mBAGC,MAAM;;;;mBAAN,MAAM;;;;wBAiBZ,MAAM,MAAM,MAAM;CAgB9C,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAuB,MAAM,cAAc,CAAC;AACvE,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE;iBASvC,MAAM,WAAW,CAAC;;;;kBAMvB;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE;EAUpD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-storage.spec.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.spec.ts"],"names":[],"mappings":""}