@tradejs/infra 3.1.28-beta.252 → 3.1.28-beta.254

package/dist/{chunk-46XQGVDB.mjs → chunk-GTZOMAFK.mjs}

@@ -602,6 +602,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/redis.d.mts

@@ -47,6 +47,9 @@ declare const redisKeys: {
     tradingAccounts: (userName: string) => string;
     tradingAccount: (userName: string, accountId: string) => string;
     runtimeDeploymentHeartbeat: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionState: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionEvents: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionEvent: (userName: string, deploymentId: string, eventId: string) => string;
     runtimeControls: (userName: string) => string;
     bots: (userName: string) => string;
     botsPrefix: () => string;

package/dist/redis.d.ts

@@ -47,6 +47,9 @@ declare const redisKeys: {
     tradingAccounts: (userName: string) => string;
     tradingAccount: (userName: string, accountId: string) => string;
     runtimeDeploymentHeartbeat: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionState: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionEvents: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentCompositionEvent: (userName: string, deploymentId: string, eventId: string) => string;
     runtimeControls: (userName: string) => string;
     bots: (userName: string) => string;
     botsPrefix: () => string;

package/dist/redis.js

@@ -657,6 +657,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/redis.mjs

@@ -21,7 +21,7 @@ import {
   setDataStrict,
   setHashJsonField,
   setHashJsonFields
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 export {
   RedisWriteBlockedError,
   closeRedisConnection,

package/dist/runtimeControls.js

@@ -257,6 +257,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/runtimeControls.mjs

@@ -3,7 +3,7 @@ import {
   getDataStrict,
   redisKeys,
   setDataStrict
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 
 // src/runtimeControls.ts
 import { randomUUID } from "crypto";

package/dist/runtimeDeploymentEvents.d.mts

@@ -0,0 +1,11 @@
+import { RuntimeDeploymentCompositionEvent, RuntimeDeployment } from '@tradejs/types';
+
+declare const isRuntimeDeploymentCompositionEvent: (value: unknown) => value is RuntimeDeploymentCompositionEvent;
+declare const observeRuntimeDeploymentComposition: ({ userName, deployment, observedAt, }: {
+    userName: string;
+    deployment: RuntimeDeployment;
+    observedAt?: number;
+}) => Promise<RuntimeDeploymentCompositionEvent | null>;
+declare const loadRuntimeDeploymentCompositionEvents: (userName: string, deploymentId: string) => Promise<RuntimeDeploymentCompositionEvent[]>;
+
+export { isRuntimeDeploymentCompositionEvent, loadRuntimeDeploymentCompositionEvents, observeRuntimeDeploymentComposition };

package/dist/runtimeDeploymentEvents.d.ts

@@ -0,0 +1,11 @@
+import { RuntimeDeploymentCompositionEvent, RuntimeDeployment } from '@tradejs/types';
+
+declare const isRuntimeDeploymentCompositionEvent: (value: unknown) => value is RuntimeDeploymentCompositionEvent;
+declare const observeRuntimeDeploymentComposition: ({ userName, deployment, observedAt, }: {
+    userName: string;
+    deployment: RuntimeDeployment;
+    observedAt?: number;
+}) => Promise<RuntimeDeploymentCompositionEvent | null>;
+declare const loadRuntimeDeploymentCompositionEvents: (userName: string, deploymentId: string) => Promise<RuntimeDeploymentCompositionEvent[]>;
+
+export { isRuntimeDeploymentCompositionEvent, loadRuntimeDeploymentCompositionEvents, observeRuntimeDeploymentComposition };

package/dist/runtimeDeploymentEvents.js

@@ -0,0 +1,446 @@
+"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/runtimeDeploymentEvents.ts
+var runtimeDeploymentEvents_exports = {};
+__export(runtimeDeploymentEvents_exports, {
+  isRuntimeDeploymentCompositionEvent: () => isRuntimeDeploymentCompositionEvent,
+  loadRuntimeDeploymentCompositionEvents: () => loadRuntimeDeploymentCompositionEvents,
+  observeRuntimeDeploymentComposition: () => observeRuntimeDeploymentComposition
+});
+module.exports = __toCommonJS(runtimeDeploymentEvents_exports);
+var import_node_crypto = require("crypto");
+var import_types = require("@tradejs/types");
+
+// src/redis.ts
+var import_ioredis = __toESM(require("ioredis"));
+var TTL_1D = 86400;
+var SCREENSHOT_TOKEN_TTL_SECONDS = 15 * 60;
+var toJson = (value) => JSON.stringify(value);
+var logger = {
+  log: (level, message, ...args) => {
+    const method = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+    console[method](`[infra:redis] ${message}`, ...args);
+  }
+};
+var redisConnectionWarningShown = false;
+var redisUnavailable = false;
+var isRedisConnectivityError = (error) => {
+  const errorText = [error.name, error.message, String(error)].join(" ");
+  return /ECONNREFUSED|ECONNRESET|ECONNABORTED|EPIPE|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+    errorText
+  );
+};
+var toNonNegativeInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+var toPositiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var markRedisUnavailable = (error) => {
+  redisUnavailable = true;
+  if (redisConnectionWarningShown) return;
+  redisConnectionWarningShown = true;
+  logger.log(
+    "warn",
+    "Redis is unavailable: %s. Cache-dependent features are temporarily disabled.",
+    error.message
+  );
+};
+var getRedis = () => {
+  if (!global.__redis__) {
+    const host = process.env.REDIS_HOST || "127.0.0.1";
+    const port = toPositiveInt(process.env.REDIS_PORT, 6379);
+    const connectTimeout = toPositiveInt(
+      process.env.REDIS_CONNECT_TIMEOUT_MS,
+      3e3
+    );
+    const maxRetriesPerRequest = toNonNegativeInt(
+      process.env.REDIS_MAX_RETRIES_PER_REQUEST,
+      1
+    );
+    global.__redis__ = new import_ioredis.default({
+      host,
+      port,
+      connectTimeout,
+      maxRetriesPerRequest,
+      enableOfflineQueue: false,
+      retryStrategy: (attempt) => Math.min(attempt * 200, 2e3)
+    });
+    global.__redis__.on("error", (error) => {
+      if (isRedisConnectivityError(error)) {
+        markRedisUnavailable(error);
+        return;
+      }
+      logger.log("error", "Redis client error: %s", String(error));
+    });
+    global.__redis__.on("ready", () => {
+      redisUnavailable = false;
+      if (redisConnectionWarningShown) {
+        redisConnectionWarningShown = false;
+        logger.log("info", "Redis connection restored");
+      }
+    });
+  }
+  return global.__redis__;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getRedisStatus = (redis) => String(redis.status ?? "ready");
+var waitForRedisReady = async (redis) => {
+  if (getRedisStatus(redis) === "ready") {
+    return true;
+  }
+  const readyTimeoutMs = toPositiveInt(
+    process.env.REDIS_READY_TIMEOUT_MS,
+    toPositiveInt(process.env.REDIS_CONNECT_TIMEOUT_MS, 3e3)
+  );
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < readyTimeoutMs) {
+    if (getRedisStatus(redis) === "ready") {
+      return true;
+    }
+    if (getRedisStatus(redis) === "end") {
+      return false;
+    }
+    await sleep(50);
+  }
+  return getRedisStatus(redis) === "ready";
+};
+var getReadyRedis = async () => {
+  if (redisUnavailable) return null;
+  const redis = getRedis();
+  const ready = await waitForRedisReady(redis);
+  if (ready) {
+    return redis;
+  }
+  markRedisUnavailable(
+    new Error(`Redis is not ready (status=${getRedisStatus(redis)})`)
+  );
+  return null;
+};
+var toResultString = (result) => {
+  if (result == null) return null;
+  if (typeof result === "string") return result;
+  if (Buffer.isBuffer(result)) return result.toString("utf8");
+  return String(result);
+};
+var DEFAULT_OPTIONS = {
+  expire: TTL_1D
+};
+var parseJsonOrDeleteKey = async (redis, key, raw, fallback) => {
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    logger.log("error", "failed JSON.parse(%s): %s", key, String(e));
+    await redis.del(key);
+    return fallback;
+  }
+};
+var getKeys = async (prefix) => {
+  if (redisUnavailable) return [];
+  const redis = await getReadyRedis();
+  if (!redis) return [];
+  const keys = [];
+  try {
+    let cursor = "0";
+    do {
+      const [nextCursor, batch] = await redis.scan(
+        cursor,
+        "MATCH",
+        `${prefix}*`,
+        "COUNT",
+        "200"
+      );
+      cursor = nextCursor;
+      for (const key of batch) {
+        if (key.startsWith(prefix)) {
+          keys.push(key);
+        }
+      }
+    } while (cursor !== "0");
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return [];
+    }
+    logger.log("warn", "failed SCAN for %s: %s", prefix, String(e));
+    return [];
+  }
+  return keys;
+};
+var getData = async (key, fallback = []) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const rawJson = await redis.call("JSON.GET", key);
+    const raw = toResultString(rawJson);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log(
+      "error",
+      "failed JSON.GET %s: %s (fallback to GET)",
+      key,
+      String(e)
+    );
+  }
+  try {
+    const raw = await redis.get(key);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed GET %s: %s", key, String(e));
+    return fallback;
+  }
+};
+var requireReadyRedis = async () => {
+  if (redisUnavailable) {
+    throw new Error("Redis is unavailable");
+  }
+  const redis = await getReadyRedis();
+  if (!redis) {
+    throw new Error("Redis is unavailable");
+  }
+  return redis;
+};
+var setDataStrict = async (key, data, options = {}) => {
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await requireReadyRedis();
+  const value = toJson(data);
+  try {
+    await redis.call("JSON.SET", key, "$", value);
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+    return;
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+      throw error;
+    }
+    logger.log(
+      "error",
+      "failed strict JSON.SET %s: %s (fallback to SET)",
+      key,
+      String(error)
+    );
+  }
+  try {
+    if (expire) {
+      await redis.set(key, value, "EX", expire);
+    } else {
+      await redis.set(key, value);
+    }
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+    }
+    throw error;
+  }
+};
+var redisKeys = {
+  users: () => "users:index:",
+  user: (userName) => `users:index:${userName}`,
+  tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
+  tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
+  runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
+  runtimeControls: (userName) => `users:${userName}:runtime:controls`,
+  bots: (userName) => `users:${userName}:bots`,
+  botsPrefix: () => "users:",
+  bot: (userName, botId) => `users:${userName}:bots:${botId}`,
+  backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
+  strategies: (userName) => `users:${userName}:strategies`,
+  strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
+  runtimeStrategyControlEvents: (userName) => `users:${userName}:runtime:strategy-control-events:`,
+  runtimeStrategyControlEvent: (userName, eventId) => `users:${userName}:runtime:strategy-control-events:${eventId}`,
+  strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
+  strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
+  strategyChartCard: (userName, mode, cardId) => `users:${userName}:strategies:charts:${mode}:cards:${cardId}`,
+  tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
+  testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
+  testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
+  testStat: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:stat`,
+  testSummaries: (userName) => `users:${userName}:tests:index:summary`,
+  cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
+  cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
+  cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  tickerUniverse: (userName, connectorName, universe, accountId) => universe || accountId ? `users:${userName}:cache:tickers:${connectorName}:${universe ?? "crypto"}:${accountId ?? "default"}` : `users:${userName}:cache:tickers:${connectorName}`,
+  signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
+  signalsBySymbol: (symbol) => `signals:${symbol}:`,
+  storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
+  runtimeSignals: (userName) => `users:${userName}:runtime:signals:`,
+  runtimeSignal: (userName, signalId) => `users:${userName}:runtime:signals:${signalId}`,
+  runtimeSignalBuckets: (userName) => `users:${userName}:runtime:signals:days:`,
+  runtimeSignalBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signals:days:${dayKey}:${strategyName}`,
+  runtimeSignalEvaluations: (userName) => `users:${userName}:runtime:signal-evaluations:`,
+  runtimeSignalEvaluation: (userName, evaluationId) => `users:${userName}:runtime:signal-evaluations:${evaluationId}`,
+  runtimeSignalEvaluationBuckets: (userName) => `users:${userName}:runtime:signal-evaluations:days:`,
+  runtimeSignalEvaluationBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluations:days:${dayKey}:${strategyName}`,
+  runtimeSignalEvaluationStatsBuckets: (userName) => `users:${userName}:runtime:signal-evaluation-stats:days:`,
+  runtimeSignalEvaluationStatsBucket: (userName, dayKey, strategyName, deploymentId) => `users:${userName}:runtime:signal-evaluation-stats:days:${dayKey}:${deploymentId ? `${deploymentId}:` : ""}${strategyName}`,
+  runtimeLineageScopeBucket: (userName, dayKey) => `users:${userName}:runtime:lineage-scopes:days:${dayKey}`,
+  runtimeTrades: (userName) => `users:${userName}:runtime:trade-records:`,
+  runtimeTrade: (userName, orderId) => `users:${userName}:runtime:trade-records:${orderId}`,
+  runtimeTradeBuckets: (userName) => `users:${userName}:runtime:trade-records:days:`,
+  runtimeTradeBucket: (userName, dayKey) => `users:${userName}:runtime:trade-records:days:${dayKey}`,
+  runtimeClosedTradeBuckets: (userName) => `users:${userName}:runtime:closed-trade-records:days:`,
+  runtimeClosedTradeBucket: (userName, dayKey) => `users:${userName}:runtime:closed-trade-records:days:${dayKey}`,
+  runtimeActiveTrades: (userName) => `users:${userName}:runtime:active-trades:`,
+  runtimeActiveTrade: (userName, symbol, scopeId) => scopeId ? `users:${userName}:runtime:active-trades:${scopeId}:${symbol}` : `users:${userName}:runtime:active-trades:${symbol}`,
+  aiChatHistory: (userName, symbolKey) => `users:${userName}:ai:chats:${symbolKey}`,
+  analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
+  screenshotSessionToken: (token) => `auth:screenshot:${token}`,
+  backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  backtestJobs: (userName) => `users:${userName}:backtests:jobs:`,
+  backtestJob: (userName, jobId) => `users:${userName}:backtests:jobs:${jobId}`,
+  backtestRuns: (userName) => `users:${userName}:backtests:runs:`,
+  backtestRun: (userName, runId) => `users:${userName}:backtests:runs:${runId}`,
+  backtestRunResults: (userName, runId) => `users:${userName}:backtests:runs:${runId}:results`,
+  backtestLatestRun: (userName, config) => `users:${userName}:backtests:latest:${config}`,
+  researchRuns: (userName) => `users:${userName}:research:runs:`,
+  researchRun: (userName, runId) => `users:${userName}:research:runs:${runId}`,
+  researchLatestRun: (userName, strategyName) => `users:${userName}:research:latest:${strategyName}`,
+  mlSignalsByStrategy: (strategyName) => `ml:${strategyName}:signals:`,
+  mlSignals: () => "ml:",
+  mlSignal: (strategyName, signalId) => `ml:${strategyName}:signals:${signalId}`,
+  mlResultsByStrategy: (strategyName) => `ml:${strategyName}:results:`,
+  mlResults: () => "ml:",
+  mlResult: (strategyName, signalId) => `ml:${strategyName}:results:${signalId}`
+};
+
+// src/runtimeDeploymentEvents.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var normalizeDeploymentId = (value) => {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  if (!normalized) throw new Error("Deployment id is required");
+  return normalized;
+};
+var isRuntimeDeploymentCompositionEvent = (value) => {
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => ![
+      "schema",
+      "eventId",
+      "deploymentId",
+      "deploymentCompositionId",
+      "observedAt",
+      "strategies"
+    ].includes(key)
+  ) || value.schema !== import_types.RUNTIME_DEPLOYMENT_COMPOSITION_EVENT_SCHEMA || typeof value.eventId !== "string" || !value.eventId.trim() || typeof value.deploymentId !== "string" || !value.deploymentId.trim() || typeof value.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || value.observedAt < 0 || !Array.isArray(value.strategies)) {
+    return false;
+  }
+  const strategyNames = /* @__PURE__ */ new Set();
+  for (const strategy of value.strategies) {
+    if (!isRecord(strategy) || Object.keys(strategy).some(
+      (key) => !["strategyName", "strategyRevision"].includes(key)
+    ) || typeof strategy.strategyName !== "string" || !strategy.strategyName.trim() || strategyNames.has(strategy.strategyName) || typeof strategy.strategyRevision !== "string" || !/^sr1:[a-f0-9]{16}$/.test(strategy.strategyRevision)) {
+      return false;
+    }
+    strategyNames.add(strategy.strategyName);
+  }
+  return true;
+};
+var observeRuntimeDeploymentComposition = async ({
+  userName,
+  deployment,
+  observedAt = Date.now()
+}) => {
+  if (!Number.isFinite(observedAt) || observedAt < 0) {
+    throw new Error("Invalid deployment composition observation time");
+  }
+  const deploymentId = normalizeDeploymentId(deployment.id);
+  const stateKey = redisKeys.runtimeDeploymentCompositionState(
+    userName,
+    deploymentId
+  );
+  const current = await getData(stateKey, null);
+  if (isRuntimeDeploymentCompositionEvent(current) && current.deploymentId === deploymentId && current.deploymentCompositionId === deployment.deploymentCompositionId) {
+    return null;
+  }
+  const event = {
+    schema: import_types.RUNTIME_DEPLOYMENT_COMPOSITION_EVENT_SCHEMA,
+    eventId: `${observedAt}-${(0, import_node_crypto.randomUUID)()}`,
+    deploymentId,
+    deploymentCompositionId: deployment.deploymentCompositionId,
+    observedAt,
+    strategies: deployment.strategies.map(({ strategyName, strategyRevision }) => ({
+      strategyName,
+      strategyRevision
+    })).sort(
+      (left, right) => left.strategyName.localeCompare(right.strategyName)
+    )
+  };
+  if (!isRuntimeDeploymentCompositionEvent(event)) {
+    throw new Error("Invalid runtime deployment composition event");
+  }
+  await setDataStrict(
+    redisKeys.runtimeDeploymentCompositionEvent(
+      userName,
+      deploymentId,
+      event.eventId
+    ),
+    event,
+    { expire: 0 }
+  );
+  await setDataStrict(stateKey, event, { expire: 0 });
+  return event;
+};
+var loadRuntimeDeploymentCompositionEvents = async (userName, deploymentId) => {
+  const normalizedDeploymentId = normalizeDeploymentId(deploymentId);
+  const keys = await getKeys(
+    redisKeys.runtimeDeploymentCompositionEvents(
+      userName,
+      normalizedDeploymentId
+    )
+  );
+  const values = await Promise.all(keys.map((key) => getData(key, null)));
+  return values.filter(isRuntimeDeploymentCompositionEvent).filter((event) => event.deploymentId === normalizedDeploymentId).sort(
+    (left, right) => left.observedAt - right.observedAt || left.eventId.localeCompare(right.eventId)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRuntimeDeploymentCompositionEvent,
+  loadRuntimeDeploymentCompositionEvents,
+  observeRuntimeDeploymentComposition
+});

package/dist/runtimeDeploymentEvents.mjs

@@ -0,0 +1,105 @@
+import {
+  getData,
+  getKeys,
+  redisKeys,
+  setDataStrict
+} from "./chunk-GTZOMAFK.mjs";
+
+// src/runtimeDeploymentEvents.ts
+import { randomUUID } from "crypto";
+import {
+  RUNTIME_DEPLOYMENT_COMPOSITION_EVENT_SCHEMA
+} from "@tradejs/types";
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var normalizeDeploymentId = (value) => {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  if (!normalized) throw new Error("Deployment id is required");
+  return normalized;
+};
+var isRuntimeDeploymentCompositionEvent = (value) => {
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => ![
+      "schema",
+      "eventId",
+      "deploymentId",
+      "deploymentCompositionId",
+      "observedAt",
+      "strategies"
+    ].includes(key)
+  ) || value.schema !== RUNTIME_DEPLOYMENT_COMPOSITION_EVENT_SCHEMA || typeof value.eventId !== "string" || !value.eventId.trim() || typeof value.deploymentId !== "string" || !value.deploymentId.trim() || typeof value.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || value.observedAt < 0 || !Array.isArray(value.strategies)) {
+    return false;
+  }
+  const strategyNames = /* @__PURE__ */ new Set();
+  for (const strategy of value.strategies) {
+    if (!isRecord(strategy) || Object.keys(strategy).some(
+      (key) => !["strategyName", "strategyRevision"].includes(key)
+    ) || typeof strategy.strategyName !== "string" || !strategy.strategyName.trim() || strategyNames.has(strategy.strategyName) || typeof strategy.strategyRevision !== "string" || !/^sr1:[a-f0-9]{16}$/.test(strategy.strategyRevision)) {
+      return false;
+    }
+    strategyNames.add(strategy.strategyName);
+  }
+  return true;
+};
+var observeRuntimeDeploymentComposition = async ({
+  userName,
+  deployment,
+  observedAt = Date.now()
+}) => {
+  if (!Number.isFinite(observedAt) || observedAt < 0) {
+    throw new Error("Invalid deployment composition observation time");
+  }
+  const deploymentId = normalizeDeploymentId(deployment.id);
+  const stateKey = redisKeys.runtimeDeploymentCompositionState(
+    userName,
+    deploymentId
+  );
+  const current = await getData(stateKey, null);
+  if (isRuntimeDeploymentCompositionEvent(current) && current.deploymentId === deploymentId && current.deploymentCompositionId === deployment.deploymentCompositionId) {
+    return null;
+  }
+  const event = {
+    schema: RUNTIME_DEPLOYMENT_COMPOSITION_EVENT_SCHEMA,
+    eventId: `${observedAt}-${randomUUID()}`,
+    deploymentId,
+    deploymentCompositionId: deployment.deploymentCompositionId,
+    observedAt,
+    strategies: deployment.strategies.map(({ strategyName, strategyRevision }) => ({
+      strategyName,
+      strategyRevision
+    })).sort(
+      (left, right) => left.strategyName.localeCompare(right.strategyName)
+    )
+  };
+  if (!isRuntimeDeploymentCompositionEvent(event)) {
+    throw new Error("Invalid runtime deployment composition event");
+  }
+  await setDataStrict(
+    redisKeys.runtimeDeploymentCompositionEvent(
+      userName,
+      deploymentId,
+      event.eventId
+    ),
+    event,
+    { expire: 0 }
+  );
+  await setDataStrict(stateKey, event, { expire: 0 });
+  return event;
+};
+var loadRuntimeDeploymentCompositionEvents = async (userName, deploymentId) => {
+  const normalizedDeploymentId = normalizeDeploymentId(deploymentId);
+  const keys = await getKeys(
+    redisKeys.runtimeDeploymentCompositionEvents(
+      userName,
+      normalizedDeploymentId
+    )
+  );
+  const values = await Promise.all(keys.map((key) => getData(key, null)));
+  return values.filter(isRuntimeDeploymentCompositionEvent).filter((event) => event.deploymentId === normalizedDeploymentId).sort(
+    (left, right) => left.observedAt - right.observedAt || left.eventId.localeCompare(right.eventId)
+  );
+};
+export {
+  isRuntimeDeploymentCompositionEvent,
+  loadRuntimeDeploymentCompositionEvents,
+  observeRuntimeDeploymentComposition
+};

package/dist/runtimeHeartbeats.js

@@ -238,6 +238,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/runtimeHeartbeats.mjs

@@ -2,7 +2,7 @@ import {
   getData,
   redisKeys,
   setData
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 
 // src/runtimeHeartbeats.ts
 var normalizeDeploymentId = (value) => {

package/dist/runtimeStrategyConfigs.js

@@ -276,6 +276,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/runtimeStrategyConfigs.mjs

@@ -3,7 +3,7 @@ import {
   getKeys,
   redisKeys,
   setData
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 
 // src/runtimeStrategyConfigs.ts
 var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);

package/dist/tradingAccounts.js

@@ -306,6 +306,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/tradingAccounts.mjs

@@ -4,7 +4,7 @@ import {
   getKeys,
   redisKeys,
   setData
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 
 // src/tradingAccounts.ts
 var normalizeId = (value, label) => {

package/dist/userSettings.js

@@ -239,6 +239,9 @@ var redisKeys = {
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  runtimeDeploymentCompositionState: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-state`,
+  runtimeDeploymentCompositionEvents: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:`,
+  runtimeDeploymentCompositionEvent: (userName, deploymentId, eventId) => `users:${userName}:runtime:deployments:${deploymentId}:composition-events:${eventId}`,
   runtimeControls: (userName) => `users:${userName}:runtime:controls`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",

package/dist/userSettings.mjs

@@ -2,7 +2,7 @@ import {
   getData,
   redisKeys,
   setData
-} from "./chunk-46XQGVDB.mjs";
+} from "./chunk-GTZOMAFK.mjs";
 
 // src/userSettings.ts
 var readString = (value) => typeof value === "string" ? value.trim() : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/infra",
-  "version": "3.1.28-beta.252",
+  "version": "3.1.28-beta.254",
   "description": "MIT-licensed server infrastructure adapters for TradeJS: Redis, Timescale, ML, logging, and IO.",
   "keywords": [
     "tradejs",
@@ -81,6 +81,11 @@
       "import": "./dist/runtimeControls.mjs",
       "require": "./dist/runtimeControls.js"
     },
+    "./runtimeDeploymentEvents": {
+      "types": "./dist/runtimeDeploymentEvents.d.ts",
+      "import": "./dist/runtimeDeploymentEvents.mjs",
+      "require": "./dist/runtimeDeploymentEvents.js"
+    },
     "./strategyReleaseEvidence": {
       "types": "./dist/strategyReleaseEvidence.d.ts",
       "import": "./dist/strategyReleaseEvidence.mjs",
@@ -130,7 +135,7 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.8.1",
-    "@tradejs/types": "^3.1.28-beta.252",
+    "@tradejs/types": "^3.1.28-beta.254",
     "chalk": "4.1.2",
     "date-fns": "^3.6.0",
     "ioredis": "5.11.1",