@alphafox/cli 0.1.5 → 0.3.2

package/skills/strategy/SKILL.md

@@ -1,35 +1,49 @@
 ---
 name: alphafox-strategy
 description: Strategy definitions, chats, and backtests via public operationIds.
-version: 0.1.0
+version: 0.3.2
 ---
 
 # Strategy / Chat / Backtest
 
+Always `--format json --no-input`. Read scopes `trading:read` / `backtests:read`; writes `chats:write` / `backtests:write`.
+
 ## Read
 
 ```bash
-alphafox schema trading.strategy_definitions.list
-alphafox api GET /api/v1/trading/strategy-definitions
+alphafox schema trading.strategy_definitions.list --format json --no-input
+alphafox api GET /api/v1/trading/strategy-definitions --format json --no-input
 ```
 
 ## Write (ordinary)
 
+Read `request.body` first. Do not invent chat or strategy fields.
+
 ```bash
-alphafox api POST /api/v1/chats --body '{"strategyGenerationMode":"simple"}'
+alphafox schema chats.create --format json --no-input
+alphafox chats create --body '{"strategyGenerationMode":"simple"}' --format json --no-input
+# large / nested bodies:
+# alphafox chats create --config @./create-chat.json --format json --no-input
 ```
 
-Requires auth. Sends `Idempotency-Key` when available.
+Requires auth. Sends `Idempotency-Key` when available. Duplicate key → `409`; do not invent a new key unless the operator asks to create another chat.
+
+Engine strategy backtest (WASM tape + persist) is `skills/engine-backtest` (`alphafox engine-backtest run`). Do not treat `/api/v1/backtests` as the Engine WASM runner — that stub is the chat backtest job below.
 
 ## Long-running backtest
 
 ```bash
-alphafox api POST /api/v1/backtests --body '{...}'
-alphafox api GET /api/v1/backtests/{backtestId}
-alphafox api GET /api/v1/backtests/{backtestId}/stream
-alphafox api POST /api/v1/backtests/{backtestId}/cancel --body '{}'
+alphafox schema backtests.create --format json --no-input
+alphafox api POST /api/v1/backtests --body '{"chatId":"<chat-id>"}' --format json --no-input
+alphafox api GET /api/v1/backtests/{backtestId} --format json --no-input
+alphafox api GET /api/v1/backtests/{backtestId}/stream --format jsonl --no-input
+alphafox api POST /api/v1/backtests/{backtestId}/cancel --body '{}' --format json --no-input
 ```
 
+`backtests.create` requires `chatId`. `strategyId` is optional: the facade resolves a compiled strategy on that chat. A chat with no compiled strategy returns `CHAT_HAS_NO_COMPILED_STRATEGY` (not `JOB_NOT_FOUND`). Optional `backtestSettings` overlays chat settings when it is a settingsJson object.
+
+If the stream drops, `GET` the backtest by id — do not assume success. Cancel is explicit; interruption must remain queryable.
+
 ## operationIds
 
 - `trading.strategy_definitions.list`

package/skills/trading/SKILL.md

@@ -1,25 +1,38 @@
 ---
 name: alphafox-trading
 description: Traders list and high-risk start/stop with confirmation gates.
-version: 0.1.0
+version: 0.3.2
 ---
 
 # Trading
 
+Always `--format json --no-input`. Read first. Writes need scopes `trading:write`; start/stop also `trading:high-risk`.
+
 ## Read
 
 ```bash
-alphafox api GET /api/v1/trading/traders
+alphafox api GET /api/v1/trading/traders --format json --no-input
 ```
 
 ## High-risk write
 
+Read `alphafox schema trading.traders.byId.start` first. Body may only include documented fields (`reason` is optional). Do not invent keys.
+
 ```bash
-alphafox api POST /api/v1/trading/traders/{traderId}/start --body '{}' --dry-run
-alphafox api POST /api/v1/trading/traders/{traderId}/start --body '{}' --yes
+alphafox schema trading.traders.byId.start --format json --no-input
+alphafox trading traders byId start --traderId <id> --body '{}' --dry-run --format json --no-input
+alphafox trading traders byId start --traderId <id> --body '{}' --yes --format json --no-input
 ```
 
