@alphafox/cli 0.3.2 → 0.3.4

package/dist/engine-backtest/persist.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SNAPSHOT_SCHEMA_VERSION = exports.DEFAULT_EXECUTION_MODEL = void 0;
+exports.ENGINE_BACKTEST_SWEEP_ERROR_MAX_UTF8_BYTES = exports.ENGINE_BACKTEST_SWEEP_MAX_UTF8_BYTES = exports.SNAPSHOT_SCHEMA_VERSION = exports.DEFAULT_EXECUTION_MODEL = void 0;
 exports.exclusiveTapeEndToRangeEnd = exclusiveTapeEndToRangeEnd;
 exports.uniqueSeriesField = uniqueSeriesField;
 exports.buildCreateRunRequest = buildCreateRunRequest;
 exports.experimentPageUrl = experimentPageUrl;
+exports.experimentSweepPageUrl = experimentSweepPageUrl;
+exports.shouldPersistSweepCompletion = shouldPersistSweepCompletion;
+exports.mintClientSweepId = mintClientSweepId;
+exports.sweepsPath = sweepsPath;
+exports.buildSweepBaseSnapshot = buildSweepBaseSnapshot;
+exports.buildCreateSweepRequest = buildCreateSweepRequest;
+exports.assertSweepCreateRequestSize = assertSweepCreateRequestSize;
 const errors_1 = require("./errors");
