@tradejs/node 3.0.0 → 3.1.0

package/dist/backtest.js

@@ -44,10 +44,10 @@ __reExport(backtest_exports, require("@tradejs/core/backtest"), module.exports);
 
 // src/testing.ts
 var import_indicators3 = require("@tradejs/core/indicators");
-var import_constants8 = require("@tradejs/core/constants");
+var import_constants9 = require("@tradejs/core/constants");
 var import_strategies7 = require("@tradejs/core/strategies");
-var import_time2 = require("@tradejs/core/time");
-var import_logger13 = require("@tradejs/infra/logger");
+var import_time3 = require("@tradejs/core/time");
+var import_logger15 = require("@tradejs/infra/logger");
 
 // src/strategyRuntime.ts
 var import_constants5 = require("@tradejs/core/constants");
@@ -60,11 +60,8 @@ var import_constants3 = require("@tradejs/core/constants");
 var import_ml2 = require("@tradejs/infra/ml");
 
 // src/ai.ts
-var import_aiLanguages = require("@tradejs/core/aiLanguages");
-var import_aiEndpoints = require("@tradejs/core/aiEndpoints");
-var import_aiModels = require("@tradejs/core/aiModels");
+var import_aiLanguages2 = require("@tradejs/core/aiLanguages");
 var import_redis = require("@tradejs/infra/redis");
-var import_userSettings = require("@tradejs/infra/userSettings");
 
 // src/aiShared.ts
 var MAX_AI_SERIES_POINTS = 5;
@@ -1273,6 +1270,139 @@ var postProcessLocalAiAnalysisByStrategy = (signal, analysis, payload = buildAiP
   }) ?? strategyAnalysis;
 };
 
