@zudojs/scheduler 0.1.0 → 1.1.0

package/dist/scheduler/trigger/cron.parser.js

@@ -0,0 +1,256 @@
+/**
+ * @zudojs/scheduler/trigger/cron
+ *
+ * Standard five-field cron expression parsing and next-fire computation.
+ *
+ * Fields, in order: minute, hour, day-of-month, month, day-of-week.
+ * Each supports `*`, a value, a `a-b` range, a `a-b/n` or `*\/n` step, and a
+ * comma-separated list of any of those. Month and day-of-week also accept the
+ * usual three-letter names. A leading `@yearly`-style macro is expanded first.
+ */
+import { CronParseError } from "../errors/scheduler.errors.js";
+/** Inclusive bounds for each cron field. */
+const FIELD_BOUNDS = [
+    { name: "minute", min: 0, max: 59 },
+    { name: "hour", min: 0, max: 23 },
+    { name: "dayOfMonth", min: 1, max: 31 },
+    { name: "month", min: 1, max: 12 },
+    { name: "dayOfWeek", min: 0, max: 6 },
+];
+/** Named aliases accepted in the month field. */
+const MONTH_NAMES = {
+    jan: 1,
+    feb: 2,
+    mar: 3,
+    apr: 4,
+    may: 5,
+    jun: 6,
+    jul: 7,
+    aug: 8,
+    sep: 9,
+    oct: 10,
+    nov: 11,
+    dec: 12,
+};
+/** Named aliases accepted in the day-of-week field. */
+const DAY_NAMES = {
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6,
+};
+/** Shorthand macros. */
+const MACROS = {
+    "@yearly": "0 0 1 1 *",
+    "@annually": "0 0 1 1 *",
+    "@monthly": "0 0 1 * *",
+    "@weekly": "0 0 * * 0",
+    "@daily": "0 0 * * *",
+    "@midnight": "0 0 * * *",
+    "@hourly": "0 * * * *",
+};
+/** How far ahead {@link nextCronDate} will search before giving up. */
+const MAX_SEARCH_YEARS = 5;
+/**
+ * Parses a cron expression into the set of values each field permits.
+ *
+ * @param expression - A five-field cron expression or a supported macro.
+ * @returns The parsed expression.
+ * @throws {CronParseError} when the expression is not valid.
+ */
+export function parseCron(expression) {
+    const trimmed = expression.trim().toLowerCase();
+    if (trimmed.length === 0) {
+        throw new CronParseError("Cron expression cannot be empty", expression);
+    }
+    const expanded = MACROS[trimmed] ?? trimmed;
+    const fields = expanded.split(/\s+/);
+    if (fields.length !== 5) {
+        throw new CronParseError(`Cron expression must have 5 fields (minute hour day-of-month month day-of-week), got ${fields.length}`, expression);
+    }
+    const sets = FIELD_BOUNDS.map((bounds, index) => parseField(fields[index] ?? "", bounds, expression));
+    return {
+        minute: sets[0] ?? new Set(),
+        hour: sets[1] ?? new Set(),
+        dayOfMonth: sets[2] ?? new Set(),
+        month: sets[3] ?? new Set(),
+        dayOfWeek: sets[4] ?? new Set(),
+        dayOfMonthUnrestricted: (fields[2] ?? "") === "*",
+        dayOfWeekUnrestricted: (fields[4] ?? "") === "*",
+    };
+}
+/** Parses a single cron field into the set of values it permits. */
+function parseField(field, bounds, expression) {
+    if (field.length === 0) {
+        throw new CronParseError(`Cron field "${bounds.name}" is empty`, expression);
+    }
+    const values = new Set();
+    for (const part of field.split(",")) {
+        const [rangePart, stepPart] = part.split("/");
+        if (stepPart !== undefined && !/^\d+$/.test(stepPart)) {
+            throw new CronParseError(`Cron field "${bounds.name}" has an invalid step: "${part}"`, expression);
+        }
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (step === 0) {
+            throw new CronParseError(`Cron field "${bounds.name}" has a zero step: "${part}"`, expression);
+        }
+        let start;
+        let end;
+        if (rangePart === "*" || rangePart === undefined || rangePart === "") {
+            start = bounds.min;
+            end = bounds.max;
+        }
+        else if (rangePart.includes("-")) {
+            const [from, to] = rangePart.split("-");
+            start = resolveValue(from ?? "", bounds, expression);
+            end = resolveValue(to ?? "", bounds, expression);
+            if (start > end) {
+                throw new CronParseError(`Cron field "${bounds.name}" has an inverted range: "${rangePart}"`, expression);
+            }
+        }
+        else {
+            start = resolveValue(rangePart, bounds, expression);
+            // A bare value with a step means "from here to the end of the field".
+            end = stepPart === undefined ? start : bounds.max;
+        }
+        for (let v = start; v <= end; v += step) {
+            values.add(v);
+        }
+    }
+    if (values.size === 0) {
+        throw new CronParseError(`Cron field "${bounds.name}" matches no values: "${field}"`, expression);
+    }
+    return values;
+}
+/** Resolves a numeric or named field value, checking it against the bounds. */
+function resolveValue(raw, bounds, expression) {
+    let value;
+    if (/^\d+$/.test(raw)) {
+        value = Number(raw);
+        // Both 0 and 7 are Sunday in common cron dialects.
+        if (bounds.name === "dayOfWeek" && value === 7) {
+            value = 0;
+        }
+    }
+    else if (bounds.name === "month" && raw in MONTH_NAMES) {
+        value = MONTH_NAMES[raw];
+    }
+    else if (bounds.name === "dayOfWeek" && raw in DAY_NAMES) {
+        value = DAY_NAMES[raw];
+    }
+    else {
+        throw new CronParseError(`Cron field "${bounds.name}" has an invalid value: "${raw}"`, expression);
+    }
+    if (value < bounds.min || value > bounds.max) {
+        throw new CronParseError(`Cron field "${bounds.name}" value ${value} is outside ${bounds.min}-${bounds.max}`, expression);
+    }
+    return value;
+}
+/**
+ * Computes the next time a parsed cron expression fires, strictly after `after`.
+ *
+ * Search is minute-by-minute with whole-field skips, bounded by
+ * {@link MAX_SEARCH_YEARS} so an unsatisfiable expression (30 February) fails
+ * rather than looping.
+ *
+ * @param parsed - The parsed expression.
+ * @param after - The instant to search forward from (exclusive).
+ * @param utc - Interpret the fields in UTC rather than local time.
+ * @returns The next fire time, or null when none exists within the horizon.
+ */
+export function nextCronDate(parsed, after, utc = false) {
+    const get = {
+        minute: (d) => (utc ? d.getUTCMinutes() : d.getMinutes()),
+        hour: (d) => (utc ? d.getUTCHours() : d.getHours()),
+        date: (d) => (utc ? d.getUTCDate() : d.getDate()),
+        month: (d) => (utc ? d.getUTCMonth() : d.getMonth()) + 1,
+        day: (d) => (utc ? d.getUTCDay() : d.getDay()),
+        year: (d) => (utc ? d.getUTCFullYear() : d.getFullYear()),
+    };
+    // Start at the next whole minute after `after`, with seconds cleared.
+    const candidate = new Date(after.getTime());
+    candidate.setSeconds(0, 0);
+    candidate.setTime(candidate.getTime() + 60_000);
+    const limitYear = get.year(after) + MAX_SEARCH_YEARS;
+    while (get.year(candidate) <= limitYear) {
+        if (!parsed.month.has(get.month(candidate))) {
+            advanceMonth(candidate, utc);
+            continue;
+        }
+        if (!matchesDay(parsed, candidate, get.date, get.day)) {
+            advanceDay(candidate, utc);
+            continue;
+        }
+        if (!parsed.hour.has(get.hour(candidate))) {
+            advanceHour(candidate);
+            continue;
+        }
+        if (!parsed.minute.has(get.minute(candidate))) {
+            candidate.setTime(candidate.getTime() + 60_000);
+            continue;
+        }
+        return candidate;
+    }
+    return null;
+}
+/**
+ * Applies the cron day-matching rule.
+ *
+ * When both day-of-month and day-of-week are restricted, cron matches if
+ * *either* does — an inconsistency in the original spec that every
+ * implementation preserves, because `0 0 1,15 * mon` is widely used to mean
+ * "the 1st, the 15th, and every Monday".
+ */
+function matchesDay(parsed, candidate, getDate, getDay) {
+    const domMatches = parsed.dayOfMonth.has(getDate(candidate));
+    const dowMatches = parsed.dayOfWeek.has(getDay(candidate));
+    if (parsed.dayOfMonthUnrestricted && parsed.dayOfWeekUnrestricted) {
+        return true;
+    }
+    if (parsed.dayOfMonthUnrestricted) {
+        return dowMatches;
+    }
+    if (parsed.dayOfWeekUnrestricted) {
+        return domMatches;
+    }
+    return domMatches || dowMatches;
+}
+/** Moves to 00:00 on the first day of the next month. */
+function advanceMonth(candidate, utc) {
+    if (utc) {
+        candidate.setUTCDate(1);
+        candidate.setUTCHours(0, 0, 0, 0);
+        candidate.setUTCMonth(candidate.getUTCMonth() + 1);
+    }
+    else {
+        candidate.setDate(1);
+        candidate.setHours(0, 0, 0, 0);
+        candidate.setMonth(candidate.getMonth() + 1);
+    }
+}
+/** Moves to 00:00 on the next day. */
+function advanceDay(candidate, utc) {
+    if (utc) {
+        candidate.setUTCHours(0, 0, 0, 0);
+        candidate.setUTCDate(candidate.getUTCDate() + 1);
+    }
+    else {
+        candidate.setHours(0, 0, 0, 0);
+        candidate.setDate(candidate.getDate() + 1);
+    }
+}
+/**
+ * Moves to the top of the next hour.
+ *
+ * Uses wall-clock arithmetic rather than adding an hour of milliseconds, so a
+ * DST transition does not skip or repeat an hour of scheduling.
+ */
+function advanceHour(candidate) {
+    candidate.setMinutes(0, 0, 0);
+    candidate.setTime(candidate.getTime() + 3_600_000);
+    candidate.setMinutes(0, 0, 0);
+}
+//# sourceMappingURL=cron.parser.js.map

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

