alepha 0.20.4 → 0.20.6

package/dist/api/jobs/index.d.ts

@@ -1,5 +1,6 @@
 import * as _$alepha from "alepha";
 import { Alepha, AlephaError, Async, KIND, PipelinePrimitive, PipelinePrimitiveOptions, Static, TNull, TObject, TOptional, TSchema, TUnion } from "alepha";
+import { LockProvider } from "alepha/lock";
 import * as _$alepha_queue0 from "alepha/queue";
 import { CronProvider } from "alepha/scheduler";
 import * as _$alepha_server0 from "alepha/server";
@@ -313,6 +314,57 @@ declare module "alepha" {
   interface Env extends Partial<Static<typeof databaseEnvSchema>> {}
 } //# sourceMappingURL=databaseEnvSchema.d.ts.map
 //#endregion
+//#region ../../src/api/jobs/entities/jobExecutionEntity.d.ts
+/**
+ * Job execution record.
+ *
+ * Stores durable state for queue-mode jobs (outbox pattern) and error records
+ * for cron-mode jobs. Successful executions are trimmed by the sweep to keep
+ * the last N rows per job (configurable via `jobConfig.keepLastSuccess`).
+ *
+ * Status transitions:
+ * - queue push            → pending (or `scheduled` if `delay`/`scheduledAt` was given)
+ * - worker claim          → running
+ * - success               → ok (or row deleted, depending on `record` and `keepLastSuccess`)
+ * - terminal failure      → error
+ * - retryable failure     → scheduled (with scheduledAt = now; sweep picks it up)
+ * - delay                 → scheduled (with scheduledAt = now + delay)
+ * - sweep picks due ones  → pending
+ * - cancel                → cancelled
+ */
+declare const jobExecutionEntity: _$alepha_orm0.EntityPrimitive<_$alepha.TObject<{
+  id: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_PRIMARY_KEY>, typeof _$alepha_orm0.PG_DEFAULT>;
+  createdAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_CREATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
+  updatedAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_UPDATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
+  jobName: _$alepha.TString;
+  key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
+  status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
+  priority: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
+  attempt: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
+  maxAttempts: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
+  payload: _$alepha.TOptional<_$alepha.TRecord<"^.*$", _$alepha.TAny>>;
+  scheduledAt: _$alepha.TOptional<_$alepha.TString>;
+  startedAt: _$alepha.TOptional<_$alepha.TString>;
+  completedAt: _$alepha.TOptional<_$alepha.TString>;
+  error: _$alepha.TOptional<_$alepha.TString>;
+  logs: _$alepha.TOptional<_$alepha.TArray<_$alepha.TObject<{
+    level: _$alepha.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    message: _$alepha.TString;
+    service: _$alepha.TString;
+    module: _$alepha.TString;
+    context: _$alepha.TOptional<_$alepha.TString>;
+    app: _$alepha.TOptional<_$alepha.TString>;
+    data: _$alepha.TOptional<_$alepha.TAny>;
+    timestamp: _$alepha.TNumber;
+  }>>>;
+  triggeredBy: _$alepha.TOptional<_$alepha.TString>;
+  triggeredByName: _$alepha.TOptional<_$alepha.TString>;
+  cancelledBy: _$alepha.TOptional<_$alepha.TString>;
+  cancelledByName: _$alepha.TOptional<_$alepha.TString>;
+}>>;
+type JobExecutionEntity = Static<typeof jobExecutionEntity.schema>;
+type JobStatus = "pending" | "running" | "scheduled" | "ok" | "error" | "cancelled";
+//#endregion
 //#region ../../src/api/jobs/primitives/$job.d.ts
 /**
  * Job primitive for defining scheduled (cron) or queued (push) tasks.
@@ -333,15 +385,8 @@ interface JobHandlerArgs<T extends TSchema = TSchema> {
   signal: AbortSignal;
   executionId: string;
 }
-interface JobRetryBackoff {
-  initial: DurationLike;
-  factor?: number;
-  max?: DurationLike;
-  jitter?: boolean;
-}
 interface JobRetryOptions {
   retries: number;
-  backoff?: DurationLike | JobRetryBackoff;
   when?: (error: Error) => boolean;
 }
 type JobPriority = "critical" | "high" | "normal" | "low";
@@ -366,10 +411,30 @@ interface JobPrimitiveOptions<T extends TSchema = TSchema> extends PipelinePrimi
    */
   cron?: string;
   /**
-   * Retry policy for queue-mode jobs.
+   * Retry policy for queue-mode and direct-mode jobs.
    * Cron-mode jobs do not retry — the next tick re-runs.
+   *
+   * Retries are picked up by the reconciliation sweep, so retry granularity
+   * is bounded by `sweepCron` (default 5 minutes). The first retry may run
+   * earlier than 5 minutes if the sweep tick happens sooner.
    */
   retry?: JobRetryOptions;
+  /**
+   * **Cron-mode only.** Whether to acquire a distributed lock around the
+   * cron tick so that only one instance of a multi-replica deployment runs
+   * the handler per tick.
+   *
+   * Has **no effect** on queue-mode and direct-mode jobs — those rely on
+   * the outbox `claim()` UPDATE-guard to serialize work instead, which is
+   * always on.
+   *
+   * To get cross-instance coordination on Docker / Node deployments,
+   * register a real `LockProvider` (e.g. `alepha/lock/redis`). The default
+   * `MemoryLockProvider` is per-process only.
+   *
+   * @default true
+   */
+  lock?: boolean;
   /**
    * Max execution time per attempt. Handler receives an `AbortSignal`.
    */
