@alphafox/cli 0.3.2 → 0.3.4

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

@@ -0,0 +1,749 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWEEP_WASM_BATCH_VARIANTS = exports.MAX_ENGINE_BACKTEST_BATCH_VARIANTS = void 0;
+exports.cloneTapeBuffers = cloneTapeBuffers;
+exports.splitBatchChunk = splitBatchChunk;
+exports.executeEngineBacktestSweep = executeEngineBacktestSweep;
+const node_crypto_1 = require("node:crypto");
+const profiles_1 = require("../config/profiles");
+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_axes_1 = require("./parse-axes");
+const persist_1 = require("./persist");
+const replay_timeframe_1 = require("./replay-timeframe");
+const resolve_packages_1 = require("./resolve-packages");
+const sweep_kernel_1 = require("./sweep-kernel");
+/** WASM `runBacktestBatch` hard limit. Keep in sync with Engine. */
+exports.MAX_ENGINE_BACKTEST_BATCH_VARIANTS = 256;
+/** Sweep chunk size: below the 256 cap so JSONL can refresh mid-search. */
+exports.SWEEP_WASM_BATCH_VARIANTS = 32;
+const CREATE_EXPERIMENT_PATH = "/api/v1/engine-backtest/experiments";
+const SUBSCRIPTION_PATH = "/api/v1/subscriptions/me";
+const SUBSCRIPTION_TIERS = new Set([
+    "free",
+    "pro",
+    "pro_max",
+]);
+function cloneTapeBuffers(sourceBuffers) {
+    return Object.fromEntries(Object.entries(sourceBuffers).map(([key, buffer]) => [key, buffer.slice(0)]));
+}
+function splitBatchChunk(chunk, maxVariants = exports.MAX_ENGINE_BACKTEST_BATCH_VARIANTS) {
+    const limit = Math.max(1, Math.floor(maxVariants));
+    if (chunk.length <= limit)
+        return [chunk.slice()];
+    const parts = [];
+    for (let offset = 0; offset < chunk.length; offset += limit) {
+        parts.push(chunk.slice(offset, offset + limit));
+    }
+    return parts;
+}
+async function executeEngineBacktestSweep(args, flags, env = process.env, deps = {}) {
+    if (args.help) {
+        throw new errors_1.EngineBacktestError({
+            type: "usage",
+            message: "internal: help should be handled by the command wrapper",
+        });
+    }
+    if (!args.definitionId || !args.configRaw || !args.exchange || !args.range || !args.axesRaw) {
+        throw new errors_1.EngineBacktestError({
+            type: "usage",
+            subtype: "invalid_args",
+            message: "Missing required sweep arguments",
+            status: 400,
+        });
+    }
+    const startedAt = (deps.now ?? Date.now)();
+    const profile = (0, profiles_1.resolveProfile)(flags.profile, env, {
+        unsafeCustomEndpoint: flags.unsafeCustomEndpoint,
+    });
+    const api = deps.apiRequest ?? client_1.apiRequest;
+    const tokensFn = deps.loadTokens ?? store_1.loadTokens;
+    const persist = args.persist && !flags.dryRun;
+    const createExperiment = args.createExperiment && !flags.dryRun;
+    const mintId = deps.randomUUID ?? node_crypto_1.randomUUID;
+    const writeLine = deps.writeLine ??
+        ((value) => {
+            process.stdout.write(`${JSON.stringify(value)}\n`);
+        });
+    if (persist) {
+        requireAuth(profile, env, tokensFn);
+    }
+    const config = asConfigRecord((0, load_config_1.loadConfigValue)(args.configRaw, {
+        cwd: deps.cwd,
+        readFile: deps.readFile,
+    }));
+    const axisInputs = (0, parse_axes_1.parseSweepAxesDocument)((0, load_config_1.loadConfigValue)(args.axesRaw, {
+        cwd: deps.cwd,
+        readFile: deps.readFile,
+    }), config, args.mode);
+    const { wasm, runner } = await loadRuntime(deps, env);
+    const clients = [];
+    try {
+        const client = wasm.createNodeBacktestClient();
+        clients.push(client);
+        if (typeof client.init === "function") {
+            await client.init();
+        }
+        const configSchemaVersion = await resolveConfigSchemaVersion(client, args.definitionId, args.configSchemaVersion);
+        let subscriptionTier = args.tier ?? "pro";
+        if (persist) {
+            const accountTier = await loadAccountSubscriptionTier(api, profile, env);
+            if (args.tier !== undefined && args.tier !== accountTier) {
+                throw new errors_1.EngineBacktestError({
+                    type: "usage",
+                    subtype: "subscription_tier_mismatch",
+                    message: `--tier ${args.tier} does not match account subscription tier ${accountTier}`,
+                    hint: "Remove --tier for persisted sweeps, or use --no-persist to simulate another tier.",
+                    status: 400,
+                    details: { requestedTier: args.tier, accountTier },
+                });
+            }
+            subscriptionTier = accountTier;
+        }
+        const concurrency = (0, sweep_kernel_1.resolveSweepConcurrency)({
+            subscriptionTier,
+            requested: args.concurrency,
+        });
+        const coarsePlan = (0, sweep_kernel_1.planSweep)({
+            axes: axisInputs,
+            searchMode: args.searchMode,
+            subscriptionTier,
+        });
+        const standardPlan = args.searchMode === "fast"
+            ? (0, sweep_kernel_1.planSweep)({
+                axes: axisInputs,
+                searchMode: "standard",
+                subscriptionTier,
+            })
+            : coarsePlan;
+        if (coarsePlan.coordinates.length === 0) {
+            throw new errors_1.EngineBacktestError({
+                type: "usage",
+                subtype: "empty_sweep",
+                message: "Sweep plan produced no coordinates",
+                status: 400,
+            });
+        }
+        emitProgress(flags, writeLine, "planning", 0);
+        const plannedByKey = new Map();
+        const tapePlans = [];
+        for (const [index, coordinate] of standardPlan.coordinates.entries()) {
+            const planned = await planCoordinate({
+                client,
+                definitionId: args.definitionId,
+                configSchemaVersion,
+                config,
+                axes: coarsePlan.axes,
+                coordinate,
+            });
+            plannedByKey.set(coordinateKey(coordinate), planned);
+            if ("plan" in planned) {
+                tapePlans.push(planned.plan);
+            }
+            emitProgress(flags, writeLine, "planning", (index + 1) / standardPlan.coordinates.length);
+        }
+        let exchange;
+        try {
+            exchange = runner.resolveTapeExchange(args.exchange);
+        }
+        catch (err) {
+            throw new errors_1.EngineBacktestError({
+                type: "usage",
+                subtype: "invalid_exchange",
+                message: err instanceof Error ? err.message : String(err),
+                status: 400,
+            });
+        }
+        const coverage = unionTapePlans(tapePlans);
+        const replayPlan = (0, replay_timeframe_1.mergeReplayTimeframeWithPlan)({
+            replayTimeframe: args.replayTimeframe,
+            planTimeframes: coverage.timeframes,
+            seriesRequirements: coverage.seriesRequirements,
+            symbols: coverage.symbols,
+        });
+        emitProgress(flags, writeLine, "tape", 0);
+        let tapeResult = {
+            tape: {
+                from: "",
+                to: "",
+                baseTimeframe: replayPlan.baseTimeframe,
+                markets: {},
+                series: [],
+            },
+            buffers: {},
+            coverageWarnings: [],
+        };
+        if (tapePlans.length > 0) {
+            try {
+                tapeResult = await runner.loadTape({
+                    exchangeId: exchange.id,
+                    exchange,
+                    symbols: coverage.symbols,
+                    baseTimeframe: replayPlan.baseTimeframe,
+                    timeframes: replayPlan.timeframes,
+                    seriesRequirements: replayPlan.seriesRequirements,
+                    needsFunding: coverage.needsFunding,
+                    auxiliaryDataRequirements: coverage.auxiliaryDataRequirements,
+                    fromMs: args.range.fromMs,
+                    toMs: args.range.toMs,
+                    dataQualityMode: args.dataQualityMode,
+                    onProgress: (progress) => {
+                        emitProgress(flags, writeLine, progress.stage || "tape", progress.fraction, progress.detail);
+                    },
+                });
+            }
+            catch (err) {
+                if ((0, errors_1.isEngineBacktestError)(err))
+                    throw err;
+                const issues = err && typeof err === "object" && "issues" in err
+                    ? err.issues
+                    : undefined;
+                throw new errors_1.EngineBacktestError({
+                    type: "runtime",
+                    subtype: issues ? "tape_unavailable" : "tape_load_failed",
+                    message: err instanceof Error ? err.message : String(err),
+                    details: issues ? { issues } : undefined,
+                });
+            }
+        }
+        emitProgress(flags, writeLine, "tape", 1);
+        while (clients.length < concurrency) {
+            const extra = wasm.createNodeBacktestClient();
+            clients.push(extra);
+            if (typeof extra.init === "function") {
+                await extra.init();
+            }
+        }
+        const executionModel = {
+            ...(runner.DEFAULT_EXECUTION_MODEL ?? persist_1.DEFAULT_EXECUTION_MODEL),
+            ...args.executionModelOverride,
+        };
+        const maxVariantsPerBatch = Math.min(exports.MAX_ENGINE_BACKTEST_BATCH_VARIANTS, Math.max(1, deps.maxVariantsPerBatch ?? exports.SWEEP_WASM_BATCH_VARIANTS));
+        const runPrepared = async (coordinates, onSweepProgress) => {
+            const failed = [];
+            const ready = [];
+            for (const coordinate of coordinates) {
+                const planned = plannedByKey.get(coordinateKey(coordinate)) ??
+                    (await planCoordinate({
+                        client,
+                        definitionId: args.definitionId,
+                        configSchemaVersion,
+                        config,
+                        axes: coarsePlan.axes,
+                        coordinate,
+                    }));
+                if ("status" in planned) {
+                    failed.push(planned);
+                }
+                else {
+                    ready.push(planned);
+                }
+            }
+            onSweepProgress(failed.length, failed);
+            const executed = await executeSweepBatches({
+                clients,
+                runner,
+                ready,
+                tape: tapeResult.tape,
+                buffers: tapeResult.buffers,
+                definitionId: args.definitionId,
+                configSchemaVersion,
+                subscriptionTier,
+                initialEquity: args.initialEquity,
+                executionModel,
+                mintId,
+                maxVariantsPerBatch,
+                onProgress: (done, points) => {
+                    onSweepProgress(failed.length + done, [...failed, ...points]);
+                },
+            });
+            return [...failed, ...executed];
+        };
+        const exactTotalEstimate = args.searchMode === "fast"
+            ? standardPlan.coordinates.length
+            : coarsePlan.coordinates.length;
+        let sweepPoints = [];
+        emitProgress(flags, writeLine, "sweep", 0);
+        const coarsePoints = await runPrepared(coarsePlan.coordinates, (done, points) => {
+            sweepPoints = points;
+            emitProgress(flags, writeLine, "sweep", done / Math.max(exactTotalEstimate, 1));
+        });
+        sweepPoints = coarsePoints;
+        let refinement = [];
+        if (args.searchMode === "fast") {
+            const center = (0, sweep_kernel_1.selectBestNonLiquidatedPoint)(coarsePoints);
+            refinement = center
+                ? (0, sweep_kernel_1.planSweepFastRefinement)({
+                    coarsePlan,
+                    standardPlan,
+                    center: center.coordinate,
+                })
+                : [];
+        }
+        if (refinement.length > 0) {
+            const refinementPoints = await runPrepared(refinement, (done, points) => {
+                sweepPoints = [...coarsePoints, ...points];
+                emitProgress(flags, writeLine, "sweep", (coarsePlan.coordinates.length + done) /
+                    (coarsePlan.coordinates.length + refinement.length));
+            });
+            sweepPoints = [...coarsePoints, ...refinementPoints];
+        }
+        emitProgress(flags, writeLine, "sweep", 1);
+        const engineVersion = (typeof client.version === "function"
+            ? (await client.version()).trim()
+            : "") || "node-wasm";
+        const best = (0, sweep_kernel_1.selectBestNonLiquidatedPoint)(sweepPoints);
+        const successful = sweepPoints.filter((point) => point.status === "ok");
+        const elapsedMs = Math.max(0, (deps.now ?? Date.now)() - startedAt);
+        const sampled = standardPlan.requestedCombinationCount >
+            coarsePlan.coordinates.length + refinement.length;
+        const completed = (0, persist_1.shouldPersistSweepCompletion)({
+            completed: true,
+            cancelled: false,
+        });
+        let experimentId = args.experimentId;
+        let sweepId;
+        let clientSweepId;
+        let persisted = false;
+        if (persist && completed) {
+            emitProgress(flags, writeLine, "persist", 0);
+            if (createExperiment) {
+                const created = await postJson(api, profile, env, CREATE_EXPERIMENT_PATH, {
+                    name: args.name,
+                    strategyDefinitionId: args.definitionId,
+                    strategyDefinitionDisplay: {
+                        zh: args.definitionLabelZh?.trim() || args.definitionId,
+                        en: args.definitionLabelEn?.trim() || args.definitionId,
+                    },
+                }, mintId);
+                experimentId = extractEntityId(created.json);
+                if (!experimentId) {
+                    throw new errors_1.EngineBacktestError({
+                        type: "runtime",
+                        subtype: "create_experiment_no_id",
+                        message: "experiments.create response did not include an id",
+                        details: created.json,
+                    });
+                }
+            }
+            if (!experimentId) {
+                throw new errors_1.EngineBacktestError({
+                    type: "usage",
+                    subtype: "missing_experiment",
+                    message: "Provide --experiment <uuid> or --create-experiment --name <name>",
+                    status: 400,
+                });
+            }
+            const tapeSymbols = (0, persist_1.uniqueSeriesField)(tapeResult.tape.series, "symbol");
+            const snapshot = (0, persist_1.buildSweepBaseSnapshot)({
+                definitionId: args.definitionId,
+                configSchemaVersion,
+                config,
+                exchangeId: exchange.id,
+                rangeStart: tapeResult.tape.from
+                    ? tapeResult.tape.from.slice(0, 10)
+                    : args.range.rangeStart,
+                rangeEnd: tapeResult.tape.to
+                    ? (0, persist_1.exclusiveTapeEndToRangeEnd)(tapeResult.tape.to)
+                    : args.range.rangeEnd,
+                initialEquity: args.initialEquity,
+                subscriptionTier,
+                dataQualityMode: args.dataQualityMode,
+                symbols: tapeSymbols.length > 0 ? tapeSymbols : coverage.symbols,
+                timeframes: (0, persist_1.uniqueSeriesField)(tapeResult.tape.series, "timeframe"),
+                baseTimeframe: tapeResult.tape.baseTimeframe || args.replayTimeframe,
+                executionModel,
+                positionSideDual: true,
+                engineVersion,
+            });
+            clientSweepId = (0, persist_1.mintClientSweepId)(mintId);
+            const body = (0, persist_1.buildCreateSweepRequest)({
+                clientSweepId,
+                snapshot,
+                axes: coarsePlan.axes,
+                mode: args.mode,
+                searchMode: args.searchMode,
+                concurrency,
+                requestedCombinationCount: standardPlan.requestedCombinationCount,
+                sampled,
+                points: sweepPoints,
+                successfulCount: successful.length,
+                failedCount: sweepPoints.length - successful.length,
+                liquidatedCount: successful.filter((point) => (point.metrics?.liquidationCount ?? 0) > 0).length,
+                elapsedMs,
+                best,
+                engineVersion,
+            });
+            const saved = await postJson(api, profile, env, (0, persist_1.sweepsPath)(experimentId), body, mintId);
+            sweepId = extractEntityId(saved.json);
+            if (!sweepId) {
+                throw new errors_1.EngineBacktestError({
+                    type: "runtime",
+                    subtype: "create_sweep_no_id",
+                    message: "sweeps.create response did not include an id",
+                    details: saved.json,
+                });
+            }
+            persisted = true;
+            emitProgress(flags, writeLine, "persist", 1);
+        }
+        return {
+            persisted,
+            sweepId,
+            clientSweepId,
+            mode: args.mode,
+            searchMode: args.searchMode,
+            requestedCombinationCount: standardPlan.requestedCombinationCount,
+            sampled,
+            combinationCount: sweepPoints.length,
+            successfulCount: successful.length,
+            failedCount: sweepPoints.length - successful.length,
+            liquidatedCount: successful.filter((point) => (point.metrics?.liquidationCount ?? 0) > 0).length,
+            elapsedMs,
+            best: best
+                ? {
+                    coordinate: best.coordinate,
+                    returnPct: best.returnPct,
+                    config: (0, sweep_kernel_1.applySweepCoordinate)(config, coarsePlan.axes, best.coordinate),
+                }
+                : null,
+            points: sweepPoints,
+            engineVersion,
+            experimentId,
+            experimentUrl: experimentId
+                ? (0, persist_1.experimentSweepPageUrl)(profile.name, experimentId)
+                : undefined,
+            coverageWarnings: tapeResult.coverageWarnings ?? [],
+            axes: coarsePlan.axes,
+        };
+    }
+    finally {
+        for (const client of clients) {
+            client.terminate();
+        }
+    }
+}
+function requireAuth(profile, env, loadTokensFn) {
+    const tokens = loadTokensFn(profile.name, env);
+    if (tokens?.accessToken?.trim())
+        return;
+    throw new errors_1.EngineBacktestError({
+        type: "http",
+        status: 401,
+        message: "Not authenticated. Run alphafox auth login.",
+        hint: "Tokens live in the OS keychain. Do not pass --token.",
+        subtype: "unauthenticated",
+    });
+}
+function extractErrorMessage(json, fallback) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.message === "string")
+            return o.message;
+        if (typeof o.detail === "string")
+            return o.detail;
+        if (typeof o.error === "string")
+            return o.error;
+        if (o.error && typeof o.error === "object") {
+            const e = o.error;
+            if (typeof e.message === "string")
+                return e.message;
+        }
+    }
+    return fallback || "Request failed";
+}
+function extractErrorCode(json) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.code === "string" || typeof o.code === "number")
+            return o.code;
+    }
+    return undefined;
+}
+function extractEntityId(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const o = json;
+    if (typeof o.id === "string" && o.id.trim())
+        return o.id.trim();
+    if (o.data && typeof o.data === "object") {
+        const d = o.data;
+        if (typeof d.id === "string" && d.id.trim())
+            return d.id.trim();
+    }
+    return undefined;
+}
+function extractSubscriptionTier(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const root = json;
+    const nested = root.data && typeof root.data === "object"
+        ? root.data
+        : undefined;
+    const value = root.subscriptionTier ?? nested?.subscriptionTier;
+    return typeof value === "string" &&
+        SUBSCRIPTION_TIERS.has(value)
+        ? value
+        : undefined;
+}
+async function postJson(api, profile, env, path, body, mintId) {
+    const res = await api({
+        method: "POST",
+        path,
+        body,
+        profile,
+        idempotencyKey: mintId(),
+    }, env);
+    if (res.status >= 400) {
+        throw new errors_1.EngineBacktestError({
+            type: "http",
+            status: res.status,
+            message: extractErrorMessage(res.json, res.bodyText),
+            code: extractErrorCode(res.json),
+            details: res.json,
+        });
+    }
+    return res;
+}
+async function loadAccountSubscriptionTier(api, profile, env) {
+    const res = await api({
+        method: "GET",
+        path: SUBSCRIPTION_PATH,
+        profile,
+    }, env);
+    if (res.status >= 400) {
+        throw new errors_1.EngineBacktestError({
+            type: "http",
+            status: res.status,
+            message: extractErrorMessage(res.json, res.bodyText),
+            code: extractErrorCode(res.json),
+            details: res.json,
+        });
+    }
+    const tier = extractSubscriptionTier(res.json);
+    if (!tier) {
+        throw new errors_1.EngineBacktestError({
+            type: "runtime",
+            subtype: "subscription_tier_unresolved",
+            message: "subscriptions.me response did not include a valid subscriptionTier",
+            details: res.json,
+        });
+    }
+    return tier;
+}
+async function loadRuntime(deps, env) {
+    if (deps.createNodeBacktestClient &&
+        deps.loadTape &&
+        deps.assembleScenario &&
+        deps.resolveTapeExchange) {
+        return {
+            wasm: { createNodeBacktestClient: deps.createNodeBacktestClient },
+            runner: {
+                loadTape: deps.loadTape,
+                assembleScenario: deps.assembleScenario,
+                resolveTapeExchange: deps.resolveTapeExchange,
+                DEFAULT_EXECUTION_MODEL: deps.defaultExecutionModel ?? persist_1.DEFAULT_EXECUTION_MODEL,
+            },
+        };
+    }
+    const [wasmLoaded, runnerLoaded] = await Promise.all([
+        (0, resolve_packages_1.loadBacktestWasm)(env, deps.resolveHooks),
+        (0, resolve_packages_1.loadBacktestRunner)(env, deps.resolveHooks),
+    ]);
+    return { wasm: wasmLoaded.module, runner: runnerLoaded.module };
+}
+async function resolveConfigSchemaVersion(client, definitionId, explicit) {
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    const listed = await client.strategyDefinitions();
+    const found = listed.definitions.find((d) => d.id === definitionId);
+    const version = found?.configSchemaVersion;
+    if (typeof version !== "number" || !Number.isInteger(version) || version <= 0) {
+        throw new errors_1.EngineBacktestError({
+            type: "runtime",
+            subtype: "config_schema_version_unresolved",
+            message: `strategyDefinitions() has no configSchemaVersion for "${definitionId}"`,
+            hint: "Pass --config-schema-version explicitly.",
+            details: { definitionId },
+        });
+    }
+    return version;
+}
+async function planCoordinate(input) {
+    const nextConfig = (0, sweep_kernel_1.applySweepCoordinate)(input.config, input.axes, input.coordinate);
+    try {
+        const plan = await input.client.planBacktest({
+            definitionId: input.definitionId,
+            configSchemaVersion: input.configSchemaVersion,
+            config: nextConfig,
+        });
+        if (!isSupportedPlan(plan)) {
+            const reason = plan && typeof plan === "object" && "support" in plan
+                ? plan.support
+                    ?.reason
+                : undefined;
+            return {
+                coordinate: input.coordinate,
+                status: "failed",
+                error: reason?.message ??
+                    `planBacktest does not support definition "${input.definitionId}"`,
+            };
+        }
+        return {
+            coordinate: input.coordinate,
+            config: nextConfig,
+            plan,
+        };
+    }
+    catch (err) {
+        if ((0, errors_1.isEngineBacktestError)(err))
+            throw err;
+        return {
+            coordinate: input.coordinate,
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function executeSweepBatches(input) {
+    if (input.ready.length === 0) {
+        return [];
+    }
+    const workers = input.clients.slice(0, Math.min(input.clients.length, input.ready.length));
+    const chunks = partitionRoundRobin(input.ready, workers.length);
+    const completed = Array.from({
+        length: input.ready.length,
+    });
+    await Promise.all(chunks.map(async (chunk, workerIndex) => {
+        const client = workers[workerIndex];
+        for (const subChunk of splitBatchChunk(chunk, input.maxVariantsPerBatch)) {
+            const scenarios = subChunk.map((item) => input.runner.assembleScenario({
+                runId: input.mintId(),
+                definitionId: input.definitionId,
+                configSchemaVersion: input.configSchemaVersion,
+                config: item.item.config,
+                subscriptionTier: input.subscriptionTier,
+                initialEquity: input.initialEquity,
+                tape: input.tape,
+                executionModel: input.executionModel,
+            }));
+            const first = scenarios[0];
+            if (!first)
+                continue;
+            const { tape: _tape, ...baseScenario } = first;
+            const batch = {
+                version: 1,
+                batchId: input.mintId(),
+                baseScenario,
+                variants: scenarios.map((scenario) => ({
+                    runId: scenario.runId,
+                    config: scenario.trader.config,
+                })),
+                tape: input.tape,
+            };
+            const result = await client.runBacktestBatch(batch, cloneTapeBuffers(input.buffers));
+            if (result.results.length !== subChunk.length) {
+                throw new errors_1.EngineBacktestError({
+                    type: "runtime",
+                    subtype: "batch_result_count",
+                    message: "runBacktestBatch returned an unexpected result count",
+                    details: {
+                        expected: subChunk.length,
+                        actual: result.results.length,
+                    },
+                });
+            }
+            subChunk.forEach((entry, index) => {
+                const point = result.results[index];
+                completed[entry.index] = readBatchPoint(entry.item.coordinate, point);
+            });
+            const finished = completed.filter((point) => point !== undefined);
+            input.onProgress(finished.length, finished);
+        }
+    }));
+    return completed.filter((point) => point !== undefined);
+}
+function readBatchPoint(coordinate, point) {
+    if (point.status === "completed") {
+        return {
+            coordinate,
+            status: "ok",
+            metrics: (0, sweep_kernel_1.extractSweepMetrics)(point.metrics),
+        };
+    }
+    return {
+        coordinate,
+        status: "failed",
+        error: point.errors?.[0]?.message ?? "runBacktestBatch variant failed",
+    };
+}
+function partitionRoundRobin(items, workerCount) {
+    const count = Math.min(Math.max(1, workerCount), items.length);
+    const chunks = Array.from({ length: count }, () => []);
+    items.forEach((item, index) => {
+        chunks[index % count].push({ index, item });
+    });
+    return chunks;
+}
+function unionTapePlans(plans) {
+    const symbols = [...new Set(plans.flatMap((plan) => plan.symbols))];
+    const timeframes = [...new Set(plans.flatMap((plan) => plan.timeframes))];
+    const warmup = new Map();
+    for (const plan of plans) {
+        for (const requirement of plan.seriesRequirements) {
+            const key = `${requirement.symbol}\u0000${requirement.timeframe}`;
+            const previous = warmup.get(key);
+            if (!previous ||
+                requirement.minWarmupCandles > previous.minWarmupCandles) {
+                warmup.set(key, requirement);
+            }
+        }
+    }
+    const auxiliary = new Map();
+    for (const plan of plans) {
+        for (const item of plan.auxiliaryDataRequirements) {
+            auxiliary.set(JSON.stringify(item), item);
+        }
+    }
+    return {
+        symbols,
+        timeframes,
+        seriesRequirements: [...warmup.values()],
+        needsFunding: plans.some((plan) => plan.needsFunding),
+        auxiliaryDataRequirements: [...auxiliary.values()],
+    };
+}
+function isSupportedPlan(plan) {
+    return (!!plan &&
+        typeof plan === "object" &&
+        !("status" in plan && plan.status === "failed") &&
+        "support" in plan &&
+        plan.support?.status === "supported");
+}
+function asConfigRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new errors_1.EngineBacktestError({
+            type: "usage",
+            subtype: "invalid_config",
+            message: "--config must be a JSON object",
+            status: 400,
+        });
+    }
+    return value;
+}
+function coordinateKey(coordinate) {
+    return coordinate.values.join("\u0000");
+}
+function emitProgress(flags, writeLine, stage, fraction, detail) {
+    if (flags.format !== "jsonl")
+        return;
+    writeLine({
+        event: "progress",
+        stage,
+        fraction,
+        ...(detail ? { detail } : {}),
+    });
+}