+// src/aiProvider.ts
+var import_aiEndpoints = require("@tradejs/core/aiEndpoints");
+var import_aiModels = require("@tradejs/core/aiModels");
+var import_aiLanguages = require("@tradejs/core/aiLanguages");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var DEFAULT_AI_MODEL = "openai/gpt-5-mini";
+var userSettingsCache = /* @__PURE__ */ new Map();
+var aiModelCache = /* @__PURE__ */ new Map();
+var normalizeResponseContent = (content) => {
+  if (typeof content === "string") return content;
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map(
+      (part) => typeof part?.text === "string" ? part.text : ""
+    ).join("\n").trim();
+  }
+  return String(content ?? "");
+};
+var getAiInvocationError = (error) => {
+  const details = error instanceof Error && error.message.trim() ? error.message.trim() : String(error);
+  const isEmptyCompletion = error instanceof TypeError && /Cannot read properties of undefined \(reading ['"]message['"]\)/.test(
+    details
+  );
+  const wrapped = new Error(
+    isEmptyCompletion ? "AI provider returned an empty chat completion" : `AI model invocation failed: ${details}`
+  );
+  wrapped.cause = error;
+  return wrapped;
+};
+var isEmptyResponseContent = (content) => typeof content === "string" ? content.trim().length === 0 : Object.keys(content).length === 0;
+var getAiModelCacheKey = (userName, modelName, temperature) => `${userName}::${modelName}::${temperature}`;
+var resolveAiModelName = (settings, requestedModelName) => {
+  const explicitModelName = requestedModelName?.trim() ?? "";
+  if (explicitModelName) return explicitModelName;
+  return settings.AI_MODEL?.trim() || DEFAULT_AI_MODEL;
+};
+var getOpenRouterModelKwargs = (apiEndpoint) => {
+  const endpoint = String(apiEndpoint ?? "").trim();
+  if (!endpoint) return {};
+  let hostname = "";
+  try {
+    hostname = new URL(endpoint).hostname;
+  } catch {
+    hostname = endpoint;
+  }
+  return hostname.toLowerCase().includes("openrouter") ? { provider: { ignore: ["azure"] } } : {};
+};
+var getAiUserSettings = async (userName = "root") => {
+  let settingsPromise = userSettingsCache.get(userName);
+  if (!settingsPromise) {
+    settingsPromise = (0, import_userSettings.getUserSettings)(userName).then((settings2) => {
+      const endpoint = (0, import_aiEndpoints.normalizeAiEndpoint)(settings2.AI_API_ENDPOINT);
+      return {
+        ...settings2,
+        AI_API_ENDPOINT: endpoint,
+        AI_MODEL: (0, import_aiModels.normalizeAiModel)(settings2.AI_MODEL, endpoint),
+        AI_RESPONSE_LANGUAGE: (0, import_aiLanguages.normalizeAiResponseLanguage)(
+          settings2.AI_RESPONSE_LANGUAGE
+        )
+      };
+    });
+    settingsPromise.catch(() => userSettingsCache.delete(userName));
+    userSettingsCache.set(userName, settingsPromise);
+  }
+  const settings = await settingsPromise;
+  if (!settings.AI_API_KEY || !settings.AI_API_ENDPOINT) {
+    throw new Error(`AI settings are incomplete for user ${userName}`);
+  }
+  return settings;
+};
+var getAiModel = async (userName = "root", requestedModelName, temperature = 0.2) => {
+  const settings = await getAiUserSettings(userName);
+  const modelName = resolveAiModelName(settings, requestedModelName);
+  const cacheKey = getAiModelCacheKey(userName, modelName, temperature);
+  let modelPromise = aiModelCache.get(cacheKey);
+  if (!modelPromise) {
+    modelPromise = import("@langchain/openai").then(({ ChatOpenAI }) => {
+      const modelKwargs = getOpenRouterModelKwargs(settings.AI_API_ENDPOINT);
+      return new ChatOpenAI({
+        temperature,
+        modelName,
+        apiKey: settings.AI_API_KEY,
+        ...Object.keys(modelKwargs).length ? { modelKwargs } : {},
+        configuration: {
+          baseURL: settings.AI_API_ENDPOINT,
+          defaultHeaders: {
+            "HTTP-Referer": "https://tradejs.dev",
+            "X-Title": "Inv"
+          }
+        }
+      });
+    });
+    modelPromise.catch(() => aiModelCache.delete(cacheKey));
+    aiModelCache.set(cacheKey, modelPromise);
+  }
+  try {
+    return await modelPromise;
+  } catch (error) {
+    aiModelCache.delete(cacheKey);
+    userSettingsCache.delete(userName);
+    throw error;
+  }
+};
+var invokeAiChatWithUserMessageEncoding = async ({
+  messages,
+  userName = "root",
+  model,
+  temperature = 0.2
+}, resolveUserMessageEncoding) => {
+  const [{ HumanMessage, SystemMessage }, aiModel] = await Promise.all([
+    import("@langchain/core/messages"),
+    getAiModel(userName, model, temperature)
+  ]);
+  const providerMessages = messages.map(
+    (message) => message.role === "system" ? new SystemMessage(message.content) : new HumanMessage(
+      resolveUserMessageEncoding(message) === "text-block" ? { content: [{ type: "text", text: message.content }] } : message.content
+    )
+  );
+  try {
+    const response = await aiModel.invoke(providerMessages);
+    const content = normalizeResponseContent(response?.content);
+    if (isEmptyResponseContent(content)) {
+      throw new Error("AI provider returned an empty chat completion");
+    }
+    return { content };
+  } catch (error) {
+    throw getAiInvocationError(error);
+  }
+};
+var invokeAiPromptChat = (options) => invokeAiChatWithUserMessageEncoding(options, () => "text-block");
+
 // src/ai.ts
 var parseAIResponse = (input) => {
   try {
@@ -1286,18 +1416,6 @@ var parseAIResponse = (input) => {
     return {};
   }
 };
-var normalizeResponseContent = (content) => {
-  if (typeof content === "string" || content && typeof content === "object") {
-    if (typeof content !== "object" || !Array.isArray(content)) {
-      return content;
-    }
-  }
-  if (Array.isArray(content)) {
-    const text = content.map((part) => typeof part?.text === "string" ? part.text : "").join("\n").trim();
-    return text;
-  }
-  return String(content ?? "");
-};
 var normalizeAnalysis = (raw) => {
   const direction = raw?.direction === "LONG" || raw?.direction === "SHORT" ? raw.direction : null;
   const qualityNum = typeof raw?.quality === "number" ? Math.max(1, Math.min(5, Math.round(raw.quality))) : void 0;
@@ -1531,153 +1649,24 @@ Trade payload:
 ${JSON.stringify(payload)}
 ${buildAiHumanPromptAddonByStrategy(signal, payload)}
 `;
-var getAiInvocationError = (error) => {
-  const details = error instanceof Error && error.message.trim() ? error.message.trim() : String(error);
-  const isEmptyCompletion = error instanceof TypeError && /Cannot read properties of undefined \(reading ['"]message['"]\)/.test(
-    details
-  );
-  const wrapped = new Error(
-    isEmptyCompletion ? "AI provider returned an empty chat completion" : `AI model invocation failed: ${details}`
-  );
-  wrapped.cause = error;
-  return wrapped;
-};
-var isEmptyResponseContent = (content) => typeof content === "string" ? content.trim().length === 0 : Object.keys(content).length === 0;
-var DEFAULT_AI_MODEL = "openai/gpt-5-mini";
-var userSettingsCache = /* @__PURE__ */ new Map();
-var aiModelCache = /* @__PURE__ */ new Map();
-var getAiModelCacheKey = (userName, modelName) => `${userName}::${modelName}`;
-var resolveAiModelName = (settings, requestedModelName) => {
-  const explicitModelName = typeof requestedModelName === "string" ? requestedModelName.trim() : "";
-  if (explicitModelName) {
-    return explicitModelName;
-  }
-  const settingsModelName = typeof settings.AI_MODEL === "string" ? settings.AI_MODEL.trim() : "";
-  return settingsModelName || DEFAULT_AI_MODEL;
-};
-var getOpenRouterModelKwargs = (apiEndpoint) => {
-  const endpoint = String(apiEndpoint ?? "").trim();
-  if (!endpoint) {
-    return {};
-  }
-  let hostname = "";
-  try {
-    hostname = new URL(endpoint).hostname;
-  } catch {
-    hostname = endpoint;
-  }
-  if (!hostname.toLowerCase().includes("openrouter")) {
-    return {};
-  }
-  return {
-    provider: {
-      ignore: ["azure"]
-    }
-  };
-};
-var getAiSettings = async (userName = "root") => {
-  let settingsPromise = userSettingsCache.get(userName);
-  if (!settingsPromise) {
-    settingsPromise = (0, import_userSettings.getUserSettings)(userName).then((settings2) => {
-      const endpoint = (0, import_aiEndpoints.normalizeAiEndpoint)(settings2.AI_API_ENDPOINT);
-      return {
-        ...settings2,
-        AI_API_ENDPOINT: endpoint,
-        AI_MODEL: (0, import_aiModels.normalizeAiModel)(settings2.AI_MODEL, endpoint),
-        AI_RESPONSE_LANGUAGE: (0, import_aiLanguages.normalizeAiResponseLanguage)(
-          settings2.AI_RESPONSE_LANGUAGE
-        )
-      };
-    });
-    settingsPromise.catch(() => {
-      userSettingsCache.delete(userName);
-    });
-    userSettingsCache.set(userName, settingsPromise);
-  }
-  const settings = await settingsPromise;
-  if (!settings.AI_API_KEY || !settings.AI_API_ENDPOINT) {
-    throw new Error(`AI settings are incomplete for user ${userName}`);
-  }
-  return settings;
-};
-var createAiModel = async (userName = "root", requestedModelName) => {
-  const settings = await getAiSettings(userName);
-  const modelName = resolveAiModelName(settings, requestedModelName);
-  const cacheKey = getAiModelCacheKey(userName, modelName);
-  let modelPromise = aiModelCache.get(cacheKey);
-  if (!modelPromise) {
-    modelPromise = (async () => {
-      const { ChatOpenAI } = await import("@langchain/openai");
-      const modelKwargs = getOpenRouterModelKwargs(settings.AI_API_ENDPOINT);
-      return new ChatOpenAI({
-        temperature: 0.2,
-        modelName,
-        apiKey: settings.AI_API_KEY,
-        ...Object.keys(modelKwargs).length ? { modelKwargs } : {},
-        configuration: {
-          baseURL: settings.AI_API_ENDPOINT,
-          defaultHeaders: {
-            "HTTP-Referer": "https://tradejs.dev",
-            "X-Title": "Inv"
-          }
-        }
-      });
-    })();
-    modelPromise.catch(() => {
-      aiModelCache.delete(cacheKey);
-    });
-    aiModelCache.set(cacheKey, modelPromise);
-  }
-  return modelPromise;
-};
-var getAiModel = async (userName = "root", requestedModelName) => {
-  const settings = await getAiSettings(userName);
-  const resolvedModelName = resolveAiModelName(settings, requestedModelName);
-  try {
-    return await createAiModel(userName, resolvedModelName);
-  } catch (error) {
-    aiModelCache.delete(getAiModelCacheKey(userName, resolvedModelName));
-    userSettingsCache.delete(userName);
-    throw error;
-  }
-};
 var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
-  const [{ HumanMessage, SystemMessage }, model, settings] = await Promise.all([
-    import("@langchain/core/messages"),
-    getAiModel(options.userName, options.model),
-    getAiSettings(options.userName)
-  ]);
-  const messages = [];
-  const responseLanguage = (0, import_aiLanguages.getAiResponseLanguagePromptName)(
-    settings.AI_RESPONSE_LANGUAGE || import_aiLanguages.DEFAULT_AI_RESPONSE_LANGUAGE
-  );
-  messages.push(new SystemMessage(systemPrompt));
-  messages.push(
-    new SystemMessage(
-      `Write all user-visible text fields in ${responseLanguage}. Keep field names and JSON syntax unchanged.`
-    )
-  );
-  messages.push(
-    new HumanMessage({
-      content: [
-        {
-          type: "text",
-          text: humanPrompt
-        }
-      ]
-    })
+  const settings = await getAiUserSettings(options.userName);
+  const responseLanguage = (0, import_aiLanguages2.getAiResponseLanguagePromptName)(
+    settings.AI_RESPONSE_LANGUAGE || import_aiLanguages2.DEFAULT_AI_RESPONSE_LANGUAGE
   );
-  let response;
-  try {
-    response = await model.invoke(messages);
-  } catch (error) {
-    throw getAiInvocationError(error);
-  }
-  const responseContent = normalizeResponseContent(response?.content);
-  if (isEmptyResponseContent(responseContent)) {
-    throw new Error("AI provider returned an empty chat completion");
-  }
-  const parsed = parseAIResponse(responseContent);
+  const response = await invokeAiPromptChat({
+    userName: options.userName,
+    model: options.model,
+    messages: [
+      { role: "system", content: systemPrompt },
+      {
+        role: "system",
+        content: `Write all user-visible text fields in ${responseLanguage}. Keep field names and JSON syntax unchanged.`
+      },
+      { role: "user", content: humanPrompt }
+    ]
+  });
+  const parsed = parseAIResponse(response.content);
   const normalized = normalizeAnalysis(parsed);
   if (!options.signal) {
     return normalized;
@@ -6241,7 +6230,323 @@ var createStrategyRuntime = ({
 setStrategyRuntimeFactory(createStrategyRuntime);
 
 // src/connectorsRegistry.ts
+var import_logger14 = require("@tradejs/infra/logger");
+
+// src/connectorRuntime.ts
+var import_logger13 = require("@tradejs/infra/logger");
+var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
+
+// src/timescaleCachedKline.ts
+var import_constants6 = require("@tradejs/core/constants");
+var import_data4 = require("@tradejs/core/data");
+var import_time2 = require("@tradejs/core/time");
+var import_async = require("@tradejs/core/async");
 var import_logger12 = require("@tradejs/infra/logger");
+var import_candles = require("@tradejs/infra/timescale/candles");
+var DEFAULT_LIMIT = 1e3;
+var DEFAULT_CACHE_FALLBACK_WINDOW = 1e3;
+var DEFAULT_TIMESCALE_RETRIES = 2;
+var DEFAULT_TIMESCALE_RETRY_DELAY_MS = 1e3;
+var resolveNonNegativeInt = (value, fallback) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return Math.floor(parsed);
+};
+var getTimescaleRetryCount = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRIES,
+  DEFAULT_TIMESCALE_RETRIES
+);
+var getTimescaleRetryDelayMs = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRY_DELAY_MS,
+  DEFAULT_TIMESCALE_RETRY_DELAY_MS
+);
+var intervalMsOf = (interval) => interval * 6e4;
+var clampToClosedCandle = (value, intervalMs) => Math.floor(value / intervalMs) * intervalMs;
+var normalizeRangeToClosed = (intervalMs, start, end) => {
+  const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+  const normStart = start !== void 0 ? clampToClosedCandle(start, intervalMs) : 0;
+  const cappedEnd = Math.min(end ?? Date.now(), lastClosed);
+  const normEnd = clampToClosedCandle(cappedEnd, intervalMs);
+  return { normStart, normEnd };
+};
+var rowsToKline = (rows) => rows.map(({ ts, ...data }) => ({
+  timestamp: new Date(ts).getTime(),
+  ...data
+}));
+var createTimescaleCachedKline = ({
+  provider,
+  request,
+  intervalToMinutes,
+  limit = DEFAULT_LIMIT,
+  cacheFallbackWindow = DEFAULT_CACHE_FALLBACK_WINDOW
+}) => {
+  let isTimescaleFallbackMode = false;
+  const runTimescaleOperation = async (operation) => {
+    const retries = getTimescaleRetryCount();
+    const retryDelayMs = getTimescaleRetryDelayMs();
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt >= retries) {
+          throw error;
+        }
+        const waitMs = retryDelayMs * 2 ** attempt;
+        if (waitMs > 0) {
+          await (0, import_async.delay)(waitMs);
+        }
+      }
+    }
+  };
+  const loadData = async (direction, pointer, limitBoundary, requestParams, intervalMs, options = {}) => {
+    if (pointer === void 0) return { data: [], loaded: false };
+    let accumulated = [];
+    let fulfilled = false;
+    let loaded = false;
+    const shouldAccumulate = options.accumulate ?? true;
+    while (!fulfilled) {
+      const currentPointer = pointer;
+      const params = {
+        symbol: requestParams.symbol,
+        interval: requestParams.interval,
+        silent: requestParams.silent,
+        end: requestParams.end
+      };
+      if (direction === "older") {
+        params.end = pointer;
+        if (limitBoundary !== void 0) params.start = limitBoundary;
+      } else {
+        params.start = pointer;
+        if (limitBoundary !== void 0) params.end = limitBoundary;
+      }
+      const partData = await request(params);
+      if (!partData.length) {
+        fulfilled = true;
+        break;
+      }
+      loaded = true;
+      if (options.onPartData) {
+        await options.onPartData(partData);
+      }
+      if (shouldAccumulate) {
+        accumulated = direction === "older" ? (0, import_data4.mergeData)(partData, accumulated) : (0, import_data4.mergeData)(accumulated, partData);
+      }
+      const boundaryReached = limitBoundary !== void 0 && (direction === "older" && currentPointer <= limitBoundary || direction === "newer" && currentPointer >= limitBoundary);
+      if (partData.length < limit || boundaryReached) {
+        fulfilled = true;
+        break;
+      }
+      const nextPointer = direction === "older" ? (0, import_time2.getItemTimestamp)(partData[0]) - intervalMs : (0, import_time2.getItemTimestamp)(partData[partData.length - 1]) + intervalMs;
+      if (!Number.isFinite(nextPointer) || nextPointer === currentPointer) {
+        fulfilled = true;
+        break;
+      }
+      pointer = nextPointer;
+    }
+    return { data: accumulated, loaded };
+  };
+  const refreshTail = async ({
+    symbol,
+    interval,
+    silent,
+    tailCount = 2
+  }) => {
+    const intMinutes = intervalToMinutes(interval);
+    if (!intMinutes) {
+      import_logger12.logger.log("error", "refreshTail: invalid interval %s", interval);
+      return;
+    }
+    const intervalMs = intervalMsOf(intMinutes);
+    const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+    const tailEnd = lastClosed + intervalMs;
+    const tailStart = tailEnd - tailCount * intervalMs;
+    const part = await request({
+      symbol,
+      interval,
+      start: tailStart,
+      end: tailEnd,
+      silent
+    });
+    if (part.length) {
+      await runTimescaleOperation(
+        () => (0, import_candles.upsertCandles)((0, import_candles.toRows)(provider, symbol, intMinutes, part))
+      );
+    }
+  };
+  return async ({
+    symbol,
+    interval,
+    start: defaultStart,
+    end: defaultEnd,
+    silent = false,
+    cacheOnly = false,
+    warmOnly = false
+  }) => {
+    const intMinutes = intervalToMinutes(interval);
+    if (!intMinutes) {
+      import_logger12.logger.log("error", "kline: invalid interval %s", interval);
+      return [];
+    }
+    if (defaultStart !== void 0 && defaultEnd !== void 0 && defaultEnd <= defaultStart) {
+      return [];
+    }
+    const intervalMs = intervalMsOf(intMinutes);
+    try {
+      const edges = await runTimescaleOperation(
+        () => (0, import_candles.getDataEdges)(provider, symbol, intMinutes)
+      );
+      let dataStart = edges.min;
+      let dataEnd = edges.max;
+      const { normStart, normEnd } = normalizeRangeToClosed(
+        intervalMs,
+        defaultStart,
+        defaultEnd
+      );
+      if (cacheOnly) {
+        const base = edges.max ?? Date.now();
+        const s = Math.max(
+          defaultStart ?? base - cacheFallbackWindow * intervalMs,
+          0
+        );
+        const e = defaultEnd ?? base;
+        const dbData2 = await runTimescaleOperation(
+          () => (0, import_candles.getCandlesRange)(provider, symbol, intMinutes, s, e)
+        );
+        return rowsToKline(dbData2);
+      }
+      const needOlderData = defaultStart !== void 0 && (dataStart === void 0 || normStart < dataStart);
+      const persistPartData = warmOnly ? (partData) => runTimescaleOperation(
+        () => (0, import_candles.upsertCandles)((0, import_candles.toRows)(provider, symbol, intMinutes, partData))
+      ) : void 0;
+      if (needOlderData) {
+        const pointerForOlder = dataStart ?? normEnd ?? Date.now();
+        const olderResult = await loadData(
+          "older",
+          pointerForOlder,
+          normStart,
+          {
+            symbol,
+            interval,
+            silent,
+            start: normStart,
+            end: pointerForOlder
+          },
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
+        );
+        if (warmOnly && olderResult.loaded) {
+          dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
+        } else if (olderResult.data.length) {
+          await runTimescaleOperation(
+            () => (0, import_candles.upsertCandles)(
+              (0, import_candles.toRows)(provider, symbol, intMinutes, olderResult.data)
+            )
+          );
+          dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
+        }
+      }
+      const needNewerData = defaultEnd !== void 0 && (dataEnd === void 0 || normEnd > dataEnd);
+      if (needNewerData) {
+        const fallbackStart = (0, import_time2.getTimestamp)(import_constants6.PRELOAD_FALLBACK_DAYS);
+        const pointerForNewer = dataEnd ?? (defaultStart !== void 0 ? normStart : fallbackStart) ?? 0;
+        const newerResult = await loadData(
+          "newer",
+          pointerForNewer,
+          normEnd,
+          {
+            symbol,
+            interval,
+            silent,
+            start: pointerForNewer,
+            end: normEnd
+          },
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
+        );
+        if (warmOnly && newerResult.loaded) {
+          dataEnd = normEnd;
+        } else if (newerResult.data.length) {
+          await runTimescaleOperation(
+            () => (0, import_candles.upsertCandles)(
+              (0, import_candles.toRows)(provider, symbol, intMinutes, newerResult.data)
+            )
+          );
+          dataEnd = normEnd;
+        }
+      }
+      const isRightEdgeQuery = defaultEnd === void 0 || defaultEnd && defaultEnd >= Date.now() - intervalMs;
+      if (!cacheOnly && isRightEdgeQuery) {
+        await refreshTail({ symbol, interval, silent });
+      }
+      if (warmOnly) {
+        if (isTimescaleFallbackMode) {
+          isTimescaleFallbackMode = false;
+          import_logger12.logger.log("info", "TimescaleDB connection restored for kline cache");
+        }
+        return [];
+      }
+      const rangeStart = defaultStart ?? dataStart ?? 0;
+      const rangeEnd = defaultEnd ?? dataEnd ?? Date.now();
+      const { normStart: finalStart, normEnd: finalEnd } = normalizeRangeToClosed(intervalMs, rangeStart, rangeEnd);
+      const dbData = await runTimescaleOperation(
+        () => (0, import_candles.getCandlesRange)(provider, symbol, intMinutes, finalStart, finalEnd)
+      );
+      if (isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = false;
+        import_logger12.logger.log("info", "TimescaleDB connection restored for kline cache");
+      }
+      return rowsToKline(dbData);
+    } catch (error) {
+      if (!isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = true;
+        import_logger12.logger.log(
+          "warn",
+          "TimescaleDB unavailable for %s %s: %s. Falling back to exchange API.",
+          symbol,
+          interval,
+          String(error)
+        );
+      }
+      if (cacheOnly || warmOnly) {
+        return [];
+      }
+      return request({
+        symbol,
+        interval,
+        start: defaultStart,
+        end: defaultEnd,
+        silent
+      });
+    }
+  };
+};
+
+// src/connectorRuntime.ts
+var connectorRuntime = {
+  logger: import_logger13.logger,
+  resolveTradingAccount: import_tradingAccounts.resolveTradingAccount,
+  createCachedKline: createTimescaleCachedKline
+};
+var bindConnectorRuntime = (creator, runtime = connectorRuntime) => {
+  const boundCreator = (config) => creator(config, runtime);
+  return boundCreator;
+};
+
+// src/connectorsRegistry.ts
 var createConnectorRegistryState = () => ({
   connectorCreators: /* @__PURE__ */ new Map(),
   providerToConnectorName: /* @__PURE__ */ new Map(),
@@ -6293,7 +6598,7 @@ var normalizeProviders = (providers, connectorName) => {
 var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
-    import_logger12.logger.warn(
+    import_logger14.logger.warn(
       'Skip duplicate connector provider "%s" from %s: already mapped to %s',
       provider,
       source,
@@ -6306,11 +6611,11 @@ var registerProvider = (provider, connectorName, source, providerToConnectorName
 var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
-    import_logger12.logger.warn("Skip connector entry without name from %s", source);
+    import_logger14.logger.warn("Skip connector entry without name from %s", source);
     return;
   }
   if (typeof entry.creator !== "function") {
-    import_logger12.logger.warn(
+    import_logger14.logger.warn(
       'Skip connector entry "%s" from %s: creator must be a function',
       connectorName,
       source
@@ -6322,7 +6627,7 @@ var registerEntry = (entry, source, state) => {
     state.connectorCreators
   );
   if (existingByName) {
-    import_logger12.logger.warn(
+    import_logger14.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
       connectorName,
       source,
@@ -6330,7 +6635,10 @@ var registerEntry = (entry, source, state) => {
     );
     return;
   }
-  state.connectorCreators.set(connectorName, entry.creator);
+  state.connectorCreators.set(
+    connectorName,
+    bindConnectorRuntime(entry.creator)
+  );
   const providers = normalizeProviders(entry.providers, connectorName);
   for (const provider of providers) {
     registerProvider(
@@ -6394,7 +6702,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           );
           const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
           if (!pluginDefinition) {
-            import_logger12.logger.warn(
+            import_logger14.logger.warn(
               'Skip connector plugin "%s": export { connectorEntries } is missing',
               moduleName
             );
@@ -6402,7 +6710,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           }
           registerEntries2(pluginDefinition.connectorEntries, moduleName, state);
         } catch (error) {
-          import_logger12.logger.warn(
+          import_logger14.logger.warn(
             'Failed to load connector plugin "%s": %s',
             moduleName,
             String(error)
@@ -6547,7 +6855,7 @@ var import_coreResearch = require("@tradejs/infra/coreResearch");
 var import_ml3 = require("@tradejs/infra/ml");
 
 // src/executionCosts.ts
-var import_constants6 = require("@tradejs/core/constants");
+var import_constants7 = require("@tradejs/core/constants");
 var finiteOr = (value, fallback) => {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
@@ -6587,8 +6895,8 @@ var resolveExecutionCosts = async (params) => {
   const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
   const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
   const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
-  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? import_constants6.FEE_PERCENT;
-  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? import_constants6.FEE_PERCENT;
+  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? import_constants7.FEE_PERCENT;
+  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? import_constants7.FEE_PERCENT;
   const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
   const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
   const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
@@ -6609,18 +6917,18 @@ var resolveExecutionCosts = async (params) => {
         toTimestamp: fundingRates.at(-1)?.timestamp ?? null
       },
       slippage: {
-        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, import_constants6.BACKTEST_BASE_SLIPPAGE_BPS),
+        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, import_constants7.BACKTEST_BASE_SLIPPAGE_BPS),
         spreadMultiplier: finiteOr(
           config.SLIPPAGE_SPREAD_MULTIPLIER,
-          import_constants6.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
+          import_constants7.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
         ),
         marketImpactBps: finiteOr(
           config.SLIPPAGE_MARKET_IMPACT_BPS,
-          import_constants6.BACKTEST_MARKET_IMPACT_BPS
+          import_constants7.BACKTEST_MARKET_IMPACT_BPS
         ),
         delayRiskMultiplier: finiteOr(
           config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
-          import_constants6.BACKTEST_DELAY_RISK_MULTIPLIER
+          import_constants7.BACKTEST_DELAY_RISK_MULTIPLIER
         ),
         source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
       },
@@ -6638,7 +6946,7 @@ var resolveExecutionCosts = async (params) => {
 
 // src/testConnector.ts
 var import_node_crypto4 = require("crypto");
-var import_constants7 = require("@tradejs/core/constants");
+var import_constants8 = require("@tradejs/core/constants");
 var import_backtest = require("@tradejs/core/backtest");
 var import_trade2 = require("@tradejs/core/trade");
 var import_math = require("@tradejs/core/math");
@@ -6665,14 +6973,14 @@ var createTestConnector = (connector, context) => {
   const positionLog = [];
   const fastMode = Boolean(context?.fastMode);
   const executionCostModel = context?.executionCostModel;
-  const makerFeeRate = executionCostModel?.fees.makerRate ?? import_constants7.FEE_PERCENT;
-  const takerFeeRate = executionCostModel?.fees.takerRate ?? import_constants7.FEE_PERCENT;
+  const makerFeeRate = executionCostModel?.fees.makerRate ?? import_constants8.FEE_PERCENT;
+  const takerFeeRate = executionCostModel?.fees.takerRate ?? import_constants8.FEE_PERCENT;
   const fundingRates = [...context?.fundingRates ?? []].sort(
     (left, right) => left.timestamp - right.timestamp
   );
   const processedFundingTimestamps = /* @__PURE__ */ new Set();
   let currentPosition = null;
-  let amount = import_constants7.INITIAL_BACKTEST_AMOUNT;
+  let amount = import_constants8.INITIAL_BACKTEST_AMOUNT;
   let originalQty = 0;
   let currentPositionProfit = 0;
   let currentSignalId = null;
@@ -7115,7 +7423,7 @@ var createTestConnector = (connector, context) => {
           profit: fullStat.netProfit
         } : {
           amount: (0, import_math.round)(amount),
-          profit: (0, import_math.round)(amount - import_constants7.INITIAL_BACKTEST_AMOUNT),
+          profit: (0, import_math.round)(amount - import_constants8.INITIAL_BACKTEST_AMOUNT),
           orders: positionLog.length
         },
         orderLogId,
@@ -8143,7 +8451,7 @@ var BACKTEST_INTERVAL = "15";
 var resolveBacktestExecutionInterval = (interval) => {
   const normalized = String(interval);
   if (normalized === "15") {
-    return import_constants8.BACKTEST_EXECUTION_INTERVAL;
+    return import_constants9.BACKTEST_EXECUTION_INTERVAL;
   }
   if (normalized === "60") {
     return "15";
@@ -8190,7 +8498,7 @@ var filterClosedAlignedCandles = (data, btcData, interval) => {
   };
 };
 var shouldLoadBacktestExecutionCandles = (interval) => {
-  if (!import_constants8.BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED) {
+  if (!import_constants9.BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED) {
     return false;
   }
   const executionInterval = resolveBacktestExecutionInterval(interval);
@@ -8300,7 +8608,7 @@ var prepareTestingData = async (params) => {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
   if (!binanceConnector || !coinbaseConnector) {
-    import_logger13.logger.warn(
+    import_logger15.logger.warn(
       "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
       connectorName
     );
@@ -8583,7 +8891,7 @@ var testing = async (test) => {
   if (!start) {
     throw new Error("no start");
   }
-  const preloadStart = (0, import_time2.getBacktestPreloadStart)(start);
+  const preloadStart = (0, import_time3.getBacktestPreloadStart)(start);
   const progress = createBacktestProgress({
     testName: name,
     symbol,
@@ -8683,7 +8991,7 @@ var testingGroupInSharedCandleLoop = async (tests) => {
   if (!start) {
     throw new Error("no start");
   }
-  const preloadStart = (0, import_time2.getBacktestPreloadStart)(start);
+  const preloadStart = (0, import_time3.getBacktestPreloadStart)(start);
   const progress = createBacktestProgress({
     testName: first.name,
     symbol,