@@ -1,3 +1,5 @@
 export type { Trigger } from "./trigger.type.js";
 export { DateTrigger, DelayTrigger, IntervalTrigger, CronTrigger, } from "./schedulerTrigger.core.js";
+export { parseCron, nextCronDate } from "./cron.parser.js";
+export type { ParsedCron } from "./cron.parser.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/trigger/index.js

@@ -1,2 +1,3 @@
 export { DateTrigger, DelayTrigger, IntervalTrigger, CronTrigger, } from "./schedulerTrigger.core.js";
+export { parseCron, nextCronDate } from "./cron.parser.js";
 //# sourceMappingURL=index.js.map

package/dist/scheduler/trigger/schedulerTrigger.core.d.ts

@@ -1,10 +1,16 @@
 import type { Trigger } from "./trigger.type.js";
 /**
  * Trigger that fires once at a specific date.
+ *
+ * A date already in the past yields `null` from {@link DateTrigger.next}, which
+ * the scheduler interprets through the schedule's misfire policy rather than
+ * treating as an error.
  */
 export declare class DateTrigger implements Trigger {
     private readonly date;
     constructor(date: Date);
+    /** The instant this trigger fires at. */
+    get fireAt(): Date;
     next(after: Date): Date | null;
 }
 /**
@@ -21,15 +27,30 @@ export declare class DelayTrigger implements Trigger {
 export declare class IntervalTrigger implements Trigger {
     private readonly intervalMs;
     constructor(intervalMs: number);
+    /** The interval, in milliseconds. */
+    get interval(): number;
     next(after: Date): Date;
 }
 /**
  * Trigger that fires according to a cron expression.
+ *
+ * The expression is parsed once at construction, so an invalid one fails where
+ * the schedule is declared rather than silently firing on some other cadence.
  */
 export declare class CronTrigger implements Trigger {
     private readonly expression;
-    private readonly timezone?;
+    private readonly parsed;
+    private readonly utc;
+    /**
+     * @param expression - A five-field cron expression, or a macro such as `@daily`.
+     * @param timezone - Pass `"UTC"` to interpret the fields in UTC. Any other
+     *   value is rejected: honouring an arbitrary IANA zone needs real zone data,
+     *   and silently ignoring the argument is what made the previous
+     *   implementation's `timezone` parameter meaningless.
+     */
     constructor(expression: string, timezone?: string);
+    /** The expression this trigger was built from. */
+    get source(): string;
     next(after: Date): Date | null;
 }
 //# sourceMappingURL=schedulerTrigger.core.d.ts.map

