gemi 0.116.0 → 0.118.0

package/dist/services/queue/QueueManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueueManager.d.ts","sourceRoot":"","sources":["../../../services/queue/QueueManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"QueueManager.d.ts","sourceRoot":"","sources":["../../../services/queue/QueueManager.ts"],"names":[],"mappings":"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"}

package/dist/services/queue/QueueServiceProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueueServiceProvider.d.ts","sourceRoot":"","sources":["../../../services/queue/QueueServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAyBhE,qBAAa,oBAAqB,SAAQ,eAAe;IACvD,QAAQ;IAYR;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,IAAI;IAQV;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;;;CAqB/C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,WAAW,QAO9D"}
+{"version":3,"file":"QueueServiceProvider.d.ts","sourceRoot":"","sources":["../../../services/queue/QueueServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAyBhE,qBAAa,oBAAqB,SAAQ,eAAe;IACvD,QAAQ;IAYR;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,IAAI;IAcV;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;;;CAqB/C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,WAAW,QAO9D"}

package/dist/services/queue/backoff.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The delay before the retry that follows attempt `attempt`: the number
+ * itself, or the array's entry for that retry with its last entry repeated.
+ */
+export declare function backoffFor(backoff: number | number[], attempt: number): number;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/services/queue/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../services/queue/backoff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,UAKrE"}

package/dist/services/queue/batch.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The bookkeeping of a job batch, shared by every driver so that the rules for
+ * when a batch is cancelled and which callbacks run are written once.
+ *
+ * A driver keeps a `BatchRecord` per batch and calls these functions while it
+ * holds that record exclusively: inside the transaction that also ends the job
+ * (the database driver, with the batch row locked), or synchronously (the
+ * memory driver). Everything here is pure; the driver writes what comes back,
+ * and enqueues the callback jobs `settle` returns in the same step, which is
+ * what makes each callback run exactly once.
+ *
+ * The rules:
+ *
+ * - Every job of the batch ends exactly once as `succeeded`, `failed` (it was
+ *   dead-lettered) or `cancelled` (it never ran to the end because the batch was
+ *   cancelled). `pending` counts the ones that have not ended yet.
+ * - `catch` is due at the first failure or cancellation, whichever comes first.
+ * - Without `allowFailures`, the first failure cancels the batch: the jobs still
+ *   waiting are ended as `cancelled` at once, and running ones see it through
+ *   `this.batch.cancelled()`.
+ * - Once `pending` reaches 0 the batch is finished: `then` is due when it was
+ *   not cancelled and nothing failed (or `allowFailures` is set), and `finally`
+ *   is always due.
+ */
+/** A job and the arguments to dispatch it with: what `Job.with(...)` returns. */
+export type JobCall = {
+    /** The job's registered name: its class's `static name`. */
+    name: string;
+    /** The `run` arguments, before the batch status is appended. */
+    args: unknown[];
+};
+export type BatchCallbacks = {
+    then?: JobCall;
+    catch?: JobCall;
+    finally?: JobCall;
+};
+/** What `Job.findBatch` resolves to, and the last argument a batch callback gets. */
+export type BatchStatus = {
+    id: string;
+    /** The `name` given to `dispatchBatch`, or `null`. */
+    name: string | null;
+    /** How many jobs the batch was dispatched with. */
+    total: number;
+    /** Jobs that have not ended yet: waiting, running, or waiting out a retry. */
+    pending: number;
+    succeeded: number;
+    /** Jobs that were dead-lettered. */
+    failed: number;
+    /** Jobs that ended without running to the end because the batch was cancelled. */
+    cancelled: number;
+    /** The ids of the dead-lettered jobs, in the order they failed. */
+    failedJobIds: string[];
+    /**
+     * 0 to 1: the ended jobs plus the share each running job reported with
+     * `this.progress()`, over `total`. 1 for a batch of no jobs.
+     */
+    progress: number;
+    /** When the batch was cancelled, in epoch milliseconds, or `null`. */
+    cancelledAt: number | null;
+    /** When its last job ended, in epoch milliseconds, or `null` while it runs. */
+    finishedAt: number | null;
+    createdAt: number;
+};
+/** What a driver stores per batch. */
+export type BatchRecord = Omit<BatchStatus, "progress"> & {
+    allowFailures: boolean;
+    callbacks: BatchCallbacks;
+};
+/** How one job of a batch ended. */
+export type BatchOutcome = "succeeded" | "failed" | "cancelled";
+/** The callback jobs to enqueue, their arguments already serialised. */
+export type BatchCallbackJob = {
+    name: string;
+    args: string;
+};
+export declare function newBatchRecord(batch: {
+    id: string;
+    name: string | null;
+    total: number;
+    allowFailures: boolean;
+    callbacks: BatchCallbacks;
+    now: number;
+}): BatchRecord;
+/** Counts one job's end. A batch with nothing pending is left as it is. */
+export declare function countOutcome(record: BatchRecord, outcome: BatchOutcome, jobId: string): BatchRecord;
+/**
+ * Whether going from `prev` to `next` is the failure that cancels the batch:
+ * its first, without `allowFailures`, in a batch not already cancelled.
+ */
+export declare function cancelsBatch(prev: BatchRecord, next: BatchRecord): boolean;
+/**
+ * Marks the batch cancelled, counting the `waiting` jobs the driver has just
+ * ended as `cancelled`.
+ */
+export declare function markCancelled(record: BatchRecord, now: number, waiting: number): BatchRecord;
+/**
+ * Finishes the batch when nothing is pending, and says which callbacks became
+ * due between `prev` and `next`. Each callback's arguments are its own followed
+ * by the batch's status as it stands after this step.
+ */
+export declare function settle(prev: BatchRecord, next: BatchRecord, now: number): {
+    record: BatchRecord;
+    calls: BatchCallbackJob[];
+};
+/**
+ * The status of a batch. `running` is the sum of the progress the batch's
+ * unfinished jobs have reported, each 0 to 1.
+ */
+export declare function statusOf(record: BatchRecord, running?: number): BatchStatus;
+/** A progress value as stored: a finite number clamped to 0..1. */
+export declare function clampProgress(value: number): number;
+//# sourceMappingURL=batch.d.ts.map

package/dist/services/queue/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../../services/queue/batch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,OAAO,GAAG;IACpB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,qFAAqF;AACrF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,+EAA+E;IAC/E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG;IACxD,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,cAAc,CAAC;CAC3B,CAAC;AAEF,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEhE,wEAAwE;AACxE,MAAM,MAAM,gBAAgB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,cAAc,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,WAAW,CAgBd;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,MAAM,GACZ,WAAW,CAUb;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAO1E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAQ5F;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,GACV;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAwBpD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,SAAI,GAAG,WAAW,CAMtE;AAED,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKnD"}

package/dist/services/queue/config.d.ts

@@ -2,6 +2,7 @@ import type { Application } from "../../foundation/Application";
 import type { Job } from "./Job";
 import type { LockStore } from "../lock/LockStore";
 import type { QueueDriver } from "./QueueDriver";
+import type { WorkflowClass } from "./workflow/Workflow";
 export interface QueueConfig {
     /**
      * The `Job` subclasses this application dispatches, or nothing.
@@ -45,6 +46,14 @@ export interface QueueConfig {
      * jobs is what this field is for; pointing it at `app/` is not.
      */
     jobsDir?: string;
+    /**
+     * The `Workflow` subclasses this application runs, or nothing, by the same
+     * rule as `jobs`: declared (including `[]`) is used as given, and absent
+     * discovers the classes under `workflowsDir`.
+     */
+    workflows?: WorkflowClass[];
+    /** Where to look when `workflows` was not declared. Default `app/workflows`. */
+    workflowsDir?: string;
     concurrency?: number;
     /**
      * Where queued jobs are kept: `"memory"`, `"database"`, a `QueueDriver`, or

package/dist/services/queue/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../services/queue/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC;IAE5B;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,EACH,QAAQ,GACR,UAAU,GACV,WAAW,GACX,CAAC,CAAC,WAAW,EAAE,WAAW,KAAK,WAAW,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EACF,MAAM,GACN,QAAQ,GACR,UAAU,GACV,SAAS,GACT,CAAC,CAAC,WAAW,EAAE,WAAW,KAAK,SAAS,CAAC,CAAC;CAC/C;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAElE;AAED,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,WAAW,CAAC,CAW3D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../services/queue/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC;IAE5B;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAE5B,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,EACH,QAAQ,GACR,UAAU,GACV,WAAW,GACX,CAAC,CAAC,WAAW,EAAE,WAAW,KAAK,WAAW,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EACF,MAAM,GACN,QAAQ,GACR,UAAU,GACV,SAAS,GACT,CAAC,CAAC,WAAW,EAAE,WAAW,KAAK,SAAS,CAAC,CAAC;CAC/C;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAElE;AAED,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,WAAW,CAAC,CAa3D"}

package/dist/services/queue/queueDriverContract.d.ts

@@ -24,6 +24,9 @@ import type { QueueDriver } from "./QueueDriver";
  * checks that the driver says so, because the manager then holds the dispatch
  * until the commit itself; that half is `QueueManager.transaction.test.ts`.
  *
+ * `features.batches` runs the batch tests: `enqueueBatch`, the counters
+ * `complete` and `fail` keep, `findBatch`, `cancelBatch` and `reportProgress`.
+ *
  * Not a `*.test.ts` file, so vitest never runs it on its own, and not exported
  * from `gemi/services`, because it imports vitest.
  *
@@ -42,5 +45,7 @@ export declare function queueDriverContract(name: string, create: () => QueueDri
         run(driver: QueueDriver, fn: () => Promise<void>): Promise<void>;
         joins: boolean;
     };
+    /** The driver implements the batch methods, and runs the tests that pin them. */
+    batches?: boolean;
 }): void;
 //# sourceMappingURL=queueDriverContract.d.ts.map

