@maestro-js/recurring-jobs 1.0.0-alpha.0

package/README.md

@@ -0,0 +1,348 @@
+# RecurringJobs Skill
+
+## Overview
+
+RecurringJobs provides cron-based job scheduling backed by the Queue package. Each recurring job gets its own dedicated queue where every execution is a persisted message with full lifecycle tracking. The next run is enqueued before the work function executes, guaranteeing the schedule continues even if the current run fails.
+
+## Quick Setup
+
+```ts
+import { RecurringJobs } from '@maestro-js/recurring-jobs'
+import { Queue } from '@maestro-js/queue'
+import { Log } from '@maestro-js/log'
+
+// Create a logger for recurring job events
+const logger = Log.create<[RecurringJobs.LogMessage]>({
+  transports: [{ write: ({ data: [msg] }) => console.log(msg) }]
+})
+
+// Create and register the recurring jobs service with a queue service
+const recurringJobsService = RecurringJobs.Provider.create({
+  logger,
+  queueService: Queue.provider('default')
+})
+RecurringJobs.Provider.register('default', recurringJobsService)
+
+// Define a recurring job
+const dailyReport = RecurringJobs.createJob({
+  name: 'daily-sales-report',
+  cron: '0 6 * * *',
+  workFn: async () => {
+    const total = await calculateDailySales()
+    return { total }
+  }
+})
+
+// Start processing
+dailyReport.startProcessing()
+```
+
+## Cron Expression Format
+
+Uses the `cron-parser` library (v4.x) for standard 5-field cron expressions:
+
+```
+ ┌───────────── minute (0-59)
+ │ ┌───────────── hour (0-23)
+ │ │ ┌───────────── day of month (1-31)
+ │ │ │ ┌───────────── month (1-12)
+ │ │ │ │ ┌───────────── day of week (0-7, 0 and 7 are Sunday)
+ │ │ │ │ │
+ * * * * *
+```
+
+Common examples:
+- `0 6 * * *` -- every day at 6:00 AM
+- `*/15 * * * *` -- every 15 minutes
+- `0 0 * * 0` -- every Sunday at midnight
+- `0 9 1 * *` -- first day of every month at 9:00 AM
+- `30 */2 * * *` -- every 2 hours at the 30-minute mark
+
+Invalid cron expressions throw immediately when passed to `createJob()`, since `cron-parser.parseExpression()` is called at creation time.
+
+## API Reference
+
+### Provider Setup
+
+#### `RecurringJobs.Provider.create(config)`
+
+Create a recurring jobs service instance.
+
+```ts
+RecurringJobs.Provider.create(config: {
+  logger: Log.Logger<[RecurringJobs.LogMessage]>
+  queueService: Queue.QueueService
+})
+```
+
+- `logger` -- a Log instance typed to `RecurringJobs.LogMessage` for structured job lifecycle events
+- `queueService` -- the Queue service used to back each recurring job's dedicated queue
+
+#### `RecurringJobs.Provider.register(name, service)`
+
+Register the service instance in the named registry.
+
+```ts
+RecurringJobs.Provider.register('default', recurringJobsService)
+```
+
+#### `RecurringJobs.provider(key)`
+
+Resolve a named instance from the registry. Supports deferred resolution via Proxy.
+
+```ts
+const jobs = RecurringJobs.provider('default')
+```
+
+### Service Methods (on the facade or provider instance)
+
+#### `RecurringJobs.createJob(config)`
+
+Create a recurring job with a dedicated queue. Returns a `RecurringJob` handle.
+
+```ts
+RecurringJobs.createJob<T>(config: {
+  name: string
+  cron: string
+  workFn: () => Promise<T>
+  logger?: Log.LogFunctions<[RecurringJobs.LogMessage]>  // optional per-job logger
+}): RecurringJobs.RecurringJob<T>
+```
+
+Each job creates a queue named `RecurringJobs: <name>`. The cron expression is validated immediately and throws if invalid.
+
+#### `RecurringJobs.startProcessing()`
+
+Start processing on all registered recurring jobs.
+
+```ts
+RecurringJobs.startProcessing()
+```
+
+#### `RecurringJobs.stopProcessing()`
+
+Stop processing on all registered recurring jobs.
+
+```ts
+RecurringJobs.stopProcessing()
+```
+
+#### `RecurringJobs.list()`
+
+Return the names of all registered recurring jobs.
+
+```ts
+RecurringJobs.list()  // ['daily-sales-report', 'session-cleanup']
+```
+
+#### `RecurringJobs.get(name)`
+
+Return the recurring job with the given name, or `undefined` if not found.
+
+```ts
+const job = RecurringJobs.get<{ total: number }>('daily-sales-report')
+```
+
+### RecurringJob Instance Methods
+
+#### `job.startProcessing()`
+
+Enqueue the next scheduled run and begin polling. If a waiting job already exists, it is not duplicated (deduplication).
+
+```ts
+dailyReport.startProcessing()
+```
+
+#### `job.stopProcessing()`
+
+Stop polling for this job.
+
+```ts
+dailyReport.stopProcessing()
+```
+
+#### `job.getNextUp()`
+
+Return the first message in `waiting` status, or `null` if none exists.
+
+```ts
+const next = await dailyReport.getNextUp()
+// { id: 42, status: 'waiting', scheduledDate: '2026-02-22T06:00:00.000Z', cron: '0 6 * * *', ... }
+```
+
+#### `job.list({ pageSize, pageNumber })`
+
+Return a paginated list of all messages (past runs and pending) for this job.
+
+```ts
+const history = await dailyReport.list({ pageSize: 20, pageNumber: 0 })
+// [{ id: 41, status: 'success', result: { total: 15420 }, ... }, ...]
+```
+
+#### `job.rescheduleJob({ jobId, scheduledDate })`
+
+Change the scheduled time of a waiting job. Only the next waiting job can be rescheduled; throws if `jobId` does not match the current waiting job.
+
+```ts
+await dailyReport.rescheduleJob({
+  jobId: 42,
+  scheduledDate: '2026-02-22T08:00:00.000Z' as Iso.Instant
+})
+```
+
+#### `job.name` / `job.cron`
+
+Read-only properties exposing the job's name and cron expression.
+
+```ts
+dailyReport.name  // 'daily-sales-report'
+dailyReport.cron  // '0 6 * * *'
+```
+
+### JobMessage Interface
+
+Each queue message returned by `getNextUp()` and `list()` has these fields:
+
+```ts
+interface JobMessage<Result = any> {
+  id: number
+  batchId: number | null
+  queue: string
+  scheduledDate: Iso.Instant
+  enqueuedDate: Iso.Instant
+  startedDate: Iso.Instant | null
+  status: 'waiting' | 'processing' | 'success' | 'error' | 'stuck'
+  result: Result
+  recovered: number
+  runningTime: number | null
+  uniqueKey: number | null
+  priority: number | null
+  cron: string
+}
+```
+
+## Common Patterns
+
+### Multiple Recurring Jobs
+
+```ts
+const report = RecurringJobs.createJob({
+  name: 'daily-report',
+  cron: '0 6 * * *',
+  workFn: async () => generateReport()
+})
+
+const cleanup = RecurringJobs.createJob({
+  name: 'session-cleanup',
+  cron: '0 0 * * *',
+  workFn: async () => cleanStaleSessions()
+})
+
+// Start all jobs at once
+RecurringJobs.startProcessing()
+
+// Or start individually
+report.startProcessing()
+cleanup.startProcessing()
+```
+
+### Inspecting and Rescheduling
+
+```ts
+const job = RecurringJobs.get('daily-report')
+if (job) {
+  const next = await job.getNextUp()
+  if (next) {
+    // Delay the next run by 2 hours
+    const delayed = new Date(new Date(next.scheduledDate).getTime() + 2 * 60 * 60 * 1000)
+    await job.rescheduleJob({
+      jobId: next.id,
+      scheduledDate: delayed.toISOString() as Iso.Instant
+    })
+  }
+}
+```
+
+### Per-Job Logger
+
+Add a dedicated logger to a specific job for fine-grained observability:
+
+```ts
+const jobLogger: Log.LogFunctions<[RecurringJobs.LogMessage]> = {
+  write({ data: [msg] }) {
+    if (msg.event === 'jobFailed') {
+      alertOpsTeam(msg.job, msg.error)
+    }
+  }
+}
+
+const criticalJob = RecurringJobs.createJob({
+  name: 'payment-reconciliation',
+  cron: '0 */4 * * *',
+  workFn: async () => reconcilePayments(),
+  logger: jobLogger
+})
+```
+
+### Execution History
+
+```ts
+const job = RecurringJobs.get('daily-report')
+if (job) {
+  const runs = await job.list({ pageSize: 50, pageNumber: 0 })
+  const failures = runs.filter(r => r.status === 'error')
+  const avgRuntime = runs
+    .filter(r => r.runningTime !== null)
+    .reduce((sum, r) => sum + r.runningTime!, 0) / runs.length
+}
+```
+
+## Log Events
+
+The service emits structured log events of type `RecurringJobs.LogMessage`:
+
+| Event | Level | Description |
+|---|---|---|
+| `jobProcessing` | info | A job message was dequeued and is about to execute |
+| `jobSucceeded` | info | The work function completed successfully |
+| `jobFailed` | error | The work function threw an error |
+| `jobScheduled` | info | The next run was enqueued with its scheduled date |
+| `jobAlreadyScheduled` | info | A waiting job already exists; skip enqueueing |
+| `jobSchedulingFailed` | error | Failed to enqueue the next run |
+
+## Cross-Package Integration
+
+### Dependencies
+
+- **@maestro-js/service-registry** -- foundation for the Provider pattern (registry, deferred Proxy resolution)
+- **@maestro-js/queue** -- each recurring job creates a dedicated queue via `queueService.create()`. Queue handles message persistence, polling, dequeuing, and lifecycle transitions
+- **@maestro-js/log** -- structured logging with pluggable transports for job lifecycle events
+
+### How It Connects
+
+RecurringJobs wraps Queue to add cron scheduling semantics. When `startProcessing()` is called, the next cron-derived date is computed and a queue message is enqueued for that date. When the Queue dequeues and runs the message, the work function fires and the next run is enqueued before the work executes. This ensures schedule continuity even on failure.
+
+Queue itself depends on Db (MySQL) for message persistence, so the full dependency chain is:
+
+```
+RecurringJobs -> Queue -> Db (MySQL)
+              -> Log
+              -> ServiceRegistry
+```
+
+### Provider Pattern
+
+This package follows the standard maestro Provider pattern:
+
+1. `RecurringJobs.Provider.create(config)` -- factory that instantiates the service
+2. `RecurringJobs.Provider.register(name, service)` -- registers the instance by name
+3. `RecurringJobs.provider(key)` -- resolves a named instance (deferred via Proxy)
+4. `RecurringJobs.*` -- facade that spreads `provider('default')` for direct method access
+
+## Notes
+
+- No tests exist for this package yet (`pnpm --filter @maestro-js/recurring-jobs test` prints "No tests yet").
+- The `cron-parser` library validates cron expressions at job creation time; invalid expressions throw immediately.
+- Deduplication: `startProcessing()` checks for an existing waiting message before enqueueing, preventing double-fires across process restarts.
+- The next run is enqueued inside the queue's `workFn` (before the user's `workFn` runs), so the schedule continues even if the current execution fails.
+- Only the next waiting job can be rescheduled via `rescheduleJob()`. Attempting to reschedule a non-waiting or non-next job throws an error.

