@tradejs/node 3.1.29-beta.290 → 3.1.29-beta.291

package/dist/{chunk-UL5Z46JL.mjs → chunk-PYJWXAYR.mjs}

@@ -12,6 +12,16 @@ import {
 } from "@tradejs/core/aiLanguages";
 import { setData, redisKeys } from "@tradejs/infra/redis";
 
+// src/strategyAdapters/ai.ts
+import { getRegisteredIndicatorEntries } from "@tradejs/core/indicators";
+import {
+  projectAiFeatures,
+  TICKER_PROFILE_AI_FEATURES,
+  PORTFOLIO_AI_FEATURES,
+  validateAiFeatureDefinitions,
+  validateAiFeatureSnapshot
+} from "@tradejs/core/aiFeatures";
+
 // src/aiShared.ts
 var MAX_AI_SERIES_POINTS = 5;
 var COMPACT_INDICATORS_SNAPSHOT_SYMBOL = /* @__PURE__ */ Symbol.for(
@@ -235,37 +245,44 @@ var buildMarketBreadthsContextFromSignal = (signal) => {
     top100: build("top100")
   };
 };
+var buildTargetVsReference = (signal, asset) => {
+  const base = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(base?.relative);
+  const target = toRecord(relative?.[`targetVs${asset}`]);
+  return {
+    source: target ? String(target.source ?? "") : null,
+    available: Boolean(target),
+    ratioReturn1h: toFiniteNumber(target?.ratioReturn1h),
+    ratioReturn4h: toFiniteNumber(target?.ratioReturn4h),
+    ratioReturn24h: toFiniteNumber(target?.ratioReturn24h),
+    alpha1h: toFiniteNumber(target?.[`alphaVs${asset}1h`]),
+    alpha4h: toFiniteNumber(target?.[`alphaVs${asset}4h`]),
+    alpha24h: toFiniteNumber(target?.[`alphaVs${asset}24h`]),
+    beta: toFiniteNumber(target?.[`betaTo${asset}20`]),
+    correlation: toFiniteNumber(target?.[`correlationTo${asset}20`]),
+    ratioTrend: typeof target?.ratioTrend === "string" ? target.ratioTrend : null
+  };
+};
 var buildTargetVsBtcContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const targetVsBtc = toRecord(relative?.targetVsBtc);