package/dist/services/queue/queueDriverContract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queueDriverContract.d.ts","sourceRoot":"","sources":["../../../services/queue/queueDriverContract.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,EAChD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACvD,QAAQ,GAAE;IACR,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE;QACZ,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACjE,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;CACE,QAulBP"}
+{"version":3,"file":"queueDriverContract.d.ts","sourceRoot":"","sources":["../../../services/queue/queueDriverContract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,EAChD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACvD,QAAQ,GAAE;IACR,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE;QACZ,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACjE,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;IACF,iFAAiF;IACjF,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,QAo4BP"}

package/dist/services/queue/work.js

@@ -1,4 +1,4 @@
 // @bun
-import{Ec as E,Hc as T}from"../../chunk-7vb4eey2.js";import"../../chunk-tn2bryy2.js";import"../../chunk-cbqazg9k.js";import"../../chunk-1myhm0g3.js";import"../../chunk-kejwjerj.js";import"../../chunk-t4yh4nf9.js";import"../../chunk-1vzks22y.js";import{fi as I,gi as J,ji as O}from"../../chunk-zyt2w03d.js";import{ni as N}from"../../chunk-1hr4xht1.js";import"../../chunk-vw8849ys.js";import L from"path";class F extends Error{name="QueueWorkerRefused"}class H{kernel;stopping;keepAlive;settings;constructor(y,z={}){this.kernel=y;this.settings={...J(),...z}}async start(){if(await this.kernel.waitForBoot(),this.stopping)return;let y=this.kernel.app;if(!y.bound(E))throw new F("[gemi] `gemi queue:work` has no queue to claim from: this application does not register QueueServiceProvider.");let z=y.make(E);if(!z.durable)throw new F('[gemi] `gemi queue:work` refuses to start: the queue uses the memory driver, which keeps each job in the process that dispatched it, so a worker never sees one. Set `driver: "database"` (or another driver every process can reach) in app/config/queue.ts, or run jobs in the server and drop the worker.');z.start(),this.keepAlive=setInterval(()=>{},1073741824),console.log(`[gemi] Queue worker started: claiming up to ${z.config.concurrency} job(s) at a time.`)}stop(y={}){return this.stopping??=this.drain({...this.settings,...y}),this.stopping}async drain(y){I();let z=this.kernel.app,A=z.resolved(E)?z.make(E):void 0;if(A)console.log(`[gemi] Shutting down: waiting for ${A.running} running job(s) (up to ${y.timeoutMs/1000}s).`),await A.drain(y.timeoutMs);let B=await this.kernel.shutdown({timeoutMs:y.providerTimeoutMs});clearInterval(this.keepAlive);let C=(A?.running??0)===0&&B.failed.length===0&&B.timedOut.length===0;return console.log(`[gemi] Shutdown ${C?"complete":"finished with errors"}.`),C?0:1}}async function U(){let y=N();process.env.ROOT_DIR=y,process.env.APP_DIR=L.join(y,"app"),T();let z=L.join(y,"app/kernel/Kernel.ts"),{default:A}=await import(z);if(typeof A!=="function")return console.error(`[gemi] ${z} has no default export to boot the worker from.`),1;let B=new A;B.boot();let C=new H(B);O(()=>C.stop());try{await C.start()}catch(G){if(!(G instanceof F))throw G;return console.error(G.message),1}return}U().then((y)=>{if(y!==void 0)process.exit(y)},(y)=>{console.error("[gemi] The queue worker failed to start:",y),process.exit(1)});
+import{Rc as E,Uc as T}from"../../chunk-nang3847.js";import"../../chunk-xx3zvc3g.js";import"../../chunk-gqfqnv3f.js";import"../../chunk-kkte8nze.js";import"../../chunk-hr1r3g0d.js";import"../../chunk-g5ppst76.js";import"../../chunk-d806cy7p.js";import{Vi as I,Wi as J,Zi as O}from"../../chunk-8wcpxm41.js";import{bj as N}from"../../chunk-jg79n382.js";import"../../chunk-hm9cjxy2.js";import L from"path";class F extends Error{name="QueueWorkerRefused"}class H{kernel;stopping;keepAlive;settings;constructor(y,z={}){this.kernel=y;this.settings={...J(),...z}}async start(){if(await this.kernel.waitForBoot(),this.stopping)return;let y=this.kernel.app;if(!y.bound(E))throw new F("[gemi] `gemi queue:work` has no queue to claim from: this application does not register QueueServiceProvider.");let z=y.make(E);if(!z.durable)throw new F('[gemi] `gemi queue:work` refuses to start: the queue uses the memory driver, which keeps each job in the process that dispatched it, so a worker never sees one. Set `driver: "database"` (or another driver every process can reach) in app/config/queue.ts, or run jobs in the server and drop the worker.');z.start(),this.keepAlive=setInterval(()=>{},1073741824),console.log(`[gemi] Queue worker started: claiming up to ${z.config.concurrency} job(s) at a time.`)}stop(y={}){return this.stopping??=this.drain({...this.settings,...y}),this.stopping}async drain(y){I();let z=this.kernel.app,A=z.resolved(E)?z.make(E):void 0;if(A)console.log(`[gemi] Shutting down: waiting for ${A.running} running job(s) (up to ${y.timeoutMs/1000}s).`),await A.drain(y.timeoutMs);let B=await this.kernel.shutdown({timeoutMs:y.providerTimeoutMs});clearInterval(this.keepAlive);let C=(A?.running??0)===0&&B.failed.length===0&&B.timedOut.length===0;return console.log(`[gemi] Shutdown ${C?"complete":"finished with errors"}.`),C?0:1}}async function U(){let y=N();process.env.ROOT_DIR=y,process.env.APP_DIR=L.join(y,"app"),T();let z=L.join(y,"app/kernel/Kernel.ts"),{default:A}=await import(z);if(typeof A!=="function")return console.error(`[gemi] ${z} has no default export to boot the worker from.`),1;let B=new A;B.boot();let C=new H(B);O(()=>C.stop());try{await C.start()}catch(G){if(!(G instanceof F))throw G;return console.error(G.message),1}return}U().then((y)=>{if(y!==void 0)process.exit(y)},(y)=>{console.error("[gemi] The queue worker failed to start:",y),process.exit(1)});
 
-//# debugId=94D4E3D8DDBEA88A64756E2164756E21
+//# debugId=FAD23F28132E03B464756E2164756E21

package/dist/services/queue/work.js.map

@@ -6,6 +6,6 @@
     "import type { Application, ShutdownReport } from \"../../foundation/Application\";\nimport { markShuttingDown, shutdownSettings, type ShutdownSettings } from \"../../server/shutdown\";\nimport { QueueManager } from \"./QueueManager\";\n\n/** The part of a `Kernel` a worker drives. */\nexport type WorkerKernel = {\n  readonly app: Application;\n  waitForBoot(): Promise<void>;\n  shutdown(options?: { timeoutMs?: number }): Promise<ShutdownReport>;\n};\n\n/**\n * A worker that was told to start in an application it cannot claim for. The\n * message is written for the operator reading the deploy's logs.\n */\nexport class QueueWorkerRefused extends Error {\n  name = \"QueueWorkerRefused\";\n}\n\n/**\n * The process `gemi queue:work` runs: the application booted as a server boots\n * it, claiming from the queue, and no `Bun.serve`. It exists so job capacity\n * can be scaled apart from request traffic, which needs a driver both kinds of\n * process can reach; see `start` for why the memory driver is refused.\n *\n * The caller marks the process as a worker (`markQueueWorker`) before the\n * kernel registers, so every claim rule that asks `claimsInThisProcess` sees a\n * process that claims, whatever `GEMI_QUEUE_CLAIM` says.\n */\nexport class QueueWorker {\n  private stopping: Promise<number> | undefined;\n  private keepAlive: ReturnType<typeof setInterval> | undefined;\n  private readonly settings: ShutdownSettings;\n\n  /**\n   * `settings` default to the `GEMI_SHUTDOWN_*` variables, read here rather\n   * than at the signal so a bad value is warned about while the deploy is\n   * being watched, as `Server.start` does.\n   */\n  constructor(\n    private readonly kernel: WorkerKernel,\n    settings: Partial<ShutdownSettings> = {},\n  ) {\n    this.settings = { ...shutdownSettings(), ...settings };\n  }\n\n  /**\n   * Boots the application and starts claiming. Rejects with\n   * `QueueWorkerRefused` when the application has no queue, or its queue uses\n   * the memory driver.\n   *\n   * Refused rather than warned about, because a memory worker can never do\n   * anything: its jobs live in a `Map` in the process that dispatched them,\n   * so a worker's is always empty. Left running, it looks like a healthy\n   * deploy — a process up, no errors — that runs nothing, and scaling it out\n   * adds no capacity. An exit the platform reports as a crash loop is a form\n   * of the mistake someone will see.\n   */\n  async start(): Promise<void> {\n    await this.kernel.waitForBoot();\n    // A signal during the boot has already drained and cleared the handle\n    // below. Going on would start the loop again and arm a handle nothing\n    // clears, holding open a worker that has finished shutting down.\n    if (this.stopping) return;\n\n    const application = this.kernel.app;\n    // `bound`, not `make` in a try: an application built without the queue\n    // provider is a configuration to name, not an unbound-token stack trace.\n    if (!application.bound(QueueManager)) {\n      throw new QueueWorkerRefused(\n        \"[gemi] `gemi queue:work` has no queue to claim from: this application \" +\n          \"does not register QueueServiceProvider.\",\n      );\n    }\n    const queue = application.make(QueueManager);\n    if (!queue.durable) {\n      throw new QueueWorkerRefused(\n        \"[gemi] `gemi queue:work` refuses to start: the queue uses the memory \" +\n          \"driver, which keeps each job in the process that dispatched it, so \" +\n          'a worker never sees one. Set `driver: \"database\"` (or another driver ' +\n          \"every process can reach) in app/config/queue.ts, or run jobs in the \" +\n          \"server and drop the worker.\",\n      );\n    }\n\n    // Idempotent: a production boot with a durable driver has already started\n    // it (`startClaimingIfServing`). Development has not, and a worker claims\n    // in either.\n    queue.start();\n    // The queue's poll timer is unref'd, so that a script's queue does not\n    // hold it open; here the queue is the process, and without a handle of its\n    // own an idle worker would exit 0 as soon as it booted.\n    this.keepAlive = setInterval(() => {}, 1 << 30);\n    console.log(\n      `[gemi] Queue worker started: claiming up to ${queue.config.concurrency} job(s) at a time.`,\n    );\n  }\n\n  /**\n   * Stops claiming, waits for the running jobs, runs every provider's\n   * `shutdown()`, and resolves with the exit code: 0 when no job was left\n   * running and every provider finished in time, 1 otherwise. Idempotent.\n   *\n   * `gemi start`'s drain, with the jobs where the requests were:\n   * `isShuttingDown()` turns true, which stops a durable queue claiming;\n   * running jobs get `timeoutMs` (`GEMI_SHUTDOWN_TIMEOUT`), which a server\n   * spends on requests; then `Application.shutdown` gets `providerTimeoutMs`,\n   * and in it the queue provider waits for whatever is still running and\n   * names it. The two budgets add up as they do for a server, so a worker\n   * fits the same grace period. `delayMs` is not waited: it is for a load\n   * balancer, and nothing routes to a worker.\n   */\n  stop(settings: Partial<ShutdownSettings> = {}): Promise<number> {\n    this.stopping ??= this.drain({ ...this.settings, ...settings });\n    return this.stopping;\n  }\n\n  private async drain(settings: ShutdownSettings): Promise<number> {\n    markShuttingDown();\n    const application = this.kernel.app;\n    // Resolving the manager now would build a driver only to stop it, which\n    // is what a signal during the boot, before the provider resolved it, finds.\n    const queue = application.resolved(QueueManager) ? application.make(QueueManager) : undefined;\n    if (queue) {\n      console.log(\n        `[gemi] Shutting down: waiting for ${queue.running} running job(s) ` +\n          `(up to ${settings.timeoutMs / 1000}s).`,\n      );\n      await queue.drain(settings.timeoutMs);\n    }\n\n    const report = await this.kernel.shutdown({ timeoutMs: settings.providerTimeoutMs });\n    clearInterval(this.keepAlive);\n    const clean =\n      (queue?.running ?? 0) === 0 && report.failed.length === 0 && report.timedOut.length === 0;\n    console.log(`[gemi] Shutdown ${clean ? \"complete\" : \"finished with errors\"}.`);\n    return clean ? 0 : 1;\n  }\n}\n"
   ],
   "mappings": ";iZAYA,kBCGO,IAAM,QAA2B,GAAM,DAC5C,GAAO,kBACT,DAYO,IAAM,CAAY,CAWJ,OAVX,SACA,UACS,SAOjB,WAAW,CACQ,EACjB,EAAsC,CAAC,EACvC,CAFiB,cAGjB,KAAK,SAAW,IAAK,EAAiB,KAAM,CAAS,OAejD,MAAK,EAAkB,CAK3B,GAJA,MAAM,KAAK,OAAO,YAAY,EAI1B,KAAK,SAAU,OAEnB,IAAM,EAAc,KAAK,OAAO,IAGhC,GAAI,CAAC,EAAY,MAAM,CAAY,EACjC,MAAM,IAAI,EACR,+GAEF,EAEF,IAAM,EAAQ,EAAY,KAAK,CAAY,EAC3C,GAAI,CAAC,EAAM,QACT,MAAM,IAAI,EACR,8SAKF,EAMF,EAAM,MAAM,EAIZ,KAAK,UAAY,YAAY,IAAM,GAAI,UAAO,EAC9C,QAAQ,IACN,+CAA+C,EAAM,OAAO,+BAC9D,EAiBF,IAAI,CAAC,EAAsC,CAAC,EAAoB,CAE9D,OADA,KAAK,WAAa,KAAK,MAAM,IAAK,KAAK,YAAa,CAAS,CAAC,EACvD,KAAK,cAGA,MAAK,CAAC,EAA6C,CAC/D,EAAiB,EACjB,IAAM,EAAc,KAAK,OAAO,IAG1B,EAAQ,EAAY,SAAS,CAAY,EAAI,EAAY,KAAK,CAAY,EAAI,OACpF,GAAI,EACF,QAAQ,IACN,qCAAqC,EAAM,iCAC/B,EAAS,UAAY,SACnC,EACA,MAAM,EAAM,MAAM,EAAS,SAAS,EAGtC,IAAM,EAAS,MAAM,KAAK,OAAO,SAAS,CAAE,UAAW,EAAS,iBAAkB,CAAC,EACnF,cAAc,KAAK,SAAS,EAC5B,IAAM,GACH,GAAO,SAAW,KAAO,GAAK,EAAO,OAAO,SAAW,GAAK,EAAO,SAAS,SAAW,EAE1F,OADA,QAAQ,IAAI,mBAAmB,EAAQ,WAAa,yBAAyB,EACtE,EAAQ,EAAI,EAEvB,CDvHA,eAAe,CAAI,EAAgC,CACjD,IAAM,EAAU,EAAY,EAI5B,QAAQ,IAAI,SAAW,EACvB,QAAQ,IAAI,QAAU,EAAK,KAAK,EAAS,KAAK,EAE9C,EAAgB,EAEhB,IAAM,EAAa,EAAK,KAAK,EAAS,sBAAsB,GACpD,QAAS,GAAY,MAAa,UAG1C,GAAI,OAAO,IAAW,WAEpB,OADA,QAAQ,MAAM,UAAU,kDAA2D,EAC5E,EAET,IAAM,EAAS,IAAI,EACnB,EAAO,KAAK,EAEZ,IAAM,EAAS,IAAI,EAAY,CAAM,EAKrC,EAAuB,IAAM,EAAO,KAAK,CAAC,EAE1C,GAAI,CACF,MAAM,EAAO,MAAM,EACnB,MAAO,EAAO,CACd,GAAI,EAAE,aAAiB,GAAqB,MAAM,EAElD,OADA,QAAQ,MAAM,EAAM,OAAO,EACpB,EAGT,OAGF,EAAK,EAAE,KACL,CAAC,IAAS,CACR,GAAI,IAAS,OAAW,QAAQ,KAAK,CAAI,GAE3C,CAAC,IAAU,CACT,QAAQ,MAAM,2CAA4C,CAAK,EAC/D,QAAQ,KAAK,CAAC,EAElB",