package/dist/scheduler/trigger/schedulerTrigger.core.js

@@ -1,16 +1,29 @@
+import { parseCron, nextCronDate } from "./cron.parser.js";
+import { InvalidScheduleError } from "../errors/scheduler.errors.js";
 /**
  * Trigger that fires once at a specific date.
+ *
+ * A date already in the past yields `null` from {@link DateTrigger.next}, which
+ * the scheduler interprets through the schedule's misfire policy rather than
+ * treating as an error.
  */
 export class DateTrigger {
     date;
     constructor(date) {
-        this.date = date;
+        if (Number.isNaN(date.getTime())) {
+            throw new InvalidScheduleError("DateTrigger requires a valid Date", "date-trigger");
+        }
+        this.date = new Date(date.getTime());
+    }
+    /** The instant this trigger fires at. */
+    get fireAt() {
+        return new Date(this.date.getTime());
     }
     next(after) {
-        if (after >= this.date) {
+        if (after.getTime() >= this.date.getTime()) {
             return null;
         }
-        return this.date;
+        return new Date(this.date.getTime());
     }
 }
 /**
@@ -19,6 +32,7 @@ export class DateTrigger {
 export class DelayTrigger {
     delayMs;
     constructor(delayMs) {
+        assertUsableInterval(delayMs, "DelayTrigger");
         this.delayMs = delayMs;
     }
     next(after) {
@@ -31,24 +45,73 @@ export class DelayTrigger {
 export class IntervalTrigger {
     intervalMs;
     constructor(intervalMs) {
+        assertUsableInterval(intervalMs, "IntervalTrigger");
         this.intervalMs = intervalMs;
     }
+    /** The interval, in milliseconds. */
+    get interval() {
+        return this.intervalMs;
+    }
     next(after) {
         return new Date(after.getTime() + this.intervalMs);
     }
 }
 /**
  * Trigger that fires according to a cron expression.
+ *
+ * The expression is parsed once at construction, so an invalid one fails where
+ * the schedule is declared rather than silently firing on some other cadence.
  */
 export class CronTrigger {
     expression;
-    timezone;
+    parsed;
+    utc;
+    /**
+     * @param expression - A five-field cron expression, or a macro such as `@daily`.
+     * @param timezone - Pass `"UTC"` to interpret the fields in UTC. Any other
+     *   value is rejected: honouring an arbitrary IANA zone needs real zone data,
+     *   and silently ignoring the argument is what made the previous
+     *   implementation's `timezone` parameter meaningless.
+     */
     constructor(expression, timezone) {
         this.expression = expression;
-        this.timezone = timezone;
+        this.parsed = parseCron(expression);
+        if (timezone === undefined) {
+            this.utc = false;
+        }
+        else if (/^utc$/i.test(timezone) || timezone === "Etc/UTC") {
+            this.utc = true;
+        }
+        else {
+            throw new InvalidScheduleError(`CronTrigger supports only "UTC" or the system local zone, got "${timezone}"`, expression);
+        }
+    }
+    /** The expression this trigger was built from. */
+    get source() {
+        return this.expression;
     }
     next(after) {
-        return new Date(after.getTime() + 60_000);
+        return nextCronDate(this.parsed, after, this.utc);
+    }
+}
+/**
+ * Rejects an interval that cannot produce a usable schedule.
+ *
+ * A zero or negative interval would fire continuously, and one large enough to
+ * overflow the Date range produces an invalid date whose `getTime()` is `NaN` —
+ * which then poisons every comparison in the scheduler's heap.
+ */
+function assertUsableInterval(ms, what) {
+    if (!Number.isFinite(ms)) {
+        throw new InvalidScheduleError(`${what} requires a finite interval, got: ${ms}`, what);
+    }
+    if (ms <= 0) {
+        throw new InvalidScheduleError(`${what} requires a positive interval, got: ${ms}`, what);
+    }
+    // The Date range is ±8.64e15 ms from the epoch; anything approaching it
+    // cannot be added to "now" and still yield a valid date.
+    if (ms > 8.64e15) {
+        throw new InvalidScheduleError(`${what} interval ${ms}ms exceeds the representable date range`, what);
     }
 }
 //# sourceMappingURL=schedulerTrigger.core.js.map

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