+const return_curve_1 = require("./return-curve");
 /** Aligned with `@alphafoxai/backtest-runner` DEFAULT_EXECUTION_MODEL. */
 exports.DEFAULT_EXECUTION_MODEL = {
     pricePath: "ohlc_path_4",
@@ -69,12 +77,17 @@ function buildCreateRunRequest(input) {
         positionSideDual: scenario.exchange.positionSideDual,
         engineVersion,
     };
+    const returnCurve = (0, return_curve_1.compressEngineBacktestReturnCurve)({
+        initialEquity: snapshot.initialEquity,
+        equityCurve: input.equityCurve,
+    });
     return {
         clientRunId: input.clientRunId,
         snapshot,
         metrics: input.metrics,
         engineVersion,
         configSchemaVersion: snapshot.configSchemaVersion,
+        ...(returnCurve ? { returnCurve } : {}),
     };
 }
 /**
@@ -92,3 +105,185 @@ function experimentPageUrl(profile, experimentId) {
     }
     return `https://alphafox.app${path}`;
 }
+/** Web experiment workspace opens the Sweep tab with `?tab=sweep`. */
+function experimentSweepPageUrl(profile, experimentId) {
+    return `${experimentPageUrl(profile, experimentId)}?tab=sweep`;
+}
+exports.ENGINE_BACKTEST_SWEEP_MAX_UTF8_BYTES = 4 * 1024 * 1024;
+exports.ENGINE_BACKTEST_SWEEP_ERROR_MAX_UTF8_BYTES = 4 * 1024;
+const CLIENT_SWEEP_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function shouldPersistSweepCompletion(input) {
+    return input.completed && !input.cancelled;
+}
+function mintClientSweepId(randomUuid = () => globalThis.crypto.randomUUID()) {
+    const allocated = randomUuid();
+    if (!CLIENT_SWEEP_ID_RE.test(allocated)) {
+        throw new errors_1.EngineBacktestError({
+            type: "runtime",
+            subtype: "invalid_client_sweep_id",
+            message: "clientSweepId must be a UUID.",
+        });
+    }
+    return allocated;
+}
+function sweepsPath(experimentId) {
+    return `/api/v1/engine-backtest/experiments/${encodeURIComponent(experimentId)}/sweeps`;
+}
+function buildSweepBaseSnapshot(input) {
+    const symbols = [...new Set(input.symbols.map((item) => item.trim()).filter(Boolean))];
+    if (symbols.length === 0) {
+        throw new errors_1.EngineBacktestError({
+            type: "runtime",
+            subtype: "persist_no_symbols",
+            message: "Completed sweep has no symbols to persist.",
+        });
+    }
+    const timeframes = [
+        ...new Set(input.timeframes.map((item) => item.trim()).filter(Boolean)),
+    ];
+    return {
+        snapshotSchemaVersion: exports.SNAPSHOT_SCHEMA_VERSION,
+        strategyDefinitionId: input.definitionId,
+        configSchemaVersion: input.configSchemaVersion,
+        config: input.config,
+        exchangeId: input.exchangeId.trim() || "binance",
+        rangeStart: input.rangeStart,
+        rangeEnd: input.rangeEnd,
+        initialEquity: input.initialEquity,
+        subscriptionTier: input.subscriptionTier,
+        dataQualityMode: input.dataQualityMode,
+        symbols,
+        timeframes: timeframes.length > 0 ? timeframes : ["1m"],
+        baseTimeframe: input.baseTimeframe.trim() || "1m",
+        executionModel: input.executionModel,
+        positionSideDual: input.positionSideDual,
+        engineVersion: input.engineVersion.trim() || "node-wasm",
+    };
+}
+/**
+ * Build POST .../sweeps body from a completed local search.
+ * Field set matches web `buildCreateSweepRequestFromCompleted`.
+ */
+function buildCreateSweepRequest(input) {
+    const clientSweepId = mintClientSweepId(() => input.clientSweepId);
+    const axes = input.axes.map((axis, axisIndex) => ({
+        path: [...axis.path],
+        current: axis.current,
+        values: uniqueFiniteNumbers(input.points.map((point) => point.coordinate.values[axisIndex]), axis.current),
+    }));
+    const pointSummaries = input.points.map((point) => toPointSummary(point));
+    const body = {
+        clientSweepId,
+        baseInputSnapshot: input.snapshot,
+        axes,
+        searchMetadata: {
+            mode: input.mode,
+            searchMode: input.searchMode,
+            concurrency: input.concurrency,
+            requestedCombinationCount: input.requestedCombinationCount,
+            sampled: input.sampled,
+        },
+        aggregateSummary: {
+            successfulCount: input.successfulCount,
+            failedCount: input.failedCount,
+            liquidatedCount: input.liquidatedCount,
+            elapsedMs: Math.max(0, Math.round(input.elapsedMs)),
+            best: input.best
+                ? {
+                    coordinate: { values: [...input.best.coordinate.values] },
+                    returnPct: input.best.returnPct,
+                }
+                : null,
+        },
+        pointSummaries,
+        engineVersion: input.engineVersion.trim() || input.snapshot.engineVersion,
+        configSchemaVersion: input.snapshot.configSchemaVersion,
+    };
+    assertSweepCreateRequestSize(body);
+    return body;
+}
+function toPointSummary(row) {
+    const coordinate = { values: [...row.coordinate.values] };
+    if (row.status === "ok" && row.metrics) {
+        return {
+            coordinate,
+            status: "ok",
+            metrics: {
+                returnPct: row.metrics.returnPct,
+                maxDrawdownPct: row.metrics.maxDrawdownPct,
+                sharpeRatio: row.metrics.sharpeRatio,
+                winRatePct: row.metrics.winRatePct,
+                liquidationCount: row.metrics.liquidationCount,
+                netPnl: row.metrics.netPnl,
+                finalEquity: row.metrics.finalEquity,
+                tradeCount: row.metrics.tradeCount,
+                ...(typeof row.metrics.maxLeverage === "number" &&
+                    Number.isFinite(row.metrics.maxLeverage)
+                    ? { maxLeverage: row.metrics.maxLeverage }
+                    : {}),
+            },
+        };
+    }
+    return {
+        coordinate,
+        status: "failed",
+        error: truncateUtf8(row.error?.trim() || "Point failed", exports.ENGINE_BACKTEST_SWEEP_ERROR_MAX_UTF8_BYTES),
+    };
+}
+function uniqueFiniteNumbers(values, fallback) {
+    const unique = new Set();
+    for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            unique.add(value);
+        }
+    }
+    if (unique.size === 0) {
+        unique.add(fallback);
+    }
+    return [...unique].sort((left, right) => left - right);
+}
+function truncateUtf8(value, maxBytes) {
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.length <= maxBytes) {
+        return value;
+    }
+    return new TextDecoder("utf-8", { fatal: false })
+        .decode(bytes.slice(0, maxBytes))
+        .replace(/\uFFFD$/u, "");
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).length;
+}
+function assertSweepCreateRequestSize(body) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(body);
+    }
+    catch {
+        throw new errors_1.EngineBacktestError({
+            type: "usage",
+            subtype: "sweep_invalid",
+            message: "Sweep create request is not JSON-serializable.",
+            status: 400,
+        });
+    }
+    if (utf8ByteLength(serialized) > exports.ENGINE_BACKTEST_SWEEP_MAX_UTF8_BYTES) {
+        throw new errors_1.EngineBacktestError({
+            type: "usage",
+            subtype: "sweep_too_large",
+            message: `Sweep create request exceeds ${exports.ENGINE_BACKTEST_SWEEP_MAX_UTF8_BYTES} UTF-8 bytes.`,
+            status: 400,
+        });
+    }
+    for (const [index, point] of body.pointSummaries.entries()) {
+        if (point.error !== undefined &&
+            utf8ByteLength(point.error) > exports.ENGINE_BACKTEST_SWEEP_ERROR_MAX_UTF8_BYTES) {
+            throw new errors_1.EngineBacktestError({
+                type: "usage",
+                subtype: "sweep_too_large",
+                message: `Sweep point error text at index ${index} exceeds ${exports.ENGINE_BACKTEST_SWEEP_ERROR_MAX_UTF8_BYTES} UTF-8 bytes.`,
+                status: 400,
+            });
+        }
+    }
+}

