@zudojs/scheduler 0.1.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @zudojs/scheduler
 
-Scheduled task and job infrastructure with cron-like scheduling, persistence, and worker management.
+In-process scheduling for delayed, recurring and cron-driven jobs.
 
 ## Installation
 
@@ -11,31 +11,185 @@ npm install @zudojs/scheduler
 ## Quick Start
 
 ```typescript
-import { createScheduler } from "@zudojs/scheduler";
+import { Scheduler } from "@zudojs/scheduler";
 
-const scheduler = createScheduler();
+const scheduler = new Scheduler({
+  onError: ({ jobId, error }) => log.error({ jobId, error }, "job failed"),
+});
+
+// Register the job, then schedule it. A job must be defined before it can be
+// scheduled — scheduling an unregistered id throws.
+scheduler.define({
+  id: "cleanup",
+  name: "Clean up old records",
+  handler: async (ctx) => {
+    await cleanupOldRecords({ signal: ctx.signal });
+  },
+});
+
+scheduler.cron("0 0 * * *", "cleanup", { timezone: "UTC" });
+
+scheduler.start();
+
+// On shutdown: aborts in-flight jobs and waits for them to settle.
+await scheduler.stop({ timeoutMs: 30_000 });
+```
+
+## Scheduling
+
+Four entry points, each returning a `ScheduleHandle`:
+
+```typescript
+scheduler.after("30s", "job-id"); // once, after a delay
+scheduler.at(new Date("2027-01-01"), "job-id"); // once, at an instant
+scheduler.every("5m", "job-id"); // repeating interval
+scheduler.cron("*/15 * * * *", "job-id"); // repeating cron
+```
 