@@ -1,2 +1,13 @@
-export type { SchedulerJobId, ScheduleId, ExecutionId, ScheduleType, ScheduleState, JobState, OverlapPolicy, MisfirePolicy, RetryStrategy, RetryPolicy, JobOptions, JobDefinition, JobHandler, JobContext, JobExecution, JobExecutionResult, Schedule, ScheduleOptions, ScheduleHandle, Trigger, } from "./schedulerTypes.core.js";
+/**
+ * The package's public type surface.
+ *
+ * Identity, state and policy vocabulary comes from `schedulerTypes.core.ts`;
+ * every structural type is re-exported from the module that owns it, so the
+ * type a consumer imports is the one the implementation actually uses.
+ */
+export type { SchedulerJobId, ScheduleId, ExecutionId, ScheduleType, ScheduleState, JobState, OverlapPolicy, MisfirePolicy, JobExecution, JobExecutionResult, } from "./schedulerTypes.core.js";
+export type { JobOptions, RetryPolicy, RetryStrategy, JobDefinition, JobHandler, JobContext, } from "../job/index.js";
+export type { Schedule, ScheduleOptions } from "../schedule/index.js";
+export type { ScheduleHandle } from "../scheduleHandle/index.js";
+export type { Trigger } from "../trigger/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/types/index.js

