@tradejs/node 1.0.0

package/dist/pine.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pine.ts
+var pine_exports = {};
+__export(pine_exports, {
+  createLoadPineScript: () => createLoadPineScript,
+  loadPineScript: () => loadPineScript,
+  runPineScript: () => runPineScript
+});
+module.exports = __toCommonJS(pine_exports);
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+__reExport(pine_exports, require("@tradejs/core/pine"), module.exports);
+var loadPinets = () => {
+  const resolvedPath = require.resolve("pinets");
+  const cjsPath = resolvedPath.includes("pinets.min.browser") ? resolvedPath.replace(/pinets\.min\.browser(\.es)?\.js$/, "pinets.min.cjs") : resolvedPath;
+  return require(cjsPath);
+};
+var loadPineScript = (filePath, fallback = "") => {
+  const resolvedPath = String(filePath || "").trim();
+  if (!resolvedPath) {
+    return fallback;
+  }
+  try {
+    return import_node_fs.default.readFileSync(resolvedPath, "utf8").trim();
+  } catch {
+    return fallback;
+  }
+};
+var createLoadPineScript = (baseDir) => {
+  const resolvedBaseDir = import_node_path.default.resolve(baseDir);
+  return (fileNameOrPath, fallback = "") => {
+    const rawPath = String(fileNameOrPath || "").trim();
+    if (!rawPath) {
+      return fallback;
+    }
+    const resolvedPath = import_node_path.default.isAbsolute(rawPath) ? rawPath : import_node_path.default.resolve(resolvedBaseDir, rawPath);
+    return loadPineScript(resolvedPath, fallback);
+  };
+};
+var MINUTE_MS = 6e4;
+var normalizeTimestampMs = (timestamp) => timestamp < 1e12 ? timestamp * 1e3 : timestamp;
+var resolveCandleDuration = (candles) => {
+  if (candles.length < 2) {
+    return MINUTE_MS;
+  }
+  const first = normalizeTimestampMs(candles[0].timestamp);
+  const second = normalizeTimestampMs(candles[1].timestamp);
+  const duration = Math.max(second - first, MINUTE_MS);
+  return Number.isFinite(duration) && duration > 0 ? duration : MINUTE_MS;
+};
+var toPineRuntimeCandles = (candles) => {
+  const candleDuration = resolveCandleDuration(candles);
+  return candles.map((candle) => {
+    const openTime = normalizeTimestampMs(candle.timestamp);
+    return {
+      open: Number(candle.open),
+      high: Number(candle.high),
+      low: Number(candle.low),
+      close: Number(candle.close),
+      volume: Number(candle.volume ?? 0),
+      openTime,
+      closeTime: openTime + candleDuration
+    };
+  });
+};
+var runPineScript = async ({
+  candles,
+  script,
+  symbol = "SYMBOL",
+  timeframe = "15",
+  inputs = {},
+  limit
+}) => {
+  const { PineTS, Indicator } = loadPinets();
+  const trimmedScript = String(script || "").trim();
+  if (!trimmedScript) {
+    throw new Error("Pine script is empty");
+  }
+  if (!Array.isArray(candles) || candles.length === 0) {
+    throw new Error("No candles provided for Pine script execution");
+  }
+  const pineCandles = toPineRuntimeCandles(candles);
+  const pine = new PineTS(
+    pineCandles,
+    symbol,
+    timeframe,
+    Math.max(1, limit ?? pineCandles.length)
+  );
+  const indicator = new Indicator(trimmedScript, inputs);
+  const context = await pine.run(indicator);
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLoadPineScript,
+  loadPineScript,
+  runPineScript,
+  ...require("@tradejs/core/pine")
+});

package/dist/pine.mjs

@@ -0,0 +1,11 @@
+import {
+  createLoadPineScript,
+  loadPineScript,
+  runPineScript
+} from "./chunk-CVTV6S2V.mjs";
+import "./chunk-6DZX6EAA.mjs";
+export {
+  createLoadPineScript,
+  loadPineScript,
+  runPineScript
+};

