@quantform/core 0.7.0-beta.8 → 0.7.9

package/lib/use-memo.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.token = void 0;
+exports.useMemo = useMemo;
+const module_1 = require("./module");
+const use_hash_1 = require("./use-hash");
+exports.token = Symbol('memo-token');
+function useMemo(calculateValue, dependencies) {
+    const memory = (0, module_1.useContext)(exports.token);
+    const hash = (0, use_hash_1.useHash)(dependencies);
+    if (memory[hash]) {
+        return memory[hash];
+    }
+    return (memory[hash] = calculateValue());
+}
+useMemo.options = () => ({
+    provide: exports.token,
+    useValue: {}
+});

package/lib/use-socket.d.ts

@@ -0,0 +1,20 @@
+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;
+    }>;
+    monitor(): Observable<"opened" | "closed" | "errored">;
+};
+//# sourceMappingURL=use-socket.d.ts.map

package/lib/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,EAAqB,MAAM,MAAM,CAAC;AAM5D,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAA2B;IAsBzD;;;OAGG;aACM,UAAU,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;kBAgD9C;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,UAAU,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;;EAczE"}

package/lib/use-socket.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSocket = useSocket;
+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);
+    const monitor = new rxjs_1.ReplaySubject();
+    socket.on('error', e => {
+        debug('errored', url, e);
+        monitor.next('errored');
+    });
+    socket.on('close', () => {
+        debug('closed', url);
+        monitor.next('closed');
+    });
+    socket.on('open', () => {
+        debug('opened', url);
+        monitor.next('opened');
+    });
+    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);
+                    stream.error(it);
+                };
+                socket.onclose = () => {
+                    clearInterval(interval);
+                    stream.error();
+                };
+                socket.onopen = () => {
+                    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)(() => {
+                debug('sent', url, message.payload);
+                socket.send(JSON.stringify(message.payload));
+                return (0, rxjs_1.of)({ timestamp: (0, use_timestamp_1.useTimestamp)() });
+            });
+        },
+        monitor() {
+            return monitor.asObservable();
+        }
+    };
+}

package/{dist → lib}/use-timestamp.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTimestamp = void 0;
-const use_replay_coordinator_1 = require("./replay/use-replay-coordinator");
+exports.useTimestamp = useTimestamp;
+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();
 }
-exports.useTimestamp = useTimestamp;

package/lib/when-socket.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+export declare function whenSocket(url: string, options?: {
+    pingInterval?: number;
+}): [Observable<{
+    timestamp: number;
+    payload: unknown;
+}>, (message: unknown) => void];
+//# sourceMappingURL=when-socket.d.ts.map

package/lib/when-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when-socket.d.ts","sourceRoot":"","sources":["../src/when-socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAMlC,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAA2B,GAC1D,CAAC,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,CAmDnF"}

package/{dist/use-socket.js → lib/when-socket.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSocket = void 0;
+exports.whenSocket = whenSocket;
 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) {
-    const { debug } = (0, use_logger_1.useLogger)('useSocket');
+function whenSocket(url, options = { pingInterval: 5000 }) {
+    const { debug } = (0, use_logger_1.useLogger)('whenSocket');
     const message = new rxjs_1.Observable(stream => {
         const socket = new ws_1.WebSocket(url);
         let isAlive = false;
@@ -14,6 +14,7 @@ function useSocket(url) {
         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 = () => {
@@ -33,7 +34,7 @@ function useSocket(url) {
                     socket.terminate();
                     clearInterval(interval);
                 }
-            }, 5000);
+            }, options.pingInterval);
             socket.on('pong', () => {
                 isAlive = true;
             });
@@ -49,4 +50,3 @@ function useSocket(url) {
     });
     return [message, (message) => JSON.stringify(message)];
 }
-exports.useSocket = useSocket;

package/lib/with-memo.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+import { dependency } from './use-hash';
+export declare function withMemo<T extends Array<dependency>, U>(fn: (...args: T) => U): (...args: T) => U;
+export declare function withMemo<T extends Array<dependency>, U>(fn: (...args: T) => Observable<U>): (...args: T) => Observable<U>;
+//# sourceMappingURL=with-memo.d.ts.map