@@ -433,6 +498,52 @@ declare class JobPrimitive<T extends TSchema = TSchema> extends PipelinePrimitiv
   trigger(context?: JobTriggerContext<T>): Promise<void>;
 }
 //#endregion
+//#region ../../src/api/jobs/providers/JobDispatcher.d.ts
+/**
+ * Abstract dispatcher for queued/direct job executions.
+ *
+ * The default implementation, {@link DirectJobDispatcher}, runs the handler
+ * in-process after the caller's `push()` returns — fast and dependency-free.
+ *
+ * `AlephaApiJobsQueue` substitutes this with `JobQueueProvider`, which
+ * publishes the executionId to `AlephaQueue` so a worker pool can consume
+ * the work asynchronously.
+ *
+ * Substitute via DI:
+ * ```ts
+ * Alepha.create()
+ *   .with({ provide: JobDispatcher, use: MyCustomDispatcher })
+ *   .with(AlephaApiJobs);
+ * ```
+ *
+ * The `kind` getter is read by the `JobProvider.effectiveMode` accessor
+ * and by the admin UI so users can see which dispatcher is currently active.
+ */
+declare abstract class JobDispatcher {
+  /**
+   * Identifier for this dispatcher's effective mode. Reported to the admin
+   * UI so operators can see whether `$job` is running in `queue` or
+   * `direct` mode.
+   */
+  abstract readonly kind: "queue" | "direct";
+  /**
+   * Hand off a single execution. The caller's `push()` awaits this so the
+   * caller can be sure the dispatch has at least been initiated. Long-running
+   * work must NOT be awaited here (use background scheduling instead) — this
+   * call should return as quickly as possible.
+   */
+  abstract dispatch(jobName: string, executionId: string): Promise<void>;
+  /**
+   * Optional batch dispatch. The default implementation loops, but
+   * dispatchers backed by a real queue should override this to use the
+   * provider's batch send (e.g. Cloudflare Queues `sendBatch`).
+   */
+  dispatchMany(items: Array<{
+    jobName: string;
+    executionId: string;
+  }>): Promise<void>;
+}
+//#endregion
 //#region ../../src/api/jobs/providers/JobProvider.d.ts
 declare const PRIORITY_MAP: Record<JobPriority, number>;
 declare const PRIORITY_REVERSE: Record<number, JobPriority>;
@@ -460,34 +571,54 @@ interface CancelContext {
   cancelledBy?: string;
   cancelledByName?: string;
 }
+/**
+ * The declared shape of the job (set at registration time).
+ *
+ * **Important** — this `kind` is the *declared* form. The *effective*
+ * runtime mode (cron / queue / direct) is exposed by
+ * `JobProvider.effectiveMode(name)` and the `JobRegistration.type` field on
+ * the admin schema. Don't conflate the two: a `queue` kind can run as
+ * `direct` at runtime when no queue dispatcher is loaded.
+ */
 interface JobRuntimeRegistration {
   name: string;
   options: JobPrimitiveOptions;
-  type: "cron" | "queue";
+  kind: "cron" | "queue";
 }
