@tradejs/infra 1.0.5 → 1.0.8

package/dist/chunk-DSTV67R5.mjs

@@ -0,0 +1,345 @@
+// src/redis.ts
+import { randomBytes } from "crypto";
+import Redis from "ioredis";
+var TTL_1D = 86400;
+var SCREENSHOT_TOKEN_TTL_SECONDS = 15 * 60;
+var toJson = (value) => JSON.stringify(value);
+var logger = {
+  log: (level, message, ...args) => {
+    const method = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+    console[method](`[infra:redis] ${message}`, ...args);
+  }
+};
+var redisConnectionWarningShown = false;
+var redisUnavailable = false;
+var isRedisConnectivityError = (error) => /ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+  error.message
+);
+var toNonNegativeInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+var toPositiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var markRedisUnavailable = (error) => {
+  redisUnavailable = true;
+  if (redisConnectionWarningShown) return;
+  redisConnectionWarningShown = true;
+  logger.log(
+    "warn",
+    "Redis is unavailable: %s. Cache-dependent features are temporarily disabled.",
+    error.message
+  );
+};
+var getRedis = () => {
+  if (!global.__redis__) {
+    const host = process.env.REDIS_HOST || "127.0.0.1";
+    const port = toPositiveInt(process.env.REDIS_PORT, 6379);
+    const connectTimeout = toPositiveInt(
+      process.env.REDIS_CONNECT_TIMEOUT_MS,
+      3e3
+    );
+    const maxRetriesPerRequest = toNonNegativeInt(
+      process.env.REDIS_MAX_RETRIES_PER_REQUEST,
+      1
+    );
+    global.__redis__ = new Redis({
+      host,
+      port,
+      connectTimeout,
+      maxRetriesPerRequest,
+      enableOfflineQueue: false,
+      retryStrategy: (attempt) => Math.min(attempt * 200, 2e3)
+    });
+    global.__redis__.on("error", (error) => {
+      if (isRedisConnectivityError(error)) {
+        markRedisUnavailable(error);
+        return;
+      }
+      logger.log("error", "Redis client error: %s", String(error));
+    });
+    global.__redis__.on("ready", () => {
+      redisUnavailable = false;
+      if (redisConnectionWarningShown) {
+        redisConnectionWarningShown = false;
+        logger.log("info", "Redis connection restored");
+      }
+    });
+  }
+  return global.__redis__;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getRedisStatus = (redis) => String(redis.status ?? "ready");
+var waitForRedisReady = async (redis) => {
+  if (getRedisStatus(redis) === "ready") {
+    return true;
+  }
+  const readyTimeoutMs = toPositiveInt(
+    process.env.REDIS_READY_TIMEOUT_MS,
+    toPositiveInt(process.env.REDIS_CONNECT_TIMEOUT_MS, 3e3)
+  );
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < readyTimeoutMs) {
+    if (getRedisStatus(redis) === "ready") {
+      return true;
+    }
+    if (getRedisStatus(redis) === "end") {
+      return false;
+    }
+    await sleep(50);
+  }
+  return getRedisStatus(redis) === "ready";
+};
+var getReadyRedis = async () => {
+  if (redisUnavailable) return null;
+  const redis = getRedis();
+  const ready = await waitForRedisReady(redis);
+  if (ready) {
+    return redis;
+  }
+  markRedisUnavailable(
+    new Error(`Redis is not ready (status=${getRedisStatus(redis)})`)
+  );
+  return null;
+};
+var toResultString = (result) => {
+  if (result == null) return null;
+  if (typeof result === "string") return result;
+  if (Buffer.isBuffer(result)) return result.toString("utf8");
+  return String(result);
+};
+var DEFAULT_OPTIONS = {
+  expire: TTL_1D
+};
+var parseJsonOrDeleteKey = async (redis, key, raw, fallback) => {
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    logger.log("error", "failed JSON.parse(%s): %s", key, String(e));
+    await redis.del(key);
+    return fallback;
+  }
+};
+var getKeys = async (prefix) => {
+  if (redisUnavailable) return [];
+  const redis = await getReadyRedis();
+  if (!redis) return [];
+  const keys = [];
+  try {
+    let cursor = "0";
+    do {
+      const [nextCursor, batch] = await redis.scan(
+        cursor,
+        "MATCH",
+        `${prefix}*`,
+        "COUNT",
+        "200"
+      );
+      cursor = nextCursor;
+      for (const key of batch) {
+        if (key.startsWith(prefix)) {
+          keys.push(key);
+        }
+      }
+    } while (cursor !== "0");
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return [];
+    }
+    logger.log("warn", "failed SCAN for %s: %s", prefix, String(e));
+    return [];
+  }
+  return keys;
+};
+var getData = async (key, fallback = []) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const rawJson = await redis.call("JSON.GET", key);
+    const raw = toResultString(rawJson);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log(
+      "error",
+      "failed JSON.GET %s: %s (fallback to GET)",
+      key,
+      String(e)
+    );
+  }
+  try {
+    const raw = await redis.get(key);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed GET %s: %s", key, String(e));
+    return fallback;
+  }
+};
+var delKey = async (key) => {
+  return delKeyWithOptions(key);
+};
+var RedisWriteBlockedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedisWriteBlockedError";
+  }
+};
+var delKeyWithOptions = async (key, options = {}) => {
+  if (redisUnavailable) return false;
+  const { raiseOnMisconf = false } = options;
+  const redis = await getReadyRedis();
+  if (!redis) return false;
+  try {
+    const result = await redis.del(key);
+    if (result === 1) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return false;
+    }
+    const msg = String(e);
+    if (raiseOnMisconf && msg.includes("MISCONF")) {
+      throw new RedisWriteBlockedError(msg);
+    }
+    logger.log("error", "failed DEL %s: %s", key, String(e));
+    return false;
+  }
+};
+var setData = async (key, data, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  const value = toJson(data);
+  try {
+    await redis.call("JSON.SET", key, "$", value);
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log(
+      "error",
+      "failed JSON.SET %s: %s (fallback to SET)",
+      key,
+      String(e)
+    );
+    try {
+      if (expire) {
+        await redis.set(key, value, "EX", expire);
+      } else {
+        await redis.set(key, value);
+      }
+    } catch (e2) {
+      if (e2 instanceof Error && isRedisConnectivityError(e2)) {
+        markRedisUnavailable(e2);
+        return;
+      }
+      logger.log("error", "failed SET %s: %s", key, String(e2));
+    }
+  }
+};
+var createScreenshotSessionToken = async (userName) => {
+  const token = randomBytes(24).toString("hex");
+  await setData(
+    redisKeys.screenshotSessionToken(token),
+    {
+      userName,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      expire: SCREENSHOT_TOKEN_TTL_SECONDS
+    }
+  );
+  return token;
+};
+var consumeScreenshotSessionToken = async (token) => {
+  const normalizedToken = token.trim();
+  if (!normalizedToken) {
+    return null;
+  }
+  const key = redisKeys.screenshotSessionToken(normalizedToken);
+  const payload = await getData(
+    key,
+    null
+  );
+  if (!payload?.userName) {
+    return null;
+  }
+  await delKey(key);
+  return payload.userName;
+};
+var redisKeys = {
+  users: () => "users:index:",
+  user: (userName) => `users:index:${userName}`,
+  bots: (userName) => `users:${userName}:bots`,
+  botsPrefix: () => "users:",
+  bot: (userName, botId) => `users:${userName}:bots:${botId}`,
+  backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
+  strategies: (userName) => `users:${userName}:strategies`,
+  strategyConfig: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:config`,
+  strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
+  testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
+  testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
+  testStat: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:stat`,
+  testSummaries: (userName) => `users:${userName}:tests:index:summary`,
+  cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
+  cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
+  cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
+  signalsBySymbol: (symbol) => `signals:${symbol}:`,
+  storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
+  runtimeSignals: (userName) => `users:${userName}:runtime:signals:`,
+  runtimeSignal: (userName, signalId) => `users:${userName}:runtime:signals:${signalId}`,
+  runtimeSignalEvaluations: (userName) => `users:${userName}:runtime:signal-evaluations:`,
+  runtimeSignalEvaluation: (userName, evaluationId) => `users:${userName}:runtime:signal-evaluations:${evaluationId}`,
+  runtimeTrades: (userName) => `users:${userName}:runtime:trade-records:`,
+  runtimeTrade: (userName, orderId) => `users:${userName}:runtime:trade-records:${orderId}`,
+  runtimeActiveTrades: (userName) => `users:${userName}:runtime:active-trades:`,
+  runtimeActiveTrade: (userName, symbol) => `users:${userName}:runtime:active-trades:${symbol}`,
+  aiChatHistory: (userName, symbolKey) => `users:${userName}:ai:chats:${symbolKey}`,
+  analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
+  screenshotSessionToken: (token) => `auth:screenshot:${token}`,
+  backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  researchRuns: (userName) => `users:${userName}:research:runs:`,
+  researchRun: (userName, runId) => `users:${userName}:research:runs:${runId}`,
+  researchLatestRun: (userName, strategyName) => `users:${userName}:research:latest:${strategyName}`,
+  mlSignalsByStrategy: (strategyName) => `ml:${strategyName}:signals:`,
+  mlSignals: () => "ml:",
+  mlSignal: (strategyName, signalId) => `ml:${strategyName}:signals:${signalId}`,
+  mlResultsByStrategy: (strategyName) => `ml:${strategyName}:results:`,
+  mlResults: () => "ml:",
+  mlResult: (strategyName, signalId) => `ml:${strategyName}:results:${signalId}`
+};
+
+export {
+  getKeys,
+  getData,
+  delKey,
+  RedisWriteBlockedError,
+  delKeyWithOptions,
+  setData,
+  createScreenshotSessionToken,
+  consumeScreenshotSessionToken,
+  redisKeys
+};

