@fluojs/cron 2.0.1 → 3.0.0

package/README.ko.md

@@ -1,12 +1,31 @@
 # @fluojs/cron
 
 <p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+<!-- fluo:cron-nestjs-migration: timezone-mapping -->
+<!-- fluo:cron-nestjs-migration: wait-for-completion -->
+<!-- fluo:cron-nestjs-migration: unsupported-options -->
+<!-- fluo:cron-nestjs-migration: absolute-time -->
+<!-- fluo:cron-nestjs-migration: named-interval-timeout -->
+<!-- fluo:cron-nestjs-migration: async-configuration -->
+<!-- fluo:cron-nestjs-migration: global-visibility -->
+<!-- fluo:cron-nestjs-migration: category-switches -->
+| Migration proposition | Governed fluo rule |
+| --- | --- |
+| `timezone-mapping` | `timeZone`은 `timezone`으로 매핑되며 `CronTaskOptions.timezone`은 문자열입니다. |
+| `wait-for-completion` | `protect: true`가 Croner 호출의 중복을 막고 `CronLifecycleService`는 작업 실행 중 tick을 거부합니다. |
+| `unsupported-options` | 문서화된 fluo 옵션 외 NestJS scheduler 옵션은 지원되지 않습니다. |
+| `absolute-time` | `@Cron`은 cron-expression 문자열만 받고 `Date`와 `DateTime` overload는 지원되지 않습니다. |
+| `named-interval-timeout` | `@Interval(ms, options)`와 `@Timeout(ms, options)`는 millisecond와 선택적 named task option을 받습니다. |
+| `async-configuration` | `CronModule.forRoot(...)`는 동기식이며 async configuration은 호출 전에 해석합니다. |
+| `global-visibility` | `CronModule.forRoot(...)`는 기본적으로 local이고 필요할 때 `global: true`를 명시합니다. |
+| `category-switches` | `cronJobs`, `intervals`, `timeouts` category switch는 지원되지 않습니다. |
 
 fluo 애플리케이션을 위한 데코레이터 기반 스케줄링 패키지입니다. 앱 라이프사이클에 맞춰 시작/종료를 관리하고, Redis 기반 분산 락(Distributed Locking) 기능을 제공합니다.
 
 ## 목차
 
 - [설치](#설치)
+- [Node.js 호환성](#nodejs-호환성)
 - [사용 시점](#사용-시점)
 - [빠른 시작](#빠른-시작)
 - [공통 패턴](#공통-패턴)
@@ -28,6 +47,14 @@ npm install @fluojs/cron
 
 `@fluojs/redis`는 Redis distributed locking을 활성화할 때만 필요합니다. Non-distributed scheduling 경로는 package import, module registration, bootstrap, status snapshot 생성 중 Redis integration을 로드하지 않습니다.
 
+## Node.js 호환성
+
+`@fluojs/cron`은 패키지 자체의 지원 정책으로 Node.js `>=24.0.0 <27`을 요구합니다. Node.js 24 미만과 Node.js 27+는 지원하지 않습니다. Portable `@fluojs/runtime`의 engine omission은 별도 계약입니다.
+
+### 3으로 마이그레이션
+
+`@fluojs/cron` 2에서 업그레이드하기 전에 배포 host를 Node.js `>=24.0.0 <27`로 옮기세요. `@fluojs/cron` 3을 설치하기 전에 제거된 Node.js version을 사용하는 runtime image, CI matrix, local development environment를 업데이트해야 합니다.
+
 ## 사용 시점
 
 - 정기적인 백그라운드 작업(예: 데이터베이스 정리, 리포트 생성)이 필요할 때 사용합니다.
@@ -90,6 +117,18 @@ NestJS `@Cron()` 옵션은 `CronTaskOptions`에 그대로 전달할 수 없습
 
 이 guard는 한 application process 안의 같은 task instance만 보호합니다. 여러 application instance가 같은 task를 동시에 실행하지 않아야 한다면 [분산 락 사용하기](#분산-락-사용하기)를 적용하세요.
 
+나머지 NestJS scheduling option에는 `CronTaskOptions` 대응 항목이 없습니다. `utcOffset`, `unrefTimeout`, `disabled`, `threshold`, `initialDelay`을 복사하지 마세요. fluo는 이를 받거나 흉내 내지 않습니다. Disabled 또는 category별 schedule은 해당 provider/module을 생략하는 application composition으로 소유하거나, application-owned condition이 만족된 뒤에만 dynamic task를 등록하세요. Threshold/recovery policy도 application-owned work로 다루세요. `@Timeout(ms, ...)`은 application startup 기준 지연이 의도한 동작일 때만 사용합니다. NestJS `@Cron(Date)` 또는 `@Cron(DateTime)`의 absolute-time 대체 수단이 아닙니다.
+
+| NestJS scheduling form | fluo 마이그레이션 |
+| --- | --- |
+| `@Cron(expression, { timeZone })` | `@Cron(expression, { timezone })` |
+| `@Cron(Date)` 또는 `@Cron(DateTime)` | 직접 대응 없음. Application code에서 absolute-time plan을 해석하고 startup-relative `@Timeout`으로 대체하지 마세요. |
+| `@Interval('name', ms)` | `@Interval(ms, { name: 'name' })` |
+| `@Timeout('name', ms)` | `@Timeout(ms, { name: 'name' })` |
+| `ScheduleModule.forRootAsync(...)` | Application bootstrap/composition boundary에서 async configuration을 해석한 뒤 동기 `CronModule.forRoot(...)`를 호출합니다. |
+| NestJS의 global-by-default schedule registration | Global visibility가 필요하면 `CronModule.forRoot({ global: true })`를 사용합니다. fluo 기본값은 `false`입니다. |
+| `cronJobs`, `intervals`, `timeouts` category switch | 직접 대응 없음. Application에서 conditional provider/module composition 또는 명시적 dynamic registration을 소유하세요. |
+
 ### 분산 락 사용하기
 
 여러 서버 인스턴스에서 스케줄링된 작업이 동시에 실행되는 것을 방지하려면 분산 모드를 활성화하세요. 이 기능은 `@fluojs/redis`가 필요하며, Redis peer는 `distributed.enabled`가 `true`일 때만 로드되고 resolve됩니다.
@@ -118,7 +157,7 @@ class AppModule {}
 
 `distributed.lockTtlMs`는 `1_000ms` 이상이어야 합니다. Distributed locking이 활성화된 경우 fluo는 Redis를 load, resolve, probe하기 전에 module option normalization 중 module-level TTL을 검증합니다. Task-level `lockTtlMs` override는 module distributed mode와 해당 task의 distributed locking이 모두 활성화된 경우에만 검증됩니다. Module 또는 task locking이 비활성화되어 있으면 사용되지 않는 TTL이 distributed 최소값보다 낮다는 이유만으로 실패하지 않습니다. fluo는 활성 TTL이 만료되기 전에 Redis 락을 갱신하며, 최소 지원 경계인 `1_000ms`도 포함됩니다.
 
-각 scheduler instance는 platform-neutral 기본 `distributed.ownerId`를 사용합니다. 배포 환경에 더 강한 stable-owner 규칙이 있을 때만 `distributed.ownerId`를 명시적으로 지정하세요. `distributed.ownerId`를 제공한 경우 fluo는 module option normalization 중에 값을 trim하고, scheduler 또는 Redis lifecycle setup 전에 blank 또는 non-string 값을 거부합니다. 따라서 유효하지 않거나 빈 owner 식별자가 Redis lock ownership 상태로 들어갈 수 없습니다. Lock release는 task 실행 뒤 `finally` 경로에서 수행됩니다. Distributed tick이 이미 실행 중인 상태에서 bootstrap이 나중에 실패하면 startup rollback은 해당 active task가 drain되어 락을 release할 수 있을 때까지 Redis lock client를 유지합니다. Redis release가 실패하면 fluo는 status snapshot의 local ownership을 유지하고 shutdown 중 다시 release를 시도합니다. Redis가 다른 owner의 key라고 응답하면 fencing이 이미 다른 곳으로 이동한 것이므로 local ownership을 정리합니다. Redis TTL과 renewal timing은 drift 영향을 받는 coordination primitive이지 강한 fencing token 자체는 아니므로, stale work가 위험한 long-running job은 idempotent하게 작성하고 application-level fencing을 함께 사용해야 합니다.
+각 scheduler instance는 platform-neutral 기본 `distributed.ownerId`를 사용합니다. 배포 환경에 더 강한 stable-owner 규칙이 있을 때만 `distributed.ownerId`를 명시적으로 지정하세요. `distributed.ownerId`를 제공한 경우 fluo는 module option normalization 중에 값을 trim하고, scheduler 또는 Redis lifecycle setup 전에 blank 또는 non-string 값을 거부합니다. 따라서 유효하지 않거나 빈 owner 식별자가 Redis lock ownership 상태로 들어갈 수 없습니다. 성공한 acquisition마다 이 owner identity에서 고유한 lease token을 만들고 renewal과 release는 정확히 그 token을 비교합니다. 따라서 만료된 이전 acquisition의 늦은 release는 두 acquisition이 같은 configured `ownerId`를 재사용해도 더 새로운 lease를 삭제할 수 없습니다. Lock release는 task 실행 뒤 `finally` 경로에서 수행됩니다. Distributed tick이 이미 실행 중인 상태에서 bootstrap이 나중에 실패하면 startup rollback은 해당 active task가 drain되어 락을 release할 수 있을 때까지 Redis lock client를 유지합니다. Redis release가 실패하면 fluo는 status snapshot의 local ownership을 유지하고 shutdown 중 다시 release를 시도합니다. Redis가 다른 owner의 key라고 응답하면 fencing이 이미 다른 곳으로 이동한 것이므로 local ownership을 정리합니다. Redis TTL과 renewal timing은 drift 영향을 받는 coordination primitive이지 강한 fencing token 자체는 아니므로, stale work가 위험한 long-running job은 idempotent하게 작성하고 application-level fencing을 함께 사용해야 합니다.
 
 ```typescript
 @Module({
@@ -168,13 +207,13 @@ class TaskManager {
 
 Registry는 `addCron`, `addInterval`, `addTimeout`, `remove`, `enable`, `disable`, `get`, `getAll`, `updateCronExpression`, `updateIntervalMs`를 제공합니다. 첫 번째 `name` 인자는 기본 registry key이며, `options.name`을 전달하면 dynamic task의 실제 registry key, scheduler metadata name, 기본 distributed lock key가 이를 사용해 decorator naming semantics와 일치합니다. Registry, decorator, dynamic `options.name` task name은 non-empty string이어야 합니다. Blank dynamic override name은 scheduler 또는 registry state를 남기기 전에 거부됩니다. `get`과 `getAll`은 live `CronJob` handle이나 mutable registry state가 아니라 immutable `SchedulingTaskDescriptor` snapshot을 반환합니다. Timeout task는 한 번 실행된 뒤 비활성화되지만 registry에는 남아 있어 의도적으로 다시 활성화할 수 있습니다.
 
-Dynamic cron 등록은 scheduler startup과 원자적으로 처리됩니다. Scheduler가 새 cron job을 거부하면 registry는 half-registered task를 남기지 않습니다. 실행 중인 cron expression 또는 interval cadence update도 rollback-safe합니다. 이전 scheduled handle의 stop이 성공해야만 replacement를 commit합니다. Replacement scheduling이 실패하거나 이전 handle을 stop할 수 없으면 fluo는 provisional replacement를 stop하고 이전 expression 또는 interval milliseconds와 handle을 복원한 뒤 failure를 다시 throw하므로 duplicate schedule을 조용히 남기지 않습니다. Cron task는 scheduler-level no-overlap protection과 fluo의 in-process running guard를 함께 사용하므로 같은 task instance가 overlapping tick으로 실행되지 않습니다.
+Dynamic cron 등록은 scheduler startup과 원자적으로 처리됩니다. Scheduler가 새 cron job을 거부하면 registry는 half-registered task를 남기지 않습니다. 실행 중인 cron expression 또는 interval cadence update도 rollback-safe합니다. Provisional replacement는 이전 scheduled handle의 stop이 성공하고 registry가 새 handle token을 commit할 때까지 tick을 실행할 수 없으며, retired handle이 이미 queue한 callback도 무시됩니다. Replacement scheduling이 실패하거나 이전 handle을 stop할 수 없으면 fluo는 provisional replacement를 stop하고 이전 expression 또는 interval milliseconds와 handle을 복원한 뒤 failure를 다시 throw하므로 duplicate schedule을 조용히 남기지 않습니다. Active task를 disable 또는 remove할 때도 `stop()`이 성공한 뒤에만 scheduler handle을 지웁니다. Stop failure는 log로 드러나고 handle은 안전한 retry를 위해 registry에 남으며 operation은 `false`를 반환합니다. 실패한 `disable()`은 task descriptor를 disabled 상태로 두어 다음 tick을 계속 차단하고, 이후 disable 또는 shutdown이 cleanup을 재시도합니다. 실패한 `remove()`는 이후 removal이 성공할 때까지 task를 유지합니다. 첫 shutdown cleanup 시도도 실패하면 다음 shutdown lifecycle hook이 같은 retained handle을 다시 시도하고, `stop()`이 성공한 뒤에만 handle을 지웁니다. Cron task는 scheduler-level no-overlap protection과 fluo의 in-process running guard를 함께 사용하므로 같은 task instance가 overlapping tick으로 실행되지 않습니다.
 
 ### 제한된 종료
 
 `CronModule`은 애플리케이션 종료 시 실행 중인 작업을 제한된 타임아웃 안에서 drain합니다. 따라서 하나의 hung task 때문에 프로세스 종료가 영원히 막히지 않습니다.
 
-기본적으로 shutdown drain은 최대 `10_000ms` 동안 기다립니다. 이 시간이 지나면 스케줄러는 경고 로그를 남기고 hung task가 끝나기를 더 기다리지 않은 채 종료를 계속합니다. 같은 `shutdown.timeoutMs` 경계는 shutdown 중 Redis owned-lock release I/O에도 적용되므로, 멈춘 Redis release가 process termination을 무기한 막지 못합니다. 분산 락을 사용하는 경우 아직 실행 중인 작업이 보유한 락은 timeout 시점에 즉시 해제하지 않습니다. 해당 작업이 정상적으로 끝날 때까지 락 소유권을 유지하거나, 프로세스가 종료된 뒤 Redis TTL로 만료되게 둡니다. fluo는 lock renewal timer에 `unref()`를 호출하므로 다른 작업이 Node.js event loop를 활성 상태로 유지하는 동안에는 갱신을 계속하지만 timer 자체만으로 process를 유지하지 않으며, task가 settle되면 timer를 clear합니다. Release I/O 자체가 timeout되면 fluo는 Redis가 release를 확인하거나 다른 owner가 key를 보유한다고 응답할 때까지 local owned-lock visibility/status를 보존하고 ownership을 지우지 않습니다. 이렇게 원래 작업이 아직 실행 중인데 다른 노드가 같은 작업을 시작하지 않도록 합니다.
+Shutdown은 scheduled handle을 stop하기 전에 tick admission을 닫습니다. 따라서 이미 queue된 callback도 drain이 시작된 뒤에는 task body를 시작하거나 distributed lease를 획득할 수 없습니다. 기본적으로 shutdown drain은 최대 `10_000ms` 동안 기다립니다. 이 시간이 지나면 스케줄러는 경고 로그를 남기고 hung task가 끝나기를 더 기다리지 않은 채 종료를 계속합니다. 같은 `shutdown.timeoutMs` 경계는 shutdown 중 Redis owned-lock release I/O에도 적용되므로, 멈춘 Redis release가 process termination을 무기한 막지 못합니다. Task의 post-run `finally` release와 즉시 이어지는 stopped-state retry는 shutdown 시작 시 설정되어 `shutdown.timeoutMs` 뒤에 만료되는 deadline의 남은 시간만 사용합니다. 따라서 deadline 뒤에 task가 settle되어도 새 release window를 열지 않습니다. 분산 락을 사용하는 경우 아직 실행 중인 작업이 보유한 락은 timeout 시점에 즉시 해제하지 않습니다. 해당 작업이 정상적으로 끝날 때까지 락 소유권을 유지하거나, 프로세스가 종료된 뒤 Redis TTL로 만료되게 둡니다. fluo는 lock renewal timer에 `unref()`를 호출하므로 다른 작업이 Node.js event loop를 활성 상태로 유지하는 동안에는 갱신을 계속하지만 timer 자체만으로 process를 유지하지 않으며, task가 settle되면 timer를 clear합니다. Release I/O 자체가 timeout되면 fluo는 Redis가 release를 확인하거나 다른 owner가 key를 보유한다고 응답할 때까지 local owned-lock visibility/status를 보존하고 ownership을 지우지 않습니다. 이렇게 원래 작업이 아직 실행 중인데 다른 노드가 같은 작업을 시작하지 않도록 합니다.
 
 ```typescript
 @Module({

package/README.md

@@ -1,12 +1,31 @@
 # @fluojs/cron
 
 <p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+<!-- fluo:cron-nestjs-migration: timezone-mapping -->
+<!-- fluo:cron-nestjs-migration: wait-for-completion -->
+<!-- fluo:cron-nestjs-migration: unsupported-options -->
+<!-- fluo:cron-nestjs-migration: absolute-time -->
+<!-- fluo:cron-nestjs-migration: named-interval-timeout -->
+<!-- fluo:cron-nestjs-migration: async-configuration -->
+<!-- fluo:cron-nestjs-migration: global-visibility -->
+<!-- fluo:cron-nestjs-migration: category-switches -->
+| Migration proposition | Governed fluo rule |
+| --- | --- |
+| `timezone-mapping` | `timeZone` maps to `timezone`; `CronTaskOptions.timezone` is a string. |
+| `wait-for-completion` | `protect: true` prevents overlapping Croner invocations, and `CronLifecycleService` rejects a tick while its task is running. |
+| `unsupported-options` | NestJS scheduler options other than the documented fluo options are unsupported. |
+| `absolute-time` | `@Cron` accepts a cron-expression string only; `Date` and `DateTime` overloads are unsupported. |
+| `named-interval-timeout` | `@Interval(ms, options)` and `@Timeout(ms, options)` accept milliseconds and optional named task options. |
+| `async-configuration` | `CronModule.forRoot(...)` is synchronous; resolve async configuration before calling it. |
+| `global-visibility` | `CronModule.forRoot(...)` is local by default; pass `global: true` explicitly when needed. |
+| `category-switches` | `cronJobs`, `intervals`, and `timeouts` category switches are unsupported. |
 
 Decorator-based scheduling for fluo applications with lifecycle-managed startup/shutdown and optional Redis distributed locking.
 
 ## Table of Contents
 
 - [Installation](#installation)
+- [Node.js Compatibility](#nodejs-compatibility)
 - [When to Use](#when-to-use)
 - [Quick Start](#quick-start)
 - [Common Patterns](#common-patterns)
@@ -28,6 +47,14 @@ npm install @fluojs/cron
 
 `@fluojs/redis` is needed only when Redis distributed locking is enabled. Non-distributed scheduling paths do not load the Redis integration during package import, module registration, bootstrap, or status snapshot creation.
 
+## Node.js Compatibility
+
+`@fluojs/cron` requires Node.js `>=24.0.0 <27` as its package-owned support policy. Node.js versions below 24 and Node.js 27+ are not supported. The portable `@fluojs/runtime` engine omission is a separate contract.
+
+### Migration to 3
+
+Before upgrading from `@fluojs/cron` 2, move deployment hosts to Node.js `>=24.0.0 <27`. Update any runtime image, CI matrix, or local development environment that still uses a removed Node.js version before installing `@fluojs/cron` 3.
+
 ## When to Use
 
 - When you need to run periodic background tasks (e.g., database cleanup, report generation).
@@ -90,6 +117,18 @@ Do not copy `waitForCompletion` or invent an overlap flag. fluo does not expose
 
 This guard covers one task instance in one application process. Use [Distributed Locking](#distributed-locking) when multiple application instances must not run the same task concurrently.
 
+The remaining NestJS scheduling options have no `CronTaskOptions` equivalent. Do not copy `utcOffset`, `unrefTimeout`, `disabled`, `threshold`, or `initialDelay`: fluo does not accept or emulate them. Make disabled or category-specific schedules part of application composition by omitting the provider/module that declares them, or register a dynamic task only after the application-owned condition is satisfied. Treat threshold/recovery policy as application-owned work. Use `@Timeout(ms, ...)` only when a delay relative to application startup is the intended behavior; it is not an absolute-time replacement for NestJS `@Cron(Date)` or `@Cron(DateTime)`.
+
+| NestJS scheduling form | fluo migration |
+| --- | --- |
+| `@Cron(expression, { timeZone })` | `@Cron(expression, { timezone })` |
+| `@Cron(Date)` or `@Cron(DateTime)` | No direct equivalent. Resolve the absolute-time plan in application code; do not substitute a startup-relative `@Timeout`. |
+| `@Interval('name', ms)` | `@Interval(ms, { name: 'name' })` |
+| `@Timeout('name', ms)` | `@Timeout(ms, { name: 'name' })` |
+| `ScheduleModule.forRootAsync(...)` | Resolve async configuration at the application bootstrap/composition boundary, then call synchronous `CronModule.forRoot(...)`. |
+| NestJS global-by-default schedule registration | `CronModule.forRoot({ global: true })` when global visibility is required; fluo defaults to `false`. |
+| `cronJobs`, `intervals`, or `timeouts` category switches | No direct equivalent. Own the conditional provider/module composition or explicit dynamic registration in the application. |
+
 ### Distributed Locking
 
 To prevent scheduled tasks from running concurrently across multiple server instances, enable distributed mode. This requires `@fluojs/redis`; the Redis peer is loaded and resolved only when `distributed.enabled` is `true`.
@@ -118,7 +157,7 @@ Leave `distributed.clientName` unset to keep using the default Redis registratio
 
 `distributed.lockTtlMs` must stay at or above `1_000ms`. When distributed locking is enabled, fluo validates that module-level TTL during option normalization before loading, resolving, or probing Redis. Task-level `lockTtlMs` overrides are validated only when module distributed mode and that task's distributed locking are both enabled. Disabled module or task locking does not fail solely because an inactive TTL is below the distributed minimum. fluo renews the Redis lock before the active TTL expires, including the minimum supported `1_000ms` boundary.
 
-Each scheduler instance uses a platform-neutral default `distributed.ownerId`; set `distributed.ownerId` explicitly only when your deployment has a stronger stable-owner convention. When `distributed.ownerId` is provided, fluo trims it during module option normalization and rejects blank or non-string values before scheduler or Redis lifecycle setup, so invalid or empty owner identifiers cannot enter Redis lock ownership state. Lock release runs in a `finally` path after task execution. If bootstrap later fails while a distributed tick is already running, startup rollback keeps the Redis lock client available until that active task can drain and release its lock. If Redis release fails, fluo keeps local ownership in status snapshots and retries during shutdown; if Redis reports that another owner holds the key, local ownership is cleared because fencing has already moved elsewhere. Redis TTL and renewal timing are still drift-sensitive coordination primitives rather than hard fencing tokens, so long-running jobs should remain idempotent and use application-level fencing when stale work would be unsafe.
+Each scheduler instance uses a platform-neutral default `distributed.ownerId`; set `distributed.ownerId` explicitly only when your deployment has a stronger stable-owner convention. When `distributed.ownerId` is provided, fluo trims it during module option normalization and rejects blank or non-string values before scheduler or Redis lifecycle setup, so invalid or empty owner identifiers cannot enter Redis lock ownership state. Every successful acquisition derives a unique lease token from that owner identity, and renewal and release compare the exact token. A delayed release from an expired acquisition therefore cannot delete a newer lease even when both acquisitions reuse the same configured `ownerId`. Lock release runs in a `finally` path after task execution. If bootstrap later fails while a distributed tick is already running, startup rollback keeps the Redis lock client available until that active task can drain and release its lock. If Redis release fails, fluo keeps local ownership in status snapshots and retries during shutdown; if Redis reports that another owner holds the key, local ownership is cleared because fencing has already moved elsewhere. Redis TTL and renewal timing are still drift-sensitive coordination primitives rather than hard fencing tokens, so long-running jobs should remain idempotent and use application-level fencing when stale work would be unsafe.
 
 ```typescript
 @Module({
@@ -168,13 +207,13 @@ class TaskManager {
 
 The registry exposes `addCron`, `addInterval`, `addTimeout`, `remove`, `enable`, `disable`, `get`, `getAll`, `updateCronExpression`, and `updateIntervalMs`. The first `name` argument is the default registry key; passing `options.name` overrides the actual registry key, scheduler metadata name, and default distributed lock key for dynamic tasks so dynamic registration matches decorator naming semantics. Registry, decorator, and dynamic `options.name` task names must be non-empty strings; blank dynamic override names are rejected before scheduler or registry state is retained. `get` and `getAll` return immutable `SchedulingTaskDescriptor` snapshots, not live `CronJob` handles or mutable registry state. Timeout tasks run once, then disable themselves while remaining in the registry so they can be re-enabled deliberately.
 
-Dynamic cron registration is atomic with scheduler startup: if the scheduler rejects a new cron job, the registry does not retain a half-registered task. Updating a running cron expression or interval cadence is also rollback-safe. A replacement is committed only after the previous scheduled handle stops successfully. If replacement scheduling fails or the previous handle cannot be stopped, fluo stops the provisional replacement, restores the previous expression or interval milliseconds and handle, and rethrows the failure instead of silently retaining duplicate schedules. Cron tasks use both scheduler-level no-overlap protection and fluo's in-process running guard, so the same task instance will not run overlapping ticks.
+Dynamic cron registration is atomic with scheduler startup: if the scheduler rejects a new cron job, the registry does not retain a half-registered task. Updating a running cron expression or interval cadence is also rollback-safe. A provisional replacement remains tick-ineligible until the previous scheduled handle stops successfully and the registry commits the new handle token; callbacks already queued by a retired handle are ignored. If replacement scheduling fails or the previous handle cannot be stopped, fluo stops the provisional replacement, restores the previous expression or interval milliseconds and handle, and rethrows the failure instead of silently retaining duplicate schedules. Disabling or removing an active task clears its scheduler handle only after `stop()` succeeds. A stop failure is logged, the handle remains registered for a safe retry, and the operation returns `false`. A failed `disable()` leaves the task descriptor disabled so later ticks stay gated while another disable or shutdown retries cleanup; a failed `remove()` keeps the task registered until a later removal succeeds. If the first shutdown cleanup attempt also fails, the next shutdown lifecycle hook retries the same retained handle and clears it only after `stop()` succeeds. Cron tasks use both scheduler-level no-overlap protection and fluo's in-process running guard, so the same task instance will not run overlapping ticks.
 
 ### Bounded Shutdown
 
 `CronModule` drains active task executions during application shutdown with a bounded timeout so one hung task cannot block process termination forever.
 
-By default the shutdown drain waits up to `10_000ms`. If that timeout expires, the scheduler logs a warning and continues shutdown without waiting for the hung task to settle. The same `shutdown.timeoutMs` boundary also applies to Redis owned-lock release I/O during shutdown, so a stuck Redis release cannot block process termination indefinitely. When distributed locking is enabled, locks held by still-running tasks are not eagerly released on timeout; they remain owned by that task until it settles normally, or until Redis expires the lock after the process exits. fluo calls `unref()` on lock renewal timers so they continue renewing while other work keeps the Node.js event loop active without retaining the process by themselves, and it clears them when the task settles. If release I/O itself times out, fluo preserves local owned-lock visibility/status and does not clear ownership until Redis confirms release or reports that another owner holds the key. This prevents another node from starting the same job while the original task is still running.
+Shutdown closes tick admission before scheduled handles are stopped, so callbacks that were already queued cannot start task bodies or acquire distributed leases after draining begins. By default the shutdown drain waits up to `10_000ms`. If that timeout expires, the scheduler logs a warning and continues shutdown without waiting for the hung task to settle. The same `shutdown.timeoutMs` boundary also applies to Redis owned-lock release I/O during shutdown, so a stuck Redis release cannot block process termination indefinitely. A task's post-run `finally` release and any immediate stopped-state retry use only the time remaining on the deadline established when shutdown starts, which expires after `shutdown.timeoutMs`; a task that settles after that deadline does not open a new release window. When distributed locking is enabled, locks held by still-running tasks are not eagerly released on timeout; they remain owned by that task until it settles normally, or until Redis expires the lock after the process exits. fluo calls `unref()` on lock renewal timers so they continue renewing while other work keeps the Node.js event loop active without retaining the process by themselves, and it clears them when the task settles. If release I/O itself times out, fluo preserves local owned-lock visibility/status and does not clear ownership until Redis confirms release or reports that another owner holds the key. This prevents another node from starting the same job while the original task is still running.
 
 ```typescript
 @Module({

package/dist/decorators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,eAAe,EAEf,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,KAAK,yBAAyB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;AACjG,KAAK,mBAAmB,GAAG,yBAAyB,CAAC;AAyCrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,mBAAmB,CAoB3F;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,mBAAmB,CAgB3F;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,mBAAmB,CAgBzF"}
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,eAAe,EAEf,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,KAAK,yBAAyB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;AACjG,KAAK,mBAAmB,GAAG,yBAAyB,CAAC;AA4CrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,mBAAmB,CAoB3F;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,mBAAmB,CAgB3F;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,mBAAmB,CAgBzF"}

package/dist/decorators.js

@@ -8,7 +8,7 @@ function getStandardMetadataBag(metadata) {
 function defineStandardSchedulingMetadata(metadata, propertyKey, taskMetadata) {
   const bag = getStandardMetadataBag(metadata);
   const current = bag[schedulingMetadataSymbol];
-  const map = current ?? new Map();
+  const map = Object.hasOwn(bag, schedulingMetadataSymbol) && current !== undefined ? current : new Map(current);
   map.set(propertyKey, {
     ...taskMetadata,
     options: {

package/dist/distributed-lock-manager.d.ts

@@ -11,12 +11,17 @@ export interface LockRenewalMonitor {
     getPostRunError(): Promise<Error | undefined>;
     stop(): void;
 }
+interface DistributedLockLease {
+    readonly lockKey: string;
+    readonly taskName: string;
+    readonly token: string;
+}
 /** Coordinates Redis lock acquisition, renewal, and release for scheduled cron tasks. */
 export declare class CronDistributedLockManager {
     private readonly options;
     private readonly runtimeContainer;
     private readonly logger;
-    private readonly ownedLockKeys;
+    private readonly ownedLeases;
     private lockIoError;
     private redisClient;
     private lockOwnershipLosses;
@@ -29,18 +34,20 @@ export declare class CronDistributedLockManager {
     get renewalFailures(): number;
     resolveClient(): Promise<void>;
     reset(): void;
-    tryAcquireLock(descriptor: CronTaskDescriptor): Promise<boolean>;
-    startLockRenewalMonitor(descriptor: CronTaskDescriptor): LockRenewalMonitor;
-    releaseLock(descriptor: CronTaskDescriptor): Promise<boolean>;
+    tryAcquireLock(descriptor: CronTaskDescriptor): Promise<DistributedLockLease | undefined>;
+    startLockRenewalMonitor(descriptor: CronTaskDescriptor, lease: DistributedLockLease): LockRenewalMonitor;
+    releaseLock(lease: DistributedLockLease, timeoutMs?: number): Promise<boolean>;
     releaseOwnedLocks(excludedLockKeys?: ReadonlySet<string>, timeoutMs?: number): Promise<void>;
     private createLockRenewalState;
     private queueDueLockRenewalAttempts;
     private runLockRenewalAttempt;
     private toLockPostRunError;
     private renewLock;
-    private releaseLockKey;
+    private releaseLease;
+    private clearOwnedLease;
     private verifyLockIoAvailability;
     private markLockIoAvailable;
     private markLockIoUnavailable;
 }
+export {};
 //# sourceMappingURL=distributed-lock-manager.d.ts.map

package/dist/distributed-lock-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributed-lock-manager.d.ts","sourceRoot":"","sources":["../src/distributed-lock-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAElF,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrF,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CAC7G;AAED,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,eAAe,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAC9C,IAAI,IAAI,IAAI,CAAC;CACd;AA+ED,yFAAyF;AACzF,qBAAa,0BAA0B;IAQnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IATzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,mBAAmB,CAAK;gBAGb,OAAO,EAAE,2BAA2B,EACpC,gBAAgB,EAAE,SAAS,EAC3B,MAAM,EAAE,iBAAiB;IAG5C,IAAI,cAAc,IAAI,eAAe,GAAG,SAAS,CAEhD;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,eAAe,IAAI,OAAO,CAM7B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBpC,KAAK,IAAI,IAAI;IAKP,cAAc,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAkCtE,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB;IA8BrE,WAAW,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D,iBAAiB,CAAC,gBAAgB,GAAE,WAAW,CAAC,MAAM,CAAa,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB7G,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,2BAA2B;YAcrB,qBAAqB;IAqBnC,OAAO,CAAC,kBAAkB;YAYZ,SAAS;YA2CT,cAAc;YAyCd,wBAAwB;IAmBtC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,qBAAqB;CAG9B"}
+{"version":3,"file":"distributed-lock-manager.d.ts","sourceRoot":"","sources":["../src/distributed-lock-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAElF,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrF,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CAC7G;AAED,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,eAAe,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAC9C,IAAI,IAAI,IAAI,CAAC;CACd;AAWD,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAuED,yFAAyF;AACzF,qBAAa,0BAA0B;IAQnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IATzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2C;IACvE,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,mBAAmB,CAAK;gBAGb,OAAO,EAAE,2BAA2B,EACpC,gBAAgB,EAAE,SAAS,EAC3B,MAAM,EAAE,iBAAiB;IAG5C,IAAI,cAAc,IAAI,eAAe,GAAG,SAAS,CAEhD;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,eAAe,IAAI,OAAO,CAM7B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBpC,KAAK,IAAI,IAAI;IAKP,cAAc,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IA6C/F,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,oBAAoB,GAAG,kBAAkB;IA8BlG,WAAW,CAAC,KAAK,EAAE,oBAAoB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI9E,iBAAiB,CAAC,gBAAgB,GAAE,WAAW,CAAC,MAAM,CAAa,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB7G,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,2BAA2B;YAcrB,qBAAqB;IAqBnC,OAAO,CAAC,kBAAkB;YAYZ,SAAS;YA2CT,YAAY;IAyC1B,OAAO,CAAC,eAAe;YAMT,wBAAwB;IAoBtC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,qBAAqB;CAG9B"}

package/dist/distributed-lock-manager.js

@@ -1,3 +1,5 @@
+import { createCronRandomId } from './random-id.js';
+
 /** Minimal Redis command surface required for distributed cron locks. */
 
 /** Tracks renewal state for one acquired distributed cron lock. */
@@ -49,7 +51,7 @@ async function resolveRedisPeerModule() {
 
 /** Coordinates Redis lock acquisition, renewal, and release for scheduled cron tasks. */
 export class CronDistributedLockManager {
-  ownedLockKeys = new Set();
+  ownedLeases = new Map();
   lockIoError;
   redisClient;
   lockOwnershipLosses = 0;
@@ -63,7 +65,7 @@ export class CronDistributedLockManager {
     return this.redisClient;
   }
   get ownedLocks() {
-    return this.ownedLockKeys.size;
+    return this.ownedLeases.size;
   }
   get lockIoAvailable() {
     if (!this.options.distributed.enabled) {
@@ -102,23 +104,33 @@ export class CronDistributedLockManager {
   async tryAcquireLock(descriptor) {
     const redis = this.redisClient;
     if (!redis) {
-      return true;
+      return {
+        lockKey: descriptor.lockKey,
+        taskName: descriptor.taskName,
+        token: `${this.options.distributed.ownerId}:${createCronRandomId()}`
+      };
     }
+    const lease = {
+      lockKey: descriptor.lockKey,
+      taskName: descriptor.taskName,
+      token: `${this.options.distributed.ownerId}:${createCronRandomId()}`
+    };
     try {
-      const result = await redis.set(descriptor.lockKey, this.options.distributed.ownerId, 'PX', descriptor.lockTtlMs, 'NX');
+      const result = await redis.set(descriptor.lockKey, lease.token, 'PX', descriptor.lockTtlMs, 'NX');
       this.markLockIoAvailable();
       if (result === 'OK') {
-        this.ownedLockKeys.add(descriptor.lockKey);
+        this.ownedLeases.set(descriptor.lockKey, lease);
+        return lease;
       }
-      return result === 'OK';
+      return undefined;
     } catch (error) {
       this.markLockIoUnavailable(error);
       this.logger.error(`Failed to acquire distributed cron lock for ${descriptor.taskName}.`, error, 'CronLifecycleService');
-      return false;
+      return undefined;
     }
   }
-  startLockRenewalMonitor(descriptor) {
-    const renewalState = this.createLockRenewalState(descriptor.lockTtlMs);
+  startLockRenewalMonitor(descriptor, lease) {
+    const renewalState = this.createLockRenewalState(descriptor.lockTtlMs, lease);
     const renewalTimer = setInterval(() => {
       if (renewalState.stopped) {
         return;
@@ -143,24 +155,28 @@ export class CronDistributedLockManager {
       }
     };
   }
-  async releaseLock(descriptor) {
-    return await this.releaseLockKey(descriptor.lockKey, descriptor.taskName);
+  async releaseLock(lease, timeoutMs) {
+    return await this.releaseLease(lease, timeoutMs);
   }
   async releaseOwnedLocks(excludedLockKeys = new Set(), timeoutMs) {
-    if (!this.redisClient || this.ownedLockKeys.size === 0) {
+    if (!this.redisClient || this.ownedLeases.size === 0) {
       return;
     }
-    const lockKeys = Array.from(this.ownedLockKeys).filter(lockKey => !excludedLockKeys.has(lockKey));
-    if (lockKeys.length === 0) {
+    const leases = Array.from(this.ownedLeases.values()).filter(lease => !excludedLockKeys.has(lease.lockKey));
+    if (leases.length === 0) {
       return;
     }
-    await Promise.all(lockKeys.map(async lockKey => {
-      await this.releaseLockKey(lockKey, lockKey, timeoutMs);
+    await Promise.all(leases.map(async lease => {
+      await this.releaseLease({
+        ...lease,
+        taskName: lease.lockKey
+      }, timeoutMs);
     }));
   }
-  createLockRenewalState(lockTtlMs) {
+  createLockRenewalState(lockTtlMs, lease) {
     const renewalIntervalMs = Math.max(250, Math.floor(lockTtlMs / 2));
     return {
+      lease,
       lockPostRunError: undefined,
       nextRenewalDueAt: Date.now() + renewalIntervalMs,
       renewalChain: Promise.resolve(),
@@ -178,7 +194,7 @@ export class CronDistributedLockManager {
     }
   }
   async runLockRenewalAttempt(descriptor, renewalState) {
-    const outcome = await this.renewLock(descriptor);
+    const outcome = await this.renewLock(descriptor, renewalState.lease);
     if (outcome === 'ownership-lost') {
       this.lockOwnershipLosses += 1;
     }
@@ -199,13 +215,13 @@ export class CronDistributedLockManager {
     }
     return undefined;
   }
-  async renewLock(descriptor) {
+  async renewLock(descriptor, lease) {
     const redis = this.redisClient;
     if (!redis) {
       return 'renewed';
     }
     try {
-      const result = await redis.eval(RENEW_LOCK_SCRIPT, 1, descriptor.lockKey, this.options.distributed.ownerId, String(descriptor.lockTtlMs));
+      const result = await redis.eval(RENEW_LOCK_SCRIPT, 1, descriptor.lockKey, lease.token, String(descriptor.lockTtlMs));
       if (typeof result === 'number' && result <= 0) {
         this.markLockIoAvailable();
         this.logger.warn(`Distributed cron lock ownership was lost for ${descriptor.taskName}.`, 'CronLifecycleService');
@@ -220,38 +236,44 @@ export class CronDistributedLockManager {
       return 'renewal-failed';
     }
   }
-  async releaseLockKey(lockKey, taskName, timeoutMs) {
+  async releaseLease(lease, timeoutMs) {
     const redis = this.redisClient;
-    if (!redis) {
-      return true;
+    if (!redis || timeoutMs !== undefined && timeoutMs <= 0) {
+      return redis === undefined;
     }
     try {
-      const result = await withTimeout(redis.eval(RELEASE_LOCK_SCRIPT, 1, lockKey, this.options.distributed.ownerId), timeoutMs);
+      const result = await withTimeout(redis.eval(RELEASE_LOCK_SCRIPT, 1, lease.lockKey, lease.token), timeoutMs);
       if (typeof result === 'number' && result <= 0) {
         this.markLockIoAvailable();
-        this.logger.warn(`Distributed cron lock for ${taskName} was already released or owned by another node.`, 'CronLifecycleService');
-        this.ownedLockKeys.delete(lockKey);
+        this.logger.warn(`Distributed cron lock for ${lease.taskName} was already released or owned by another node.`, 'CronLifecycleService');
+        this.clearOwnedLease(lease);
         return true;
       }
       this.markLockIoAvailable();
-      this.logger.log(`Released distributed cron lock for ${taskName}.`, 'CronLifecycleService');
-      this.ownedLockKeys.delete(lockKey);
+      this.logger.log(`Released distributed cron lock for ${lease.taskName}.`, 'CronLifecycleService');
+      this.clearOwnedLease(lease);
       return true;
     } catch (error) {
       this.markLockIoUnavailable(error);
-      this.logger.error(`Failed to release distributed cron lock for ${taskName}.`, error, 'CronLifecycleService');
+      this.logger.error(`Failed to release distributed cron lock for ${lease.taskName}.`, error, 'CronLifecycleService');
       return false;
     }
   }
+  clearOwnedLease(lease) {
+    if (this.ownedLeases.get(lease.lockKey)?.token === lease.token) {
+      this.ownedLeases.delete(lease.lockKey);
+    }
+  }
   async verifyLockIoAvailability() {
     const redis = this.redisClient;
     if (!redis) {
       return;
     }
-    const probeKey = `${this.options.distributed.keyPrefix}:__probe:${this.options.distributed.ownerId}`;
+    const probeToken = `${this.options.distributed.ownerId}:${createCronRandomId()}`;
+    const probeKey = `${this.options.distributed.keyPrefix}:__probe:${probeToken}`;
     try {
-      await redis.set(probeKey, this.options.distributed.ownerId, 'PX', 1_000, 'NX');
-      await redis.eval(RELEASE_LOCK_SCRIPT, 1, probeKey, this.options.distributed.ownerId);
+      await redis.set(probeKey, probeToken, 'PX', 1_000, 'NX');
+      await redis.eval(RELEASE_LOCK_SCRIPT, 1, probeKey, probeToken);
       this.markLockIoAvailable();
     } catch (error) {
       this.markLockIoUnavailable(error);

package/dist/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAoGjF;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iBAAsB,GAAG,2BAA2B,CAMvG;AAeD,iEAAiE;AACjE,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,iBAAsB,GAAG,UAAU;CAS5D"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAMhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AA0FjF;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iBAAsB,GAAG,2BAA2B,CAMvG;AAeD,iEAAiE;AACjE,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,iBAAsB,GAAG,UAAU;CAS5D"}

package/dist/module.js

@@ -1,15 +1,9 @@
 import { defineModule } from '@fluojs/runtime';
+import { createCronRandomId } from './random-id.js';
 import { defaultCronScheduler } from './scheduler.js';
 import { CronLifecycleService } from './service.js';
 import { CRON_OPTIONS, SCHEDULING_REGISTRY } from './tokens.js';
 const DEFAULT_CRON_SHUTDOWN_TIMEOUT_MS = 10_000;
-function randomId() {
-  const randomUUID = globalThis.crypto?.randomUUID;
-  if (randomUUID) {
-    return randomUUID.call(globalThis.crypto);
-  }
-  return `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
 function normalizeRedisClientName(clientName) {
   if (clientName === undefined) {
     return undefined;
@@ -27,7 +21,7 @@ function assertValidDistributedLockTtlMs(lockTtlMs) {
 }
 function normalizeDistributedOwnerId(ownerId) {
   if (ownerId === undefined) {
-    return randomId();
+    return createCronRandomId();
   }
   if (typeof ownerId !== 'string') {
     throw new Error('Cron distributed ownerId must be a string when provided.');
@@ -45,7 +39,7 @@ function normalizeDistributedOptions(distributed) {
       enabled: false,
       keyPrefix: 'fluo:cron:lock',
       lockTtlMs: 30_000,
-      ownerId: randomId()
+      ownerId: createCronRandomId()
     };
   }
   if (distributed === true) {
@@ -54,7 +48,7 @@ function normalizeDistributedOptions(distributed) {
       enabled: true,
       keyPrefix: 'fluo:cron:lock',
       lockTtlMs: 30_000,
-      ownerId: randomId()
+      ownerId: createCronRandomId()
     };
   }
   const normalizedDistributed = {

package/dist/random-id.d.ts

@@ -0,0 +1,3 @@
+/** Creates a platform-neutral random identifier for Cron ownership boundaries. */
+export declare function createCronRandomId(): string;
+//# sourceMappingURL=random-id.d.ts.map

package/dist/random-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-id.d.ts","sourceRoot":"","sources":["../src/random-id.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,wBAAgB,kBAAkB,IAAI,MAAM,CAQ3C"}

package/dist/random-id.js

@@ -0,0 +1,8 @@
+/** Creates a platform-neutral random identifier for Cron ownership boundaries. */
+export function createCronRandomId() {
+  const randomUUID = globalThis.crypto?.randomUUID;
+  if (randomUUID) {
+    return randomUUID.call(globalThis.crypto);
+  }
+  return `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}

package/dist/service.d.ts

@@ -15,10 +15,11 @@ export declare class CronLifecycleService implements SchedulingRegistry, OnAppli
     private readonly logger;
     private readonly tasks;
     private readonly activeTasks;
-    private readonly runningDistributedLockKeys;
+    private readonly runningDistributedLeaseCounts;
     private readonly distributedLocks;
     private readonly taskRunner;
     private lifecycleState;
+    private shutdownDeadlineMs;
     private started;
     private shutdownPromise;
     constructor(options: NormalizedCronModuleOptions, runtimeContainer: Container, compiledModules: readonly CompiledModule[], logger: ApplicationLogger);
@@ -53,7 +54,7 @@ export declare class CronLifecycleService implements SchedulingRegistry, OnAppli
      * Removes a registered task by name.
      *
      * @param name Task name to remove.
-     * @returns `true` when a task existed and was removed.
+     * @returns `true` when a task existed and was removed; `false` when it was absent or its handle could not stop.
      */
     remove(name: string): boolean;
     /**
@@ -67,7 +68,7 @@ export declare class CronLifecycleService implements SchedulingRegistry, OnAppli
      * Disables a task without removing its descriptor.
      *
      * @param name Task name to disable.
-     * @returns `true` when the task exists after the operation.
+     * @returns `true` when the task exists and its handle stopped; `false` when it was absent or its handle could not stop.
      */
     disable(name: string): boolean;
     /**
@@ -112,6 +113,7 @@ export declare class CronLifecycleService implements SchedulingRegistry, OnAppli
     private completeStartupFailureCleanupAfterActiveTasks;
     private resetDistributedLocksAfterStartupFailure;
     private runShutdownLifecycle;
+    private getRemainingShutdownTimeoutMs;
     private getRunningDistributedLockKeys;
     private registerDecoratorTasks;
     private registerTask;
@@ -123,6 +125,7 @@ export declare class CronLifecycleService implements SchedulingRegistry, OnAppli
     private unscheduleTask;
     private stopScheduledHandle;
     private handleTaskTick;
+    private isTaskTickCurrent;
     private runTaskTick;
     private shouldUseDistributedExecution;
     private runDistributedTaskTick;

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/dist/service.js

@@ -44,6 +44,9 @@ function createRedisDependencyId(name) {
   }
   return `redis.${normalizedName}`;
 }
+function getRemainingTimeoutMs(deadlineMs) {
+  return Math.max(0, deadlineMs - Date.now());
+}
 
 /**
  * Lifecycle-managed scheduler runtime for decorator-discovered and dynamic tasks.
@@ -59,10 +62,11 @@ class CronLifecycleService {
   }
   tasks = new Map();
   activeTasks = new Set();
-  runningDistributedLockKeys = new Set();
+  runningDistributedLeaseCounts = new Map();
   distributedLocks;
   taskRunner;
   lifecycleState = 'created';
+  shutdownDeadlineMs;
   started = false;
   shutdownPromise;
   constructor(options, runtimeContainer, compiledModules, logger) {
@@ -157,14 +161,16 @@ class CronLifecycleService {
    * Removes a registered task by name.
    *
    * @param name Task name to remove.
-   * @returns `true` when a task existed and was removed.
+   * @returns `true` when a task existed and was removed; `false` when it was absent or its handle could not stop.
    */
   remove(name) {
     const task = this.tasks.get(name);
     if (!task) {
       return false;
     }
-    this.unscheduleTask(task);
+    if (!this.unscheduleTask(task)) {
+      return false;
+    }
     this.tasks.delete(name);
     return true;
   }
@@ -201,7 +207,7 @@ class CronLifecycleService {
    * Disables a task without removing its descriptor.
    *
    * @param name Task name to disable.
-   * @returns `true` when the task exists after the operation.
+   * @returns `true` when the task exists and its handle stopped; `false` when it was absent or its handle could not stop.
    */
   disable(name) {
     const task = this.tasks.get(name);
@@ -212,8 +218,7 @@ class CronLifecycleService {
       return true;
     }
     task.enabled = false;
-    this.unscheduleTask(task);
-    return true;
+    return this.unscheduleTask(task);
   }
 
   /**
@@ -258,6 +263,7 @@ class CronLifecycleService {
     }
     const previousExpression = task.descriptor.expression;
     const previousHandle = task.scheduledHandle;
+    const previousToken = task.activeScheduleToken;
     let nextHandle;
     task.descriptor.expression = expression;
     try {
@@ -266,12 +272,14 @@ class CronLifecycleService {
         previousHandle.stop();
       }
       task.scheduledHandle = nextHandle;
+      task.activeScheduleToken = nextHandle.token;
     } catch (error) {
       if (nextHandle) {
         this.stopScheduledHandle(nextHandle);
       }
       task.descriptor.expression = previousExpression;
       task.scheduledHandle = previousHandle;
+      task.activeScheduleToken = previousToken;
       throw error;
     }
   }
@@ -298,6 +306,7 @@ class CronLifecycleService {
     }
     const previousMs = task.descriptor.ms;
     const previousHandle = task.scheduledHandle;
+    const previousToken = task.activeScheduleToken;
     let nextHandle;
     task.descriptor.ms = ms;
     try {
@@ -306,12 +315,14 @@ class CronLifecycleService {
         previousHandle.stop();
       }
       task.scheduledHandle = nextHandle;
+      task.activeScheduleToken = nextHandle.token;
     } catch (error) {
       if (nextHandle) {
         this.stopScheduledHandle(nextHandle);
       }
       task.descriptor.ms = previousMs;
       task.scheduledHandle = previousHandle;
+      task.activeScheduleToken = previousToken;
       throw error;
     }
   }
@@ -381,9 +392,11 @@ class CronLifecycleService {
   async shutdown() {
     if (this.shutdownPromise) {
       await this.shutdownPromise;
+      this.stopAllScheduledTasks();
       await this.retryReleasedDistributedLocksAfterShutdown();
       return;
     }
+    this.shutdownDeadlineMs = Date.now() + this.options.shutdown.timeoutMs;
     this.shutdownPromise = this.runShutdownLifecycle();
     await this.shutdownPromise;
   }
@@ -391,7 +404,7 @@ class CronLifecycleService {
     if (this.lifecycleState !== 'stopped' || this.activeTasks.size > 0) {
       return;
     }
-    await this.distributedLocks.releaseOwnedLocks(new Set(), this.options.shutdown.timeoutMs);
+    await this.distributedLocks.releaseOwnedLocks(new Set(), this.getRemainingShutdownTimeoutMs());
   }
   async startLifecycle() {
     this.validateDistributedLockConfiguration();
@@ -439,11 +452,14 @@ class CronLifecycleService {
     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(shutdownTimedOut ? this.getRunningDistributedLockKeys() : new Set(), this.options.shutdown.timeoutMs);
+    await this.distributedLocks.releaseOwnedLocks(shutdownTimedOut ? this.getRunningDistributedLockKeys() : new Set(), this.getRemainingShutdownTimeoutMs());
     this.lifecycleState = 'stopped';
   }
+  getRemainingShutdownTimeoutMs() {
+    return this.shutdownDeadlineMs === undefined ? this.options.shutdown.timeoutMs : getRemainingTimeoutMs(this.shutdownDeadlineMs);
+  }
   getRunningDistributedLockKeys() {
-    return new Set(this.runningDistributedLockKeys);
+    return new Set(this.runningDistributedLeaseCounts.keys());
   }
   registerDecoratorTasks() {
     const descriptors = discoverCronTaskDescriptors(this.compiledModules, this.options, this.logger);
@@ -458,6 +474,7 @@ class CronLifecycleService {
       assertValidLockTtlMs(descriptor.lockTtlMs);
     }
     const task = {
+      activeScheduleToken: undefined,
       descriptor,
       enabled: true,
       running: false,
@@ -465,7 +482,7 @@ class CronLifecycleService {
       source
     };
     if (this.started) {
-      task.scheduledHandle = this.createScheduledHandle(task);
+      this.scheduleTask(task);
     }
     this.tasks.set(descriptor.taskName, task);
   }
@@ -485,22 +502,36 @@ class CronLifecycleService {
     if (!task.enabled || task.scheduledHandle) {
       return;
     }
-    task.scheduledHandle = this.createScheduledHandle(task);
+    const previousToken = task.activeScheduleToken;
+    const nextToken = {};
+    task.activeScheduleToken = nextToken;
+    try {
+      task.scheduledHandle = this.createScheduledHandle(task, nextToken);
+    } catch (error) {
+      task.activeScheduleToken = previousToken;
+      throw error;
+    }
   }
-  createScheduledHandle(task) {
+  createScheduledHandle(task, token = {}) {
     const taskName = task.descriptor.taskName;
     if (task.descriptor.kind === 'cron') {
       const expression = task.descriptor.expression;
       if (!expression) {
         throw new Error(`Cron task "${taskName}" is missing a cron expression.`);
       }
-      return this.options.scheduler(expression, {
+      const scheduledHandle = this.options.scheduler(expression, {
         name: taskName,
         protect: true,
         timezone: task.descriptor.timezone
       }, async () => {
-        await this.handleTaskTick(taskName);
+        await this.handleTaskTick(taskName, token);
       });
+      return {
+        stop: () => {
+          scheduledHandle.stop();
+        },
+        token
+      };
     }
     const ms = task.descriptor.ms;
     if (!ms) {
@@ -508,54 +539,63 @@ class CronLifecycleService {
     }
     if (task.descriptor.kind === 'interval') {
       const timer = setInterval(() => {
-        void this.handleTaskTick(taskName);
+        void this.handleTaskTick(taskName, token);
       }, ms);
       return {
         stop: () => {
           clearInterval(timer);
-        }
+        },
+        token
       };
     }
     const timer = setTimeout(() => {
-      void this.handleTaskTick(taskName).finally(() => {
-        this.completeTimeoutTask(taskName);
+      void this.handleTaskTick(taskName, token).finally(() => {
+        this.completeTimeoutTask(taskName, token);
       });
     }, ms);
     return {
       stop: () => {
         clearTimeout(timer);
-      }
+      },
+      token
     };
   }
-  completeTimeoutTask(taskName) {
+  completeTimeoutTask(taskName, token) {
     const task = this.tasks.get(taskName);
-    if (!task || task.descriptor.kind !== 'timeout') {
+    if (!task || task.descriptor.kind !== 'timeout' || task.activeScheduleToken !== token) {
       return;
     }
     task.scheduledHandle = undefined;
+    task.activeScheduleToken = undefined;
     task.enabled = false;
   }
   unscheduleTask(task) {
     if (!task.scheduledHandle) {
-      return;
+      return true;
     }
     const scheduledHandle = task.scheduledHandle;
+    if (!this.stopScheduledHandle(scheduledHandle)) {
+      return false;
+    }
     task.scheduledHandle = undefined;
-    this.stopScheduledHandle(scheduledHandle);
+    task.activeScheduleToken = undefined;
+    return true;
   }
   stopScheduledHandle(scheduledHandle) {
     try {
       scheduledHandle.stop();
+      return true;
     } catch (error) {
       this.logger.error('Failed to stop scheduled task.', error, 'CronLifecycleService');
+      return false;
     }
   }
-  async handleTaskTick(taskName) {
+  async handleTaskTick(taskName, token) {
     const taskState = this.tasks.get(taskName);
-    if (!taskState?.enabled || taskState.running) {
+    if (!this.started || !this.isTaskTickCurrent(taskName, token, taskState) || taskState.running) {
       return;
     }
-    const task = this.runTaskTick(taskState.descriptor, taskState);
+    const task = this.runTaskTick(taskState.descriptor, taskState, token);
     taskState.running = true;
     this.activeTasks.add(task);
     try {
@@ -565,23 +605,30 @@ class CronLifecycleService {
       this.activeTasks.delete(task);
     }
   }
-  async runTaskTick(descriptor, taskState) {
+  isTaskTickCurrent(taskName, token, taskState) {
+    return this.lifecycleState !== 'stopping' && this.lifecycleState !== 'stopped' && taskState?.enabled === true && this.tasks.get(taskName) === taskState && taskState.activeScheduleToken === token;
+  }
+  async runTaskTick(descriptor, taskState, token) {
     if (!this.shouldUseDistributedExecution(descriptor)) {
       await this.executeTask(descriptor, taskState);
       return;
     }
-    await this.runDistributedTaskTick(descriptor, taskState);
+    await this.runDistributedTaskTick(descriptor, taskState, token);
   }
   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) {
+  async runDistributedTaskTick(descriptor, taskState, token) {
+    const lease = await this.distributedLocks.tryAcquireLock(descriptor);
+    if (!lease) {
       return;
     }
-    const lockRenewalMonitor = this.distributedLocks.startLockRenewalMonitor(descriptor);
-    this.runningDistributedLockKeys.add(descriptor.lockKey);
+    if (this.lifecycleState !== 'failed' && !this.isTaskTickCurrent(descriptor.taskName, token, taskState)) {
+      await this.distributedLocks.releaseLock(lease, this.shutdownPromise ? this.getRemainingShutdownTimeoutMs() : undefined);
+      return;
+    }
+    const lockRenewalMonitor = this.distributedLocks.startLockRenewalMonitor(descriptor, lease);
+    this.runningDistributedLeaseCounts.set(descriptor.lockKey, (this.runningDistributedLeaseCounts.get(descriptor.lockKey) ?? 0) + 1);
     try {
       await this.executeTask(descriptor, taskState, async () => {
         lockRenewalMonitor.stop();
@@ -589,10 +636,15 @@ class CronLifecycleService {
       });
     } finally {
       lockRenewalMonitor.stop();
-      this.runningDistributedLockKeys.delete(descriptor.lockKey);
-      const released = await this.distributedLocks.releaseLock(descriptor);
+      const runningLeaseCount = this.runningDistributedLeaseCounts.get(descriptor.lockKey);
+      if (runningLeaseCount === 1) {
+        this.runningDistributedLeaseCounts.delete(descriptor.lockKey);
+      } else if (runningLeaseCount !== undefined) {
+        this.runningDistributedLeaseCounts.set(descriptor.lockKey, runningLeaseCount - 1);
+      }
+      const released = await this.distributedLocks.releaseLock(lease, this.shutdownPromise ? this.getRemainingShutdownTimeoutMs() : undefined);
       if (!released && this.lifecycleState === 'stopped') {
-        await this.distributedLocks.releaseOwnedLocks(new Set(), this.options.shutdown.timeoutMs);
+        await this.distributedLocks.releaseOwnedLocks(this.getRunningDistributedLockKeys(), this.getRemainingShutdownTimeoutMs());
       }
     }
   }
@@ -600,7 +652,8 @@ class CronLifecycleService {
     if (this.activeTasks.size === 0) {
       return false;
     }
-    if (this.options.shutdown.timeoutMs === 0) {
+    const timeoutMs = this.getRemainingShutdownTimeoutMs();
+    if (timeoutMs === 0) {
       return true;
     }
     let timeoutHandle;
@@ -608,7 +661,7 @@ class CronLifecycleService {
       return await Promise.race([this.drainActiveTasks().then(() => false), new Promise(resolve => {
         timeoutHandle = setTimeout(() => {
           resolve(true);
-        }, this.options.shutdown.timeoutMs);
+        }, timeoutMs);
       })]);
     } finally {
       if (timeoutHandle) {
@@ -626,6 +679,7 @@ class CronLifecycleService {
     if (descriptor.kind === 'timeout') {
       taskState.enabled = false;
       taskState.scheduledHandle = undefined;
+      taskState.activeScheduleToken = undefined;
     }
   }
   stopAllScheduledTasks() {

package/dist/types.d.ts

@@ -167,7 +167,8 @@ export interface SchedulingRegistry {
      * Removes one registered task from the runtime registry.
      *
      * @param name Task name to remove.
-     * @returns `true` when a task existed and was removed.
+     * @returns `true` when a task existed and was removed; `false` when it was absent or its handle could not stop.
+     * @remarks A failed stop keeps the task and scheduler handle registered so removal can be retried safely.
      */
     remove(name: string): boolean;
     /**
@@ -181,7 +182,8 @@ export interface SchedulingRegistry {
      * Disables a task without deleting its descriptor.
      *
      * @param name Task name to disable.
-     * @returns `true` when the task exists after the operation.
+     * @returns `true` when the task exists and its handle stopped; `false` when it was absent or its handle could not stop.
+     * @remarks A failed stop leaves the task disabled and keeps its scheduler handle registered for cleanup retry.
      */
     disable(name: string): boolean;
     /**

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -9,7 +9,7 @@
     "timeout",
     "distributed-lock"
   ],
-  "version": "2.0.1",
+  "version": "3.0.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
     "directory": "packages/cron"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0 <27"
   },
   "publishConfig": {
     "access": "public"
@@ -37,12 +37,12 @@
   ],
   "dependencies": {
     "croner": "^8.1.2",
-    "@fluojs/core": "^1.1.0",
-    "@fluojs/di": "^2.0.0",
-    "@fluojs/runtime": "^2.0.1"
+    "@fluojs/core": "^2.0.0",
+    "@fluojs/runtime": "^3.0.0",
+    "@fluojs/di": "^3.0.0"
   },
   "peerDependencies": {
-    "@fluojs/redis": "^1.1.0"
+    "@fluojs/redis": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@fluojs/redis": {
@@ -50,8 +50,8 @@
     }
   },
   "devDependencies": {
-    "vitest": "^3.2.4",
-    "@fluojs/redis": "^1.1.0"
+    "vitest": "^4.1.11",
+    "@fluojs/redis": "^2.0.0"
   },
   "scripts": {
     "prebuild": "node ../../tooling/scripts/clean-dist.mjs",