-Without `--yes`, CLI exits `10` with `confirmation_required`.
+Without `--yes`, CLI exits `10` with `confirmation_required`. Server still checks role/ownership.
+
+Stop: `POST /api/v1/trading/traders/{traderId}/stop` with the same `--dry-run` then `--yes` sequence.
+
+## Recovery
+
+- `403`: missing scope or not owner — stop, do not retry `--yes`.
+- `409`: trader already in the requested state — report, do not loop start/stop.
+- Unknown HTTP after a write: do not auto-retry.
 
 ## operationIds
 

package/vendor/backtest-runner/NOTICE.md

@@ -0,0 +1 @@
+Vendored from alphafox-engine `npm/backtest-runner` so public CLI installs do not need GitHub Packages. Keep this copy aligned when the Engine runner changes.

package/vendor/backtest-runner/README.md

@@ -0,0 +1,97 @@
+# Vendored Engine tape runner
+
+This directory is copied from `alphafox-engine/npm/backtest-runner` so the public CLI does not need GitHub Packages. Keep it aligned when the Engine runner changes.
+
+# @alphafoxai/backtest-runner
+
+Node 侧的 Engine Backtest **tape loader + scenario 组装**库。从交易所拉 closed OHLCV / funding，编成 wasm 运行时需要的 tape JSON 与列式 `ArrayBuffer`，并套上与 web 回测相同的默认 `executionModel`。
+
+本包**不执行 wasm**，也不依赖 `@alphafoxai/backtest-wasm`（避免把约 40MB 的 wasm 拖进 CLI 的懒加载路径）。CLI 应同时依赖本包与 wasm 包：runner 负责行情，wasm 包负责 `planBacktest` / `runBacktest`。
+
+## 安装
+
+```bash
+npm install @alphafoxai/backtest-runner --registry=https://npm.pkg.github.com
+```
+
+要求 Node >= 20。
+
+## 发布
+
+`main` push 通过常规 CI 后，仅当 `lib/`、入口 / 类型声明或 package 元数据发生变化时发布到 GitHub Packages。测试、README 或其他 Engine 文件单独变化不会触发 runner 发布。CI 使用当前 workflow run / attempt 生成唯一版本，并通过仓库 `GITHUB_TOKEN` 发布。
+
+## 公共 API
+
+```js
+import {
+  DEFAULT_EXECUTION_MODEL,
+  TAPE_EXCHANGES,
+  resolveTapeExchange,
+  encodeOhlcvColumns,
+  createFileTapeCache,
+  loadTape,
+  assembleScenario,
+} from "@alphafoxai/backtest-runner";
+
+const { tape, buffers, coverageWarnings } = await loadTape({
+  exchangeId: "binance_perp_usdt",
+  symbols: ["BTC/USDT:USDT"],
+  timeframes: ["1m", "1h"],
+  fromMs,
+  toMs,
+  dataQualityMode: "strict",
+});
+
+const scenario = assembleScenario({
+  runId,
+  definitionId: "grid",
+  configSchemaVersion: 4,
+  config,
+  subscriptionTier: "pro",
+  initialEquity: 10_000,
+  traderName: "paper-grid",
+  tape,
+});
+```
+
+| 导出 | 作用 |
+|---|---|
+| `DEFAULT_EXECUTION_MODEL` | web 硬编码值：`ohlc_path_4` / maker `0.0002` / taker `0.0005` / slippage `0.0001` |
+| `TAPE_EXCHANGES` | Binance / OKX / Bybit / Bitget / Hyperliquid 线性合约定义 |
+| `resolveTapeExchange(id)` | 解析 `binance_perp_usdt` 或 `binance` 等别名；未知 id **抛错** |
+| `encodeOhlcvColumns(rows)` | 与 wasm 包相同的 float64 列式小端布局 |
+| `createFileTapeCache(rootDir)` | 默认根目录 `~/.alphafox/cache/engine-backtest` |
+| `loadTape(request, options?)` | 拉数 + 缓存缺口补齐 + 覆盖率校验 |
+| `assembleScenario(input)` | 组装 `EngineBacktestScenario`，不跑 wasm |
+
+`loadTape` 可注入 `ohlcvFetcher` / `fundingFetcher` / `marketsLoader`，单测不得打真实交易所。任一注入器出现时，本包拒绝再构造 live ccxt client。
+
+## 缓存
+
+- 语义对齐 web 的 closed-series IndexedDB 缓存：每个 `ccxtId + symbol + timeframe` 一条滚动区间，命中后只补缺口。
+- Node 侧改为文件系统 JSON；max-age 30 天。
+- `options.cache === false` / `"disable"` 关闭缓存；`options.cacheDir` 覆盖根目录。测试应使用临时目录。
+
+## 代理
+
+尊重 `HTTPS_PROXY` / `https_proxy` / `HTTP_PROXY` / `http_proxy`，并写入 ccxt 构造参数 `httpsProxy` / `httpProxy`。也可显式传入 `options.httpsProxy` / `options.httpProxy` / `options.agent`。未配置时不会假装“已走代理”。
+
+## 分页 limit
+
+与 web `tape-loader.series.ts` 对齐：Binance 1500、OKX 100、Bybit / Bitget 1000、Hyperliquid 5000。Bitget 另受约 89 天请求跨度限制；Hyperliquid 分页带 `until` 窗口。
+
+## 数据质量
+
+- `strict`（默认）：任何缺口 / 缺数 / 非法 K 线都抛 `TapeDataUnavailableError`。
+- `basic`：硬失败（缺市场、空序列、非法 K 线、拉数失败）仍抛错；软缺口进入 `coverageWarnings`。
+- 禁止 mock 成功或静默降级。
+
+## 已知限制（相对 alphafox-web）
+
+- **不执行 wasm**，不做 `planBacktest` / `runBacktest`。
+- **HIP-3**：构造 Hyperliquid 时与 web 一样只附加硬编码的 `xyz` builder DEX，不拉取完整 HIP-3 目录，也不移植 Next alias / 浏览器 HIP-3 市场列表。原生 HL USDC 线性合约是主路径；HIP-3 符号属于尽力而为。
+- **缓存后端**是文件系统，不是 IndexedDB；key 版本仍是 `closed-series-v2`。
+- **未知交易所 id 抛错**，web 的 `resolveEngineBacktestTapeExchange` 会静默回落到 Binance。
+- **Aster / Gate** 不是 tape 数据源。
+- Hyperliquid 不提供 `6h` K 线（与 web 相同，快速失败）。
+- 本包不依赖 `@alphafoxai/backtest-wasm`；`encodeOhlcvColumns` 与必要类型自包含。`EngineBacktestTapeMarket.precisionMode` 按 Go tape 协议写出（wasm 包的 `index.d.ts` 目前漏了该字段）。

