@gobing-ai/ts-infra 0.4.59 → 0.4.62

package/dist/job-queue/db-job-queue.js

@@ -1,3 +1,4 @@
+import { resolveExecutionTimeoutMs, runWithExecutionDeadline } from '../execution-policy.js';
 import { settleWithin } from '../internals/drain.js';
 import { getLogger } from '../logger.js';
 import { getQueueJobCompletedTotal, getQueueJobEnqueuedTotal, getQueueJobFailedTotal, getQueueJobProcessingDuration, } from '../telemetry/metrics.js';
@@ -51,7 +52,7 @@ function enqueuedDetail(jobId, type, options) {
         detail.ttlMs = options.ttlMs;
     return detail;
 }
-/** DB-backed queue consumer with polling, retry, and visibility-timeout handling. */
+/** DB-backed queue consumer with polling, retry, lease ownership, and execution-deadline handling. */
 export class DBQueueConsumer {
     dao;
     handlers = new Map();
@@ -62,6 +63,11 @@ export class DBQueueConsumer {
     baseDelay;
     maxDelay;
     drainTimeoutMs;
+    drainPolicy;
+    /** Default execution policy for jobs without their own persisted decision; `null` = unlimited. */
+    defaultTimeoutMs;
+    /** Live attempts owned by this consumer, keyed by job id — the target of `cancel()`. */
+    activeAttempts = new Map();
     /**
      * Validated event sink: the bus plus the non-empty queue name its lifecycle rows
      * require (ADR-068). `undefined` for silent consumers — no `events`, no identity.
@@ -80,6 +86,15 @@ export class DBQueueConsumer {
         this.baseDelay = nonNegativeFiniteConfig('baseDelay', config.baseDelay ?? 1_000);
         this.maxDelay = nonNegativeFiniteConfig('maxDelay', config.maxDelay ?? 60_000);
         this.drainTimeoutMs = nonNegativeFiniteConfig('drainTimeoutMs', config.drainTimeoutMs ?? 30_000);
+        this.drainPolicy = config.drainPolicy ?? 'bounded';
+        if (config.defaultTimeoutMs !== undefined &&
+            config.defaultTimeoutMs !== null &&
+            (typeof config.defaultTimeoutMs !== 'number' ||
+                !Number.isInteger(config.defaultTimeoutMs) ||
+                config.defaultTimeoutMs <= 0)) {
+            throw new RangeError(`Queue consumer defaultTimeoutMs must be a positive integer or null; received ${String(config.defaultTimeoutMs)}`);
+        }
+        this.defaultTimeoutMs = config.defaultTimeoutMs ?? null;
         this.eventSink = resolveEventSink(config);
     }
     register(type, handler) {
@@ -110,6 +125,7 @@ export class DBQueueConsumer {
             clearTimeout(this.timer);
             this.timer = null;
         }
+        const drainToCompletion = this.drainPolicy === 'drain-to-completion';
         const deadline = Date.now() + this.drainTimeoutMs;
         // Wait for an already-running poll cycle before consulting `inFlight`.
         // `inFlight` is only incremented once claimReady() has resolved, so a stop()
@@ -118,10 +134,26 @@ export class DBQueueConsumer {
         // to claim and process jobs after stop() resolved.
         const pending = this.pollPromise;
         if (pending !== null) {
-            await settleWithin(pending, deadline);
+            if (drainToCompletion) {
+                await pending;
+            }
+            else {
+                await settleWithin(pending, deadline);
+            }
         }
-        while (this.inFlight > 0 && Date.now() < deadline) {
-            await sleep(10);
+        if (drainToCompletion) {
+            // Shutdown policy (A21): wait for every in-flight attempt to settle,
+            // however long that takes. Leases keep renewing while we wait.
+            while (this.inFlight > 0) {
+                await sleep(10);
+            }
+        }
+        else {
+            while (this.inFlight > 0 && Date.now() < deadline) {
+                await sleep(10);
+            }
+            // Bounded drain expiry (A21): attempts still running keep ownership —
+            // their leases keep renewing and they are acknowledged when they settle.
         }
         if (wasRunning) {
             const drained = this.inFlight === 0;
@@ -138,6 +170,14 @@ export class DBQueueConsumer {
             }
         }
     }
+    async cancel(jobId) {
+        const attempt = this.activeAttempts.get(jobId);
+        if (attempt === undefined)
+            return false;
+        attempt.state.cancelled = true;
+        attempt.controller.abort();
+        return true;
+    }
     async stats() {
         return this.dao.getStats();
     }
@@ -146,7 +186,7 @@ export class DBQueueConsumer {
         return traceAsync('queue.poll', async () => {
             await this.dao.resetStuckJobs(this.visibilityTimeout);
             await this.dao.failExpiredJobs();
-            const jobs = await this.dao.claimReady(this.batchSize);
+            const jobs = await this.dao.claimReady(this.batchSize, { leaseMs: this.visibilityTimeout });
             let processed = 0;
             for (let index = 0; index < jobs.length; index += this.maxConcurrency) {
                 const batch = jobs.slice(index, index + this.maxConcurrency);
@@ -203,7 +243,7 @@ export class DBQueueConsumer {
         catch (error) {
             // Corrupt payload — the job can never parse; route it through the
             // retry/fail path instead of rejecting the whole batch.
-            await this.failOrRetry(record, error, 0);
+            await this.failOrRetry(record, error, 0, record.attemptToken ?? undefined);
             return;
         }
         return traceAsync('queue.job.process', async () => {
@@ -213,38 +253,135 @@ export class DBQueueConsumer {
                 'queue.job_attempt': job.attempts,
             });
             const handler = this.handlers.get(job.type);
+            const token = record.attemptToken ?? undefined;
             if (handler === undefined) {
-                await this.failOrRetry(job, new Error(`No handler registered for job type "${job.type}"`), 0);
+                await this.failOrRetry(job, new Error(`No handler registered for job type "${job.type}"`), 0, token);
                 return;
             }
-            const startMs = performance.now();
+            // Per-attempt ownership (A21): the fresh claim token fences every
+            // acknowledgement, and the external controller carries lease-loss and
+            // manual cancellation into the shared deadline clock.
+            let attemptWake;
+            const attempt = { lost: false, cancelled: false, settled: false };
+            const attemptAbort = new AbortController();
+            if (token !== undefined) {
+                const { promise: settledSignal, resolve: resolveSettled } = Promise.withResolvers();
+                attempt.settledSignal = settledSignal;
+                attemptWake = resolveSettled;
+                // Shares the `attempt` object reference so cancel() mutations are
+                // visible in the outcome dispatch below.
+                this.activeAttempts.set(record.id, { controller: attemptAbort, state: attempt });
+            }
+            const renewal = token === undefined
+                ? undefined
+                : this.renewUntilSettled(record.id, token, attempt, attemptAbort).catch(() => { });
             try {
-                await handler(job);
-                await this.dao.markCompleted(job.id);
+                const resolvedTimeout = resolveExecutionTimeoutMs(`job "${job.type}"`, record.timeoutUnlimited === 1 ? null : (record.timeoutMs ?? undefined), this.defaultTimeoutMs);
+                const startMs = performance.now();
+                const outcome = await runWithExecutionDeadline((context) => handler(job, context), {
+                    timeoutMs: resolvedTimeout,
+                    signal: attemptAbort.signal,
+                });
+                attempt.settled = true;
+                attemptWake?.();
                 const durationMs = performance.now() - startMs;
-                getQueueJobCompletedTotal().add(1, { type: job.type });
-                getQueueJobProcessingDuration().record(durationMs, { type: job.type });
-                const completed = {
-                    jobId: job.id,
+                getQueueJobProcessingDuration().record(Number.isFinite(durationMs) ? durationMs : 0, {
                     type: job.type,
-                    durationMs: Number.isFinite(durationMs) ? durationMs : 0,
-                    attempt: job.attempts,
-                    severity: 'info',
-                };
-                await this.eventSink?.bus.emit('queue.job.completed', completed);
+                });
+                if (attempt.lost) {
+                    // Ownership was lost: the row now belongs to a replacement attempt
+                    // claimed through the expired lease. Fence every acknowledgement —
+                    // a stale ack must never mutate the replacement's work (R4).
+                    queueLogger().warn('queue attempt lost lease ownership; acknowledgement fenced', {
+                        jobId: record.id,
+                        type: job.type,
+                        outcome: outcome.outcome,
+                    });
+                    return;
+                }
+                if (outcome.outcome === 'error') {
+                    await this.failOrRetry(job, outcome.error, Number.isFinite(durationMs) ? durationMs : 0, token);
+                }
+                else if (outcome.timedOut) {
+                    // Deadline expiry is a failure like any other, reported only after
+                    // the handler has settled — even if it ignored the abort.
+                    await this.failOrRetry(job, outcome.error, Number.isFinite(durationMs) ? durationMs : 0, token);
+                }
+                else if (attempt.cancelled) {
+                    // Manual cancellation is terminal: settle, then fail without retry.
+                    const message = 'job cancelled';
+                    const applied = await this.dao.markFailed(record.id, job.attempts + 1, message, token);
+                    if (applied) {
+                        getQueueJobFailedTotal().add(1, { type: job.type });
+                        await this.eventSink?.bus.emit('queue.job.failed', {
+                            jobId: job.id,
+                            type: job.type,
+                            error: message,
+                            attempt: job.attempts + 1,
+                            maxRetries: job.maxRetries,
+                            durationMs: Number.isFinite(durationMs) ? durationMs : 0,
+                            severity: 'warning',
+                        });
+                    }
+                }
+                else {
+                    await this.dao.markCompleted(record.id, token);
+                    getQueueJobCompletedTotal().add(1, { type: job.type });
+                    const completed = {
+                        jobId: job.id,
+                        type: job.type,
+                        durationMs: Number.isFinite(durationMs) ? durationMs : 0,
+                        attempt: job.attempts,
+                        severity: 'info',
+                    };
+                    await this.eventSink?.bus.emit('queue.job.completed', completed);
+                }
             }
-            catch (error) {
-                const durationMs = performance.now() - startMs;
-                getQueueJobProcessingDuration().record(durationMs, { type: job.type });
-                await this.failOrRetry(job, error, Number.isFinite(durationMs) ? durationMs : 0);
+            finally {
+                attempt.settled = true;
+                attemptWake?.();
+                if (renewal !== undefined)
+                    await renewal;
+                if (token !== undefined)
+                    this.activeAttempts.delete(record.id);
             }
         });
     }
-    async failOrRetry(job, error, durationMs) {
+    /**
+     * Extend the attempt's lease on an interval derived from the visibility
+     * timeout, proving this consumer is still alive and working. A failed or
+     * erroring renewal means ownership was lost: abort the attempt so the
+     * handler can stop, and mark the attempt fenced.
+     */
+    async renewUntilSettled(id, token, attempt, attemptAbort) {
+        const intervalMs = Math.max(1, Math.floor(this.visibilityTimeout / 3));
+        while (!attempt.settled) {
+            // Settle-aware wait: wakes early when the attempt finishes so a long
+            // visibility timeout never delays acknowledgement past the handler.
+            await Promise.race([sleep(intervalMs), attempt.settledSignal]);
+            if (attempt.settled)
+                return;
+            let renewed = false;
+            try {
+                renewed = await this.dao.renewLease(id, token, this.visibilityTimeout);
+            }
+            catch {
+                renewed = false; // DB unavailability is treated like ownership loss
+            }
+            if (attempt.settled)
+                return;
+            if (!renewed) {
+                attempt.lost = true;
+                attemptAbort.abort();
+                return;
+            }
+        }
+    }
+    async failOrRetry(job, error, durationMs, attemptToken) {
         const attempts = job.attempts + 1;
         const message = error instanceof Error ? error.message : String(error);
         if (attempts >= job.maxRetries) {
-            await this.dao.markFailed(job.id, attempts, message);
+            await this.dao.markFailed(job.id, attempts, message, attemptToken);
             getQueueJobFailedTotal().add(1, { type: job.type });
             const failed = {
                 jobId: job.id,
@@ -260,7 +397,7 @@ export class DBQueueConsumer {
         }
         const delay = Math.min(this.maxDelay, this.baseDelay * 2 ** Math.max(0, attempts - 1));
         const nextRetryAt = Date.now() + delay;
-        await this.dao.markForRetry(job.id, attempts, message, nextRetryAt);
+        await this.dao.markForRetry(job.id, attempts, message, nextRetryAt, attemptToken);
         const retrying = {
             jobId: job.id,
             type: job.type,
@@ -286,6 +423,8 @@ function toJob(record) {
         nextRetryAt: record.nextRetryAt,
         lastError: record.lastError,
         processingAt: record.processingAt,
+        // Persisted job policy: explicit unlimited stays `null`, absence stays undefined.
+        timeoutMs: record.timeoutUnlimited === 1 ? null : (record.timeoutMs ?? undefined),
     };
 }
 function sleep(ms) {

package/dist/job-queue/types.d.ts

@@ -6,7 +6,8 @@
  */
 import type { EventBus } from '../event-bus/event-bus';
 import type { QueueEvents } from '../events';
-/** A queued job with status tracking, retry metadata, and timestamps. */
+import type { ExecutionContext } from '../execution-policy';
+/** A queued job with status tracking, retry metadata, timestamps, and its persisted execution policy. */
 export interface Job<T = unknown> {
     id: string;
     type: string;
@@ -20,13 +21,26 @@ export interface Job<T = unknown> {
     nextRetryAt: number | null;
     lastError: string | null;
     processingAt: number | null;
+    /**
+     * Job-level execution policy as persisted: a positive integer ms deadline,
+     * explicit `null` = unlimited, or `undefined` = no job-level decision (the
+     * consumer default applies). Never the resolved per-attempt value.
+     */
+    timeoutMs?: number | null;
 }
-/** Options for enqueuing a job: retry policy, delay, and TTL. */
+/** Options for enqueuing a job: retry policy, delay, TTL, and execution policy. */
 export interface EnqueueOptions {
     /** Total attempts allowed (default 3) — `maxRetries: 1` runs the job once with no retry. */
     maxRetries?: number;
     delay?: number;
     ttlMs?: number;
+    /**
+     * Job execution policy persisted with the row: a positive integer ms
+     * deadline, explicit `null` = unlimited (disables this job's deadline),
+     * omitted = no job-level decision (consumers apply their own default).
+     * Invalid explicit values are rejected before the row is created.
+     */
+    timeoutMs?: number | null;
 }
 /** Producer interface for the job queue — enqueue single jobs or batches. */
 export interface JobQueue<T = unknown> {
@@ -37,8 +51,12 @@ export interface JobQueue<T = unknown> {
     } & EnqueueOptions>): Promise<string[]>;
     stats(): Promise<QueueStats>;
 }
-/** Async handler that processes a single job. */
-export type JobHandler<T = unknown> = (job: Job<T>) => Promise<void>;
+/**
+ * Async handler that processes a single job. The context carries the shared
+ * execution deadline clock for this attempt; single-argument handlers stay
+ * assignable.
+ */
+export type JobHandler<T = unknown> = (job: Job<T>, context: ExecutionContext) => Promise<void>;
 /** Aggregate statistics for a job queue: counts by status. */
 export interface QueueStats {
     pending: number;
@@ -46,7 +64,7 @@ export interface QueueStats {
     completed: number;
     failed: number;
 }
-/** Configuration for a queue consumer: polling, concurrency, and backoff. */
+/** Configuration for a queue consumer: polling, concurrency, backoff, and the default execution policy. */
 export interface QueueConsumerConfig {
     pollInterval?: number;
     batchSize?: number;
@@ -56,6 +74,20 @@ export interface QueueConsumerConfig {
     maxDelay?: number;
     /** Upper bound (ms, default 30_000) on how long `stop()` waits for in-flight work to drain. */
     drainTimeoutMs?: number;
+    /**
+     * Shutdown drain policy (A21). `'bounded'` (default): `stop()` gives up after
+     * `drainTimeoutMs`; attempts still running keep their leases, keep renewing, and
+     * are acknowledged when they settle. `'drain-to-completion'`: `stop()` waits for
+     * all in-flight attempts to settle, however long that takes.
+     */
+    drainPolicy?: 'bounded' | 'drain-to-completion';
+    /**
+     * Default execution policy for jobs without their own persisted decision
+     * (A21): a positive integer ms deadline or explicit `null` = unlimited.
+     * First-match-wins: an explicit job option — including job `null` — beats
+     * this default; absence inherits it.
+     */
+    defaultTimeoutMs?: number | null;
     /**
      * Identity of the queue this consumer polls. Runtime-required whenever `events` is
      * configured (ADR-068): an observable consumer must never emit an anonymous lifecycle
@@ -76,10 +108,18 @@ export interface QueueConsumerConfig {
 export interface QueueConsumer<T = unknown> {
     register(type: string, handler: JobHandler<T>): void;
     start(): Promise<void>;
+    /**
+     * Request cooperative cancellation of a claimed attempt (A21). The context
+     * signal aborts with reason `'cancelled'`; the attempt is allowed to settle
+     * and is then failed without retry. Resolves `false` when the job is not
+     * currently owned by this consumer.
+     */
+    cancel(jobId: string): Promise<boolean>;
     /**
      * Stop polling and drain work already in flight, including a poll cycle that has
-     * claimed nothing yet. Resolves once the drain completes or `drainTimeoutMs`
-     * elapses — whichever comes first, so a hung handler cannot block shutdown.
+     * claimed nothing yet. Under the default `'bounded'` policy this resolves once the
+     * drain completes or `drainTimeoutMs` elapses; `'drain-to-completion'` ignores the
+     * bound and waits for every in-flight attempt.
      */
     stop(): Promise<void>;
     stats(): Promise<QueueStats>;

package/dist/job-queue/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/job-queue/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,yEAAyE;AACzE,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,OAAO;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC3B,4FAA4F;IAC5F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACjC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7E,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,GAAG,cAAc,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5F,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CAChC;AAED,iDAAiD;AACjD,MAAM,MAAM,UAAU,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAErE,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;CAClC;AAED,gGAAgG;AAChG,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;OAIG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CAChC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/job-queue/types.ts"],"names":[],"mappings":"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"}

package/dist/scheduler/cloudflare.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Cloudflare Workers scheduler adapter using Cron Triggers.
+ * Uses minimal local type declarations — no @cloudflare/workers-types dependency.
+ */
 import type { ScheduledAction, SchedulerAdapter } from './types';
 interface CfScheduledEvent {
     cron: string;

package/dist/scheduler/cloudflare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../src/scheduler/cloudflare.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEjE,UAAU,gBAAgB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED,UAAU,cAAc;IACpB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;;IAI9D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IAI/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;OAGG;IACH,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI;CAmB3E"}
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../src/scheduler/cloudflare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEjE,UAAU,gBAAgB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED,UAAU,cAAc;IACpB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;;IAI9D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IAI/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;OAGG;IACH,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI;CAmB3E"}

package/dist/scheduler/cloudflare.js

@@ -2,6 +2,7 @@
  * Cloudflare Workers scheduler adapter using Cron Triggers.
  * Uses minimal local type declarations — no @cloudflare/workers-types dependency.
  */
+import { unlimitedExecutionContext } from '../execution-policy.js';
 import { getSchedulerJobDuration, getSchedulerJobExecutedTotal, getSchedulerJobFailedTotal, } from '../telemetry/metrics.js';
 /**
  * Scheduler adapter for Cloudflare Workers Cron Triggers.
@@ -38,7 +39,7 @@ export class CloudflareSchedulerAdapter {
         if (action) {
             const startMs = performance.now();
             getSchedulerJobExecutedTotal().add(1, { cron: event.cron });
-            ctx.waitUntil(action()
+            ctx.waitUntil(action(unlimitedExecutionContext())
                 .catch((error) => {
                 getSchedulerJobFailedTotal().add(1, { cron: event.cron });
                 throw error;

package/dist/scheduler/index.d.ts

@@ -1,6 +1,6 @@
 export { ActionRegistry, type CreateDefaultRegistryOptions, createDefaultRegistry, HealthPingAction, type HealthPingWriter, LogAction, QueueStatsAction, type QueueStatsDaoProvider, type SchedulerAction, toScheduledAction, } from './action';
 export { initScheduler } from './factory';
 export { NoopSchedulerAdapter } from './noop';
-export type { ScheduledAction, SchedulerAdapter, SchedulerJobConfig } from './types';
+export type { ScheduledAction, ScheduledActionOptions, SchedulerAdapter, SchedulerJobConfig, } from './types';
 export { wrapScheduledHandler } from './wrap-handler';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scheduler/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,cAAc,EACd,KAAK,4BAA4B,EACjC,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,SAAS,EACT,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,iBAAiB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scheduler/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,cAAc,EACd,KAAK,4BAA4B,EACjC,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,SAAS,EACT,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,iBAAiB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC9C,YAAY,EACR,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/scheduler/node.d.ts

@@ -8,6 +8,12 @@
 import type { ScheduledAction, SchedulerAdapter } from './types';
 /** Constructor options for {@link NodeSchedulerAdapter}. */
 export interface NodeSchedulerAdapterConfig {
+    /**
+     * Default execution policy (A21) for entries registered without their own
+     * `timeoutMs` option: a positive integer ms deadline or explicit `null` =
+     * unlimited. Invalid values throw at construction.
+     */
+    readonly timeoutMs?: number | null;
     /**
      * Upper bound (ms) on how long `stop()` waits for an in-flight tick to settle.
      * A hung action is abandoned at this deadline so it cannot block shutdown.
@@ -32,11 +38,14 @@ export interface NodeSchedulerAdapterConfig {
 export declare class NodeSchedulerAdapter implements SchedulerAdapter {
     private readonly entries;
     private readonly drainTimeoutMs;
+    private readonly defaultTimeoutMs;
     private readonly now;
     private running;
     private readonly inflight;
     constructor(config?: NodeSchedulerAdapterConfig);
-    register(cron: string, action: ScheduledAction): void;
+    register(cron: string, action: ScheduledAction, options?: {
+        timeoutMs?: number | null;
+    }): void;
     private parseEntry;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/scheduler/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/scheduler/node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA0DjE,4DAA4D;AAC5D,MAAM,WAAW,0BAA0B;IACvC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;gBAEzC,MAAM,GAAE,0BAA+B;IAWnD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IAWrD,OAAO,CAAC,UAAU;IAYZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAwB3B,OAAO,CAAC,UAAU;IAiBlB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAwBf;;;;;OAKG;YACW,QAAQ;YAsBR,gBAAgB;CAYjC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/scheduler/node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA4DjE,4DAA4D;AAC5D,MAAM,WAAW,0BAA0B;IACvC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IACvD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;gBAEzC,MAAM,GAAE,0BAA+B;IAYnD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI;IAW9F,OAAO,CAAC,UAAU;IAoBZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAwB3B,OAAO,CAAC,UAAU;IAiBlB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAwBf;;;;;OAKG;YACW,QAAQ;YAsBR,gBAAgB;CAyBjC"}

package/dist/scheduler/node.js

@@ -5,7 +5,9 @@
  * No external cron library dependency — cron expressions are parsed by the
  * internal `scheduler/cron.ts` grammar shared with `application-node.ts`.
  */
+import { resolveExecutionTimeoutMs, runWithExecutionDeadline } from '../execution-policy.js';
 import { settleWithin } from '../internals/drain.js';
+import { getLogger } from '../logger.js';
 import { getSchedulerJobDuration, getSchedulerJobExecutedTotal, getSchedulerJobFailedTotal, } from '../telemetry/metrics.js';
 import { nextCronTime, parseCronExpression } from './cron.js';
 /** Platform timer maximum for `setTimeout` (2^31 - 1 ms). Longer delays are chunked. */
@@ -53,6 +55,7 @@ function parseInterval(cron) {
 export class NodeSchedulerAdapter {
     entries = [];
     drainTimeoutMs;
+    defaultTimeoutMs;
     now;
     running = false;
     inflight = new Set();
@@ -62,28 +65,33 @@ export class NodeSchedulerAdapter {
             throw new RangeError(`NodeSchedulerAdapter drainTimeoutMs must be a non-negative finite number; received ${drainTimeoutMs}`);
         }
         this.drainTimeoutMs = drainTimeoutMs ?? 30_000;
+        this.defaultTimeoutMs = resolveExecutionTimeoutMs('NodeSchedulerAdapter', config.timeoutMs ?? undefined);
         this.now = now ?? (() => Date.now());
     }
-    register(cron, action) {
+    register(cron, action, options) {
         // Fail at registration time: an unsupported expression must never reach
         // start(), where it would otherwise create a silently-wrong interval
         // (task 0060 F7) or a never-firing cron (task 0734 R1).
-        const entry = this.parseEntry(cron, action);
+        const entry = this.parseEntry(cron, action, options);
         this.entries.push(entry);
         if (this.running) {
             this.startEntry(entry);
         }
     }
-    parseEntry(cron, action) {
+    parseEntry(cron, action, options) {
+        // Resolve the entry's execution policy now: an explicit option (including
+        // explicit null) wins, absence inherits the adapter default. Invalid
+        // options throw here rather than leaving a tick to discover it mid-flight.
+        const timeoutMs = resolveExecutionTimeoutMs(`scheduler entry "${cron}"`, options?.timeoutMs, this.defaultTimeoutMs);
         const intervalMs = parseInterval(cron);
         if (intervalMs !== undefined) {
-            return { kind: 'interval', cron, action, intervalMs };
+            return { kind: 'interval', cron, action, intervalMs, timeoutMs };
         }
         // Real five-field cron. Validate and verify a next occurrence exists at
         // registration (bounded scan) so an unsatisfiable expression fails here.
         const expr = parseCronExpression(cron);
         const target = nextCronTime(expr, this.now()).getTime();
-        return { kind: 'cron', cron, action, expr, target };
+        return { kind: 'cron', cron, action, expr, target, timeoutMs };
     }
     async start() {
         if (this.running)
@@ -187,7 +195,21 @@ export class NodeSchedulerAdapter {
         const startMs = performance.now();
         getSchedulerJobExecutedTotal().add(1, { cron: entry.cron });
         try {
-            await entry.action();
+            // One shared deadline clock per tick (A21): expiry aborts the
+            // context and the action is always awaited to settlement. Timeout
+            // counts as a failure; the adapter keeps ticking.
+            const outcome = await runWithExecutionDeadline(entry.action, { timeoutMs: entry.timeoutMs });
+            if (outcome.timedOut) {
+                getSchedulerJobFailedTotal().add(1, { cron: entry.cron });
+                getLogger('scheduler').warn('scheduled tick exceeded its execution deadline', {
+                    cron: entry.cron,
+                    timeoutMs: entry.timeoutMs,
+                    elapsedMs: Math.round(outcome.elapsedMs),
+                });
+            }
+            else if (outcome.outcome === 'error') {
+                getSchedulerJobFailedTotal().add(1, { cron: entry.cron });
+            }
         }
         catch {
             // Swallow — scheduler errors should not crash the process

package/dist/scheduler/types.d.ts

@@ -1,8 +1,23 @@
 /**
  * Scheduler types and interface.
  */
-/** Signature for scheduled action handlers. */
-export type ScheduledAction = () => Promise<void>;
+import type { ExecutionContext } from '../execution-policy';
+/**
+ * Signature for scheduled action handlers. The context carries the shared
+ * execution-deadline clock for this tick (A21); zero-argument handlers stay
+ * assignable — notably the Cloudflare adapter, which invokes actions with an
+ * unlimited execution context (no wall-clock deadline on that runtime).
+ */
+export type ScheduledAction = (context: ExecutionContext) => Promise<void>;
+/** Per-entry execution policy options for {@link SchedulerAdapter.register}. */
+export interface ScheduledActionOptions {
+    /**
+     * Execution policy for this entry's ticks: a positive integer ms deadline,
+     * explicit `null` = unlimited, omitted = inherit the adapter default.
+     * Invalid explicit values throw at registration time.
+     */
+    timeoutMs?: number | null;
+}
 /**
  * Abstract scheduler interface — implementations for Node and Cloudflare.
  *
@@ -11,7 +26,7 @@ export type ScheduledAction = () => Promise<void>;
  * action is abandoned at the deadline rather than blocking shutdown forever.
  */
 export interface SchedulerAdapter {
-    register(cron: string, action: ScheduledAction): void;
+    register(cron: string, action: ScheduledAction, options?: ScheduledActionOptions): void;
     start(): Promise<void>;
     stop(): Promise<void>;
 }
@@ -29,10 +44,12 @@ export type SchedulerJobConfig = {
     readonly command: string;
     readonly intervalMinutes: number;
     readonly cron?: never;
+    readonly timeoutMs?: number | null;
 } | {
     readonly name: string;
     readonly command: string;
     readonly cron: string;
     readonly intervalMinutes?: never;
+    readonly timeoutMs?: number | null;
 };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scheduler/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IACtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAA;CAAE,GAC5G;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scheduler/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE3E,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACxF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GACxB;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC,GACD;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC,CAAC"}

package/dist/scheduler/wrap-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-handler.d.ts","sourceRoot":"","sources":["../../src/scheduler/wrap-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,SAAS,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI,GAC7C,eAAe,CA4BjB"}
+{"version":3,"file":"wrap-handler.d.ts","sourceRoot":"","sources":["../../src/scheduler/wrap-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,SAAS,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI,GAC7C,eAAe,CA4BjB"}

package/dist/scheduler/wrap-handler.js

@@ -17,13 +17,13 @@ import { addSpanAttributes, addSpanEvent, traceAsync } from '../telemetry/tracin
  * @param systemBus - Optional bus to emit `scheduler.job.executed` on.
  */
 export function wrapScheduledHandler(name, action, systemBus) {
-    return async () => {
+    return async (context) => {
         const startTime = performance.now();
         return traceAsync('scheduler.job', async (span) => {
             addSpanAttributes({ 'scheduler.job_name': name });
             let execError;
             try {
-                await action();
+                await action(context);
             }
             catch (error) {
                 execError = error instanceof Error ? error.message : String(error);