package/dist/engine-backtest/return-curve.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Compact Engine Backtest Run return-curve contract.
+ * Must stay aligned with alphafox-web `domains/engine-backtest-return-curve.ts`.
+ *
+ * Stored shape: [[unix_ms, cumulative_return]]
+ * - timestamp: engine equity point `t`, Unix milliseconds
+ * - cumulative_return: (equity / initialEquity) - 1 (decimal ratio, not percent),
+ *   rounded to 10 decimal places
+ * - even-sample when longer than 4000: index = round(i * (n-1) / (limit-1))
+ */
+export declare const ENGINE_BACKTEST_RETURN_CURVE_MAX_POINTS = 4000;
+/** Must match alphafox-web `ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS`. */
+export declare const ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS = 10;
+export declare function roundCumulativeReturn(value: number): number;
+export type EngineBacktestReturnCurvePoint = readonly [number, number];
+export type EngineBacktestReturnCurve = readonly EngineBacktestReturnCurvePoint[];
+export interface EngineBacktestEquitySample {
+    readonly t: number;
+    readonly equity: number;
+}
+export declare function downsampleEvenlySpacedPoints<T>(points: readonly T[], limit: number): T[];
+export declare function readEquitySamples(value: unknown): EngineBacktestEquitySample[];
+export declare function compressEngineBacktestReturnCurve(input: {
+    readonly initialEquity: number;
+    readonly equityCurve: unknown;
+    readonly maxPoints?: number;
+}): EngineBacktestReturnCurve | undefined;