package/dist/chunk-DTCLZIBM.mjs

@@ -0,0 +1,163 @@
+import {
+  AI_CUSTOM_ENDPOINT_VALUE
+} from "./chunk-XQ3YBULV.mjs";
+
+// src/aiModels.ts
+var AI_CUSTOM_MODEL_VALUE = "__custom_model__";
+var OPENAI_ENDPOINT = "https://api.openai.com/v1";
+var ANTHROPIC_ENDPOINT = "https://api.anthropic.com/v1";
+var OPENROUTER_ENDPOINT = "https://openrouter.ai/api/v1";
+var GEMINI_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/openai";
+var TOGETHER_ENDPOINT = "https://api.together.xyz/v1";
+var GROQ_ENDPOINT = "https://api.groq.com/openai/v1";
+var XAI_ENDPOINT = "https://api.x.ai/v1";
+var QWEN_INTL_ENDPOINT = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+var QWEN_CN_ENDPOINT = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+var QWEN_US_ENDPOINT = "https://dashscope-us.aliyuncs.com/compatible-mode/v1";
+var PERPLEXITY_ENDPOINT = "https://api.perplexity.ai";
+var KIMI_ENDPOINT = "https://api.moonshot.ai/v1";
+var PROXY_API_ENDPOINT = "https://openai.api.proxyapi.ru/v1";
+var AI_MODEL_OPTIONS_BY_ENDPOINT = {
+  [OPENAI_ENDPOINT]: [
+    { label: "GPT-5 mini", value: "gpt-5-mini" },
+    { label: "GPT-5", value: "gpt-5" },
+    { label: "GPT-5.2", value: "gpt-5.2" },
+    { label: "GPT-4.1", value: "gpt-4.1" },
+    { label: "GPT-4o", value: "gpt-4o" }
+  ],
+  [ANTHROPIC_ENDPOINT]: [
+    { label: "Claude Sonnet 4", value: "claude-sonnet-4-20250514" },
+    { label: "Claude Opus 4.1", value: "claude-opus-4-1-20250805" },
+    { label: "Claude Opus 4", value: "claude-opus-4-20250514" },
+    { label: "Claude 3.7 Sonnet", value: "claude-3-7-sonnet-20250219" },
+    { label: "Claude 3.5 Haiku", value: "claude-3-5-haiku-20241022" }
+  ],
+  [OPENROUTER_ENDPOINT]: [
+    { label: "OpenAI GPT-5", value: "openai/gpt-5" },
+    { label: "Anthropic Claude Sonnet 4", value: "anthropic/claude-sonnet-4" },
+    { label: "Google Gemini 2.5 Pro", value: "google/gemini-2.5-pro" },
+    { label: "OpenAI GPT-5 mini", value: "openai/gpt-5-mini" },
+    {
+      label: "DeepSeek V3.1",
+      value: "deepseek/deepseek-chat-v3.1"
+    }
+  ],
+  [GEMINI_ENDPOINT]: [
+    { label: "Gemini 2.5 Pro", value: "gemini-2.5-pro" },
+    { label: "Gemini 2.5 Flash", value: "gemini-2.5-flash" },
+    { label: "Gemini 2.5 Flash-Lite", value: "gemini-2.5-flash-lite" },
+    { label: "Gemini 2.0 Flash", value: "gemini-2.0-flash" },
+    { label: "Gemini 2.0 Flash-Lite", value: "gemini-2.0-flash-lite" }
+  ],
+  [TOGETHER_ENDPOINT]: [
+    { label: "DeepSeek V3.1", value: "deepseek-ai/DeepSeek-V3.1" },
+    {
+      label: "Qwen3 Coder 480B",
+      value: "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8"
+    },
+    {
+      label: "Llama 4 Maverick",
+      value: "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
+    },
+    { label: "DeepSeek V3", value: "deepseek-ai/DeepSeek-V3" },
+    {
+      label: "Llama 3.3 70B Turbo",
+      value: "meta-llama/Llama-3.3-70B-Instruct-Turbo"
+    }
+  ],
+  [GROQ_ENDPOINT]: [
+    { label: "GPT-OSS 120B", value: "openai/gpt-oss-120b" },
+    {
+      label: "Llama 4 Scout",
+      value: "meta-llama/llama-4-scout-17b-16e-instruct"
+    },
+    { label: "Qwen3 32B", value: "qwen/qwen3-32b" },
+    { label: "Llama 3.3 70B", value: "llama-3.3-70b-versatile" },
+    { label: "Llama 3.1 8B Instant", value: "llama-3.1-8b-instant" }
+  ],
+  [XAI_ENDPOINT]: [
+    { label: "Grok 4 Fast Reasoning", value: "grok-4-fast-reasoning" },
+    { label: "Grok 4 Fast Non-Reasoning", value: "grok-4-fast-non-reasoning" },
+    { label: "Grok Code Fast 1", value: "grok-code-fast-1" },
+    { label: "Grok 4", value: "grok-4-0709" },
+    { label: "Grok 3 Mini", value: "grok-3-mini" }
+  ],
+  [QWEN_INTL_ENDPOINT]: [
+    { label: "Qwen Plus Latest", value: "qwen-plus-latest" },
+    { label: "Qwen Turbo Latest", value: "qwen-turbo-latest" },
+    { label: "Qwen Max Latest", value: "qwen-max-latest" },
+    { label: "Qwen3 Coder Plus", value: "qwen3-coder-plus" },
+    { label: "Qwen3 Coder Next", value: "qwen3-coder-next" }
+  ],
+  [QWEN_CN_ENDPOINT]: [
+    { label: "Qwen Plus Latest", value: "qwen-plus-latest" },
+    { label: "Qwen Turbo Latest", value: "qwen-turbo-latest" },
+    { label: "Qwen Max Latest", value: "qwen-max-latest" },
+    { label: "Qwen3 Coder Plus", value: "qwen3-coder-plus" },
+    { label: "Qwen3 Coder Next", value: "qwen3-coder-next" }
+  ],
+  [QWEN_US_ENDPOINT]: [
+    { label: "Qwen Plus Latest", value: "qwen-plus-latest" },
+    { label: "Qwen Turbo Latest", value: "qwen-turbo-latest" },
+    { label: "Qwen Max Latest", value: "qwen-max-latest" },
+    { label: "Qwen3 Coder Plus", value: "qwen3-coder-plus" },
+    { label: "Qwen3 Coder Next", value: "qwen3-coder-next" }
+  ],
+  [PERPLEXITY_ENDPOINT]: [
+    { label: "Sonar Pro", value: "sonar-pro" },
+    { label: "Sonar", value: "sonar" },
+    { label: "Sonar Reasoning Pro", value: "sonar-reasoning-pro" },
+    { label: "Sonar Deep Research", value: "sonar-deep-research" }
+  ],
+  [KIMI_ENDPOINT]: [
+    { label: "Kimi K2.5", value: "kimi-k2.5" },
+    { label: "Kimi K2 Thinking", value: "kimi-k2-thinking" },
+    { label: "Kimi K2 Turbo Preview", value: "kimi-k2-turbo-preview" },
+    { label: "Kimi K2 0905 Preview", value: "kimi-k2-0905-preview" },
+    { label: "Kimi K2", value: "kimi-k2" }
+  ],
+  [PROXY_API_ENDPOINT]: [
+    {
+      label: "Anthropic Claude Sonnet 4",
+      value: "anthropic/claude-sonnet-4-20250514"
+    },
+    { label: "Gemini 2.5 Flash", value: "gemini/gemini-2.5-flash" },
+    { label: "OpenAI GPT-5 mini", value: "openai/gpt-5-mini" },
+    { label: "OpenAI GPT-4o", value: "openai/gpt-4o" },
+    {
+      label: "OpenRouter DeepSeek Chat V3.1",
+      value: "openrouter/deepseek/deepseek-chat-v3.1"
+    }
+  ]
+};
+var DEFAULT_AI_MODEL_BY_ENDPOINT = Object.fromEntries(
+  Object.entries(AI_MODEL_OPTIONS_BY_ENDPOINT).map(([endpoint, options]) => [
+    endpoint,
+    options[0]?.value ?? ""
+  ])
+);
+var normalizeModel = (value) => value.trim();
+var getAiModelOptionsForEndpoint = (endpoint) => AI_MODEL_OPTIONS_BY_ENDPOINT[endpoint] ?? [];
+var getDefaultAiModelForEndpoint = (endpoint) => DEFAULT_AI_MODEL_BY_ENDPOINT[endpoint] ?? "";
+var normalizeAiModel = (value, endpoint) => {
+  if (typeof value === "string") {
+    const trimmed = normalizeModel(value);
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return getDefaultAiModelForEndpoint(endpoint);
+};
+var isKnownAiModelForEndpoint = (value, endpoint) => getAiModelOptionsForEndpoint(endpoint).some(
+  (option) => option.value === normalizeAiModel(value, endpoint)
+);
+var hasPresetAiModelsForEndpoint = (endpoint) => getAiModelOptionsForEndpoint(endpoint).length > 0 && endpoint !== AI_CUSTOM_ENDPOINT_VALUE;
+
+export {
+  AI_CUSTOM_MODEL_VALUE,
+  getAiModelOptionsForEndpoint,
+  getDefaultAiModelForEndpoint,
+  normalizeAiModel,
+  isKnownAiModelForEndpoint,
+  hasPresetAiModelsForEndpoint
+};

package/dist/chunk-KVEZORMS.mjs

@@ -0,0 +1,142 @@
+// src/mlDatasetFile.ts
+import { once } from "events";
+import { createReadStream, createWriteStream } from "fs";
+import fs from "fs/promises";
+import path from "path";
+var DEFAULT_DIR = "data/ml/export";
+var ML_DATASET_WRITE_BATCH_SIZE = 200;
+var ML_CHUNK_FILE_RE = /^ml-dataset-(.+)-chunk-[^.]+\.jsonl$/;
+var writerByPath = /* @__PURE__ */ new Map();
+var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
+var getMlChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => path.join(
+  outDir,
+  `ml-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
+);
+var appendMlDatasetRow = async (params) => {
+  const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
+  const filePath = getMlChunkFilePath(strategyName, chunkId, outDir);
+  let state = writerByPath.get(filePath);
+  if (!state) {
+    await fs.mkdir(outDir, { recursive: true });
+    const stream = createWriteStream(filePath, {
+      encoding: "utf8",
+      flags: "a"
+    });
+    state = {
+      filePath,
+      stream,
+      buffer: [],
+      writeQueue: Promise.resolve(),
+      closed: false
+    };
+    writerByPath.set(filePath, state);
+  }
+  if (state.closed) {
+    throw new Error(`ML dataset writer is closed: ${filePath}`);
+  }
+  state.buffer.push(`${JSON.stringify(row)}
+`);
+  if (state.buffer.length >= ML_DATASET_WRITE_BATCH_SIZE) {
+    await flushMlDatasetWriter(filePath);
+  }
+  return filePath;
+};
+var flushState = async (state) => {
+  if (state.closed || state.buffer.length === 0) {
+    return;
+  }
+  const chunk = state.buffer.join("");
+  state.buffer = [];
+  if (!state.stream.write(chunk)) {
+    await once(state.stream, "drain");
+  }
+};
+var flushMlDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state || state.closed) {
+    return;
+  }
+  state.writeQueue = state.writeQueue.then(() => flushState(state));
+  await state.writeQueue;
+};
+var closeState = async (state) => {
+  if (state.closed) {
+    return;
+  }
+  await flushState(state);
+  state.closed = true;
+  state.stream.end();
+  await Promise.all([
+    once(state.stream, "finish"),
+    once(state.stream, "close")
+  ]);
+};
+var closeMlDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state) return;
+  state.writeQueue = state.writeQueue.then(() => closeState(state));
+  await state.writeQueue;
+  writerByPath.delete(filePath);
+};
+var closeAllMlDatasetWriters = async () => {
+  const filePaths = [...writerByPath.keys()];
+  for (const filePath of filePaths) {
+    await closeMlDatasetWriter(filePath);
+  }
+};
+var listMlChunkFiles = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  const prefix = `ml-dataset-${toFileToken(strategyName)}-chunk-`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch (error) {
+    return [];
+  }
+  return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => path.join(outDir, name)).sort();
+};
+var listMlChunkStrategies = async (params) => {
+  const outDir = params?.outDir ?? DEFAULT_DIR;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return [
+    ...new Set(
+      entries.map((name) => name.match(ML_CHUNK_FILE_RE)?.[1] || "").filter(Boolean)
+    )
+  ].sort();
+};
+var mergeJsonlFiles = async (params) => {
+  const { filePaths, outPath } = params;
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  const stream = createWriteStream(outPath, { encoding: "utf8" });
+  const done = Promise.all([once(stream, "finish"), once(stream, "close")]);
+  try {
+    for (const filePath of filePaths) {
+      const reader = createReadStream(filePath, { encoding: "utf8" });
+      for await (const chunk of reader) {
+        if (!stream.write(chunk)) {
+          await once(stream, "drain");
+        }
+      }
+    }
+  } finally {
+    stream.end();
+    await done;
+  }
+};
+
+export {
+  toFileToken,
+  getMlChunkFilePath,
+  appendMlDatasetRow,
+  flushMlDatasetWriter,
+  closeMlDatasetWriter,
+  closeAllMlDatasetWriters,
+  listMlChunkFiles,
+  listMlChunkStrategies,
+  mergeJsonlFiles
+};