@fluojs/cron 1.0.0-beta.1

package/dist/service.js

@@ -0,0 +1,528 @@
+let _initClass;
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
+import { Inject } from '@fluojs/core';
+import { getRedisComponentId } from '@fluojs/redis';
+import { Cron as CronValidator } from 'croner';
+import { APPLICATION_LOGGER, COMPILED_MODULES, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
+import { CronDistributedLockManager } from './distributed-lock-manager.js';
+import { createCronPlatformStatusSnapshot } from './status.js';
+import { createLockKey, discoverCronTaskDescriptors } from './task-discovery.js';
+import { CronTaskRunner } from './task-runner.js';
+import { CRON_OPTIONS } from './tokens.js';
+function assertValidLockTtlMs(lockTtlMs) {
+  if (!Number.isFinite(lockTtlMs) || !Number.isInteger(lockTtlMs) || lockTtlMs < 1_000) {
+    throw new Error('Cron distributed lockTtlMs must be a positive integer greater than or equal to 1000ms.');
+  }
+}
+function assertValidTaskName(name) {
+  if (name.trim().length === 0) {
+    throw new Error('Scheduling task name must be a non-empty string.');
+  }
+}
+function assertValidMs(ms, context) {
+  if (!Number.isFinite(ms) || !Number.isInteger(ms) || ms <= 0) {
+    throw new Error(`${context}: ms must be a positive integer.`);
+  }
+}
+function assertValidCronExpression(expression) {
+  try {
+    new CronValidator(expression, {
+      maxRuns: 0
+    });
+  } catch {
+    throw new Error(`@Cron(): invalid cron expression "${expression}".`);
+  }
+}
+
+/**
+ * Lifecycle-managed scheduler runtime for decorator-discovered and dynamic tasks.
+ *
+ * The service discovers scheduling decorators during bootstrap, coordinates
+ * optional distributed locks through Redis, and exposes runtime task management
+ * through {@link SchedulingRegistry}.
+ */
+let _CronLifecycleService;
+class CronLifecycleService {
+  static {
+    [_CronLifecycleService, _initClass] = _applyDecs(this, [Inject(CRON_OPTIONS, RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER)], []).c;
+  }
+  tasks = new Map();
+  activeTasks = new Set();
+  distributedLocks;
+  taskRunner;
+  lifecycleState = 'created';
+  started = false;
+  shutdownPromise;
+  constructor(options, runtimeContainer, compiledModules, logger) {
+    this.options = options;
+    this.runtimeContainer = runtimeContainer;
+    this.compiledModules = compiledModules;
+    this.logger = logger;
+    this.distributedLocks = new CronDistributedLockManager(this.options, this.runtimeContainer, this.logger);
+    this.taskRunner = new CronTaskRunner(this.runtimeContainer, this.logger);
+  }
+
+  /**
+   * Registers a cron task at runtime.
+   *
+   * @param name Stable task name used for lookup and distributed lock derivation.
+   * @param expression Cron expression validated before registration.
+   * @param callback Task body executed on matching cron ticks.
+   * @param options Optional hooks, distributed lock overrides, and timezone.
+   */
+  addCron(name, expression, callback, options = {}) {
+    assertValidTaskName(name);
+    assertValidCronExpression(expression);
+    this.registerTask({
+      afterRun: options.afterRun,
+      beforeRun: options.beforeRun,
+      callback,
+      distributed: options.distributed ?? true,
+      expression,
+      kind: 'cron',
+      lockKey: createLockKey(this.options.distributed.keyPrefix, options.key ?? name),
+      lockTtlMs: options.lockTtlMs ?? this.options.distributed.lockTtlMs,
+      onError: options.onError,
+      onSuccess: options.onSuccess,
+      taskName: name,
+      timezone: options.timezone
+    }, 'dynamic');
+  }
+
+  /**
+   * Registers a fixed-interval task at runtime.
+   *
+   * @param name Stable task name used for lookup and distributed lock derivation.
+   * @param ms Positive interval in milliseconds.
+   * @param callback Task body executed on each interval.
+   * @param options Optional hooks and distributed lock overrides.
+   */
+  addInterval(name, ms, callback, options = {}) {
+    assertValidTaskName(name);
+    assertValidMs(ms, 'scheduling registry');
+    this.registerTask({
+      afterRun: options.afterRun,
+      beforeRun: options.beforeRun,
+      callback,
+      distributed: options.distributed ?? true,
+      kind: 'interval',
+      lockKey: createLockKey(this.options.distributed.keyPrefix, options.key ?? name),
+      lockTtlMs: options.lockTtlMs ?? this.options.distributed.lockTtlMs,
+      ms,
+      onError: options.onError,
+      onSuccess: options.onSuccess,
+      taskName: name
+    }, 'dynamic');
+  }
+
+  /**
+   * Registers a one-shot delayed task at runtime.
+   *
+   * @param name Stable task name used for lookup and distributed lock derivation.
+   * @param ms Positive delay in milliseconds before execution.
+   * @param callback Task body executed once after the delay.
+   * @param options Optional hooks and distributed lock overrides.
+   */
+  addTimeout(name, ms, callback, options = {}) {
+    assertValidTaskName(name);
+    assertValidMs(ms, 'scheduling registry');
+    this.registerTask({
+      afterRun: options.afterRun,
+      beforeRun: options.beforeRun,
+      callback,
+      distributed: options.distributed ?? true,
+      kind: 'timeout',
+      lockKey: createLockKey(this.options.distributed.keyPrefix, options.key ?? name),
+      lockTtlMs: options.lockTtlMs ?? this.options.distributed.lockTtlMs,
+      ms,
+      onError: options.onError,
+      onSuccess: options.onSuccess,
+      taskName: name
+    }, 'dynamic');
+  }
+
+  /**
+   * Removes a registered task by name.
+   *
+   * @param name Task name to remove.
+   * @returns `true` when a task existed and was removed.
+   */
+  remove(name) {
+    const task = this.tasks.get(name);
+    if (!task) {
+      return false;
+    }
+    this.unscheduleTask(task);
+    this.tasks.delete(name);
+    return true;
+  }
+
+  /**
+   * Enables a task that was previously disabled.
+   *
+   * @param name Task name to enable.
+   * @returns `true` when the task exists after the operation.
+   */
+  enable(name) {
+    const task = this.tasks.get(name);
+    if (!task) {
+      return false;
+    }
+    if (task.enabled) {
+      return true;
+    }
+    task.enabled = true;
+    if (this.started) {
+      this.scheduleTask(task);
+    }
+    return true;
+  }
+
+  /**
+   * Disables a task without removing its descriptor.
+   *
+   * @param name Task name to disable.
+   * @returns `true` when the task exists after the operation.
+   */
+  disable(name) {
+    const task = this.tasks.get(name);
+    if (!task) {
+      return false;
+    }
+    if (!task.enabled && !task.scheduledHandle) {
+      return true;
+    }
+    task.enabled = false;
+    this.unscheduleTask(task);
+    return true;
+  }
+
+  /**
+   * Looks up one task descriptor.
+   *
+   * @param name Task name to inspect.
+   * @returns The task descriptor, or `undefined` when not found.
+   */
+  get(name) {
+    const task = this.tasks.get(name);
+    return task ? this.toSchedulingTaskDescriptor(task) : undefined;
+  }
+
+  /**
+   * Lists every known task descriptor.
+   *
+   * @returns All decorator-discovered and dynamically registered task descriptors.
+   */
+  getAll() {
+    return Array.from(this.tasks.values()).map(task => this.toSchedulingTaskDescriptor(task));
+  }
+
+  /**
+   * Replaces the cron expression of one existing cron task.
+   *
+   * @param name Name of the cron task to update.
+   * @param expression New cron expression to validate and schedule.
+   */
+  updateCronExpression(name, expression) {
+    assertValidCronExpression(expression);
+    const task = this.tasks.get(name);
+    if (!task) {
+      throw new Error(`Scheduling task "${name}" does not exist.`);
+    }
+    if (task.descriptor.kind !== 'cron') {
+      throw new Error(`updateCronExpression() supports only cron tasks. Received ${task.descriptor.kind} task "${name}".`);
+    }
+    task.descriptor.expression = expression;
+    if (!task.enabled || !this.started) {
+      return;
+    }
+    this.unscheduleTask(task);
+    this.scheduleTask(task);
+  }
+  async onApplicationBootstrap() {
+    if (this.started) {
+      return;
+    }
+    this.lifecycleState = 'starting';
+    try {
+      await this.startLifecycle();
+      this.lifecycleState = 'ready';
+    } catch (error) {
+      this.lifecycleState = 'failed';
+      this.handleStartupFailure();
+      throw error;
+    }
+  }
+  async onApplicationShutdown() {
+    await this.shutdown();
+  }
+  async onModuleDestroy() {
+    await this.shutdown();
+  }
+  createPlatformStatusSnapshot() {
+    let enabledTasks = 0;
+    let runningTasks = 0;
+    for (const task of this.tasks.values()) {
+      if (task.enabled) {
+        enabledTasks += 1;
+      }
+      if (task.running) {
+        runningTasks += 1;
+      }
+    }
+    return createCronPlatformStatusSnapshot({
+      activeTicks: this.activeTasks.size,
+      dependencyId: this.options.distributed.enabled ? getRedisComponentId(this.options.distributed.clientName) : undefined,
+      distributedEnabled: this.options.distributed.enabled,
+      enabledTasks,
+      lifecycleState: this.lifecycleState,
+      lockOwnershipLosses: this.distributedLocks.ownershipLosses,
+      lockRenewalFailures: this.distributedLocks.renewalFailures,
+      ownedLocks: this.distributedLocks.ownedLocks,
+      redisDependencyResolved: this.distributedLocks.resolvedClient !== undefined,
+      runningTasks,
+      totalTasks: this.tasks.size
+    });
+  }
+  toSchedulingTaskDescriptor(task) {
+    return {
+      distributed: task.descriptor.distributed,
+      enabled: task.enabled,
+      expression: task.descriptor.expression,
+      kind: task.descriptor.kind,
+      lockKey: task.descriptor.lockKey,
+      lockTtlMs: task.descriptor.lockTtlMs,
+      methodName: task.descriptor.methodName,
+      moduleName: task.descriptor.moduleName,
+      ms: task.descriptor.ms,
+      name: task.descriptor.taskName,
+      source: task.source,
+      targetName: task.descriptor.targetName,
+      timezone: task.descriptor.timezone
+    };
+  }
+  async shutdown() {
+    if (this.shutdownPromise) {
+      await this.shutdownPromise;
+      return;
+    }
+    this.shutdownPromise = this.runShutdownLifecycle();
+    await this.shutdownPromise;
+  }
+  async startLifecycle() {
+    await this.distributedLocks.resolveClient();
+    this.validateDistributedLockConfiguration();
+    this.registerDecoratorTasks();
+    this.started = true;
+    this.scheduleEnabledTasks();
+  }
+  validateDistributedLockConfiguration() {
+    if (!this.options.distributed.enabled) {
+      return;
+    }
+    assertValidLockTtlMs(this.options.distributed.lockTtlMs);
+  }
+  handleStartupFailure() {
+    this.started = false;
+    this.stopAllScheduledTasks();
+    this.tasks.clear();
+    this.distributedLocks.reset();
+  }
+  async runShutdownLifecycle() {
+    this.lifecycleState = 'stopping';
+    this.started = false;
+    this.stopAllScheduledTasks();
+    const shutdownTimedOut = await this.waitForActiveTasks();
+    if (shutdownTimedOut) {
+      this.logger.warn(`Cron shutdown timed out after ${String(this.options.shutdown.timeoutMs)}ms with ${String(this.activeTasks.size)} active task(s) still pending.`, 'CronLifecycleService');
+    }
+    await this.distributedLocks.releaseOwnedLocks();
+    this.lifecycleState = 'stopped';
+  }
+  registerDecoratorTasks() {
+    const descriptors = discoverCronTaskDescriptors(this.compiledModules, this.options, this.logger);
+    for (const descriptor of descriptors) {
+      this.registerTask(descriptor, 'decorator');
+    }
+  }
+  registerTask(descriptor, source) {
+    this.assertTaskNameAvailable(descriptor.taskName);
+    if (descriptor.distributed) {
+      assertValidLockTtlMs(descriptor.lockTtlMs);
+    }
+    const task = {
+      descriptor,
+      enabled: true,
+      running: false,
+      scheduledHandle: undefined,
+      source
+    };
+    this.tasks.set(descriptor.taskName, task);
+    if (this.started) {
+      this.scheduleTask(task);
+    }
+  }
+  assertTaskNameAvailable(taskName) {
+    if (this.tasks.has(taskName)) {
+      throw new Error(`Duplicate scheduling task name detected: "${taskName}". Task names must be unique globally.`);
+    }
+  }
+  scheduleEnabledTasks() {
+    for (const task of this.tasks.values()) {
+      if (task.enabled) {
+        this.scheduleTask(task);
+      }
+    }
+  }
+  scheduleTask(task) {
+    if (!task.enabled || task.scheduledHandle) {
+      return;
+    }
+    if (task.descriptor.kind === 'cron') {
+      const expression = task.descriptor.expression;
+      if (!expression) {
+        throw new Error(`Cron task "${task.descriptor.taskName}" is missing a cron expression.`);
+      }
+      const scheduled = this.options.scheduler(expression, {
+        name: task.descriptor.taskName,
+        protect: true,
+        timezone: task.descriptor.timezone
+      }, async () => {
+        await this.handleTaskTick(task.descriptor.taskName);
+      });
+      task.scheduledHandle = scheduled;
+      return;
+    }
+    const ms = task.descriptor.ms;
+    if (!ms) {
+      throw new Error(`${task.descriptor.kind} task "${task.descriptor.taskName}" is missing interval duration.`);
+    }
+    if (task.descriptor.kind === 'interval') {
+      const timer = setInterval(() => {
+        void this.handleTaskTick(task.descriptor.taskName);
+      }, ms);
+      task.scheduledHandle = {
+        stop: () => {
+          clearInterval(timer);
+        }
+      };
+      return;
+    }
+    const timer = setTimeout(() => {
+      void this.handleTaskTick(task.descriptor.taskName).finally(() => {
+        this.completeTimeoutTask(task.descriptor.taskName);
+      });
+    }, ms);
+    task.scheduledHandle = {
+      stop: () => {
+        clearTimeout(timer);
+      }
+    };
+  }
+  completeTimeoutTask(taskName) {
+    const task = this.tasks.get(taskName);
+    if (!task || task.descriptor.kind !== 'timeout') {
+      return;
+    }
+    task.scheduledHandle = undefined;
+    task.enabled = false;
+  }
+  unscheduleTask(task) {
+    if (!task.scheduledHandle) {
+      return;
+    }
+    try {
+      task.scheduledHandle.stop();
+    } catch (error) {
+      this.logger.error('Failed to stop scheduled task during shutdown.', error, 'CronLifecycleService');
+    } finally {
+      task.scheduledHandle = undefined;
+    }
+  }
+  async handleTaskTick(taskName) {
+    const taskState = this.tasks.get(taskName);
+    if (!taskState || !taskState.enabled || taskState.running) {
+      return;
+    }
+    const task = this.runTaskTick(taskState.descriptor, taskState);
+    taskState.running = true;
+    this.activeTasks.add(task);
+    try {
+      await task;
+    } finally {
+      taskState.running = false;
+      this.activeTasks.delete(task);
+    }
+  }
+  async runTaskTick(descriptor, taskState) {
+    if (!this.shouldUseDistributedExecution(descriptor)) {
+      await this.executeTask(descriptor, taskState);
+      return;
+    }
+    await this.runDistributedTaskTick(descriptor, taskState);
+  }
+  shouldUseDistributedExecution(descriptor) {
+    return this.options.distributed.enabled && descriptor.distributed && this.distributedLocks.resolvedClient !== undefined;
+  }
+  async runDistributedTaskTick(descriptor, taskState) {
+    const lockAcquired = await this.distributedLocks.tryAcquireLock(descriptor);
+    if (!lockAcquired) {
+      return;
+    }
+    const lockRenewalMonitor = this.distributedLocks.startLockRenewalMonitor(descriptor);
+    try {
+      await this.executeTask(descriptor, taskState, async () => {
+        lockRenewalMonitor.stop();
+        return await lockRenewalMonitor.getPostRunError();
+      });
+    } finally {
+      lockRenewalMonitor.stop();
+      await this.distributedLocks.releaseLock(descriptor);
+    }
+  }
+  async waitForActiveTasks() {
+    if (this.activeTasks.size === 0) {
+      return false;
+    }
+    if (this.options.shutdown.timeoutMs === 0) {
+      return true;
+    }
+    let timeoutHandle;
+    try {
+      return await Promise.race([this.drainActiveTasks().then(() => false), new Promise(resolve => {
+        timeoutHandle = setTimeout(() => {
+          resolve(true);
+        }, this.options.shutdown.timeoutMs);
+      })]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  }
+  async drainActiveTasks() {
+    while (this.activeTasks.size > 0) {
+      await Promise.allSettled(Array.from(this.activeTasks));
+    }
+  }
+  async executeTask(descriptor, taskState, postRunErrorProvider) {
+    await this.taskRunner.executeTask(descriptor, postRunErrorProvider);
+    if (descriptor.kind === 'timeout') {
+      taskState.enabled = false;
+      taskState.scheduledHandle = undefined;
+    }
+  }
+  stopAllScheduledTasks() {
+    for (const task of this.tasks.values()) {
+      this.unscheduleTask(task);
+    }
+  }
+  static {
+    _initClass();
+  }
+}
+export { _CronLifecycleService as CronLifecycleService };

package/dist/status.d.ts

@@ -0,0 +1,32 @@
+import type { PlatformHealthReport, PlatformReadinessReport, PlatformSnapshot } from '@fluojs/runtime';
+/** Lifecycle phases reported by the cron platform status adapter. */
+export type CronLifecycleState = 'created' | 'starting' | 'ready' | 'stopping' | 'stopped' | 'failed';
+/** Input payload used to derive cron readiness, health, and dependency details. */
+export interface CronStatusAdapterInput {
+    activeTicks: number;
+    dependencyId?: string;
+    distributedEnabled: boolean;
+    enabledTasks: number;
+    lifecycleState: CronLifecycleState;
+    lockOwnershipLosses: number;
+    lockRenewalFailures: number;
+    ownedLocks: number;
+    redisDependencyResolved: boolean;
+    runningTasks: number;
+    totalTasks: number;
+}
+/** Cron-specific platform snapshot returned to health and readiness integrations. */
+export interface CronPlatformStatusSnapshot {
+    readiness: PlatformReadinessReport;
+    health: PlatformHealthReport;
+    ownership: PlatformSnapshot['ownership'];
+    details: Record<string, unknown>;
+}
+/**
+ * Creates the cron platform snapshot consumed by status reporters.
+ *
+ * @param input Normalized cron runtime metrics and dependency information.
+ * @returns Readiness, health, ownership, and cron detail fields.
+ */
+export declare function createCronPlatformStatusSnapshot(input: CronStatusAdapterInput): CronPlatformStatusSnapshot;
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEvG,qEAAqE;AACrE,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtG,mFAAmF;AACnF,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,kBAAkB,CAAC;IACnC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,uBAAuB,EAAE,OAAO,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAoFD;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,sBAAsB,GAAG,0BAA0B,CAsB1G"}

package/dist/status.js

@@ -0,0 +1,107 @@
+/** Lifecycle phases reported by the cron platform status adapter. */
+
+/** Input payload used to derive cron readiness, health, and dependency details. */
+
+/** Cron-specific platform snapshot returned to health and readiness integrations. */
+
+function createReadiness(input) {
+  if (input.lifecycleState === 'ready') {
+    if (input.distributedEnabled && !input.redisDependencyResolved) {
+      return {
+        critical: true,
+        reason: 'Distributed cron mode requires a ready Redis lock client.',
+        status: 'not-ready'
+      };
+    }
+    return {
+      critical: true,
+      status: 'ready'
+    };
+  }
+  if (input.lifecycleState === 'starting') {
+    return {
+      critical: true,
+      reason: 'Cron scheduler is still starting.',
+      status: 'degraded'
+    };
+  }
+  if (input.lifecycleState === 'stopping') {
+    return {
+      critical: true,
+      reason: 'Cron scheduler is draining active ticks.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'stopped') {
+    return {
+      critical: true,
+      reason: 'Cron scheduler is stopped.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'failed') {
+    return {
+      critical: true,
+      reason: 'Cron scheduler failed to initialize.',
+      status: 'not-ready'
+    };
+  }
+  return {
+    critical: true,
+    reason: 'Cron scheduler has not started yet.',
+    status: 'not-ready'
+  };
+}
+function createHealth(input) {
+  if (input.lifecycleState === 'failed' || input.lifecycleState === 'stopped') {
+    return {
+      reason: 'Cron scheduler is unavailable.',
+      status: 'unhealthy'
+    };
+  }
+  if (input.lifecycleState === 'starting' || input.lifecycleState === 'stopping') {
+    return {
+      reason: 'Cron scheduler is transitioning lifecycle state.',
+      status: 'degraded'
+    };
+  }
+  if (input.lockRenewalFailures > 0 || input.lockOwnershipLosses > 0) {
+    return {
+      reason: 'Distributed cron lock renewal reported recoverable failures.',
+      status: 'degraded'
+    };
+  }
+  return {
+    status: 'healthy'
+  };
+}
+
+/**
+ * Creates the cron platform snapshot consumed by status reporters.
+ *
+ * @param input Normalized cron runtime metrics and dependency information.
+ * @returns Readiness, health, ownership, and cron detail fields.
+ */
+export function createCronPlatformStatusSnapshot(input) {
+  return {
+    details: {
+      activeTicks: input.activeTicks,
+      dependencies: input.distributedEnabled ? [input.dependencyId ?? 'redis.default'] : [],
+      distributedEnabled: input.distributedEnabled,
+      enabledTasks: input.enabledTasks,
+      lifecycleState: input.lifecycleState,
+      lockOwnershipLosses: input.lockOwnershipLosses,
+      lockRenewalFailures: input.lockRenewalFailures,
+      ownedLocks: input.ownedLocks,
+      redisDependencyResolved: input.redisDependencyResolved,
+      runningTasks: input.runningTasks,
+      totalTasks: input.totalTasks
+    },
+    health: createHealth(input),
+    ownership: {
+      externallyManaged: false,
+      ownsResources: true
+    },
+    readiness: createReadiness(input)
+  };
+}

package/dist/task-discovery.d.ts

@@ -0,0 +1,8 @@
+import { type MetadataPropertyKey } from '@fluojs/core';
+import type { ApplicationLogger, CompiledModule } from '@fluojs/runtime';
+import type { CronTaskDescriptor, NormalizedCronModuleOptions } from './types.js';
+export declare function buildDefaultTaskName(targetName: string, methodName: string): string;
+export declare function createLockKey(prefix: string, taskName: string): string;
+export declare function methodKeyToName(methodKey: MetadataPropertyKey): string;
+export declare function discoverCronTaskDescriptors(compiledModules: readonly CompiledModule[], options: NormalizedCronModuleOptions, logger: ApplicationLogger): CronTaskDescriptor[];
+//# sourceMappingURL=task-discovery.d.ts.map

package/dist/task-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-discovery.d.ts","sourceRoot":"","sources":["../src/task-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,cAAc,CAAC;AAGpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AASlF,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAEtE;AAED,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE,iBAAiB,GACxB,kBAAkB,EAAE,CA4DtB"}