@tradejs/node 3.1.27 → 3.1.28-beta.252

package/dist/backtest.mjs

@@ -5,11 +5,11 @@ import {
 import {
   buildMlPayload,
   enrichSignalWithMarketContextStages
-} from "./chunk-XHNJ757K.mjs";
+} from "./chunk-VQSGH7YA.mjs";
 import {
   buildAiPayload,
   getStrategyCreator
-} from "./chunk-IKRSNRP6.mjs";
+} from "./chunk-UITD6LG6.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-LZDXRXIU.mjs";
@@ -159,6 +159,10 @@ import {
   BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
   FEE_PERCENT
 } from "@tradejs/core/constants";
+import {
+  assertStrategyExecutionIsolation,
+  parseBacktestExecutionCosts
+} from "@tradejs/core/backtest";
 var finiteOr = (value, fallback) => {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
@@ -195,20 +199,27 @@ var loadFundingRates = (connector, symbol, startTime, endTime) => {
 };
 var resolveExecutionCosts = async (params) => {
   const { connector, symbol, config, startTime, endTime, instrument } = params;
-  const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
-  const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
+  assertStrategyExecutionIsolation(config);
+  const costs = params.executionCosts == null ? void 0 : parseBacktestExecutionCosts(params.executionCosts);
+  const cacheOnly = params.cacheOnly === true;
+  const hasConfiguredFees = costs != null;
   const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
-  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? FEE_PERCENT;
-  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? FEE_PERCENT;
-  const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
+  const makerRate = hasConfiguredFees ? costs.fees.makerRate : exchangeFees?.makerRate ?? FEE_PERCENT;
+  const takerRate = hasConfiguredFees ? costs.fees.takerRate : exchangeFees?.takerRate ?? FEE_PERCENT;
+  const fundingEnabled = costs?.funding.enabled !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
   const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
   const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
   const venueMaxLeverage = Number(instrument?.venueMetadata?.maxLeverage);
   const maxAllowed = Number.isFinite(venueMaxLeverage) ? venueMaxLeverage : null;
   const effectiveLeverage = maxAllowed == null ? requestedLeverage : Math.min(requestedLeverage, maxAllowed);
   const feeSource = hasConfiguredFees ? "config" : exchangeFees?.source ?? "fallback";
-  const fundingSource = !fundingEnabled ? cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
-  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || config.SLIPPAGE_BASE_BPS == null && config.SLIPPAGE_SPREAD_MULTIPLIER == null && config.SLIPPAGE_MARKET_IMPACT_BPS == null;
+  const fundingSource = !fundingEnabled ? costs?.funding.enabled === false ? "disabled" : cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
+  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || !costs;
+  if (costs?.funding.enabled && (!fundingEnabled || fundingSource !== "historical")) {
+    throw new Error(
+      "Requested funding history is unavailable; explicitly disable funding or provide historical data"
+    );
+  }
   return {
     model: {
       fees: { makerRate, takerRate, source: feeSource },
@@ -220,20 +231,20 @@ var resolveExecutionCosts = async (params) => {
         toTimestamp: fundingRates.at(-1)?.timestamp ?? null
       },
       slippage: {
-        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, BACKTEST_BASE_SLIPPAGE_BPS),
+        baseBps: costs?.slippage.baseBps ?? BACKTEST_BASE_SLIPPAGE_BPS,
         spreadMultiplier: finiteOr(
-          config.SLIPPAGE_SPREAD_MULTIPLIER,
+          costs?.slippage.spreadMultiplier,
           BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
         ),
         marketImpactBps: finiteOr(
-          config.SLIPPAGE_MARKET_IMPACT_BPS,
+          costs?.slippage.marketImpactBps,
           BACKTEST_MARKET_IMPACT_BPS
         ),
         delayRiskMultiplier: finiteOr(
-          config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
+          costs?.slippage.delayRiskMultiplier,
           BACKTEST_DELAY_RISK_MULTIPLIER
         ),
-        source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
+        source: costs != null ? "config" : "fallback"
       },
       leverage: {
         requested: requestedLeverage,
@@ -555,7 +566,7 @@ var createTestConnector = (connector, context) => {
       allocatedQty += legExitQty;
       const legResult = currentEntryLegResults[leg.index];
       const legGrossProfit = currentPosition.direction === "LONG" ? (executionPrice - legResult.entryPrice) * legExitQty : (legResult.entryPrice - executionPrice) * legExitQty;
-      const legFee = executionPrice * legExitQty * takerFeeRate;
+      const legFee = fee * (legExitQty / qty);
       currentEntryLegResults[leg.index] = appendExitToTradeResult({
         tradeResult: legResult,
         direction: currentPosition.direction,
@@ -1239,7 +1250,8 @@ var createTestConnector = (connector, context) => {
       const { fee, profit } = getNetProfit({
         grossProfit,
         price: executionPrice,
-        qty: currentPosition.qty
+        qty: currentPosition.qty,
+        feeRate: order.isLimit ? makerFeeRate : takerFeeRate
       });
       recordExitResult({
         timestamp: order.timestamp,
@@ -1384,6 +1396,8 @@ var createBacktestSession = async ({
     connector,
     symbol: test.symbol,
     config: test.strategyConfig,
+    executionCosts: test.executionCosts,
+    cacheOnly: test.executionCostsCacheOnly,
     startTime: start,
     endTime: test.options.end,
     instrument

package/dist/{chunk-NQO2MFP6.mjs → chunk-K2YQ3MQC.mjs}

@@ -2,7 +2,7 @@ import {
   getStrategyCreator,
   getStrategyEntry,
   getStrategyPluginSource
-} from "./chunk-IKRSNRP6.mjs";
+} from "./chunk-UITD6LG6.mjs";
 import {
   loadTradejsConfig
 } from "./chunk-LZDXRXIU.mjs";
@@ -40,7 +40,13 @@ var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
   "assetClasses",
   "tickers"
 ]);
-var STRATEGY_KEYS = /* @__PURE__ */ new Set(["generation", "enabled", "selection", "config"]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set([
+  "module",
+  "generation",
+  "enabled",
+  "selection",
+  "config"
+]);
 var SELECTION_KEYS = /* @__PURE__ */ new Set(["tickers"]);
 var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "ACCOUNT_ID",
@@ -112,6 +118,39 @@ var readRuntimePackageManifest = async (projectRoot) => {
   }
   return value;
 };
+var parseNpmAliasReference = (value) => {
+  if (typeof value !== "string" || !value.startsWith("npm:")) return null;
+  const target = value.slice("npm:".length);
+  const versionSeparator = target.lastIndexOf("@");
+  if (versionSeparator <= 0 || versionSeparator === target.length - 1) {
+    return null;
+  }
+  return {
+    packageName: target.slice(0, versionSeparator),
+    version: target.slice(versionSeparator + 1)
+  };
+};
+var verifyInstalledPackageName = async ({
+  projectRoot,
+  packageName,
+  installedName,
+  installedVersion,
+  projectPackage
+}) => {
+  if (installedName === void 0 || installedName === packageName) return;
+  if (projectPackage || typeof installedName !== "string") {
+    throw new Error("name is invalid");
+  }
+  const projectManifest = JSON.parse(
+    await readFile(path.join(projectRoot, "package.json"), "utf8")
+  );
+  const alias = parseNpmAliasReference(
+    projectManifest.dependencies?.[packageName]
+  );
+  if (alias?.packageName !== installedName || alias.version !== installedVersion) {
+    throw new Error("name or alias target is invalid");
+  }
+};
 var readInstalledPackageMetadata = async ({
   projectRoot,
   packageName,
@@ -125,9 +164,16 @@ var readInstalledPackageMetadata = async ({
   );
   try {
     const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    if (packageJson.name !== void 0 && packageJson.name !== packageName || typeof packageJson.version !== "string" || !packageJson.version.trim()) {
-      throw new Error("name or version is invalid");
+    if (typeof packageJson.version !== "string" || !packageJson.version.trim()) {
+      throw new Error("version is invalid");
     }
+    await verifyInstalledPackageName({
+      projectRoot,
+      packageName,
+      installedName: packageJson.name,
+      installedVersion: packageJson.version,
+      projectPackage
+    });
     const dependencyNames = [
       ...isRecord(packageJson.dependencies) ? Object.keys(packageJson.dependencies) : [],
       ...isRecord(packageJson.peerDependencies) ? Object.keys(packageJson.peerDependencies) : []
@@ -222,7 +268,7 @@ var verifyDeploymentDeclaration = (deploymentId, value) => {
   for (const [strategyName, strategyValue] of Object.entries(
     value.strategies
   )) {
-    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
+    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || strategyValue.module !== void 0 && (typeof strategyValue.module !== "string" || !strategyValue.module.trim()) || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !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(
@@ -256,9 +302,9 @@ var resolveStrategyComposition = async ({
   packageManifest
 }) => {
   const [strategyEntry, strategyCreator, pluginSource] = await Promise.all([
-    getStrategyEntry(strategyName, projectRoot),
-    getStrategyCreator(strategyName, projectRoot),
-    getStrategyPluginSource(strategyName, projectRoot)
+    getStrategyEntry(strategyName, projectRoot, declaration.module),
+    getStrategyCreator(strategyName, projectRoot, declaration.module),
+    getStrategyPluginSource(strategyName, projectRoot, declaration.module)
   ]);
   if (!strategyEntry || !strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
@@ -308,6 +354,7 @@ var resolveStrategyComposition = async ({
   });
   return {
     strategyName,
+    strategyModule: pluginSource ?? strategyPackage.name,
     strategyRevision: computeStrategyRevision({
       strategyName,
       strategyPackage: strategyPackage.name,
@@ -496,11 +543,12 @@ var loadResolvedRuntimeStrategies = async ({
 };
 var getRuntimeStrategyPackageMetadata = async ({
   strategyName,
-  projectRoot
+  projectRoot,
+  strategyModule
 }) => {
   const [packageManifest, pluginSource] = await Promise.all([
     readRuntimePackageManifest(projectRoot),
-    getStrategyPluginSource(strategyName, projectRoot)
+    getStrategyPluginSource(strategyName, projectRoot, strategyModule)
   ]);
   const strategyPackage = await resolveStrategyPackage({
     pluginSource: pluginSource ?? null,

package/dist/{chunk-FB5NUEOQ.mjs → chunk-OFVUEYUR.mjs}

@@ -164,7 +164,8 @@ var buildExchangeFallbackRuntimeTrades = ({
   openPositions,
   strategyNames,
   existingTrades,
-  endTime
+  endTime,
+  scope
 }) => {
   if (!entryRows.length && !closedPnlRows.length) return [];
   const strategyNameByOrderId = new Map(
@@ -219,6 +220,7 @@ var buildExchangeFallbackRuntimeTrades = ({
     const entryPrice = typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice) ? entry.entryPrice : typeof closed?.entryPrice === "number" && Number.isFinite(closed.entryPrice) ? closed.entryPrice : null;
     if (entryPrice == null) return null;
     return {
+      ...scope,
       orderId: runtimeOrderId,
       strategy,
       symbol: entry.symbol,
@@ -261,6 +263,7 @@ var buildExchangeFallbackRuntimeTrades = ({
       return null;
     }
     return {
+      ...scope,
       orderId: runtimeOrderId,
       strategy,
       symbol: row.symbol,

package/dist/{chunk-IKRSNRP6.mjs → chunk-UITD6LG6.mjs}

@@ -599,6 +599,7 @@ var createStrategyRegistryState = () => ({
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
   strategySourcesMap: /* @__PURE__ */ new Map(),
+  strategyModuleResolutions: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -660,7 +661,7 @@ var validateStrategyEntries = (moduleName, entries, state) => {
     const strategyName = entry?.manifest?.name;
     if (typeof strategyName !== "string" || !strategyName.trim()) {
       issues.push(`${entryPath}: manifest.name is required`);
-    } else if (names.has(strategyName) || state.strategyEntriesMap.has(strategyName)) {
+    } else if (names.has(strategyName) || state?.strategyEntriesMap.has(strategyName)) {
       issues.push(`${entryPath}: duplicate strategy ${strategyName}`);
     } else {
       names.add(strategyName);
@@ -722,6 +723,72 @@ var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()
     moduleName
   );
 };
+var resolveStrategyModuleEntry = async ({
+  strategyName,
+  moduleName,
+  cwd
+}) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  const source = moduleName.trim();
+  const resolvedModuleName = resolvePluginModuleSpecifier(source, projectRoot);
+  const cacheKey = `${resolvedModuleName}\0${strategyName}`;
+  const cached = state.strategyModuleResolutions.get(cacheKey);
+  if (cached) return cached;
+  const resolution = (async () => {
+    const moduleExport = await importStrategyPluginModule(
+      resolvedModuleName,
+      projectRoot
+    );
+    const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+    if (!pluginDefinition) {
+      throw new Error(`${source}: export { strategyEntries } is missing`);
+    }
+    const issues = validateStrategyEntries(
+      source,
+      pluginDefinition.strategyEntries
+    );
+    if (issues.length > 0) {
+      throw new Error(
+        ["Invalid TradeJS strategy module:", ...issues].join("\n")
+      );
+    }
+    const entry = pluginDefinition.strategyEntries.find(
+      (candidate) => candidate.manifest.name === strategyName
+    );
+    if (!entry) {
+      throw new Error(`${source}: strategy ${strategyName} is missing`);
+    }
+    const factory = sharedStrategyRegistry.strategyRuntimeFactory;
+    if (!factory) {
+      throw new Error("Strategy runtime factory is not configured");
+    }
+    const manifestsByName = new Map(
+      pluginDefinition.strategyEntries.map(
+        (candidate) => [candidate.manifest.name, candidate.manifest]
+      )
+    );
+    return {
+      entry,
+      creator: factory({
+        strategyName,
+        defaults: entry.defaults,
+        createCore: entry.createCore,
+        manifest: entry.manifest,
+        detectorKey: entry.detectorKey,
+        detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+        resolveRegisteredManifest: (name) => manifestsByName.get(name) ?? state.strategyManifestsMap.get(name)
+      }),
+      source
+    };
+  })();
+  state.strategyModuleResolutions.set(cacheKey, resolution);
+  try {
+    return await resolution;
+  } catch (error) {
+    state.strategyModuleResolutions.delete(cacheKey);
+    throw error;
+  }
+};
 var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
   const { projectRoot, state } = getStrategyRegistryState(cwd);
   if (!state.pluginsLoadPromise) {
@@ -800,7 +867,11 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
   await state.pluginsLoadPromise;
 };
 var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
-var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).creator;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyCreators.get(name);
@@ -810,12 +881,20 @@ var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyEntriesMap.get(name)?.defaults;
 };
-var getStrategyEntry = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyEntry = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).entry;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyEntriesMap.get(name);
 };
-var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).source;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategySourcesMap.get(name);