-scheduler.add("cleanup", {
-  cron: "0 0 * * *",
-  handler: async () => {
-    await cleanupOldRecords();
+Durations accept `ms`, `s`, `m`, `h`, `d` and `w`, and compose: `"1h30m"`.
+Zero, negative and out-of-range durations are rejected.
+
+Cron expressions are standard five-field (`minute hour day-of-month month
+day-of-week`) with ranges, lists, steps and three-letter names, plus the
+`@daily`/`@hourly`/`@weekly`/`@monthly`/`@yearly` macros. An invalid expression
+throws where the schedule is declared, not at fire time.
+
+Only `timezone: "UTC"` and the system local zone are supported. Any other zone
+is rejected rather than silently ignored — honouring an arbitrary IANA zone
+needs real zone data this package does not carry.
+
+## Controlling a schedule
+
+The handle is bound to its scheduler, so these reach the queue:
+
+```typescript
+const handle = scheduler.every("1h", "sync");
+
+handle.nextRun(); // Date — the real next fire time
+await handle.pause(); // stops firing; recomputes from now on resume
+await handle.resume();
+await handle.cancel(); // aborts any in-flight run and removes the schedule
+```
+
+## Failure handling
+
+Nothing is swallowed. A job that throws is reported to `onError`, after its
+retry policy is exhausted:
+
+```typescript
+scheduler.define({
+  id: "flaky",
+  name: "Flaky upstream call",
+  options: {
+    timeout: 10_000,
+    retry: {
+      attempts: 3,
+      strategy: "exponential", // or "fixed" | "linear"
+      delay: 1_000,
+      maxDelay: 30_000,
+      jitter: true,
+    },
   },
+  handler: callUpstream,
+});
+```
+
+A timeout raises `SchedulerJobTimeoutError` and **aborts the handler** via
+`ctx.signal`; anything else raises `SchedulerJobExecutionError` carrying the
+original error as `cause`.
+
+## Concurrency and overlap
+
+`maxConcurrency` (default 10) bounds executions in flight across all schedules;
+work over the ceiling waits for the next tick. Per schedule, `overlap` decides
+what happens when a fire time arrives while the previous run is still going:
+
+```typescript
+scheduler.every("10s", "report", { overlap: "skip" });
+```
+
+| `overlap`           | Behaviour when the previous run is still going  |
+| ------------------- | ----------------------------------------------- |
+| `"allow"` (default) | starts the new run alongside it                 |
+| `"skip"`            | drops the fire time                             |
+| `"queue"`           | holds it and runs it when the current one ends  |
+| `"replace"`         | aborts the running execution and starts a new one |
+
+`JobOptions.overlap` sets the default for every schedule of a job;
+`ScheduleOptions.overlap` overrides it per schedule.
+
+`JobOptions.concurrency` caps how many executions of one job run at once
+across every schedule that fires it. A fire time arriving at the ceiling is
+held and dispatched when an execution finishes, not dropped:
+
+```typescript
+scheduler.define({
+  id: "reindex",
+  name: "Reindex a tenant",
+  options: { concurrency: 2 },
+  handler: reindex,
 });
+```
 
-await scheduler.start();
+`ScheduleOptions.priority` breaks ties between schedules due at the same
+instant — higher runs first. It never lets a schedule jump ahead of one due
+earlier.
+
+## Misfires
+
+A fire time already in the past follows the schedule's `misfire` policy. This
+is the case for `at(pastDate)`, for a schedule restored after a restart, and
+for a recurring schedule whose process was blocked past its fire time.
+
+| `misfire`              | Behaviour                                            |
+| ---------------------- | ---------------------------------------------------- |
+| `"run-once"` (default) | runs once immediately, then resumes from now         |
+| `"skip"`               | refuses the schedule                                 |
+| `"catch-up"`           | replays every missed occurrence until it is current  |
+
+```typescript
+scheduler.every("1h", "hourly-rollup", { misfire: "catch-up" });
+```
+
+## Execution history
+
+The scheduler keeps the last 100 executions (`MAX_EXECUTION_HISTORY`), each a
+`JobExecution` with its status, timings and error:
+
+```typescript
+scheduler.getExecutions("cleanup");
+// [{ id, jobId, scheduleId, status: "completed" | "failed" | "timed_out" |
+//    "cancelled" | "running", scheduledAt, startedAt, completedAt,
+//    duration, attempt, error? }]
 ```
 
 ## Features
 
-- Cron-like job scheduling
-- Persistent job storage
-- Worker management
-- Job retry and backoff
-- Job history and logs
+- Delay, date, interval and cron triggers
+- Real five-field cron parsing with macros, ranges, steps and names
+- Bound schedule handles: pause, resume, cancel, next-run
+- Retry policies with fixed, linear and exponential backoff, capping and jitter
+- Per-job timeouts that abort the handler through `AbortSignal`
+- Global concurrency ceiling, per-job concurrency limits, and per-schedule
+  overlap and misfire policies
+- Bounded execution history
+- Graceful shutdown with abort or drain
+- Min-heap priority queue, O(log n) insert and remove
+
+## Not included
+
+This package schedules work inside one process. It has no persistence, no
+cross-process locking and no worker pool — a restart loses the schedule, and two
+instances will each run the same job. Pair it with `@zudojs/queue` when you need
+durability or distribution.
+
+Because there is no store and no lock, the store, lock, not-started and
+schedule-lookup error classes are not re-exported here; they live in
+`@zudojs/errors` for a durable scheduler built on top.
 
 ## Use Cases
 
-- Scheduled maintenance tasks
+- Scheduled maintenance and cleanup
+- Periodic synchronisation
 - Report generation
-- Data cleanup jobs
-- Periodic synchronization
+- Cache warming and refresh

package/dist/index.d.ts

@@ -24,17 +24,21 @@
  * ```
  */
 export type { SchedulerJobId, ScheduleId, ExecutionId, ScheduleType, ScheduleState, JobState, OverlapPolicy, MisfirePolicy, RetryStrategy, RetryPolicy, JobOptions, JobDefinition, JobHandler, JobContext, JobExecution, JobExecutionResult, Schedule, ScheduleOptions, ScheduleHandle, Trigger, } from "./scheduler/types/index.js";
-export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, SCHEDULER_TICK_INTERVAL, } from "./scheduler/constants/index.js";
+export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, } from "./scheduler/constants/index.js";
 export type { SchedulerErrorOptions } from "./scheduler/errors/index.js";
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "./scheduler/errors/index.js";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "./scheduler/errors/index.js";
 export { createJobContext, createJobDefinition, } from "./scheduler/job/index.js";
 export { createSchedule } from "./scheduler/schedule/index.js";
 export { ScheduleHandleImpl } from "./scheduler/scheduleHandle/index.js";
+export type { ScheduleHandleBinding } from "./scheduler/scheduleHandle/index.js";
 export { DateTrigger, DelayTrigger, IntervalTrigger, CronTrigger, } from "./scheduler/trigger/index.js";
+export { parseCron, nextCronDate } from "./scheduler/trigger/index.js";
+export type { ParsedCron } from "./scheduler/trigger/index.js";
 export { SystemClock, createSystemClock } from "./scheduler/clock/index.js";
 export { JobRegistry } from "./scheduler/registry/index.js";
-export { JobExecutor } from "./scheduler/executor/index.js";
+export { JobExecutor, retryDelay } from "./scheduler/executor/index.js";
 export { PriorityQueue } from "./scheduler/priorityQueue/index.js";
 export { parseDuration } from "./scheduler/duration/index.js";
 export { Scheduler } from "./scheduler/scheduler.core.js";
+export type { SchedulerOptions, SchedulerErrorEvent, } from "./scheduler/scheduler.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -24,8 +24,8 @@
  * ```
  */
 // Constants
-export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, SCHEDULER_TICK_INTERVAL, } from "./scheduler/constants/index.js";
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "./scheduler/errors/index.js";
+export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, } from "./scheduler/constants/index.js";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "./scheduler/errors/index.js";
 // Job
 export { createJobContext, createJobDefinition, } from "./scheduler/job/index.js";
 // Schedule
@@ -34,12 +34,13 @@ export { createSchedule } from "./scheduler/schedule/index.js";
 export { ScheduleHandleImpl } from "./scheduler/scheduleHandle/index.js";
 // Trigger
 export { DateTrigger, DelayTrigger, IntervalTrigger, CronTrigger, } from "./scheduler/trigger/index.js";
+export { parseCron, nextCronDate } from "./scheduler/trigger/index.js";
 // Clock
 export { SystemClock, createSystemClock } from "./scheduler/clock/index.js";
 // Registry
 export { JobRegistry } from "./scheduler/registry/index.js";
 // Executor
-export { JobExecutor } from "./scheduler/executor/index.js";
+export { JobExecutor, retryDelay } from "./scheduler/executor/index.js";
 // Priority Queue
 export { PriorityQueue } from "./scheduler/priorityQueue/index.js";
 // Duration

package/dist/scheduler/constants/index.d.ts

@@ -1,2 +1,2 @@
-export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, SCHEDULER_TICK_INTERVAL, } from "./schedulerConstants.core.js";
+export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, } from "./schedulerConstants.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/constants/index.js