package/dist/engine-backtest/return-curve.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Compact Engine Backtest Run return-curve contract.
+ * Must stay aligned with alphafox-web `domains/engine-backtest-return-curve.ts`.
+ *
+ * Stored shape: [[unix_ms, cumulative_return]]
+ * - timestamp: engine equity point `t`, Unix milliseconds
+ * - cumulative_return: (equity / initialEquity) - 1 (decimal ratio, not percent),
+ *   rounded to 10 decimal places
+ * - even-sample when longer than 4000: index = round(i * (n-1) / (limit-1))
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS = exports.ENGINE_BACKTEST_RETURN_CURVE_MAX_POINTS = void 0;
+exports.roundCumulativeReturn = roundCumulativeReturn;
+exports.downsampleEvenlySpacedPoints = downsampleEvenlySpacedPoints;
+exports.readEquitySamples = readEquitySamples;
+exports.compressEngineBacktestReturnCurve = compressEngineBacktestReturnCurve;
+exports.ENGINE_BACKTEST_RETURN_CURVE_MAX_POINTS = 4_000;
+/** Must match alphafox-web `ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS`. */
+exports.ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS = 10;
+function roundCumulativeReturn(value) {
+    if (value === 0) {
+        return 0;
+    }
+    const factor = 10 ** exports.ENGINE_BACKTEST_RETURN_CURVE_RETURN_DECIMALS;
+    return Math.round(value * factor) / factor;
+}
+function downsampleEvenlySpacedPoints(points, limit) {
+    if (points.length <= limit) {
+        return [...points];
+    }
+    if (limit <= 1) {
+        return points[0] === undefined ? [] : [points[0]];
+    }
+    const lastIndex = points.length - 1;
+    const sampled = [];
+    let previousIndex = -1;
+    for (let slot = 0; slot < limit; slot += 1) {
+        const index = Math.round((slot * lastIndex) / (limit - 1));
+        if (index === previousIndex) {
+            continue;
+        }
+        sampled.push(points[index]);
+        previousIndex = index;
+    }
+    return sampled;
+}
+function readEquitySamples(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const samples = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const record = item;
+        const t = Number(record.t);
+        const equity = Number(record.equity);
+        if (!Number.isFinite(t) || !Number.isFinite(equity)) {
+            continue;
+        }
+        samples.push({ t, equity });
+    }
+    return samples;
+}
+function compressEngineBacktestReturnCurve(input) {
+    if (!Number.isFinite(input.initialEquity) || input.initialEquity <= 0) {
+        return undefined;
+    }
+    const samples = readEquitySamples(input.equityCurve);
+    if (samples.length === 0) {
+        return undefined;
+    }
+    const points = samples.map((sample) => [
+        sample.t,
+        roundCumulativeReturn(sample.equity / input.initialEquity - 1),
+    ]);
+    return downsampleEvenlySpacedPoints(points, input.maxPoints ?? exports.ENGINE_BACKTEST_RETURN_CURVE_MAX_POINTS);
+}

package/dist/engine-backtest/run-command.d.ts

@@ -2,6 +2,7 @@ import type { ApiRequestOptions, ApiResponse } from "../http/client";
 import { loadTokens } from "../keychain/store";
 import { type ResolvePackageHooks } from "./resolve-packages";
 import type { BacktestRunnerModule, BacktestWasmModule, EngineBacktestRunArgs, EngineBacktestRunSuccess } from "./types";
