@tradejs/node 3.1.8-beta.207 → 3.1.8-beta.212

package/dist/runtimeStrategies.js

@@ -30,13 +30,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtimeStrategies.ts
 var runtimeStrategies_exports = {};
 __export(runtimeStrategies_exports, {
+  getRuntimeDeployment: () => getRuntimeDeployment,
   getRuntimeStrategyPackageMetadata: () => getRuntimeStrategyPackageMetadata,
-  loadResolvedRuntimeStrategies: () => loadResolvedRuntimeStrategies
+  listRuntimeDeployments: () => listRuntimeDeployments,
+  loadResolvedRuntimeStrategies: () => loadResolvedRuntimeStrategies,
+  verifyRuntimeDeclaration: () => verifyRuntimeDeclaration
 });
 module.exports = __toCommonJS(runtimeStrategies_exports);
 var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"));
-var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
+var import_runtimeControls = require("@tradejs/infra/runtimeControls");
 var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
 
 // src/strategy/manifests.ts
@@ -84,11 +87,13 @@ var normalizeConfig = (rawConfig) => {
   const hooks = (0, import_config.normalizeTradejsConfigHooks)(
     config.hooks
   );
+  const runtime = config.runtime && typeof config.runtime === "object" && !Array.isArray(config.runtime) ? config.runtime : void 0;
   return {
     strategies: strategies2,
     indicators,
     connectors,
-    ...hooks ? { hooks } : {}
+    ...hooks ? { hooks } : {},
+    ...runtime ? { runtime } : {}
   };
 };
 var getNodeCreateRequire = () => {
@@ -543,6 +548,40 @@ var strategies = new Proxy(
 );
 
 // src/runtimeStrategies.ts
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var RUNTIME_KEYS = /* @__PURE__ */ new Set(["deployments"]);
+var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "connectorName",
+  "provider",
+  "accountId",
+  "enabled",
+  "strategies",
+  "assetClasses",
+  "tickers"
+]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set(["version", "enabled", "config"]);
+var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "ACCOUNT_ID",
+  "DEPLOYMENT_ID",
+  "CONNECTOR_NAME",
+  "ENABLE"
+]);
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var readPackageManifest = async (projectRoot) => {
   const candidates = [
     process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
@@ -593,31 +632,84 @@ var resolveStrategyPackageName = async ({
     return null;
   }
 };
-var validateReleaseRuntimeCompatibility = async ({
-  release,
-  projectRoot,
-  packageManifest
-}) => {
-  const installedStrategyVersion = await resolveInstalledPackageVersion(
-    projectRoot,
-    release.strategyPackage,
-    packageManifest
-  );
-  if (release.strategyPackageVersion !== installedStrategyVersion) {
-    throw new Error(
-      `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
-    );
+var verifyStringArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+var verifyDeploymentDeclaration = (deploymentId, value) => {
+  if (!deploymentId.trim() || !isRecord(value) || Object.keys(value).some((key) => !DEPLOYMENT_KEYS.has(key)) || typeof value.connectorName !== "string" || !value.connectorName.trim() || typeof value.accountId !== "string" || !value.accountId.trim() || value.label !== void 0 && typeof value.label !== "string" || value.provider !== void 0 && typeof value.provider !== "string" || value.enabled !== void 0 && typeof value.enabled !== "boolean" || !verifyStringArray(value.assetClasses) || !verifyStringArray(value.tickers) || !isRecord(value.strategies) || !Object.keys(value.strategies).length) {
+    throw new Error(`Invalid runtime deployment declaration: ${deploymentId}`);
   }
-  const installedRuntimeVersion = await resolveInstalledPackageVersion(
-    projectRoot,
-    "@tradejs/node",
-    packageManifest
-  );
-  if (release.runtimePackageVersion !== installedRuntimeVersion) {
-    throw new Error(
-      `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
-    );
+  for (const [strategyName, strategyValue] of Object.entries(
+    value.strategies
+  )) {
+    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || !Number.isSafeInteger(strategyValue.version) || Number(strategyValue.version) <= 0 || typeof strategyValue.enabled !== "boolean" || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
+      (key) => FORBIDDEN_CONFIG_KEYS.has(key)
+    ) || !INTERVALS.has(String(strategyValue.config.INTERVAL)) || !["crypto", "tradfi"].includes(String(strategyValue.config.UNIVERSE))) {
+      throw new Error(
+        `Invalid runtime strategy declaration: ${deploymentId}/${strategyName}`
+      );
+    }
   }
+  return value;
+};
+var verifyRuntimeDeclaration = (value) => {
+  if (!isRecord(value) || Object.keys(value).some((key) => !RUNTIME_KEYS.has(key)) || !isRecord(value.deployments) || !Object.keys(value.deployments).length) {
+    throw new Error("Invalid runtime declaration");
+  }
+  for (const [deploymentId, deployment] of Object.entries(value.deployments)) {
+    verifyDeploymentDeclaration(deploymentId, deployment);
+  }
+  return value;
+};
+var toRuntimeDeployment = ({
+  id,
+  declaration,
+  controls
+}) => {
+  const deploymentEnabled = declaration.enabled ?? true;
+  return {
+    id,
+    label: declaration.label?.trim() || id,
+    connectorName: declaration.connectorName.trim(),
+    provider: (declaration.provider || declaration.connectorName).trim().toLowerCase(),
+    accountId: declaration.accountId.trim(),
+    enabled: deploymentEnabled,
+    strategies: Object.entries(declaration.strategies).map(
+      ([strategyName, strategy]) => ({
+        strategyName,
+        version: strategy.version,
+        enabled: strategy.enabled,
+        controlState: deploymentEnabled && strategy.enabled && !controls.deployments[id]?.[strategyName]?.entriesPaused ? "active" : "entries_paused"
+      })
+    ),
+    ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
+    ...declaration.tickers ? { tickers: declaration.tickers } : {}
+  };
+};
+var loadRuntimeDeclaration = async (projectRoot) => {
+  const projectConfig = await loadTradejsConfig(projectRoot);
+  if (!projectConfig.runtime) {
+    throw new Error("Runtime declaration is required in tradejs.config.ts");
+  }
+  return verifyRuntimeDeclaration(projectConfig.runtime);
+};
+var listRuntimeDeployments = async ({
+  userName,
+  projectRoot
+}) => {
+  const [runtime, controls] = await Promise.all([
+    loadRuntimeDeclaration(projectRoot),
+    (0, import_runtimeControls.getRuntimeControls)(userName)
+  ]);
+  return Object.entries(runtime.deployments).map(
+    ([id, declaration]) => toRuntimeDeployment({ id, declaration, controls })
+  ).sort((left, right) => left.label.localeCompare(right.label));
+};
+var getRuntimeDeployment = async ({
+  userName,
+  projectRoot,
+  deploymentId
+}) => {
+  const deployments = await listRuntimeDeployments({ userName, projectRoot });
+  return deployments.find((deployment) => deployment.id === deploymentId) ?? null;
 };
 var resolveAccountId = async ({
   userName,
@@ -635,89 +727,91 @@ var resolveAccountId = async ({
   }
   return account.id;
 };
-var loadVersionedRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deployment
-}) => {
-  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 (Object.keys(reference).some(
-        (key) => !["strategyName", "releaseVersion", "controlState"].includes(key)
-      )) {
-        throw new Error(`Deployment ${deployment.id} has invalid fields`);
-      }
-      if (!reference.controlState) {
-        throw new Error(
-          `Deployment ${deployment.id} strategy ${reference.strategyName} has no controlState`
-        );
-      }
-      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,
-        universe
-      });
-      return {
-        strategyName: reference.strategyName,
-        releaseVersion: release.releaseVersion,
-        controlState: reference.controlState,
-        interval,
-        universe,
-        accountId,
-        strategyPackage: release.strategyPackage,
-        strategyPackageVersion: release.strategyPackageVersion,
-        runtimePackageVersion: release.runtimePackageVersion,
-        strategyCreator,
-        sourceStrategyConfig: release.config,
-        strategyConfig: release.config
-      };
-    })
-  );
-};
 var loadResolvedRuntimeStrategies = async ({
   userName,
   projectRoot,
-  deployment,
+  deploymentId,
   universe,
   accountId,
   interval
 }) => {
-  if (!deployment) throw new Error("Runtime deployment is required");
-  const strategies2 = await loadVersionedRuntimeStrategies({
-    userName,
-    projectRoot,
-    deployment
+  const [runtime, controls, packageManifest] = await Promise.all([
+    loadRuntimeDeclaration(projectRoot),
+    (0, import_runtimeControls.getRuntimeControls)(userName),
+    readPackageManifest(projectRoot)
+  ]);
+  const declaration = runtime.deployments[deploymentId];
+  if (!declaration) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  const deployment = toRuntimeDeployment({
+    id: deploymentId,
+    declaration,
+    controls
   });
+  const strategies2 = await Promise.all(
+    Object.entries(declaration.strategies).map(
+      async ([strategyName, strategyDeclaration]) => {
+        const strategyCreator = await getStrategyCreator(
+          strategyName,
+          projectRoot
+        );
+        if (!strategyCreator) {
+          throw new Error(`Unknown strategy: ${strategyName}`);
+        }
+        const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+        const strategyPackage = await resolveStrategyPackageName({
+          pluginSource,
+          projectRoot
+        });
+        const [strategyPackageVersion, runtimePackageVersion] = await Promise.all([
+          resolveInstalledPackageVersion(
+            projectRoot,
+            strategyPackage,
+            packageManifest
+          ),
+          resolveInstalledPackageVersion(
+            projectRoot,
+            "@tradejs/node",
+            packageManifest
+          )
+        ]);
+        if (!strategyPackage || !strategyPackageVersion) {
+          throw new Error(
+            `Installed strategy package not found: ${strategyName}`
+          );
+        }
+        if (!runtimePackageVersion) {
+          throw new Error("Installed @tradejs/node package version not found");
+        }
+        const strategyView = deployment.strategies.find(
+          (candidate) => candidate.strategyName === strategyName
+        );
+        const strategyConfig = strategyDeclaration.config;
+        const strategyUniverse = strategyConfig.UNIVERSE;
+        const resolvedAccountId = await resolveAccountId({
+          userName,
+          deployment,
+          universe: strategyUniverse
+        });
+        return {
+          strategyName,
+          version: strategyDeclaration.version,
+          enabled: strategyDeclaration.enabled,
+          controlState: strategyView?.controlState ?? "entries_paused",
+          interval: String(strategyConfig.INTERVAL),
+          universe: strategyUniverse,
+          accountId: resolvedAccountId,
+          strategyPackage,
+          strategyPackageVersion,
+          runtimePackageVersion,
+          strategyCreator,
+          sourceStrategyConfig: strategyConfig,
+          strategyConfig
+        };
+      }
+    )
+  );
   const filtered = strategies2.filter(
     (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
   );
@@ -748,11 +842,18 @@ var getRuntimeStrategyPackageMetadata = async ({
       strategyPackage,
       packageManifest
     ),
-    runtimePackageVersion: packageManifest.packages?.["@tradejs/node"] ?? null
+    runtimePackageVersion: await resolveInstalledPackageVersion(
+      projectRoot,
+      "@tradejs/node",
+      packageManifest
+    )
   };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getRuntimeDeployment,
   getRuntimeStrategyPackageMetadata,
-  loadResolvedRuntimeStrategies
+  listRuntimeDeployments,
+  loadResolvedRuntimeStrategies,
+  verifyRuntimeDeclaration
 });

package/dist/runtimeStrategies.mjs

@@ -1,224 +1,17 @@
 import {
-  getStrategyCreator,
-  getStrategyPluginSource
-} from "./chunk-XN7BC7XK.mjs";
-import "./chunk-WS5DYEVZ.mjs";
+  getRuntimeDeployment,
+  getRuntimeStrategyPackageMetadata,
+  listRuntimeDeployments,
+  loadResolvedRuntimeStrategies,
+  verifyRuntimeDeclaration
+} from "./chunk-F7ODY5W4.mjs";
+import "./chunk-MEZIXBZ3.mjs";
+import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
-
-// src/runtimeStrategies.ts
-import { readFile } from "fs/promises";
-import path from "path";
-import { getRuntimeStrategyRelease } from "@tradejs/infra/runtimeStrategyReleases";
-import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
-var readPackageManifest = async (projectRoot) => {
-  const candidates = [
-    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
-    path.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 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 = path.join(
-      projectRoot,
-      "node_modules",
-      ...packageName.split("/"),
-      "package.json"
-    );
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    return packageJson.version ?? null;
-  } catch {
-    return null;
-  }
-};
-var resolveStrategyPackageName = async ({
-  pluginSource,
-  projectRoot
-}) => {
-  if (!pluginSource) return null;
-  if (!pluginSource.startsWith(".") && !path.isAbsolute(pluginSource)) {
-    return pluginSource;
-  }
-  try {
-    const packageJson = JSON.parse(
-      await readFile(path.join(projectRoot, "package.json"), "utf8")
-    );
-    return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name : null;
-  } catch {
-    return null;
-  }
-};
-var validateReleaseRuntimeCompatibility = async ({
-  release,
-  projectRoot,
-  packageManifest
-}) => {
-  const installedStrategyVersion = await resolveInstalledPackageVersion(
-    projectRoot,
-    release.strategyPackage,
-    packageManifest
-  );
-  if (release.strategyPackageVersion !== installedStrategyVersion) {
-    throw new Error(
-      `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
-    );
-  }
-  const installedRuntimeVersion = await resolveInstalledPackageVersion(
-    projectRoot,
-    "@tradejs/node",
-    packageManifest
-  );
-  if (release.runtimePackageVersion !== installedRuntimeVersion) {
-    throw new Error(
-      `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
-    );
-  }
-};
-var resolveAccountId = async ({
-  userName,
-  deployment,
-  universe
-}) => {
-  const account = await resolveTradingAccount({
-    userName,
-    accountId: deployment.accountId,
-    provider: deployment.provider,
-    universe
-  });
-  if (!account) {
-    throw new Error(`Trading account not found: ${deployment.accountId}`);
-  }
-  return account.id;
-};
-var loadVersionedRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deployment
-}) => {
-  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 (Object.keys(reference).some(
-        (key) => !["strategyName", "releaseVersion", "controlState"].includes(key)
-      )) {
-        throw new Error(`Deployment ${deployment.id} has invalid fields`);
-      }
-      if (!reference.controlState) {
-        throw new Error(
-          `Deployment ${deployment.id} strategy ${reference.strategyName} has no controlState`
-        );
-      }
-      const release = await 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,
-        universe
-      });
-      return {
-        strategyName: reference.strategyName,
-        releaseVersion: release.releaseVersion,
-        controlState: reference.controlState,
-        interval,
-        universe,
-        accountId,
-        strategyPackage: release.strategyPackage,
-        strategyPackageVersion: release.strategyPackageVersion,
-        runtimePackageVersion: release.runtimePackageVersion,
-        strategyCreator,
-        sourceStrategyConfig: release.config,
-        strategyConfig: release.config
-      };
-    })
-  );
-};
-var loadResolvedRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deployment,
-  universe,
-  accountId,
-  interval
-}) => {
-  if (!deployment) throw new Error("Runtime deployment is required");
-  const strategies = await loadVersionedRuntimeStrategies({
-    userName,
-    projectRoot,
-    deployment
-  });
-  const filtered = strategies.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 pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
-  const strategyPackage = await resolveStrategyPackageName({
-    pluginSource,
-    projectRoot
-  });
-  return {
-    strategyPackage,
-    strategyPackageVersion: await resolveInstalledPackageVersion(
-      projectRoot,
-      strategyPackage,
-      packageManifest
-    ),
-    runtimePackageVersion: packageManifest.packages?.["@tradejs/node"] ?? null
-  };
-};
 export {
+  getRuntimeDeployment,
   getRuntimeStrategyPackageMetadata,
-  loadResolvedRuntimeStrategies
+  listRuntimeDeployments,
+  loadResolvedRuntimeStrategies,
+  verifyRuntimeDeclaration
 };

