@tradejs/node 1.0.2 → 1.0.3

package/dist/strategies.js

@@ -5751,7 +5751,7 @@ var init_tradejsConfig = __esm({
 });
 
 // src/strategy/manifests.ts
-var import_indicators, import_logger3, strategyCreators, strategyManifestsMap, pluginsLoadPromise, toUniqueModules, getConfiguredPluginModuleNames, extractModuleEntries, extractStrategyPluginDefinition, extractIndicatorPluginDefinition, registerEntries, importStrategyPluginModule, ensureStrategyPluginsLoaded, ensureIndicatorPluginsLoaded, getStrategyCreator, getAvailableStrategyNames, getRegisteredStrategies, getRegisteredManifests, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies;
+var import_indicators, import_logger3, createStrategyRegistryState, registryStateByProjectRoot, getStrategyRegistryState, toUniqueModules, getConfiguredPluginModuleNames, extractModuleEntries, extractStrategyPluginDefinition, extractIndicatorPluginDefinition, registerEntries, importStrategyPluginModule, ensureStrategyPluginsLoaded, ensureIndicatorPluginsLoaded, getStrategyCreator, getAvailableStrategyNames, getRegisteredStrategies, getRegisteredManifests, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies;
 var init_manifests = __esm({
   "src/strategy/manifests.ts"() {
     "use strict";
@@ -5759,14 +5759,29 @@ var init_manifests = __esm({
     import_logger3 = require("@tradejs/infra/logger");
     init_tradejsConfig();
     init_tradejsConfig();
-    strategyCreators = /* @__PURE__ */ new Map();
-    strategyManifestsMap = /* @__PURE__ */ new Map();
-    pluginsLoadPromise = null;
+    createStrategyRegistryState = () => ({
+      strategyCreators: /* @__PURE__ */ new Map(),
+      strategyManifestsMap: /* @__PURE__ */ new Map(),
+      pluginsLoadPromise: null
+    });
+    registryStateByProjectRoot = /* @__PURE__ */ new Map();
+    getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+      const projectRoot = getTradejsProjectCwd(cwd);
+      let state = registryStateByProjectRoot.get(projectRoot);
+      if (!state) {
+        state = createStrategyRegistryState();
+        registryStateByProjectRoot.set(projectRoot, state);
+      }
+      return {
+        projectRoot,
+        state
+      };
+    };
     toUniqueModules = (modules = []) => [
       ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
     ];
-    getConfiguredPluginModuleNames = async () => {
-      const config = await loadTradejsConfig();
+    getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+      const config = await loadTradejsConfig(cwd);
       return {
         strategyModules: toUniqueModules(config.strategies),
         indicatorModules: toUniqueModules(config.indicators)
@@ -5800,14 +5815,14 @@ var init_manifests = __esm({
       );
       return indicatorEntries ? { indicatorEntries } : null;
     };
-    registerEntries = (entries, source) => {
+    registerEntries = (entries, source, state) => {
       for (const entry of entries) {
         const strategyName = entry.manifest?.name;
         if (!strategyName) {
           import_logger3.logger.warn("Skip strategy entry without name from %s", source);
           continue;
         }
-        if (strategyCreators.has(strategyName)) {
+        if (state.strategyCreators.has(strategyName)) {
           import_logger3.logger.warn(
             'Skip duplicate strategy "%s" from %s: already registered',
             strategyName,
@@ -5815,8 +5830,8 @@ var init_manifests = __esm({
           );
           continue;
         }
-        strategyCreators.set(strategyName, entry.creator);
-        strategyManifestsMap.set(strategyName, entry.manifest);
+        state.strategyCreators.set(strategyName, entry.creator);
+        state.strategyManifestsMap.set(strategyName, entry.manifest);
       }
     };
     importStrategyPluginModule = async (moduleName) => {
@@ -5828,93 +5843,119 @@ var init_manifests = __esm({
         moduleName
       );
     };
-    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_logger3.logger.warn(
-                  'Skip strategy plugin "%s": export { strategyEntries } is missing',
-                  moduleName
-                );
-              } else {
-                registerEntries(pluginDefinition.strategyEntries, moduleName);
+    ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+      const { projectRoot, state } = getStrategyRegistryState(cwd);
+      if (!state.pluginsLoadPromise) {
+        (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+        state.pluginsLoadPromise = (async () => {
+          const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+          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,
+                projectRoot
+              );
+              const moduleExport = await importStrategyPluginModule(resolvedModuleName);
+              if (strategySet.has(moduleName)) {
+                const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+                if (!pluginDefinition) {
+                  import_logger3.logger.warn(
+                    'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                    moduleName
+                  );
+                } else {
+                  registerEntries(
+                    pluginDefinition.strategyEntries,
+                    moduleName,
+                    state
+                  );
+                }
               }
-            }
-            if (indicatorSet.has(moduleName)) {
-              const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
-              if (!indicatorPluginDefinition) {
+              if (indicatorSet.has(moduleName)) {
+                const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+                if (!indicatorPluginDefinition) {
+                  import_logger3.logger.warn(
+                    'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                    moduleName
+                  );
+                } else {
+                  (0, import_indicators.registerIndicatorEntries)(
+                    indicatorPluginDefinition.indicatorEntries,
+                    moduleName,
+                    projectRoot
+                  );
+                }
+              }
+              if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
                 import_logger3.logger.warn(
-                  'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-                  moduleName
-                );
-              } else {
-                (0, import_indicators.registerIndicatorEntries)(
-                  indicatorPluginDefinition.indicatorEntries,
+                  'Skip plugin "%s": no strategy/indicator sections requested in config',
                   moduleName
                 );
               }
-            }
-            if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            } catch (error) {
               import_logger3.logger.warn(
-                'Skip plugin "%s": no strategy/indicator sections requested in config',
-                moduleName
+                'Failed to load plugin "%s": %s',
+                moduleName,
+                String(error)
               );
             }
-          } catch (error) {
-            import_logger3.logger.warn(
-              'Failed to load plugin "%s": %s',
-              moduleName,
-              String(error)
-            );
           }
-        }
-      })();
-      return pluginsLoadPromise;
+        })();
+      }
+      await state.pluginsLoadPromise;
     };
-    ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
-    getStrategyCreator = async (name) => {
-      await ensureStrategyPluginsLoaded();
-      return strategyCreators.get(name);
+    ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+    getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+      await ensureStrategyPluginsLoaded(cwd);
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyCreators.get(name);
     };
-    getAvailableStrategyNames = async () => {
-      await ensureStrategyPluginsLoaded();
-      return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+    getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+      await ensureStrategyPluginsLoaded(cwd);
+      const { state } = getStrategyRegistryState(cwd);
+      return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
     };
-    getRegisteredStrategies = () => {
-      return Object.fromEntries(strategyCreators.entries());
+    getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return Object.fromEntries(state.strategyCreators.entries());
     };
-    getRegisteredManifests = () => {
-      return [...strategyManifestsMap.values()];
+    getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return [...state.strategyManifestsMap.values()];
     };
-    getStrategyManifest = (name) => {
-      return name ? strategyManifestsMap.get(name) : void 0;
+    getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+      if (!name) {
+        return void 0;
+      }
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyManifestsMap.get(name);
     };
-    isKnownStrategy = (name) => {
-      return strategyCreators.has(name);
+    isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyCreators.has(name);
     };
-    registerStrategyEntries = (entries) => {
-      registerEntries(entries, "runtime");
+    registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      registerEntries(entries, "runtime", state);
     };
-    resetStrategyRegistryCache = () => {
-      strategyCreators.clear();
-      strategyManifestsMap.clear();
-      (0, import_indicators.resetIndicatorRegistryCache)();
-      pluginsLoadPromise = null;
+    resetStrategyRegistryCache = (cwd) => {
+      const normalizedCwd = String(cwd ?? "").trim();
+      if (!normalizedCwd) {
+        registryStateByProjectRoot.clear();
+        (0, import_indicators.resetIndicatorRegistryCache)();
+        return;
+      }
+      const projectRoot = getTradejsProjectCwd(normalizedCwd);
+      registryStateByProjectRoot.delete(projectRoot);
+      (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
     };
     strategies = new Proxy(
       {},
@@ -5923,10 +5964,10 @@ var init_manifests = __esm({
           if (typeof property !== "string") {
             return void 0;
           }
-          return strategyCreators.get(property);
+          return getStrategyRegistryState().state.strategyCreators.get(property);
         },
         ownKeys: () => {
-          return [...strategyCreators.keys()];
+          return [...getStrategyRegistryState().state.strategyCreators.keys()];
         },
         getOwnPropertyDescriptor: () => ({
           enumerable: true,
@@ -6399,6 +6440,7 @@ var buildMlPayload = (payload) => {
 };
 
 // src/strategyHelpers/runtime.ts
+init_tradejsConfig();
 var formatAiError = (err) => {
   const error = err;
   const safeJson = (value) => {
@@ -6440,7 +6482,8 @@ var enrichSignalWithMl = async ({
     const mlResult = await (0, import_ml2.fetchMlThreshold)({
       strategy,
       features,
-      threshold: ml.mlThreshold
+      threshold: ml.mlThreshold,
+      projectRoot: getTradejsProjectCwd()
     });
     if (mlResult) {
       signal.ml = mlResult;
@@ -6545,6 +6588,7 @@ var createLoadPineScript = (baseDir) => {
 
 // src/strategyRuntime.ts
 init_manifests();
+init_tradejsConfig();
 
 // src/strategyHelpers/config.ts
 var import_lodash2 = __toESM(require_lodash());
@@ -6768,6 +6812,7 @@ var createStrategyRuntime = ({
   manifest: staticManifest,
   strategyDirectory
 }) => {
+  const projectRoot = getTradejsProjectCwd();
   const resolveManifest = (name) => {
     if (!name) {
       return void 0;
@@ -6775,11 +6820,11 @@ var createStrategyRuntime = ({
     if (staticManifest?.name === name) {
       return staticManifest;
     }
-    return getStrategyManifest(name);
+    return getStrategyManifest(name, projectRoot);
   };
   const loadPineScript2 = createLoadPineScript(
     strategyDirectory ? import_node_path2.default.resolve(strategyDirectory) : import_node_path2.default.resolve(
-      process.cwd(),
+      projectRoot,
       "packages",
       "strategies",
       "src",
@@ -6874,7 +6919,8 @@ var createStrategyRuntime = ({
       btcData,
       btcBinanceData,
       btcCoinbaseData,
-      periods: (0, import_strategies.buildDefaultIndicatorPeriods)(config)
+      periods: (0, import_strategies.buildDefaultIndicatorPeriods)(config),
+      pluginRegistryScope: projectRoot
     });
     const strategyApi = (0, import_strategies.createStrategyAPI)({
       strategy: strategyName,

package/dist/strategies.mjs

@@ -1,12 +1,12 @@
 import {
   buildMlPayload
-} from "./chunk-PXJJPAQT.mjs";
+} from "./chunk-H4HXW3EZ.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
 import {
   createLoadPineScript
-} from "./chunk-OB4CSYDJ.mjs";
+} from "./chunk-7ICOZAKA.mjs";
 import "./chunk-5YNMSWL3.mjs";
 import {
   MAX_AI_SERIES_POINTS,
@@ -15,7 +15,7 @@ import {
   buildAiPayload,
   buildAiSystemPrompt,
   trimSeriesDeep
-} from "./chunk-ZIMX3JX2.mjs";
+} from "./chunk-QDYCJ2OK.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -28,8 +28,10 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-CK2PW4L5.mjs";
+import {
+  getTradejsProjectCwd
+} from "./chunk-3C76HVLA.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -185,7 +187,8 @@ var enrichSignalWithMl = async ({
     const mlResult = await fetchMlThreshold({
       strategy,
       features,
-      threshold: ml.mlThreshold
+      threshold: ml.mlThreshold,
+      projectRoot: getTradejsProjectCwd()
     });
     if (mlResult) {
       signal.ml = mlResult;
@@ -203,7 +206,7 @@ var enrichSignalWithAi = async ({
     return void 0;
   }
   try {
-    const { askAI: askAI2 } = await import("./ai-NNJ3RLLL.mjs");
+    const { askAI: askAI2 } = await import("./ai-MDMDKAEE.mjs");
     const analysis = await askAI2(signal);
     if (typeof analysis?.quality === "number") {
       const normalizedQuality = Math.round(analysis.quality);
@@ -484,6 +487,7 @@ var createStrategyRuntime = ({
   manifest: staticManifest,
   strategyDirectory
 }) => {
+  const projectRoot = getTradejsProjectCwd();
   const resolveManifest = (name) => {
     if (!name) {
       return void 0;
@@ -491,11 +495,11 @@ var createStrategyRuntime = ({
     if (staticManifest?.name === name) {
       return staticManifest;
     }
-    return getStrategyManifest(name);
+    return getStrategyManifest(name, projectRoot);
   };
   const loadPineScript = createLoadPineScript(
     strategyDirectory ? path.resolve(strategyDirectory) : path.resolve(
-      process.cwd(),
+      projectRoot,
       "packages",
       "strategies",
       "src",
@@ -590,7 +594,8 @@ var createStrategyRuntime = ({
       btcData,
       btcBinanceData,
       btcCoinbaseData,
-      periods: buildDefaultIndicatorPeriods(config)
+      periods: buildDefaultIndicatorPeriods(config),
+      pluginRegistryScope: projectRoot
     });
     const strategyApi = createStrategyAPI({
       strategy: strategyName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Node-only TradeJS runtime for strategies, backtests, Pine loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -54,9 +54,9 @@
   "dependencies": {
     "@langchain/core": "^0.3.68",
     "@langchain/openai": "^0.6.11",
-    "@tradejs/core": "^1.0.2",
-    "@tradejs/infra": "^1.0.2",
-    "@tradejs/types": "^1.0.2",
+    "@tradejs/core": "^1.0.3",
+    "@tradejs/infra": "^1.0.3",
+    "@tradejs/types": "^1.0.3",
     "chalk": "4.1.2",
     "ioredis": "5.8.0",
     "pinets": "0.8.12",

package/dist/chunk-E2QNOA5M.mjs

@@ -1,227 +0,0 @@
-import {
-  importTradejsModule,
-  loadTradejsConfig,
-  resolvePluginModuleSpecifier
-} from "./chunk-DE7ADBIR.mjs";
-
-// src/connectorsRegistry.ts
-import { logger } from "@tradejs/infra/logger";
-var connectorCreators = /* @__PURE__ */ new Map();
-var providerToConnectorName = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
-var BUILTIN_CONNECTOR_NAMES = {
-  ByBit: "ByBit",
-  Binance: "Binance",
-  Coinbase: "Coinbase",
-  Test: "Test"
-};
-var normalizeProvider = (value) => String(value ?? "").trim().toLowerCase();
-var toUniqueModules = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var findConnectorNameInsensitive = (name) => {
-  const normalized = name.trim().toLowerCase();
-  if (!normalized) {
-    return null;
-  }
-  for (const existingName of connectorCreators.keys()) {
-    if (existingName.toLowerCase() === normalized) {
-      return existingName;
-    }
-  }
-  return null;
-};
-var normalizeProviders = (providers, connectorName) => {
-  const list = Array.isArray(providers) ? providers.map((item) => normalizeProvider(item)).filter(Boolean) : [];
-  const deduped = [...new Set(list)];
-  if (deduped.length) {
-    return deduped;
-  }
-  return [normalizeProvider(connectorName)];
-};
-var registerProvider = (provider, connectorName, source) => {
-  const existing = providerToConnectorName.get(provider);
-  if (existing && existing !== connectorName) {
-    logger.warn(
-      'Skip duplicate connector provider "%s" from %s: already mapped to %s',
-      provider,
-      source,
-      existing
-    );
-    return;
-  }
-  providerToConnectorName.set(provider, connectorName);
-};
-var registerEntry = (entry, source) => {
-  const connectorName = String(entry?.name ?? "").trim();
-  if (!connectorName) {
-    logger.warn("Skip connector entry without name from %s", source);
-    return;
-  }
-  if (typeof entry.creator !== "function") {
-    logger.warn(
-      'Skip connector entry "%s" from %s: creator must be a function',
-      connectorName,
-      source
-    );
-    return;
-  }
-  const existingByName = findConnectorNameInsensitive(connectorName);
-  if (existingByName) {
-    logger.warn(
-      'Skip duplicate connector "%s" from %s: already registered as %s',
-      connectorName,
-      source,
-      existingByName
-    );
-    return;
-  }
-  connectorCreators.set(connectorName, entry.creator);
-  const providers = normalizeProviders(entry.providers, connectorName);
-  for (const provider of providers) {
-    registerProvider(provider, connectorName, source);
-  }
-};
-var registerEntries = (entries, source) => {
-  for (const entry of entries) {
-    registerEntry(entry, source);
-  }
-};
-var extractConnectorPluginDefinition = (moduleExport) => {
-  if (!moduleExport || typeof moduleExport !== "object") {
-    return null;
-  }
-  const candidate = moduleExport;
-  if (Array.isArray(candidate.connectorEntries)) {
-    return {
-      connectorEntries: candidate.connectorEntries
-    };
-  }
-  const defaultExport = candidate.default;
-  if (defaultExport && Array.isArray(defaultExport.connectorEntries)) {
-    return {
-      connectorEntries: defaultExport.connectorEntries
-    };
-  }
-  return null;
-};
-var importConnectorPluginModule = async (moduleName) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
-  }
-  return import(
-    /* webpackIgnore: true */
-    moduleName
-  );
-};
-var ensureConnectorPluginsLoaded = async () => {
-  if (pluginsLoadPromise) {
-    return pluginsLoadPromise;
-  }
-  pluginsLoadPromise = (async () => {
-    const config = await loadTradejsConfig();
-    const connectorModules = toUniqueModules(config.connectors);
-    if (!connectorModules.length) {
-      return;
-    }
-    for (const moduleName of connectorModules) {
-      try {
-        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
-        const moduleExport = await importConnectorPluginModule(resolvedModuleName);
-        const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
-        if (!pluginDefinition) {
-          logger.warn(
-            'Skip connector plugin "%s": export { connectorEntries } is missing',
-            moduleName
-          );
-          continue;
-        }
-        registerEntries(pluginDefinition.connectorEntries, moduleName);
-      } catch (error) {
-        logger.warn(
-          'Failed to load connector plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
-      }
-    }
-  })();
-  return pluginsLoadPromise;
-};
-var getConnectorCreatorByName = async (connectorName) => {
-  await ensureConnectorPluginsLoaded();
-  const raw = String(connectorName ?? "").trim();
-  if (!raw) {
-    return void 0;
-  }
-  const direct = connectorCreators.get(raw);
-  if (direct) {
-    return direct;
-  }
-  const existing = findConnectorNameInsensitive(raw);
-  if (!existing) {
-    return void 0;
-  }
-  return connectorCreators.get(existing);
-};
-var getConnectorNameByProvider = async (provider) => {
-  await ensureConnectorPluginsLoaded();
-  const normalized = normalizeProvider(provider);
-  if (!normalized) {
-    return void 0;
-  }
-  return providerToConnectorName.get(normalized);
-};
-var getConnectorCreatorByProvider = async (provider) => {
-  const connectorName = await getConnectorNameByProvider(provider);
-  if (!connectorName) {
-    return void 0;
-  }
-  return connectorCreators.get(connectorName);
-};
-var resolveConnectorName = async (providerOrName) => {
-  const raw = String(providerOrName ?? "").trim();
-  if (!raw) {
-    return void 0;
-  }
-  const byProvider = await getConnectorNameByProvider(raw);
-  if (byProvider) {
-    return byProvider;
-  }
-  const byName = await getConnectorCreatorByName(raw);
-  if (!byName) {
-    return void 0;
-  }
-  return findConnectorNameInsensitive(raw) ?? void 0;
-};
-var getAvailableConnectorNames = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
-};
-var getAvailableConnectorProviders = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...providerToConnectorName.keys()].sort((a, b) => a.localeCompare(b));
-};
-var registerConnectorEntries = (entries) => {
-  registerEntries(entries, "runtime");
-};
-var resetConnectorRegistryCache = () => {
-  connectorCreators.clear();
-  providerToConnectorName.clear();
-  pluginsLoadPromise = null;
-};
-var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
-
-export {
-  BUILTIN_CONNECTOR_NAMES,
-  ensureConnectorPluginsLoaded,
-  getConnectorCreatorByName,
-  getConnectorNameByProvider,
-  getConnectorCreatorByProvider,
-  resolveConnectorName,
-  getAvailableConnectorNames,
-  getAvailableConnectorProviders,
-  registerConnectorEntries,
-  resetConnectorRegistryCache,
-  DEFAULT_CONNECTOR_NAME
-};