@warlock.js/scheduler 5.29.0 → 5.31.0

package/skills/index.md

@@ -1,11 +1,13 @@
 ---
-description: "In-process job scheduler for Warlock.js with fluent and cron scheduling, retries, overlap prevention and timezones. Exports `Scheduler`, `scheduler`, `Job`, `job`, `CronParser`, `parseCron`, plus types `RetryConfig`, `JobResult`, `SchedulerEvents`. Use for: \"run this every day at 3am\", \"run a cron expression on weekdays\", \"retry a failing job 3 times\", \"stop a job overlapping itself\", \"run in New York time\", \"log job failures\". Not this package: durable queues and background workers are not scheduling; per-run locking across instances uses @warlock.js/cache."
+description: 'In-process job scheduler for Warlock.js with fluent and cron scheduling, retries, overlap prevention and timezones. Exports `Scheduler`, `scheduler`, `Job`, `job`, `CronParser`, `parseCron`, plus types `RetryConfig`, `JobResult`, `SchedulerEvents`. Use for: "run this every day at 3am", "run a cron expression on weekdays", "retry a failing job 3 times", "stop a job overlapping itself", "run in New York time", "log job failures". Not this package: durable queues and background workers are not scheduling; per-run locking across instances uses @warlock.js/cache.'
 ---
+
 # @warlock.js/scheduler
 
 Build a `job(name, fn)`, describe when it runs with the fluent API (`.daily().at("03:00")`) or `.cron("...")`, add it to a `Scheduler`, then `start()`. Events (`job:error` and others) provide observability; `shutdown()` stops gracefully.
 
 ## The 80% path
+
 1. Orient: `overview.md`, `scheduler-basics.md`.
 2. Define the schedule fluently: `schedule-fluently.md`, or by cron: `schedule-with-cron.md`.
 3. Make it resilient: `configure-retry-and-overlap.md`.