package/dist/index.d.ts

@@ -0,0 +1,200 @@
+import { Iso } from 'iso-fns2';
+import { Queue } from '@maestro-js/queue';
+import { Log } from '@maestro-js/log';
+
+declare function create(serviceConfig: RecurringJobs.Provider.RecurringJobsServiceConfig): {
+    startProcessing: () => void;
+    stopProcessing: () => void;
+    list: () => string[];
+    get: <Result>(name: string) => RecurringJobs.RecurringJob<Result> | undefined;
+    createJob: <T>(jobConfig: RecurringJobs.JobConfig<T>) => RecurringJobs.RecurringJob<T>;
+};
+declare function provider(key: RecurringJobs.Provider.Key): {
+    startProcessing: () => void;
+    stopProcessing: () => void;
+    list: () => string[];
+    get: <Result>(name: string) => RecurringJobs.RecurringJob<Result> | undefined;
+    createJob: <T>(jobConfig: RecurringJobs.JobConfig<T>) => RecurringJobs.RecurringJob<T>;
+};
+/**
+ * Cron-based job scheduling backed by the Queue package.
+ *
+ * Each recurring job gets its own dedicated queue where every execution is a
+ * persisted message with full lifecycle tracking. The next run is enqueued
+ * *before* the work function executes, guaranteeing the schedule continues
+ * even if the current run fails. Deduplication prevents double-fires across
+ * process restarts.
+ *
+ * @example
+ * ```ts
+ * // Create a daily sales report job
+ * const salesReport = RecurringJobs.createJob({
+ *   name: 'daily-sales-report',
+ *   cron: '0 6 * * *',
+ *   workFn: async () => {
+ *     const total = await calculateDailySales()
+ *     return { total }
+ *   }
+ * })
+ *
+ * // Start processing and inspect upcoming runs
+ * salesReport.startProcessing()
+ * const next = await salesReport.getNextUp()  // { status: 'waiting', scheduledDate: '...' }
+ *
+ * // List all registered jobs
+ * RecurringJobs.list() // ['daily-sales-report']
+ * ```
+ */
+declare namespace RecurringJobs {
+    /** A single queue message representing one scheduled or completed job execution */
+    interface JobMessage<Result = any> {
+        id: number;
+        batchId: number | null;
+        queue: string;
+        scheduledDate: Iso.Instant;
+        enqueuedDate: Iso.Instant;
+        startedDate: Iso.Instant | null;
+        status: 'waiting' | 'processing' | 'success' | 'error' | 'stuck';
+        result: Result;
+        recovered: number;
+        runningTimeSeconds: number | null;
+        uniqueKey: number | null;
+        priority: number | null;
+        cron: string;
+    }
+    /**
+     * A single recurring job instance with its own dedicated queue.
+     *
+     * Each job has independent start/stop lifecycle, execution history, and
+     * rescheduling capability. The queue stores one message per scheduled run —
+     * call {@link list} to page through past and pending executions, or
+     * {@link getNextUp} to peek at the next waiting run.
+     *
+     * @example
+     * ```ts
+     * const job = RecurringJobs.createJob({
+     *   name: 'stale-session-cleanup',
+     *   cron: '0 0 * * *',
+     *   workFn: async () => { await cleanStaleSessions() }
+     * })
+     * job.startProcessing()
+     * const next = await job.getNextUp() // { status: 'waiting', ... }
+     * ```
+     */
+    interface RecurringJob<T = unknown> {
+        /** Enqueues the next scheduled run and begins polling */
+        startProcessing(): void;
+        /** Stops polling for this job */
+        stopProcessing(): void;
+        /** The name of the recurring job as specified in the config */
+        name: string;
+        /** The cron expression defining this job's schedule */
+        cron: string;
+        /** Changes the scheduled time of a waiting job */
+        rescheduleJob(job: {
+            jobId: number;
+            scheduledDate: Iso.Instant;
+        }): Promise<void>;
+        /** Returns the first message in `waiting` status, or `null` if none exists */
+        getNextUp(): Promise<JobMessage<T> | null>;
+        /** Returns a paginated list of all messages (past runs and pending) for this job */
+        list(options: {
+            pageSize: number;
+            pageNumber: number;
+        }): Promise<JobMessage<unknown>[]>;
+    }
+    /** Union of all recurring job lifecycle log event shapes */
+    type LogMessage = {
+        event: 'jobProcessing';
+        job: string;
+        driver: Queue.Driver;
+        messageId: number;
+    } | {
+        event: 'jobSucceeded';
+        job: string;
+        driver: Queue.Driver;
+        result: unknown;
+        messageId: number;
+    } | {
+        event: 'jobFailed';
+        job: string;
+        driver: Queue.Driver;
+        error: unknown;
+        messageId: number;
+    } | {
+        event: 'jobScheduled';
+        job: string;
+        nextRun: Iso.Instant;
+    } | {
+        event: 'jobAlreadyScheduled';
+        job: string;
+        existingJobId: number;
+    } | {
+        event: 'jobSchedulingFailed';
+        job: string;
+        error: unknown;
+    };
+    /** Configuration for a single recurring job passed to {@link RecurringJobsService.createJob} */
+    interface JobConfig<T = unknown> {
+        cron: string;
+        workFn(): Promise<T>;
+        name: string;
+        logger?: Log.LogFunctions<[LogMessage]>;
+    }
+    /**
+     * Container that manages multiple recurring jobs sharing the same queue service.
+     *
+     * Create individual jobs with {@link createJob}, then start or stop processing
+     * across all jobs at once or individually. Each job gets its own dedicated queue
+     * named `RecurringJobs: <jobName>`.
+     *
+     * @example
+     * ```ts
+     * const report = RecurringJobs.createJob({ name: 'daily-report', cron: '0 6 * * *', workFn: generateReport })
+     * const cleanup = RecurringJobs.createJob({ name: 'session-cleanup', cron: '0 0 * * *', workFn: cleanSessions })
+     * RecurringJobs.startProcessing() // starts both jobs
+     * ```
+     */
+    interface RecurringJobsService {
+        /** Creates a recurring job with its own dedicated queue */
+        createJob<T>(jobConfig: RecurringJobs.JobConfig<T>): RecurringJobs.RecurringJob<T>;
+        /** Starts processing on all registered recurring jobs */
+        startProcessing: () => void;
+        /** Stops processing on all registered recurring jobs */
+        stopProcessing: () => void;
+        /** Returns the names of all registered recurring jobs */
+        list: () => string[];
+        /** Returns the recurring job with the given name, or `undefined` if not found */
+        get: <Result>(name: string) => RecurringJobs.RecurringJob<Result> | undefined;
+    }
+    namespace Provider {
+        /** Service-level configuration passed to `RecurringJobs.Provider.create()` */
+        interface RecurringJobsServiceConfig {
+            logger: Log.Logger<[RecurringJobs.LogMessage]>;
+            queueService: Queue.QueueService;
+        }
+        type Key = keyof Keys;
+        interface Keys {
+            default: unknown;
+        }
+    }
+}
+/**
+ * Cron-based job scheduling backed by the Queue package.
+ * Call `RecurringJobs.Provider.create()` with a queue service, register it, then use `RecurringJobs.createJob()` to define jobs.
+ */
+declare const RecurringJobs: {
+    Provider: {
+        create: typeof create;
+        register: (name: RecurringJobs.Provider.Key, item: RecurringJobs.RecurringJobsService) => void;
+        list: () => "default"[];
+    };
+    provider: typeof provider;
+    startProcessing: () => void;
+    stopProcessing: () => void;
+    list: () => string[];
+    get: <Result>(name: string) => RecurringJobs.RecurringJob<Result> | undefined;
+    createJob: <T>(jobConfig: RecurringJobs.JobConfig<T>) => RecurringJobs.RecurringJob<T>;
+};
+
+export { RecurringJobs };