+type JobEffectiveMode = "cron" | "queue" | "direct";
 /**
- * Coordinates cron (scheduler) and queue (push) jobs with a durable outbox
- * table and a single reconciliation sweep.
+ * Coordinates cron and push jobs with a durable outbox table and a single
+ * reconciliation sweep. The actual delivery channel (queue / direct) is
+ * abstracted behind {@link JobDispatcher}, substituted by DI:
  *
- * Queue-mode flow:
- *   push()  → INSERT row (pending) + queue.send({ executionId })
- *   worker  → SELECT row → UPDATE running → handler → DELETE (ok) / UPDATE (error)
+ * - **DirectJobDispatcher** (default, registered by `AlephaApiJobs`) —
+ *   runs the handler in-process right after `push()` returns.
+ * - **QueueJobDispatcher** (registered by `AlephaApiJobsQueue`) — sends
+ *   the executionId through `AlephaQueue` so a pool of workers can pick
+ *   it up.
  *
- * Cron-mode flow:
- *   scheduler tick → handler runs inline → INSERT row only on error
+ * Push flow:
+ *   push()  → INSERT row (pending) → dispatcher.dispatch(jobName, id)
+ *   worker  → claim → UPDATE running → handler → DELETE/UPDATE on success
+ *           → UPDATE error / scheduled (retry) on failure
  *
- * Sweep responsibilities (every `sweepInterval`):
+ * Cron flow:
+ *   scheduler tick → acquire lock → executeInline (no retry)
+ *                                 → enqueue + dispatch (retry declared)
+ *
+ * Sweep responsibilities (every `sweepCron`):
  *   - re-enqueue pending rows older than `staleThreshold`
- *   - fail running rows older than `max(timeout*2, runTimeout)`
- *   - move `scheduled` rows with `scheduledAt <= now` to pending + enqueue
+ *   - mark crashed running rows as failed and apply retry policy
+ *   - move `scheduled` rows with `scheduledAt <= now` to pending + dispatch
  *   - trim per-job history beyond `keepLastSuccess` / `keepLastError`
  */
 declare class JobProvider {
   protected readonly alepha: Alepha;
   protected readonly dt: DateTimeProvider;
   protected readonly cronProvider: CronProvider;
+  protected readonly lockProvider: LockProvider;
   protected readonly config: Readonly<{
-    sweepInterval: number;
+    sweepCron: string;
     staleThreshold: number;
     runTimeout: number;
     keepLastSuccess: number;
@@ -495,6 +626,15 @@ declare class JobProvider {
     logMaxEntries: number;
     drainTimeout: number;
   }>;
+  /**
+   * Resolved at first use (after the container is fully wired) — picks
+   * the queue dispatcher when `AlephaApiJobsQueue` was loaded, otherwise
+   * the direct dispatcher. Lazy because both dispatchers inject
+   * `JobProvider` themselves; resolving them at field-init time would
+   * create a circular construction.
+   */
+  protected dispatcherRef?: JobDispatcher;
+  get dispatcher(): JobDispatcher;
   protected readonly log: _$alepha_logger0.Logger;
   protected readonly executions: _$alepha_orm0.Repository<_$alepha.TObject<{
     id: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_PRIMARY_KEY>, typeof _$alepha_orm0.PG_DEFAULT>;
@@ -502,7 +642,7 @@ declare class JobProvider {
     updatedAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_UPDATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
     jobName: _$alepha.TString;
     key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-    status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
+    status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
     priority: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
     attempt: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
     maxAttempts: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
@@ -540,14 +680,75 @@ declare class JobProvider {
     timestamp: number;
   }[]>;
   protected stopping: boolean;
-  /**
-   * Set by `JobQueueProvider` when `AlephaApiJobsQueue` is loaded.
-   * When null, queue-mode jobs cannot be pushed.
-   */
-  queueDispatch: ((jobName: string, executionId: string) => Promise<void>) | null;
   registerJob(name: string, options: JobPrimitiveOptions): void;
   getRegisteredJobs(): Map<string, JobRuntimeRegistration>;
+  /**
+   * Resolves what *actually* runs at dispatch time. Cron jobs are always
+   * "cron"; non-cron jobs delegate to the active `JobDispatcher` (queue
+   * vs. direct), which is determined by which modules the app loaded.
+   */
+  effectiveMode(name: string): JobEffectiveMode;
   protected runCron(name: string): Promise<void>;
+  /**
+   * Cron-mode runner that respects the per-job distributed lock.
+   * Used by both the scheduled tick and manual `trigger()` calls so that an
+   * admin-triggered run on one instance can't race a scheduled run on another.
+   *
+   * **Two paths depending on `retry`:**
+   *
+   * - **No `retry`** — runs the handler inline. No DB row on success;
+   *   error row only on failure. The "next tick" is the implicit retry.
+   * - **`retry` declared** — enqueues a synthetic execution row and hands
+   *   it to the dispatcher. The handler then runs through the same path
+   *   as a queue/direct push (claim, retry-on-fail, sweep recovery). Use
+   *   this when a single failed tick must not block work for the whole
+   *   `cron` interval (e.g. once-daily jobs).
+   */
+  protected runCronLocked(registration: JobRuntimeRegistration, ctx: {
+    triggeredBy?: string;
+    triggeredByName?: string;
+  }): Promise<void>;
+  /**
+   * Materialize a cron tick into the outbox so it goes through the normal
+   * retry/sweep path. Used when the user opts into `retry` on a cron job —
+   * a transient failure no longer means "wait for the next cron tick", it
+   * means "the sweep will retry within `sweepCron`".
+   */
+  protected enqueueCronExecution(registration: JobRuntimeRegistration, ctx: {
+    triggeredBy?: string;
+    triggeredByName?: string;
+  }): Promise<void>;
+  /**
+   * Acquire a per-job NX lock keyed by `cron-job:<name>` so that a single
+   * tick across all replicas runs exactly one execution. Auto-expires after
+   * `2 * timeout` (or 5 minutes if no per-job timeout) so a crashed worker
+   * cannot permanently block the cron from firing.
+   *
+   * **Caveat — same-process double-fire is not prevented.** The lock value
+   * is a per-process holder id, so two concurrent ticks on the same process
+   * (e.g. a scheduled tick overlapping an admin `trigger()` call) will both
+   * see "we own it". This is acceptable for the multi-replica use case the
+   * lock targets; a process that overlaps its own cron handler should set a
+   * smaller `timeout` or use idempotent handler logic. A future fix can add
+   * a per-process Set guard before reaching the LockProvider.
+   */
+  protected acquireCronLock(registration: JobRuntimeRegistration): Promise<boolean>;
+  /**
+   * Update only when the row is still in one of the expected statuses.
+   * Logs and returns silently when the guard rejects — this happens when a
+   * concurrent operation (most often `cancel()`) has already moved the row
+   * into a terminal state. We must not overwrite that.
+   */
+  protected guardedUpdate(executionId: string, expectedStatuses: JobStatus[], patch: Parameters<typeof this.executions.updateById>[1], label: string): Promise<void>;
+  protected releaseCronLock(registration: JobRuntimeRegistration): Promise<void>;
+  protected cronLockKey(jobName: string): string;
+  /**
+   * Stable per-process id used as the lock value — survives multiple ticks.
+   * Lazy so that Cloudflare Workers (which forbid random in global scope)
+   * stay happy.
+   */
+  protected lockHolderIdValue?: string;
+  protected get lockHolderId(): string;
   /**
    * Execute a cron handler inline. Records a row only on error (or always,
    * when `record: 'all'`). No DB writes on the happy path by default.
@@ -576,17 +777,65 @@ declare class JobProvider {
    */
   protected scheduleOptimisticDispatch(jobName: string, executionId: string, scheduledAt: string): void;
   pushMany(name: string, items: Array<PushManyItem>): Promise<string[]>;
-  protected dispatchToQueue(jobName: string, executionId: string): Promise<void>;
+  /**
+   * Hand a single execution to the active `JobDispatcher`. Whether that
+   * results in a queue send or in-process execution depends on which
+   * dispatcher is wired (see {@link JobDispatcher}).
+   */
+  protected dispatch(jobName: string, executionId: string): Promise<void>;
+  /**
+   * Batched variant. Used by `pushMany` so a backing queue can do a single
+   * batch network call (e.g. Cloudflare Queues `sendBatch`).
+   */
+  protected dispatchMany(items: Array<{
+    jobName: string;
+    executionId: string;
+  }>): Promise<void>;
   trigger(name: string, context?: JobTriggerContext): Promise<void>;
   cancel(executionId: string, context?: CancelContext): Promise<void>;
   processExecution(jobName: string, executionId: string): Promise<void>;
   protected processQueueExecution(registration: JobRuntimeRegistration, executionId: string): Promise<void>;
-  protected claim(executionId: string): Promise<boolean>;
+  /**
+   * Transition pending → running and return the post-update row.
+   * Two round-trips: read current attempt, then guarded UPDATE … RETURNING.
+   * Returns null when the row is gone or already claimed by another worker.
+   * The returned row replaces a separate post-claim findById, so the dispatch
+   * path is 2 queries instead of 3.
+   */
+  protected claim(executionId: string): Promise<{
+    error?: string | undefined;
+    key?: string | null | undefined;
+    payload?: Record<string, any> | undefined;
+    scheduledAt?: string | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    logs?: {
+      context?: string | undefined;
+      app?: string | undefined;
+      data?: any;
+      level: "SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
+      message: string;
+      service: string;
+      module: string;
+      timestamp: number;
+    }[] | undefined;
+    triggeredBy?: string | undefined;
+    triggeredByName?: string | undefined;
+    cancelledBy?: string | undefined;
+    cancelledByName?: string | undefined;
+    priority: number;
+    status: "ok" | "error" | "pending" | "running" | "scheduled" | "cancelled";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    jobName: string;
+    attempt: number;
+    maxAttempts: number;
+  } | null>;
   protected handleFailure(executionId: string, registration: JobRuntimeRegistration, currentAttempt: number, error: Error, contextId: string): Promise<void>;
-  protected computeBackoff(retry: JobRetryOptions, attempt: number): string;
   protected snapshotLogs(contextId: string): LogEntry[] | undefined;
   protected sweep(): Promise<void>;
-  protected dispatchToQueueSafe(jobName: string, executionId: string): Promise<void>;
+  protected dispatchSafe(jobName: string, executionId: string): Promise<void>;
   /**
    * Move a row from `scheduled` → `pending` and dispatch it.
    * Used by the optimistic retry/delay timer. If the sweep has already moved
@@ -602,22 +851,68 @@ declare class JobProvider {
 //#endregion
 //#region ../../src/api/jobs/schemas/jobExecutionQuerySchema.d.ts
 declare const jobExecutionQuerySchema: _$alepha.TObject<{
-  status: _$alepha.TOptional<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">>;
+  status: _$alepha.TOptional<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">>;
   limit: _$alepha.TOptional<_$alepha.TInteger>;
 }>;
 type JobExecutionQuery = Static<typeof jobExecutionQuerySchema>;
 //#endregion
+//#region ../../src/api/jobs/schemas/jobExecutionResourceSchema.d.ts
+/**
+ * Public-facing schema for a job execution row.
+ *
+ * Diverges from the raw entity in two places, both for API ergonomics:
+ *
+ * - `priority` is exposed as the **string enum** (`critical`/`high`/...)
+ *   instead of the numeric value used internally for SQL ordering. The
+ *   `JobService` is responsible for the int → string transform.
+ * - `can` derives the available admin actions from the row's status.
+ */
+declare const jobExecutionResourceSchema: _$alepha.TObject<{
+  id: PgAttr<PgAttr<_$alepha.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  jobName: _$alepha.TString;
+  key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
+  status: PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof PG_DEFAULT>;
+  priority: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
+  attempt: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
+  maxAttempts: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
+  payload: _$alepha.TOptional<_$alepha.TRecord<"^.*$", _$alepha.TAny>>;
+  scheduledAt: _$alepha.TOptional<_$alepha.TString>;
+  startedAt: _$alepha.TOptional<_$alepha.TString>;
+  completedAt: _$alepha.TOptional<_$alepha.TString>;
+  error: _$alepha.TOptional<_$alepha.TString>;
+  logs: _$alepha.TOptional<_$alepha.TArray<_$alepha.TObject<{
+    level: _$alepha.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    message: _$alepha.TString;
+    service: _$alepha.TString;
+    module: _$alepha.TString;
+    context: _$alepha.TOptional<_$alepha.TString>;
+    app: _$alepha.TOptional<_$alepha.TString>;
+    data: _$alepha.TOptional<_$alepha.TAny>;
+    timestamp: _$alepha.TNumber;
+  }>>>;
+  triggeredBy: _$alepha.TOptional<_$alepha.TString>;
+  triggeredByName: _$alepha.TOptional<_$alepha.TString>;
+  cancelledBy: _$alepha.TOptional<_$alepha.TString>;
+  cancelledByName: _$alepha.TOptional<_$alepha.TString>;
+  can: _$alepha.TObject<{
+    retry: _$alepha.TBoolean;
+    cancel: _$alepha.TBoolean;
+  }>;
+}>;
+type JobExecutionResource = Static<typeof jobExecutionResourceSchema>;
+//#endregion
 //#region ../../src/api/jobs/schemas/jobRegistrationSchema.d.ts
 declare const jobRegistrationSchema: _$alepha.TObject<{
   name: _$alepha.TString;
   description: _$alepha.TOptional<_$alepha.TString>;
-  type: _$alepha.TUnsafe<"cron" | "queue">;
+  type: _$alepha.TUnsafe<"cron" | "queue" | "direct">;
   priority: _$alepha.TUnsafe<"critical" | "high" | "normal" | "low">;
   cron: _$alepha.TOptional<_$alepha.TString>;
   timeout: _$alepha.TOptional<_$alepha.TString>;
   retry: _$alepha.TOptional<_$alepha.TObject<{
     retries: _$alepha.TInteger;
-    hasBackoff: _$alepha.TBoolean;
   }>>;
   recent: _$alepha.TObject<{
     ok: _$alepha.TInteger;
@@ -646,7 +941,7 @@ declare class JobService {
     updatedAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_UPDATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
     jobName: _$alepha.TString;
     key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-    status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
+    status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
     priority: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
     attempt: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
     maxAttempts: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
@@ -674,6 +969,16 @@ declare class JobService {
     retry: boolean;
     cancel: boolean;
   };
+  /**
+   * Convert the int-priority storage column into the public enum string.
+   * The cast through `unknown` skips TypeScript's structural check between
+   * the entity-level row (`priority: number`) and the resource schema
+   * (`priority: enum`); the runtime values are correct.
+   */
+  protected toResource<T extends {
+    priority: number;
+    status: string;
+  }>(row: T): JobExecutionResource;
   /**
    * List every registered job with recent ok/error counts and lastRun.
    * One aggregate query covers all jobs.
@@ -683,12 +988,8 @@ declare class JobService {
    * Recent executions for a single job, ORDER BY startedAt DESC.
    */
   getExecutions(jobName: string, query?: JobExecutionQuery): Promise<{
-    can: {
-      retry: boolean;
-      cancel: boolean;
-    };
-    key?: string | null | undefined;
     error?: string | undefined;
+    key?: string | null | undefined;
     payload?: Record<string, any> | undefined;
     scheduledAt?: string | undefined;
     startedAt?: string | undefined;
@@ -707,25 +1008,25 @@ declare class JobService {
     triggeredByName?: string | undefined;
     cancelledBy?: string | undefined;
     cancelledByName?: string | undefined;
+    priority: number;
+    status: "ok" | "error" | "pending" | "running" | "scheduled" | "cancelled";
     id: string;
     createdAt: string;
     updatedAt: string;
     jobName: string;
-    status: "pending" | "running" | "scheduled" | "ok" | "error" | "cancelled";
-    priority: number;
     attempt: number;
     maxAttempts: number;
+    can: {
+      retry: boolean;
+      cancel: boolean;
+    };
   }[]>;
   /**
    * Full execution detail (includes captured logs).
    */
   getExecution(id: string): Promise<{
-    can: {
-      retry: boolean;
-      cancel: boolean;
-    };
-    key?: string | null | undefined;
     error?: string | undefined;
+    key?: string | null | undefined;
     payload?: Record<string, any> | undefined;
     scheduledAt?: string | undefined;
     startedAt?: string | undefined;
@@ -744,14 +1045,18 @@ declare class JobService {
     triggeredByName?: string | undefined;
     cancelledBy?: string | undefined;
     cancelledByName?: string | undefined;
+    priority: number;
+    status: "ok" | "error" | "pending" | "running" | "scheduled" | "cancelled";
     id: string;
     createdAt: string;
     updatedAt: string;
     jobName: string;
-    status: "pending" | "running" | "scheduled" | "ok" | "error" | "cancelled";
-    priority: number;
     attempt: number;
     maxAttempts: number;
+    can: {
+      retry: boolean;
+      cancel: boolean;
+    };
   }>;
   /**
    * Manual trigger (cron jobs) or push-with-payload (queue jobs).
@@ -788,13 +1093,12 @@ declare class AdminJobController {
     response: _$alepha.TArray<_$alepha.TObject<{
       name: _$alepha.TString;
       description: _$alepha.TOptional<_$alepha.TString>;
-      type: _$alepha.TUnsafe<"cron" | "queue">;
+      type: _$alepha.TUnsafe<"cron" | "queue" | "direct">;
       priority: _$alepha.TUnsafe<"critical" | "high" | "normal" | "low">;
       cron: _$alepha.TOptional<_$alepha.TString>;
       timeout: _$alepha.TOptional<_$alepha.TString>;
       retry: _$alepha.TOptional<_$alepha.TObject<{
         retries: _$alepha.TInteger;
-        hasBackoff: _$alepha.TBoolean;
       }>>;
       recent: _$alepha.TObject<{
         ok: _$alepha.TInteger;
@@ -808,7 +1112,7 @@ declare class AdminJobController {
       name: _$alepha.TString;
     }>;
     query: _$alepha.TObject<{
-      status: _$alepha.TOptional<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">>;
+      status: _$alepha.TOptional<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">>;
       limit: _$alepha.TOptional<_$alepha.TInteger>;
     }>;
     response: _$alepha.TArray<_$alepha.TObject<{
@@ -817,7 +1121,7 @@ declare class AdminJobController {
       updatedAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
       jobName: _$alepha.TString;
       key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-      status: PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof PG_DEFAULT>;
+      status: PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof PG_DEFAULT>;
       priority: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
       attempt: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
       maxAttempts: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
@@ -856,7 +1160,7 @@ declare class AdminJobController {
       updatedAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
       jobName: _$alepha.TString;
       key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-      status: PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof PG_DEFAULT>;
+      status: PgAttr<_$alepha.TUnsafe<"ok" | "error" | "pending" | "running" | "scheduled" | "cancelled">, typeof PG_DEFAULT>;
       priority: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
       attempt: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
       maxAttempts: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
@@ -920,79 +1224,77 @@ declare class AdminJobController {
   }>;
 }
 //#endregion
-//#region ../../src/api/jobs/entities/jobExecutionEntity.d.ts
+//#region ../../src/api/jobs/providers/DirectJobDispatcher.d.ts
 /**
- * Job execution record.
+ * Default `JobDispatcher` for environments without `AlephaApiJobsQueue`.
  *
- * Stores durable state for queue-mode jobs (outbox pattern) and error records
- * for cron-mode jobs. Successful executions are trimmed by the sweep to keep
- * the last N rows per job (configurable via `jobConfig.keepLastSuccess`).
+ * Runs `JobProvider.processExecution` in the background — the caller's
+ * `push()` returns immediately while the handler continues to completion
+ * in the same process. The DB outbox row is the durability guarantee:
+ * if the process dies before the handler finishes, the next sweep tick
+ * picks the row up and re-dispatches.
  *
- * Status transitions:
- * - queue push            → pending
- * - worker claim          → running
- * - success               → ok
- * - terminal failure      → error
- * - retry                 → scheduled (with scheduledAt = now + backoff)
- * - delay                 → scheduled (with scheduledAt = now + delay)
- * - sweep picks due ones  → pending
- * - cancel                → cancelled
+ * **Cloudflare Workers** — when an `executionCtx.waitUntil` is available
+ * in the alepha store at `cloudflare.waitUntil`, the dispatch wraps the
+ * background promise with `waitUntil` so the runtime keeps the isolate
+ * alive past the HTTP response. Without this, the handler would be
+ * terminated when the response is returned and only the next sweep
+ * (every 5 min by default) would re-dispatch.
+ *
+ * **Vercel / single-Node** — on long-running runtimes the event loop
+ * keeps the promise alive naturally; no special wiring is required.
  */
-declare const jobExecutionEntity: _$alepha_orm0.EntityPrimitive<_$alepha.TObject<{
-  id: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_PRIMARY_KEY>, typeof _$alepha_orm0.PG_DEFAULT>;
-  createdAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_CREATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
-  updatedAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$alepha.TString, typeof _$alepha_orm0.PG_UPDATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
-  jobName: _$alepha.TString;
-  key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-  status: _$alepha_orm0.PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof _$alepha_orm0.PG_DEFAULT>;
-  priority: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
-  attempt: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
-  maxAttempts: _$alepha_orm0.PgAttr<_$alepha.TInteger, typeof _$alepha_orm0.PG_DEFAULT>;
-  payload: _$alepha.TOptional<_$alepha.TRecord<"^.*$", _$alepha.TAny>>;
-  scheduledAt: _$alepha.TOptional<_$alepha.TString>;
-  startedAt: _$alepha.TOptional<_$alepha.TString>;
-  completedAt: _$alepha.TOptional<_$alepha.TString>;
-  error: _$alepha.TOptional<_$alepha.TString>;
-  logs: _$alepha.TOptional<_$alepha.TArray<_$alepha.TObject<{
-    level: _$alepha.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-    message: _$alepha.TString;
-    service: _$alepha.TString;
-    module: _$alepha.TString;
-    context: _$alepha.TOptional<_$alepha.TString>;
-    app: _$alepha.TOptional<_$alepha.TString>;
-    data: _$alepha.TOptional<_$alepha.TAny>;
-    timestamp: _$alepha.TNumber;
-  }>>>;
-  triggeredBy: _$alepha.TOptional<_$alepha.TString>;
-  triggeredByName: _$alepha.TOptional<_$alepha.TString>;
-  cancelledBy: _$alepha.TOptional<_$alepha.TString>;
-  cancelledByName: _$alepha.TOptional<_$alepha.TString>;
-}>>;
-type JobExecutionEntity = Static<typeof jobExecutionEntity.schema>;
-type JobStatus = "pending" | "running" | "scheduled" | "ok" | "error" | "cancelled";
+declare class DirectJobDispatcher extends JobDispatcher {
+  readonly kind: "direct";
+  protected readonly alepha: Alepha;
+  protected readonly log: _$alepha_logger0.Logger;
+  protected jobProviderRef?: JobProvider;
+  protected getJobProvider(): JobProvider;
+  dispatch(jobName: string, executionId: string): Promise<void>;
+}
 //#endregion
 //#region ../../src/api/jobs/providers/JobQueueProvider.d.ts
 /**
- * Plumbs outbox-style dispatch through `AlephaQueue`.
+ * Queue-backed `JobDispatcher` registered by `AlephaApiJobsQueue`.
+ *
+ * Extends {@link JobDispatcher} and substitutes the default
+ * `DirectJobDispatcher` so that `$job.push()` is delivered through
+ * `AlephaQueue` (e.g. Cloudflare Queues, Redis, in-memory) instead of
+ * being processed in-process.
  *
- * Registered only when the app imports `AlephaApiJobsQueue`. Sets
- * `JobProvider.queueDispatch` eagerly at instantiation so queue-mode jobs
- * can dispatch regardless of start-hook ordering.
+ * The class is also kept as a `JobQueueProvider` export name for backwards
+ * compatibility — it has always been the queue path's entry point.
  */
-declare class JobQueueProvider {
-  protected readonly jobProvider: JobProvider;
+declare class JobQueueProvider extends JobDispatcher {
+  readonly kind: "queue";
+  protected readonly alepha: Alepha;
+  protected jobProviderRef?: JobProvider;
+  protected getJobProvider(): JobProvider;
   protected readonly queue: _$alepha_queue0.QueuePrimitive<_$alepha.TObject<{
     jobName: _$alepha.TString;
     executionId: _$alepha.TString;
   }>>;
-  constructor();
-  protected wireDispatcher(): void;
+  dispatch(jobName: string, executionId: string): Promise<void>;
+  /**
+   * Fan-out to a single variadic `queue.push(...payloads)` call so the
+   * underlying queue provider can batch the network round-trips when it
+   * supports it (Cloudflare Queues, Redis pipelines).
+   */
+  dispatchMany(items: Array<{
+    jobName: string;
+    executionId: string;
+  }>): Promise<void>;
+  /**
+   * Backwards-compatible alias for {@link dispatch}. Older code paths called
+   * `JobQueueProvider.push(jobName, executionId)` directly; new code should
+   * go through the `JobDispatcher.dispatch` API.
+   */
   push(jobName: string, executionId: string): Promise<void>;
 }
 //#endregion
 //#region ../../src/api/jobs/schemas/jobConfigAtom.d.ts
 declare const jobConfig: _$alepha.Atom<_$alepha.TObject<{
-  sweepInterval: _$alepha.TInteger;
+  sweepCron: _$alepha.TString;
   staleThreshold: _$alepha.TInteger;
   runTimeout: _$alepha.TInteger;
   keepLastSuccess: _$alepha.TInteger;
@@ -1007,43 +1309,6 @@ declare module "alepha" {
   }
 } //# sourceMappingURL=jobConfigAtom.d.ts.map
 //#endregion
-//#region ../../src/api/jobs/schemas/jobExecutionResourceSchema.d.ts
-declare const jobExecutionResourceSchema: _$alepha.TObject<{
-  id: PgAttr<PgAttr<_$alepha.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<_$alepha.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  jobName: _$alepha.TString;
-  key: _$alepha.TOptional<_$alepha.TUnion<[_$alepha.TNull, _$alepha.TString]>>;
-  status: PgAttr<_$alepha.TUnsafe<"pending" | "running" | "scheduled" | "ok" | "error" | "cancelled">, typeof PG_DEFAULT>;
-  priority: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
-  attempt: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
-  maxAttempts: PgAttr<_$alepha.TInteger, typeof PG_DEFAULT>;
-  payload: _$alepha.TOptional<_$alepha.TRecord<"^.*$", _$alepha.TAny>>;
-  scheduledAt: _$alepha.TOptional<_$alepha.TString>;
-  startedAt: _$alepha.TOptional<_$alepha.TString>;
-  completedAt: _$alepha.TOptional<_$alepha.TString>;
-  error: _$alepha.TOptional<_$alepha.TString>;
-  logs: _$alepha.TOptional<_$alepha.TArray<_$alepha.TObject<{
-    level: _$alepha.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-    message: _$alepha.TString;
-    service: _$alepha.TString;
-    module: _$alepha.TString;
-    context: _$alepha.TOptional<_$alepha.TString>;
-    app: _$alepha.TOptional<_$alepha.TString>;
-    data: _$alepha.TOptional<_$alepha.TAny>;
-    timestamp: _$alepha.TNumber;
-  }>>>;
-  triggeredBy: _$alepha.TOptional<_$alepha.TString>;
-  triggeredByName: _$alepha.TOptional<_$alepha.TString>;
-  cancelledBy: _$alepha.TOptional<_$alepha.TString>;
-  cancelledByName: _$alepha.TOptional<_$alepha.TString>;
-  can: _$alepha.TObject<{
-    retry: _$alepha.TBoolean;
-    cancel: _$alepha.TBoolean;
-  }>;
-}>;
-type JobExecutionResource = Static<typeof jobExecutionResourceSchema>;
-//#endregion
 //#region ../../src/api/jobs/schemas/triggerJobSchema.d.ts
 declare const triggerJobSchema: _$alepha.TObject<{
   payload: _$alepha.TOptional<_$alepha.TRecord<"^.*$", _$alepha.TAny>>;
@@ -1080,27 +1345,59 @@ declare module "alepha" {
 /**
  * Job execution framework — cron and durable queue work with a single primitive.
  *
- * A `$job` is either **cron-only** (declares `cron`) or **queue-only** (declares `schema`).
- * Cron jobs run inline on their schedule and only record errors by default.
- * Queue jobs use the outbox pattern: push commits to DB first, then notifies via queue.
+ * A `$job` is either **cron-only** (declares `cron`) or **payload-only** (declares `schema`).
+ *
+ * **Three runtime modes:**
+ *
+ * - **cron** — fires on a schedule. Cron-mode jobs are protected by a
+ *   distributed lock by default (`lock: true`), so multi-replica Docker
+ *   deployments only run the handler once per tick. Override with
+ *   `lock: false` if you genuinely want every replica to fire.
+ * - **queue** — push-driven, dispatched through the queue infrastructure
+ *   (`AlephaQueue`, e.g. Cloudflare Queues, Redis). Real-time delivery,
+ *   ideal for high-volume systems. Requires `AlephaApiJobsQueue`.
+ * - **direct** — push-driven, processed in-process right after the caller
+ *   awaits the push. The DB outbox row is the durability guarantee — if
+ *   the process dies, the reconciliation sweep re-dispatches. Default
+ *   when `AlephaApiJobsQueue` is *not* loaded. Best for cheap deployments
+ *   (Cloudflare Workers, single-instance Node) where standing up a queue
+ *   is overkill.
+ *
+ * **Retries** are sweep-driven across all modes (no exponential backoff).
+ * Granularity is bounded by `sweepCron` (default 5 min). The first retry
+ * may land anywhere from a few seconds to ~5 min later depending on when
+ * the next sweep tick fires. Cron jobs that declare `retry` go through
+ * the same sweep path — a transient failure no longer means waiting for
+ * the next cron tick (useful for once-daily jobs).
+ *
+ * **Runtime support for cron triggers**
  *
- * **This module provides cron support only.** To enable queue-mode jobs, also
- * import {@link AlephaApiJobsQueue} — it brings in the queue layer and infrastructure
- * binding (e.g. Cloudflare Queues). Cron-only deployments (Vercel, CF-without-Queues)
- * do not need `AlephaApiJobsQueue`.
+ * - **Long-running Node / Docker** — `CronProvider` runs an in-process
+ *   timer loop. Multi-replica deployments serialize ticks via the cron
+ *   lock (see `$job.lock`).
+ * - **Cloudflare Workers** — the build emits cron expressions into
+ *   `wrangler.jsonc`; Cloudflare invokes the worker on schedule and the
+ *   `cloudflare:scheduled` hook routes the event to the matching jobs.
+ * - **Vercel** — the build emits cron entries into
+ *   `.vercel/output/config.json` mapped to `/_alepha/cron/:name`; the
+ *   serverless handler emits `serverless:cron` and `CronProvider` runs
+ *   the matching job. Set `CRON_SECRET` to require authenticated calls.
  *
  * @module alepha.api.jobs
  */
 declare const AlephaApiJobs: _$alepha.Service<_$alepha.Module>;
 /**
  * Queue support for `$job`. Import alongside {@link AlephaApiJobs} when your
- * app declares queue-mode jobs (any `$job` with a `schema`).
+ * app declares queue-mode jobs (any `$job` with a `schema`) and you want a
+ * real queue (e.g. Cloudflare Queues, Redis) instead of in-process direct
+ * execution.
  *
- * Adds `JobQueueProvider` which plumbs the outbox dispatch through `AlephaQueue`.
+ * Adds `JobQueueProvider` to the container. `JobProvider` detects its
+ * presence at start-up and routes dispatches through it.
  *
  * @module alepha.api.jobs.queue
  */
 declare const AlephaApiJobsQueue: _$alepha.Service<_$alepha.Module>;
 //#endregion
-export { $job, AdminJobController, AlephaApiJobs, AlephaApiJobsQueue, CancelContext, JobConfig, JobExecutionEntity, JobExecutionQuery, JobExecutionResource, JobHandlerArgs, JobPrimitive, JobPrimitiveOptions, JobPriority, JobProvider, JobQueueProvider, JobRegistration, JobRetryBackoff, JobRetryOptions, JobService, JobStatus, JobTriggerContext, PRIORITY_MAP, PRIORITY_REVERSE, PushManyItem, PushOptions, TriggerJob, jobConfig, jobExecutionEntity, jobExecutionQuerySchema, jobExecutionResourceSchema, jobRegistrationSchema, triggerJobSchema };
+export { $job, AdminJobController, AlephaApiJobs, AlephaApiJobsQueue, CancelContext, DirectJobDispatcher, JobConfig, JobDispatcher, JobEffectiveMode, JobExecutionEntity, JobExecutionQuery, JobExecutionResource, JobHandlerArgs, JobPrimitive, JobPrimitiveOptions, JobPriority, JobProvider, JobQueueProvider, JobRegistration, JobRetryOptions, JobService, JobStatus, JobTriggerContext, PRIORITY_MAP, PRIORITY_REVERSE, PushManyItem, PushOptions, TriggerJob, jobConfig, jobExecutionEntity, jobExecutionQuerySchema, jobExecutionResourceSchema, jobRegistrationSchema, triggerJobSchema };
 //# sourceMappingURL=index.d.ts.map