@@ -1,2 +1,9 @@
+/**
+ * The package's public type surface.
+ *
+ * Identity, state and policy vocabulary comes from `schedulerTypes.core.ts`;
+ * every structural type is re-exported from the module that owns it, so the
+ * type a consumer imports is the one the implementation actually uses.
+ */
 export {};
 //# sourceMappingURL=index.js.map

package/dist/scheduler/types/schedulerTypes.core.d.ts

@@ -1,7 +1,13 @@
 /**
  * @zudojs/scheduler/types
  *
- * Core types for the Zudojs scheduler package.
+ * The scheduler's identity, state and policy vocabulary.
+ *
+ * Structural types — jobs, schedules, handles, triggers — live with the code
+ * that builds them and are re-exported by `types/index.ts`. They used to be
+ * declared a second time here, and the copies had drifted: the public
+ * `ScheduleOptions` was missing `overlap` and `data`, so correct calls to
+ * `scheduler.every(..., { overlap: "skip" })` did not typecheck.
  */
 /**
  * Unique identifier for a scheduled job.
@@ -35,54 +41,6 @@ export type OverlapPolicy = "allow" | "skip" | "queue" | "replace";
  * Policy for handling missed executions.
  */
 export type MisfirePolicy = "skip" | "run-once" | "catch-up";