package/dist/strategies.js

@@ -712,11 +712,13 @@ var normalizeConfig = (rawConfig) => {
   const hooks = (0, import_config.normalizeTradejsConfigHooks)(
     config.hooks
   );
+  const runtime = config.runtime && typeof config.runtime === "object" && !Array.isArray(config.runtime) ? config.runtime : void 0;
   return {
     strategies: strategies2,
     indicators,
     connectors,
-    ...hooks ? { hooks } : {}
+    ...hooks ? { hooks } : {},
+    ...runtime ? { runtime } : {}
   };
 };
 var getNodeCreateRequire = () => {
@@ -4546,7 +4548,7 @@ var executeEntryOrder = async ({
       deploymentId: signal.deploymentId,
       policyProfileId: signal.policyProfileId,
       runtimeConfigId: signal.runtimeConfigId,
-      runtimeReleaseVersion: signal.runtimeReleaseVersion,
+      runtimeVersion: signal.runtimeVersion,
       runtimeLineage: signal.runtimeLineage,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
@@ -5457,7 +5459,7 @@ var createStrategyRuntime = ({
     deploymentId: requestedDeploymentId,
     policyProfileId,
     runtimeConfigId,
-    runtimeReleaseVersion,
+    runtimeVersion,
     entriesPaused = false,
     runtimeLineage,
     runtimeConfigSnapshot,
@@ -6129,8 +6131,8 @@ var createStrategyRuntime = ({
             signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
           }
         }
-        if (runtimeReleaseVersion) {
-          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        if (runtimeVersion) {
+          signal.runtimeVersion = runtimeVersion;
         }
         if (decisionHookCtx.policyProfileId) {
           signal.policyProfileId = decisionHookCtx.policyProfileId;
@@ -6243,7 +6245,7 @@ var createStrategyRuntime = ({
         if (signal) {
           signal.orderStatus = "skipped";
           signal.orderSkipReason = skipReason;
-          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+          signal.runtimeVersion = runtimeVersion;
         }
         return signal ?? skipReason;
       }

package/dist/strategies.mjs

@@ -22,7 +22,7 @@ import {
   resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   validateEntryProtectionAtArrival
-} from "./chunk-MCDICN3I.mjs";
+} from "./chunk-SVAUSZUE.mjs";
 import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
@@ -39,7 +39,7 @@ import {
   runAiPrompt,
   runAiPromptLocal,
   trimSeriesDeep
-} from "./chunk-SEQJ6V6B.mjs";
+} from "./chunk-733VVTWU.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -54,8 +54,8 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-XN7BC7XK.mjs";
-import "./chunk-WS5DYEVZ.mjs";
+} from "./chunk-MEZIXBZ3.mjs";
+import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 
 // src/strategies.ts