-  "debugId": "94D4E3D8DDBEA88A64756E2164756E21",
+  "debugId": "FAD23F28132E03B464756E2164756E21",
   "names": []
 }

package/dist/services/queue/workflow/DatabaseWorkflowStore.d.ts

@@ -0,0 +1,89 @@
+import type { SQL, TransactionSQL } from "bun";
+import type { Dialect } from "../../../database/dialect";
+import type { EnqueueBatch, EnqueueJob } from "../QueueDriver";
+import { type AcquireResult, type WorkflowChange, type WorkflowSnapshot, type WorkflowState, type WorkflowStore } from "./WorkflowStore";
+/** A SQL fragment, as the driver's helpers build them. */
+type Fragment = ReturnType<SQL["unsafe"]>;
+/**
+ * What the database queue driver lends its workflow store: its connection,
+ * its transactions and clock, and the writes a workflow's changes schedule.
+ * The driver builds it from its private methods, so the two share one
+ * transaction per change.
+ */
+export type DatabaseQueueInternals = {
+    sql: SQL;
+    dialect: Dialect;
+    connection: string | undefined;
+    configure(): Promise<void>;
+    atomically<T>(fn: (q: SQL) => Promise<T>): Promise<T>;
+    transaction(): TransactionSQL | undefined;
+    now(q: SQL): Fragment;
+    ms(q: SQL, value: number): Fragment;
+    timeOrNull(q: SQL, value: number | null): Fragment;
+    fraction(q: SQL, value: number): Fragment;
+    clock(q: SQL): Promise<number>;
+    insertJob(q: SQL, job: EnqueueJob): Promise<string>;
+    insertBatch(q: SQL, batch: EnqueueBatch): Promise<void>;
+    cancelBatch(q: SQL, id: string): Promise<boolean>;
+    quoted(identifier: string): string;
+};
+/**
+ * Workflows in two tables of the queue's database: one row per workflow, and
+ * one per step, keyed by the workflow and the step's key.
+ *
+ * Every change runs in a transaction that locks the workflow's row first
+ * (`SELECT … FOR UPDATE` on Postgres and MySQL; a no-op write on SQLite, which
+ * takes the file's write lock), reads what the change depends on, and writes
+ * it together with any tick job or batch it schedules. The queue's batch
+ * transactions lock a batch row and then job rows and never a workflow row,
+ * so the two kinds cannot deadlock on each other.
+ */
+export declare class DatabaseWorkflowStore implements WorkflowStore {
+    private readonly db;
+    readonly table: string;
+    readonly stepTable: string;
+    constructor(db: DatabaseQueueInternals, options: {
+        table: string;
+        stepTable: string;
+    });
+    joinsTransaction(): boolean;
+    create(workflow: {
+        id: string;
+        name: string;
+        args: string;
+    }): Promise<void>;
+    private insertWorkflow;
+    find(id: string, options?: {
+        steps?: boolean;
+    }): Promise<WorkflowState | null>;
+    acquire(id: string, owner: string, leaseMs: number): Promise<AcquireResult>;
+    renew(id: string, owner: string, leaseMs: number): Promise<boolean>;
+    update<T>(id: string, options: {
+        owner?: string;
+        key?: string;
+        allSteps?: boolean;
+    }, decide: (snapshot: WorkflowSnapshot) => WorkflowChange<T>): Promise<T | undefined>;
+    prune(olderThanMs: number): Promise<number>;
+    private writeStep;
+    /**
+     * Reads the workflow's row and holds it until the transaction ends, as the
+     * driver's `lockBatch` holds a batch's.
+     */
+    private lock;
+    private stepOf;
+    private stepsOf;
+    private workflows;
+    private steps;
+    /** `key` is a reserved word in MySQL. */
+    private keyColumn;
+}
+/**
+ * The two workflow tables, as Prisma generates them for the `GemiWorkflow`
+ * and `GemiWorkflowStep` models in the docs (checked against `prisma migrate
+ * diff` for all three providers), with `IF NOT EXISTS` added. MySQL cannot
+ * say that of an index, so its index is declared inside the table, which is
+ * also where Prisma puts it.
+ */
+export declare function createWorkflowTableStatements(dialect: Dialect, table: string, stepTable: string): string[];
+export {};
+//# sourceMappingURL=DatabaseWorkflowStore.d.ts.map