package/dist/index.js

@@ -0,0 +1,153 @@
+// src/index.ts
+import "iso-fns2";
+import cronParser from "cron-parser";
+import { Log } from "@maestro-js/log";
+import { ServiceRegistry } from "@maestro-js/service-registry";
+function create(serviceConfig) {
+  const queueService = serviceConfig.queueService;
+  const jobs = [];
+  function createJob(jobConfig) {
+    cronParser.parseExpression(jobConfig.cron);
+    const logger = Log.create({
+      transports: [serviceConfig.logger, ...jobConfig.logger ? [jobConfig.logger] : []]
+    });
+    const queue = queueService.create({
+      name: `RecurringJobs: ${jobConfig.name}`,
+      workFn: async () => {
+        await addJobToQueue(getNextScheduledDate());
+        return jobConfig.workFn();
+      },
+      logger: Log.create({
+        transports: [
+          {
+            write({ data: [message] }) {
+              if (message.event === "messageDequeued") {
+                logger.info({
+                  event: "jobProcessing",
+                  job: jobConfig.name,
+                  driver: message.driver,
+                  messageId: message.messageId
+                });
+              } else if (message.event === "messageProcessed") {
+                logger.info({
+                  event: "jobSucceeded",
+                  job: jobConfig.name,
+                  driver: message.driver,
+                  result: message.result,
+                  messageId: message.messageId
+                });
+              } else if (message.event === "messageFailed") {
+                logger.error({
+                  event: "jobFailed",
+                  job: jobConfig.name,
+                  driver: message.driver,
+                  error: message.error,
+                  messageId: message.messageId
+                });
+              }
+            }
+          }
+        ]
+      })
+    });
+    function getNextScheduledDate() {
+      const interval = cronParser.parseExpression(jobConfig.cron);
+      return interval.next().toDate().toISOString();
+    }
+    async function getNextUp() {
+      const messages = await queue.listMessages({ pageNumber: 0, pageSize: 100 });
+      const result = messages.find((m) => m.status === "waiting");
+      return result ? { ...result, cron: jobConfig.cron } : null;
+    }
+    async function list2({
+      pageNumber,
+      pageSize
+    }) {
+      const messages = await queue.listMessages({ pageNumber, pageSize });
+      return messages.map((m) => ({ ...m, cron: jobConfig.cron }));
+    }
+    async function rescheduleJob({ jobId, scheduledDate }) {
+      const nextUp = await getNextUp();
+      if (!nextUp || nextUp.id !== jobId) {
+        throw new Error(
+          `Cannot reschedule job ${jobId}: only the next waiting job can be rescheduled.` + (nextUp ? ` The current waiting job is ${nextUp.id}.` : " No waiting job found.")
+        );
+      }
+      await queue.updateMessage({ messageId: jobId, scheduledDate, body: {} });
+    }
+    async function addJobToQueue(nextRun) {
+      const data = await getNextUp();
+      if (data) {
+        logger.info({ event: "jobAlreadyScheduled", job: jobConfig.name, existingJobId: data.id });
+        return false;
+      }
+      await queue.addMessage({}, { scheduledDate: nextRun, tracingContext: null });
+      logger.info({ event: "jobScheduled", job: jobConfig.name, nextRun });
+      return true;
+    }
+    function startProcessing2() {
+      addJobToQueue(getNextScheduledDate()).catch((error) => {
+        logger.error({ event: "jobSchedulingFailed", job: jobConfig.name, error });
+      });
+      queue.startProcessing();
+    }
+    function stopProcessing2() {
+      queue.stopProcessing();
+    }
+    const jobFunctions = {
+      getNextUp,
+      list: list2,
+      startProcessing: startProcessing2,
+      stopProcessing: stopProcessing2,
+      rescheduleJob,
+      name: jobConfig.name,
+      cron: jobConfig.cron
+    };
+    jobs.push(jobFunctions);
+    return jobFunctions;
+  }
+  function startProcessing() {
+    jobs.forEach((job) => job.startProcessing());
+  }
+  function stopProcessing() {
+    jobs.forEach((job) => job.stopProcessing());
+  }
+  function list() {
+    return jobs.map((job) => job.name);
+  }
+  function get(name) {
+    return jobs.find((job) => job.name === name);
+  }
+  return { startProcessing, stopProcessing, list, get, createJob };
+}
+var registry = ServiceRegistry.createRegistry(
+  ServiceRegistry.proxyFunctionsForObject
+);
+var Provider = {
+  create,
+  register: registry.register,
+  list: registry.list
+};
+function provider(key) {
+  const service = registry.resolve(key);
+  return {
+    startProcessing: service.startProcessing,
+    stopProcessing: service.stopProcessing,
+    list: service.list,
+    get: service.get,
+    createJob: service.createJob
+  };
+}
+var facade = provider("default");
+var RecurringJobs = {
+  Provider,
+  provider,
+  startProcessing: facade.startProcessing,
+  stopProcessing: facade.stopProcessing,
+  list: facade.list,
+  get: facade.get,
+  createJob: facade.createJob
+};
+export {
+  RecurringJobs
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@maestro-js/recurring-jobs",
+  "description": "Use when working with @maestro-js/recurring-jobs. Cron-based job scheduling backed by the Queue package. Covers creating recurring jobs, managing schedules, start/stop processing, rescheduling, listing jobs, and inspecting upcoming runs. Follows the Provider pattern with ServiceRegistry. Key capabilities include cron expression parsing, deduplication across process restarts, per-job dedicated queues, structured log events, and paginated execution history.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "cron-parser": "^4.9.0",
+    "iso-fns2": "npm:iso-fns@2.0.0-alpha.26",
+    "@maestro-js/service-registry": "1.0.0-alpha.0",
+    "@maestro-js/log": "1.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11",
+    "@maestro-js/queue": "1.0.0-alpha.0"
+  },
+  "version": "1.0.0-alpha.0",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "repository": "https://github.com/Marcato-Partners/maestro-js",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "echo 'No tests yet'",
+    "format": "prettier --write src/",
+    "lint": "prettier --check src/"
+  }
+}