-/**
- * Retry strategy.
- */
-export type RetryStrategy = "fixed" | "linear" | "exponential";
-/**
- * Retry policy for job executions.
- */
-export interface RetryPolicy {
-    readonly attempts: number;
-    readonly strategy: RetryStrategy;
-    readonly delay: number;
-    readonly maxDelay?: number;
-    readonly jitter?: boolean;
-}
-/**
- * Options for a scheduled job.
- */
-export interface JobOptions {
-    readonly timeout?: number;
-    readonly retry?: RetryPolicy;
-    readonly concurrency?: number;
-    readonly overlap?: OverlapPolicy;
-}
-/**
- * Definition of a scheduled job.
- */
-export interface JobDefinition {
-    readonly id: SchedulerJobId;
-    readonly name: string;
-    readonly handler: JobHandler;
-    readonly options?: JobOptions;
-}
-/**
- * Handler for a scheduled job.
- */
-export type JobHandler<T = unknown> = (context: JobContext<T>) => Promise<void> | void;
-/**
- * Context passed to a job handler during execution.
- */
-export interface JobContext<T = unknown> {
-    readonly jobId: SchedulerJobId;
-    readonly executionId: ExecutionId;
-    readonly scheduledAt: Date;
-    readonly startedAt: Date;
-    readonly attempt: number;
-    readonly data: T;
-    readonly signal: AbortSignal;
-}
 /**
  * Record of a job execution.
  */
@@ -105,42 +63,4 @@ export interface JobExecutionResult {
     readonly success: boolean;
     readonly error?: unknown;
 }
-/**
- * Schedule definition.
- */
-export interface Schedule {
-    readonly id: ScheduleId;
-    readonly jobId: SchedulerJobId;
-    readonly type: ScheduleType;
-    readonly expression?: string;
-    readonly nextRunAt: Date;
-    readonly lastRunAt?: Date;
-    readonly state: ScheduleState;
-    readonly options?: ScheduleOptions;
-}
-/**
- * Options for a schedule.
- */
-export interface ScheduleOptions {
-    readonly timezone?: string;
-    readonly misfire?: MisfirePolicy;
-    readonly priority?: number;
-}
-/**
- * Handle for controlling a schedule.
- */
-export interface ScheduleHandle {
-    readonly id: ScheduleId;
-    readonly state: ScheduleState;
-    pause(): Promise<void>;
-    resume(): Promise<void>;
-    cancel(): Promise<void>;
-    nextRun(): Date | undefined;
-}
-/**
- * Trigger interface for calculating next execution time.
- */
-export interface Trigger {
-    next(after: Date): Date | null;
-}
 //# sourceMappingURL=schedulerTypes.core.d.ts.map

package/dist/scheduler/types/schedulerTypes.core.js

@@ -1,7 +1,13 @@
 /**
  * @zudojs/scheduler/types
  *
- * Core types for the Zudojs scheduler package.
+ * The scheduler's identity, state and policy vocabulary.
+ *
+ * Structural types — jobs, schedules, handles, triggers — live with the code
+ * that builds them and are re-exported by `types/index.ts`. They used to be
+ * declared a second time here, and the copies had drifted: the public
+ * `ScheduleOptions` was missing `overlap` and `data`, so correct calls to
+ * `scheduler.every(..., { overlap: "skip" })` did not typecheck.
  */
 export {};
 //# sourceMappingURL=schedulerTypes.core.js.map

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/scheduler",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Scheduled task and job infrastructure with cron-like scheduling, persistence, and worker management.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -14,25 +18,21 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "engines": {
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@zudojs/errors": "0.1.0",
-    "@zudojs/constants": "0.1.0",
-    "@zudojs/types": "0.1.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1",
+    "@zudojs/types": "1.0.0"
   },
   "devDependencies": {
-    "typescript": "^7.0.2",
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "publishConfig": {
@@ -45,8 +45,19 @@
     "jobs"
   ],
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/scheduler"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}