desic-okx-agent 0.2.1 → 0.3.0

package/dist/strategy/service.js

@@ -0,0 +1,745 @@
+import crypto from "node:crypto";
+import os from "node:os";
+import { RuntimeError } from "../core/errors.js";
+import { resultMeta } from "../core/types.js";
+import { ONE_MINUTE_MS, alignMinuteOpen, expectedBarCount } from "../bars/types.js";
+import { isSupportedInterval } from "../bars/timeframe.js";
+import { engineRoot, pythonStatus, setupPythonEnvironment } from "./environment.js";
+import { loadContractSpec } from "./instrument.js";
+import { loadSettings, resetSettings, saveSettings, withSetting } from "./settings.js";
+import { invokePython } from "./python-bridge.js";
+import { requireRun } from "./store.js";
+import { DEFAULT_BUDGET, MAX_BUDGET, countCombinations, describeSpace, parseParameterSpace, sampleCandidates } from "./parameter-space.js";
+import { rankCandidate, splitWindow, verdictFor } from "./optimize.js";
+import { buildComparison } from "../report/compare.js";
+import { MAX_PAGE_ROWS } from "./constants.js";
+/**
+ * A backtest may not end inside the last hour.
+ *
+ * The most recent minutes are the ones an exchange is most likely to revise, so
+ * excluding them keeps a run reproducible.
+ */
+const MINIMUM_END_LAG_MS = 60 * 60_000;
+const MAX_EVALUATION_DAYS = 365;
+const MAX_BACKTEST_BARS = 600_000;
+const DEFAULT_EVALUATION_DAYS = 30;
+const MINIMUM_PRELOAD_BARS = 2;
+export class StrategyService {
+    store;
+    bars;
+    market;
+    maxWorkers;
+    now;
+    injectedSettings;
+    active = new Map();
+    queue = [];
+    running = 0;
+    constructor(store, bars, 
+    /**
+     * Source of contract specifications. Optional so a test can construct the
+     * service without a market runtime; a run then fails with a clear message
+     * rather than falling back to a guessed contract size.
+     */
+    market, maxWorkers = defaultWorkerCount(), now = Date.now, 
+    /** Test seam: bypasses the settings file so a run is reproducible. */
+    injectedSettings) {
+        this.store = store;
+        this.bars = bars;
+        this.market = market;
+        this.maxWorkers = maxWorkers;
+        this.now = now;
+        this.injectedSettings = injectedSettings;
+    }
+    /** Reports interpreter availability without changing anything. */
+    async environment() {
+        return { data: await pythonStatus(), meta: resultMeta({ source: "derived" }) };
+    }
+    async setupEnvironment(onLog) {
+        const result = await setupPythonEnvironment(onLog);
+        const status = await pythonStatus();
+        return {
+            data: { ...result, status },
+            meta: resultMeta({ source: "derived" })
+        };
+    }
+    /** Saved settings, or the injected ones when a caller supplied them. */
+    settings() {
+        return this.injectedSettings ?? loadSettings();
+    }
+    readSettings() {
+        return { data: this.settings(), meta: resultMeta({ source: "derived" }) };
+    }
+    /**
+     * Applies saved settings. Unknown keys and out-of-range values are rejected
+     * rather than ignored: a silently dropped change means the next run uses
+     * assumptions the caller believes it changed.
+     */
+    updateSettings(values, reset = false) {
+        let current = reset ? resetSettings() : this.settings();
+        for (const [key, value] of Object.entries(values)) {
+            current = withSetting(current, key, value).settings;
+        }
+        saveSettings(current);
+        return { data: current, meta: resultMeta({ source: "derived" }) };
+    }
+    /** Static policy check. Fast enough to run on every edit. */
+    async validate(source) {
+        const status = await this.requireInterpreter();
+        const response = await invokePython({
+            interpreter: status.interpreter,
+            engineRoot: status.engineRoot,
+            request: { command: "validate", source },
+            timeoutMs: 30_000
+        });
+        if (!response.ok)
+            throw pythonError(response);
+        return {
+            data: {
+                valid: Boolean(response.valid),
+                violations: response.violations ?? []
+            },
+            meta: resultMeta({ source: "derived" })
+        };
+    }
+    /**
+     * Queues a backtest and returns immediately.
+     *
+     * A run can take minutes, so the caller polls `getRun` rather than holding a
+     * request open and risking a client-side timeout.
+     */
+    async startBacktest(request) {
+        if (typeof request.source !== "string" || !request.source.trim()) {
+            throw new RuntimeError("VALIDATION", "A backtest requires strategy source");
+        }
+        const status = await this.requireInterpreter();
+        const validation = await this.validate(request.source);
+        if (!validation.data.valid) {
+            throw new RuntimeError("VALIDATION", "Strategy source failed the static policy check", false, {
+                violations: validation.data.violations
+            });
+        }
+        const id = this.store.createRun({
+            kind: "backtest",
+            strategyName: request.strategyName?.trim() || "strategy",
+            source: request.source,
+            instId: request.instId,
+            request
+        });
+        const controller = new AbortController();
+        this.active.set(id, { id, controller });
+        this.enqueue(async () => {
+            try {
+                await this.execute(id, request, status, controller.signal);
+            }
+            finally {
+                this.active.delete(id);
+            }
+        });
+        return { data: { runId: id, status: "queued" }, meta: resultMeta({ source: "derived" }) };
+    }
+    /**
+     * Queues a parameter search and returns immediately.
+     *
+     * The space is validated against the strategy's own declared parameters before
+     * anything is queued, so a range naming a parameter the strategy never reads
+     * fails at the prompt rather than after every candidate has run identically.
+     */
+    async startOptimize(request) {
+        if (typeof request.source !== "string" || !request.source.trim()) {
+            throw new RuntimeError("VALIDATION", "An optimization requires strategy source");
+        }
+        // Host-side checks first. They need no interpreter, so a malformed space, an
+        // impossible budget, or too short a window is rejected in microseconds instead
+        // of after a process spawn. Everything here is also resolved before queuing:
+        // discovering any of it later would leave a failed run where a rejected
+        // request belonged.
+        const space = parseParameterSpace(request.space, request.params ?? {});
+        const budget = resolveBudget(request.budget);
+        const candidates = sampleCandidates(space, budget);
+        const window = this.resolveWindow(request);
+        const split = splitWindow(window.evaluationStart, window.evaluationEnd);
+        const status = await this.requireInterpreter();
+        const validation = await this.validate(request.source);
+        if (!validation.data.valid) {
+            throw new RuntimeError("VALIDATION", "Strategy source failed the static policy check", false, {
+                violations: validation.data.violations
+            });
+        }
+        const id = this.store.createRun({
+            kind: "optimize",
+            strategyName: request.strategyName?.trim() || "strategy",
+            source: request.source,
+            instId: request.instId,
+            request: { ...request, space, budget, resolvedCandidates: candidates.length }
+        });
+        this.store.seedCandidates(id, candidates);
+        const controller = new AbortController();
+        this.active.set(id, { id, controller });
+        this.enqueue(async () => {
+            try {
+                await this.executeOptimize(id, request, space, candidates, split, status, controller.signal);
+            }
+            finally {
+                this.active.delete(id);
+            }
+        });
+        return { data: { runId: id, status: "queued" }, meta: resultMeta({ source: "derived" }) };
+    }
+    /**
+     * Ranked candidates for one optimize run.
+     *
+     * Ranking is by the held-back segment, never the searched one. The winner's
+     * ranking basis is reported alongside, because Calmar is unavailable on short
+     * windows and a column that silently changes meaning is worse than a labelled
+     * one.
+     */
+    optimization(id, top = 20) {
+        const run = requireRun(this.store, id);
+        if (run.kind !== "optimize") {
+            throw new RuntimeError("VALIDATION", `${id} is a ${run.kind} run, not an optimization`);
+        }
+        const stored = (this.store.runRequest(id) ?? {});
+        const space = stored.space ?? {};
+        const candidates = this.store.candidates(id, top);
+        const counts = this.store.candidateCounts(id);
+        const leader = candidates.find((candidate) => candidate.status === "completed");
+        return {
+            data: {
+                run,
+                space,
+                budget: stored.budget ?? counts.total,
+                combinations: Object.keys(space).length ? countCombinations(space) : counts.total,
+                split: splitFromAssumptions(run.assumptions),
+                candidates,
+                completed: counts.completed,
+                failed: counts.failed,
+                rankBasis: leader?.rankBasis ?? null
+            },
+            meta: resultMeta({ source: "sqlite" })
+        };
+    }
+    /**
+     * Compares completed runs.
+     *
+     * The equity curves are read whole here rather than paged: a comparison is
+     * summary-level, and the curves are downsampled before they leave. The response
+     * carries metrics, the assumptions that differ, and the warnings — not the
+     * curves, which would bury an agent's context for no benefit.
+     */
+    compareRuns(runIds) {
+        const runs = runIds.map((runId) => ({
+            run: requireRun(this.store, runId),
+            // A run that never completed has no curve. It stays in the comparison so the
+            // report can say why, rather than silently dropping it.
+            equity: this.store.equity(runId, 0, MAX_PAGE_ROWS).rows
+        }));
+        const { series: _series, ...rest } = buildComparison({ runs });
+        return { data: rest, meta: resultMeta({ source: "sqlite" }) };
+    }
+    getRun(id) {
+        return { data: requireRun(this.store, id), meta: resultMeta({ source: "sqlite" }) };
+    }
+    listRuns(options = {}) {
+        return { data: this.store.listRuns(options), meta: resultMeta({ source: "sqlite" }) };
+    }
+    equity(id, offset, limit) {
+        requireRun(this.store, id);
+        return { data: this.store.equity(id, offset, limit), meta: resultMeta({ source: "sqlite" }) };
+    }
+    trades(id, offset, limit) {
+        requireRun(this.store, id);
+        return { data: this.store.trades(id, offset, limit), meta: resultMeta({ source: "sqlite" }) };
+    }
+    actions(id, offset, limit) {
+        requireRun(this.store, id);
+        return { data: this.store.actions(id, offset, limit), meta: resultMeta({ source: "sqlite" }) };
+    }
+    cancel(id) {
+        requireRun(this.store, id);
+        const active = this.active.get(id);
+        active?.controller.abort();
+        return { data: { cancelled: this.store.cancelRun(id) }, meta: resultMeta({ source: "derived" }) };
+    }
+    deleteRun(id) {
+        requireRun(this.store, id);
+        this.active.get(id)?.controller.abort();
+        return { data: { deleted: this.store.deleteRun(id) }, meta: resultMeta({ source: "derived" }) };
+    }
+    /**
+     * Resolves the exact bar window a request describes.
+     *
+     * Preloaded history is context only: it warms up indicators and supplies the
+     * first decision point, and is excluded from every reported statistic.
+     */
+    resolveWindow(request) {
+        const latestAllowed = alignMinuteOpen(this.now() - MINIMUM_END_LAG_MS);
+        const evaluationEnd = request.toMs === undefined ? latestAllowed : Math.min(alignMinuteOpen(request.toMs), latestAllowed);
+        const evaluationStart = request.fromMs === undefined
+            ? evaluationEnd - (request.days ?? DEFAULT_EVALUATION_DAYS) * 1_440 * ONE_MINUTE_MS
+            : alignMinuteOpen(request.fromMs);
+        if (evaluationEnd <= evaluationStart) {
+            throw new RuntimeError("VALIDATION", "The backtest range must end after it starts", false, {
+                evaluationStart,
+                evaluationEnd,
+                latestAllowed
+            });
+        }
+        const evaluationDays = (evaluationEnd - evaluationStart) / 86_400_000;
+        if (evaluationDays > MAX_EVALUATION_DAYS) {
+            throw new RuntimeError("VALIDATION", `The backtest range covers ${evaluationDays.toFixed(1)} days, above the ${MAX_EVALUATION_DAYS}-day limit`);
+        }
+        const preloadBars = Math.max(MINIMUM_PRELOAD_BARS, Math.floor(request.preloadBars ?? 120));
+        const preloadStart = evaluationStart - preloadBars * ONE_MINUTE_MS;
+        const totalBars = expectedBarCount(preloadStart, evaluationEnd);
+        if (totalBars > MAX_BACKTEST_BARS) {
+            throw new RuntimeError("VALIDATION", `The window covers ${totalBars} bars including preload, above the ${MAX_BACKTEST_BARS} limit`);
+        }
+        return { evaluationStart, evaluationEnd, preloadStart, preloadBars, totalBars };
+    }
+    async execute(id, request, status, signal) {
+        try {
+            if (signal.aborted)
+                return;
+            const window = this.resolveWindow(request);
+            // Fails closed on any absent minute: a run over a window with a hole
+            // would report performance for a timeline that never happened.
+            const bars = this.bars.store.loadWindow(request.instId, window.preloadStart, window.evaluationEnd);
+            const first = bars[window.preloadBars];
+            if (!first || first.openTimeMs !== window.evaluationStart) {
+                throw new RuntimeError("STALE_DATA", "Local history does not cover the requested preloaded range before the evaluation start", true);
+            }
+            // Position sizing depends entirely on the contract specification, so it is
+            // read from the exchange rather than assumed. Guessing it would produce a
+            // run whose sizes are wrong by the factor of the guess while every metric
+            // still looked plausible.
+            const contract = await this.contractSpec(request.instId);
+            const dataSnapshotId = snapshotId(bars, this.bars.store.environment);
+            const engineRequest = buildEngineRequest(request, bars, window.preloadBars, contract, this.settings());
+            // Record the assumptions this run actually used, not the ones saved now:
+            // settings can change between runs, and a report that cannot say what it
+            // assumed is not comparable to any other report.
+            this.store.markRunning(id, bars.length, window.preloadBars, dataSnapshotId, resolvedAssumptions(engineRequest, contract, window));
+            const startedAt = this.now();
+            const response = await invokePython({
+                interpreter: status.interpreter,
+                engineRoot: status.engineRoot,
+                request: engineRequest,
+                signal,
+                onProgress: (progress) => {
+                    const elapsed = Math.max(1, this.now() - startedAt);
+                    const remaining = Math.max(0, progress.total - progress.done);
+                    const rate = progress.done / elapsed;
+                    this.store.updateProgress(id, progress.pct, rate > 0 ? Math.round(remaining / rate) : null);
+                }
+            });
+            if (signal.aborted)
+                return;
+            if (!response.ok)
+                throw pythonError(response);
+            const report = response.report;
+            this.store.completeRun(id, report.metrics, report.equity, report.trades, report.actions);
+        }
+        catch (error) {
+            if (signal.aborted) {
+                this.store.cancelRun(id);
+                return;
+            }
+            const message = error instanceof Error ? error.message : "The backtest failed";
+            this.store.failRun(id, message);
+        }
+    }
+    /**
+     * Runs one parameter search.
+     *
+     * The bars are loaded once and every candidate is measured against that single
+     * array. Batches go out one per worker rather than one per candidate: the
+     * payload is a small share of a candidate's cost, so nothing is gained by
+     * splitting further, while a process per candidate would hold the same
+     * multi-megabyte array once per candidate.
+     */
+    async executeOptimize(id, request, space, candidates, split, status, signal) {
+        try {
+            if (signal.aborted)
+                return;
+            const window = this.resolveWindow(request);
+            const bars = this.bars.store.loadWindow(request.instId, window.preloadStart, window.evaluationEnd);
+            const first = bars[window.preloadBars];
+            if (!first || first.openTimeMs !== window.evaluationStart) {
+                throw new RuntimeError("STALE_DATA", "Local history does not cover the requested preloaded range before the evaluation start", true);
+            }
+            const contract = await this.contractSpec(request.instId);
+            const settings = this.settings();
+            const engineRequest = buildEngineRequest(request, bars, window.preloadBars, contract, settings);
+            // The validation segment gets its own warm-up prefix taken from the bars
+            // immediately before it — which are training bars. That is legitimate:
+            // warm-up supplies indicator state a live strategy would also have, and it
+            // produces no equity point, trade, or statistic.
+            const segments = resolveSegments(bars, window.preloadBars, split);
+            const assumptions = {
+                ...resolvedAssumptions(engineRequest, contract, window),
+                space: describeSpace(space),
+                budget: candidates.length,
+                combinations: countCombinations(space),
+                trainStartMs: split.trainStart,
+                trainEndMs: split.trainEnd,
+                validationStartMs: split.validationStart,
+                validationEndMs: split.validationEnd,
+                trainBars: split.trainBars,
+                validationBars: split.validationBars
+            };
+            this.store.markRunning(id, bars.length, window.preloadBars, snapshotId(bars, this.bars.store.environment), assumptions);
+            const batches = splitIntoBatches(candidates, this.maxWorkers);
+            const startedAt = this.now();
+            const progressByBatch = new Map();
+            await Promise.all(batches.map(async (batch, batchIndex) => {
+                if (signal.aborted)
+                    return;
+                const payload = {
+                    ...engineRequest,
+                    command: "optimize",
+                    segments,
+                    // The candidate's values are layered over the strategy's own defaults,
+                    // so a parameter the space does not vary keeps its declared value
+                    // rather than disappearing.
+                    candidates: batch.map((item) => ({ index: item.index, params: { ...request.params, ...item.params } }))
+                };
+                // Marked before the batch starts so a stalled worker shows its
+                // candidates as running rather than leaving them queued.
+                for (const item of batch)
+                    this.store.markCandidateRunning(id, item.index);
+                try {
+                    const response = await invokePython({
+                        interpreter: status.interpreter,
+                        engineRoot: status.engineRoot,
+                        request: payload,
+                        signal,
+                        onProgress: (progress) => {
+                            progressByBatch.set(batchIndex, { done: progress.done, total: progress.total });
+                            let done = 0;
+                            let total = 0;
+                            for (const entry of progressByBatch.values()) {
+                                done += entry.done;
+                                total += entry.total;
+                            }
+                            // Scaled against every candidate, not this batch: a per-batch
+                            // percentage would jump backwards each time a batch reported.
+                            const overall = candidates.length * segments.length;
+                            const pct = overall === 0 ? 0 : Math.min(100, (done / Math.max(total, overall)) * 100);
+                            const elapsed = Math.max(1, this.now() - startedAt);
+                            const rate = done / elapsed;
+                            this.store.updateProgress(id, pct, rate > 0 ? Math.round((overall - done) / rate) : null);
+                        }
+                    });
+                    if (signal.aborted)
+                        return;
+                    if (!response.ok)
+                        throw pythonError(response);
+                    this.recordBatch(id, batch, response.results);
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return;
+                    // A failed batch marks only its own candidates; the other workers keep
+                    // their results, so a partial search still reports what it measured.
+                    const message = error instanceof Error ? error.message : "The candidate batch failed";
+                    for (const item of batch)
+                        this.store.failCandidate(id, item.index, message);
+                }
+            }));
+            if (signal.aborted)
+                return;
+            const counts = this.store.candidateCounts(id);
+            if (counts.completed === 0) {
+                this.store.failRun(id, `Every one of the ${counts.total} candidates failed`);
+                return;
+            }
+            const ranked = this.store.candidates(id, 1);
+            const best = ranked[0];
+            // The run's own metrics are the winner's validation metrics: the figure a
+            // reader should quote is the one measured out of sample.
+            this.store.completeRun(id, {
+                ...(best?.validation ?? {}),
+                candidatesEvaluated: counts.completed,
+                candidatesFailed: counts.failed,
+                bestParams: best?.params ?? null,
+                bestRankScore: best?.rankScore ?? null,
+                bestRankBasis: best?.rankBasis ?? null,
+                bestVerdict: best?.verdict ?? null,
+                bestTrainReturnPct: best?.train?.returnPct ?? null
+            }, [], [], []);
+        }
+        catch (error) {
+            if (signal.aborted) {
+                this.store.cancelRun(id);
+                return;
+            }
+            const message = error instanceof Error ? error.message : "The optimization failed";
+            this.store.failRun(id, message);
+        }
+    }
+    /** Stores one batch's results, keyed by the candidate index the host assigned. */
+    recordBatch(id, batch, results) {
+        const rows = Array.isArray(results) ? results : [];
+        const byIndex = new Map();
+        for (const row of rows) {
+            if (row && typeof row === "object") {
+                const record = row;
+                byIndex.set(Number(record.index), record);
+            }
+        }
+        for (const item of batch) {
+            const row = byIndex.get(item.index);
+            if (!row) {
+                // A silent omission would leave the candidate queued forever, which reads
+                // as a stalled run rather than a missing result.
+                this.store.failCandidate(id, item.index, "The engine returned no result for this candidate");
+                continue;
+            }
+            if (row.ok !== true) {
+                this.store.failCandidate(id, item.index, String(row.error ?? "The candidate failed"));
+                continue;
+            }
+            const metrics = (row.metrics ?? {});
+            const train = metrics.train;
+            const validation = metrics.validation;
+            if (!train || !validation) {
+                this.store.failCandidate(id, item.index, "The engine did not measure both segments");
+                continue;
+            }
+            const rank = rankCandidate(validation);
+            this.store.completeCandidate(id, item.index, {
+                train,
+                validation,
+                rankScore: rank.score,
+                rankBasis: rank.basis,
+                verdict: verdictFor(train, validation)
+            });
+        }
+    }
+    /**
+     * Reads the instrument's contract specification.
+     *
+     * Refuses rather than defaulting: a backtest sized off a guessed contract value
+     * reports confident numbers for positions that could never have been taken.
+     */
+    async contractSpec(instId) {
+        if (!this.market) {
+            throw new RuntimeError("CAPABILITY_UNAVAILABLE", `No market runtime is available to read the contract specification for ${instId}`);
+        }
+        return loadContractSpec(this.market, instId);
+    }
+    async requireInterpreter() {
+        const status = await pythonStatus();
+        if (!status.interpreter) {
+            throw new RuntimeError("CAPABILITY_UNAVAILABLE", status.problems.join("; ") || "Python is unavailable");
+        }
+        return { interpreter: status.interpreter, engineRoot: status.engineRoot || engineRoot() };
+    }
+    enqueue(task) {
+        this.queue.push(task);
+        this.drain();
+    }
+    drain() {
+        while (this.running < this.maxWorkers && this.queue.length > 0) {
+            const task = this.queue.shift();
+            this.running += 1;
+            void task().finally(() => {
+                this.running -= 1;
+                this.drain();
+            });
+        }
+    }
+}
+function buildEngineRequest(request, bars, preloadBars, contract, settings) {
+    const budgetUsdt = request.entryBudgetUsdt ?? settings.entryBudgetUsdt;
+    const intervals = ["1m"];
+    for (const interval of request.intervals ?? []) {
+        if (!isSupportedInterval(interval)) {
+            throw new RuntimeError("VALIDATION", `Unsupported interval '${interval}'`);
+        }
+        if (!intervals.includes(interval))
+            intervals.push(interval);
+    }
+    return {
+        command: "backtest",
+        source: request.source,
+        params: request.params ?? {},
+        intervals,
+        preloadBars,
+        initialEquityUsdt: request.initialEquityUsdt ?? settings.initialEquityUsdt,
+        closeAtEnd: request.closeAtEnd ?? settings.closeAtEnd,
+        instrument: {
+            instId: request.instId,
+            contractValue: contract.contractValue,
+            contractMultiplier: contract.contractMultiplier,
+            lotSize: contract.lotSize,
+            minSize: contract.minSize,
+            tickSize: contract.tickSize
+        },
+        sizing: {
+            leverage: request.leverage ?? settings.leverage,
+            marginSafetyMultiplier: request.marginSafetyMultiplier ?? settings.marginSafetyMultiplier,
+            // A fixed budget of zero means "use the percentage"; a saved zero must not
+            // become a literal zero-size budget.
+            ...(budgetUsdt > 0 ? { entryBudgetUsdt: budgetUsdt } : {}),
+            entryBudgetPct: request.entryBudgetPct ?? settings.entryBudgetPct
+        },
+        costs: {
+            takerFeeRate: request.takerFeeRate ?? settings.takerFeeRate,
+            makerFeeRate: request.makerFeeRate ?? settings.makerFeeRate,
+            entrySlippageBps: request.entrySlippageBps ?? settings.entrySlippageBps,
+            exitSlippageBps: request.exitSlippageBps ?? settings.exitSlippageBps
+        },
+        bars: bars.map((bar) => ({
+            openTimeMs: bar.openTimeMs,
+            closeTimeMs: bar.closeTimeMs,
+            open: Number(bar.open),
+            high: Number(bar.high),
+            low: Number(bar.low),
+            close: Number(bar.close),
+            volume: Number(bar.volume)
+        }))
+    };
+}
+/**
+ * The assumptions a run used, taken from the request the engine received.
+ *
+ * Derived from that object rather than from the settings file, so a record can
+ * never describe a different run than the one that happened.
+ */
+function resolvedAssumptions(engineRequest, contract, window) {
+    const payload = engineRequest;
+    return {
+        initialEquityUsdt: payload.initialEquityUsdt,
+        closeAtEnd: payload.closeAtEnd,
+        leverage: payload.sizing.leverage,
+        marginSafetyMultiplier: payload.sizing.marginSafetyMultiplier,
+        entryBudgetUsdt: payload.sizing.entryBudgetUsdt ?? null,
+        entryBudgetPct: payload.sizing.entryBudgetPct,
+        takerFeeRate: payload.costs.takerFeeRate,
+        makerFeeRate: payload.costs.makerFeeRate,
+        entrySlippageBps: payload.costs.entrySlippageBps,
+        exitSlippageBps: payload.costs.exitSlippageBps,
+        preloadBars: window.preloadBars,
+        evaluationStartMs: window.evaluationStart,
+        evaluationEndMs: window.evaluationEnd,
+        intervals: payload.intervals,
+        params: payload.params,
+        contract: {
+            contractValue: contract.contractValue,
+            contractMultiplier: contract.contractMultiplier,
+            lotSize: contract.lotSize,
+            minSize: contract.minSize,
+            tickSize: contract.tickSize,
+            contractValueCurrency: contract.contractValueCurrency
+        }
+    };
+}
+function resolveBudget(requested) {
+    if (requested === undefined)
+        return DEFAULT_BUDGET;
+    if (!Number.isInteger(requested) || requested < 2) {
+        throw new RuntimeError("VALIDATION", "The candidate budget must be a whole number of at least 2");
+    }
+    if (requested > MAX_BUDGET) {
+        throw new RuntimeError("VALIDATION", `A budget of ${requested} is above the ${MAX_BUDGET} limit. Narrow the space instead of searching longer.`);
+    }
+    return requested;
+}
+/**
+ * Converts the two window segments into index ranges over the loaded bars.
+ *
+ * Indices rather than timestamps, because the engine receives one array and each
+ * segment is a slice of it. Each slice carries its own warm-up prefix, so the
+ * strategy enters the validation segment with the indicator state it would have
+ * had, and the two measurements start from the same footing.
+ */
+function resolveSegments(bars, preloadBars, split) {
+    const indexOf = (openTimeMs) => {
+        const index = Math.round((openTimeMs - bars[0].openTimeMs) / ONE_MINUTE_MS);
+        if (index < 0 || index >= bars.length || bars[index].openTimeMs !== openTimeMs) {
+            throw new RuntimeError("STALE_DATA", `The loaded window does not contain the minute ${openTimeMs}`, true);
+        }
+        return index;
+    };
+    const trainStart = indexOf(split.trainStart);
+    const trainEnd = indexOf(split.trainEnd);
+    const validationStart = indexOf(split.validationStart);
+    const validationEnd = indexOf(split.validationEnd);
+    // The validation prefix cannot reach before the array's start, so it shrinks
+    // rather than silently sliding the segment's first evaluated minute later.
+    const validationPreload = Math.min(preloadBars, validationStart);
+    if (validationPreload < 2) {
+        throw new RuntimeError("VALIDATION", "There are too few bars before the validation segment to warm up indicators");
+    }
+    return [
+        { name: "train", fromIndex: trainStart - preloadBars, toIndex: trainEnd, preloadBars },
+        {
+            name: "validation",
+            fromIndex: validationStart - validationPreload,
+            toIndex: validationEnd,
+            preloadBars: validationPreload
+        }
+    ];
+}
+/**
+ * Deals candidates across the worker pool.
+ *
+ * Round-robin rather than contiguous chunks: candidates near each other in the
+ * sample often share a slow parameter value, and contiguous chunks would leave
+ * one worker holding all of them.
+ */
+function splitIntoBatches(candidates, workers) {
+    const count = Math.max(1, Math.min(workers, candidates.length));
+    const batches = Array.from({ length: count }, () => []);
+    candidates.forEach((params, index) => {
+        batches[index % count].push({ index, params });
+    });
+    return batches.filter((batch) => batch.length > 0);
+}
+/** Reads the split back out of a run's recorded assumptions. */
+function splitFromAssumptions(assumptions) {
+    if (!assumptions || assumptions.trainStartMs === undefined)
+        return null;
+    return {
+        trainStartMs: Number(assumptions.trainStartMs),
+        trainEndMs: Number(assumptions.trainEndMs),
+        validationStartMs: Number(assumptions.validationStartMs),
+        validationEndMs: Number(assumptions.validationEndMs),
+        trainBars: Number(assumptions.trainBars),
+        validationBars: Number(assumptions.validationBars)
+    };
+}
+/**
+ * Identifies the exact data a run consumed.
+ *
+ * The hash is embedded in the id, so any drift in the underlying bars produces
+ * a different snapshot id instead of passing silently.
+ */
+function snapshotId(bars, environment) {
+    const hash = crypto.createHash("sha256");
+    // The environment is hashed too: demo and live are separate venues, so the same
+    // instrument and minute can carry different prices in each. Two runs that happened
+    // to agree on every price would otherwise share an id while describing different
+    // data.
+    hash.update(`${environment}\n`);
+    for (const bar of bars) {
+        // Price text is hashed as stored, so the digest does not depend on any
+        // float formatting decision.
+        hash.update(`${bar.openTimeMs}|${bar.open}|${bar.high}|${bar.low}|${bar.close}|${bar.volume}\n`);
+    }
+    return `bars-${hash.digest("hex").slice(0, 24)}`;
+}
+function pythonError(response) {
+    const error = (response.error ?? {});
+    return new RuntimeError(error.code === "policy_violation" ? "VALIDATION" : "INTERNAL", error.message ?? "The strategy engine reported an error", false, error.violations ? { violations: error.violations } : undefined);
+}
+/**
+ * Leaves one core for the runtime's own websocket and HTTP work, and caps the
+ * pool so a batch of runs cannot saturate the machine.
+ */
+function defaultWorkerCount() {
+    const cpus = os.cpus().length || 2;
+    return Math.max(1, Math.min(4, cpus - 1));
+}
+//# sourceMappingURL=service.js.map