+export { loadConfigValue } from "./load-config";
 export interface EngineBacktestCliFlags {
     readonly profile?: string;
     readonly format: "json" | "jsonl" | "text";
@@ -25,10 +26,6 @@ export interface EngineBacktestRunDeps {
     readonly writeLine?: (value: unknown) => void;
     readonly resolveHooks?: ResolvePackageHooks;
 }
-export declare function loadConfigValue(raw: string, options?: {
-    readonly cwd?: string;
-    readonly readFile?: (path: string) => string;
-}): unknown;
 export declare function executeEngineBacktestRun(args: EngineBacktestRunArgs, flags: EngineBacktestCliFlags, env?: NodeJS.ProcessEnv, deps?: EngineBacktestRunDeps): Promise<EngineBacktestRunSuccess>;
 export declare function engineBacktestHelpData(): {
     readonly name: string;

package/dist/engine-backtest/run-command.js

@@ -1,21 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConfigValue = loadConfigValue;
+exports.loadConfigValue = void 0;
 exports.executeEngineBacktestRun = executeEngineBacktestRun;
 exports.engineBacktestHelpData = engineBacktestHelpData;
 exports.cmdEngineBacktest = cmdEngineBacktest;
 const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const profiles_1 = require("../config/profiles");
 const envelope_1 = require("../envelope");
 const client_1 = require("../http/client");
 const store_1 = require("../keychain/store");
 const errors_1 = require("./errors");
+const load_config_1 = require("./load-config");
 const parse_args_1 = require("./parse-args");
+const sweep_command_1 = require("./sweep-command");
 const persist_1 = require("./persist");
 const replay_timeframe_1 = require("./replay-timeframe");
 const resolve_packages_1 = require("./resolve-packages");
+var load_config_2 = require("./load-config");
+Object.defineProperty(exports, "loadConfigValue", { enumerable: true, get: function () { return load_config_2.loadConfigValue; } });
 const CREATE_EXPERIMENT_PATH = "/api/v1/engine-backtest/experiments";
 const SUBSCRIPTION_PATH = "/api/v1/subscriptions/me";
 const SUBSCRIPTION_TIERS = new Set([
@@ -26,44 +28,6 @@ const SUBSCRIPTION_TIERS = new Set([
 function runsPath(experimentId) {
     return `/api/v1/engine-backtest/experiments/${encodeURIComponent(experimentId)}/runs`;
 }
-function loadConfigValue(raw, options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const read = options.readFile ?? ((p) => (0, node_fs_1.readFileSync)(p, "utf8"));
-    if (raw.startsWith("@")) {
-        const rel = raw.slice(1);
-        if (!rel) {
-            throw new errors_1.EngineBacktestError({
-                type: "usage",
-                subtype: "missing_config",
-                message: "--config @path is empty",
-                status: 400,
-            });
-        }
-        const abs = (0, node_path_1.isAbsolute)(rel) ? rel : (0, node_path_1.resolve)(cwd, rel);
-        try {
-            return JSON.parse(read(abs));
-        }
-        catch (err) {
-            throw new errors_1.EngineBacktestError({
-                type: "usage",
-                subtype: "invalid_config",
-                message: `Cannot read --config file ${abs}: ${err instanceof Error ? err.message : String(err)}`,
-                status: 400,
-            });
-        }
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new errors_1.EngineBacktestError({
-            type: "usage",
-            subtype: "invalid_config",
-            message: "--config must be JSON or @path-to.json",
-            status: 400,
-        });
-    }
-}
 function extractErrorMessage(json, fallback) {
     if (json && typeof json === "object") {
         const o = json;
@@ -227,7 +191,7 @@ async function executeEngineBacktestRun(args, flags, env = process.env, deps = {
     if (needsApi) {
         requireAuth(profile, env, tokensFn);
     }
-    const config = loadConfigValue(args.configRaw, {
+    const config = (0, load_config_1.loadConfigValue)(args.configRaw, {
         cwd: deps.cwd,
         readFile: deps.readFile,
     });
@@ -433,6 +397,7 @@ async function executeEngineBacktestRun(args, flags, env = process.env, deps = {
                 exchangeId: exchange.id,
                 dataQualityMode: args.dataQualityMode,
                 engineVersion,
+                equityCurve: result.equityCurve,
             });
             const res = await postJson(api, profile, env, runsPath(experimentId), body, mintId);
             persistedRunId = extractEntityId(res.json);
@@ -464,10 +429,13 @@ function engineBacktestHelpData() {
         name: "engine-backtest",
         usage: [
             ...parse_args_1.ENGINE_BACKTEST_RUN_USAGE,
+            ...parse_args_1.ENGINE_BACKTEST_SWEEP_USAGE,
             "Catalog CRUD (underscore domain): alphafox engine_backtest experiments list|create|...",
         ],
         notes: [
-            "Local WASM run is hyphenated engine-backtest so it does not steal typed catalog engine_backtest.*",
+            "Local WASM run/sweep is hyphenated engine-backtest so it does not steal typed catalog engine_backtest.*",
+            "Sweep persist POSTs engine_backtest.experiments.byId.sweeps.create once after local completion; --no-persist writes nothing",
+            "sweeps.create is write (not high-risk-write); sweeps.byId.delete is high-risk-write and needs --yes",
             "runs.create is write (not high-risk-write); --yes is not required",
             "Do not pass --token; use alphafox auth login",
             "--replay-timeframe defaults to 1m (min 1m). Indicator series still download their native plan timeframes.",
@@ -486,14 +454,17 @@ async function cmdEngineBacktest(args, flags, env = process.env, deps = {}) {
         });
         return 0;
     }
-    if (sub !== "run") {
+    if (sub !== "run" && sub !== "sweep") {
         (0, envelope_1.writeError)({
             type: "usage",
             subtype: "unknown_subcommand",
             message: `Unknown engine-backtest subcommand "${sub}"`,
-            hint: "Local WASM: alphafox engine-backtest run. Catalog CRUD: alphafox engine_backtest experiments list",
+            hint: "Local WASM: alphafox engine-backtest run|sweep. Catalog CRUD: alphafox engine_backtest experiments list",
         });
     }
+    if (sub === "sweep") {
+        return await invokeSweep(rest, flags, env, deps);
+    }
     let parsed;
     try {
         parsed = (0, parse_args_1.parseEngineBacktestRunArgs)(rest);
@@ -538,3 +509,48 @@ async function cmdEngineBacktest(args, flags, env = process.env, deps = {}) {
         throw err;
     }
 }
+async function invokeSweep(rest, flags, env, deps) {
+    let parsed;
+    try {
+        parsed = (0, parse_args_1.parseEngineBacktestSweepArgs)(rest);
+    }
+    catch (err) {
+        if ((0, errors_1.isEngineBacktestError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+    if (parsed.help) {
+        (0, envelope_1.writeSuccess)(engineBacktestHelpData(), {
+            format: flags.format,
+            jq: flags.jq,
+        });
+        return 0;
+    }
+    try {
+        const result = await (0, sweep_command_1.executeEngineBacktestSweep)(parsed, flags, env, deps);
+        (0, envelope_1.writeSuccess)(result, { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    catch (err) {
+        if ((0, errors_1.isEngineBacktestError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                code: err.code,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+}

package/dist/engine-backtest/sweep-command.d.ts

@@ -0,0 +1,13 @@
+import type { EngineBacktestCliFlags, EngineBacktestRunDeps } from "./run-command";
+import type { EngineBacktestSweepArgs, EngineBacktestSweepSuccess } from "./types";
+/** WASM `runBacktestBatch` hard limit. Keep in sync with Engine. */
+export declare const MAX_ENGINE_BACKTEST_BATCH_VARIANTS = 256;
+/** Sweep chunk size: below the 256 cap so JSONL can refresh mid-search. */
+export declare const SWEEP_WASM_BATCH_VARIANTS = 32;
+export interface EngineBacktestSweepDeps extends EngineBacktestRunDeps {
+    readonly maxVariantsPerBatch?: number;
+    readonly now?: () => number;
+}
+export declare function cloneTapeBuffers(sourceBuffers: Readonly<Record<string, ArrayBuffer>>): Record<string, ArrayBuffer>;
+export declare function splitBatchChunk<T>(chunk: readonly T[], maxVariants?: number): T[][];
+export declare function executeEngineBacktestSweep(args: EngineBacktestSweepArgs, flags: EngineBacktestCliFlags, env?: NodeJS.ProcessEnv, deps?: EngineBacktestSweepDeps): Promise<EngineBacktestSweepSuccess>;