@tradejs/node 1.0.2 → 1.0.3

package/dist/connectors.js

@@ -247,9 +247,24 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 // src/connectorsRegistry.ts
-var connectorCreators = /* @__PURE__ */ new Map();
-var providerToConnectorName = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
+var createConnectorRegistryState = () => ({
+  connectorCreators: /* @__PURE__ */ new Map(),
+  providerToConnectorName: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getConnectorRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createConnectorRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var BUILTIN_CONNECTOR_NAMES = {
   ByBit: "ByBit",
   Binance: "Binance",
@@ -260,7 +275,7 @@ var normalizeProvider = (value) => String(value ?? "").trim().toLowerCase();
 var toUniqueModules = (modules = []) => [
   ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
 ];
-var findConnectorNameInsensitive = (name) => {
+var findConnectorNameInsensitive = (name, connectorCreators) => {
   const normalized = name.trim().toLowerCase();
   if (!normalized) {
     return null;
@@ -280,7 +295,7 @@ var normalizeProviders = (providers, connectorName) => {
   }
   return [normalizeProvider(connectorName)];
 };
-var registerProvider = (provider, connectorName, source) => {
+var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
     import_logger2.logger.warn(
@@ -293,7 +308,7 @@ var registerProvider = (provider, connectorName, source) => {
   }
   providerToConnectorName.set(provider, connectorName);
 };
-var registerEntry = (entry, source) => {
+var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
     import_logger2.logger.warn("Skip connector entry without name from %s", source);
@@ -307,7 +322,10 @@ var registerEntry = (entry, source) => {
     );
     return;
   }
-  const existingByName = findConnectorNameInsensitive(connectorName);
+  const existingByName = findConnectorNameInsensitive(
+    connectorName,
+    state.connectorCreators
+  );
   if (existingByName) {
     import_logger2.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
@@ -317,15 +335,20 @@ var registerEntry = (entry, source) => {
     );
     return;
   }
-  connectorCreators.set(connectorName, entry.creator);
+  state.connectorCreators.set(connectorName, entry.creator);
   const providers = normalizeProviders(entry.providers, connectorName);
   for (const provider of providers) {
-    registerProvider(provider, connectorName, source);
+    registerProvider(
+      provider,
+      connectorName,
+      source,
+      state.providerToConnectorName
+    );
   }
 };
-var registerEntries = (entries, source) => {
+var registerEntries = (entries, source, state) => {
   for (const entry of entries) {
-    registerEntry(entry, source);
+    registerEntry(entry, source, state);
   }
 };
 var extractConnectorPluginDefinition = (moduleExport) => {
@@ -355,101 +378,118 @@ var importConnectorPluginModule = async (moduleName) => {
     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) {
+var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getConnectorRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    state.pluginsLoadPromise = (async () => {
+      const config = await loadTradejsConfig(projectRoot);
+      const connectorModules = toUniqueModules(config.connectors);
+      if (!connectorModules.length) {
+        return;
+      }
+      for (const moduleName of connectorModules) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importConnectorPluginModule(resolvedModuleName);
+          const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
+          if (!pluginDefinition) {
+            import_logger2.logger.warn(
+              'Skip connector plugin "%s": export { connectorEntries } is missing',
+              moduleName
+            );
+            continue;
+          }
+          registerEntries(pluginDefinition.connectorEntries, moduleName, state);
+        } catch (error) {
           import_logger2.logger.warn(
-            'Skip connector plugin "%s": export { connectorEntries } is missing',
-            moduleName
+            'Failed to load connector plugin "%s": %s',
+            moduleName,
+            String(error)
           );
-          continue;
         }
-        registerEntries(pluginDefinition.connectorEntries, moduleName);
-      } catch (error) {
-        import_logger2.logger.warn(
-          'Failed to load connector plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
       }
-    }
-  })();
-  return pluginsLoadPromise;
+    })();
+  }
+  await state.pluginsLoadPromise;
 };
-var getConnectorCreatorByName = async (connectorName) => {
-  await ensureConnectorPluginsLoaded();
+var getConnectorCreatorByName = async (connectorName, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
   const raw = String(connectorName ?? "").trim();
   if (!raw) {
     return void 0;
   }
-  const direct = connectorCreators.get(raw);
+  const direct = state.connectorCreators.get(raw);
   if (direct) {
     return direct;
   }
-  const existing = findConnectorNameInsensitive(raw);
+  const existing = findConnectorNameInsensitive(raw, state.connectorCreators);
   if (!existing) {
     return void 0;
   }
-  return connectorCreators.get(existing);
+  return state.connectorCreators.get(existing);
 };
-var getConnectorNameByProvider = async (provider) => {
-  await ensureConnectorPluginsLoaded();
+var getConnectorNameByProvider = async (provider, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
   const normalized = normalizeProvider(provider);
   if (!normalized) {
     return void 0;
   }
-  return providerToConnectorName.get(normalized);
+  return state.providerToConnectorName.get(normalized);
 };
-var getConnectorCreatorByProvider = async (provider) => {
-  const connectorName = await getConnectorNameByProvider(provider);
+var getConnectorCreatorByProvider = async (provider, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  const normalized = normalizeProvider(provider);
+  if (!normalized) {
+    return void 0;
+  }
+  const connectorName = state.providerToConnectorName.get(normalized);
   if (!connectorName) {
     return void 0;
   }
-  return connectorCreators.get(connectorName);
+  return state.connectorCreators.get(connectorName);
 };
-var resolveConnectorName = async (providerOrName) => {
+var resolveConnectorName = async (providerOrName, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
   const raw = String(providerOrName ?? "").trim();
   if (!raw) {
     return void 0;
   }
-  const byProvider = await getConnectorNameByProvider(raw);
+  const byProvider = state.providerToConnectorName.get(normalizeProvider(raw));
   if (byProvider) {
     return byProvider;
   }
-  const byName = await getConnectorCreatorByName(raw);
-  if (!byName) {
-    return void 0;
-  }
-  return findConnectorNameInsensitive(raw) ?? void 0;
+  return state.connectorCreators.get(raw) && raw ? raw : findConnectorNameInsensitive(raw, state.connectorCreators) ?? void 0;
 };
-var getAvailableConnectorNames = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
+var getAvailableConnectorNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  return [...state.connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
 };
-var getAvailableConnectorProviders = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...providerToConnectorName.keys()].sort((a, b) => a.localeCompare(b));
+var getAvailableConnectorProviders = async (cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  return [...state.providerToConnectorName.keys()].sort(
+    (a, b) => a.localeCompare(b)
+  );
 };
-var registerConnectorEntries = (entries) => {
-  registerEntries(entries, "runtime");
+var registerConnectorEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getConnectorRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
 };
-var resetConnectorRegistryCache = () => {
-  connectorCreators.clear();
-  providerToConnectorName.clear();
-  pluginsLoadPromise = null;
+var resetConnectorRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    return;
+  }
+  registryStateByProjectRoot.delete(getTradejsProjectCwd(normalizedCwd));
 };
 var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/connectors.mjs

@@ -10,8 +10,8 @@ import {
   registerConnectorEntries,
   resetConnectorRegistryCache,
   resolveConnectorName
-} from "./chunk-E2QNOA5M.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-MGFEID6K.mjs";
+import "./chunk-3C76HVLA.mjs";
 import "./chunk-6DZX6EAA.mjs";
 export {
   BUILTIN_CONNECTOR_NAMES,

package/dist/pine.d.mts

@@ -25,7 +25,6 @@ declare const getPinePlotSeries: (context: PineContextLike, plotName: string) =>
 declare const getLatestPinePlotValue: (context: PineContextLike, plotName: string) => unknown;
 declare const asFiniteNumber: (value: unknown) => number | undefined;
 declare const asPineBoolean: (value: unknown) => boolean;
-
 declare const loadPineScript: (filePath: string, fallback?: string) => string;
 declare const createLoadPineScript: (baseDir: string) => ((fileNameOrPath: string, fallback?: string) => string);
 declare const runPineScript: ({ candles, script, symbol, timeframe, inputs, limit, }: RunPineScriptParams) => Promise<PineContextLike>;

package/dist/pine.d.ts

@@ -25,7 +25,6 @@ declare const getPinePlotSeries: (context: PineContextLike, plotName: string) =>
 declare const getLatestPinePlotValue: (context: PineContextLike, plotName: string) => unknown;
 declare const asFiniteNumber: (value: unknown) => number | undefined;
 declare const asPineBoolean: (value: unknown) => boolean;
-
 declare const loadPineScript: (filePath: string, fallback?: string) => string;
 declare const createLoadPineScript: (baseDir: string) => ((fileNameOrPath: string, fallback?: string) => string);
 declare const runPineScript: ({ candles, script, symbol, timeframe, inputs, limit, }: RunPineScriptParams) => Promise<PineContextLike>;

package/dist/pine.js

@@ -41,8 +41,6 @@ __export(pine_exports, {
 module.exports = __toCommonJS(pine_exports);
 var import_node_fs = __toESM(require("fs"));
 var import_node_path = __toESM(require("path"));
-
-// src/pineShared.ts
 var getPinePlotSeries = (context, plotName) => {
   const name = String(plotName || "").trim();
   if (!name) return [];
@@ -65,8 +63,6 @@ var asPineBoolean = (value) => {
   if (typeof value === "number") return Number.isFinite(value) && value !== 0;
   return false;
 };
-
-// src/pine.ts
 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;

package/dist/pine.mjs

@@ -6,7 +6,7 @@ import {
   getPinePlotSeries,
   loadPineScript,
   runPineScript
-} from "./chunk-OB4CSYDJ.mjs";
+} from "./chunk-7ICOZAKA.mjs";
 import "./chunk-6DZX6EAA.mjs";
 export {
   asFiniteNumber,

package/dist/registry.d.mts

@@ -1,15 +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 ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
+declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
+declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
+declare const resetStrategyRegistryCache: (cwd?: string) => void;
 declare const strategies: Record<string, StrategyCreator>;
 
 export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };

package/dist/registry.d.ts

@@ -1,15 +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 ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
+declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
+declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
+declare const resetStrategyRegistryCache: (cwd?: string) => void;
 declare const strategies: Record<string, StrategyCreator>;
 
 export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };

package/dist/registry.js

@@ -248,14 +248,29 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 // src/strategy/manifests.ts
-var strategyCreators = /* @__PURE__ */ new Map();
-var strategyManifestsMap = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var toUniqueModules = (modules = []) => [
   ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
 ];
-var getConfiguredPluginModuleNames = async () => {
-  const config = await loadTradejsConfig();
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
   return {
     strategyModules: toUniqueModules(config.strategies),
     indicatorModules: toUniqueModules(config.indicators)
@@ -289,14 +304,14 @@ var extractIndicatorPluginDefinition = (moduleExport) => {
   );
   return indicatorEntries ? { indicatorEntries } : null;
 };
-var registerEntries = (entries, source) => {
+var registerEntries = (entries, source, state) => {
   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)) {
+    if (state.strategyCreators.has(strategyName)) {
       import_logger2.logger.warn(
         'Skip duplicate strategy "%s" from %s: already registered',
         strategyName,
@@ -304,8 +319,8 @@ var registerEntries = (entries, source) => {
       );
       continue;
     }
-    strategyCreators.set(strategyName, entry.creator);
-    strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyCreators.set(strategyName, entry.creator);
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
   }
 };
 var importStrategyPluginModule = async (moduleName) => {
@@ -317,93 +332,119 @@ var importStrategyPluginModule = async (moduleName) => {
     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);
+var 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_logger2.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_logger2.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_logger2.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_logger2.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_logger2.logger.warn(
-          'Failed to load plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
       }
-    }
-  })();
-  return pluginsLoadPromise;
+    })();
+  }
+  await state.pluginsLoadPromise;
 };
-var ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
-var getStrategyCreator = async (name) => {
-  await ensureStrategyPluginsLoaded();
-  return strategyCreators.get(name);
+var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
 };
-var getAvailableStrategyNames = async () => {
-  await ensureStrategyPluginsLoaded();
-  return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
 };
-var getRegisteredStrategies = () => {
-  return Object.fromEntries(strategyCreators.entries());
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
 };
-var getRegisteredManifests = () => {
-  return [...strategyManifestsMap.values()];
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
 };
-var getStrategyManifest = (name) => {
-  return name ? strategyManifestsMap.get(name) : void 0;
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
 };
-var isKnownStrategy = (name) => {
-  return strategyCreators.has(name);
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
 };
-var registerStrategyEntries = (entries) => {
-  registerEntries(entries, "runtime");
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
 };
-var resetStrategyRegistryCache = () => {
-  strategyCreators.clear();
-  strategyManifestsMap.clear();
-  (0, import_indicators.resetIndicatorRegistryCache)();
-  pluginsLoadPromise = null;
+var 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);
 };
 var strategies = new Proxy(
   {},
@@ -412,10 +453,10 @@ var strategies = new Proxy(
       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,

package/dist/registry.mjs

@@ -11,8 +11,8 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-CK2PW4L5.mjs";
+import "./chunk-3C76HVLA.mjs";
 import "./chunk-6DZX6EAA.mjs";
 export {
   ensureIndicatorPluginsLoaded,