@voyantjs/workflows-orchestrator-node 0.30.1 → 0.30.5

package/dist/node-standalone-driver.d.ts

@@ -49,6 +49,10 @@ export interface NodeStandaloneDriverOptions {
      * cadence. Defaults to `false` (poller starts immediately).
      */
     disableTimeWheel?: boolean;
+    /** Schedule runner tick interval. Defaults to 1_000 ms. */
+    schedulePollIntervalMs?: number;
+    /** Disable automatic firing for schedules registered through manifests. */
+    disableScheduleRunner?: boolean;
 }
 /**
  * Build the Mode 2 driver factory. The factory closes over its options

package/dist/node-standalone-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-standalone-driver.d.ts","sourceRoot":"","sources":["../src/node-standalone-driver.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,aAAa,EAOd,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAWxD,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAIpC,MAAM,WAAW,2BAA2B;IAC1C,4EAA4E;IAC5E,EAAE,EAAE,EAAE,CAAA;IACN,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;IAC7D,wDAAwD;IACxD,UAAU,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAA;IACpC,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,2BAA2B,GAAG,aAAa,CA8R3F"}
+{"version":3,"file":"node-standalone-driver.d.ts","sourceRoot":"","sources":["../src/node-standalone-driver.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,aAAa,EAOd,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAML,KAAK,SAAS,EAId,KAAK,WAAW,EAEjB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAWxD,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAIpC,MAAM,WAAW,2BAA2B;IAC1C,4EAA4E;IAC5E,EAAE,EAAE,EAAE,CAAA;IACN,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;IAC7D,wDAAwD;IACxD,UAAU,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAA;IACpC,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,2DAA2D;IAC3D,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,2EAA2E;IAC3E,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,2BAA2B,GAAG,aAAa,CAuX3F"}

package/dist/node-standalone-driver.js

@@ -18,7 +18,7 @@
 // See architecture doc §7 for the full Mode 2 design.
 import { deriveStableEventId } from "@voyantjs/workflows/events";
 import { handleStepRequest } from "@voyantjs/workflows/handler";
-import { cancel as orchestratorCancel, trigger as orchestratorTrigger, routeEvent, } from "@voyantjs/workflows-orchestrator";
+import { createInProcessConcurrencyCoordinator, createScheduler, manifestScheduleSources, cancel as orchestratorCancel, trigger as orchestratorTrigger, routeEvent, } from "@voyantjs/workflows-orchestrator";
 import { createPersistentWakeupManager, } from "./persistent-wakeup-manager.js";
 import { createPostgresManifestStore } from "./postgres-manifest-store.js";
 import { createPostgresRunRecordStore } from "./postgres-run-record-store.js";
@@ -98,7 +98,16 @@ export function createNodeStandaloneDriver(opts) {
             // via `manager.poll()`).
             wakeupManager.start();
         }
+        const scheduleRunners = new Map();
         let shuttingDown = false;
+        const concurrency = createInProcessConcurrencyCoordinator({
+            async cancelRun(runId, reason) {
+                const out = await orchestratorCancel({ runId, reason }, { store: runStore, handler, now });
+                if (out.ok && isTerminal(out.record.status)) {
+                    concurrency.releaseRun(out.record);
+                }
+            },
+        });
         // ---- WorkflowDriver implementation ----
         async function registerManifest(args) {
             assertNotShutdown(shuttingDown);
@@ -117,6 +126,7 @@ export function createNodeStandaloneDriver(opts) {
                     error: err instanceof Error ? err.message : String(err),
                 });
             }
+            startScheduleRunner(args.environment, args.manifest);
             return result;
         }
         async function getManifest(args) {
@@ -129,7 +139,8 @@ export function createNodeStandaloneDriver(opts) {
             assertNotShutdown(shuttingDown);
             const workflowId = typeof workflow === "string" ? workflow : workflow.id;
             const env = triggerOpts?.environment ?? defaultEnv;
-            const record = await orchestratorTrigger({
+            const policy = await resolveConcurrencyPolicy(workflow, workflowId, env, getManifest);
+            const record = await triggerRecord({
                 workflowId,
                 workflowVersion: triggerOpts?.lockToVersion ?? "v1",
                 input: input,
@@ -138,7 +149,8 @@ export function createNodeStandaloneDriver(opts) {
                 tags: triggerOpts?.tags,
                 idempotencyKey: triggerOpts?.idempotencyKey,
                 delay: triggerOpts?.delay,
-            }, { store: runStore, handler, now });
+                priority: triggerOpts?.priority,
+            }, policy);
             // Sync wakeup row so the time-wheel can resume DATETIME-parked runs.
             // No-op if the run completed inline (status !== "waiting").
             await syncWakeupFromRecord(wakeupStore, record);
@@ -176,7 +188,7 @@ export function createNodeStandaloneDriver(opts) {
                     continue;
                 }
                 try {
-                    const record = await orchestratorTrigger({
+                    const record = await triggerRecord({
                         workflowId: entry.targetWorkflowId,
                         workflowVersion: "v1",
                         input: entry.input,
@@ -189,7 +201,7 @@ export function createNodeStandaloneDriver(opts) {
                             eventType: args.envelope.name,
                             filterId: entry.filterId,
                         },
-                    }, { store: runStore, handler, now });
+                    }, await resolveConcurrencyPolicy(entry.targetWorkflowId, entry.targetWorkflowId, args.environment, getManifest));
                     await syncWakeupFromRecord(wakeupStore, record);
                     matches.push({
                         filterId: entry.filterId,
@@ -225,6 +237,55 @@ export function createNodeStandaloneDriver(opts) {
             // Idempotent — calling stop() on an already-stopped manager is a
             // no-op.
             wakeupManager.stop();
+            for (const runner of scheduleRunners.values()) {
+                runner.stop();
+            }
+            scheduleRunners.clear();
+        }
+        function startScheduleRunner(environment, manifest) {
+            const existing = scheduleRunners.get(environment);
+            existing?.stop();
+            scheduleRunners.delete(environment);
+            if (opts.disableScheduleRunner)
+                return;
+            const sources = manifestScheduleSources(manifest);
+            if (sources.length === 0)
+                return;
+            const runner = createScheduler({
+                sources,
+                environment,
+                now,
+                tickMs: opts.schedulePollIntervalMs,
+                onFire: async ({ workflowId, input, scheduleId, fireAt }) => {
+                    assertNotShutdown(shuttingDown);
+                    const record = await triggerRecord({
+                        workflowId,
+                        workflowVersion: "v1",
+                        input,
+                        tenantMeta,
+                        environment,
+                        idempotencyKey: `${scheduleId}:${fireAt}`,
+                        triggeredBy: { kind: "schedule", scheduleId },
+                    }, await resolveConcurrencyPolicy(workflowId, workflowId, environment, getManifest));
+                    await syncWakeupFromRecord(wakeupStore, record);
+                },
+                logger: (level, msg, data) => deps.logger(level, msg, data),
+            });
+            if (runner.sourceCount() === 0)
+                return;
+            runner.start();
+            scheduleRunners.set(environment, runner);
+        }
+        async function triggerRecord(args, policy) {
+            return concurrency.run({
+                workflowId: args.workflowId,
+                input: args.input,
+                policy,
+                holderId: concurrencyHolderId(args),
+            }, (hooks) => orchestratorTrigger({
+                ...args,
+                onRunRecordCreated: hooks.onRunRecordCreated,
+            }, { store: runStore, handler, now }));
         }
         // ---- WorkflowAdmin (full; Mode 2 has Postgres-native query support) ----
         const admin = {
@@ -271,7 +332,10 @@ export function createNodeStandaloneDriver(opts) {
                 // default (architecture doc §21.21). The `compensate` flag is
                 // accepted but no-ops in v1.
                 void cancelOpts?.compensate;
-                await orchestratorCancel({ runId, reason: cancelOpts?.reason }, { store: runStore, handler, now });
+                const out = await orchestratorCancel({ runId, reason: cancelOpts?.reason }, { store: runStore, handler, now });
+                if (out.ok && isTerminal(out.record.status)) {
+                    concurrency.releaseRun(out.record);
+                }
             },
             streamRun(runId) {
                 // Live journal-event streaming is a follow-up — needs LISTEN/NOTIFY
@@ -305,6 +369,27 @@ function assertNotShutdown(shuttingDown) {
         throw new Error("NodeStandaloneDriver: shutdown() has been called; new operations are refused.");
     }
 }
+async function resolveConcurrencyPolicy(workflow, workflowId, environment, getManifest) {
+    if (typeof workflow !== "string" && workflow.config?.concurrency) {
+        return workflow.config.concurrency;
+    }
+    const manifest = await getManifest({ environment });
+    return manifest?.workflows.find((entry) => entry.id === workflowId)?.concurrency;
+}
+function isTerminal(status) {
+    return (status === "completed" ||
+        status === "failed" ||
+        status === "cancelled" ||
+        status === "compensated" ||
+        status === "compensation_failed");
+}
+function concurrencyHolderId(args) {
+    if (args.runId !== undefined)
+        return args.runId;
+    if (args.idempotencyKey !== undefined)
+        return `idem-${args.workflowId}-${args.idempotencyKey}`;
+    return undefined;
+}
 function randomToken() {
     return Math.floor(Math.random() * 1_000_000_000)
         .toString(36)

package/dist/postgres-schema.d.ts

@@ -272,6 +272,23 @@ export declare const wakeupsTable: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        priority: import("drizzle-orm/pg-core").PgColumn<{
+            name: "priority";
+            tableName: "voyant_wakeups";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         leaseOwner: import("drizzle-orm/pg-core").PgColumn<{
             name: "lease_owner";
             tableName: "voyant_wakeups";

package/dist/postgres-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-schema.d.ts","sourceRoot":"","sources":["../src/postgres-schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C7B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAelC,CAAA"}
+{"version":3,"file":"postgres-schema.d.ts","sourceRoot":"","sources":["../src/postgres-schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C7B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAelC,CAAA"}

package/dist/postgres-schema.js

@@ -36,11 +36,12 @@ export const snapshotRunsTable = pgTable("voyant_snapshot_runs", {
 export const wakeupsTable = pgTable("voyant_wakeups", {
     runId: text("run_id").primaryKey(),
     wakeAt: bigint("wake_at", { mode: "number" }).notNull(),
+    priority: integer("priority").notNull().default(0),
     leaseOwner: text("lease_owner"),
     leaseExpiresAt: bigint("lease_expires_at", { mode: "number" }),
     updatedAt: bigint("updated_at", { mode: "number" }).notNull(),
 }, (table) => ({
-    dueIdx: index("voyant_wakeups_due_idx").on(table.wakeAt),
+    dueIdx: index("voyant_wakeups_due_idx").on(table.priority.desc(), table.wakeAt.asc()),
     leaseIdx: index("voyant_wakeups_lease_idx").on(table.leaseExpiresAt),
 }));
 /**

package/dist/postgres-wakeup-store.d.ts

@@ -12,6 +12,7 @@ export declare function wakeupToRow(record: Omit<WakeupRecord, "updatedAt"> & {
 }, updatedAt: number): {
     runId: string;
     wakeAt: number;
+    priority: number;
     leaseOwner: string | null;
     leaseExpiresAt: number | null;
     updatedAt: number;

package/dist/postgres-wakeup-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-wakeup-store.d.ts","sourceRoot":"","sources":["../src/postgres-wakeup-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAElE,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAE1C,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,0BAA0B,GAAG,WAAW,CA0GvF;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAC/D,SAAS,EAAE,MAAM;;;;;;EASlB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,YAAY,CAAC,YAAY,GAAG,YAAY,CAQrF"}
+{"version":3,"file":"postgres-wakeup-store.d.ts","sourceRoot":"","sources":["../src/postgres-wakeup-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAElE,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAE1C,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,0BAA0B,GAAG,WAAW,CAkHvF;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAC/D,SAAS,EAAE,MAAM;;;;;;;EAUlB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,YAAY,CAAC,YAAY,GAAG,YAAY,CASrF"}

package/dist/postgres-wakeup-store.js

@@ -49,7 +49,7 @@ export function createPostgresWakeupStore(opts) {
               OR lease_expires_at <= ${at}
               OR lease_owner = ${owner}
             )
-          ORDER BY wake_at ASC
+          ORDER BY priority DESC, wake_at ASC
           LIMIT ${limit}
           FOR UPDATE SKIP LOCKED
         )
@@ -59,12 +59,19 @@ export function createPostgresWakeupStore(opts) {
             updated_at = ${at}
         FROM due
         WHERE wakeups.run_id = due.run_id
-        RETURNING wakeups.run_id, wakeups.wake_at, wakeups.lease_owner, wakeups.lease_expires_at, wakeups.updated_at
+        RETURNING wakeups.run_id, wakeups.wake_at, wakeups.priority, wakeups.lease_owner, wakeups.lease_expires_at, wakeups.updated_at
       `);
             const rows = result.rows;
+            rows.sort((a, b) => {
+                const priorityDelta = toNumber(b.priority) - toNumber(a.priority);
+                if (priorityDelta !== 0)
+                    return priorityDelta;
+                return toNumber(a.wake_at) - toNumber(b.wake_at);
+            });
             return rows.map((row) => ({
                 runId: row.run_id,
                 wakeAt: toNumber(row.wake_at),
+                priority: toNumber(row.priority),
                 leaseOwner: row.lease_owner ?? undefined,
                 leaseExpiresAt: row.lease_expires_at === null ? undefined : toNumber(row.lease_expires_at),
                 updatedAt: toNumber(row.updated_at),
@@ -90,6 +97,7 @@ export function wakeupToRow(record, updatedAt) {
     return {
         runId: record.runId,
         wakeAt: record.wakeAt,
+        priority: record.priority ?? 0,
         leaseOwner: record.leaseOwner ?? null,
         leaseExpiresAt: record.leaseExpiresAt ?? null,
         updatedAt,
@@ -99,6 +107,7 @@ export function rowToWakeupRecord(row) {
     return {
         runId: row.runId,
         wakeAt: row.wakeAt,
+        priority: row.priority,
         leaseOwner: row.leaseOwner ?? undefined,
         leaseExpiresAt: row.leaseExpiresAt ?? undefined,
         updatedAt: row.updatedAt,

package/dist/scheduler.d.ts

@@ -1,44 +1,2 @@
-import type { Duration, EnvironmentName, ScheduleDeclaration } from "@voyantjs/workflows";
-export interface ScheduleSource {
-    workflowId: string;
-    decl: ScheduleDeclaration;
-}
-export interface SchedulerDeps {
-    sources: readonly ScheduleSource[];
-    onFire: (args: {
-        workflowId: string;
-        input: unknown;
-        scheduleName?: string;
-    }) => Promise<void>;
-    now?: () => number;
-    environment?: EnvironmentName;
-    tickMs?: number;
-    setInterval?: typeof setInterval;
-    clearInterval?: typeof clearInterval;
-    logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void;
-}
-export interface SchedulerHandle {
-    start: () => void;
-    stop: () => void;
-    tick: () => Promise<void>;
-    nextFirings: () => {
-        workflowId: string;
-        name?: string;
-        nextAt: number;
-        done: boolean;
-    }[];
-    sourceCount: () => number;
-}
-export declare function createScheduler(deps: SchedulerDeps): SchedulerHandle;
-export declare function computeNextFire(decl: ScheduleDeclaration, fromMs: number): number;
-export interface CronSpec {
-    minute: number[];
-    hour: number[];
-    day: number[];
-    month: number[];
-    dow: number[];
-}
-export declare function parseCron(expr: string): CronSpec;
-export declare function nextCronFire(spec: CronSpec, fromMs: number): number;
-export declare function toMs(duration: Duration): number;
+export { type CronSpec, computeNextFire, createScheduler, manifestScheduleSources, nextCronFire, parseCron, type SchedulableDeclaration, type SchedulerDeps, type SchedulerHandle, type ScheduleSource, toMs, } from "@voyantjs/workflows-orchestrator";
 //# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzF,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,mBAAmB,CAAA;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,SAAS,cAAc,EAAE,CAAA;IAClC,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9F,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;IAChC,aAAa,CAAC,EAAE,OAAO,aAAa,CAAA;IACpC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAChF;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,WAAW,EAAE,MAAM;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;IACzF,WAAW,EAAE,MAAM,MAAM,CAAA;CAC1B;AASD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,eAAe,CAsGpE;AAWD,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CASjF;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,GAAG,EAAE,MAAM,EAAE,CAAA;CACd;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAYhD;AA8BD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAmBnE;AAED,wBAAgB,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAqB/C"}
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,SAAS,EACT,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,IAAI,GACL,MAAM,kCAAkC,CAAA"}

package/dist/scheduler.js

@@ -1,207 +1 @@
-export function createScheduler(deps) {
-    const now = deps.now ?? (() => Date.now());
-    const tickMs = deps.tickMs ?? 1_000;
-    const setInt = deps.setInterval ?? setInterval;
-    const clearInt = deps.clearInterval ?? clearInterval;
-    const env = deps.environment ?? "development";
-    const log = deps.logger ?? (() => { });
-    const states = [];
-    for (const source of deps.sources) {
-        if (source.decl.enabled === false)
-            continue;
-        if (source.decl.environments && !source.decl.environments.includes(env))
-            continue;
-        let firstAt;
-        try {
-            firstAt = computeNextFire(source.decl, now());
-        }
-        catch (err) {
-            log("warn", `scheduler: skipping source for workflow "${source.workflowId}": ${String(err)}`);
-            continue;
-        }
-        states.push({ source, nextAt: firstAt, done: false, inFlight: false });
-    }
-    let timer;
-    const advanceAfterFire = (state, firedAt) => {
-        if ("at" in state.source.decl) {
-            state.done = true;
-            return;
-        }
-        try {
-            state.nextAt = computeNextFire(state.source.decl, firedAt);
-        }
-        catch (err) {
-            log("error", `scheduler: cannot compute next fire for "${state.source.workflowId}": ${String(err)}`);
-            state.done = true;
-        }
-    };
-    const doTick = async () => {
-        const t = now();
-        const ready = states.filter((state) => !state.done && state.nextAt <= t);
-        for (const state of ready) {
-            const overlap = state.source.decl.overlap ?? "skip";
-            if (state.inFlight && overlap === "skip")
-                continue;
-            let input;
-            try {
-                input = await resolveInput(state.source.decl.input);
-            }
-            catch (err) {
-                log("error", `scheduler: failed to resolve input for "${state.source.workflowId}": ${String(err)}`);
-                advanceAfterFire(state, t);
-                continue;
-            }
-            state.inFlight = true;
-            const firePromise = (async () => {
-                try {
-                    await deps.onFire({
-                        workflowId: state.source.workflowId,
-                        input,
-                        scheduleName: state.source.decl.name,
-                    });
-                }
-                catch (err) {
-                    log("error", `scheduler: onFire threw for "${state.source.workflowId}": ${String(err)}`);
-                }
-                finally {
-                    state.inFlight = false;
-                }
-            })();
-            advanceAfterFire(state, t);
-            if (overlap === "skip")
-                await firePromise;
-        }
-    };
-    return {
-        start() {
-            if (timer)
-                return;
-            timer = setInt(() => {
-                doTick().catch(() => { });
-            }, tickMs);
-            timer.unref?.();
-        },
-        stop() {
-            if (!timer)
-                return;
-            clearInt(timer);
-            timer = undefined;
-        },
-        tick: doTick,
-        nextFirings() {
-            return states.map((state) => ({
-                workflowId: state.source.workflowId,
-                name: state.source.decl.name,
-                nextAt: state.nextAt,
-                done: state.done,
-            }));
-        },
-        sourceCount() {
-            return states.length;
-        },
-    };
-}
-async function resolveInput(input) {
-    if (typeof input === "function") {
-        return await input();
-    }
-    return input;
-}
-export function computeNextFire(decl, fromMs) {
-    if ("cron" in decl)
-        return nextCronFire(parseCron(decl.cron), fromMs);
-    if ("every" in decl)
-        return fromMs + toMs(decl.every);
-    if ("at" in decl) {
-        const at = typeof decl.at === "string" ? Date.parse(decl.at) : decl.at.getTime();
-        if (!Number.isFinite(at))
-            throw new Error(`invalid "at" value: ${String(decl.at)}`);
-        return at < fromMs ? Number.POSITIVE_INFINITY : at;
-    }
-    throw new Error(`schedule declaration missing one of cron/every/at`);
-}
-export function parseCron(expr) {
-    const parts = expr.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        throw new Error(`invalid cron "${expr}" — expected 5 fields (minute hour day month dow)`);
-    }
-    return {
-        minute: parseField(parts[0], 0, 59, "minute"),
-        hour: parseField(parts[1], 0, 23, "hour"),
-        day: parseField(parts[2], 1, 31, "day"),
-        month: parseField(parts[3], 1, 12, "month"),
-        dow: parseField(parts[4], 0, 6, "dow"),
-    };
-}
-function parseField(f, min, max, label) {
-    const out = new Set();
-    for (const part of f.split(",")) {
-        const stepMatch = /^(.+)\/(\d+)$/.exec(part);
-        const body = stepMatch ? stepMatch[1] : part;
-        const step = stepMatch ? Number(stepMatch[2]) : 1;
-        if (!(step >= 1))
-            throw new Error(`cron ${label} step must be >=1 in "${f}"`);
-        let lo;
-        let hi;
-        if (body === "*") {
-            lo = min;
-            hi = max;
-        }
-        else if (body.includes("-")) {
-            const [a, b] = body.split("-");
-            lo = Number(a);
-            hi = Number(b);
-        }
-        else {
-            lo = Number(body);
-            hi = lo;
-        }
-        if (!Number.isFinite(lo) || !Number.isFinite(hi) || lo < min || hi > max || lo > hi) {
-            throw new Error(`cron ${label} out of range [${min}..${max}] in "${f}"`);
-        }
-        for (let i = lo; i <= hi; i += step)
-            out.add(i);
-    }
-    return [...out].sort((a, b) => a - b);
-}
-export function nextCronFire(spec, fromMs) {
-    const date = new Date(fromMs);
-    date.setUTCSeconds(0, 0);
-    date.setUTCMinutes(date.getUTCMinutes() + 1);
-    const maxIterations = 60 * 24 * 366 * 5;
-    for (let i = 0; i < maxIterations; i++) {
-        if (spec.minute.includes(date.getUTCMinutes()) &&
-            spec.hour.includes(date.getUTCHours()) &&
-            spec.day.includes(date.getUTCDate()) &&
-            spec.month.includes(date.getUTCMonth() + 1) &&
-            spec.dow.includes(date.getUTCDay())) {
-            return date.getTime();
-        }
-        date.setUTCMinutes(date.getUTCMinutes() + 1);
-    }
-    throw new Error("cron search exceeded 5 years without finding a match");
-}
-export function toMs(duration) {
-    if (typeof duration === "number")
-        return duration;
-    const m = /^(\d+)(ms|s|m|h|d|w)$/.exec(duration);
-    if (!m)
-        throw new Error(`invalid duration "${duration}"`);
-    const n = Number(m[1]);
-    switch (m[2]) {
-        case "ms":
-            return n;
-        case "s":
-            return n * 1_000;
-        case "m":
-            return n * 60_000;
-        case "h":
-            return n * 3_600_000;
-        case "d":
-            return n * 86_400_000;
-        case "w":
-            return n * 604_800_000;
-        default:
-            throw new Error(`invalid duration "${duration}"`);
-    }
-}
+export { computeNextFire, createScheduler, manifestScheduleSources, nextCronFire, parseCron, toMs, } from "@voyantjs/workflows-orchestrator";

package/dist/wakeup-store.d.ts

@@ -2,6 +2,7 @@ import type { RunRecord } from "@voyantjs/workflows-orchestrator";
 export interface WakeupRecord {
     runId: string;
     wakeAt: number;
+    priority?: number;
     leaseOwner?: string;
     leaseExpiresAt?: number;
     updatedAt: number;

package/dist/wakeup-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wakeup-store.d.ts","sourceRoot":"","sources":["../src/wakeup-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAGjE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAA;IACzD,MAAM,EAAE,CACN,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,KAC7D,OAAO,CAAC,YAAY,CAAC,CAAA;IAC1B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3C,IAAI,EAAE,MAAM,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IACnC,QAAQ,EAAE,CAAC,IAAI,EAAE;QACf,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,oBAAyB,GAAG,WAAW,CA4EhF;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAY/F"}
+{"version":3,"file":"wakeup-store.d.ts","sourceRoot":"","sources":["../src/wakeup-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAGjE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAA;IACzD,MAAM,EAAE,CACN,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,KAC7D,OAAO,CAAC,YAAY,CAAC,CAAA;IAC1B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3C,IAAI,EAAE,MAAM,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IACnC,QAAQ,EAAE,CAAC,IAAI,EAAE;QACf,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,oBAAyB,GAAG,WAAW,CA4EhF;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAa/F"}

package/dist/wakeup-store.js

@@ -41,7 +41,7 @@ export function createFsWakeupStore(opts = {}) {
             return wakeups;
         },
         async leaseDue({ owner, now: at = now(), leaseMs, limit = 25 }) {
-            const wakeups = await this.list();
+            const wakeups = (await this.list()).sort(compareWakeupClaimOrder);
             const leased = [];
             for (const wakeup of wakeups) {
                 if (leased.length >= limit)
@@ -86,10 +86,17 @@ export async function syncWakeupFromRecord(store, record) {
     await store.upsert({
         runId: record.id,
         wakeAt,
+        priority: record.priority,
         leaseOwner: undefined,
         leaseExpiresAt: undefined,
     });
 }
+function compareWakeupClaimOrder(a, b) {
+    const priorityDelta = (b.priority ?? 0) - (a.priority ?? 0);
+    if (priorityDelta !== 0)
+        return priorityDelta;
+    return a.wakeAt - b.wakeAt;
+}
 async function safeReaddir(dir) {
     try {
         const entries = await readdir(dir);

package/drizzle/0005_wakeup_priority.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "voyant_wakeups" ADD COLUMN "priority" integer DEFAULT 0 NOT NULL;--> statement-breakpoint
+DROP INDEX "voyant_wakeups_due_idx";--> statement-breakpoint
+CREATE INDEX "voyant_wakeups_due_idx" ON "voyant_wakeups" USING btree ("priority" DESC,"wake_at" ASC);

package/drizzle/meta/_journal.json

@@ -36,6 +36,13 @@
       "when": 1779000001000,
       "tag": "0004_workflow_manifests",
       "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1779000002000,
+      "tag": "0005_wakeup_priority",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/workflows-orchestrator-node",
-  "version": "0.30.1",
+  "version": "0.30.5",
   "description": "Node/Docker runtime primitives for @voyantjs/workflows-orchestrator, including a file-backed run store and local scheduler.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,8 +29,8 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "pg": "^8.20.0",
-    "@voyantjs/workflows-orchestrator": "0.30.1",
-    "@voyantjs/workflows": "0.30.1"
+    "@voyantjs/workflows-orchestrator": "0.30.5",
+    "@voyantjs/workflows": "0.30.5"
   },
   "devDependencies": {
     "@types/node": "^20.12.0",

package/src/node-standalone-driver.ts

@@ -37,11 +37,17 @@ import { deriveStableEventId } from "@voyantjs/workflows/events"
 import { handleStepRequest, type WorkflowStepRequest } from "@voyantjs/workflows/handler"
 import type { WorkflowManifest } from "@voyantjs/workflows/protocol"
 import {
+  createInProcessConcurrencyCoordinator,
+  createScheduler,
+  manifestScheduleSources,
   cancel as orchestratorCancel,
   trigger as orchestratorTrigger,
   type RunRecord,
+  type RuntimeConcurrencyPolicy,
   routeEvent,
+  type SchedulerHandle,
   type StepHandler,
+  type TriggerArgs,
 } from "@voyantjs/workflows-orchestrator"
 import type { drizzle } from "drizzle-orm/node-postgres"
 
@@ -105,6 +111,10 @@ export interface NodeStandaloneDriverOptions {
    * cadence. Defaults to `false` (poller starts immediately).
    */
   disableTimeWheel?: boolean