-  if (!targetVsBtc) {
-    return {
-      source: null,
-      available: false,
-      ratioReturn1h: null,
-      ratioReturn4h: null,
-      ratioReturn24h: null,
-      alphaVsBtc1h: null,
-      alphaVsBtc4h: null,
-      alphaVsBtc24h: null,
-      betaToBtc20: null,
-      correlationToBtc20: null,
-      ratioTrend: null
-    };
-  }
+  const { alpha1h, alpha4h, alpha24h, beta, correlation, ...shared } = buildTargetVsReference(signal, "Btc");
   return {
-    source: String(targetVsBtc.source ?? ""),
-    available: true,
-    ratioReturn1h: toFiniteNumber(targetVsBtc.ratioReturn1h),
-    ratioReturn4h: toFiniteNumber(targetVsBtc.ratioReturn4h),
-    ratioReturn24h: toFiniteNumber(targetVsBtc.ratioReturn24h),
-    alphaVsBtc1h: toFiniteNumber(targetVsBtc.alphaVsBtc1h),
-    alphaVsBtc4h: toFiniteNumber(targetVsBtc.alphaVsBtc4h),
-    alphaVsBtc24h: toFiniteNumber(targetVsBtc.alphaVsBtc24h),
-    betaToBtc20: toFiniteNumber(targetVsBtc.betaToBtc20),
-    correlationToBtc20: toFiniteNumber(targetVsBtc.correlationToBtc20),
-    ratioTrend: typeof targetVsBtc.ratioTrend === "string" ? targetVsBtc.ratioTrend : null
+    ...shared,
+    alphaVsBtc1h: alpha1h,
+    alphaVsBtc4h: alpha4h,
+    alphaVsBtc24h: alpha24h,
+    betaToBtc20: beta,
+    correlationToBtc20: correlation
+  };
+};
+var buildTargetVsEthContextFromSignal = (signal) => {
+  const { alpha1h, alpha4h, alpha24h, beta, correlation, ...shared } = buildTargetVsReference(signal, "Eth");
+  return {
+    ...shared,
+    alphaVsEth1h: alpha1h,
+    alphaVsEth4h: alpha4h,
+    alphaVsEth24h: alpha24h,
+    betaToEth20: beta,
+    correlationToEth20: correlation
   };
 };
 var buildBtcAltRegimeContextFromSignal = (signal) => {
@@ -574,6 +591,7 @@ var buildAiMarketContext = (signal) => ({
     marketBreadth: buildMarketBreadthContextFromSignal(signal),
     marketBreadths: buildMarketBreadthsContextFromSignal(signal),
     targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
+    targetVsEth: buildTargetVsEthContextFromSignal(signal),
     btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
     cmcGlobal: buildCmcGlobalContextFromSignal(signal),
     cmcReferenceAssets: buildCmcReferenceAssetsContextFromSignal(signal),
@@ -1061,12 +1079,61 @@ var buildBaseAiPayload = (signal) => {
   };
 };
 var defaultAiAdapter = {};
+var tickerProfileFeatureIds = new Set(
+  TICKER_PROFILE_AI_FEATURES.map(({ id }) => id)
+);
 var getStrategyAiAdapter = (strategy, profileId) => getStrategyProfileAiAdapter(getStrategyManifest(strategy), profileId) ?? defaultAiAdapter;
 var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy, signal.policyProfileId);
 var buildAiPayloadByStrategy = (signal) => {
   const basePayload = buildBaseAiPayload(signal);
   const adapter = getSignalAiAdapter(signal);
-  return adapter.buildPayload?.({ signal, basePayload }) ?? basePayload;
+  const payload = adapter.buildPayload?.({ signal, basePayload }) ?? basePayload;
+  const custom = getStrategyManifest(signal.strategy)?.aiFeatures ?? [];
+  const frozen = signal.aiFeatureReplay?.snapshot;
+  if (frozen) validateAiFeatureSnapshot(frozen);
+  const tickerProfile = signal.additionalIndicators?.tickerProfile ?? signal.additionalIndicators?.baseContext?.tickerProfile;
+  const hasProfile = Boolean(
+    tickerProfile || frozen?.definitions.some(({ id }) => tickerProfileFeatureIds.has(id))
+  );
+  const indicatorFeatures = getRegisteredIndicatorEntries(
+    getTradejsProjectCwd()
+  ).flatMap((entry) => entry.indicator.enabled ? entry.aiFeatures ?? [] : []);
+  const hasPortfolio = Boolean(
+    signal.additionalIndicators?.portfolioContext || frozen?.definitions.some(
+      ({ id }) => PORTFOLIO_AI_FEATURES.some((d) => d.id === id)
+    )
+  );
+  const definitions = [
+    ...hasPortfolio ? PORTFOLIO_AI_FEATURES : [],
+    ...hasProfile ? TICKER_PROFILE_AI_FEATURES : [],
+    ...indicatorFeatures,
+    ...custom
+  ];
+  if (!definitions.length && !signal.aiFeatureReplay?.snapshot) return payload;
+  validateAiFeatureDefinitions(definitions);
+  if (signal.aiFeatureReplay && !frozen) {
+    throw new Error(
+      "Dataset has no frozen AI features; regenerate the decision-time export"
+    );
+  }
+  if (frozen && JSON.stringify(frozen.definitions) !== JSON.stringify(definitions)) {
+    throw new Error(
+      "AI feature definition changed; regenerate the decision-time export"
+    );
+  }
+  return {
+    ...payload,
+    featureSnapshot: frozen ?? projectAiFeatures(definitions, {
+      signal: tickerProfile ? {
+        ...signal,
+        additionalIndicators: {
+          ...signal.additionalIndicators,
+          tickerProfile
+        }
+      } : signal,
+      payload
+    })
+  };
 };
 var buildAiSystemPromptAddonByStrategy = (signal) => getSignalAiAdapter(signal).buildSystemPromptAddon?.({ signal }) ?? "";
 var buildAiHumanPromptAddonByStrategy = (signal, payload) => getSignalAiAdapter(signal).buildHumanPromptAddon?.({

package/dist/chunk-UUNEWAT4.mjs

@@ -0,0 +1,193 @@
+// src/portfolio.ts
+import {
+  buildPortfolioContext,
+  createPortfolioState,
+  portfolioFingerprint,
+  reconcilePortfolio,
+  reservePortfolioEntry,
+  portfolioCloseCommands,
+  validatePortfolioObservation
+} from "@tradejs/core/portfolio";
+function createPortfolioCoordinator({
+  policy,
+  strategy,
+  store,
+  execution
+}) {
+  const fingerprint = portfolioFingerprint(policy, strategy);
+  let cache;
+  async function transact(now, change, force = false) {
+    for (let attempt = 0; attempt < 16; attempt++) {
+      const previous = await store.read();
+      if (previous && previous.fingerprint !== fingerprint)
+        throw new Error(
+          "Portfolio policy changed under existing state; reconcile the persisted scope before changing configuration"
+        );
+      const base = previous ?? createPortfolioState(fingerprint);
+      const bucket = Math.floor(now / policy.observationIntervalMs);
+      const observation = !force && cache?.revision === base.revision && cache.bucket === bucket ? cache.observation : await execution.observe(now, base.reservations);
+      const reconciled = reconcilePortfolio(
+        policy,
+        strategy,
+        base,
+        observation
+      );
+      for (const intent of base.closing) {
+        if (!observation.positions.some(
+          (p) => p.symbol === intent.position.symbol
+        ))
+          await execution.confirmClosed?.(intent, observation.asOf);
+      }
+      const changed = change(reconciled, observation);
+      const next = { ...changed.state, revision: base.revision + 1 };
+      if (await store.compare(previous, next)) {
+        cache = { revision: next.revision, bucket, observation };
+        return { state: next, observation, result: changed.result };
+      }
+      cache = void 0;
+    }
+    throw new Error("Portfolio state contention; entry was not submitted");
+  }
+  async function tick(now, force = false) {
+    const claimed = await transact(
+      now,
+      (state, observation) => {
+        const commands = portfolioCloseCommands(policy, state, observation);
+        return {
+          state: {
+            ...state,
+            closing: state.closing.map(
+              (c) => commands.some((x) => x.intent.positionId === c.positionId) ? { ...c, lastAttemptAt: observation.asOf } : c
+            )
+          },
+          result: commands
+        };
+      },
+      force
+    );
+    for (const command of claimed.result)
+      await execution.close(
+        command.position,
+        command.intent,
+        claimed.observation.asOf
+      );
+    if (claimed.result.length) {
+      cache = void 0;
+      const refreshed = await transact(
+        now,
+        (state) => ({ state, result: void 0 }),
+        true
+      );
+      return buildPortfolioContext(
+        policy,
+        strategy,
+        refreshed.state,
+        refreshed.observation
+      );
+    }
+    return buildPortfolioContext(
+      policy,
+      strategy,
+      claimed.state,
+      claimed.observation
+    );
+  }
+  async function updateReservation(now, id, submitted, qty) {
+    return transact(
+      now,
+      (s, o) => {
+        const exists = s.reservations.some((r) => r.id === id);
+        const blocked = submitted && (!exists || s.closing.length > 0 || o.asOf <= s.blockedThrough);
+        return {
+          state: {
+            ...s,
+            reservations: s.reservations.flatMap(
+              (r) => r.id !== id ? [r] : submitted && !blocked ? [{ ...r, submitted: true, qty: qty ?? r.qty }] : []
+            )
+          },
+          result: !blocked
+        };
+      },
+      true
+    );
+  }
+  return {
+    async context(now) {
+      const state = await store.read() ?? createPortfolioState(fingerprint);
+      if (state.fingerprint !== fingerprint)
+        throw new Error("Portfolio policy changed under existing state");
+      const observation = await execution.observe(now, state.reservations);
+      validatePortfolioObservation(observation);
+      return buildPortfolioContext(policy, strategy, state, observation);
+    },
+    tick,
+    async submit(now, entry, send) {
+      await tick(now);
+      const admitted = await transact(
+        now,
+        (s, o) => {
+          const r = reservePortfolioEntry(policy, strategy, s, o, {
+            ...entry,
+            submitted: false,
+            oppositeHandled: false
+          });
+          return { state: r.state, result: r.reason };
+        },
+        true
+      );
+      if (admitted.result) return { reason: admitted.result };
+      let submitted = false;
+      try {
+        const value = await send(
+          async (qty) => {
+            if (!Number.isFinite(qty) || qty <= 0)
+              throw new Error("Invalid submitted portfolio quantity");
+            submitted = true;
+            const update = await updateReservation(now, entry.id, true, qty);
+            if (!update.result)
+              throw new Error("PORTFOLIO_SUBMISSION_NO_LONGER_ADMITTED");
+          },
+          async () => {
+            await transact(
+              now,
+              (s) => ({
+                state: {
+                  ...s,
+                  reservations: s.reservations.filter((r) => r.id !== entry.id),
+                  completedSignals: {
+                    ...s.completedSignals,
+                    [entry.signalId]: now
+                  }
+                },
+                result: void 0
+              }),
+              true
+            );
+          }
+        );
+        if (!submitted) await updateReservation(now, entry.id, false);
+        else await tick(now, true);
+        return { value };
+      } catch (error) {
+        if (!submitted) await updateReservation(now, entry.id, false);
+        throw error;
+      }
+    }
+  };
+}
+function createMemoryPortfolioStore() {
+  let state = null;
+  return {
+    read: async () => state === null ? null : structuredClone(state),
+    compare: async (expected, next) => {
+      if ((state?.revision ?? -1) !== (expected?.revision ?? -1)) return false;
+      state = structuredClone(next);
+      return true;
+    }
+  };
+}
+
+export {
+  createPortfolioCoordinator,
+  createMemoryPortfolioStore
+};

package/dist/{chunk-BO42QWAB.mjs → chunk-W6PPAADK.mjs}

@@ -2,7 +2,7 @@ import {
   getStrategyCreator,
   getStrategyEntry,
   getStrategyPluginSource
-} from "./chunk-UL5Z46JL.mjs";
+} from "./chunk-PYJWXAYR.mjs";
 import {
   loadTradejsConfig
 } from "./chunk-LZDXRXIU.mjs";