@tradejs/infra 3.1.8-beta.207 → 3.1.8-beta.210

package/dist/{runtimeStrategyReleases.js → runtimeControls.js}

@@ -27,17 +27,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/runtimeStrategyReleases.ts
-var runtimeStrategyReleases_exports = {};
-__export(runtimeStrategyReleases_exports, {
-  assertRuntimeStrategyReleaseConfig: () => assertRuntimeStrategyReleaseConfig,
-  getRuntimeStrategyRelease: () => getRuntimeStrategyRelease,
-  listRuntimeStrategyReleases: () => listRuntimeStrategyReleases,
-  publishRuntimeStrategyRelease: () => publishRuntimeStrategyRelease,
+// src/runtimeControls.ts
+var runtimeControls_exports = {};
+__export(runtimeControls_exports, {
+  emptyRuntimeControls: () => emptyRuntimeControls,
+  getRuntimeControls: () => getRuntimeControls,
+  pauseRuntimeStrategy: () => pauseRuntimeStrategy,
   recordRuntimeStrategyControlEvent: () => recordRuntimeStrategyControlEvent,
-  verifyRuntimeStrategyRelease: () => verifyRuntimeStrategyRelease
+  resumeRuntimeStrategy: () => resumeRuntimeStrategy,
+  verifyRuntimeControls: () => verifyRuntimeControls
 });
-module.exports = __toCommonJS(runtimeStrategyReleases_exports);
+module.exports = __toCommonJS(runtimeControls_exports);
 var import_node_crypto = require("crypto");
 var import_types = require("@tradejs/types");
 
@@ -158,152 +158,92 @@ var toResultString = (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 requireReadyRedis = async () => {
+  if (redisUnavailable) {
+    throw new Error("Redis is unavailable");
   }
-};
-var getKeys = async (prefix) => {
-  if (redisUnavailable) return [];
   const redis = await getReadyRedis();
-  if (!redis) return [];
-  const keys = [];
+  if (!redis) {
+    throw new Error("Redis is unavailable");
+  }
+  return redis;
+};
+var parseJsonStrict = (key, raw) => {
   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 JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON stored at ${key}`, { cause: error });
   }
-  return keys;
 };
-var getData = async (key, fallback = []) => {
-  if (redisUnavailable) return fallback;
-  const redis = await getReadyRedis();
-  if (!redis) return fallback;
+var getDataStrict = async (key) => {
+  const redis = await requireReadyRedis();
   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;
+    const raw = toResultString(await redis.call("JSON.GET", key));
+    return raw == null ? null : parseJsonStrict(key, raw);
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+      throw error;
+    }
+    if (error instanceof Error && error.message.startsWith("Invalid JSON")) {
+      throw error;
     }
     logger.log(
       "error",
-      "failed JSON.GET %s: %s (fallback to GET)",
+      "failed strict JSON.GET %s: %s (fallback to GET)",
       key,
-      String(e)
+      String(error)
     );
   }
   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;
+    return raw == null ? null : parseJsonStrict(key, raw);
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+    }
+    throw error;
+  }
+};
+var delKeyStrict = async (key) => {
+  const redis = await requireReadyRedis();
+  try {
+    return await redis.del(key) === 1;
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
     }
-    logger.log("error", "failed GET %s: %s", key, String(e));
-    return fallback;
+    throw error;
   }
 };
-var setData = async (key, data, options = {}) => {
-  if (redisUnavailable) return;
+var setDataStrict = async (key, data, options = {}) => {
   const { expire } = { ...DEFAULT_OPTIONS, ...options };
-  const redis = await getReadyRedis();
-  if (!redis) return;
+  const redis = await requireReadyRedis();
   const value = toJson(data);
   try {
     await redis.call("JSON.SET", key, "$", value);
     if (expire) {
       await redis.expire(key, expire);
     }
-  } catch (e) {
-    if (e instanceof Error && isRedisConnectivityError(e)) {
-      markRedisUnavailable(e);
-      return;
-    }
-    logger.log(
-      "error",
-      "failed JSON.SET %s: %s (fallback to SET)",
-      key,
-      String(e)
-    );
-    try {
-      if (expire) {
-        await redis.set(key, value, "EX", expire);
-      } else {
-        await redis.set(key, value);
-      }
-    } catch (e2) {
-      if (e2 instanceof Error && isRedisConnectivityError(e2)) {
-        markRedisUnavailable(e2);
-        return;
-      }
-      logger.log("error", "failed SET %s: %s", key, String(e2));
-    }
-  }
-};
-var setDataIfAbsent = async (key, data) => {
-  if (redisUnavailable) return false;
-  const redis = await getReadyRedis();
-  if (!redis) return false;
-  try {
-    return await redis.call("JSON.SET", key, "$", toJson(data), "NX") === "OK";
+    return;
   } catch (error) {
     if (error instanceof Error && isRedisConnectivityError(error)) {
       markRedisUnavailable(error);
-      return false;
+      throw error;
     }
     logger.log(
-      "warn",
-      "failed JSON.SET NX %s: %s (fallback to SET NX)",
+      "error",
+      "failed strict JSON.SET %s: %s (fallback to SET)",
       key,
       String(error)
     );
-    try {
-      return await redis.set(key, toJson(data), "NX") === "OK";
-    } catch (fallbackError) {
-      if (fallbackError instanceof Error && isRedisConnectivityError(fallbackError)) {
-        markRedisUnavailable(fallbackError);
-      }
-      logger.log("error", "failed SET NX %s: %s", key, String(fallbackError));
-      return false;
-    }
   }
-};
-var incrementKey = async (key) => {
-  if (redisUnavailable) throw new Error("Redis is unavailable");
-  const redis = await getReadyRedis();
-  if (!redis) throw new Error("Redis is unavailable");
   try {
-    return await redis.incr(key);
+    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);
@@ -316,18 +256,14 @@ var redisKeys = {
   user: (userName) => `users:index:${userName}`,
   tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
   tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
-  runtimeDeployments: (userName) => `users:${userName}:runtime:deployments:`,
-  runtimeDeployment: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}`,
   runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
+  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}`,
-  runtimeStrategyReleases: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:releases:`,
-  runtimeStrategyRelease: (userName, strategyName, releaseVersion) => `users:${userName}:strategies:${strategyName}:releases:${releaseVersion}`,
-  runtimeStrategyReleaseSequence: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:release-seq`,
   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`,
@@ -386,157 +322,96 @@ var redisKeys = {
   mlResult: (strategyName, signalId) => `ml:${strategyName}:results:${signalId}`
 };
 
-// src/runtimeStrategyReleases.ts
-var SHA256_RE = /^[a-f0-9]{64}$/;
-var FORBIDDEN_RELEASE_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "ACCOUNT_ID",
-  "AI_REPLAY_ANALYSES",
-  "DEPLOYMENT_ID",
-  "ENABLE",
-  "ENV",
-  "MAKE_ORDERS",
-  "RECORD_RUNTIME_TRADES",
-  "configId"
-]);
-var SECRET_CONFIG_KEY_RE = /(?:^|_)(?:API_KEY|API_SECRET|TOKEN|PASSWORD|PRIVATE_KEY)$/i;
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var canonicalJson = (value) => {
-  const normalize = (current) => {
-    if (Array.isArray(current)) return current.map(normalize);
-    const record = asRecord(current);
-    if (!record) return current;
-    return Object.fromEntries(
-      Object.entries(record).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalize(entry)])
-    );
-  };
-  return JSON.stringify(normalize(value));
-};
-var releaseContentSha256 = (release) => (0, import_node_crypto.createHash)("sha256").update(canonicalJson(release)).digest("hex");
-var assertStrategyName = (strategyName) => {
-  if (!/^[a-zA-Z0-9_-]+$/.test(strategyName)) {
-    throw new Error(`Invalid strategy name: ${strategyName}`);
-  }
-};
-var assertPackageIdentity = (value, label) => {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${label} is required for a runtime strategy release`);
-  }
-};
-var assertRuntimeStrategyReleaseConfig = (config) => {
-  const record = asRecord(config);
-  if (!record) throw new Error("Strategy release config must be an object");
-  for (const key of FORBIDDEN_RELEASE_CONFIG_KEYS) {
-    if (record[key] !== void 0) {
-      throw new Error(`${key} is a deployment binding, not release config`);
-    }
+// src/runtimeControls.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var verifyPauseOverride = (value) => isRecord(value) && Object.keys(value).every(
+  (key) => ["entriesPaused", "updatedAt", "updatedBy"].includes(key)
+) && value.entriesPaused === true && typeof value.updatedAt === "string" && Number.isFinite(Date.parse(value.updatedAt)) && typeof value.updatedBy === "string" && Boolean(value.updatedBy.trim());
+var emptyRuntimeControls = () => ({
+  schema: import_types.RUNTIME_CONTROLS_SCHEMA,
+  deployments: {}
+});
+var verifyRuntimeControls = (value) => {
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => !["schema", "deployments"].includes(key)
+  ) || value.schema !== import_types.RUNTIME_CONTROLS_SCHEMA || !isRecord(value.deployments)) {
+    throw new Error("Invalid runtime controls");
   }
-  const inspect = (value, parentPath = "") => {
-    if (Array.isArray(value)) {
-      value.forEach(
-        (entry, index) => inspect(entry, `${parentPath}[${index}]`)
-      );
-      return;
+  for (const [deploymentId, strategyOverrides] of Object.entries(
+    value.deployments
+  )) {
+    if (!deploymentId.trim() || !isRecord(strategyOverrides)) {
+      throw new Error("Invalid runtime controls");
     }
-    const current = asRecord(value);
-    if (!current) return;
-    for (const [key, entry] of Object.entries(current)) {
-      const keyPath = parentPath ? `${parentPath}.${key}` : key;
-      if (SECRET_CONFIG_KEY_RE.test(key)) {
-        throw new Error(`${keyPath} is secret material, not release config`);
+    for (const [strategyName, override] of Object.entries(strategyOverrides)) {
+      if (!strategyName.trim() || !verifyPauseOverride(override)) {
+        throw new Error("Invalid runtime controls");
       }
-      inspect(entry, keyPath);
     }
-  };
-  inspect(record);
-  if (typeof record.INTERVAL !== "string" || !record.INTERVAL.trim()) {
-    throw new Error("Published strategy config must define INTERVAL");
   }
-  if (record.UNIVERSE !== "crypto" && record.UNIVERSE !== "tradfi") {
-    throw new Error("Published strategy config must define a valid UNIVERSE");
-  }
-};
-var isRelease = (value) => {
-  const release = asRecord(value);
-  return Boolean(
-    release?.schema === import_types.RUNTIME_STRATEGY_RELEASE_SCHEMA && typeof release.strategyName === "string" && Number.isSafeInteger(release.releaseVersion) && Number(release.releaseVersion) > 0 && asRecord(release.config) && typeof release.strategyPackage === "string" && Boolean(release.strategyPackage.trim()) && typeof release.strategyPackageVersion === "string" && Boolean(release.strategyPackageVersion.trim()) && typeof release.runtimePackageVersion === "string" && Boolean(release.runtimePackageVersion.trim()) && typeof release.createdAt === "number" && typeof release.createdBy === "string" && typeof release.contentSha256 === "string" && SHA256_RE.test(release.contentSha256)
-  );
-};
-var verifyRuntimeStrategyRelease = (value) => {
-  if (!isRelease(value)) throw new Error("Invalid runtime strategy release");
-  const { contentSha256, ...content } = value;
-  if (releaseContentSha256(content) !== contentSha256) {
-    throw new Error(
-      `${value.strategyName} v${value.releaseVersion} content checksum mismatch`
-    );
-  }
-  assertRuntimeStrategyReleaseConfig(value.config);
   return value;
 };
-var getRuntimeStrategyRelease = async (userName, strategyName, releaseVersion) => {
-  const value = await getData(
-    redisKeys.runtimeStrategyRelease(userName, strategyName, releaseVersion),
-    null
-  );
-  return value == null ? null : verifyRuntimeStrategyRelease(value);
-};
-var listRuntimeStrategyReleases = async (userName, strategyName) => {
-  const keys = await getKeys(
-    redisKeys.runtimeStrategyReleases(userName, strategyName)
-  );
-  const releases = await Promise.all(
-    keys.map(async (key) => {
-      const value = await getData(key, null);
-      return value == null ? null : verifyRuntimeStrategyRelease(value);
-    })
-  );
-  return releases.filter((release) => release != null).sort((left, right) => right.releaseVersion - left.releaseVersion);
+var getRuntimeControls = async (userName) => {
+  const value = await getDataStrict(redisKeys.runtimeControls(userName));
+  return value == null ? emptyRuntimeControls() : verifyRuntimeControls(value);
 };
-var publishRuntimeStrategyRelease = async ({
+var pauseRuntimeStrategy = async ({
   userName,
+  deploymentId,
   strategyName,
-  config,
-  strategyPackage,
-  strategyPackageVersion,
-  runtimePackageVersion,
-  createdBy
+  updatedBy,
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString()
 }) => {
-  assertStrategyName(strategyName);
-  assertRuntimeStrategyReleaseConfig(config);
-  assertPackageIdentity(strategyPackage, "strategyPackage");
-  assertPackageIdentity(strategyPackageVersion, "strategyPackageVersion");
-  assertPackageIdentity(runtimePackageVersion, "runtimePackageVersion");
-  const releaseVersion = await incrementKey(
-    redisKeys.runtimeStrategyReleaseSequence(userName, strategyName)
-  );
-  const content = {
-    schema: import_types.RUNTIME_STRATEGY_RELEASE_SCHEMA,
-    strategyName,
-    releaseVersion,
-    config,
-    strategyPackage,
-    strategyPackageVersion,
-    runtimePackageVersion,
-    createdAt: Date.now(),
-    createdBy
-  };
-  const release = {
-    ...content,
-    contentSha256: releaseContentSha256(content)
+  const controls = await getRuntimeControls(userName);
+  const next = {
+    ...controls,
+    deployments: {
+      ...controls.deployments,
+      [deploymentId]: {
+        ...controls.deployments[deploymentId],
+        [strategyName]: {
+          entriesPaused: true,
+          updatedAt,
+          updatedBy: updatedBy.trim()
+        }
+      }
+    }
   };
-  const stored = await setDataIfAbsent(
-    redisKeys.runtimeStrategyRelease(userName, strategyName, releaseVersion),
-    release
-  );
-  if (!stored) {
-    throw new Error(`Refused to overwrite ${strategyName} v${releaseVersion}`);
+  const verified = verifyRuntimeControls(next);
+  await setDataStrict(redisKeys.runtimeControls(userName), verified, {
+    expire: 0
+  });
+  return verified;
+};
+var resumeRuntimeStrategy = async ({
+  userName,
+  deploymentId,
+  strategyName
+}) => {
+  const controls = await getRuntimeControls(userName);
+  const deployment = { ...controls.deployments[deploymentId] };
+  delete deployment[strategyName];
+  const deployments = { ...controls.deployments };
+  if (Object.keys(deployment).length) {
+    deployments[deploymentId] = deployment;
+  } else {
+    delete deployments[deploymentId];
+  }
+  const next = verifyRuntimeControls({ ...controls, deployments });
+  if (Object.keys(deployments).length) {
+    await setDataStrict(redisKeys.runtimeControls(userName), next, {
+      expire: 0
+    });
+  } else {
+    await delKeyStrict(redisKeys.runtimeControls(userName));
   }
-  return release;
+  return next;
 };
 var recordRuntimeStrategyControlEvent = async ({
   userName,
   deploymentId,
   strategyName,
-  releaseVersion,
+  version,
   previousState,
   nextState,
   createdBy
@@ -547,14 +422,14 @@ var recordRuntimeStrategyControlEvent = async ({
     eventId: `${createdAt}-${(0, import_node_crypto.randomUUID)()}`,
     deploymentId,
     strategyName,
-    releaseVersion,
+    version,
     action,
     previousState,
     nextState,
     createdAt,
     createdBy
   };
-  await setData(
+  await setDataStrict(
     redisKeys.runtimeStrategyControlEvent(userName, event.eventId),
     event,
     { expire: 0 }
@@ -563,10 +438,10 @@ var recordRuntimeStrategyControlEvent = async ({
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  assertRuntimeStrategyReleaseConfig,
-  getRuntimeStrategyRelease,
-  listRuntimeStrategyReleases,
-  publishRuntimeStrategyRelease,
+  emptyRuntimeControls,
+  getRuntimeControls,
+  pauseRuntimeStrategy,
   recordRuntimeStrategyControlEvent,
-  verifyRuntimeStrategyRelease
+  resumeRuntimeStrategy,
+  verifyRuntimeControls
 });

package/dist/runtimeControls.mjs

@@ -0,0 +1,133 @@
+import {
+  delKeyStrict,
+  getDataStrict,
+  redisKeys,
+  setDataStrict
+} from "./chunk-NN4CAPDW.mjs";
+
+// src/runtimeControls.ts
+import { randomUUID } from "crypto";
+import {
+  RUNTIME_CONTROLS_SCHEMA
+} from "@tradejs/types";
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var verifyPauseOverride = (value) => isRecord(value) && Object.keys(value).every(
+  (key) => ["entriesPaused", "updatedAt", "updatedBy"].includes(key)
+) && value.entriesPaused === true && typeof value.updatedAt === "string" && Number.isFinite(Date.parse(value.updatedAt)) && typeof value.updatedBy === "string" && Boolean(value.updatedBy.trim());
+var emptyRuntimeControls = () => ({
+  schema: RUNTIME_CONTROLS_SCHEMA,
+  deployments: {}
+});
+var verifyRuntimeControls = (value) => {
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => !["schema", "deployments"].includes(key)
+  ) || value.schema !== RUNTIME_CONTROLS_SCHEMA || !isRecord(value.deployments)) {
+    throw new Error("Invalid runtime controls");
+  }
+  for (const [deploymentId, strategyOverrides] of Object.entries(
+    value.deployments
+  )) {
+    if (!deploymentId.trim() || !isRecord(strategyOverrides)) {
+      throw new Error("Invalid runtime controls");
+    }
+    for (const [strategyName, override] of Object.entries(strategyOverrides)) {
+      if (!strategyName.trim() || !verifyPauseOverride(override)) {
+        throw new Error("Invalid runtime controls");
+      }
+    }
+  }
+  return value;
+};
+var getRuntimeControls = async (userName) => {
+  const value = await getDataStrict(redisKeys.runtimeControls(userName));
+  return value == null ? emptyRuntimeControls() : verifyRuntimeControls(value);
+};
+var pauseRuntimeStrategy = async ({
+  userName,
+  deploymentId,
+  strategyName,
+  updatedBy,
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString()
+}) => {
+  const controls = await getRuntimeControls(userName);
+  const next = {
+    ...controls,
+    deployments: {
+      ...controls.deployments,
+      [deploymentId]: {
+        ...controls.deployments[deploymentId],
+        [strategyName]: {
+          entriesPaused: true,
+          updatedAt,
+          updatedBy: updatedBy.trim()
+        }
+      }
+    }
+  };
+  const verified = verifyRuntimeControls(next);
+  await setDataStrict(redisKeys.runtimeControls(userName), verified, {
+    expire: 0
+  });
+  return verified;
+};
+var resumeRuntimeStrategy = async ({
+  userName,
+  deploymentId,
+  strategyName
+}) => {
+  const controls = await getRuntimeControls(userName);
+  const deployment = { ...controls.deployments[deploymentId] };
+  delete deployment[strategyName];
+  const deployments = { ...controls.deployments };
+  if (Object.keys(deployment).length) {
+    deployments[deploymentId] = deployment;
+  } else {
+    delete deployments[deploymentId];
+  }
+  const next = verifyRuntimeControls({ ...controls, deployments });
+  if (Object.keys(deployments).length) {
+    await setDataStrict(redisKeys.runtimeControls(userName), next, {
+      expire: 0
+    });
+  } else {
+    await delKeyStrict(redisKeys.runtimeControls(userName));
+  }
+  return next;
+};
+var recordRuntimeStrategyControlEvent = async ({
+  userName,
+  deploymentId,
+  strategyName,
+  version,
+  previousState,
+  nextState,
+  createdBy
+}) => {
+  const action = nextState === "entries_paused" ? "pause_entries" : "resume";
+  const createdAt = Date.now();
+  const event = {
+    eventId: `${createdAt}-${randomUUID()}`,
+    deploymentId,
+    strategyName,
+    version,
+    action,
+    previousState,
+    nextState,
+    createdAt,
+    createdBy
+  };
+  await setDataStrict(
+    redisKeys.runtimeStrategyControlEvent(userName, event.eventId),
+    event,
+    { expire: 0 }
+  );
+  return event;
+};
+export {
+  emptyRuntimeControls,
+  getRuntimeControls,
+  pauseRuntimeStrategy,
+  recordRuntimeStrategyControlEvent,
+  resumeRuntimeStrategy,
+  verifyRuntimeControls
+};

package/dist/runtimeHeartbeats.d.mts

@@ -0,0 +1,6 @@
+import { RuntimeDeploymentHeartbeat } from '@tradejs/types';
+
+declare const getRuntimeDeploymentHeartbeat: (userName: string, deploymentId: string) => Promise<RuntimeDeploymentHeartbeat | null>;
+declare const saveRuntimeDeploymentHeartbeat: (userName: string, heartbeat: RuntimeDeploymentHeartbeat) => Promise<RuntimeDeploymentHeartbeat>;
+
+export { getRuntimeDeploymentHeartbeat, saveRuntimeDeploymentHeartbeat };

package/dist/runtimeHeartbeats.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeDeploymentHeartbeat } from '@tradejs/types';
+
+declare const getRuntimeDeploymentHeartbeat: (userName: string, deploymentId: string) => Promise<RuntimeDeploymentHeartbeat | null>;
+declare const saveRuntimeDeploymentHeartbeat: (userName: string, heartbeat: RuntimeDeploymentHeartbeat) => Promise<RuntimeDeploymentHeartbeat>;
+
+export { getRuntimeDeploymentHeartbeat, saveRuntimeDeploymentHeartbeat };