+  /** Schedule runner tick interval. Defaults to 1_000 ms. */
+  schedulePollIntervalMs?: number
+  /** Disable automatic firing for schedules registered through manifests. */
+  disableScheduleRunner?: boolean
 }
 
 const DEFAULT_TENANT_META: RunRecord["tenantMeta"] = {
@@ -189,7 +199,16 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
       wakeupManager.start()
     }
 
+    const scheduleRunners = new Map<string, SchedulerHandle>()
     let shuttingDown = false
+    const concurrency = createInProcessConcurrencyCoordinator({
+      async cancelRun(runId, reason) {
+        const out = await orchestratorCancel({ runId, reason }, { store: runStore, handler, now })
+        if (out.ok && isTerminal(out.record.status)) {
+          concurrency.releaseRun(out.record)
+        }
+      },
+    })
 
     // ---- WorkflowDriver implementation ----
 
@@ -216,6 +235,10 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
           error: err instanceof Error ? err.message : String(err),
         })
       }
+      startScheduleRunner(
+        args.environment as "production" | "preview" | "development",
+        args.manifest,
+      )
       return result
     }
 
@@ -233,8 +256,9 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
       assertNotShutdown(shuttingDown)
       const workflowId = typeof workflow === "string" ? workflow : workflow.id
       const env = triggerOpts?.environment ?? defaultEnv
