@skelm/scheduler 0.4.1 → 0.4.3

package/README.md

@@ -1,6 +1,6 @@
 # @skelm/scheduler
 
-> Long-running trigger management for [skelm](https://github.com/scottgl9/skelm) pipelines — cron, interval, webhook, poll, and queue triggers with deduplication and overlap policies.
+> Long-running trigger management for [skelm](https://github.com/scottgl9/skelm) pipelines — cron, interval, and webhook triggers with deduplication and overlap policies.
 
 [![npm](https://img.shields.io/npm/v/@skelm/scheduler)](https://www.npmjs.com/package/@skelm/scheduler)
 
@@ -38,13 +38,11 @@ await scheduler.start()
 
 ## Trigger types
 
-| Builder                  | When it fires                                                              |
-| ------------------------ | -------------------------------------------------------------------------- |
-| `createCronTrigger`      | On a cron schedule (`'0 9 * * 1-5'`)                                       |
-| `createIntervalTrigger`  | Every N milliseconds                                                       |
-| `createWebhookTrigger`   | When the gateway receives a request at the trigger's path                  |
-| `createPollTrigger`      | When a polling function returns new items                                  |
-| `createQueueTrigger`     | When a message arrives on a connected queue (in-memory or external broker) |
+| Builder                  | When it fires                                             |
+| ------------------------ | --------------------------------------------------------- |
+| `createCronTrigger`      | On a cron schedule (`'0 9 * * 1-5'`)                      |
+| `createIntervalTrigger`  | Every N milliseconds                                      |
+| `createWebhookTrigger`   | When the gateway receives a request at the trigger's path |
 
 ## Policies
 
@@ -57,13 +55,12 @@ await scheduler.start()
 ```ts
 export { Scheduler } from './scheduler.js'
 export {
-  createCronTrigger, createIntervalTrigger,
-  createWebhookTrigger, createPollTrigger, createQueueTrigger,
+  createCronTrigger, createIntervalTrigger, createWebhookTrigger,
 } from './builders.js'
 export type {
   SchedulerConfig, Trigger, TriggerRegistration, TriggerContext, TriggerType,
   DedupePolicy, OverlapPolicy, TriggerBase,
-  CronTrigger, IntervalTrigger, WebhookTrigger, PollTrigger, QueueTrigger,
+  CronTrigger, IntervalTrigger, WebhookTrigger,
   TriggerOptions,
 } from './types.js'
 ```

package/dist/builders.d.ts

@@ -1,4 +1,4 @@
-import type { CronTrigger, DedupePolicy, IntervalTrigger, OverlapPolicy, PollTrigger, QueueTrigger, WebhookTrigger } from './types.js';
+import type { CronTrigger, DedupePolicy, IntervalTrigger, OverlapPolicy, WebhookTrigger } from './types.js';
 /** Base trigger options */
 export interface TriggerOptions {
     description?: string;
@@ -20,15 +20,3 @@ export declare function createWebhookTrigger(id: string, pipelineId: string, pat
     secret?: string;
     transformPayload?: (payload: unknown) => unknown;
 }): WebhookTrigger;
-/** Create a poll trigger */
-export declare function createPollTrigger(id: string, pipelineId: string, url: string, intervalMs: number, options?: TriggerOptions & {
-    headers?: Record<string, string>;
-    detectNew?: (previous: unknown, current: unknown) => boolean;
-    extractInput?: (data: unknown) => unknown | null;
-}): PollTrigger;
-/** Create a queue trigger */
-export declare function createQueueTrigger(id: string, pipelineId: string, queueName: string, options?: TriggerOptions & {
-    batchSize?: number;
-    visibilityTimeoutMs?: number;
-    extractInput?: (message: unknown) => unknown | null;
-}): QueueTrigger;

package/dist/builders.js

@@ -87,68 +87,3 @@ export function createWebhookTrigger(id, pipelineId, path, options = {}) {
     }
     return result;
 }
-/** Create a poll trigger */
-export function createPollTrigger(id, pipelineId, url, intervalMs, options = {}) {
-    const result = {
-        id,
-        type: 'poll',
-        url,
-        intervalMs,
-        pipelineId,
-        enabled: options.enabled ?? true,
-        dedupe: options.dedupe ?? 'skip',
-        overlap: options.overlap ?? 'wait',
-    };
-    if (options.description !== undefined) {
-        result.description = options.description;
-    }
-    if (options.maxConcurrent !== undefined) {
-        result.maxConcurrent = options.maxConcurrent;
-    }
-    if (options.headers !== undefined) {
-        result.headers = options.headers;
-    }
-    if (options.detectNew !== undefined) {
-        result.detectNew = options.detectNew;
-    }
-    if (options.extractInput !== undefined) {
-        result.extractInput = options.extractInput;
-    }
-    if (options.inputTemplate !== undefined) {
-        result.inputTemplate = options.inputTemplate;
-    }
-    if (options.metadata !== undefined) {
-        result.metadata = options.metadata;
-    }
-    return result;
-}
-/** Create a queue trigger */
-export function createQueueTrigger(id, pipelineId, queueName, options = {}) {
-    const result = {
-        id,
-        type: 'queue',
-        queueName,
-        pipelineId,
-        enabled: options.enabled ?? true,
-        dedupe: options.dedupe ?? 'skip',
-        overlap: options.overlap ?? 'run-concurrent',
-        maxConcurrent: options.maxConcurrent ?? 5,
-        batchSize: options.batchSize ?? 1,
-    };
-    if (options.description !== undefined) {
-        result.description = options.description;
-    }
-    if (options.visibilityTimeoutMs !== undefined) {
-        result.visibilityTimeoutMs = options.visibilityTimeoutMs;
-    }
-    if (options.extractInput !== undefined) {
-        result.extractInput = options.extractInput;
-    }
-    if (options.inputTemplate !== undefined) {
-        result.inputTemplate = options.inputTemplate;
-    }
-    if (options.metadata !== undefined) {
-        result.metadata = options.metadata;
-    }
-    return result;
-}

package/dist/index.d.ts

@@ -5,6 +5,7 @@
  * with deduplication and overlap policies.
  */
 export { Scheduler } from './scheduler.js';
-export { createCronTrigger, createIntervalTrigger, createWebhookTrigger, createPollTrigger, createQueueTrigger, } from './builders.js';
-export type { SchedulerConfig, Trigger, TriggerRegistration, TriggerContext, TriggerType, DedupePolicy, OverlapPolicy, TriggerBase, CronTrigger, IntervalTrigger, WebhookTrigger, PollTrigger, QueueTrigger, } from './types.js';
+export type { SchedulerRunStore, SchedulerPipelineLoader, SchedulerPipelineExecutor, } from './scheduler.js';
+export { createCronTrigger, createIntervalTrigger, createWebhookTrigger, } from './builders.js';
+export type { SchedulerConfig, Trigger, TriggerRegistration, TriggerContext, TriggerType, DedupePolicy, OverlapPolicy, TriggerBase, CronTrigger, IntervalTrigger, WebhookTrigger, } from './types.js';
 export type { TriggerOptions } from './builders.js';

package/dist/index.js

@@ -5,4 +5,4 @@
  * with deduplication and overlap policies.
  */
 export { Scheduler } from './scheduler.js';
-export { createCronTrigger, createIntervalTrigger, createWebhookTrigger, createPollTrigger, createQueueTrigger, } from './builders.js';
+export { createCronTrigger, createIntervalTrigger, createWebhookTrigger, } from './builders.js';

package/dist/scheduler.d.ts

@@ -1,8 +1,20 @@
-import type { SchedulerConfig, Trigger, TriggerRegistration } from './types.js';
+import type { Pipeline, Run, RunStore } from '@skelm/core';
+import type { SchedulerConfig, Trigger, TriggerContext, TriggerRegistration } from './types.js';
+/** The slice of `RunStore` the scheduler depends on for recording triggered runs. */
+export type SchedulerRunStore = Pick<RunStore, 'putRun'>;
+/** Resolves a registered pipeline ID to the executable pipeline, or `null` if unknown. */
+export type SchedulerPipelineLoader = (pipelineId: string) => Promise<Pipeline | null>;
+/**
+ * Executes a loaded pipeline for a trigger fire. Must return the terminal
+ * Run record (with status set to one of `completed`, `failed`, or
+ * `cancelled` and `completedAt` populated) so the scheduler can persist a
+ * complete entry. When omitted, fires register the trigger metadata but
+ * do not produce Run records — see Scheduler.executeTrigger.
+ */
+export type SchedulerPipelineExecutor = (pipeline: Pipeline, input: unknown, ctx: TriggerContext) => Promise<Run>;
 /**
  * Scheduler manages long-running triggers for pipelines.
- * Handles cron, interval, webhook, poll, and queue-based triggers
- * with deduplication and overlap policies.
+ * Handles cron, interval, and webhook triggers with overlap policies.
  */
 export declare class Scheduler {
     private readonly config;
@@ -10,16 +22,18 @@ export declare class Scheduler {
     private readonly cronJobs;
     private readonly intervalJobs;
     private webhookServer;
-    private pollJobs;
-    private queueJobs;
+    private readonly inFlight;
+    private readonly runningCount;
+    private readonly lastRun;
     private isRunning;
     private readonly runStore;
     private readonly pipelineLoader;
+    private readonly pipelineExecutor;
+    private readonly noExecutorWarned;
     constructor(config: SchedulerConfig, deps: {
-        runStore: {
-            putRun: (run: unknown) => Promise<void>;
-        };
-        pipelineLoader: (pipelineId: string) => Promise<unknown>;
+        runStore: SchedulerRunStore;
+        pipelineLoader: SchedulerPipelineLoader;
+        pipelineExecutor?: SchedulerPipelineExecutor;
     });
     /** Register a new trigger */
     register(trigger: Trigger): Promise<TriggerRegistration>;
@@ -39,18 +53,30 @@ export declare class Scheduler {
     stopWebhookServer(): Promise<void>;
     /** Start all triggers */
     start(): Promise<void>;
-    /** Stop all triggers */
+    /**
+     * Stop all triggers. Clears the timers, then waits up to 30s for any
+     * in-flight executeTrigger callbacks to settle so a SIGTERM does not
+     * leave fire-and-forget executions racing the process exit.
+     *
+     * Runs unconditionally — `register()` arms timers immediately without
+     * setting isRunning, so a stop() that gated on isRunning would leak
+     * those timers when the scheduler is constructed without start().
+     */
     stop(): Promise<void>;
+    /** Track a fire-and-forget execution so stop() can drain it. */
+    private track;
+    private drainInFlight;
     private startCronTrigger;
+    private scheduleNextCron;
     private stopCronTrigger;
     private startIntervalTrigger;
     private stopIntervalTrigger;
-    private startPollTrigger;
-    private stopPollTrigger;
-    private startQueueTrigger;
-    private stopQueueTrigger;
+    /**
+     * Apply the overlap policy and schedule the execution.
+     * - fail-fast: skip if a previous run is in progress.
+     * - wait: chain after the previous run (next() resolves before we start).
+     * - run-concurrent: start immediately regardless.
+     */
+    private fire;
     private executeTrigger;
-    private executePollTrigger;
-    private executeQueueTrigger;
-    private parseCronToInterval;
 }

package/dist/scheduler.js

@@ -1,7 +1,7 @@
+import parser from 'cron-parser';
 /**
  * Scheduler manages long-running triggers for pipelines.
- * Handles cron, interval, webhook, poll, and queue-based triggers
- * with deduplication and overlap policies.
+ * Handles cron, interval, and webhook triggers with overlap policies.
  */
 export class Scheduler {
     config;
@@ -9,11 +9,14 @@ export class Scheduler {
     cronJobs = new Map();
     intervalJobs = new Map();
     webhookServer = null;
-    pollJobs = new Map();
-    queueJobs = new Map();
+    inFlight = new Set();
+    runningCount = new Map();
+    lastRun = new Map();
     isRunning = false;
     runStore;
     pipelineLoader;
+    pipelineExecutor;
+    noExecutorWarned = new Set();
     constructor(config, deps) {
         const cfg = {
             webhookPort: config.webhookPort ?? 3001,
@@ -27,6 +30,7 @@ export class Scheduler {
         this.config = cfg;
         this.runStore = deps.runStore;
         this.pipelineLoader = deps.pipelineLoader;
+        this.pipelineExecutor = deps.pipelineExecutor;
     }
     /** Register a new trigger */
     async register(trigger) {
@@ -39,7 +43,6 @@ export class Scheduler {
             status: 'active',
         };
         this.triggers.set(trigger.id, registration);
-        // Start the trigger based on type
         switch (trigger.type) {
             case 'cron':
                 this.startCronTrigger(trigger);
@@ -50,12 +53,6 @@ export class Scheduler {
             case 'webhook':
                 // Webhook server starts separately via startWebhookServer()
                 break;
-            case 'poll':
-                this.startPollTrigger(trigger);
-                break;
-            case 'queue':
-                this.startQueueTrigger(trigger);
-                break;
         }
         return registration;
     }
@@ -64,11 +61,10 @@ export class Scheduler {
         const registration = this.triggers.get(triggerId);
         if (!registration)
             return;
-        // Stop any running jobs
         this.stopCronTrigger(triggerId);
         this.stopIntervalTrigger(triggerId);
-        this.stopPollTrigger(triggerId);
-        this.stopQueueTrigger(triggerId);
+        this.lastRun.delete(triggerId);
+        this.runningCount.delete(triggerId);
         this.triggers.delete(triggerId);
     }
     /** Pause a trigger */
@@ -78,11 +74,8 @@ export class Scheduler {
             return;
         registration.status = 'paused';
         registration.updatedAt = Date.now();
-        // Stop jobs for time-based triggers
         this.stopCronTrigger(triggerId);
         this.stopIntervalTrigger(triggerId);
-        this.stopPollTrigger(triggerId);
-        this.stopQueueTrigger(triggerId);
     }
     /** Resume a paused trigger */
     async resume(triggerId) {
@@ -94,7 +87,6 @@ export class Scheduler {
         registration.status = 'active';
         registration.updatedAt = Date.now();
         const trigger = registration.trigger;
-        // Restart jobs based on type
         switch (trigger.type) {
             case 'cron':
                 this.startCronTrigger(trigger);
@@ -102,12 +94,6 @@ export class Scheduler {
             case 'interval':
                 this.startIntervalTrigger(trigger);
                 break;
-            case 'poll':
-                this.startPollTrigger(trigger);
-                break;
-            case 'queue':
-                this.startQueueTrigger(trigger);
-                break;
         }
     }
     /** List all registered triggers */
@@ -120,13 +106,10 @@ export class Scheduler {
     }
     /** Start the webhook server */
     async startWebhookServer() {
-        // Webhook server implementation would go here
-        // Uses h3 or similar for HTTP handling
         console.log(`Webhook server would start on ${this.config.webhookHost}:${this.config.webhookPort}`);
     }
     /** Stop the webhook server */
     async stopWebhookServer() {
-        // Stop webhook server
         this.webhookServer = null;
     }
     /** Start all triggers */
@@ -144,63 +127,90 @@ export class Scheduler {
                     case 'interval':
                         this.startIntervalTrigger(trigger);
                         break;
-                    case 'poll':
-                        this.startPollTrigger(trigger);
-                        break;
-                    case 'queue':
-                        this.startQueueTrigger(trigger);
-                        break;
                 }
             }
         }
     }
-    /** Stop all triggers */
+    /**
+     * Stop all triggers. Clears the timers, then waits up to 30s for any
+     * in-flight executeTrigger callbacks to settle so a SIGTERM does not
+     * leave fire-and-forget executions racing the process exit.
+     *
+     * Runs unconditionally — `register()` arms timers immediately without
+     * setting isRunning, so a stop() that gated on isRunning would leak
+     * those timers when the scheduler is constructed without start().
+     */
     async stop() {
-        if (!this.isRunning)
-            return;
         this.isRunning = false;
-        // Clear all jobs
         for (const [id, job] of this.cronJobs) {
-            clearInterval(job);
+            clearTimeout(job);
             this.cronJobs.delete(id);
         }
         for (const [id, job] of this.intervalJobs) {
             clearInterval(job);
             this.intervalJobs.delete(id);
         }
-        for (const [id, job] of this.pollJobs) {
-            clearInterval(job);
-            this.pollJobs.delete(id);
-        }
-        for (const [id, job] of this.queueJobs) {
-            clearInterval(job);
-            this.queueJobs.delete(id);
-        }
+        await this.drainInFlight(30_000);
+    }
+    /** Track a fire-and-forget execution so stop() can drain it. */
+    track(promise) {
+        this.inFlight.add(promise);
+        promise.finally(() => this.inFlight.delete(promise));
+    }
+    async drainInFlight(timeoutMs) {
+        if (this.inFlight.size === 0)
+            return;
+        await Promise.race([
+            Promise.allSettled([...this.inFlight]),
+            new Promise((resolve) => setTimeout(resolve, timeoutMs).unref?.()),
+        ]);
     }
     startCronTrigger(trigger) {
-        // Simple cron implementation using setInterval
-        // In production, use 'cron' package for proper cron expression parsing
-        const intervalMs = this.parseCronToInterval(trigger.schedule);
-        const job = setInterval(async () => {
-            if (trigger.enabled && this.triggers.get(trigger.id)?.status === 'active') {
-                await this.executeTrigger(trigger);
+        this.scheduleNextCron(trigger);
+    }
+    scheduleNextCron(trigger) {
+        let delay;
+        try {
+            const opts = { currentDate: new Date() };
+            if (trigger.timezone !== undefined)
+                opts.tz = trigger.timezone;
+            const next = parser.parseExpression(trigger.schedule, opts).next().getTime();
+            delay = Math.max(0, next - Date.now());
+        }
+        catch (err) {
+            const registration = this.triggers.get(trigger.id);
+            if (registration) {
+                registration.status = 'error';
+                registration.lastError = `Invalid cron expression "${trigger.schedule}": ${err.message}`;
             }
-        }, intervalMs);
-        this.cronJobs.set(trigger.id, job);
+            console.error(`Trigger ${trigger.id} disabled: invalid cron "${trigger.schedule}"`);
+            return;
+        }
+        const handle = setTimeout(() => {
+            const reg = this.triggers.get(trigger.id);
+            if (!reg || reg.status !== 'active' || !trigger.enabled)
+                return;
+            // Reschedule the next firing first so a slow run doesn't drift the schedule.
+            this.scheduleNextCron(trigger);
+            this.fire(trigger);
+        }, delay);
+        handle.unref?.();
+        this.cronJobs.set(trigger.id, handle);
     }
     stopCronTrigger(triggerId) {
         const job = this.cronJobs.get(triggerId);
         if (job) {
-            clearInterval(job);
+            clearTimeout(job);
             this.cronJobs.delete(triggerId);
         }
     }
     startIntervalTrigger(trigger) {
-        const job = setInterval(async () => {
+        const job = setInterval(() => {
             if (trigger.enabled && this.triggers.get(trigger.id)?.status === 'active') {
-                await this.executeTrigger(trigger);
+                this.fire(trigger);
             }
         }, trigger.intervalMs);
+        job.unref?.();
         this.intervalJobs.set(trigger.id, job);
     }
     stopIntervalTrigger(triggerId) {
@@ -210,42 +220,29 @@ export class Scheduler {
             this.intervalJobs.delete(triggerId);
         }
     }
-    startPollTrigger(trigger) {
-        const job = setInterval(async () => {
-            if (trigger.enabled && this.triggers.get(trigger.id)?.status === 'active') {
-                await this.executePollTrigger(trigger);
-            }
-        }, trigger.intervalMs);
-        this.pollJobs.set(trigger.id, job);
-    }
-    stopPollTrigger(triggerId) {
-        const job = this.pollJobs.get(triggerId);
-        if (job) {
-            clearInterval(job);
-            this.pollJobs.delete(triggerId);
-        }
-    }
-    startQueueTrigger(trigger) {
-        const job = setInterval(async () => {
-            if (trigger.enabled && this.triggers.get(trigger.id)?.status === 'active') {
-                await this.executeQueueTrigger(trigger);
-            }
-        }, this.config.queuePollIntervalMs);
-        this.queueJobs.set(trigger.id, job);
-    }
-    stopQueueTrigger(triggerId) {
-        const job = this.queueJobs.get(triggerId);
-        if (job) {
-            clearInterval(job);
-            this.queueJobs.delete(triggerId);
-        }
+    /**
+     * Apply the overlap policy and schedule the execution.
+     * - fail-fast: skip if a previous run is in progress.
+     * - wait: chain after the previous run (next() resolves before we start).
+     * - run-concurrent: start immediately regardless.
+     */
+    fire(trigger) {
+        const previous = this.lastRun.get(trigger.id);
+        const isRunning = (this.runningCount.get(trigger.id) ?? 0) > 0;
+        const policy = trigger.overlap ?? 'wait';
+        if (isRunning && policy === 'fail-fast')
+            return;
+        const start = isRunning && policy === 'wait' && previous ? previous : Promise.resolve();
+        const promise = start.then(() => this.executeTrigger(trigger));
+        this.lastRun.set(trigger.id, promise);
+        this.track(promise);
     }
     async executeTrigger(trigger) {
         const registration = this.triggers.get(trigger.id);
         if (!registration)
             return;
+        this.runningCount.set(trigger.id, (this.runningCount.get(trigger.id) ?? 0) + 1);
         try {
-            // Check deduplication
             const ctx = {
                 triggerId: trigger.id,
                 runId: `trigger-${trigger.id}-${Date.now()}`,
@@ -254,47 +251,35 @@ export class Scheduler {
                 deduped: false,
                 overlapHandled: false,
             };
-            // Handle overlap policy - check if already running
-            if (registration.status === 'active') {
-                // Check for concurrent run tracking (simplified)
-                const hasActiveRun = false; // Would track active runs in production
-                if (hasActiveRun) {
-                    ctx.overlapHandled = true;
-                    switch (trigger.overlap ?? 'wait') {
-                        case 'fail-fast':
-                            console.log(`Trigger ${trigger.id} skipped: overlap policy is fail-fast`);
-                            return;
-                        case 'run-concurrent':
-                            // Allow concurrent runs
-                            break;
-                        default:
-                            console.log(`Trigger ${trigger.id} waiting for previous run to complete`);
-                            return;
-                    }
-                }
-            }
-            // Execute the pipeline
             const pipeline = await this.pipelineLoader(trigger.pipelineId);
             if (!pipeline) {
                 throw new Error(`Pipeline ${trigger.pipelineId} not found`);
             }
-            // Create and store the run
-            const run = {
-                runId: ctx.runId,
-                pipelineId: trigger.pipelineId,
-                input: trigger.inputTemplate ?? {},
-                status: 'running',
-                steps: {},
-                output: undefined,
-                error: undefined,
-                startedAt: Date.now(),
-                completedAt: undefined,
-            };
-            await this.runStore.putRun(run);
-            registration.runCount++;
-            registration.lastRunAt = Date.now();
-            registration.status = 'active';
-            console.log(`Trigger ${trigger.id} executed run ${ctx.runId}`);
+            if (this.pipelineExecutor === undefined) {
+                // No executor wired: register the fire but do NOT persist a
+                // status='running' Run. Persisting one without anything to
+                // finalize it leaves an orphan that crash-recovery cannot
+                // distinguish from a real interrupted run. Production callers
+                // wire pipelineExecutor (typically the gateway TriggerCoordinator,
+                // not this class). Warn once per trigger so the misconfig is loud.
+                if (!this.noExecutorWarned.has(trigger.id)) {
+                    this.noExecutorWarned.add(trigger.id);
+                    console.warn(`Scheduler: trigger ${trigger.id} fired but no pipelineExecutor is configured; Run will not be persisted. Wire deps.pipelineExecutor to execute pipelines.`);
+                }
+                registration.runCount++;
+                registration.lastRunAt = Date.now();
+                registration.status = 'active';
+            }
+            else {
+                const input = trigger.inputTemplate ?? {};
+                const run = await this.pipelineExecutor(pipeline, input, ctx);
+                await this.runStore.putRun(run);
+                registration.runCount++;
+                registration.lastRunAt = Date.now();
+                registration.status = run.status === 'failed' ? 'error' : 'active';
+                if (run.error?.message)
+                    registration.lastError = run.error.message;
+            }
         }
         catch (err) {
             registration.errorCount++;
@@ -302,39 +287,14 @@ export class Scheduler {
             registration.lastError = err.message;
             console.error(`Trigger ${trigger.id} error:`, err);
         }
-    }
-    async executePollTrigger(trigger) {
-        // Poll implementation would fetch from URL and check for new items
-        console.log(`Polling ${trigger.url} for trigger ${trigger.id}`);
-        await this.executeTrigger(trigger);
-    }
-    async executeQueueTrigger(trigger) {
-        // Queue implementation would poll message queue and process batches
-        console.log(`Checking queue ${trigger.queueName} for trigger ${trigger.id}`);
-        await this.executeTrigger(trigger);
-    }
-    parseCronToInterval(cron) {
-        // Simplified cron-to-interval conversion
-        // In production, use a proper cron library
-        if (!cron || typeof cron !== 'string') {
-            return 5 * 60 * 1000; // Default to 5 minutes
-        }
-        const parts = cron.split(' ');
-        if (parts.length !== 5) {
-            // Default to 5 minutes if invalid
-            return 5 * 60 * 1000;
-        }
-        const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
-        // Simple heuristic for common patterns
-        if (minute === '*')
-            return 60 * 1000; // Every minute
-        if (hour === '*')
-            return 60 * 60 * 1000; // Every hour
-        if (dayOfMonth === '*' && dayOfWeek === '*') {
-            const minVal = Number.parseInt(minute || '0', 10) || 0;
-            return minVal * 60 * 1000;
+        finally {
+            const n = (this.runningCount.get(trigger.id) ?? 1) - 1;
+            if (n <= 0) {
+                this.runningCount.delete(trigger.id);
+            }
+            else {
+                this.runningCount.set(trigger.id, n);
+            }
         }
-        // Default to 5 minutes
-        return 5 * 60 * 1000;
     }
 }

package/dist/types.d.ts

@@ -5,7 +5,7 @@
  * with dedupe and overlap policies.
  */
 /** Trigger types */
-export type TriggerType = 'cron' | 'interval' | 'webhook' | 'poll' | 'queue';
+export type TriggerType = 'cron' | 'interval' | 'webhook';
 /** Trigger deduplication strategies */
 export type DedupePolicy = 'skip' | 'overwrite' | 'queue';
 /** Trigger overlap strategies */
@@ -42,24 +42,7 @@ export interface WebhookTrigger extends TriggerBase {
     secret?: string;
     transformPayload?: (payload: unknown) => unknown;
 }
-/** Poll trigger - check external source periodically */
-export interface PollTrigger extends TriggerBase {
-    type: 'poll';
-    url: string;
-    intervalMs: number;
-    headers?: Record<string, string>;
-    detectNew?: (previous: unknown, current: unknown) => boolean;
-    extractInput?: (data: unknown) => unknown | null;
-}
-/** Queue trigger - message queue based */
-export interface QueueTrigger extends TriggerBase {
-    type: 'queue';
-    queueName: string;
-    batchSize?: number;
-    visibilityTimeoutMs?: number;
-    extractInput?: (message: unknown) => unknown | null;
-}
-export type Trigger = CronTrigger | IntervalTrigger | WebhookTrigger | PollTrigger | QueueTrigger;
+export type Trigger = CronTrigger | IntervalTrigger | WebhookTrigger;
 /** Trigger registration */
 export interface TriggerRegistration {
     trigger: Trigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skelm/scheduler",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "license": "MIT",
   "author": "Scott Glover <scottgl@gmail.com>",
   "homepage": "https://skelm.dev/",
@@ -44,7 +44,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@skelm/core": "^0.4.1"
+    "@skelm/core": "^0.4.3",
+    "cron-parser": "^4.9.0"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",