@@ -1,2 +1,2 @@
-export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, SCHEDULER_TICK_INTERVAL, } from "./schedulerConstants.core.js";
+export { DEFAULT_JOB_TIMEOUT, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, MAX_TIMER_DELAY, MAX_JOBS, MAX_SCHEDULES, MAX_EXECUTION_HISTORY, DEFAULT_MISFIRE_POLICY, DEFAULT_OVERLAP_POLICY, } from "./schedulerConstants.core.js";
 //# sourceMappingURL=index.js.map

package/dist/scheduler/constants/schedulerConstants.core.d.ts

@@ -45,8 +45,4 @@ export declare const DEFAULT_MISFIRE_POLICY: MisfirePolicy;
  * Default overlap policy.
  */
 export declare const DEFAULT_OVERLAP_POLICY: OverlapPolicy;
-/**
- * Tick interval for the scheduler timer (1 second).
- */
-export declare const SCHEDULER_TICK_INTERVAL = 1000;
 //# sourceMappingURL=schedulerConstants.core.d.ts.map

package/dist/scheduler/constants/schedulerConstants.core.js

@@ -43,8 +43,4 @@ export const DEFAULT_MISFIRE_POLICY = "run-once";
  * Default overlap policy.
  */
 export const DEFAULT_OVERLAP_POLICY = "allow";
-/**
- * Tick interval for the scheduler timer (1 second).
- */
-export const SCHEDULER_TICK_INTERVAL = 1_000;
 //# sourceMappingURL=schedulerConstants.core.js.map

package/dist/scheduler/duration/duration.parser.d.ts

@@ -1,11 +1,19 @@
 /**
  * Parses a human-readable duration string into milliseconds.
  *
- * Supported formats:
- * - "5s" - 5 seconds
- * - "10m" - 10 minutes
- * - "2h" - 2 hours
- * - "3d" - 3 days
+ * Supported units: `ms`, `s`, `m`, `h`, `d`, `w`. Components may be combined
+ * (`"1h30m"`), and each must be a non-negative integer. The total must be
+ * greater than zero — a zero duration would schedule a job that fires
+ * continuously — and within roughly a century.
+ *
+ * @example
+ * parseDuration("5s")     // 5000
+ * parseDuration("1h30m")  // 5400000
+ * parseDuration("250ms")  // 250
+ *
+ * @param duration - The duration string.
+ * @returns The duration in milliseconds.
+ * @throws {InvalidDurationError} when the string is malformed or out of range.
  */
 export declare function parseDuration(duration: string): number;
 //# sourceMappingURL=duration.parser.d.ts.map

