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

package/dist/mcp.mjs

@@ -6,11 +6,12 @@ import {
 import {
   listRuntimeDeployments,
   loadResolvedRuntimeStrategies
-} from "./chunk-BO42QWAB.mjs";
-import "./chunk-PB2KHBGH.mjs";
+} from "./chunk-W6PPAADK.mjs";
+import "./chunk-HRON2EAI.mjs";
+import "./chunk-UUNEWAT4.mjs";
 import {
   ensureIndicatorPluginsLoaded
-} from "./chunk-UL5Z46JL.mjs";
+} from "./chunk-PYJWXAYR.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-YR55Q355.mjs";
 import "./chunk-GHSLOJLE.mjs";

package/dist/portfolio.d.mts

@@ -0,0 +1,28 @@
+import * as _tradejs_types from '@tradejs/types';
+import { PortfolioPolicyConfig, PortfolioStateStore, PortfolioCloseIntent, PortfolioReservation, PortfolioObservation, PortfolioPosition } from '@tradejs/types';
+
+interface PortfolioExecutionAdapter {
+    /** Idempotent bookkeeping, before removing a confirmed close intent from durable state. */
+    confirmClosed?(intent: PortfolioCloseIntent, asOf: number): Promise<void>;
+    observe(asOf: number, reservations: readonly PortfolioReservation[]): Promise<PortfolioObservation>;
+    close(position: PortfolioPosition, intent: PortfolioCloseIntent, asOf: number): Promise<void>;
+}
+/** Shared by runtime and replay. IO is behind observation, execution and CAS storage. */
+declare function createPortfolioCoordinator({ policy, strategy, store, execution, }: {
+    policy: PortfolioPolicyConfig;
+    strategy: string;
+    store: PortfolioStateStore;
+    execution: PortfolioExecutionAdapter;
+}): {
+    context(now: number): Promise<_tradejs_types.PortfolioContext>;
+    tick: (now: number, force?: boolean) => Promise<_tradejs_types.PortfolioContext>;
+    submit<T>(now: number, entry: Omit<PortfolioReservation, "submitted" | "oppositeHandled">, send: (markSubmitted: (qty: number) => Promise<void>, markRejected: () => Promise<void>) => Promise<T>): Promise<{
+        reason?: string;
+        value?: T;
+    }>;
+};
+type PortfolioCoordinator = ReturnType<typeof createPortfolioCoordinator>;
+/** Isolated per replay session, never a global registry. */
+declare function createMemoryPortfolioStore(): PortfolioStateStore;
+
+export { type PortfolioCoordinator, type PortfolioExecutionAdapter, createMemoryPortfolioStore, createPortfolioCoordinator };

package/dist/portfolio.d.ts

@@ -0,0 +1,28 @@
+import * as _tradejs_types from '@tradejs/types';
+import { PortfolioPolicyConfig, PortfolioStateStore, PortfolioCloseIntent, PortfolioReservation, PortfolioObservation, PortfolioPosition } from '@tradejs/types';
+
+interface PortfolioExecutionAdapter {
+    /** Idempotent bookkeeping, before removing a confirmed close intent from durable state. */
+    confirmClosed?(intent: PortfolioCloseIntent, asOf: number): Promise<void>;
+    observe(asOf: number, reservations: readonly PortfolioReservation[]): Promise<PortfolioObservation>;
+    close(position: PortfolioPosition, intent: PortfolioCloseIntent, asOf: number): Promise<void>;
+}
+/** Shared by runtime and replay. IO is behind observation, execution and CAS storage. */
+declare function createPortfolioCoordinator({ policy, strategy, store, execution, }: {
+    policy: PortfolioPolicyConfig;
+    strategy: string;
+    store: PortfolioStateStore;
+    execution: PortfolioExecutionAdapter;
+}): {
+    context(now: number): Promise<_tradejs_types.PortfolioContext>;
+    tick: (now: number, force?: boolean) => Promise<_tradejs_types.PortfolioContext>;
+    submit<T>(now: number, entry: Omit<PortfolioReservation, "submitted" | "oppositeHandled">, send: (markSubmitted: (qty: number) => Promise<void>, markRejected: () => Promise<void>) => Promise<T>): Promise<{
+        reason?: string;
+        value?: T;
+    }>;
+};
+type PortfolioCoordinator = ReturnType<typeof createPortfolioCoordinator>;
+/** Isolated per replay session, never a global registry. */
+declare function createMemoryPortfolioStore(): PortfolioStateStore;
+
+export { type PortfolioCoordinator, type PortfolioExecutionAdapter, createMemoryPortfolioStore, createPortfolioCoordinator };

package/dist/portfolio.js

@@ -0,0 +1,210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/portfolio.ts
+var portfolio_exports = {};
+__export(portfolio_exports, {
+  createMemoryPortfolioStore: () => createMemoryPortfolioStore,
+  createPortfolioCoordinator: () => createPortfolioCoordinator
+});
+module.exports = __toCommonJS(portfolio_exports);
+var import_portfolio = require("@tradejs/core/portfolio");
+function createPortfolioCoordinator({
+  policy,
+  strategy,
+  store,
+  execution
+}) {
+  const fingerprint = (0, import_portfolio.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 ?? (0, import_portfolio.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 = (0, import_portfolio.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 = (0, import_portfolio.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 (0, import_portfolio.buildPortfolioContext)(
+        policy,
+        strategy,
+        refreshed.state,
+        refreshed.observation
+      );
+    }
+    return (0, import_portfolio.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() ?? (0, import_portfolio.createPortfolioState)(fingerprint);
+      if (state.fingerprint !== fingerprint)
+        throw new Error("Portfolio policy changed under existing state");
+      const observation = await execution.observe(now, state.reservations);
+      (0, import_portfolio.validatePortfolioObservation)(observation);
+      return (0, import_portfolio.buildPortfolioContext)(policy, strategy, state, observation);
+    },
+    tick,
+    async submit(now, entry, send) {
+      await tick(now);
+      const admitted = await transact(
+        now,
+        (s, o) => {
+          const r = (0, import_portfolio.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;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMemoryPortfolioStore,
+  createPortfolioCoordinator
+});

package/dist/portfolio.mjs

@@ -0,0 +1,9 @@
+import {
+  createMemoryPortfolioStore,
+  createPortfolioCoordinator
+} from "./chunk-UUNEWAT4.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  createMemoryPortfolioStore,
+  createPortfolioCoordinator
+};