package/dist/services/queue/workflow/DatabaseWorkflowStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseWorkflowStore.d.ts","sourceRoot":"","sources":["../../../../services/queue/workflow/DatabaseWorkflowStore.ts"],"names":[],"mappings":"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"}

package/dist/services/queue/workflow/MemoryWorkflowStore.d.ts

@@ -0,0 +1,43 @@
+import type { EnqueueBatch, EnqueueJob } from "../QueueDriver";
+import { type AcquireResult, type StepRecord, type WorkflowChange, type WorkflowRecord, type WorkflowState, type WorkflowStore } from "./WorkflowStore";
+/** What the memory driver lends its workflow store: its own writes, done synchronously. */
+export type MemoryQueueWrites = {
+    enqueue(job: EnqueueJob): void;
+    enqueueBatch(batch: EnqueueBatch): void;
+    cancelBatch(id: string): void;
+};
+/**
+ * Workflows in this process's memory, beside the memory driver's jobs, and
+ * lost with them when the process exits. Every change happens synchronously
+ * inside the call that makes it, so it is atomic without further care.
+ */
+export declare class MemoryWorkflowStore implements WorkflowStore {
+    private readonly queue;
+    private workflows;
+    private steps;
+    constructor(queue: MemoryQueueWrites);
+    create(workflow: {
+        id: string;
+        name: string;
+        args: string;
+    }): Promise<void>;
+    find(id: string, options?: {
+        steps?: boolean;
+    }): Promise<WorkflowState | null>;
+    acquire(id: string, owner: string, leaseMs: number): Promise<AcquireResult>;
+    renew(id: string, owner: string, leaseMs: number): Promise<boolean>;
+    update<T>(id: string, options: {
+        owner?: string;
+        key?: string;
+        allSteps?: boolean;
+    }, decide: (snapshot: {
+        workflow: WorkflowRecord;
+        step: StepRecord | null;
+        steps: StepRecord[];
+        now: number;
+    }) => WorkflowChange<T>): Promise<T | undefined>;
+    prune(olderThanMs: number): Promise<number>;
+    private stepsOf;
+    private tick;
+}
+//# sourceMappingURL=MemoryWorkflowStore.d.ts.map