package/dist/scheduler/duration/duration.parser.js

@@ -1,31 +1,69 @@
 import { InvalidDurationError } from "../errors/scheduler.errors.js";
+/**
+ * Largest duration that can safely be added to "now" and still produce a valid
+ * Date. Beyond this the result is an Invalid Date whose `getTime()` is `NaN`,
+ * and every heap comparison against `NaN` is false — so the entry never sinks
+ * and parks itself at the head of the queue, blocking everything behind it.
+ */
+const MAX_DURATION_MS = 100 * 365 * 24 * 60 * 60 * 1000; // ~100 years
+/** Milliseconds per supported unit. */
+const UNIT_MS = {
+    ms: 1,
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+};
 /**
  * Parses a human-readable duration string into milliseconds.
  *
- * Supported formats:
- * - "5s" - 5 seconds
- * - "10m" - 10 minutes
- * - "2h" - 2 hours
- * - "3d" - 3 days
+ * Supported units: `ms`, `s`, `m`, `h`, `d`, `w`. Components may be combined
+ * (`"1h30m"`), and each must be a non-negative integer. The total must be
+ * greater than zero — a zero duration would schedule a job that fires
+ * continuously — and within roughly a century.
+ *
+ * @example
+ * parseDuration("5s")     // 5000
+ * parseDuration("1h30m")  // 5400000
+ * parseDuration("250ms")  // 250
+ *
+ * @param duration - The duration string.
+ * @returns The duration in milliseconds.
+ * @throws {InvalidDurationError} when the string is malformed or out of range.
  */
 export function parseDuration(duration) {
-    const match = duration.match(/^(\d+)(s|m|h|d)$/);
-    if (!match) {
+    const trimmed = duration.trim();
+    if (trimmed.length === 0) {
         throw new InvalidDurationError(duration);
     }
-    const value = Number(match[1]);
-    const unit = match[2];
-    switch (unit) {
-        case "s":
-            return value * 1000;
-        case "m":
-            return value * 60 * 1000;
-        case "h":
-            return value * 60 * 60 * 1000;
-        case "d":
-            return value * 24 * 60 * 60 * 1000;
-        default:
+    // Each component is digits followed by a unit. `ms` is matched before `m`.
+    // Sticky, not global: a failed component ends the loop instead of rescanning
+    // from the next offset, so a long digit run cannot be re-matched per offset.
+    // (`g` alongside `y` was redundant — sticky already wins for `exec`.)
+    const pattern = /(\d+)(ms|s|m|h|d|w)/y; // codeql[js/polynomial-redos]
+    let total = 0;
+    let matched = 0;
+    let match;
+    while ((match = pattern.exec(trimmed)) !== null) {
+        const amount = Number(match[1]);
+        const unit = match[2];
+        if (!Number.isSafeInteger(amount)) {
+            throw new InvalidDurationError(duration);
+        }
+        total += amount * UNIT_MS[unit];
+        matched = pattern.lastIndex;
+        if (total > MAX_DURATION_MS) {
             throw new InvalidDurationError(duration);
+        }
+    }
+    // Anything left over means the string was not fully consumed.
+    if (matched !== trimmed.length) {
+        throw new InvalidDurationError(duration);
+    }
+    if (total <= 0) {
+        throw new InvalidDurationError(duration);
     }
+    return total;
 }
 //# sourceMappingURL=duration.parser.js.map

package/dist/scheduler/errors/index.d.ts

@@ -1,3 +1,3 @@
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "./scheduler.errors.js";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "./scheduler.errors.js";
 export type { SchedulerErrorOptions } from "./scheduler.errors.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/errors/index.js

@@ -1,2 +1,2 @@
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "./scheduler.errors.js";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "./scheduler.errors.js";
 //# sourceMappingURL=index.js.map

package/dist/scheduler/errors/scheduler.errors.d.ts

@@ -4,7 +4,13 @@
  * Scheduler-specific error classes for the Zudojs framework.
  *
  * Re-exported from @zudojs/errors for convenience.
+ *
+ * Only the classes this package can actually raise are re-exported. The
+ * store, lock, not-started and schedule-lookup errors were re-exported here
+ * too, and nothing in an in-process scheduler with no persistence and no
+ * cross-process locking could ever throw one. They remain available from
+ * @zudojs/errors for a durable scheduler built on top.
  */
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "@zudojs/errors";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "@zudojs/errors";
 export type { SchedulerErrorOptions } from "@zudojs/errors";
 //# sourceMappingURL=scheduler.errors.d.ts.map

package/dist/scheduler/errors/scheduler.errors.js

@@ -4,6 +4,12 @@
  * Scheduler-specific error classes for the Zudojs framework.
  *
  * Re-exported from @zudojs/errors for convenience.
+ *
+ * Only the classes this package can actually raise are re-exported. The
+ * store, lock, not-started and schedule-lookup errors were re-exported here
+ * too, and nothing in an in-process scheduler with no persistence and no
+ * cross-process locking could ever throw one. They remain available from
+ * @zudojs/errors for a durable scheduler built on top.
  */
-export { SchedulerError, SchedulerNotStartedError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, ScheduleNotFoundError, ScheduleAlreadyExistsError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, SchedulerStoreError, SchedulerLockError, createSchedulerError, isSchedulerError, } from "@zudojs/errors";
+export { SchedulerError, SchedulerAlreadyStartedError, SchedulerStoppedError, SchedulerJobNotFoundError, SchedulerJobAlreadyExistsError, InvalidJobError, InvalidScheduleError, CronParseError, InvalidDurationError, SchedulerJobExecutionError, SchedulerJobTimeoutError, SchedulerJobCancelledError, createSchedulerError, isSchedulerError, } from "@zudojs/errors";
 //# sourceMappingURL=scheduler.errors.js.map

package/dist/scheduler/executor/index.d.ts

@@ -1,2 +1,2 @@
-export { JobExecutor } from "./jobExecutor.core.js";
+export { JobExecutor, retryDelay } from "./jobExecutor.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/executor/index.js

@@ -1,2 +1,2 @@
-export { JobExecutor } from "./jobExecutor.core.js";
+export { JobExecutor, retryDelay } from "./jobExecutor.core.js";
 //# sourceMappingURL=index.js.map

package/dist/scheduler/executor/jobExecutor.core.d.ts

@@ -1,19 +1,39 @@
 import type { JobDefinition } from "../job/jobDefinition.type.js";
+import type { RetryPolicy } from "../job/jobOptions.type.js";
 import type { JobExecutionResult } from "../types/schedulerTypes.core.js";
 import type { Clock } from "../clock/schedulerClock.type.js";
 /**
- * Executes a job with timeout support.
+ * Executes a job with timeout, cancellation and retry support.
  */
 export declare class JobExecutor {
     private readonly clock;
     constructor(clock: Clock);
     /**
-     * Executes a job.
+     * Executes a job, retrying according to its retry policy.
+     *
+     * @param job - The job definition.
+     * @param executionId - Identifier for this execution.
+     * @param scheduledAt - The time the job was scheduled to run.
+     * @param attempt - The attempt number to start from (1-based).
+     * @param signal - Signal that aborts the job and stops further retries.
+     * @param data - Optional payload handed to the handler.
+     * @returns The execution result.
      */
-    execute(job: JobDefinition, executionId: string, scheduledAt: Date, attempt: number, signal: AbortSignal): Promise<JobExecutionResult>;
+    execute(job: JobDefinition, executionId: string, scheduledAt: Date, attempt: number, signal: AbortSignal, data?: unknown): Promise<JobExecutionResult>;
+    /** Runs the handler once, under a timeout that also aborts it. */
+    private runOnce;
+    /** Maps a thrown value onto the scheduler's error taxonomy. */
+    private classify;
     /**
-     * Wraps a promise with a timeout using AbortSignal.
+     * Wraps an operation with a timeout that aborts it.
      */
     private withTimeout;
 }
+/**
+ * Computes the delay before the next retry attempt.
+ *
+ * `RetryPolicy` has carried strategy, delay, maxDelay and jitter since the
+ * package was written; none of it was ever applied.
+ */
+export declare function retryDelay(policy: RetryPolicy | undefined, attempt: number): number;
 //# sourceMappingURL=jobExecutor.core.d.ts.map