@tradejs/node 3.1.0 → 3.1.2

package/dist/runtimeStrategies.js

@@ -0,0 +1,798 @@
+"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/runtimeStrategies.ts
+var runtimeStrategies_exports = {};
+__export(runtimeStrategies_exports, {
+  getRuntimeStrategyPackageMetadata: () => getRuntimeStrategyPackageMetadata,
+  loadResolvedRuntimeStrategies: () => loadResolvedRuntimeStrategies
+});
+module.exports = __toCommonJS(runtimeStrategies_exports);
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+var import_redis = require("@tradejs/infra/redis");
+var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
+
+// 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_url = require("url");
+var import_config = require("@tradejs/core/config");
+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 tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
+var tsconfigPathMatchersByCwd = /* @__PURE__ */ new Map();
+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) : [];
+  const hooks = (0, import_config.normalizeTradejsConfigHooks)(
+    config.hooks
+  );
+  return {
+    strategies: strategies2,
+    indicators,
+    connectors,
+    ...hooks ? { hooks } : {}
+  };
+};
+var getNodeCreateRequire = () => {
+  const builtinModule = process.getBuiltinModule?.("module");
+  if (typeof builtinModule?.createRequire === "function") {
+    return builtinModule.createRequire;
+  }
+  throw new TypeError("module.createRequire is not available");
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(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: "Node16",
+      moduleResolution: "node16"
+    }
+  });
+  tsNodeRegistered = true;
+};
+var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+    return;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const register = tsconfigPathsModule.register;
+  if (typeof loadConfig !== "function" || typeof register !== "function") {
+    return;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return;
+  }
+  register({
+    baseUrl: loadedConfig.absoluteBaseUrl,
+    paths: loadedConfig.paths,
+    addMatchAll: false
+  });
+  tsconfigPathsRegisteredByCwd.add(projectRoot);
+};
+var resolveTsconfigPathModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  const cachedMatcher = tsconfigPathMatchersByCwd.get(projectRoot);
+  if (cachedMatcher) {
+    const resolved2 = cachedMatcher(moduleName);
+    return resolved2 || null;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const createMatchPath = tsconfigPathsModule.createMatchPath;
+  if (typeof loadConfig !== "function" || typeof createMatchPath !== "function") {
+    return null;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return null;
+  }
+  const matchPath = createMatchPath(
+    loadedConfig.absoluteBaseUrl,
+    loadedConfig.paths
+  );
+  const matcher = (requestedModule) => matchPath(requestedModule, void 0, import_fs.default.existsSync, [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json"
+  ]) || "";
+  tsconfigPathMatchersByCwd.set(projectRoot, matcher);
+  const resolved = matcher(moduleName);
+  return resolved || null;
+};
+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();
+    await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
+    return requireFn(configFilePath);
+  }
+  return import(
+    /* webpackIgnore: true */
+    configFileUrl
+  );
+};
+var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  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) : cwd
+  );
+  if (isTsModulePath(modulePath)) {
+    await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(cwd);
+    return requireFn(modulePath);
+  }
+  if (isBareModuleSpecifier(normalized)) {
+    await ensureTsconfigPathsRegistered(cwd);
+    try {
+      return requireFn(normalized);
+    } catch (error) {
+      const resolvedByTsconfig = await resolveTsconfigPathModule(
+        normalized,
+        cwd
+      );
+      if (resolvedByTsconfig && resolvedByTsconfig !== normalized) {
+        return requireFn(resolvedByTsconfig);
+      }
+      throw error;
+    }
+  }
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      toImportSpecifier(normalized)
+    );
+  } catch (error) {
+    if (isTsModulePath(modulePath)) {
+      await ensureTsNodeRegistered();
+      await ensureTsconfigPathsRegistered(cwd);
+      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("debug", "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 SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
+var sharedRegistryScope = globalThis;
+var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
+  registryStateByProjectRoot: /* @__PURE__ */ new Map()
+});
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
+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 (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
+  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, 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 (state.strategyCreators.has(strategyName)) {
+      import_logger2.logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
+    materializeStrategyCreator(strategyName, state);
+  }
+};
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
+  }
+  const entry = state.strategyEntriesMap.get(strategyName);
+  if (!entry) return;
+  state.strategyCreators.set(
+    strategyName,
+    sharedStrategyRegistry.strategyRuntimeFactory({
+      strategyName,
+      defaults: entry.defaults,
+      createCore: entry.createCore,
+      manifest: entry.manifest,
+      detectorKey: entry.detectorKey,
+      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+    })
+  );
+};
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    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,
+            projectRoot
+          );
+          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) {
+              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 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)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategySourcesMap.get(name);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+
+// src/runtimeStrategies.ts
+var readPackageManifest = async (projectRoot) => {
+  const candidates = [
+    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
+    import_node_path.default.join(projectRoot, "runtime-package-manifest.json"),
+    "/app/runtime-package-manifest.json"
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(
+        await (0, import_promises.readFile)(candidate, "utf8")
+      );
+    } catch {
+    }
+  }
+  return { packages: {} };
+};
+var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
+  if (!packageName || packageName === "runtime") return null;
+  const manifestVersion = manifest.packages?.[packageName];
+  if (manifestVersion) return manifestVersion;
+  try {
+    const packageJsonPath = import_node_path.default.join(
+      projectRoot,
+      "node_modules",
+      ...packageName.split("/"),
+      "package.json"
+    );
+    const packageJson = JSON.parse(await (0, import_promises.readFile)(packageJsonPath, "utf8"));
+    return packageJson.version ?? null;
+  } catch {
+    return null;
+  }
+};
+var validateReleaseRuntimeCompatibility = async ({
+  release,
+  projectRoot,
+  packageManifest
+}) => {
+  const installedStrategyVersion = await resolveInstalledPackageVersion(
+    projectRoot,
+    release.strategyPackage,
+    packageManifest
+  );
+  if (release.strategyPackageVersion && installedStrategyVersion && release.strategyPackageVersion !== installedStrategyVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
+    );
+  }
+  const installedRuntimeVersion = packageManifest.packages?.["@tradejs/node"];
+  if (release.runtimePackageVersion && installedRuntimeVersion && release.runtimePackageVersion !== installedRuntimeVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
+    );
+  }
+};
+var resolveAccountId = async ({
+  userName,
+  deployment,
+  connectorName,
+  universe,
+  legacyAccountId
+}) => {
+  const requestedAccountId = deployment?.accountId ?? legacyAccountId;
+  const account = await (0, import_tradingAccounts.resolveTradingAccount)({
+    userName,
+    accountId: requestedAccountId,
+    provider: deployment?.provider ?? connectorName,
+    universe
+  });
+  return account?.id ?? requestedAccountId;
+};
+var loadVersionedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  return Promise.all(
+    deployment.strategies.map(async (reference) => {
+      if (!Number.isSafeInteger(reference.releaseVersion) || !reference.releaseVersion) {
+        throw new Error(
+          `Deployment ${deployment.id} strategy ${reference.strategyName} has no releaseVersion`
+        );
+      }
+      if (reference.config && Object.keys(reference.config).length) {
+        throw new Error(
+          `Deployment ${deployment.id} must not embed config for ${reference.strategyName}`
+        );
+      }
+      const release = await (0, import_runtimeStrategyReleases.getRuntimeStrategyRelease)(
+        userName,
+        reference.strategyName,
+        reference.releaseVersion
+      );
+      if (!release) {
+        throw new Error(
+          `Runtime release not found: ${reference.strategyName} v${reference.releaseVersion}`
+        );
+      }
+      await validateReleaseRuntimeCompatibility({
+        release,
+        projectRoot,
+        packageManifest
+      });
+      const strategyCreator = await getStrategyCreator(
+        reference.strategyName,
+        projectRoot
+      );
+      if (!strategyCreator) {
+        throw new Error(`Unknown strategy: ${reference.strategyName}`);
+      }
+      const interval = String(release.config.INTERVAL);
+      const universe = release.config.UNIVERSE;
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe
+      });
+      return {
+        strategyName: reference.strategyName,
+        releaseVersion: release.releaseVersion,
+        controlState: reference.controlState ?? "active",
+        interval,
+        universe,
+        accountId,
+        strategyPackage: release.strategyPackage,
+        strategyPackageVersion: release.strategyPackageVersion,
+        runtimePackageVersion: release.runtimePackageVersion,
+        strategyCreator,
+        sourceStrategyConfig: release.config,
+        strategyConfig: release.config,
+        // Symbol result configs are mutable legacy overlays and are not read by v2.
+        strategyResults: {}
+      };
+    })
+  );
+};
+var loadLegacyRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const deploymentStrategies = new Map(
+    (deployment?.strategies ?? []).map((strategy) => [
+      strategy.strategyName,
+      strategy
+    ])
+  );
+  const candidates = await Promise.all(
+    (await (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)).map(async (record) => {
+      const binding = deploymentStrategies.get(record.strategyName);
+      if (binding?.enabled === false || record.strategyConfig.ENABLE === false) {
+        return null;
+      }
+      const universe = record.strategyConfig.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
+      const interval = String(
+        record.strategyConfig.INTERVAL ?? "15"
+      );
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe,
+        legacyAccountId: typeof record.strategyConfig.ACCOUNT_ID === "string" ? record.strategyConfig.ACCOUNT_ID : void 0
+      });
+      const [strategyCreator, strategyResults] = await Promise.all([
+        getStrategyCreator(record.strategyName, projectRoot),
+        (0, import_redis.getData)(import_redis.redisKeys.strategyResults(userName, record.strategyName), {})
+      ]);
+      if (!strategyCreator) return null;
+      return {
+        strategyName: record.strategyName,
+        configId: record.configId,
+        controlState: "active",
+        interval,
+        universe,
+        accountId,
+        strategyCreator,
+        sourceStrategyConfig: record.strategyConfig,
+        strategyConfig: record.strategyConfig,
+        strategyResults: strategyResults ?? {}
+      };
+    })
+  );
+  return candidates.filter(Boolean);
+};
+var loadResolvedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName = "bybit",
+  universe,
+  accountId,
+  interval
+}) => {
+  const hasVersionedReferences = Boolean(
+    deployment?.strategies.some((strategy) => strategy.releaseVersion != null)
+  );
+  if (hasVersionedReferences && deployment?.strategies.some((strategy) => strategy.releaseVersion == null)) {
+    throw new Error(
+      `Deployment ${deployment.id} mixes legacy configs and versioned releases`
+    );
+  }
+  const strategies2 = hasVersionedReferences ? await loadVersionedRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  }) : await loadLegacyRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  });
+  const filtered = strategies2.filter(
+    (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
+  );
+  const identities = /* @__PURE__ */ new Set();
+  for (const candidate of filtered) {
+    const identity = `${candidate.strategyName}:${candidate.accountId ?? "default"}`;
+    if (identities.has(identity)) {
+      throw new Error(`Runtime strategy conflict: ${identity}`);
+    }
+    identities.add(identity);
+  }
+  return filtered;
+};
+var getRuntimeStrategyPackageMetadata = async ({
+  strategyName,
+  projectRoot
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  const strategyPackage = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+  return {
+    strategyPackage,
+    strategyPackageVersion: await resolveInstalledPackageVersion(
+      projectRoot,
+      strategyPackage,
+      packageManifest
+    ),
+    runtimePackageVersion: packageManifest.packages?.["@tradejs/node"] ?? null
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRuntimeStrategyPackageMetadata,
+  loadResolvedRuntimeStrategies
+});