+      const policy = await resolveConcurrencyPolicy(workflow, workflowId, env, getManifest)
 
-      const record = await orchestratorTrigger(
+      const record = await triggerRecord(
         {
           workflowId,
           workflowVersion: triggerOpts?.lockToVersion ?? "v1",
@@ -244,8 +268,9 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
           tags: triggerOpts?.tags,
           idempotencyKey: triggerOpts?.idempotencyKey,
           delay: triggerOpts?.delay,
+          priority: triggerOpts?.priority,
         },
-        { store: runStore, handler, now },
+        policy,
       )
       // Sync wakeup row so the time-wheel can resume DATETIME-parked runs.
       // No-op if the run completed inline (status !== "waiting").
@@ -286,7 +311,7 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
           continue
         }
         try {
-          const record = await orchestratorTrigger(
+          const record = await triggerRecord(
             {
               workflowId: entry.targetWorkflowId,
               workflowVersion: "v1",
@@ -301,7 +326,12 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
                 filterId: entry.filterId,
               },
             },
-            { store: runStore, handler, now },
+            await resolveConcurrencyPolicy(
+              entry.targetWorkflowId,
+              entry.targetWorkflowId,
+              args.environment,
+              getManifest,
+            ),
           )
           await syncWakeupFromRecord(wakeupStore, record)
           matches.push({
@@ -339,6 +369,72 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
       // Idempotent — calling stop() on an already-stopped manager is a
       // no-op.
       wakeupManager.stop()
+      for (const runner of scheduleRunners.values()) {
+        runner.stop()
+      }
+      scheduleRunners.clear()
+    }
+
+    function startScheduleRunner(
+      environment: "production" | "preview" | "development",
+      manifest: WorkflowManifest,
+    ): void {
+      const existing = scheduleRunners.get(environment)
+      existing?.stop()
+      scheduleRunners.delete(environment)
+      if (opts.disableScheduleRunner) return
+
+      const sources = manifestScheduleSources(manifest)
+      if (sources.length === 0) return
+
+      const runner = createScheduler({
+        sources,
+        environment,
+        now,
+        tickMs: opts.schedulePollIntervalMs,
+        onFire: async ({ workflowId, input, scheduleId, fireAt }) => {
+          assertNotShutdown(shuttingDown)
+          const record = await triggerRecord(
+            {
+              workflowId,
+              workflowVersion: "v1",
+              input,
+              tenantMeta,
+              environment,
+              idempotencyKey: `${scheduleId}:${fireAt}`,
+              triggeredBy: { kind: "schedule", scheduleId },
+            },
+            await resolveConcurrencyPolicy(workflowId, workflowId, environment, getManifest),
+          )
+          await syncWakeupFromRecord(wakeupStore, record)
+        },
+        logger: (level, msg, data) => deps.logger(level, msg, data),
+      })
+      if (runner.sourceCount() === 0) return
+      runner.start()
+      scheduleRunners.set(environment, runner)
+    }
+
+    async function triggerRecord(
+      args: TriggerArgs,
+      policy: RuntimeConcurrencyPolicy | undefined,
+    ): Promise<RunRecord> {
+      return concurrency.run(
+        {
+          workflowId: args.workflowId,
+          input: args.input,
+          policy,
+          holderId: concurrencyHolderId(args),
+        },
+        (hooks) =>
+          orchestratorTrigger(
+            {
+              ...args,
+              onRunRecordCreated: hooks.onRunRecordCreated,
+            },
+            { store: runStore, handler, now },
+          ),
+      )
     }
 
     // ---- WorkflowAdmin (full; Mode 2 has Postgres-native query support) ----
@@ -386,10 +482,13 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
         // default (architecture doc §21.21). The `compensate` flag is
         // accepted but no-ops in v1.
         void cancelOpts?.compensate
-        await orchestratorCancel(
+        const out = await orchestratorCancel(
           { runId, reason: cancelOpts?.reason },
           { store: runStore, handler, now },
         )
+        if (out.ok && isTerminal(out.record.status)) {
+          concurrency.releaseRun(out.record)
+        }
       },
 
       streamRun(runId: string): AsyncIterable<never> {
@@ -428,6 +527,35 @@ function assertNotShutdown(shuttingDown: boolean): void {
   }
 }
 
+async function resolveConcurrencyPolicy(
+  workflow: { id: string; config?: { concurrency?: RuntimeConcurrencyPolicy } } | string,
+  workflowId: string,
+  environment: "production" | "preview" | "development",
+  getManifest: (args: { environment: string }) => Promise<WorkflowManifest | null>,
+): Promise<RuntimeConcurrencyPolicy | undefined> {
+  if (typeof workflow !== "string" && workflow.config?.concurrency) {
+    return workflow.config.concurrency
+  }
+  const manifest = await getManifest({ environment })
+  return manifest?.workflows.find((entry) => entry.id === workflowId)?.concurrency
+}
+
+function isTerminal(status: RunRecord["status"]): boolean {
+  return (
+    status === "completed" ||
+    status === "failed" ||
+    status === "cancelled" ||
+    status === "compensated" ||
+    status === "compensation_failed"
+  )
+}
+
+function concurrencyHolderId(args: TriggerArgs): string | undefined {
+  if (args.runId !== undefined) return args.runId
+  if (args.idempotencyKey !== undefined) return `idem-${args.workflowId}-${args.idempotencyKey}`
+  return undefined
+}
+
 function randomToken(): string {
   return Math.floor(Math.random() * 1_000_000_000)
     .toString(36)

package/src/postgres-schema.ts

@@ -61,12 +61,13 @@ export const wakeupsTable = pgTable(
   {
     runId: text("run_id").primaryKey(),
     wakeAt: bigint("wake_at", { mode: "number" }).notNull(),
+    priority: integer("priority").notNull().default(0),
     leaseOwner: text("lease_owner"),
     leaseExpiresAt: bigint("lease_expires_at", { mode: "number" }),
     updatedAt: bigint("updated_at", { mode: "number" }).notNull(),
   },
   (table) => ({
-    dueIdx: index("voyant_wakeups_due_idx").on(table.wakeAt),
+    dueIdx: index("voyant_wakeups_due_idx").on(table.priority.desc(), table.wakeAt.asc()),
     leaseIdx: index("voyant_wakeups_lease_idx").on(table.leaseExpiresAt),
   }),
 )

package/src/postgres-wakeup-store.ts

@@ -62,6 +62,7 @@ export function createPostgresWakeupStore(opts: PostgresWakeupStoreOptions): Wak
         wake_at: number
         lease_owner: string | null
         lease_expires_at: number | null
+        priority: number
         updated_at: number
       }>(sql`
         WITH due AS (
@@ -73,7 +74,7 @@ export function createPostgresWakeupStore(opts: PostgresWakeupStoreOptions): Wak
               OR lease_expires_at <= ${at}
               OR lease_owner = ${owner}
             )
-          ORDER BY wake_at ASC
+          ORDER BY priority DESC, wake_at ASC
           LIMIT ${limit}
           FOR UPDATE SKIP LOCKED
         )
@@ -83,18 +84,25 @@ export function createPostgresWakeupStore(opts: PostgresWakeupStoreOptions): Wak
             updated_at = ${at}
         FROM due
         WHERE wakeups.run_id = due.run_id
-        RETURNING wakeups.run_id, wakeups.wake_at, wakeups.lease_owner, wakeups.lease_expires_at, wakeups.updated_at
+        RETURNING wakeups.run_id, wakeups.wake_at, wakeups.priority, wakeups.lease_owner, wakeups.lease_expires_at, wakeups.updated_at
       `)
       const rows = result.rows as Array<{
         run_id: string
         wake_at: number | string
+        priority: number | string
         lease_owner: string | null
         lease_expires_at: number | string | null
         updated_at: number | string
       }>
+      rows.sort((a, b) => {
+        const priorityDelta = toNumber(b.priority) - toNumber(a.priority)
+        if (priorityDelta !== 0) return priorityDelta
+        return toNumber(a.wake_at) - toNumber(b.wake_at)
+      })
       return rows.map((row) => ({
         runId: row.run_id,
         wakeAt: toNumber(row.wake_at),
+        priority: toNumber(row.priority),
         leaseOwner: row.lease_owner ?? undefined,
         leaseExpiresAt: row.lease_expires_at === null ? undefined : toNumber(row.lease_expires_at),
         updatedAt: toNumber(row.updated_at),
@@ -125,6 +133,7 @@ export function wakeupToRow(
   return {
     runId: record.runId,
     wakeAt: record.wakeAt,
+    priority: record.priority ?? 0,
     leaseOwner: record.leaseOwner ?? null,
     leaseExpiresAt: record.leaseExpiresAt ?? null,
     updatedAt,
@@ -135,6 +144,7 @@ export function rowToWakeupRecord(row: typeof wakeupsTable.$inferSelect): Wakeup
   return {
     runId: row.runId,
     wakeAt: row.wakeAt,
+    priority: row.priority,
     leaseOwner: row.leaseOwner ?? undefined,
     leaseExpiresAt: row.leaseExpiresAt ?? undefined,
     updatedAt: row.updatedAt,

package/src/scheduler.ts

@@ -1,250 +1,13 @@
-import type { Duration, EnvironmentName, ScheduleDeclaration } from "@voyantjs/workflows"
-
-export interface ScheduleSource {
-  workflowId: string
-  decl: ScheduleDeclaration
-}
-
-export interface SchedulerDeps {
-  sources: readonly ScheduleSource[]
-  onFire: (args: { workflowId: string; input: unknown; scheduleName?: string }) => Promise<void>
-  now?: () => number
-  environment?: EnvironmentName
-  tickMs?: number
-  setInterval?: typeof setInterval
-  clearInterval?: typeof clearInterval
-  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
-}
-
-export interface SchedulerHandle {
-  start: () => void
-  stop: () => void
-  tick: () => Promise<void>
-  nextFirings: () => { workflowId: string; name?: string; nextAt: number; done: boolean }[]
-  sourceCount: () => number
-}
-
-interface SourceState {
-  source: ScheduleSource
-  nextAt: number
-  done: boolean
-  inFlight: boolean
-}
-
-export function createScheduler(deps: SchedulerDeps): SchedulerHandle {
-  const now = deps.now ?? (() => Date.now())
-  const tickMs = deps.tickMs ?? 1_000
-  const setInt = deps.setInterval ?? setInterval
-  const clearInt = deps.clearInterval ?? clearInterval
-  const env = deps.environment ?? "development"
-  const log = deps.logger ?? (() => {})
-
-  const states: SourceState[] = []
-  for (const source of deps.sources) {
-    if (source.decl.enabled === false) continue
-    if (source.decl.environments && !source.decl.environments.includes(env)) continue
-    let firstAt: number
-    try {
-      firstAt = computeNextFire(source.decl, now())
-    } catch (err) {
-      log("warn", `scheduler: skipping source for workflow "${source.workflowId}": ${String(err)}`)
-      continue
-    }
-    states.push({ source, nextAt: firstAt, done: false, inFlight: false })
-  }
-
-  let timer: ReturnType<typeof setInterval> | undefined
-
-  const advanceAfterFire = (state: SourceState, firedAt: number): void => {
-    if ("at" in state.source.decl) {
-      state.done = true
-      return
-    }
-    try {
-      state.nextAt = computeNextFire(state.source.decl, firedAt)
-    } catch (err) {
-      log(
-        "error",
-        `scheduler: cannot compute next fire for "${state.source.workflowId}": ${String(err)}`,
-      )
-      state.done = true
-    }
-  }
-
-  const doTick = async (): Promise<void> => {
-    const t = now()
-    const ready = states.filter((state) => !state.done && state.nextAt <= t)
-    for (const state of ready) {
-      const overlap = state.source.decl.overlap ?? "skip"
-      if (state.inFlight && overlap === "skip") continue
-      let input: unknown
-      try {
-        input = await resolveInput(state.source.decl.input)
-      } catch (err) {
-        log(
-          "error",
-          `scheduler: failed to resolve input for "${state.source.workflowId}": ${String(err)}`,
-        )
-        advanceAfterFire(state, t)
-        continue
-      }
-      state.inFlight = true
-      const firePromise = (async () => {
-        try {
-          await deps.onFire({
-            workflowId: state.source.workflowId,
-            input,
-            scheduleName: state.source.decl.name,
-          })
-        } catch (err) {
-          log("error", `scheduler: onFire threw for "${state.source.workflowId}": ${String(err)}`)
-        } finally {
-          state.inFlight = false
-        }
-      })()
-      advanceAfterFire(state, t)
-      if (overlap === "skip") await firePromise
-    }
-  }
-
-  return {
-    start() {
-      if (timer) return
-      timer = setInt(() => {
-        doTick().catch(() => {})
-      }, tickMs)
-      ;(timer as unknown as { unref?: () => void }).unref?.()
-    },
-    stop() {
-      if (!timer) return
-      clearInt(timer)
-      timer = undefined
-    },
-    tick: doTick,
-    nextFirings() {
-      return states.map((state) => ({
-        workflowId: state.source.workflowId,
-        name: state.source.decl.name,
-        nextAt: state.nextAt,
-        done: state.done,
-      }))
-    },
-    sourceCount() {
-      return states.length
-    },
-  }
-}
-
-async function resolveInput(
-  input: unknown | (() => unknown | Promise<unknown>) | undefined,
-): Promise<unknown> {
-  if (typeof input === "function") {
-    return await (input as () => unknown | Promise<unknown>)()
-  }
-  return input
-}
-
-export function computeNextFire(decl: ScheduleDeclaration, fromMs: number): number {
-  if ("cron" in decl) return nextCronFire(parseCron(decl.cron), fromMs)
-  if ("every" in decl) return fromMs + toMs(decl.every)
-  if ("at" in decl) {
-    const at = typeof decl.at === "string" ? Date.parse(decl.at) : decl.at.getTime()
-    if (!Number.isFinite(at)) throw new Error(`invalid "at" value: ${String(decl.at)}`)
-    return at < fromMs ? Number.POSITIVE_INFINITY : at
-  }
-  throw new Error(`schedule declaration missing one of cron/every/at`)
-}
-
-export interface CronSpec {
-  minute: number[]
-  hour: number[]
-  day: number[]
-  month: number[]
-  dow: number[]
-}
-
-export function parseCron(expr: string): CronSpec {
-  const parts = expr.trim().split(/\s+/)
-  if (parts.length !== 5) {
-    throw new Error(`invalid cron "${expr}" — expected 5 fields (minute hour day month dow)`)
-  }
-  return {
-    minute: parseField(parts[0]!, 0, 59, "minute"),
-    hour: parseField(parts[1]!, 0, 23, "hour"),
-    day: parseField(parts[2]!, 1, 31, "day"),
-    month: parseField(parts[3]!, 1, 12, "month"),
-    dow: parseField(parts[4]!, 0, 6, "dow"),
-  }
-}
-
-function parseField(f: string, min: number, max: number, label: string): number[] {
-  const out = new Set<number>()
-  for (const part of f.split(",")) {
-    const stepMatch = /^(.+)\/(\d+)$/.exec(part)
-    const body = stepMatch ? stepMatch[1]! : part
-    const step = stepMatch ? Number(stepMatch[2]) : 1
-    if (!(step >= 1)) throw new Error(`cron ${label} step must be >=1 in "${f}"`)
-    let lo: number
-    let hi: number
-    if (body === "*") {
-      lo = min
-      hi = max
-    } else if (body.includes("-")) {
-      const [a, b] = body.split("-")
-      lo = Number(a)
-      hi = Number(b)
-    } else {
-      lo = Number(body)
-      hi = lo
-    }
-    if (!Number.isFinite(lo) || !Number.isFinite(hi) || lo < min || hi > max || lo > hi) {
-      throw new Error(`cron ${label} out of range [${min}..${max}] in "${f}"`)
-    }
-    for (let i = lo; i <= hi; i += step) out.add(i)
-  }
-  return [...out].sort((a, b) => a - b)
-}
-
-export function nextCronFire(spec: CronSpec, fromMs: number): number {
-  const date = new Date(fromMs)
-  date.setUTCSeconds(0, 0)
-  date.setUTCMinutes(date.getUTCMinutes() + 1)
-
-  const maxIterations = 60 * 24 * 366 * 5
-  for (let i = 0; i < maxIterations; i++) {
-    if (
-      spec.minute.includes(date.getUTCMinutes()) &&
-      spec.hour.includes(date.getUTCHours()) &&
-      spec.day.includes(date.getUTCDate()) &&
-      spec.month.includes(date.getUTCMonth() + 1) &&
-      spec.dow.includes(date.getUTCDay())
-    ) {
-      return date.getTime()
-    }
-    date.setUTCMinutes(date.getUTCMinutes() + 1)
-  }
-  throw new Error("cron search exceeded 5 years without finding a match")
-}
-
-export function toMs(duration: Duration): number {
-  if (typeof duration === "number") return duration
-  const m = /^(\d+)(ms|s|m|h|d|w)$/.exec(duration)
-  if (!m) throw new Error(`invalid duration "${duration}"`)
-  const n = Number(m[1])
-  switch (m[2]) {
-    case "ms":
-      return n
-    case "s":
-      return n * 1_000
-    case "m":
-      return n * 60_000
-    case "h":
-      return n * 3_600_000
-    case "d":
-      return n * 86_400_000
-    case "w":
-      return n * 604_800_000
-    default:
-      throw new Error(`invalid duration "${duration}"`)
-  }
-}
+export {
+  type CronSpec,
+  computeNextFire,
+  createScheduler,
+  manifestScheduleSources,
+  nextCronFire,
+  parseCron,
+  type SchedulableDeclaration,
+  type SchedulerDeps,
+  type SchedulerHandle,
+  type ScheduleSource,
+  toMs,
+} from "@voyantjs/workflows-orchestrator"

package/src/wakeup-store.ts

@@ -6,6 +6,7 @@ import { findEarliestWakeAt } from "./sleep-alarm-manager.js"
 export interface WakeupRecord {
   runId: string
   wakeAt: number
+  priority?: number
   leaseOwner?: string
   leaseExpiresAt?: number
   updatedAt: number
@@ -74,7 +75,7 @@ export function createFsWakeupStore(opts: FsWakeupStoreOptions = {}): WakeupStor
     },
 
     async leaseDue({ owner, now: at = now(), leaseMs, limit = 25 }) {
-      const wakeups = await this.list()
+      const wakeups = (await this.list()).sort(compareWakeupClaimOrder)
       const leased: WakeupRecord[] = []
       for (const wakeup of wakeups) {
         if (leased.length >= limit) break
@@ -119,11 +120,18 @@ export async function syncWakeupFromRecord(store: WakeupStore, record: RunRecord
   await store.upsert({
     runId: record.id,
     wakeAt,
+    priority: record.priority,
     leaseOwner: undefined,
     leaseExpiresAt: undefined,
   })
 }
 
+function compareWakeupClaimOrder(a: WakeupRecord, b: WakeupRecord): number {
+  const priorityDelta = (b.priority ?? 0) - (a.priority ?? 0)
+  if (priorityDelta !== 0) return priorityDelta
+  return a.wakeAt - b.wakeAt
+}
+
 async function safeReaddir(dir: string): Promise<string[]> {
   try {
     const entries = await readdir(dir)