package/vendor/backtest-runner/index.d.ts

@@ -0,0 +1,423 @@
+export const TAPE_SERIES_COLUMNS: readonly string[];
+
+export function encodeOhlcvColumns(
+  rows: ReadonlyArray<readonly [number, number, number, number, number, number]>
+): ArrayBuffer;
+
+export const DEFAULT_EXECUTION_MODEL: {
+  readonly pricePath: "ohlc_path_4";
+  readonly makerFeeRate: 0.0002;
+  readonly takerFeeRate: 0.0005;
+  readonly slippageRate: 0.0001;
+};
+
+export type TapeQuoteAsset = "USDT" | "USDC";
+export type TapeCcxtId =
+  | "binanceusdm"
+  | "okx"
+  | "bybit"
+  | "bitget"
+  | "hyperliquid";
+export type TapeExchangeId =
+  | "binance_perp_usdt"
+  | "okx_perp_usdt"
+  | "bybit_perp_usdt"
+  | "bitget_perp_usdt"
+  | "hyperliquid_perp_usdc";
+
+export interface TapeExchangeDefinition {
+  readonly id: TapeExchangeId | string;
+  readonly label: string;
+  readonly ccxtId: TapeCcxtId | string;
+  readonly marketType: "swap";
+  readonly quoteAsset: TapeQuoteAsset;
+}
+
+export const TAPE_EXCHANGES: readonly TapeExchangeDefinition[];
+export const PUBLIC_MARKET_EXCHANGE_BINANCE: "binance_perp_usdt";
+export const PUBLIC_MARKET_EXCHANGE_OKX: "okx_perp_usdt";
+export const PUBLIC_MARKET_EXCHANGE_BYBIT: "bybit_perp_usdt";
+export const PUBLIC_MARKET_EXCHANGE_BITGET: "bitget_perp_usdt";
+export const PUBLIC_MARKET_EXCHANGE_HYPERLIQUID: "hyperliquid_perp_usdc";
+export const HYPERLIQUID_PUBLIC_MARKET_DEXES: readonly string[];
+
+export function resolveTapeExchange(
+  exchangeId: string | TapeExchangeDefinition
+): TapeExchangeDefinition;
+
+export interface TapeExchangeRuntimeConfig {
+  readonly ohlcvPageLimit: number;
+  readonly fundingPageLimit: number;
+  readonly requestParams: Readonly<Record<string, unknown>>;
+  readonly constructorOptions?: Readonly<Record<string, unknown>>;
+  readonly unsupportedTimeframes?: readonly string[];
+}
+
+export function tapeExchangeRuntimeConfig(
+  exchange: TapeExchangeDefinition
+): TapeExchangeRuntimeConfig;
+
+export const DEFAULT_TAPE_CACHE_DIR: string;
+export const CACHE_KEY_VERSION: "closed-series-v2";
+export const CACHE_MAX_AGE_MS: number;
+
+export type CachedOhlcvRow = readonly [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export interface CachedOhlcvRange {
+  readonly sinceMs: number;
+  readonly untilMs: number;
+  readonly rows: CachedOhlcvRow[];
+}
+
+export interface OhlcvRangeSegment {
+  readonly sinceMs: number;
+  readonly untilMs: number;
+}
+
+export interface FileTapeCache {
+  readonly disabled: boolean;
+  readonly rootDir?: string;
+  read(key: string): Promise<CachedOhlcvRange | null>;
+  write(key: string, range: CachedOhlcvRange): Promise<void>;
+}
+
+export function ohlcvSeriesCacheKey(
+  exchangeId: string,
+  symbol: string,
+  timeframe: string
+): string;
+export function missingCachedOhlcvRanges(
+  cached: CachedOhlcvRange | null,
+  sinceMs: number,
+  untilMs: number
+): OhlcvRangeSegment[];
+export function mergeCachedOhlcvRanges(
+  cached: CachedOhlcvRange | null,
+  addition: CachedOhlcvRange
+): CachedOhlcvRange;
+export function createFileTapeCache(
+  rootDir?: string,
+  options?: { maxAgeMs?: number; nowMs?: number }
+): FileTapeCache;
+export function createDisabledTapeCache(): FileTapeCache;
+
+export type TapeDataQualityMode = "strict" | "basic";
+export type TapeDataIssueCode =
+  | "market_missing"
+  | "ohlcv_missing"
+  | "invalid_ohlcv"
+  | "non_monotonic"
+  | "internal_gap"
+  | "prefix_gap"
+  | "suffix_gap"
+  | "warmup_insufficient"
+  | "load_failed"
+  | "coverage_insufficient";
+
+export interface TapeDataIssue {
+  readonly code: TapeDataIssueCode;
+  readonly symbol: string;
+  readonly timeframe: string;
+  readonly expected?: number;
+  readonly actual?: number;
+  readonly timestamp?: number;
+  readonly message?: string;
+}
+
+export class TapeDataUnavailableError extends Error {
+  readonly issues: readonly TapeDataIssue[];
+  constructor(issues: readonly TapeDataIssue[]);
+}
+
+export function isTapeDataUnavailableError(
+  value: unknown
+): value is TapeDataUnavailableError;
+
+export type EngineBacktestPrecisionMode = "DECIMAL_PLACES" | "TICK_SIZE";
+export type EngineBacktestSubscriptionTier = "free" | "pro" | "pro_max";
+export type EngineBacktestPricePath = "ohlc_path_4" | "close_only";
+
+export interface EngineBacktestExecutionModel {
+  readonly pricePath: EngineBacktestPricePath;
+  readonly makerFeeRate: number;
+  readonly takerFeeRate: number;
+  readonly slippageRate: number;
+}
+
+export interface EngineBacktestTapeMarket {
+  readonly id: string;
+  readonly symbol: string;
+  readonly base?: string;
+  readonly quote?: string;
+  readonly settle?: string;
+  readonly contractSize: number;
+  readonly linear: boolean;
+  readonly precisionMode: EngineBacktestPrecisionMode;
+  readonly precisionAmount?: number;
+  readonly precisionPrice?: number;
+  readonly amountMin?: number;
+  readonly amountMax?: number;
+  readonly priceMin?: number;
+  readonly costMin?: number;
+}
+
+export interface EngineBacktestTapeSeriesRef {
+  readonly symbol: string;
+  readonly timeframe: string;
+  readonly buffer: string;
+  readonly rows: number;
+}
+
+export interface EngineBacktestFundingSample {
+  readonly timestamp: number;
+  readonly rate: number;
+  readonly interval: string;
+}
+
+export interface EngineBacktestTapeInput {
+  readonly from: string;
+  readonly to: string;
+  readonly baseTimeframe: string;
+  readonly markets: Readonly<Record<string, EngineBacktestTapeMarket>>;
+  readonly series: readonly EngineBacktestTapeSeriesRef[];
+  readonly fundingRates?: Readonly<
+    Record<string, readonly EngineBacktestFundingSample[]>
+  >;
+  readonly lowLiquiditySymbols?: readonly string[];
+}
+
+export interface EngineBacktestScenarioTrader {
+  readonly id?: string;
+  readonly name?: string;
+  readonly strategyDefinitionId: string;
+  readonly configSchemaVersion: number;
+  readonly subscriptionTier: EngineBacktestSubscriptionTier;
+  readonly config: unknown;
+}
+
+export interface EngineBacktestScenario {
+  readonly version: 1;
+  readonly runId: string;
+  readonly trader: EngineBacktestScenarioTrader;
+  readonly exchange: {
+    readonly positionSideDual: boolean;
+    readonly initialEquity: number;
+  };
+  readonly executionModel: EngineBacktestExecutionModel;
+  readonly tape: EngineBacktestTapeInput;
+}
+
+export interface EngineBacktestSeriesRequirement {
+  readonly symbol: string;
+  readonly timeframe: string;
+  readonly minWarmupCandles: number;
+}
+
+export interface EngineBacktestAuxiliaryDataRequirement {
+  readonly kind: string;
+  readonly parameters?: Record<string, unknown>;
+}
+
+export interface TapeLoadProgress {
+  readonly stage: "markets" | "ohlcv" | "validation";
+  readonly detail: string;
+  readonly fraction: number;
+}
+
+export interface TapeMarketsSnapshot {
+  readonly markets: Readonly<Record<string, TapeSymbolMarket>>;
+  readonly precisionMode?: number;
+  readonly nowMs?: number;
+}
+
+export interface TapeSymbolMarket {
+  readonly id?: string;
+  readonly symbol?: string;
+  readonly created?: number;
+  readonly base?: string;
+  readonly quote?: string;
+  readonly settle?: string;
+  readonly active?: boolean;
+  readonly type?: string;
+  readonly swap?: boolean;
+  readonly linear?: boolean;
+  readonly inverse?: boolean;
+  readonly contractSize?: number;
+  readonly precision?: { readonly amount?: number; readonly price?: number };
+  readonly limits?: {
+    readonly amount?: { readonly min?: number; readonly max?: number };
+    readonly price?: { readonly min?: number };
+    readonly cost?: { readonly min?: number };
+  };
+}
+
+export type TapeOhlcvFetcher = (
+  symbol: string,
+  timeframe: string,
+  since?: number,
+  limit?: number,
+  params?: Record<string, unknown>
+) => Promise<ReadonlyArray<readonly number[]>>;
+
+export type TapeFundingFetcher = (
+  symbol: string,
+  since?: number,
+  limit?: number,
+  params?: Record<string, unknown>
+) => Promise<ReadonlyArray<{ timestamp?: number; fundingRate?: number }>>;
+
+export interface TapeLoadRequest {
+  readonly exchangeId?: string;
+  readonly exchange?: TapeExchangeDefinition;
+  readonly symbols: readonly string[];
+  readonly baseTimeframe?: string;
+  readonly timeframes: readonly string[];
+  readonly seriesRequirements?: readonly EngineBacktestSeriesRequirement[];
+  readonly needsFunding?: boolean;
+  readonly auxiliaryDataRequirements?: readonly EngineBacktestAuxiliaryDataRequirement[];
+  readonly fromMs: number;
+  readonly toMs: number;
+  readonly dataQualityMode?: TapeDataQualityMode;
+  readonly signal?: AbortSignal;
+  readonly onProgress?: (progress: TapeLoadProgress) => void;
+  readonly nowMs?: number;
+  readonly ohlcvFetcher?: TapeOhlcvFetcher;
+  readonly fundingFetcher?: TapeFundingFetcher;
+  readonly marketsLoader?: () => Promise<TapeMarketsSnapshot>;
+}
+
+export interface TapeProxyOptions {
+  readonly httpsProxy?: string;
+  readonly httpProxy?: string;
+  readonly agent?: unknown;
+}
+
+export interface TapeLoadOptions extends TapeProxyOptions {
+  readonly cache?: FileTapeCache | false | "disable";
+  readonly cacheDir?: string;
+  readonly nowMs?: number;
+  readonly onProgress?: (progress: TapeLoadProgress) => void;
+  readonly createExchange?: (
+    exchange: TapeExchangeDefinition,
+    constructorOptions: Record<string, unknown>
+  ) => Promise<TapeRuntimeExchange> | TapeRuntimeExchange;
+}
+
+export interface TapeRuntimeExchange {
+  markets?: Readonly<Record<string, TapeSymbolMarket>>;
+  precisionMode?: number;
+  loadMarkets(): Promise<Readonly<Record<string, TapeSymbolMarket>>>;
+  fetchTime(): Promise<number>;
+  fetchOHLCV: TapeOhlcvFetcher;
+  fetchFundingRateHistory?: TapeFundingFetcher;
+}
+
+export interface TapeChartSeries {
+  readonly symbol: string;
+  readonly timeframe: string;
+  readonly rows: number;
+  readonly buffer: ArrayBuffer;
+}
+
+export interface TapeLoadResult {
+  readonly tape: EngineBacktestTapeInput;
+  readonly buffers: Record<string, ArrayBuffer>;
+  readonly coverageWarnings: readonly string[];
+  readonly chartData?: {
+    readonly exchangeId: string;
+    readonly series: readonly TapeChartSeries[];
+  };
+}
+
+export function loadTape(
+  request: TapeLoadRequest,
+  options?: TapeLoadOptions
+): Promise<TapeLoadResult>;
+
+export interface AssembleScenarioInput {
+  readonly runId: string;
+  readonly definitionId: string;
+  readonly configSchemaVersion: number;
+  readonly config: unknown;
+  readonly subscriptionTier: EngineBacktestSubscriptionTier;
+  readonly initialEquity: number;
+  readonly traderName?: string;
+  readonly traderId?: string;
+  readonly tape?: EngineBacktestTapeInput;
+  readonly preparedTape?: { readonly tape: EngineBacktestTapeInput };
+  readonly prepared?: { readonly tape: EngineBacktestTapeInput };
+  readonly executionModel?: Partial<EngineBacktestExecutionModel>;
+}
+
+export function assembleScenario(
+  input: AssembleScenarioInput
+): EngineBacktestScenario;
+
+export const TIMEFRAME_MS: Readonly<Record<string, number>>;
+export const ENGINE_BACKTEST_BASE_TIMEFRAME: string;
+export const ENGINE_BACKTEST_WARMUP_CANDLES: number;
+
+export function resolvePlanBaseTimeframe(input: {
+  readonly baseTimeframe?: string | null;
+  readonly timeframes?: readonly string[] | null;
+}): string;
+
+export function abortable<T>(
+  operation: Promise<T>,
+  signal?: AbortSignal
+): Promise<T>;
+
+export function resolveCcxtProxyOptions(
+  options?: TapeProxyOptions,
+  env?: NodeJS.ProcessEnv
+): { httpsProxy?: string; httpProxy?: string; agent?: unknown };
+
+export function buildCcxtConstructorOptions(
+  exchange: TapeExchangeDefinition,
+  options?: TapeProxyOptions & { runtimeConfig?: TapeExchangeRuntimeConfig }
+): Record<string, unknown>;
+
+export function isClosedCandle(
+  timestampMs: number,
+  timeframe: string,
+  toMs: number
+): boolean;
+
+export function ohlcvSeriesStartMs(
+  fromMs: number,
+  timeframe: string,
+  market?: Pick<TapeSymbolMarket, "created">
+): number;
+
+export function effectiveTapeEndMs(
+  requestedToMs: number,
+  nowMs?: number,
+  baseTimeframe?: string
+): number;
+
+export function inferFundingIntervals(
+  samples: readonly Omit<EngineBacktestFundingSample, "interval">[]
+): EngineBacktestFundingSample[];
+
+export function classifyTapeSymbolsForPreflight(
+  symbols: readonly string[],
+  markets: Readonly<Record<string, TapeSymbolMarket>>,
+  quoteAsset: TapeQuoteAsset
+): {
+  readonly availableSymbols: readonly string[];
+  readonly missingSymbols: readonly string[];
+};
+
+export function resolveEngineBacktestPrecisionMode(
+  precisionMode: number | undefined,
+  exchangeLabel: string
+): EngineBacktestPrecisionMode;
+
+export function resolveTapeCache(options?: TapeLoadOptions): FileTapeCache;

package/vendor/backtest-runner/index.mjs

@@ -0,0 +1,59 @@
+export { TAPE_SERIES_COLUMNS, encodeOhlcvColumns } from "./lib/encode.mjs";
+export {
+  DEFAULT_EXECUTION_MODEL,
+  assembleScenario,
+} from "./lib/scenario.mjs";
+export {
+  TAPE_EXCHANGES,
+  PUBLIC_MARKET_EXCHANGE_BINANCE,
+  PUBLIC_MARKET_EXCHANGE_OKX,
+  PUBLIC_MARKET_EXCHANGE_BYBIT,
+  PUBLIC_MARKET_EXCHANGE_BITGET,
+  PUBLIC_MARKET_EXCHANGE_HYPERLIQUID,
+  HYPERLIQUID_PUBLIC_MARKET_DEXES,
+  resolveTapeExchange,
+  tapeExchangeRuntimeConfig,
+} from "./lib/exchanges.mjs";
+export {
+  DEFAULT_TAPE_CACHE_DIR,
+  CACHE_KEY_VERSION,
+  CACHE_MAX_AGE_MS,
+  ohlcvSeriesCacheKey,
+  missingCachedOhlcvRanges,
+  mergeCachedOhlcvRanges,
+  createFileTapeCache,
+  createDisabledTapeCache,
+} from "./lib/cache.mjs";
+export {
+  TapeDataUnavailableError,
+  isTapeDataUnavailableError,
+  evaluateOhlcvCoverage,
+  analyzeOhlcvCoverage,
+} from "./lib/coverage.mjs";
+export {
+  TIMEFRAME_MS,
+  ENGINE_BACKTEST_BASE_TIMEFRAME,
+  ENGINE_BACKTEST_WARMUP_CANDLES,
+  resolvePlanBaseTimeframe,
+} from "./lib/timeframes.mjs";
+export {
+  abortable,
+} from "./lib/abortable.mjs";
+export {
+  resolveCcxtProxyOptions,
+  buildCcxtConstructorOptions,
+} from "./lib/proxy.mjs";
+export {
+  isClosedCandle,
+  ohlcvSeriesStartMs,
+  fetchClosedOhlcvRange,
+  loadSeriesWithCache,
+} from "./lib/series.mjs";
+export {
+  loadTape,
+  resolveTapeCache,
+  effectiveTapeEndMs,
+  inferFundingIntervals,
+  classifyTapeSymbolsForPreflight,
+  resolveEngineBacktestPrecisionMode,
+} from "./lib/tape-loader.mjs";