package/dist/services/queue/workflow/MemoryWorkflowStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryWorkflowStore.d.ts","sourceRoot":"","sources":["../../../../services/queue/workflow/MemoryWorkflowStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,UAAU,EAEf,KAAK,cAAc,EAGnB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AAEzB,2FAA2F;AAC3F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAKF;;;;GAIG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IAI3C,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHlC,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,KAAK,CAA8C;gBAE9B,KAAK,EAAE,iBAAiB;IAE/C,MAAM,CAAC,QAAQ,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B3E,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IASlF,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB3E,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOnE,MAAM,CAAC,CAAC,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,EAC7D,MAAM,EAAE,CAAC,QAAQ,EAAE;QACjB,QAAQ,EAAE,cAAc,CAAC;QACzB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;QACxB,KAAK,EAAE,UAAU,EAAE,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;KACb,KAAK,cAAc,CAAC,CAAC,CAAC,GACtB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAqCnB,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAcjD,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;CAOb"}

package/dist/services/queue/workflow/Step.d.ts

@@ -0,0 +1,202 @@
+import { type BatchStatus } from "../batch";
+import type { EnqueueBatch } from "../QueueDriver";
+import type { Job } from "../Job";
+import { type Duration } from "./duration";
+import { type StepRecord, type WorkflowStore } from "./WorkflowStore";
+/** What a `step.run` function is handed. */
+export type StepContext = {
+    /**
+     * `<workflow id>:<step key>`: the same on every attempt of this step, and
+     * different for every other step. Pass it to a payment provider, say, so
+     * that an attempt repeated after a crash is not charged twice.
+     */
+    idempotencyKey: string;
+    /** Which attempt this is, counting from 1. */
+    attempt: number;
+    /**
+     * Aborted when the step's `timeout` passes or the workflow is cancelled.
+     * Pass it to `fetch` and friends. The workflow stops waiting for the step
+     * at that moment, whether or not the function notices.
+     */
+    signal: AbortSignal;
+};
+export type StepRunOptions = {
+    /** How many attempts the step gets, counting the first. Default 3. */
+    attempts?: number;
+    /**
+     * Milliseconds to wait before each retry: one number for every retry, or
+     * one per retry with the last repeated, as `Job.backoff`. Default 0. A
+     * retry with a delay suspends the workflow until it is due.
+     */
+    backoff?: number | number[];
+    /** How long one attempt may take before it counts as failed. */
+    timeout?: Duration;
+};
+export type StepWaitOptions = {
+    /**
+     * How long to wait for the signal. Past it, `waitFor` throws a
+     * `WaitTimeoutError`. Without it, the workflow waits until it is signalled
+     * or cancelled.
+     */
+    timeout?: Duration;
+};
+export type StepBatchOptions = {
+    /** A label kept with the batch. Default `workflow:<id>:<key>`. */
+    name?: string;
+    /**
+     * Whether a failed job leaves the rest running. Default `false`: the first
+     * dead-lettered job cancels the batch and `step.batch` throws a
+     * `StepFailedError`. With `true`, `step.batch` returns the status, failed
+     * jobs and all.
+     */
+    allowFailures?: boolean;
+};
+/** A step that ran out of attempts, or a batch that failed. */
+export declare class StepFailedError extends Error {
+    /** The step's key. */
+    readonly step: string;
+    /** The batch's final status, for a `step.batch` that failed. */
+    readonly batch?: BatchStatus;
+    constructor(
+    /** The step's key. */
+    step: string, message: string, 
+    /** The batch's final status, for a `step.batch` that failed. */
+    batch?: BatchStatus);
+}
+/** A `step.waitFor` whose `timeout` passed before the signal arrived. */
+export declare class WaitTimeoutError extends Error {
+    readonly step: string;
+    constructor(step: string);
+}
+/** Why a step's `ctx.signal` was aborted by its `timeout`. */
+export declare class StepTimeoutError extends Error {
+    constructor(step: string, timeoutMs: number);
+}
+/** Why a step's `ctx.signal` was aborted by `Workflow.cancel`. */
+export declare class WorkflowCancelledError extends Error {
+    constructor(id: string);
+}
+/**
+ * Thrown through the workflow's code when a step cannot finish in this tick
+ * (a sleep, a wait, a batch, a retry with a delay), so the tick can end and
+ * the workflow resume later. Not exported: code that catches everything
+ * should rethrow what it does not know, and the tick treats the workflow as
+ * suspended even if this is swallowed.
+ */
+export declare class WorkflowSuspended extends Error {
+    constructor();
+}
+/** What the runtime gives the steps of one tick. */
+export type StepTick = {
+    workflowId: string;
+    /** The tick's hold on the workflow; every write is fenced by it. */
+    owner: string;
+    store: WorkflowStore;
+    /** The steps as they were when the tick took the workflow. */
+    steps: StepRecord[];
+    /** This tick runs `onCancel`, not `run`. */
+    cancelling: boolean;
+    findBatch(id: string): Promise<BatchStatus | null>;
+    buildBatch(job: new () => Job, args: ReadonlyArray<ReadonlyArray<unknown>>, options: {
+        name: string;
+        allowFailures: boolean;
+    }): EnqueueBatch;
+    /** Jobs were recorded: wake the queue. */
+    scheduled(): void;
+    /** How often a running step checks whether the workflow was cancelled. */
+    cancelCheckMs: number;
+};
+/** Why a tick stopped where it did. */
+export type Suspension = {
+    status: "sleeping" | "waiting";
+    /** When a tick is needed to continue; none for a wait on a signal or batch. */
+    wakes: number[];
+};
+/**
+ * What `run` receives as its first argument. Every method takes a **key**,
+ * unique within the workflow and the same on every pass: a step whose key has
+ * a stored result returns it without running again, which is how a workflow
+ * resumes where it stopped. Code outside the steps runs again on every pass.
+ */
+export declare class Step {
+    private readonly tick;
+    /** The workflow's id. */
+    readonly workflowId: string;
+    private readonly steps;
+    private readonly seen;
+    private readonly pending;
+    /** @internal Why the tick stopped, once a step suspended it. */
+    suspension: Suspension | undefined;
+    /** @internal The tick lost its hold on the workflow. */
+    lost: boolean;
+    /** The workflow was cancelled during this tick. */
+    private cancelled;
+    /** @internal The step the workflow is on, for its status. */
+    current: string | null;
+    /** @internal Built by the workflow runtime, once per tick. */
+    constructor(tick: StepTick);
+    /**
+     * Runs `fn` once and stores what it returns, as JSON; on every later pass
+     * the stored value is returned without running it again. A throw is retried
+     * up to `attempts`, after which the step fails and this throws a
+     * `StepFailedError`, which the workflow may catch. The value comes back as
+     * JSON makes it, the first time too: a `Date` becomes a string.
+     *
+     * At least once: a process that dies after `fn` and before its result is
+     * stored runs it again. Use `ctx.idempotencyKey` for anything that must not
+     * happen twice, or `attempts: 1`.
+     */
+    run<T>(key: string, fn: (ctx: StepContext) => T | Promise<T>, options?: StepRunOptions): Promise<Awaited<T>>;
+    /** Suspends the workflow for `duration`, without holding a process. */
+    sleep(key: string, duration: Duration): Promise<void>;
+    /**
+     * Suspends the workflow until `Workflow.signal(id, key, payload)` and
+     * returns the payload. A signal that arrives before the workflow gets here
+     * is kept, and returned at once.
+     */
+    waitFor<T = unknown>(key: string, options?: StepWaitOptions): Promise<T>;
+    /**
+     * Dispatches `job` once per argument tuple as a batch (`Job.dispatchBatch`)
+     * and suspends the workflow until every job has ended; then returns the
+     * batch's status. The step is recorded and the batch dispatched in one
+     * atomic write, so a crash cannot dispatch it twice.
+     */
+    batch<J extends Job>(key: string, job: new () => J, args: ReadonlyArray<Readonly<Parameters<J["run"]>>>, options?: StepBatchOptions): Promise<BatchStatus>;
+    /**
+     * Sets the workflow's `progress`, 0 to 1. Not a step: it writes on every
+     * pass that reaches it.
+     */
+    progress(value: number): Promise<void>;
+    /** @internal Waits for every step this tick started, however each ended. */
+    settled(): Promise<void>;
+    private track;
+    private remember;
+    /** Once suspended, nothing else may start in this tick. */
+    private assertRunning;
+    private suspend;
+    /**
+     * One atomic write, fenced by the tick's hold. A workflow that is being
+     * cancelled takes no new work from `run`: the write is skipped and the
+     * tick suspended, so `onCancel` runs next.
+     */
+    private write;
+    private record;
+    private mismatch;
+    private runStep;
+    /**
+     * One attempt of a `step.run` function, abandoned when its timeout passes
+     * or the workflow is cancelled meanwhile.
+     */
+    private execute;
+    private sleepStep;
+    private waitStep;
+    private batchStep;
+}
+/**
+ * A value as stored: JSON, or `null` for `undefined`. Refused past
+ * `WORKFLOW_OUTPUT_LIMIT`, and for what JSON cannot carry.
+ */
+export declare function encode(value: unknown, what: string): string | null;
+export declare function decode(output: string | null): unknown;
+export declare function describe(error: unknown): string;
+//# sourceMappingURL=Step.d.ts.map

package/dist/services/queue/workflow/Step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Step.d.ts","sourceRoot":"","sources":["../../../../services/queue/workflow/Step.ts"],"names":[],"mappings":"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"}