package/dist/registry.d.mts

@@ -0,0 +1,15 @@
+import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
+
+declare const ensureStrategyPluginsLoaded: () => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: () => Promise<void>;
+declare const getStrategyCreator: (name: string) => Promise<StrategyCreator | undefined>;
+declare const getAvailableStrategyNames: () => Promise<string[]>;
+declare const getRegisteredStrategies: () => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: () => StrategyManifest[];
+declare const getStrategyManifest: (name?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[]) => void;
+declare const resetStrategyRegistryCache: () => void;
+declare const strategies: Record<string, StrategyCreator>;
+
+export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };

package/dist/registry.d.ts

@@ -0,0 +1,15 @@
+import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
+
+declare const ensureStrategyPluginsLoaded: () => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: () => Promise<void>;
+declare const getStrategyCreator: (name: string) => Promise<StrategyCreator | undefined>;
+declare const getAvailableStrategyNames: () => Promise<string[]>;
+declare const getRegisteredStrategies: () => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: () => StrategyManifest[];
+declare const getStrategyManifest: (name?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[]) => void;
+declare const resetStrategyRegistryCache: () => void;
+declare const strategies: Record<string, StrategyCreator>;
+
+export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };

package/dist/registry.js

@@ -0,0 +1,439 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ensureIndicatorPluginsLoaded: () => ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded: () => ensureStrategyPluginsLoaded,
+  getAvailableStrategyNames: () => getAvailableStrategyNames,
+  getRegisteredManifests: () => getRegisteredManifests,
+  getRegisteredStrategies: () => getRegisteredStrategies,
+  getStrategyCreator: () => getStrategyCreator,
+  getStrategyManifest: () => getStrategyManifest,
+  isKnownStrategy: () => isKnownStrategy,
+  registerStrategyEntries: () => registerStrategyEntries,
+  resetStrategyRegistryCache: () => resetStrategyRegistryCache,
+  strategies: () => strategies
+});
+module.exports = __toCommonJS(registry_exports);
+
+// src/strategy/manifests.ts
+var import_indicators = require("@tradejs/core/indicators");
+var import_logger2 = require("@tradejs/infra/logger");
+
+// src/tradejsConfig.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_module = require("module");
+var import_url = require("url");
+var import_logger = require("@tradejs/infra/logger");
+var CONFIG_FILE_NAMES = [
+  "tradejs.config.ts",
+  "tradejs.config.mts",
+  "tradejs.config.js",
+  "tradejs.config.mjs",
+  "tradejs.config.cjs"
+];
+var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
+var cachedByCwd = /* @__PURE__ */ new Map();
+var announcedConfigFile = /* @__PURE__ */ new Set();
+var tsNodeRegistered = false;
+var getTradejsProjectCwd = (cwd) => {
+  const explicit = String(cwd ?? "").trim();
+  if (explicit) {
+    return import_path.default.resolve(explicit);
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return import_path.default.resolve(fromEnv);
+  }
+  return process.cwd();
+};
+var normalizeConfig = (rawConfig) => {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
+  }
+  const config = rawConfig;
+  const strategies2 = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const indicators = Array.isArray(config.indicators) ? config.indicators.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const connectors = Array.isArray(config.connectors) ? config.connectors.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  return {
+    strategies: strategies2,
+    indicators,
+    connectors
+  };
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => (0, import_module.createRequire)(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
+var ensureTsNodeRegistered = async () => {
+  if (tsNodeRegistered) {
+    return;
+  }
+  const tsNodeModule = await import("ts-node");
+  const tsNode = tsNodeModule.default ?? tsNodeModule;
+  tsNode.register?.({
+    transpileOnly: true,
+    compilerOptions: {
+      module: "commonjs",
+      moduleResolution: "node"
+    }
+  });
+  tsNodeRegistered = true;
+};
+var toImportSpecifier = (moduleName) => {
+  if (moduleName.startsWith("file://")) {
+    return moduleName;
+  }
+  if (import_path.default.isAbsolute(moduleName)) {
+    return (0, import_url.pathToFileURL)(moduleName).href;
+  }
+  return moduleName;
+};
+var isTsModulePath = (moduleName) => TS_MODULE_RE.test(moduleName.split("?")[0]);
+var isRelativeModulePath = (moduleName) => moduleName.startsWith("./") || moduleName.startsWith("../");
+var isBareModuleSpecifier = (moduleName) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return false;
+  }
+  if (normalized.startsWith("file://") || import_path.default.isAbsolute(normalized) || isRelativeModulePath(normalized)) {
+    return false;
+  }
+  return true;
+};
+var importConfigFile = async (configFilePath) => {
+  const ext = import_path.default.extname(configFilePath).toLowerCase();
+  const configFileUrl = `${toImportSpecifier(configFilePath)}?t=${Date.now()}`;
+  if (ext === ".ts" || ext === ".mts") {
+    const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
+    await ensureTsNodeRegistered();
+    return requireFn(configFilePath);
+  }
+  return import(
+    /* webpackIgnore: true */
+    configFileUrl
+  );
+};
+var importTradejsModule = async (moduleName) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return {};
+  }
+  let modulePath = normalized;
+  if (normalized.startsWith("file://")) {
+    try {
+      modulePath = (0, import_url.fileURLToPath)(normalized);
+    } catch {
+      modulePath = normalized;
+    }
+  }
+  const requireFn = getRequireFn(
+    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : getTradejsProjectCwd()
+  );
+  if (isTsModulePath(modulePath)) {
+    await ensureTsNodeRegistered();
+    return requireFn(modulePath);
+  }
+  if (isBareModuleSpecifier(normalized)) {
+    return requireFn(normalized);
+  }
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      toImportSpecifier(normalized)
+    );
+  } catch (error) {
+    if (isTsModulePath(modulePath)) {
+      await ensureTsNodeRegistered();
+      return requireFn(modulePath);
+    }
+    throw error;
+  }
+};
+var resolveExportedConfig = (moduleExports) => {
+  const candidate = moduleExports && typeof moduleExports === "object" && "default" in moduleExports ? moduleExports.default : moduleExports;
+  return normalizeConfig(candidate);
+};
+var findConfigFilePath = (cwd) => {
+  let currentDir = import_path.default.resolve(cwd);
+  while (true) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const fullPath = import_path.default.join(currentDir, fileName);
+      if (import_fs.default.existsSync(fullPath) && import_fs.default.statSync(fullPath).isFile()) {
+        return fullPath;
+      }
+    }
+    const parentDir = import_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+};
+var resolvePluginModuleSpecifier = (moduleName, cwd = getTradejsProjectCwd()) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.startsWith("file://")) {
+    try {
+      return (0, import_url.fileURLToPath)(normalized);
+    } catch {
+      return normalized;
+    }
+  }
+  if (import_path.default.isAbsolute(normalized)) {
+    return normalized;
+  }
+  if (isRelativeModulePath(normalized)) {
+    return import_path.default.resolve(cwd, normalized);
+  }
+  return normalized;
+};
+var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
+  const cached = cachedByCwd.get(cwd);
+  if (cached) {
+    return cached;
+  }
+  const configFilePath = findConfigFilePath(cwd);
+  if (!configFilePath) {
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+  try {
+    const moduleExports = await importConfigFile(configFilePath);
+    const config = resolveExportedConfig(moduleExports);
+    cachedByCwd.set(cwd, config);
+    if (!announcedConfigFile.has(configFilePath)) {
+      announcedConfigFile.add(configFilePath);
+      import_logger.logger.log("info", "Loaded TradeJS config: %s", configFilePath);
+    }
+    return config;
+  } catch (error) {
+    import_logger.logger.log(
+      "warn",
+      "Failed to load TradeJS config from %s: %s",
+      configFilePath,
+      String(error)
+    );
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+};
+
+// src/strategy/manifests.ts
+var strategyCreators = /* @__PURE__ */ new Map();
+var strategyManifestsMap = /* @__PURE__ */ new Map();
+var pluginsLoadPromise = null;
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async () => {
+  const config = await loadTradejsConfig();
+  return {
+    strategyModules: toUniqueModules(config.strategies),
+    indicatorModules: toUniqueModules(config.indicators)
+  };
+};
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
+};
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var registerEntries = (entries, source) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest?.name;
+    if (!strategyName) {
+      import_logger2.logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (strategyCreators.has(strategyName)) {
+      import_logger2.logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    strategyCreators.set(strategyName, entry.creator);
+    strategyManifestsMap.set(strategyName, entry.manifest);
+  }
+};
+var importStrategyPluginModule = async (moduleName) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureStrategyPluginsLoaded = async () => {
+  if (pluginsLoadPromise) {
+    return pluginsLoadPromise;
+  }
+  pluginsLoadPromise = (async () => {
+    const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames();
+    const strategySet = new Set(strategyModules);
+    const indicatorSet = new Set(indicatorModules);
+    const pluginModuleNames = [
+      .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+    ];
+    if (!pluginModuleNames.length) return;
+    for (const moduleName of pluginModuleNames) {
+      try {
+        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
+        const moduleExport = await importStrategyPluginModule(resolvedModuleName);
+        if (strategySet.has(moduleName)) {
+          const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+          if (!pluginDefinition) {
+            import_logger2.logger.warn(
+              'Skip strategy plugin "%s": export { strategyEntries } is missing',
+              moduleName
+            );
+          } else {
+            registerEntries(pluginDefinition.strategyEntries, moduleName);
+          }
+        }
+        if (indicatorSet.has(moduleName)) {
+          const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+          if (!indicatorPluginDefinition) {
+            import_logger2.logger.warn(
+              'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+              moduleName
+            );
+          } else {
+            (0, import_indicators.registerIndicatorEntries)(
+              indicatorPluginDefinition.indicatorEntries,
+              moduleName
+            );
+          }
+        }
+        if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+          import_logger2.logger.warn(
+            'Skip plugin "%s": no strategy/indicator sections requested in config',
+            moduleName
+          );
+        }
+      } catch (error) {
+        import_logger2.logger.warn(
+          'Failed to load plugin "%s": %s',
+          moduleName,
+          String(error)
+        );
+      }
+    }
+  })();
+  return pluginsLoadPromise;
+};
+var ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
+var getStrategyCreator = async (name) => {
+  await ensureStrategyPluginsLoaded();
+  return strategyCreators.get(name);
+};
+var getAvailableStrategyNames = async () => {
+  await ensureStrategyPluginsLoaded();
+  return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getRegisteredStrategies = () => {
+  return Object.fromEntries(strategyCreators.entries());
+};
+var getRegisteredManifests = () => {
+  return [...strategyManifestsMap.values()];
+};
+var getStrategyManifest = (name) => {
+  return name ? strategyManifestsMap.get(name) : void 0;
+};
+var isKnownStrategy = (name) => {
+  return strategyCreators.has(name);
+};
+var registerStrategyEntries = (entries) => {
+  registerEntries(entries, "runtime");
+};
+var resetStrategyRegistryCache = () => {
+  strategyCreators.clear();
+  strategyManifestsMap.clear();
+  (0, import_indicators.resetIndicatorRegistryCache)();
+  pluginsLoadPromise = null;
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded,
+  getAvailableStrategyNames,
+  getRegisteredManifests,
+  getRegisteredStrategies,
+  getStrategyCreator,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+});

package/dist/registry.mjs

@@ -0,0 +1,29 @@
+import "./chunk-5YNMSWL3.mjs";
+import {
+  ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded,
+  getAvailableStrategyNames,
+  getRegisteredManifests,
+  getRegisteredStrategies,
+  getStrategyCreator,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+} from "./chunk-MHCXPD2B.mjs";
+import "./chunk-DE7ADBIR.mjs";
+import "./chunk-6DZX6EAA.mjs";
+export {
+  ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded,
+  getAvailableStrategyNames,
+  getRegisteredManifests,
+  getRegisteredStrategies,
+  getStrategyCreator,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+};