package/lib/with-memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-memo.d.ts","sourceRoot":"","sources":["../src/with-memo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,UAAU,EAAe,MAAM,MAAM,CAAC;AAK7D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACrD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACpB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AACrB,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACrD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAChC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/{dist/use.js → lib/with-memo.js}

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.use = void 0;
+exports.withMemo = withMemo;
 const rxjs_1 = require("rxjs");
 const uuid_1 = require("uuid");
-const as_readonly_1 = require("./as-readonly");
 const module_1 = require("./module");
+const operators_1 = require("./operators");
 const use_memo_1 = require("./use-memo");
-function use(fn) {
+function withMemo(fn) {
     (0, module_1.throwWithContext)();
     const uniqueId = (0, uuid_1.v4)();
     return (...args) => (0, use_memo_1.useMemo)(() => {
         const value = fn(...args);
         if ((0, rxjs_1.isObservable)(value)) {
-            return value.pipe((0, as_readonly_1.asReadonly)(), (0, rxjs_1.shareReplay)(1));
+            return value.pipe((0, operators_1.asReadonly)(), (0, rxjs_1.shareReplay)(1));
         }
         return value;
     }, [uniqueId, ...args]);
 }
-exports.use = use;

package/lib/with-memo.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=with-memo.spec.d.ts.map

package/lib/with-memo.spec.d.ts.map

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

package/{dist/use.spec.js → lib/with-memo.spec.js}

@@ -11,8 +11,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 instrument_1 = require("./instrument");
-const use_1 = require("./use");
-describe(use_1.use.name, () => {
+const with_memo_1 = require("./with-memo");
+describe(with_memo_1.withMemo.name, () => {
     let fixtures;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         fixtures = yield getFixtures();
@@ -38,7 +38,7 @@ describe(use_1.use.name, () => {
 function getFixtures() {
     return __awaiter(this, void 0, void 0, function* () {
         const { act } = yield (0, make_test_module_1.makeTestModule)([]);
-        const getValue = (0, use_1.use)((instrument) => instrument.id);
+        const getValue = (0, with_memo_1.withMemo)((instrument) => instrument.id);
         return {
             act,
             getValue: act(() => (instrument) => getValue(instrument))

package/{dist/use-request.d.ts → lib/with-request.d.ts}

@@ -1,16 +1,16 @@
+import { Observable } from 'rxjs';
 export type RequestMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
 export declare class RequestNetworkError extends Error {
     readonly statusCode: number;
-    readonly json: () => Promise<string>;
-    constructor(statusCode: number, json: () => Promise<string>);
+    constructor(statusCode: number);
 }
-export declare function useRequest(args: {
+export declare function withRequest({ method, url, headers, body }: {
     method: RequestMethod;
     url: string;
     headers?: Record<string, any>;
     body?: string;
-}): import("rxjs").Observable<{
+}): Observable<{
     timestamp: number;
-    payload: any;
+    payload: unknown;
 }>;
-//# sourceMappingURL=use-request.d.ts.map
+//# sourceMappingURL=with-request.d.ts.map

package/lib/with-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-request.d.ts","sourceRoot":"","sources":["../src/with-request.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAMlC,MAAM,MAAM,aAAa,GACrB,KAAK,GACL,MAAM,GACN,MAAM,GACN,KAAK,GACL,QAAQ,GACR,SAAS,GACT,SAAS,GACT,OAAO,GACP,OAAO,CAAC;AAEZ,qBAAa,mBAAoB,SAAQ,KAAK;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAGxC;AAED,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,GAAG,EACH,OAAO,EACP,IAAI,EACL,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;eAGoC,MAAM;aAAW,OAAO;GA6C5D"}

package/lib/with-request.js

@@ -0,0 +1,68 @@
+"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.RequestNetworkError = void 0;
+exports.withRequest = withRequest;
+const node_crypto_1 = require("node:crypto");
+const rxjs_1 = require("rxjs");
+const undici_1 = require("undici");
+const use_logger_1 = require("./use-logger");
+const use_timestamp_1 = require("./use-timestamp");
+class RequestNetworkError extends Error {
+    constructor(statusCode) {
+        super(`Request network error, received status code: ${statusCode}`);
+        this.statusCode = statusCode;
+    }
+}
+exports.RequestNetworkError = RequestNetworkError;
+function withRequest({ method, url, headers, body }) {
+    const { error, debug } = (0, use_logger_1.useLogger)(withRequest.name);
+    return new rxjs_1.Observable(subscriber => {
+        const correlationId = (0, node_crypto_1.randomUUID)();
+        debug('requesting', { correlationId, method, url, headers, body });
+        (0, undici_1.request)(url, { method, headers, body })
+            .then((_a) => __awaiter(this, [_a], void 0, function* ({ statusCode, body }) {
+            const json = yield body.json();
+            debug('received', {
+                correlationId,
+                method,
+                url,
+                headers,
+                body: json,
+                statusCode
+            });
+            if (statusCode !== 200) {
+                error(`errored`, {
+                    method,
+                    url,
+                    headers,
+                    body,
+                    statusCode
+                });
+                subscriber.error(new RequestNetworkError(statusCode));
+            }
+            else {
+                subscriber.next({ timestamp: (0, use_timestamp_1.useTimestamp)(), payload: json });
+            }
+        }))
+            .catch((e) => {
+            error(`errored`, {
+                method,
+                url,
+                headers,
+                body,
+                error: e
+            });
+            subscriber.error(error);
+        })
+            .finally(() => subscriber.complete());
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantform/core",
-  "version": "0.7.0-beta.8",
+  "version": "0.7.9",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",
@@ -12,10 +12,10 @@
     "access": "public"
   },
   "bin": {
-    "qf": "./dist/cli/index.js"
+    "qf": "./lib/cli/index.js"
   },
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "dependencies": {
     "@swc/cli": "^0.1.62",
     "@swc/core": "^1.3.44",
@@ -37,7 +37,7 @@
     "rxjs": "^7.8.0"
   },
   "peerDependencies": {
-    "rxjs": "^7.5.6"
+    "rxjs": "^7.8.0"
   },
   "scripts": {
     "build": "tsc && tsc-alias",

package/src/asset/asset.ts

@@ -3,6 +3,12 @@ import { d, decimal } from '@lib/shared';
 
 export const AssetSelectorSeparator = ':';
 
+export class MissingAssetError extends Error {
+  constructor(asset: AssetSelector) {
+    super(`Missing asset: ${asset}`);
+  }
+}
+
 /**
  * Supposed to query specific @see Asset based on string notation.
  */

package/src/cli/index.ts

@@ -5,10 +5,10 @@ import { program } from 'commander';
 import watch from 'node-watch';
 
 import build from '@lib/cli/build';
-import dev from '@lib/cli/dev';
+import live from '@lib/cli/live';
+import paper from '@lib/cli/paper';
 import pull from '@lib/cli/pull';
-import test from '@lib/cli/replay';
-import run from '@lib/cli/run';
+import replay from '@lib/cli/replay';
 
 program
   .command('build')
@@ -18,29 +18,32 @@ program
   });
 
 program
-  .command('run')
+  .command('live')
   .argument('<name>', 'strategy to execute')
   .option('-i, --id <id>', 'session identifier')
+  .option('-r, --recording', 'recording mode for replay purposes')
   .option('-w', 'watch mode')
   .description('executes strategy in live trading mode')
-  .action(run);
+  .action(live);
 
 program
-  .command('dev')
+  .command('paper')
   .argument('<name>', 'strategy to execute')
   .option('-i, --id <id>', 'session identifier')
+  .option('-r, --recording', 'recording mode for replay purposes')
   .option('-w', 'watch mode')
   .description('executes strategy in paper e.g. simulation mode')
-  .action(dev);
+  .action(paper);
 
 program
   .command('replay')
   .description('executes strategy in backtesting mode for specified period')
   .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
   .option('-f, --from <from>', 'date from')
   .option('-t, --to <to>', 'date to')
   .option('-w', 'watch mode')
-  .action(test);
+  .action(replay);
 
 program
   .command('pull')

package/src/cli/internal/script.ts

@@ -0,0 +1,70 @@
+import { join } from 'path';
+import {
+  catchError,
+  finalize,
+  firstValueFrom,
+  forkJoin,
+  fromEvent,
+  last,
+  merge,
+  of,
+  switchMap,
+  take
+} from 'rxjs';
+
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+import { whenReplayFinished } from '@lib/replay';
+import { strategy } from '@lib/strategy';
+
+import { buildDirectory } from './workspace';
+
+export class Script {
+  constructor(
+    private readonly filename: string,
+    private readonly dependencies: Dependency[]
+  ) {}
+
+  async run() {
+    const script = await import(join(buildDirectory(), this.filename));
+
+    const { dependencies, description } = script.default as ReturnType<typeof strategy>;
+
+    const module = new Module([...core(), ...dependencies, ...this.dependencies]);
+
+    const { act } = await module.awake();
+
+    return await act(() => {
+      process.stdin.resume();
+
+      return firstValueFrom(
+        merge(
+          forkJoin(description.before.map(before => before()))
+            .pipe(
+              switchMap(() =>
+                forkJoin(description.behavior.map(behavior => behavior())).pipe(last())
+              )
+            )
+            .pipe(last()),
+          whenReplayFinished().pipe(last()),
+          fromEvent(process, 'exit'),
+          fromEvent(process, 'SIGINT'),
+          fromEvent(process, 'SIGUSR1'),
+          fromEvent(process, 'SIGUSR2'),
+          fromEvent(process, 'uncaughtException')
+        ).pipe(
+          catchError(e => {
+            console.error(e);
+
+            return of(e);
+          }),
+          take(1),
+          switchMap(
+            it => forkJoin(description.after.map(after => after())).pipe(last()) ?? of(it)
+          ),
+          finalize(() => process.exit(0))
+        )
+      );
+    });
+  }
+}

package/src/cli/live.ts

@@ -0,0 +1,22 @@
+import build from '@lib/cli/build';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
+
+export default async function (
+  name: string,
+  options: { id?: string; recording?: boolean }
+) {
+  if (await build()) {
+    return;
+  }
+
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    useExecutionMode.liveOptions({ recording: options.recording ?? false })
+  ]);
+  const output = await script.run();
+
+  console.log(output);
+}

package/src/cli/paper.ts

@@ -0,0 +1,22 @@
+import build from '@lib/cli/build';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
+
+export default async function (
+  name: string,
+  options: { id?: string; recording?: boolean }
+) {
+  if (await build()) {
+    return;
+  }
+
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    useExecutionMode.paperOptions({ recording: options.recording ?? false })
+  ]);
+  const output = await script.run();
+
+  console.log(output);
+}

package/src/cli/pull.ts

@@ -1,75 +1,15 @@
-import { join } from 'path';
-
 import build from '@lib/cli/build';
-import { buildDirectory } from '@lib/cli/internal/workspace';
-import { core } from '@lib/core';
-import { Module } from '@lib/module';
-import { strat } from '@lib/strat';
-import { paperExecutionMode } from '@lib/use-execution-mode';
-import { token } from '@lib/use-memo';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
 
 export default async function (name: string, instrument: string, options: any) {
   if (await build()) {
     return;
   }
-  await import(join(buildDirectory(), 'index'));
-
-  const script = (await import(join(buildDirectory(), name))) as ReturnType<typeof strat>;
-
-  const module = new Module([
-    ...core(),
-    ...script.dependencies,
-    paperExecutionMode({ recording: false })
-  ]);
-
-  const { act } = await module.awake();
-
-  const o = await act(() => script.fn());
-  console.log(module.get<any>(token));
-
-  /*const builder = new SessionBuilder().useSessionId(
-    options.id ? Number(options.id) : now()
-  );
-
-  await spawn(name, builder);
-
-  const session = builder.paper();
-
-  console.time('Pulling completed in');
-
-  await session.awake();
-
-  const bar = new SingleBar(
-    {
-      format: `Pulling ${instrument} [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}`
-    },
-    Presets.rect
-  );
-
-  const feed = new Feed(builder.storage('feed'));
-  const from = options.from ? Date.parse(options.from) : builder.period.from;
-  const to = options.to ? Date.parse(options.to) : builder.period.to;
-
-  bar.start(100, 0);
-
-  await session.aggregate.feed(
-    instrumentOf(instrument),
-    from,
-    to,
-    async (timestamp, events) => {
-      const duration = to - from;
-      const completed = timestamp - from;
-
-      await feed.save(events);
-
-      bar.update(Math.floor((completed / duration) * 100));
-    }
-  );
-
-  bar.update(100);
-  bar.stop();
 
-  await session.dispose();
+  const script = new Script(name, [useExecutionMode.idleOptions()]);
+  //const output = await script.run();
 
-  console.timeLog('Pulling completed in');*/
+  //console.log(output);
 }