@@ -13,6 +15,7 @@ Build a `job(name, fn)`, describe when it runs with the fluent API (`.daily().at
 5. Watch it run: `observe-scheduler.md`.
 
 ## Conventions and pitfalls
+
 - It is in-memory and per-process: each app instance runs its own copy. With multiple instances, guard jobs with a lock (for example `@warlock.js/cache`) or run the scheduler in one instance only.
 - Missed runs while the process was down are not replayed.
 - Set a timezone explicitly for jobs tied to business hours; otherwise the host's applies.

package/skills/observe-scheduler/SKILL.md

@@ -11,25 +11,25 @@ The `Scheduler` extends Node's `EventEmitter` with a fully-typed surface. Wire l
 
 ```ts
 type SchedulerEvents = {
-  "job:start":         [jobName: string];
-  "job:complete":      [jobName: string, result: JobResult];
-  "job:error":         [jobName: string, error: unknown];
-  "job:skip":          [jobName: string, reason: string];
+  "job:start": [jobName: string];
+  "job:complete": [jobName: string, result: JobResult];
+  "job:error": [jobName: string, error: unknown];
+  "job:skip": [jobName: string, reason: string];
   "scheduler:started": [];
   "scheduler:stopped": [];
-  "scheduler:tick":    [timestamp: Date];
+  "scheduler:tick": [timestamp: Date];
 };
 ```
 
-| Event                | When it fires                                                                          |
-| -------------------- | -------------------------------------------------------------------------------------- |
-| `scheduler:started`  | Once, after `.start()` enters the tick loop                                            |
-| `scheduler:stopped`  | When `.stop()` halts the loop. Not emitted if `.stop()` was a no-op (never started)    |
-| `scheduler:tick`     | Every tick — once per `runEvery()` interval (default 1 s). Keep handlers lightweight.  |
-| `job:start`          | Just before a job's callback is first invoked (NOT once per retry)                     |
-| `job:complete`       | When a job finishes successfully (possibly after retries)                              |
-| `job:error`          | When a job exhausts all retries and the final attempt still throws                     |
-| `job:skip`           | When a tick finds the job already running (see retry-and-overlap for when this occurs) |
+| Event               | When it fires                                                                          |
+| ------------------- | -------------------------------------------------------------------------------------- |
+| `scheduler:started` | Once, after `.start()` enters the tick loop                                            |
+| `scheduler:stopped` | When `.stop()` halts the loop. Not emitted if `.stop()` was a no-op (never started)    |
+| `scheduler:tick`    | Every tick — once per `runEvery()` interval (default 1 s). Keep handlers lightweight.  |
+| `job:start`         | Just before a job's callback is first invoked (NOT once per retry)                     |
+| `job:complete`      | When a job finishes successfully (possibly after retries)                              |
+| `job:error`         | When a job exhausts all retries and the final attempt still throws                     |
+| `job:skip`          | When a tick finds the job already running (see retry-and-overlap for when this occurs) |
 
 **Contract for retries.** `job:start` and `job:complete`/`job:error` fire **once per fire**, not once per retry attempt. The retry count surfaces inside the `JobResult` passed to `job:complete`, or as `result.retries === maxRetries` on the failure path.
 
@@ -38,9 +38,9 @@ type SchedulerEvents = {
 ```ts
 type JobResult = {
   success: boolean;
-  duration: number;    // milliseconds, end-to-end including retry waits
-  error?: unknown;     // present when success === false
-  retries?: number;    // attempts that failed before the final outcome
+  duration: number; // milliseconds, end-to-end including retry waits
+  error?: unknown; // present when success === false
+  retries?: number; // attempts that failed before the final outcome
 };
 ```
 
@@ -52,12 +52,12 @@ type JobResult = {
 import type { JobResult } from "@warlock.js/scheduler";
 import { scheduler } from "@warlock.js/scheduler";
 
-scheduler.on("job:start",    name           => log.debug({ name }, "job start"));
+scheduler.on("job:start", (name) => log.debug({ name }, "job start"));
 scheduler.on("job:complete", (name, result: JobResult) => {
   log.info({ name, duration: result.duration, retries: result.retries }, "job complete");
 });
-scheduler.on("job:error",    (name, error)  => log.error({ name, error }, "job failed"));
-scheduler.on("job:skip",     (name, reason) => log.warn({ name, reason }, "job skipped"));
+scheduler.on("job:error", (name, error) => log.error({ name, error }, "job failed"));
+scheduler.on("job:skip", (name, reason) => log.warn({ name, reason }, "job skipped"));
 ```
 
 `.on()`, `.once()`, `.off()` are all type-narrowed via `SchedulerEvents`.
@@ -69,6 +69,7 @@ scheduler.on("job:skip",     (name, reason) => log.warn({ name, reason }, "job s
 Prepares every registered job (computes initial `nextRun`) and enters the tick loop. Emits `scheduler:started`.
 
 Throws if:
+
 - already running (`"Scheduler is already running."`)
 - zero jobs registered (`"Cannot start scheduler with no jobs."`)
 
@@ -104,7 +105,7 @@ import { logger } from "./logger";
 import { metrics } from "./metrics";
 import { alerts } from "./alerts";
 
-scheduler.on("job:start", name => metrics.increment(`job.start.${name}`));
+scheduler.on("job:start", (name) => metrics.increment(`job.start.${name}`));
 
 scheduler.on("job:complete", (name, result) => {
   metrics.increment(`job.success.${name}`);
@@ -131,20 +132,20 @@ scheduler.start();
 ## Inspection at runtime
 
 ```ts
-scheduler.isRunning;             // boolean
-scheduler.jobCount;              // number of registered jobs
-scheduler.list();                // readonly Job[]
-scheduler.getJob("name");        // Job | undefined
+scheduler.isRunning; // boolean
+scheduler.jobCount; // number of registered jobs
+scheduler.list(); // readonly Job[]
+scheduler.getJob("name"); // Job | undefined
 ```
 
 And on each `Job`:
 
 ```ts
-job.nextRun;                     // Dayjs | null
-job.lastRun;                     // Dayjs | null — success OR failure
-job.isRunning;                   // boolean
-job.intervals;                   // readonly schedule config
-job.cronExpression;              // string | null
+job.nextRun; // Dayjs | null
+job.lastRun; // Dayjs | null — success OR failure
+job.isRunning; // boolean
+job.intervals; // readonly schedule config
+job.cronExpression; // string | null
 ```
 
 ## See also

package/skills/overview/SKILL.md

@@ -30,27 +30,33 @@ Six task skills cover the full surface. Most callers only need `scheduler-basics
 ### Foundations
 
 #### `scheduler-basics`
+
 Start here. The `job(name, fn)` factory, the `scheduler` singleton, the 2-primitive surface, UTC default, why the API is factory-first.
 
 ### Scheduling
 
 #### `schedule-fluently`
+
 Build schedules without writing cron: `.everyMinutes(N)`, `.daily().at("03:00")`, `.weekly().on("monday")`, `.monthly()`, `.beginOf("month")`, `.endOf("year")`, and friends. Reach for this 80% of the time.
 
 #### `schedule-with-cron`
+
 Drop down to `.cron("0 9 * * 1-5")` when the fluent API can't express it (Vixie OR semantics for DOM/DOW, complex multi-value lists). Includes `parseCron()` for previewing next-run times before deploy.
 
 ### Production concerns
 
 #### `configure-retry-and-overlap`
+
 `.retry(maxRetries, delay?, backoffMultiplier?)` for fixed or exponential backoff; `.preventOverlap()` so a slow run never collides with the next tick. Reach for both anytime a job calls external services.
 
 #### `pin-schedule-timezone`
+
 `.inTimezone("America/New_York")` pins wall-clock fire times across DST and across servers. The default is UTC — if your job description includes "9 AM," you almost certainly want this skill.
 
 ### Observability + shutdown
 
 #### `observe-scheduler`
+
 The seven typed `SchedulerEvents` (`job:start` / `complete` / `error` / `skip`, `scheduler:started` / `stopped` / `tick`), the `JobResult` payload, `start()` / `stop()` / `shutdown()`. Wire this for logging, metrics, alerting, and graceful SIGTERM handling.
 
 ## Quick taste

package/skills/pin-schedule-timezone/SKILL.md

@@ -10,10 +10,7 @@ Every `Job` has its own timezone. The default is **UTC** — `.daily().at("09:00
 ## Basic usage
 
 ```ts
-job("morning-digest", sendDailyDigest)
-  .daily()
-  .at("08:00")
-  .inTimezone("America/New_York");   // 8 AM ET, not 8 AM UTC
+job("morning-digest", sendDailyDigest).daily().at("08:00").inTimezone("America/New_York"); // 8 AM ET, not 8 AM UTC
 ```
 
 `.inTimezone()` is chainable — typically placed after the time/day methods.
@@ -30,9 +27,9 @@ Same logical task, three regions:
 import { scheduler, job } from "@warlock.js/scheduler";
 
 const regions = [
-  { name: "us-east",   tz: "America/New_York" },
-  { name: "eu-west",   tz: "Europe/Berlin" },
-  { name: "asia",      tz: "Asia/Tokyo" },
+  { name: "us-east", tz: "America/New_York" },
+  { name: "eu-west", tz: "Europe/Berlin" },
+  { name: "asia", tz: "Asia/Tokyo" },
 ];
 
 for (const { name, tz } of regions) {
@@ -40,7 +37,7 @@ for (const { name, tz } of regions) {
     job(`morning-report-${name}`, () => sendReport(name))
       .daily()
       .at("09:00")
-      .inTimezone(tz)
+      .inTimezone(tz),
   );
 }
 
@@ -55,20 +52,20 @@ dayjs handles transitions correctly. A daily 09:00 job in `America/New_York` shi
 
 ## Common IANA strings
 
-| Region              | TZ string                   |
-| ------------------- | --------------------------- |
-| UTC                 | `UTC`                       |
-| US Eastern          | `America/New_York`          |
-| US Central          | `America/Chicago`           |
-| US Mountain         | `America/Denver`            |
-| US Pacific          | `America/Los_Angeles`       |
-| UK / Ireland        | `Europe/London`             |
-| Central Europe      | `Europe/Berlin`             |
-| Eastern Europe      | `Europe/Kyiv`               |
-| India               | `Asia/Kolkata`              |
-| Japan               | `Asia/Tokyo`                |
-| Australia (Sydney)  | `Australia/Sydney`          |
-| Egypt               | `Africa/Cairo`              |
+| Region             | TZ string             |
+| ------------------ | --------------------- |
+| UTC                | `UTC`                 |
+| US Eastern         | `America/New_York`    |
+| US Central         | `America/Chicago`     |
+| US Mountain        | `America/Denver`      |
+| US Pacific         | `America/Los_Angeles` |
+| UK / Ireland       | `Europe/London`       |
+| Central Europe     | `Europe/Berlin`       |
+| Eastern Europe     | `Europe/Kyiv`         |
+| India              | `Asia/Kolkata`        |
+| Japan              | `Asia/Tokyo`          |
+| Australia (Sydney) | `Australia/Sydney`    |
+| Egypt              | `Africa/Cairo`        |
 
 Full list: [IANA Time Zone Database](https://www.iana.org/time-zones).
 
@@ -77,17 +74,11 @@ Full list: [IANA Time Zone Database](https://www.iana.org/time-zones).
 The timezone applies to every interpretation of "now" and every constraint:
 
 ```ts
-job("monday-standup", task)
-  .weekly()
-  .on("monday")
-  .at("09:00")
-  .inTimezone("Europe/Berlin");
+job("monday-standup", task).weekly().on("monday").at("09:00").inTimezone("Europe/Berlin");
 // "Monday in Berlin local time" + "09:00 Berlin local time"
 // — automatically shifts CET ↔ CEST as DST changes.
 
-job("nightly-cron", task)
-  .cron("0 3 * * *")
-  .inTimezone("Asia/Tokyo");
+job("nightly-cron", task).cron("0 3 * * *").inTimezone("Asia/Tokyo");
 // "0 3 * * *" interpreted in Tokyo local time → 03:00 JST = 18:00 UTC.
 ```
 

package/skills/schedule-fluently/SKILL.md

@@ -9,24 +9,24 @@ Chainable methods on a `Job` instance. Each method returns `this` for chaining;
 
 ## Preset intervals
 
-| Method               | Equivalent of            | Notes                          |
-| -------------------- | ------------------------ | ------------------------------ |
-| `.everySecond()`     | `.every(1, "second")`    | High frequency — use sparingly |
-| `.everySeconds(N)`   | `.every(N, "second")`    |                                |
-| `.everyMinute()`     | `.every(1, "minute")`    |                                |
-| `.everyMinutes(N)`   | `.every(N, "minute")`    |                                |
-| `.everyHour()`       | `.every(1, "hour")`      |                                |
-| `.everyHours(N)`     | `.every(N, "hour")`      |                                |
-| `.everyDay()`        | `.every(1, "day")`       | Same as `.daily()`             |
-| `.daily()`           | `.every(1, "day")`       |                                |
-| `.twiceDaily()`      | `.every(12, "hour")`     | Every 12 hours                 |
-| `.everyWeek()`       | `.every(1, "week")`      | Same as `.weekly()`            |
-| `.weekly()`          | `.every(1, "week")`      |                                |
-| `.everyMonth()`      | `.every(1, "month")`     | Same as `.monthly()`           |
-| `.monthly()`         | `.every(1, "month")`     |                                |
-| `.everyYear()`       | `.every(1, "year")`      | Same as `.yearly()`            |
-| `.yearly()`          | `.every(1, "year")`      |                                |
-| `.always()`          | `.every(1, "minute")`    | Continuous "tick" jobs         |
+| Method             | Equivalent of         | Notes                          |
+| ------------------ | --------------------- | ------------------------------ |
+| `.everySecond()`   | `.every(1, "second")` | High frequency — use sparingly |
+| `.everySeconds(N)` | `.every(N, "second")` |                                |
+| `.everyMinute()`   | `.every(1, "minute")` |                                |
+| `.everyMinutes(N)` | `.every(N, "minute")` |                                |
+| `.everyHour()`     | `.every(1, "hour")`   |                                |
+| `.everyHours(N)`   | `.every(N, "hour")`   |                                |
+| `.everyDay()`      | `.every(1, "day")`    | Same as `.daily()`             |
+| `.daily()`         | `.every(1, "day")`    |                                |
+| `.twiceDaily()`    | `.every(12, "hour")`  | Every 12 hours                 |
+| `.everyWeek()`     | `.every(1, "week")`   | Same as `.weekly()`            |
+| `.weekly()`        | `.every(1, "week")`   |                                |
+| `.everyMonth()`    | `.every(1, "month")`  | Same as `.monthly()`           |
+| `.monthly()`       | `.every(1, "month")`  |                                |
+| `.everyYear()`     | `.every(1, "year")`   | Same as `.yearly()`            |
+| `.yearly()`        | `.every(1, "year")`   |                                |
+| `.always()`        | `.every(1, "minute")` | Continuous "tick" jobs         |
 
 ## Custom intervals — `.every(value, unit)`
 
@@ -44,7 +44,7 @@ Units: `"second" | "minute" | "hour" | "day" | "week" | "month" | "year"`.
 
 ```ts
 job("nightly", fn).daily().at("03:00");
-job("midday",  fn).daily().at("12:30:15");
+job("midday", fn).daily().at("12:30:15");
 ```
 
 **Validation.** `.at()` throws if the format is malformed (`"foo"`, `"9-30"`), or any component is out of range (hour > 23, minute > 59, second > 59).
@@ -56,7 +56,7 @@ Day-of-week (string) or day-of-month (number 1–31):
 ```ts
 job("monday-standup", task).weekly().on("monday");
 job("mid-month-sync", task).monthly().on(15);
-job("end-of-month",   task).monthly().on(31);    // see beginOf/endOf for the right way
+job("end-of-month", task).monthly().on(31); // see beginOf/endOf for the right way
 ```
 
 Valid day-of-week strings: `"sunday"`, `"monday"`, `"tuesday"`, `"wednesday"`, `"thursday"`, `"friday"`, `"saturday"`.
@@ -69,14 +69,14 @@ Valid day-of-week strings: `"sunday"`, `"monday"`, `"tuesday"`, `"wednesday"`, `
 
 Both accept `"day" | "month" | "year"`.
 
-| Method               | Fires at                                          |
-| -------------------- | ------------------------------------------------- |
-| `beginOf("day")`     | 00:00 every day                                   |
-| `endOf("day")`       | 23:59 every day                                   |
-| `beginOf("month")`   | 1st of every month at 00:00                       |
-| `endOf("month")`     | Last day of every month at 23:59 (**dynamic**)    |
-| `beginOf("year")`    | January 1 at 00:00 every year                     |
-| `endOf("year")`      | December 31 at 23:59 every year                   |
+| Method             | Fires at                                       |
+| ------------------ | ---------------------------------------------- |
+| `beginOf("day")`   | 00:00 every day                                |
+| `endOf("day")`     | 23:59 every day                                |
+| `beginOf("month")` | 1st of every month at 00:00                    |
+| `endOf("month")`   | Last day of every month at 23:59 (**dynamic**) |
+| `beginOf("year")`  | January 1 at 00:00 every year                  |
+| `endOf("year")`    | December 31 at 23:59 every year                |
 
 **`endOf("month")` is dynamic** — recomputes per cycle, so a job defined in February (28 days) still fires on March 31, April 30, etc. Leap years pick Feb 29 correctly.
 
@@ -92,12 +92,12 @@ Every fluent method recomputes `nextRun` at the end. Putting `.at()` before `.da
 
 ```ts
 job("good", fn)
-  .weekly()              // interval
-  .on("monday")          // day
-  .at("09:00")           // time
-  .inTimezone("UTC")     // timezone
-  .preventOverlap()      // execution
-  .retry(3, 1000);       // execution
+  .weekly() // interval
+  .on("monday") // day
+  .at("09:00") // time
+  .inTimezone("UTC") // timezone
+  .preventOverlap() // execution
+  .retry(3, 1000); // execution
 ```
 
 ## Inline registration — `scheduler.newJob()`
@@ -105,10 +105,7 @@ job("good", fn)
 For one-liners, the scheduler exposes a `newJob()` shortcut that creates, registers, and returns the job in one call:
 
 ```ts
-scheduler
-  .newJob("cleanup", cleanupFn)
-  .daily()
-  .at("03:00");
+scheduler.newJob("cleanup", cleanupFn).daily().at("03:00");
 ```
 
 To register several pre-built jobs at once, `scheduler.addJobs([...])` is the batch counterpart to `addJob` (both are chainable and preserve insertion order):
@@ -127,11 +124,11 @@ If the scheduler is already running, every job added via `addJob` / `addJobs` is
 ```ts
 const j = scheduler.getJob("nightly-cleanup");
 
-j?.nextRun?.toISOString();   // next scheduled run (Dayjs)
-j?.lastRun?.toISOString();   // last attempt — success OR failure
-j?.isRunning;                // currently executing?
-j?.intervals;                // { every?, day?, dayOfMonthMode?, month?, time? } (readonly)
-j?.cronExpression;           // null if using fluent API
+j?.nextRun?.toISOString(); // next scheduled run (Dayjs)
+j?.lastRun?.toISOString(); // last attempt — success OR failure
+j?.isRunning; // currently executing?
+j?.intervals; // { every?, day?, dayOfMonthMode?, month?, time? } (readonly)
+j?.cronExpression; // null if using fluent API
 ```
 
 ## See also

package/skills/schedule-with-cron/SKILL.md

@@ -23,14 +23,14 @@ The escape hatch when the fluent API can't express a schedule. Activating `.cron
 
 ## Operators
 
-| Syntax    | Meaning                       | Example          |
-| --------- | ----------------------------- | ---------------- |
-| `*`       | Any value (full range)        | `* * * * *`      |
-| `5`       | Single value                  | `30 14 * * *`    |
-| `1,3,5`   | List                          | `0,30 * * * *`   |
-| `1-5`     | Inclusive range               | `0 9-17 * * *`   |
-| `*/N`     | Step over the wildcard        | `*/5 * * * *`    |
-| `A-B/N`   | Step over a range             | `0 1-10/2 * * *` |
+| Syntax  | Meaning                | Example          |
+| ------- | ---------------------- | ---------------- |
+| `*`     | Any value (full range) | `* * * * *`      |
+| `5`     | Single value           | `30 14 * * *`    |
+| `1,3,5` | List                   | `0,30 * * * *`   |
+| `1-5`   | Inclusive range        | `0 9-17 * * *`   |
+| `*/N`   | Step over the wildcard | `*/5 * * * *`    |
+| `A-B/N` | Step over a range      | `0 1-10/2 * * *` |
 
 **Not supported (yet):** named tokens (`MON-FRI`, `JAN-DEC`), special strings (`@daily`, `@hourly`, `@reboot`), seconds field (6-field), Quartz modifiers (`L`, `W`, `#`).
 
@@ -102,13 +102,13 @@ import dayjs from "dayjs";
 
 const parser = parseCron("0 9 * * 1-5");
 
-parser.nextRun().toISOString();              // next weekday at 9 AM
+parser.nextRun().toISOString(); // next weekday at 9 AM
 parser.nextRun(dayjs("2026-12-31")).format(); // from a specific anchor
 
-parser.matches(dayjs());                     // is "now" a fire moment?
+parser.matches(dayjs()); // is "now" a fire moment?
 
-parser.fields;                                // parsed numeric arrays
-parser.expression;                            // original string
+parser.fields; // parsed numeric arrays
+parser.expression; // original string
 ```
 
 Impossible expressions are rejected eagerly at construction (see Validation), so `nextRun(from?)` always resolves a satisfiable expression within a year — its one-year scan bound is just a defensive backstop, never the path that catches a bad expression.

package/skills/scheduler-basics/SKILL.md

@@ -36,7 +36,7 @@ The 9 things that are true in every scheduler use:
 6. **Validation throws at definition time.** `every(0)`, `at("24:00")`, `on(32)`, `retry(-1)`, malformed cron — all throw immediately when you wire the job, not at runtime.
 7. **`Job.run()` returns a `JobResult`, never throws.** Errors funnel into `result.error`. The scheduler emits `job:error` after all retries are exhausted.
 8. **Parallel mode is within a tick, not across.** Even with `runInParallel(true)`, the NEXT tick waits for the current tick's jobs to all settle.
-9. **Tick interval is drift-compensated.** A tick that takes 200 ms is followed by an 800 ms delay so the cadence between tick *starts* averages `tickInterval`, not `tickInterval + work-time`.
+9. **Tick interval is drift-compensated.** A tick that takes 200 ms is followed by an 800 ms delay so the cadence between tick _starts_ averages `tickInterval`, not `tickInterval + work-time`.
 
 ## 30-second example
 
@@ -53,7 +53,7 @@ scheduler.addJob(
     .at("03:00")
     .inTimezone("America/New_York")
     .preventOverlap()
-    .retry(3, 1000)
+    .retry(3, 1000),
 );
 
 scheduler.start();
@@ -79,13 +79,13 @@ scheduler.around((job, run) => storage.run({ job: job.name }, run));
 
 ## Pick a skill
 
-| If the task is about… | Load |
-| --- | --- |
-| Building schedules via `every*`/`daily`/`weekly`/`monthly`/`at`/`on`/`beginOf`/`endOf` | the `schedule-fluently` topic |
-| Writing `.cron("…")` expressions, debugging DOM/DOW behavior, using `parseCron()` for preview | the `schedule-with-cron` topic |
+| If the task is about…                                                                                 | Load                                    |
+| ----------------------------------------------------------------------------------------------------- | --------------------------------------- |
+| Building schedules via `every*`/`daily`/`weekly`/`monthly`/`at`/`on`/`beginOf`/`endOf`                | the `schedule-fluently` topic           |
+| Writing `.cron("…")` expressions, debugging DOM/DOW behavior, using `parseCron()` for preview         | the `schedule-with-cron` topic          |
 | Configuring `.retry()` / exponential backoff, `.preventOverlap()`, understanding failure rescheduling | the `configure-retry-and-overlap` topic |
-| Subscribing to scheduler events, reading `JobResult`, lifecycle, graceful shutdown | the `observe-scheduler` topic |
-| Per-job `.inTimezone()`, multi-region patterns, DST handling | the `pin-schedule-timezone` topic |
+| Subscribing to scheduler events, reading `JobResult`, lifecycle, graceful shutdown                    | the `observe-scheduler` topic           |
+| Per-job `.inTimezone()`, multi-region patterns, DST handling                                          | the `pin-schedule-timezone` topic       |
 
 ## When NOT to use this skill