gemi 0.117.0 → 0.118.0

package/dist/chunk-nang3847.js

@@ -0,0 +1,416 @@
+// @bun
+import{Kh as k,Mh as T0}from"./chunk-xx3zvc3g.js";import{Nh as S0}from"./chunk-gqfqnv3f.js";import{Ph as N0,Qh as R0,Rh as Q0,Th as C,Vh as q,ci as B0}from"./chunk-kkte8nze.js";import{ri as H0}from"./chunk-hr1r3g0d.js";import{Oi as W0,Ri as b}from"./chunk-g5ppst76.js";import{Ui as M0}from"./chunk-8wcpxm41.js";class p{entries=new Map;counters=new Map;async acquire(z,V,Y){let Z=Date.now(),$=this.entries.get(z);if($&&($.expiresAt>Z||$.fences>0))return null;let X=($?.token??0)+1;return this.entries.set(z,{owner:V,token:X,expiresAt:Z+Math.max(0,Y),fences:0}),X}async extend(z,V,Y,Z){let $=this.current(z,V,Y);if(!$)return!1;return $.expiresAt=Date.now()+Math.max(0,Z),!0}async release(z,V,Y){let Z=this.current(z,V,Y);if(!Z)return!1;return Z.owner="",Z.expiresAt=0,!0}async holder(z){let V=this.entries.get(z);if(!V||V.expiresAt<=Date.now())return null;return{owner:V.owner,token:V.token}}async held(z,V,Y){return this.current(z,V,Y)!==void 0}async advance(z,V){if((this.counters.get(z)??-1/0)>=V)return!1;return this.counters.set(z,V),!0}async fence(z,V,Y,Z){let $=this.current(z,V,Y);if(!$)throw new k(z,Y);$.fences++;try{return await Z()}finally{$.fences--}}windows=new Map;async hit(z,V,Y){let Z=Date.now(),$=this.windows.get(z);if(!$||$.endsAt<=Z)$={count:0,endsAt:Z+Math.max(1,Y)},this.windows.set(z,$);if($.count>=V)return{allowed:!1,resetInMs:$.endsAt-Z};return $.count++,{allowed:!0,resetInMs:$.endsAt-Z}}async refund(z){let V=this.windows.get(z);if(V&&V.endsAt>Date.now()&&V.count>0)V.count--}current(z,V,Y){let Z=this.entries.get(z);if(!Z||Z.owner!==V||Z.expiresAt<=Date.now())return;if(Y!==void 0&&Z.token!==Y)return;return Z}}class y{table;sql;dialect;connection;busyTimeout;configured;constructor(z,V={}){let Y=V.table??"gemi_locks";if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(Y))throw Error(`The lock table name "${Y}" is not a plain identifier. Use letters, digits and underscores.`);this.table=Y,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=V.busyTimeout??1000}async createTable(){await this.configure();for(let z of v0(this.dialect,this.table))await this.sql.unsafe(z)}async acquire(z,V,Y){await this.configure();let Z=this.sql,$=this.now(Z);if(await this.seed(Z,z),this.mysql){let H=await Z`
+        UPDATE ${this.name(Z)}
+        SET owner = ${V}, token = token + 1, expires_at = ${$} + ${this.ms(Z,Y)},
+            updated_at = ${$}
+        WHERE name = ${z} AND expires_at <= ${$}
+      `;if(O(H)===0)return null;let[G]=await Z`
+        SELECT token FROM ${this.name(Z)} WHERE name = ${z} AND owner = ${V}
+      `;return G?Number(G.token):null}let X=await Z`
+      UPDATE ${this.name(Z)}
+      SET owner = ${V}, token = token + 1, expires_at = ${$} + ${this.ms(Z,Y)},
+          updated_at = ${$}
+      WHERE name = ${z} AND expires_at <= ${$}
+      RETURNING token
+    `;return X[0]?Number(X[0].token):null}async extend(z,V,Y,Z){await this.configure();let $=this.sql,X=this.now($),H=await $`
+      UPDATE ${this.name($)}
+      SET expires_at = ${X} + ${this.ms($,Z)}, updated_at = ${X}
+      WHERE name = ${z} AND owner = ${V} AND token = ${Y} AND expires_at > ${X}
+    `;if(O(H)>0)return!0;return this.mysql?this.held(z,V,Y):!1}async release(z,V,Y){await this.configure();let Z=this.sql,$=this.now(Z),X=Y===void 0?Z`1 = 1`:Z`token = ${Y}`,H=await Z`
+      UPDATE ${this.name(Z)}
+      SET owner = '', expires_at = 0, updated_at = ${$}
+      WHERE name = ${z} AND owner = ${V} AND ${X} AND expires_at > ${$}
+    `;return O(H)>0}async holder(z){await this.configure();let V=this.sql,[Y]=await V`
+      SELECT owner, token FROM ${this.name(V)}
+      WHERE name = ${z} AND expires_at > ${this.now(V)}
+    `;return Y?{owner:String(Y.owner),token:Number(Y.token)}:null}async held(z,V,Y){await this.configure();let Z=this.sql;return(await Z`
+      SELECT 1 AS held FROM ${this.name(Z)}
+      WHERE name = ${z} AND owner = ${V} AND token = ${Y} AND expires_at > ${this.now(Z)}
+    `).length>0}async advance(z,V){await this.configure();let Y=this.sql;await this.seed(Y,z);let Z=await Y`
+      UPDATE ${this.name(Y)}
+      SET token = ${this.int(Y,V)}, updated_at = ${this.now(Y)}
+      WHERE name = ${z} AND token < ${this.int(Y,V)}
+    `;return O(Z)>0}async fence(z,V,Y,Z){await this.configure();let $=async(H)=>{let G=this.now(H),Q;if(this.dialect==="sqlite"){let B=await H`
+          UPDATE ${this.name(H)} SET updated_at = ${G}
+          WHERE name = ${z} AND owner = ${V} AND token = ${Y} AND expires_at > ${G}
+        `;Q=O(B)>0}else Q=(await H`
+          SELECT 1 AS held FROM ${this.name(H)}
+          WHERE name = ${z} AND owner = ${V} AND token = ${Y} AND expires_at > ${G}
+          FOR UPDATE
+        `).length>0;if(!Q)throw new k(z,Y);return Z()},X=this.connection;if(X===void 0)return await this.sql.begin((H)=>$(H));return B0(this.sql,(H)=>Q0(X,()=>$(H)),{connection:X})}async hit(z,V,Y){await this.configure();let Z=this.sql,$=this.now(Z);await this.seed(Z,z);let X=this.ms(Z,Math.max(1,Y)),H=await Z`
+      UPDATE ${this.name(Z)}
+      SET token = CASE WHEN expires_at <= ${$} THEN 1 ELSE token + 1 END,
+          expires_at = CASE WHEN expires_at <= ${$} THEN ${$} + ${X} ELSE expires_at END,
+          updated_at = ${$}
+      WHERE name = ${z} AND (expires_at <= ${$} OR token < ${this.int(Z,V)})
+    `,G=O(H)>0,[Q]=await Z`
+      SELECT expires_at - ${$} AS reset FROM ${this.name(Z)} WHERE name = ${z}
+    `;return{allowed:G,resetInMs:Math.max(0,Number(Q?.reset??0))}}async refund(z){await this.configure();let V=this.sql,Y=this.now(V);await V`
+      UPDATE ${this.name(V)} SET token = token - 1, updated_at = ${Y}
+      WHERE name = ${z} AND token > 0 AND expires_at > ${Y}
+    `}async prune(z){await this.configure();let V=this.sql,Y=this.now(V),Z=await V`
+      DELETE FROM ${this.name(V)}
+      WHERE expires_at <= ${Y} AND updated_at <= ${Y} - ${this.ms(V,z)}
+    `;return O(Z)}async seed(z,V){let Y=this.now(z);if(this.mysql){await z`
+        INSERT IGNORE INTO ${this.name(z)} (name, owner, token, expires_at, updated_at)
+        VALUES (${V}, '', 0, 0, ${Y})
+      `;return}await z`
+      INSERT INTO ${this.name(z)} (name, owner, token, expires_at, updated_at)
+      VALUES (${V}, '', 0, 0, ${Y})
+      ON CONFLICT (name) DO NOTHING
+    `}get mysql(){return this.dialect==="mysql"||this.dialect==="mariadb"}configure(){if(this.dialect!=="sqlite"||this.busyTimeout===0)return Promise.resolve();return this.configured??=(async()=>{let[z]=await this.sql.unsafe("PRAGMA busy_timeout");if(Number(z?.timeout??0)!==0)return;await this.sql.unsafe(`PRAGMA busy_timeout = ${this.busyTimeout}`)})().catch((z)=>{throw this.configured=void 0,z}),this.configured}name(z){return z.unsafe(this.mysql?`\`${this.table}\``:`"${this.table}"`)}now(z){switch(this.dialect){case"postgres":return z`floor(extract(epoch from statement_timestamp()) * 1000)::bigint`;case"mysql":case"mariadb":return z`(TIMESTAMPDIFF(MICROSECOND, '1970-01-01 00:00:00', UTC_TIMESTAMP(6)) DIV 1000)`;case"sqlite":return z`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`}}ms(z,V){return this.int(z,Math.max(0,Math.round(V)))}int(z,V){let Y=Math.round(V);return this.mysql?z`CAST(${Y} AS SIGNED)`:z`CAST(${Y} AS BIGINT)`}}function O(z){let V=z;return Math.max(Number(V.count??0),Number(V.affectedRows??0))}function v0(z,V){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${V}\` (
+    \`name\` VARCHAR(191) NOT NULL,
+    \`owner\` VARCHAR(191) NOT NULL,
+    \`token\` BIGINT NOT NULL DEFAULT 0,
+    \`expires_at\` BIGINT NOT NULL,
+    \`updated_at\` BIGINT NOT NULL,
+
+    PRIMARY KEY (\`name\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`];let Y=z==="sqlite"?'"name" TEXT NOT NULL PRIMARY KEY,':'"name" TEXT NOT NULL,',Z=z==="sqlite"?"":`,
+
+    CONSTRAINT "${V}_pkey" PRIMARY KEY ("name")`;return[`CREATE TABLE IF NOT EXISTS "${V}" (
+    ${Y}
+    "owner" TEXT NOT NULL,
+    "token" BIGINT NOT NULL DEFAULT 0,
+    "expires_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL${Z}
+)`]}var I="gemi.WorkflowTick",t=262144;function w(z,V){let Y=(Z)=>Z.slice(0,Z.lastIndexOf(":"));return Y(z)===Y(V)}class R extends Error{constructor(z){super(`The tick running workflow ${z} lost its hold on it (another tick took it over after its lease ran out), so its writes were refused.`);this.name="WorkflowLeaseLostError"}}var j0=["completed","failed","cancelled"];class o{db;table;stepTable;constructor(z,V){this.db=z;this.table=V.table,this.stepTable=V.stepTable}joinsTransaction(){return this.db.transaction()!==void 0}create(z){let V=this.db.transaction(),Y=V?this.insertWorkflow(V,z):this.db.atomically((Z)=>this.insertWorkflow(Z,z));if(V)q(Y);return Y}async insertWorkflow(z,V){await this.db.configure();let Y=this.db.now(z);await T(z`
+        INSERT INTO ${this.workflows(z)}
+          (id, name, args, status, progress, retick, created_at, updated_at)
+        VALUES
+          (${V.id}, ${V.name}, ${V.args}, 'running',
+           ${this.db.fraction(z,0)}, 0, ${Y}, ${Y})
+      `,this.table),await this.db.insertJob(z,{name:I,args:JSON.stringify([V.id])})}async find(z,V={}){await this.db.configure();let Y=this.db.sql,[Z]=await T(Y`SELECT * FROM ${this.workflows(Y)} WHERE id = ${z}`,this.table);if(!Z)return null;return{workflow:P0(Z),steps:V.steps===!1?[]:await this.stepsOf(Y,z)}}acquire(z,V,Y){return this.db.atomically(async(Z)=>{let $=await this.lock(Z,z);if(!$)return{kind:"missing"};let X=await this.db.clock(Z);if($.lockedBy!==null&&!w($.lockedBy,V)&&($.lockedUntil??0)>X)return await Z`UPDATE ${this.workflows(Z)} SET retick = 1 WHERE id = ${z}`,{kind:"busy"};let H=X+Math.max(0,Math.round(Y));return await Z`
+        UPDATE ${this.workflows(Z)}
+        SET locked_by = ${V}, locked_until = ${this.db.ms(Z,H)}, retick = 0
+        WHERE id = ${z}
+      `,{kind:"acquired",workflow:{...$,lockedBy:V,lockedUntil:H,retick:!1},steps:await this.stepsOf(Z,z)}})}async renew(z,V,Y){await this.db.configure();let Z=this.db.sql,$=await Z`
+      UPDATE ${this.workflows(Z)}
+      SET locked_until = ${this.db.now(Z)} + ${this.db.ms(Z,Y)}
+      WHERE id = ${z} AND locked_by = ${V}
+    `;return K0($)>0}update(z,V,Y){return this.db.atomically(async(Z)=>{let $=await this.lock(Z,z);if(!$)return;if(V.owner!==void 0&&$.lockedBy!==V.owner)throw new R(z);let X=V.key===void 0?null:await this.stepOf(Z,z,V.key),H=V.allSteps?await this.stepsOf(Z,z):[],G=Y({workflow:$,step:X,steps:H,now:Date.now()});if(G.step){let F=G.step.key===V.key?X!==null:await this.stepOf(Z,z,G.step.key)!==null;await this.writeStep(Z,G.step,F)}if(G.batch)await this.db.insertBatch(Z,G.batch);for(let F of G.cancelBatches??[])await this.db.cancelBatch(Z,F);let Q={...$,...G.workflow},B=G.unlock===!0,K=Z`
+        status = ${Q.status}, current_step = ${Q.currentStep},
+        progress = ${this.db.fraction(Z,Q.progress)}, result = ${Q.result},
+        error = ${Q.error}, wake_at = ${this.db.timeOrNull(Z,Q.wakeAt)},
+        updated_at = ${this.db.now(Z)}
+      `;if(B)await Z`
+          UPDATE ${this.workflows(Z)}
+          SET ${K}, locked_by = NULL, locked_until = NULL, retick = 0
+          WHERE id = ${z}
+        `;else await Z`UPDATE ${this.workflows(Z)} SET ${K} WHERE id = ${z}`;let A=(F)=>this.db.insertJob(Z,{name:I,args:JSON.stringify([z]),delayMs:Math.max(0,Math.round(F))});if(G.tick)await A(G.tick.delayMs);if(B&&$.retick)await A(0);return G.result})}async prune(z){return this.db.atomically(async(V)=>{let Y=V`status IN (${j0.map((X)=>V`${X}`).reduce((X,H)=>V`${X}, ${H}`)})`,Z=V`${this.db.now(V)} - ${this.db.ms(V,z)}`;await V`
+        DELETE FROM ${this.steps(V)}
+        WHERE workflow_id IN (
+          SELECT id FROM ${this.workflows(V)} WHERE ${Y} AND updated_at <= ${Z}
+        )
+      `;let $=await V`
+        DELETE FROM ${this.workflows(V)} WHERE ${Y} AND updated_at <= ${Z}
+      `;return K0($)})}async writeStep(z,V,Y){let Z=this.db,$=this.keyColumn(z);if(Y){await z`
+        UPDATE ${this.steps(z)}
+        SET status = ${V.status}, attempt = ${V.attempt}, output = ${V.output},
+            error = ${V.error}, batch_id = ${V.batchId},
+            wake_at = ${Z.timeOrNull(z,V.wakeAt)},
+            started_at = ${Z.timeOrNull(z,V.startedAt)},
+            finished_at = ${Z.timeOrNull(z,V.finishedAt)}, updated_at = ${Z.now(z)}
+        WHERE workflow_id = ${V.workflowId} AND ${$} = ${V.key}
+      `;return}let X=Z.now(z);await z`
+      INSERT INTO ${this.steps(z)}
+        (workflow_id, ${$}, status, attempt, output, error, batch_id, wake_at,
+         started_at, finished_at, created_at, updated_at)
+      VALUES
+        (${V.workflowId}, ${V.key}, ${V.status}, ${V.attempt}, ${V.output},
+         ${V.error}, ${V.batchId}, ${Z.timeOrNull(z,V.wakeAt)},
+         ${Z.timeOrNull(z,V.startedAt)}, ${Z.timeOrNull(z,V.finishedAt)}, ${X}, ${X})
+    `}async lock(z,V){let Y;if(this.db.dialect==="sqlite")await T(z`UPDATE ${this.workflows(z)} SET updated_at = updated_at WHERE id = ${V}`,this.table),Y=await z`SELECT * FROM ${this.workflows(z)} WHERE id = ${V}`;else Y=await T(z`SELECT * FROM ${this.workflows(z)} WHERE id = ${V} FOR UPDATE`,this.table);return Y[0]?P0(Y[0]):void 0}async stepOf(z,V,Y){let[Z]=await T(z`SELECT * FROM ${this.steps(z)} WHERE workflow_id = ${V} AND ${this.keyColumn(z)} = ${Y}`,this.stepTable);return Z?J0(Z):null}async stepsOf(z,V){return(await T(z`
+        SELECT * FROM ${this.steps(z)} WHERE workflow_id = ${V}
+        ORDER BY created_at, ${this.keyColumn(z)}
+      `,this.stepTable)).map(J0)}workflows(z){return z.unsafe(this.db.quoted(this.table))}steps(z){return z.unsafe(this.db.quoted(this.stepTable))}keyColumn(z){return z.unsafe(this.db.quoted("key"))}}function f(z){return z==null?null:Number(z)}function L(z){return z==null?null:String(z)}function P0(z){return{id:String(z.id),name:String(z.name),args:String(z.args),status:String(z.status),currentStep:L(z.current_step),progress:Number(z.progress??0),result:L(z.result),error:L(z.error),wakeAt:f(z.wake_at),lockedBy:L(z.locked_by),lockedUntil:f(z.locked_until),retick:Number(z.retick??0)!==0,createdAt:Number(z.created_at),updatedAt:Number(z.updated_at)}}function J0(z){return{workflowId:String(z.workflow_id),key:String(z.key),status:String(z.status),attempt:Number(z.attempt??0),output:L(z.output),error:L(z.error),batchId:L(z.batch_id),wakeAt:f(z.wake_at),startedAt:f(z.started_at),finishedAt:f(z.finished_at),createdAt:Number(z.created_at),updatedAt:Number(z.updated_at)}}function K0(z){let V=z;return Math.max(Number(V.count??0),Number(V.affectedRows??0))}function g0(z){let V=String(z?.message??z);return/does not exist|doesn't exist|unknown column|no such (table|column)|has no column/i.test(V)}async function T(z,V){try{return await z}catch(Y){if(!g0(Y))throw Y;throw Error(`Workflows need the "${V}" table, and the database says it is missing. Add the GemiWorkflow and GemiWorkflowStep models from the docs (docs/workflows.md#the-workflow-tables) and migrate, or call the queue driver's createTable().`,{cause:Y})}}function F0(z,V,Y){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${V}\` (
+    \`id\` VARCHAR(191) NOT NULL,
+    \`name\` VARCHAR(191) NOT NULL,
+    \`args\` LONGTEXT NOT NULL,
+    \`status\` VARCHAR(191) NOT NULL,
+    \`current_step\` VARCHAR(191) NULL,
+    \`progress\` DOUBLE NOT NULL DEFAULT 0,
+    \`result\` LONGTEXT NULL,
+    \`error\` LONGTEXT NULL,
+    \`wake_at\` BIGINT NULL,
+    \`locked_by\` VARCHAR(191) NULL,
+    \`locked_until\` BIGINT NULL,
+    \`retick\` INTEGER NOT NULL DEFAULT 0,
+    \`created_at\` BIGINT NOT NULL,
+    \`updated_at\` BIGINT NOT NULL,
+
+    INDEX \`${V}_status_idx\`(\`status\`),
+    PRIMARY KEY (\`id\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`,`CREATE TABLE IF NOT EXISTS \`${Y}\` (
+    \`workflow_id\` VARCHAR(191) NOT NULL,
+    \`key\` VARCHAR(191) NOT NULL,
+    \`status\` VARCHAR(191) NOT NULL,
+    \`attempt\` INTEGER NOT NULL DEFAULT 0,
+    \`output\` LONGTEXT NULL,
+    \`error\` LONGTEXT NULL,
+    \`batch_id\` VARCHAR(191) NULL,
+    \`wake_at\` BIGINT NULL,
+    \`started_at\` BIGINT NULL,
+    \`finished_at\` BIGINT NULL,
+    \`created_at\` BIGINT NOT NULL,
+    \`updated_at\` BIGINT NOT NULL,
+
+    PRIMARY KEY (\`workflow_id\`, \`key\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`];let Z=z==="sqlite";return[`CREATE TABLE IF NOT EXISTS "${V}" (
+    "id" TEXT NOT NULL${Z?" PRIMARY KEY":""},
+    "name" TEXT NOT NULL,
+    "args" TEXT NOT NULL,
+    "status" TEXT NOT NULL,
+    "current_step" TEXT,
+    "progress" ${Z?"REAL":"DOUBLE PRECISION"} NOT NULL DEFAULT 0,
+    "result" TEXT,
+    "error" TEXT,
+    "wake_at" BIGINT,
+    "locked_by" TEXT,
+    "locked_until" BIGINT,
+    "retick" INTEGER NOT NULL DEFAULT 0,
+    "created_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL${Z?"":`,
+
+    CONSTRAINT "${V}_pkey" PRIMARY KEY ("id")`}
+)`,`CREATE TABLE IF NOT EXISTS "${Y}" (
+    "workflow_id" TEXT NOT NULL,
+    "key" TEXT NOT NULL,
+    "status" TEXT NOT NULL,
+    "attempt" INTEGER NOT NULL DEFAULT 0,
+    "output" TEXT,
+    "error" TEXT,
+    "batch_id" TEXT,
+    "wake_at" BIGINT,
+    "started_at" BIGINT,
+    "finished_at" BIGINT,
+    "created_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL,
+
+    ${Z?'PRIMARY KEY ("workflow_id", "key")':`CONSTRAINT "${Y}_pkey" PRIMARY KEY ("workflow_id","key")`}
+)`,`CREATE INDEX IF NOT EXISTS "${V}_status_idx" ON "${V}"("status")`]}function d(z){return{id:z.id,name:z.name,total:z.total,pending:z.total,succeeded:0,failed:0,cancelled:0,failedJobIds:[],cancelledAt:null,finishedAt:null,createdAt:z.now,allowFailures:z.allowFailures,callbacks:z.callbacks}}function c(z,V,Y){if(z.pending<=0)return z;let Z={...z,pending:z.pending-1};if(V==="succeeded")Z.succeeded++;else if(V==="cancelled")Z.cancelled++;else Z.failed++,Z.failedJobIds=[...z.failedJobIds,Y];return Z}function l(z,V){return!V.allowFailures&&V.cancelledAt===null&&V.finishedAt===null&&V.failed>z.failed}function M(z,V,Y){let Z=Math.min(Math.max(0,Y),z.pending);return{...z,cancelledAt:z.cancelledAt??V,pending:z.pending-Z,cancelled:z.cancelled+Z}}function x(z,V,Y){let Z=V,$=[],X=V.callbacks,H=z.failed===0&&z.cancelledAt===null,G=V.failed===0&&V.cancelledAt===null;if(H&&!G&&X.catch)$.push(X.catch);if(V.pending===0&&V.finishedAt===null){if(Z={...V,finishedAt:Y},V.cancelledAt===null&&(V.failed===0||V.allowFailures)&&X.then)$.push(X.then);if(X.finally)$.push(X.finally)}let Q=W(Z);return{record:Z,calls:$.map((B)=>({name:B.name,args:JSON.stringify([...B.args,Q])}))}}function W(z,V=0){let{allowFailures:Y,callbacks:Z,...$}=z,X=z.total-z.pending,H=z.total===0?1:Math.min(1,Math.max(0,(X+Math.max(0,V))/z.total));return{...$,failedJobIds:[...z.failedJobIds],progress:H}}function E(z){if(typeof z!=="number"||!Number.isFinite(z))throw TypeError(`A job's progress is a number from 0 to 1; got ${String(z)}.`);return Math.min(1,Math.max(0,z))}var U0=200,h0="Its batch was cancelled before it ran.";class z0{table;batchTable;workflowTable;workflowStepTable;workflows;sql;dialect;connection;busyTimeout;configured;sqliteTail=Promise.resolve();constructor(z,V={}){let Y=V.table??"gemi_jobs",Z=V.batchTable??(Y==="gemi_jobs"?"gemi_job_batches":`${Y}_batches`),$=Y==="gemi_jobs",X=V.workflowTable??($?"gemi_workflows":`${Y}_workflows`),H=V.workflowStepTable??($?"gemi_workflow_steps":`${Y}_workflow_steps`);for(let Q of[Y,Z,X,H])if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(Q))throw Error(`The queue table name "${Q}" is not a plain identifier. Use letters, digits and underscores.`);let G=V.busyTimeout??1000;if(!Number.isInteger(G)||G<0)throw Error(`The queue's busyTimeout must be a whole number of milliseconds, 0 or more; got ${G}.`);this.table=Y,this.batchTable=Z,this.workflowTable=X,this.workflowStepTable=H,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=G}configure(){if(this.dialect!=="sqlite"||this.busyTimeout===0)return Promise.resolve();return this.configured??=(async()=>{let[z]=await this.sql.unsafe("PRAGMA busy_timeout");if(Number(z?.timeout??0)!==0)return;await this.sql.unsafe(`PRAGMA busy_timeout = ${this.busyTimeout}`)})().catch((z)=>{throw this.configured=void 0,z}),this.configured}async createTable(){await this.configure();let[z,...V]=y0(this.dialect,this.table);if(await this.sql.unsafe(z),!await this.hasBatchColumns())for(let Y of f0(this.dialect,this.table))await this.sql.unsafe(Y);for(let Y of V)await this.sql.unsafe(Y);for(let Y of q0(this.dialect,this.batchTable))await this.sql.unsafe(Y);for(let Y of F0(this.dialect,this.workflowTable,this.workflowStepTable))await this.sql.unsafe(Y)}async hasBatchColumns(){try{return await this.sql.unsafe(`SELECT batch_id, progress FROM ${this.quoted(this.table)} WHERE 1 = 0`),!0}catch(z){if(_0(z))return!1;throw z}}enqueue(z){let V=this.transaction(),Y=this.insert(V??this.sql,z);if(V)q(Y);return Y}async insert(z,{name:V,args:Y,delayMs:Z=0,id:$=Bun.randomUUIDv7()}){await this.configure();let X=this.now(z);return await z`
+      INSERT INTO ${this.name(z)}
+        (id, name, payload, status, attempts, available_at, created_at, updated_at)
+      VALUES
+        (${$}, ${V}, ${Y}, 'pending', 0, ${X} + ${this.ms(z,Z)}, ${X}, ${X})
+    `,$}lockStore(){return new y({sql:this.sql,dialect:this.dialect,name:this.connection},{busyTimeout:this.busyTimeout})}joinsTransaction(){return this.transaction()!==void 0}transaction(){if(this.dialect==="sqlite"||this.connection===void 0)return;let z=N0();if(z===void 0||R0()!==this.connection)return;return z}async claim(z,V){let Y=Math.max(0,Math.floor(z));if(Y===0)return[];return await this.configure(),(this.dialect==="mysql"||this.dialect==="mariadb"?await this.claimLocking(Y,V):await this.claimUpdating(Y,V)).map(($)=>({order:Number($.available_at),job:{id:String($.id),name:String($.name),args:String($.payload),attempt:Number($.attempts),createdAt:Number($.created_at),...$.batch_id==null?{}:{batchId:String($.batch_id)}}})).sort(($,X)=>$.order-X.order||($.job.id<X.job.id?-1:1)).map(({job:$})=>$)}async complete(z){if(z.batchId!==void 0)return this.endBatchJob(z,"succeeded");await this.configure();let V=this.sql;await V`
+      DELETE FROM ${this.name(V)}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async fail(z,V){if(z.batchId!==void 0)return this.endBatchJob(z,"failed",V);await this.configure();let Y=this.sql,Z=this.now(Y);if(V.retryInMs===null){await Y`
+        UPDATE ${this.name(Y)}
+        SET status = 'dead', lease_expires_at = NULL, last_error = ${V.error},
+            updated_at = ${Z}
+        WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+      `;return}await Y`
+      UPDATE ${this.name(Y)}
+      SET status = 'pending', available_at = ${Z} + ${this.ms(Y,V.retryInMs)},
+          lease_expires_at = NULL, last_error = ${V.error}, updated_at = ${Z}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async release(z,V){let Y=this.sql,Z=this.now(Y);await Y`
+      UPDATE ${this.name(Y)}
+      SET status = 'pending', attempts = attempts - 1,
+          available_at = ${Z} + ${this.ms(Y,V.retryInMs)},
+          lease_expires_at = NULL, updated_at = ${Z}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async heartbeat(z,V){await this.configure();let Y=this.sql;await Promise.all(z.map((Z)=>{let $=this.now(Y);return Y`
+          UPDATE ${this.name(Y)}
+          SET lease_expires_at = ${$} + ${this.ms(Y,V.visibilityTimeoutMs)},
+              updated_at = ${$}
+          WHERE id = ${Z.id} AND status = 'claimed' AND attempts = ${Z.attempt}
+        `}))}async retryDead(z){await this.configure();let V=this.sql,[Y]=await V`
+      SELECT * FROM ${this.name(V)} WHERE id = ${z} AND status = 'dead'
+    `;if(!Y||Y.batch_id!=null)return!1;let Z=this.now(V),$=await V`
+      UPDATE ${this.name(V)}
+      SET status = 'pending', attempts = 0, available_at = ${Z}, lease_expires_at = NULL,
+          updated_at = ${Z}
+      WHERE id = ${z} AND status = 'dead'
+    `;return v($)>0}async prune(z){await this.configure();let V=this.sql,Y=await V`
+      DELETE FROM ${this.name(V)}
+      WHERE status = 'dead' AND updated_at <= ${this.now(V)} - ${this.ms(V,z)}
+    `;return v(Y)}enqueueBatch(z){let V=this.transaction(),Y=V?this.insertBatch(V,z):this.atomically((Z)=>this.insertBatch(Z,z));if(V)q(Y);return Y}async insertBatch(z,V){await this.configure();let Y=await this.clock(z),Z=d({...V,total:V.args.length,now:Y}),{record:$,calls:X}=x(Z,Z,Y);await e(z`
+        INSERT INTO ${this.batches(z)}
+          (id, name, total, pending, succeeded, failed, cancelled, failed_job_ids, options,
+           cancelled_at, finished_at, created_at, updated_at)
+        VALUES
+          (${$.id}, ${$.name}, ${$.total}, ${$.pending}, 0, 0, 0,
+           '[]', ${m0($)}, NULL, ${this.timeOrNull(z,$.finishedAt)},
+           ${this.ms(z,Y)}, ${this.ms(z,Y)})
+      `,this.batchTable);let H=this.ms(z,Y);for(let G=0;G<V.args.length;G+=U0){let Q=V.args.slice(G,G+U0).map((B)=>z`(${Bun.randomUUIDv7()}, ${V.job}, ${B}, 'pending', 0, ${H}, ${H}, ${H}, ${V.id}, 0)`).reduce((B,K)=>z`${B}, ${K}`);await e(z`
+          INSERT INTO ${this.name(z)}
+            (id, name, payload, status, attempts, available_at, created_at, updated_at, batch_id, progress)
+          VALUES ${Q}
+        `,this.table)}for(let G of X)await this.insert(z,G)}async findBatch(z,V={}){await this.configure();let Y=this.sql,[Z]=await e(Y`SELECT * FROM ${this.batches(Y)} WHERE id = ${z}`,this.batchTable);if(!Z)return null;let $=A0(Z);if(V.progress===!1||$.pending===0)return W($);let[X]=await Y`
+      SELECT COALESCE(SUM(progress), 0) AS running FROM ${this.name(Y)}
+      WHERE batch_id = ${z} AND status IN ('pending', 'claimed')
+    `;return W($,Number(X?.running??0))}async cancelBatch(z){return this.atomically((V)=>this.cancelBatchOn(V,z))}async cancelBatchOn(z,V){let Y=await this.lockBatch(z,V);if(!Y||Y.finishedAt!==null||Y.cancelledAt!==null)return!1;let Z=await this.clock(z),$=M(Y,Z,await this.cancelWaiting(z,V));return await this.saveBatch(z,Y,$,Z),!0}workflowStore(){return this.workflows??=new o({sql:this.sql,dialect:this.dialect,connection:this.connection,configure:()=>this.configure(),atomically:(z)=>this.atomically(z),transaction:()=>this.transaction(),now:(z)=>this.now(z),ms:(z,V)=>this.ms(z,V),timeOrNull:(z,V)=>this.timeOrNull(z,V),fraction:(z,V)=>this.fraction(z,V),clock:(z)=>this.clock(z),insertJob:(z,V)=>this.insert(z,V),insertBatch:(z,V)=>this.insertBatch(z,V),cancelBatch:(z,V)=>this.cancelBatchOn(z,V),quoted:(z)=>this.quoted(z)},{table:this.workflowTable,stepTable:this.workflowStepTable}),this.workflows}async reportProgress(z,V){let Y=E(V);await this.configure();let Z=this.sql;await Z`
+      UPDATE ${this.name(Z)} SET progress = ${this.fraction(Z,Y)}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async pruneBatches(z){await this.configure();let V=this.sql,Y=await V`
+      DELETE FROM ${this.batches(V)}
+      WHERE finished_at IS NOT NULL AND finished_at <= ${this.now(V)} - ${this.ms(V,z)}
+    `;return v(Y)}endBatchJob(z,V,Y){let Z=z.batchId;return this.atomically(async($)=>{let X=await this.lockBatch($,Z),H=$`id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}`,G=this.now($);if(V==="succeeded"){let K=await $`DELETE FROM ${this.name($)} WHERE ${H}`;if(v(K)===0||!X)return;return this.count($,X,"succeeded",z.id)}let Q=Y.cancelled===!0||Y.retryInMs!==null&&X!==void 0&&X.cancelledAt!==null;if(Y.retryInMs!==null&&!Q){await $`
+          UPDATE ${this.name($)}
+          SET status = 'pending', available_at = ${G} + ${this.ms($,Y.retryInMs)},
+              lease_expires_at = NULL, last_error = ${Y.error}, progress = 0,
+              updated_at = ${G}
+          WHERE ${H}
+        `;return}let B=await $`
+        UPDATE ${this.name($)}
+        SET status = 'dead', lease_expires_at = NULL, last_error = ${Y.error},
+            updated_at = ${G}
+        WHERE ${H}
+      `;if(v(B)===0||!X)return;return this.count($,X,Q?"cancelled":"failed",z.id)})}async count(z,V,Y,Z){let $=await this.clock(z),X=c(V,Y,Z);if(l(V,X))X=M(X,$,await this.cancelWaiting(z,V.id));await this.saveBatch(z,V,X,$)}async cancelWaiting(z,V){let Y=this.now(z),Z=await z`
+      UPDATE ${this.name(z)}
+      SET status = 'dead', last_error = ${h0}, updated_at = ${Y}
+      WHERE batch_id = ${V} AND status = 'pending'
+    `;return v(Z)}async saveBatch(z,V,Y,Z){let{record:$,calls:X}=x(V,Y,Z);await z`
+      UPDATE ${this.batches(z)}
+      SET pending = ${$.pending}, succeeded = ${$.succeeded}, failed = ${$.failed},
+          cancelled = ${$.cancelled}, failed_job_ids = ${JSON.stringify($.failedJobIds)},
+          cancelled_at = ${this.timeOrNull(z,$.cancelledAt)},
+          finished_at = ${this.timeOrNull(z,$.finishedAt)}, updated_at = ${this.ms(z,Z)}
+      WHERE id = ${$.id}
+    `;for(let H of X)await this.insert(z,H)}async lockBatch(z,V){let Y;if(this.dialect==="sqlite")await z`UPDATE ${this.batches(z)} SET updated_at = updated_at WHERE id = ${V}`,Y=await z`SELECT * FROM ${this.batches(z)} WHERE id = ${V}`;else Y=await z`SELECT * FROM ${this.batches(z)} WHERE id = ${V} FOR UPDATE`;return Y[0]?A0(Y[0]):void 0}atomically(z){let V=async()=>{await this.configure();for(let Z=0;;Z++)try{return await this.sql.begin(($)=>z($))}catch($){if(this.dialect!=="sqlite"||Z>=50||!/within a transaction/i.test(String($?.message??$)))throw $;await new Promise((X)=>setTimeout(X,20))}};if(this.dialect!=="sqlite")return V();let Y=this.sqliteTail.then(V,V);return this.sqliteTail=Y.catch(()=>{}),Y}async clock(z){let[V]=await z`SELECT ${this.now(z)} AS now`;return Number(V.now)}timeOrNull(z,V){return V===null?z`NULL`:this.ms(z,V)}fraction(z,V){return this.dialect==="postgres"?z`CAST(${V} AS DOUBLE PRECISION)`:z`${V}`}async claimUpdating(z,V){let Y=this.sql,Z=this.now(Y),$=this.ms(Y,V.visibilityTimeoutMs),X=this.name(Y);if(this.dialect==="postgres")return await Y`
+        WITH next AS (
+          SELECT id FROM ${X}
+          WHERE ${this.claimable(Y,V)}
+          ORDER BY available_at, id
+          LIMIT ${z}
+          FOR UPDATE SKIP LOCKED
+        )
+        UPDATE ${X} AS job
+        SET status = 'claimed', attempts = job.attempts + 1, claimed_at = ${Z},
+            lease_expires_at = ${Z} + ${$}, updated_at = ${Z}
+        FROM next
+        WHERE job.id = next.id
+        RETURNING job.*
+      `;return await Y`
+      UPDATE ${X}
+      SET status = 'claimed', attempts = attempts + 1, claimed_at = ${Z},
+          lease_expires_at = ${Z} + ${$}, updated_at = ${Z}
+      WHERE id IN (
+        SELECT id FROM ${X}
+        WHERE ${this.claimable(Y,V)}
+        ORDER BY available_at, id
+        LIMIT ${z}
+      )
+      RETURNING *
+    `}async claimLocking(z,V){let Y=await this.sql.reserve(),[Z]=await Y`
+      SELECT @@transaction_isolation AS level
+    `;await Y`SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED`;try{return await this.claimLockingOn(Y,z,V)}finally{let $=Z?.level?.replaceAll("-"," ");if($&&/^[A-Z ]+$/.test($))await Y.unsafe(`SET SESSION TRANSACTION ISOLATION LEVEL ${$}`);Y.release()}}async claimLockingOn(z,V,Y){return await z.begin(async(Z)=>{let $=this.name(Z),X=Z.unsafe("*"),H=await Z`
+        SELECT ${X} FROM ${$}
+        WHERE status = 'pending' AND available_at <= ${this.now(Z)}
+          AND ${this.runnable(Z,Y,"available_at")}
+        ORDER BY available_at, id
+        LIMIT ${V}
+        FOR UPDATE SKIP LOCKED
+      `;if(H.length<V){let G=await Z`
+          SELECT ${X} FROM ${$}
+          WHERE status = 'claimed' AND lease_expires_at <= ${this.now(Z)}
+            AND ${this.runnable(Z,Y,"lease_expires_at")}
+          ORDER BY lease_expires_at, id
+          LIMIT ${V-H.length}
+          FOR UPDATE SKIP LOCKED
+        `;H.push(...G)}for(let G of H){let Q=this.now(Z);await Z`
+          UPDATE ${$}
+          SET status = 'claimed', attempts = attempts + 1, claimed_at = ${Q},
+              lease_expires_at = ${Q} + ${this.ms(Z,Y.visibilityTimeoutMs)},
+              updated_at = ${Q}
+          WHERE id = ${G.id}
+        `}return H.map((G)=>({...G,attempts:Number(G.attempts)+1}))})}claimable(z,V){let Y=this.now(z);return z`(
+      (status = 'pending' AND available_at <= ${Y}
+        AND ${this.runnable(z,V,"available_at")})
+      OR (status = 'claimed' AND lease_expires_at <= ${Y}
+        AND ${this.runnable(z,V,"lease_expires_at")})
+    )`}runnable(z,V,Y){let Z=V.registered;if(!Z)return z`1 = 1`;let $=Z.names.length?z`name IN (${Z.names.map((H)=>z`${H}`).reduce((H,G)=>z`${H}, ${G}`)})`:z`1 = 0`;if(!Number.isFinite(Z.graceMs))return $;let X=z.unsafe(Y);return z`(${$} OR ${X} <= ${this.now(z)} - ${this.ms(z,Z.graceMs)})`}name(z){return z.unsafe(this.quoted(this.table))}batches(z){return z.unsafe(this.quoted(this.batchTable))}quoted(z){return this.dialect==="mysql"||this.dialect==="mariadb"?`\`${z}\``:`"${z}"`}now(z){switch(this.dialect){case"postgres":return z`floor(extract(epoch from statement_timestamp()) * 1000)::bigint`;case"mysql":case"mariadb":return z`(TIMESTAMPDIFF(MICROSECOND, '1970-01-01 00:00:00', UTC_TIMESTAMP(6)) DIV 1000)`;case"sqlite":return z`CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)`}}ms(z,V){let Y=Math.max(0,Math.round(V));return this.dialect==="mysql"||this.dialect==="mariadb"?z`CAST(${Y} AS SIGNED)`:z`CAST(${Y} AS BIGINT)`}}function v(z){let V=z;return Math.max(Number(V.count??0),Number(V.affectedRows??0))}function y0(z,V){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${V}\` (
+    \`id\` VARCHAR(191) NOT NULL,
+    \`name\` VARCHAR(191) NOT NULL,
+    \`payload\` LONGTEXT NOT NULL,
+    \`status\` VARCHAR(191) NOT NULL,
+    \`attempts\` INTEGER NOT NULL DEFAULT 0,
+    \`available_at\` BIGINT NOT NULL,
+    \`claimed_at\` BIGINT NULL,
+    \`lease_expires_at\` BIGINT NULL,
+    \`last_error\` LONGTEXT NULL,
+    \`created_at\` BIGINT NOT NULL,
+    \`updated_at\` BIGINT NOT NULL,
+    \`batch_id\` VARCHAR(191) NULL,
+    \`progress\` DOUBLE NULL,
+
+    INDEX \`${V}_status_available_at_idx\`(\`status\`, \`available_at\`),
+    INDEX \`${V}_status_lease_expires_at_idx\`(\`status\`, \`lease_expires_at\`),
+    INDEX \`${V}_batch_id_idx\`(\`batch_id\`),
+    PRIMARY KEY (\`id\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`];let Y=z==="sqlite"?'"id" TEXT NOT NULL PRIMARY KEY,':'"id" TEXT NOT NULL,',Z=z==="sqlite"?"":`,
+
+    CONSTRAINT "${V}_pkey" PRIMARY KEY ("id")`;return[`CREATE TABLE IF NOT EXISTS "${V}" (
+    ${Y}
+    "name" TEXT NOT NULL,
+    "payload" TEXT NOT NULL,
+    "status" TEXT NOT NULL,
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+    "available_at" BIGINT NOT NULL,
+    "claimed_at" BIGINT,
+    "lease_expires_at" BIGINT,
+    "last_error" TEXT,
+    "created_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL,
+    "batch_id" TEXT,
+    "progress" ${z==="sqlite"?"REAL":"DOUBLE PRECISION"}${Z}
+)`,`CREATE INDEX IF NOT EXISTS "${V}_status_available_at_idx" ON "${V}"("status", "available_at")`,`CREATE INDEX IF NOT EXISTS "${V}_status_lease_expires_at_idx" ON "${V}"("status", "lease_expires_at")`,`CREATE INDEX IF NOT EXISTS "${V}_batch_id_idx" ON "${V}"("batch_id")`]}function f0(z,V){if(z==="mysql"||z==="mariadb")return[`ALTER TABLE \`${V}\` ADD COLUMN \`batch_id\` VARCHAR(191) NULL,
+    ADD COLUMN \`progress\` DOUBLE NULL,
+    ADD INDEX \`${V}_batch_id_idx\`(\`batch_id\`)`];let Y=z==="sqlite"?"REAL":"DOUBLE PRECISION";if(z==="sqlite")return[`ALTER TABLE "${V}" ADD COLUMN "batch_id" TEXT`,`ALTER TABLE "${V}" ADD COLUMN "progress" ${Y}`,`CREATE INDEX IF NOT EXISTS "${V}_batch_id_idx" ON "${V}"("batch_id")`];return[`ALTER TABLE "${V}" ADD COLUMN IF NOT EXISTS "batch_id" TEXT,
+ADD COLUMN IF NOT EXISTS "progress" ${Y}`,`CREATE INDEX IF NOT EXISTS "${V}_batch_id_idx" ON "${V}"("batch_id")`]}function q0(z,V){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${V}\` (
+    \`id\` VARCHAR(191) NOT NULL,
+    \`name\` VARCHAR(191) NULL,
+    \`total\` INTEGER NOT NULL,
+    \`pending\` INTEGER NOT NULL,
+    \`succeeded\` INTEGER NOT NULL DEFAULT 0,
+    \`failed\` INTEGER NOT NULL DEFAULT 0,
+    \`cancelled\` INTEGER NOT NULL DEFAULT 0,
+    \`failed_job_ids\` LONGTEXT NOT NULL,
+    \`options\` LONGTEXT NOT NULL,
+    \`cancelled_at\` BIGINT NULL,
+    \`finished_at\` BIGINT NULL,
+    \`created_at\` BIGINT NOT NULL,
+    \`updated_at\` BIGINT NOT NULL,
+
+    PRIMARY KEY (\`id\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`];let Y=z==="sqlite"?'"id" TEXT NOT NULL PRIMARY KEY,':'"id" TEXT NOT NULL,',Z=z==="sqlite"?"":`,
+
+    CONSTRAINT "${V}_pkey" PRIMARY KEY ("id")`;return[`CREATE TABLE IF NOT EXISTS "${V}" (
+    ${Y}
+    "name" TEXT,
+    "total" INTEGER NOT NULL,
+    "pending" INTEGER NOT NULL,
+    "succeeded" INTEGER NOT NULL DEFAULT 0,
+    "failed" INTEGER NOT NULL DEFAULT 0,
+    "cancelled" INTEGER NOT NULL DEFAULT 0,
+    "failed_job_ids" TEXT NOT NULL,
+    "options" TEXT NOT NULL,
+    "cancelled_at" BIGINT,
+    "finished_at" BIGINT,
+    "created_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL${Z}
+)`]}function A0(z){let V=JSON.parse(z.options),Y=(Z)=>Z==null?null:Number(Z);return{id:String(z.id),name:z.name==null?null:String(z.name),total:Number(z.total),pending:Number(z.pending),succeeded:Number(z.succeeded),failed:Number(z.failed),cancelled:Number(z.cancelled),failedJobIds:JSON.parse(z.failed_job_ids),cancelledAt:Y(z.cancelled_at),finishedAt:Y(z.finished_at),createdAt:Number(z.created_at),allowFailures:V.allowFailures===!0,callbacks:V.callbacks??{}}}function m0(z){return JSON.stringify({allowFailures:z.allowFailures,callbacks:z.callbacks})}function _0(z){let V=String(z?.message??z);return/does not exist|doesn't exist|unknown column|no such (table|column)|has no column/i.test(V)}async function e(z,V){try{return await z}catch(Y){if(!_0(Y))throw Y;throw Error(`Job batches need the "${V}" table and the batch_id and progress columns of the jobs table, and the database says one is missing. Add the GemiJobBatch model and the two GemiJob fields from the docs (docs/jobs-and-queues.md#batches) and migrate, or call the driver's createTable().`,{cause:Y})}}import{AsyncResource as c0}from"async_hooks";import{isMainThread as l0}from"worker_threads";function Nz(z){return z}function C0(){return{jobs:[],jobsDir:"app/jobs",workflows:[],workflowsDir:"app/workflows",concurrency:1,driver:"memory",visibilityTimeout:300000,pollInterval:1000,unknownJobGrace:3600000,locks:"auto"}}var b0=86400000;class V0{queue;workflows=new Map;steps=new Map;constructor(z){this.queue=z}async create(z){if(this.workflows.has(z.id))throw Error(`A workflow with the id ${z.id} already exists.`);this.prune(b0);let V=Date.now();this.workflows.set(z.id,{...z,status:"running",currentStep:null,progress:0,result:null,error:null,wakeAt:null,lockedBy:null,lockedUntil:null,retick:!1,createdAt:V,updatedAt:V}),this.steps.set(z.id,new Map),this.tick(z.id,0)}async find(z,V={}){let Y=this.workflows.get(z);if(!Y)return null;return{workflow:{...Y},steps:V.steps===!1?[]:this.stepsOf(z)}}async acquire(z,V,Y){let Z=this.workflows.get(z);if(!Z)return{kind:"missing"};let $=Date.now();if(Z.lockedBy!==null&&!w(Z.lockedBy,V)&&(Z.lockedUntil??0)>$)return Z.retick=!0,{kind:"busy"};return Z.lockedBy=V,Z.lockedUntil=$+Y,Z.retick=!1,{kind:"acquired",workflow:{...Z},steps:this.stepsOf(z)}}async renew(z,V,Y){let Z=this.workflows.get(z);if(!Z||Z.lockedBy!==V)return!1;return Z.lockedUntil=Date.now()+Y,!0}async update(z,V,Y){let Z=this.workflows.get(z);if(!Z)return;if(V.owner!==void 0&&Z.lockedBy!==V.owner)throw new R(z);let $=this.steps.get(z),X=V.key===void 0?void 0:$.get(V.key),H=Date.now(),G=Y({workflow:{...Z},step:X?{...X}:null,steps:V.allSteps?this.stepsOf(z):[],now:H});if(G.step){let Q=$.get(G.step.key);$.set(G.step.key,{...G.step,createdAt:Q?.createdAt??H,updatedAt:H})}if(G.batch)this.queue.enqueueBatch(G.batch);for(let Q of G.cancelBatches??[])this.queue.cancelBatch(Q);if(G.workflow)Object.assign(Z,G.workflow);if(Z.updatedAt=H,G.tick)this.tick(z,G.tick.delayMs);if(G.unlock){if(Z.lockedBy=null,Z.lockedUntil=null,Z.retick)Z.retick=!1,this.tick(z,0)}return G.result}async prune(z){let V=Date.now()-z,Y=0;for(let[Z,$]of this.workflows)if(["completed","failed","cancelled"].includes($.status)&&$.updatedAt<=V)this.workflows.delete(Z),this.steps.delete(Z),Y++;return Y}stepsOf(z){return[...this.steps.get(z)?.values()??[]].map((V)=>({...V}))}tick(z,V){this.queue.enqueue({name:I,args:JSON.stringify([z]),delayMs:Math.max(0,Math.round(V))})}}var u0=86400000;class i{entries=new Map;batches=new Map;workflows;listeners=new Set;timer;timerAt=1/0;seq=0;get waiting(){let z=0;for(let V of this.entries.values())if(!V.leased)z++;return z}get leased(){return this.entries.size-this.waiting}async enqueue(z){let V=this.add(z);return this.changed(),V}add({name:z,args:V,delayMs:Y=0,id:Z=crypto.randomUUID()},$){let X=Date.now();return this.entries.set(Z,{job:{id:Z,name:z,args:V,attempt:0,createdAt:X,...$===void 0?{}:{batchId:$}},until:X+Math.max(0,Y),leased:!1,seq:this.seq++,progress:0}),Z}async enqueueBatch(z){this.recordBatch(z)}recordBatch(z){let V=Date.now();this.forgetFinishedBatches(V);let Y=d({...z,total:z.args.length,now:V});for(let X of z.args)this.add({name:z.job,args:X},z.id);let{record:Z,calls:$}=x(Y,Y,V);this.batches.set(z.id,Z);for(let X of $)this.add(X);this.changed()}async findBatch(z,V={}){let Y=this.batches.get(z);if(!Y)return null;if(V.progress===!1||Y.pending===0)return W(Y);let Z=0;for(let $ of this.entries.values())if($.job.batchId===z)Z+=$.progress;return W(Y,Z)}async cancelBatch(z){return this.cancelBatchNow(z)}cancelBatchNow(z){let V=this.batches.get(z);if(!V||V.finishedAt!==null||V.cancelledAt!==null)return!1;let Y=Date.now(),Z=M(V,Y,this.cancelWaiting(z));return this.save(V,Z,Y),this.changed(),!0}workflowStore(){return this.workflows??=new V0({enqueue:(z)=>{this.add(z),this.changed()},enqueueBatch:(z)=>this.recordBatch(z),cancelBatch:(z)=>void this.cancelBatchNow(z)}),this.workflows}async reportProgress(z,V){let Y=this.current(z);if(Y)Y.progress=E(V)}async claim(z,V){let Y=Date.now(),Z=[...this.entries.values()].filter(($)=>$.until<=Y).sort(($,X)=>$.until-X.until||$.seq-X.seq).slice(0,Math.max(0,z));for(let $ of Z)$.job={...$.job,attempt:$.job.attempt+1},$.leased=!0,$.until=Y+V.visibilityTimeoutMs;if(Z.length>0)this.schedule();return Z.map(($)=>({...$.job}))}async complete(z){let V=this.current(z);if(!V)return;this.entries.delete(z.id),this.count(V,"succeeded"),this.schedule()}async fail(z,V){let Y=this.current(z);if(!Y)return;let Z=Y.job.batchId===void 0?void 0:this.batches.get(Y.job.batchId),$=V.cancelled===!0||V.retryInMs!==null&&Z?.cancelledAt!=null;if(V.retryInMs===null||$){this.entries.delete(z.id),this.count(Y,$?"cancelled":"failed"),this.schedule();return}Y.leased=!1,Y.until=Date.now()+Math.max(0,V.retryInMs),Y.seq=this.seq++,Y.progress=0,this.changed()}async release(z,V){let Y=this.current(z);if(!Y)return;Y.job={...Y.job,attempt:Y.job.attempt-1},Y.leased=!1,Y.until=Date.now()+Math.max(0,V.retryInMs),Y.seq=this.seq++,this.changed()}async heartbeat(z,V){let Y=Date.now()+V.visibilityTimeoutMs;for(let Z of z){let $=this.current(Z);if($)$.until=Y}this.schedule()}count(z,V){let Y=z.job.batchId;if(Y===void 0)return;let Z=this.batches.get(Y);if(!Z)return;let $=Date.now(),X=c(Z,V,z.job.id);if(l(Z,X))X=M(X,$,this.cancelWaiting(Y));this.save(Z,X,$),this.changed()}save(z,V,Y){let{record:Z,calls:$}=x(z,V,Y);this.batches.set(Z.id,Z);for(let X of $)this.add(X)}cancelWaiting(z){let V=0;for(let[Y,Z]of this.entries)if(Z.job.batchId===z&&!Z.leased)this.entries.delete(Y),V++;return V}forgetFinishedBatches(z){for(let[V,Y]of this.batches)if(Y.finishedAt!==null&&z-Y.finishedAt>u0)this.batches.delete(V)}subscribe(z){return this.listeners.add(z),()=>void this.listeners.delete(z)}current(z){let V=this.entries.get(z.id);if(!V||!V.leased||V.job.attempt!==z.attempt)return;return V}changed(){this.schedule();let z=Date.now();for(let V of this.entries.values())if(V.until<=z){this.wake();return}}wake(){for(let z of[...this.listeners])z()}schedule(){let z=Date.now(),V=1/0;for(let Y of this.entries.values())if(Y.until>z&&Y.until<V)V=Y.until;if(V===this.timerAt)return;if(clearTimeout(this.timer),this.timer=void 0,this.timerAt=V,V===1/0)return;this.timer=setTimeout(()=>{this.timer=void 0,this.timerAt=1/0,this.changed()},V-z),this.timer.unref?.()}}function s(z,V){let Y=Array.isArray(z)?z[Math.min(V,z.length)-1]:z;return Math.max(0,Y??0)}var k0={ms:1,s:1000,m:60000,h:3600000,d:86400000,w:604800000};function n(z){if(typeof z==="number"){if(!Number.isFinite(z)||z<0)throw TypeError(`A duration is 0 or more milliseconds; got ${z}.`);return Math.round(z)}let V=/^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)\s*$/.exec(String(z));if(!V)throw TypeError(`"${String(z)}" is not a duration. Use milliseconds, or a number and one of ms, s, m, h, d, w ("30s", "7d").`);return Math.round(Number(V[1])*k0[V[2]])}class I0 extends Error{step;batch;constructor(z,V,Y){super(V);this.step=z;this.batch=Y;this.name="StepFailedError"}}class Y0 extends Error{step;constructor(z){super(`No signal "${z}" arrived before its timeout.`);this.step=z;this.name="WaitTimeoutError"}}class E0 extends Error{constructor(z,V){super(`Step "${z}" took longer than its timeout of ${V}ms.`);this.name="StepTimeoutError"}}class O0 extends Error{constructor(z){super(`Workflow ${z} was cancelled.`);this.name="WorkflowCancelledError"}}class g extends Error{constructor(){super("The workflow is suspended until a step can continue. Rethrow this error if you catch it.");this.name="WorkflowSuspended"}}var D0=Symbol("done");class Z0{tick;workflowId;steps;seen=new Set;pending=new Set;suspension;lost=!1;cancelled=!1;current=null;constructor(z){this.tick=z;this.workflowId=z.workflowId,this.steps=new Map(z.steps.map((V)=>[V.key,V]))}run(z,V,Y={}){return this.track(z,()=>this.runStep(z,V,Y))}sleep(z,V){let Y=n(V);return this.track(z,()=>this.sleepStep(z,Y))}waitFor(z,V={}){let Y=V.timeout===void 0?void 0:n(V.timeout);return this.track(z,()=>this.waitStep(z,Y))}batch(z,V,Y,Z={}){return this.track(z,()=>this.batchStep(z,V,Y,Z))}async progress(z){let V=E(z);this.assertRunning();let Y=this.write(void 0,()=>({result:void 0,workflow:{progress:V}}));this.remember(Y),await Y}async settled(){while(this.pending.size>0)await Promise.allSettled(this.pending)}track(z,V){if(typeof z!=="string"||z.length===0||z.length>191)throw TypeError(`A step key is a string of 1 to 191 characters; got ${JSON.stringify(z)}.`);if(this.seen.has(z))throw Error(`Two steps of workflow ${this.workflowId} use the key "${z}". Each step needs a key of its own, or the second would return the first one's result.`);this.seen.add(z),this.assertRunning();let Y=V();return this.remember(Y),Y}remember(z){this.pending.add(z);let V=()=>void this.pending.delete(z);z.then(V,V)}assertRunning(){if(this.lost)throw new R(this.workflowId);if(this.suspension)throw new g}suspend(z,V){if(!this.suspension)this.suspension={status:z,wakes:[]};if(V!=null)this.suspension.wakes.push(V);throw new g}async write(z,V){let Y;try{Y=await this.tick.store.update(this.tick.workflowId,{owner:this.tick.owner,...z===void 0?{}:{key:z}},(Z)=>{if(Z.workflow.status==="cancelling"&&!this.tick.cancelling)return{result:D0};let $=V(Z);return{...$,result:{value:$.result}}})}catch(Z){if(Z instanceof R)this.lost=!0;throw Z}if(Y===void 0)throw this.lost=!0,new R(this.tick.workflowId);if(Y===D0)this.cancelled=!0,this.suspend("waiting");return Y.value}record(z,V,Y){let Z={workflowId:this.tick.workflowId,key:z,status:"running",attempt:0,output:null,error:null,batchId:null,wakeAt:null,startedAt:null,finishedAt:null,createdAt:0,updatedAt:0,...V,...Y};return this.steps.set(z,Z),Z}mismatch(z,V,Y){throw Error(`Step "${z}" of workflow ${this.tick.workflowId} was recorded as a ${V} step, and is now used as ${Y}. A key belongs to one step; rename one of them.`)}async runStep(z,V,Y){let Z=Math.max(1,Math.floor(Y.attempts??3)),$=Y.timeout===void 0?void 0:n(Y.timeout),X=this.steps.get(z);if(X?.status==="completed")return _(X.output);if(X?.status==="failed")throw j(z,X);if(X?.status==="retrying"&&X.wakeAt!==null&&X.wakeAt>Date.now())this.current=z,this.suspend("sleeping",X.wakeAt);for(;;){let H=await this.write(z,({workflow:J,step:P,now:N})=>{if(P?.status==="completed")return{result:{kind:"done",output:P.output}};if(P?.status==="failed")return{result:{kind:"failed",step:P}};if(P&&P.status!=="running"&&P.status!=="retrying")this.mismatch(z,P.status,"step.run");if(P?.status==="retrying"&&P.wakeAt!==null&&P.wakeAt>N)return{result:{kind:"wait",wakeAt:P.wakeAt}};let D=(P?.attempt??0)+1;if(D>Z){let G0=this.record(z,P,{status:"failed",error:`Attempt ${D-1} of ${Z} never finished, most likely because the process running it exited.`+(P?.error?` The last error was: ${P.error}`:""),finishedAt:N,wakeAt:null});return{result:{kind:"failed",step:G0},step:G0}}let u=this.record(z,P,{status:"running",attempt:D,startedAt:N,finishedAt:null,wakeAt:null});return{result:{kind:"run",attempt:D},step:u,workflow:J.status==="cancelling"?{currentStep:z}:{currentStep:z,status:"running"}}});if(this.current=z,H.kind==="done")return _(H.output);if(H.kind==="failed")throw j(z,H.step);if(H.kind==="wait")this.suspend("sleeping",H.wakeAt);let G=H.attempt,Q,B,K=!0;try{Q=await this.execute(z,V,G,$)}catch(J){B=J}if(this.cancelled)throw new g;let A=null;if(B===void 0)try{A=m(Q,`The result of step "${z}"`)}catch(J){B=J,K=!1}if(B===void 0)return await this.write(z,({step:J,now:P})=>({result:void 0,step:this.record(z,J,{status:"completed",output:A,error:null,wakeAt:null,finishedAt:P})})),_(A);let F=a(B);if(K&&G<Z){let J=s(Y.backoff??0,G),P=await this.write(z,({step:N,now:D})=>{let u=J>0?D+J:null;return{result:u,step:this.record(z,N,{status:"retrying",error:F,wakeAt:u})}});if(P!==null)this.suspend("sleeping",P);continue}let U=await this.write(z,({step:J,now:P})=>{let N=this.record(z,J,{status:"failed",error:F,wakeAt:null,finishedAt:P});return{result:N,step:N}});throw j(z,U)}}async execute(z,V,Y,Z){let $=new AbortController,X={idempotencyKey:`${this.tick.workflowId}:${z}`,attempt:Y,signal:$.signal},H=Promise.resolve().then(()=>V(X)),G,Q,B=new Promise((K,A)=>{let F=(U)=>{$.abort(U),A(U)};if(Z!==void 0)G=setTimeout(()=>F(new E0(z,Z)),Z);if(!this.tick.cancelling)Q=setInterval(()=>{this.tick.store.find(this.tick.workflowId,{steps:!1}).then((U)=>{if(U?.workflow.status!=="cancelling"||$.signal.aborted)return;if(this.cancelled=!0,!this.suspension)this.suspension={status:"waiting",wakes:[]};F(new O0(this.tick.workflowId))}).catch(()=>{})},this.tick.cancelCheckMs),Q.unref?.()});try{return await Promise.race([H,B])}finally{clearTimeout(G),clearInterval(Q),H.catch(()=>{}),B.catch(()=>{})}}async sleepStep(z,V){let Y=this.steps.get(z);if(Y?.status==="completed")return;if(this.current=z,Y?.status==="sleeping"&&Y.wakeAt!==null&&Y.wakeAt>Date.now())this.suspend("sleeping",Y.wakeAt);let Z=await this.write(z,({step:$,now:X})=>{if($?.status==="completed")return{result:null};if($&&$.status!=="sleeping")this.mismatch(z,$.status,"step.sleep");let H=$?.wakeAt??X+V;if(H<=X)return{result:null,step:this.record(z,$,{status:"completed",wakeAt:H,startedAt:$?.startedAt??X,finishedAt:X})};if($)return{result:H};return{result:H,step:this.record(z,null,{status:"sleeping",wakeAt:H,startedAt:X}),workflow:{currentStep:z}}});if(Z!==null)this.suspend("sleeping",Z)}async waitStep(z,V){let Y=this.steps.get(z);if(Y?.status==="completed")return _(Y.output);if(Y?.status==="timed_out")throw new Y0(z);if(this.current=z,Y?.status==="waiting"&&(Y.wakeAt===null||Y.wakeAt>Date.now()))this.suspend("waiting",Y.wakeAt);let Z=await this.write(z,({step:$,now:X})=>{if($?.status==="completed")return{result:{kind:"value",output:$.output}};if($?.status==="timed_out")return{result:{kind:"timeout"}};if($?.status==="signalled")return{result:{kind:"value",output:$.output},step:this.record(z,$,{status:"completed",wakeAt:null,startedAt:$.startedAt??X,finishedAt:X})};if($&&$.status!=="waiting")this.mismatch(z,$.status,"step.waitFor");if($){if($.wakeAt!==null&&$.wakeAt<=X)return{result:{kind:"timeout"},step:this.record(z,$,{status:"timed_out",finishedAt:X})};return{result:{kind:"wait",wakeAt:$.wakeAt}}}let H=V===void 0?null:X+V;return{result:{kind:"wait",wakeAt:H},step:this.record(z,null,{status:"waiting",wakeAt:H,startedAt:X}),workflow:{currentStep:z}}});if(Z.kind==="value")return _(Z.output);if(Z.kind==="timeout")throw new Y0(z);this.suspend("waiting",Z.wakeAt)}async batchStep(z,V,Y,Z){let $=Z.allowFailures===!0,X=this.steps.get(z);if(X?.status==="completed")return _(X.output);if(X?.status==="failed")throw j(z,X);if(X&&X.status!=="batching")this.mismatch(z,X.status,"step.batch");if(this.current=z,!X){let A=this.tick.buildBatch(V,Y,{name:Z.name??`workflow:${this.tick.workflowId}:${z}`,allowFailures:$});if(X=await this.write(z,({step:F,now:U})=>{if(F)return{result:F};let J=this.record(z,null,{status:"batching",batchId:A.id,startedAt:U});return{result:J,step:J,batch:A,workflow:{currentStep:z}}}),this.tick.scheduled(),X.status==="completed")return _(X.output);if(X.status==="failed")throw j(z,X)}let H=X.batchId===null?null:await this.tick.findBatch(X.batchId);if(H&&H.finishedAt===null)this.suspend("waiting");let G=H!==null&&H.cancelledAt===null&&(H.failed===0||$),Q=H===null?null:JSON.stringify(H),B=G?null:H===null?`The batch of step "${z}" (${X.batchId}) no longer exists.`:`The batch of step "${z}" failed: ${H.failed} failed and ${H.cancelled} cancelled of ${H.total}.`,K=await this.write(z,({step:A,now:F})=>{let U=this.record(z,A,{status:G?"completed":"failed",output:Q,error:B,finishedAt:F});return{result:U,step:U}});if(!G)throw j(z,K);return H}}function j(z,V){let Y=V.batchId!==null&&V.output!==null?JSON.parse(V.output):void 0;return new I0(z,Y?V.error??`Step "${z}" failed.`:`Step "${z}" failed: ${V.error??"unknown error"}`,Y)}function m(z,V){if(z===void 0)return null;let Y=JSON.stringify(z);if(Y===void 0)throw TypeError(`${V} cannot be stored: JSON has no form for it.`);let Z=Buffer.byteLength(Y,"utf8");if(Z>t)throw RangeError(`${V} is ${Z} bytes as JSON, over the ${t}-byte limit. Store it elsewhere and return its id.`);return Y}function _(z){return z===null?void 0:JSON.parse(z)}function a(z){return z instanceof Error?z.message:String(z)}var r=["completed","failed","cancelled"],p0=1000;class $0{queue;registry={};storeInstance;tickClass;reportedNames=new Set;constructor(z){this.queue=z}get workflows(){return this.registry}use(z){this.registry={};for(let V of z){if(V.name==="unset"||!V.name){console.error("A workflow class has no `static name`, so it was not registered. Add one.");continue}if(this.registry[V.name]){console.error(`Two workflows are named "${V.name}" \u2014 the first is registered `+"and this one is not. A workflow's name is its key in storage. Rename one.");continue}this.registry[V.name]=V}}get tickJob(){return this.tickClass??=w0(this),this.tickClass}get store(){if(!this.storeInstance){let z=this.queue.driver.workflowStore?.();if(!z||!this.queue.driver.enqueueBatch)throw Error("This queue's driver does not support workflows. The memory and database drivers do.");this.storeInstance=z}return this.storeInstance}start(z,V){if(z.name==="unset"||!z.name)throw Error("Cannot start a workflow with no name");let Y=this.store,Z={id:Bun.randomUUIDv7(),name:z.name,args:m(V,`The arguments of ${z.name}`)??"[]"},$=()=>this.queue.claimSoon(),X=Y.joinsTransaction?.()===!0;if(!X){if(C(()=>Y.create(Z).then($,(B)=>{console.error(`[gemi] The queue could not record the workflow ${z.name}, which was held until its transaction committed. The transaction stays committed; the workflow did not start.`,B)})))return Promise.resolve(Z.id)}let H=Y.create(Z),G=X&&C($);return H.then(()=>{if(!G)$();return Z.id})}async signal(z,V,Y){if(typeof V!=="string"||V.length===0||V.length>191)throw TypeError("A signal key is a string of 1 to 191 characters.");let Z=m(Y,`The payload of signal "${V}"`),$=await this.store.update(z,{key:V},({workflow:X,step:H,now:G})=>{if(r.includes(X.status)||X.status==="cancelling")return{result:!1};if(!H)return{result:!0,step:{workflowId:z,key:V,status:"signalled",attempt:0,output:Z,error:null,batchId:null,wakeAt:null,startedAt:null,finishedAt:G,createdAt:G,updatedAt:G}};if(H.status!=="waiting")return{result:!1};return{result:!0,step:{...H,status:"signalled",output:Z,wakeAt:H.wakeAt,finishedAt:G},tick:{delayMs:0}}});if($)this.queue.claimSoon();return $===!0}async cancel(z){let V=await this.store.update(z,{allSteps:!0},({workflow:Y,steps:Z})=>{if(r.includes(Y.status)||Y.status==="cancelling")return{result:!1};return{result:!0,workflow:{status:"cancelling"},cancelBatches:Z.filter(($)=>$.status==="batching"&&$.batchId!==null).map(($)=>$.batchId),tick:{delayMs:0}}});if(V)this.queue.claimSoon();return V===!0}async find(z){let V=await this.store.find(z);if(!V)return null;let{workflow:Y,steps:Z}=V,$=[];try{$=JSON.parse(Y.args)}catch{}return{id:Y.id,name:Y.name,status:Y.status,args:$,currentStep:Y.currentStep,progress:Y.progress,result:d0(Y.result),error:Y.error,steps:await Promise.all(Z.map(async(X)=>{let H={key:X.key,status:X.status,attempt:X.attempt,error:X.error,batchId:X.batchId,wakeAt:X.wakeAt,startedAt:X.startedAt,finishedAt:X.finishedAt};if(X.batchId===null)return H;let G=await this.queue.driver.findBatch?.(X.batchId);return G?{...H,progress:G.progress}:H})),createdAt:Y.createdAt,updatedAt:Y.updatedAt}}async tick(z,V){let Y=this.store,Z=V.$claimed,$=Z?`${Z.id}:${Z.attempt}`:`${crypto.randomUUID()}:1`,X=Math.max(1,this.queue.config.visibilityTimeout),H=await Y.acquire(z,$,X);if(H.kind!=="acquired")return;let{workflow:G}=H,Q=(J={})=>Y.update(z,{owner:$},()=>({...J,result:void 0,unlock:!0})).then(()=>this.queue.claimSoon()).catch((P)=>{if(!(P instanceof R))throw P});if(r.includes(G.status))return Q();let B=this.registry[G.name];if(!B)return this.unknown(G,V,Q);let K;try{K=JSON.parse(G.args)}catch(J){return Q({workflow:{status:"failed",error:`The arguments are not JSON: ${a(J)}`}})}let A=setInterval(()=>{Y.renew(z,$,X).catch((J)=>{console.error(`[gemi] Could not extend the hold on workflow ${z}.`,J)})},Math.max(1,Math.floor(X/3)));A.unref?.();let F=G.status==="cancelling",U=new Z0({workflowId:z,owner:$,store:Y,steps:H.steps,cancelling:F,findBatch:(J)=>this.queue.driver.findBatch?.(J,{progress:!1})??Promise.resolve(null),buildBatch:(J,P,N)=>this.queue.buildBatch(J,P.map((D)=>JSON.stringify(D)),{name:N.name,allowFailures:N.allowFailures,finally:{name:I,args:[z]}}),scheduled:()=>this.queue.claimSoon(),cancelCheckMs:p0});try{let J;try{let P=new B,N=await(F?P.onCancel(U,...K):P.run(U,...K));J=U.suspension?{kind:"suspended"}:{kind:"completed",result:F?null:m(N,`The result of ${G.name}`)}}catch(P){if(J=U.suspension||P instanceof g?{kind:"suspended"}:{kind:"failed",error:a(P)},P instanceof R)U.lost=!0}if(await U.settled(),U.lost)return;if(J.kind==="completed"&&U.suspension)J={kind:"suspended"};await Y.update(z,{owner:$},({workflow:P,now:N})=>this.finish(P,J,U,F,N)),this.queue.claimSoon()}catch(J){if(J instanceof R)return;throw J}finally{clearInterval(A)}}finish(z,V,Y,Z,$){let X={result:void 0,unlock:!0};if(z.status==="cancelling"&&!Z)return{...X,tick:{delayMs:0}};if(V.kind==="completed")return{...X,workflow:Z?{status:"cancelled",currentStep:null,wakeAt:null}:{status:"completed",result:V.result,progress:1,currentStep:null,wakeAt:null,error:null}};if(V.kind==="failed")return{...X,workflow:{status:Z?"cancelled":"failed",error:V.error,wakeAt:null}};let H=Y.suspension??{status:"waiting",wakes:[]},G={...X,workflow:{status:Z?"cancelling":H.status,currentStep:Y.current??z.currentStep}};if(H.wakes.length>0){let Q=Math.min(...H.wakes);if(!(z.wakeAt!==null&&z.wakeAt>$&&z.wakeAt<=Q))G.tick={delayMs:Math.max(0,Q-$)},G.workflow.wakeAt=Q}return G}async unknown(z,V,Y){let Z=Date.now()-z.createdAt;if(this.queue.durable&&Z<this.queue.config.unknownJobGrace){if(!this.reportedNames.has(z.name))this.reportedNames.add(z.name),console.error(`Left workflow "${z.name}" for another replica: nothing is registered here under that name.`);await Y(),V.release(Math.round(this.queue.config.pollInterval*(1+Math.random())));return}console.error(`Failed workflow ${z.id}: nothing is registered under the name "${z.name}". If the class exists, it was not discovered: check that it is under the queue slice's workflowsDir (app/workflows by default), or list it in app/config/queue.ts.`),await Y({workflow:{status:"failed",error:`No workflow is registered under the name "${z.name}".`}})}tickDeadLettered(z,V){console.error(`[gemi] The tick of workflow ${z} was dead-lettered.`,V),this.store.update(z,{},({workflow:Y})=>r.includes(Y.status)?{result:void 0}:{result:void 0,workflow:{status:"failed",error:`Its tick job was dead-lettered: ${V.message}`},unlock:!0}).catch(()=>{})}}function w0(z){return class extends S{static name=I;maxAttempts=20;backoff=[1000,5000,15000,30000,60000];async run(Y){await z.tick(Y,this)}onDeadletter(Y,Z){z.tickDeadLettered(Z,Y)}}}function d0(z){try{return _(z)}catch{return z}}function i0(){let z=process.env.APP_DIR,V=process.env.ROOT_DIR,Y=Bun.env.NODE_ENV==="production"?`${V}/dist/server/bootstrap.mjs`:`${z}/bootstrap.ts`,Z=new File([`
+      import { app } from "${Y}"
+      self.onmessage = async (event) => {
+        const clone = app.clone()
+        let result = null;
+        let error = null;
+        try {
+          result = await clone.dispatchJob(event.data.jobName, event.data.args)
+        } catch (err) {
+          error = err
+        }
+        clone.destroy()
+        if(error) {
+          self.postMessage({error});
+        } else {
+          self.postMessage({result});
+        }
+      };
+    `],"worker.ts"),$=URL.createObjectURL(Z);return new Worker($)}async function s0(z,V){let Y=i0();return Y.postMessage({jobName:z,args:V}),await new Promise((Z,$)=>{Y.onmessage=(X)=>{let H=X.data;if("error"in H)$(H.error);else Z(H.result)}})}var n0=new c0("gemi.queue"),a0=60000;class h{static token="queue";jobs={};config;driver;application;inFlight=new Map;state="idle";looping=!1;claiming;woken=!1;claimFailures=0;resume;unsubscribe;heartbeatTimer;releasedNames=new Set;lockManager;workflowRuntime;constructor(z={},V={}){if(this.config=S0(C0(),z),this.application=V.application,this.driver=zz(this.config.driver,this.application),this.useJobs(this.config.jobs),this.config.workflows.length>0)this.useWorkflows(this.config.workflows)}useJobs(z){this.config.jobs=z,this.jobs={};for(let V of z)this.claim(V);this.registerTickJob()}useWorkflows(z){this.config.workflows=z,this.workflows.use(z),this.registerTickJob()}get registeredWorkflows(){return[...this.config.workflows]}get workflows(){return this.workflowRuntime??=new $0(this),this.workflowRuntime}registerTickJob(){if(!this.workflowRuntime||Object.keys(this.workflowRuntime.workflows).length===0)return;let z=this.workflowRuntime.tickJob;if(this.jobs[z.name]&&this.jobs[z.name]!==z){console.error(`A queued job is named "${z.name}", which the workflow runtime uses. Workflows will not run until it is renamed.`);return}this.jobs[z.name]=z}registerJob(z){this.config.jobs=[...this.config.jobs,z],this.claim(z)}claim(z){if(this.jobs[z.name]){console.error(`Two queued jobs are named "${z.name}" \u2014 the first is registered `+"and this one is not, so dispatching either would have run one of them. A class name is the queue's key, so only one job can hold it. Rename one.");return}this.jobs[z.name]=z}get registeredJobs(){return[...this.config.jobs]}dispatchJob(z,V){if(this.jobs[z])return new this.jobs[z]().run(JSON.parse(V))}push(z,V,Y={}){let Z=this.uniqueKey(z,V);if(Z)return this.pushUnique(z,V,Z,Y);let $=this.driver.joinsTransaction?.()===!0;if(!$){let X=Bun.randomUUIDv7();if(C(()=>this.record(z,V,{id:X,reportFailure:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve(X)}return this.record(z,V,{reportFailure:Y.reportFailure,joins:$})}pushBatch(z,V,Y={}){let Z=this.buildBatch(z,V,Y),$={id:Z.id,total:V.length},X=this.driver.joinsTransaction?.()===!0;if(!X){if(C(()=>this.recordBatch(Z,{committed:!0}).then(()=>{},()=>{})))return Promise.resolve($)}return this.recordBatch(Z,{joins:X}).then(()=>$)}buildBatch(z,V,Y={}){if(!this.driver.enqueueBatch)throw Error("This queue's driver does not support batches. The memory and database drivers do.");if(new z().worker)throw Error(`${z.name} is a worker job, and a worker job cannot be dispatched in a batch: its thread has no way to report progress or reach the batch.`);if(z.prototype.uniqueId!==S.prototype.uniqueId)throw Error(`${z.name} is unique (it defines uniqueId), and a unique job cannot be dispatched in a batch: a duplicate would resolve to a job outside the batch, and the batch would wait for it forever.`);let $={};for(let X of["then","catch","finally"]){let H=Y[X];if(H===void 0)continue;if(typeof H?.name!=="string"||!Array.isArray(H.args))throw Error(`The batch's ${X} callback is not a job call. Build it with SomeJob.with(...args).`);$[X]={name:H.name,args:H.args}}return{id:Bun.randomUUIDv7(),name:Y.name??null,job:z.name,args:V,allowFailures:Y.allowFailures===!0,callbacks:$}}recordBatch(z,V){let Y=this.driver.enqueueBatch(z);this.startIfIdle();let Z=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),$=V.joins===!0&&C(Z);return Y.then(()=>$||Z(),(X)=>{if(!V.committed)return;console.error(`[gemi] The queue driver could not record a batch of ${z.job}, which was held until its transaction committed. The transaction stays committed; the batch's jobs did not run and will not be retried.`,X)}),Y}async findBatch(z){if(!this.driver.findBatch)throw Error("This queue's driver does not support batches.");return this.driver.findBatch(z)}async cancelBatch(z){if(!this.driver.cancelBatch)throw Error("This queue's driver does not support batches.");let V=await this.driver.cancelBatch(z);if(V)this.claimSoon();return V}get locks(){return this.lockManager??=new T0(this.resolveLockStore()),this.lockManager}resolveLockStore(){let z=this.config.locks;if(z==="auto"){let V=this.driver.lockStore?.();if(V)return V;if(this.durable)console.warn('[gemi] The queue driver keeps no locks, so unique jobs, withoutOverlapping and onOneServer only hold within this process. Set the queue slice\'s `locks` to "database" or a LockStore.');return new p}if(z==="memory")return new p;if(z==="database"||typeof z==="function"){if(!this.application&&(z==="database"||z.length>0))throw Error("The queue's locks need the application they belong to, and this QueueManager was built without one. Pass { application }.");if(z==="database")return new y(this.application.make(H0));return z(this.application)}if(typeof z==="string")throw Error(`Unknown queue locks "${z}". The queue slice's locks is "auto", "memory", "database", a LockStore, or a function returning one.`);return z}uniqueKey(z,V){if(z.prototype.uniqueId===S.prototype.uniqueId)return;let Y=new z,Z=Y.uniqueId(...JSON.parse(V));if(Z===void 0||Z===null||Z==="")return;return{key:L0(z.name,Z),ttl:Math.max(1,Y.uniqueFor)}}pushUnique(z,V,Y,Z){let $=Bun.randomUUIDv7();if(C(()=>this.recordUnique(z,V,Y,$,{report:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve($);return this.recordUnique(z,V,Y,$,{report:Z.reportFailure!==!1,committed:!1})}recordUnique(z,V,Y,Z,$){let X=this.locks.store,H=(async()=>{for(let G=0;G<5;G++){if(await X.acquire(Y.key,Z,Y.ttl)!==null)try{return await this.record(z,V,{id:Z,reportFailure:!1})}catch(B){throw await X.release(Y.key,Z).catch(()=>{}),B}let Q=await X.holder(Y.key);if(Q)return Q.owner}throw Error(`The unique key "${Y.key}" kept changing hands, so ${z.name} was not queued.`)})();return H.catch((G)=>{if(!$.report)return;console.error(`[gemi] The queue could not record the unique job ${z.name}`+($.committed?", which was held until its transaction committed. The transaction stays committed; the job did not run and will not be retried.":", so it did not run and will not be retried."),G)}),H}async releaseUnique(z,V,Y){if(z.uniqueId===S.prototype.uniqueId)return;try{let Z=z.uniqueId(...V);if(Z===void 0||Z===null||Z==="")return;await this.locks.store.release(L0(Y.name,Z),Y.id)}catch(Z){console.error(`[gemi] Could not free the unique key of ${Y.name} (${Y.id}); it frees itself after uniqueFor.`,Z)}}record(z,V,Y){let Z=this.driver.enqueue({name:z.name,args:V,...Y.id===void 0?{}:{id:Y.id}});this.startIfIdle();let $=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),X=Y.joins===!0&&C($);return Z.then(()=>X||$(),(H)=>{if(Y.reportFailure===!1)return;console.error(`[gemi] The queue driver could not record ${z.name}`+(Y.committed?", which was held until its transaction committed. The transaction stays committed; the job did not run and will not be retried.":", so it did not run and will not be retried."),H)}),Z}async retryDead(z){if(!this.driver.retryDead)throw Error("This queue's driver keeps nothing of a dead-lettered job, so there is nothing to retry. The database driver keeps them.");let V=await this.driver.retryDead(z);if(V)this.claimSoon();return V}startIfIdle(){if(this.state==="idle"&&(!this.durable||this.mayClaimHere()))this.start()}claimSoon(){if(this.startIfIdle(),!this.driver.subscribe&&this.state==="running")this.wake()}start(){if(this.state==="running")return;if(this.state="running",this.durable&&this.application&&this.mayClaimHere()&&!r0())globalThis.__gemiDevQueue=this;if(this.unsubscribe=this.driver.subscribe?.(()=>this.wake()),this.looping)return this.wake();n0.runInAsyncScope(()=>void this.loop())}async drain(z=1/0){if(this.state="stopped",globalThis.__gemiDevQueue===this)globalThis.__gemiDevQueue=void 0;this.unsubscribe?.(),this.unsubscribe=void 0,this.wake();let V,Y=new Promise(($)=>{if(z!==1/0)V=setTimeout($,z)}),Z=(async()=>{await this.claiming?.catch(()=>{}),await Promise.allSettled([...this.inFlight.values()].map(($)=>$.done))})();return await Promise.race([Z,Y]),clearTimeout(V),{unfinished:[...this.inFlight.values()].map(($)=>({...$.job}))}}stop(){return this.drain(0)}get running(){return this.inFlight.size}async loop(){this.looping=!0;try{await this.claimWhileRunning()}finally{this.looping=!1}}async claimWhileRunning(){while(this.state==="running"){let z=this.durable&&M0()?0:this.config.concurrency-this.inFlight.size;if(z>0){this.woken=!1;let V=this.driver.claim(z,{...this.lease(),registered:{names:Object.keys(this.jobs),graceMs:this.config.unknownJobGrace}});this.claiming=V;let Y=[];try{Y=await V,this.claimFailures=0}catch(Z){this.claimFailures++,console.error(`The queue could not claim jobs from its driver; it will try again in ${this.retryDelay()}ms.`,Z)}finally{this.claiming=void 0}for(let Z of Y)this.execute(Z);if(Y.length===z)continue;if(this.woken&&this.inFlight.size<this.config.concurrency)continue}await this.sleep()}}sleep(){return new Promise((z)=>{let V,Y=this.claimFailures>0?this.retryDelay():this.driver.subscribe?void 0:this.config.pollInterval;if(Y!==void 0)V=setTimeout(()=>this.wake(),Y),V.unref?.();this.resume=()=>{clearTimeout(V),z()}})}retryDelay(){let z=Math.min(Math.max(0,this.claimFailures-1),30);return Math.min(this.config.pollInterval*2**z,a0)}wake(){this.woken=!0;let z=this.resume;this.resume=void 0,z?.()}get durable(){return!(this.driver instanceof i)}mayClaimHere(){return!this.application||t0()}lease(){return{visibilityTimeoutMs:this.config.visibilityTimeout}}execute(z){let V=`${z.id}:${z.attempt}`,Y=()=>this.run(z),Z=(this.application?W0.run(this.application,Y):Y()).catch(($)=>{console.error(`The queue could not record the outcome of ${z.name}.`,$)}).finally(()=>{this.inFlight.delete(V),this.wake()});this.inFlight.set(V,{job:z,done:Z}),this.heartbeat()}heartbeat(){let z=this.driver;if(!z.heartbeat||this.heartbeatTimer)return;this.heartbeatTimer=setInterval(()=>{if(this.inFlight.size===0){clearInterval(this.heartbeatTimer),this.heartbeatTimer=void 0;return}let V=[...this.inFlight.values()].map((Y)=>Y.job);z.heartbeat(V,this.lease()).catch((Y)=>{console.error("The queue could not extend its job leases.",Y)})},Math.max(1,Math.floor(this.config.visibilityTimeout/3))),this.heartbeatTimer.unref?.()}async run(z){let V=this.jobs[z.name];if(!V){let B=Date.now()-z.createdAt;if(this.durable&&B<this.config.unknownJobGrace){if(!this.releasedNames.has(z.name))this.releasedNames.add(z.name),console.error(`Left a queued "${z.name}" for another replica: nothing is registered here under that name. It is dead-lettered if no replica has run it within unknownJobGrace (${this.config.unknownJobGrace}ms) of its dispatch.`);await this.driver.release(z,{retryInMs:Math.round(this.config.pollInterval*(1+Math.random()))});return}console.error(`Dropped a queued job: nothing is registered under the name "${z.name}". If the class exists, it was not `+"discovered \u2014 check that it is under the queue slice's jobsDir "+"(app/jobs by default), or list it in app/config/queue.ts."),await this.driver.fail(z,{error:`No job is registered under the name "${z.name}".`,retryInMs:null});return}let Y;try{Y=new V}catch(B){console.error(`Dropped a queued ${z.name}: it could not be constructed.`,B),await this.driver.fail(z,{error:`The job could not be constructed: ${String(B)}`,retryInMs:null});return}let Z;try{Z=JSON.parse(z.args)}catch(B){console.error(`Dropped a queued ${z.name}: its arguments are not JSON.`,B),await this.driver.fail(z,{error:`The arguments are not JSON: ${String(B)}`,retryInMs:null});return}if(z.attempt>Math.max(1,Y.maxAttempts)){let B=Error(`${z.name} was claimed for attempt ${z.attempt} of ${Y.maxAttempts}: an earlier attempt never finished, most likely because the process running it exited. Dead-lettered without running it again.`);X0(`${z.name}.onDeadletter`,()=>Y.onDeadletter(B,...Z)),await this.driver.fail(z,{error:B.message,retryInMs:null}),await this.releaseUnique(Y,Z,z);return}if(Y.$claimed={...z},z.batchId!==void 0){if((await this.driver.findBatch?.(z.batchId,{progress:!1}))?.cancelledAt!=null){await this.driver.fail(z,{error:"Its batch was cancelled before it ran.",retryInMs:null,cancelled:!0});return}let K=this.batchHandle(z);Y.batch=K.batch,Y.$progress=K.progress}let $=await this.admit(Y,Z,z);if(!$)return;let X,H;try{H=await(Y.worker?s0(z.name,z.args):Y.run(...Z))}catch(B){X=B}finally{await $.done()}let G=Y.$outcome;if(X===void 0&&G?.kind==="release"){await this.driver.release(z,{retryInMs:Math.max(0,G.delayMs)});return}if(X===void 0&&G?.kind==="fail")X=G.error;let Q=G?.kind==="fail"?G.retry:!0;if(X===void 0)try{Y.onSuccess(H,...Z)}catch(B){X=B}if(X!==void 0){let B=String(X?.stack??X);if(X0(`${z.name}.onFail`,()=>Y.onFail(X,...Z)),!Q||z.attempt>=Y.maxAttempts)X0(`${z.name}.onDeadletter`,()=>Y.onDeadletter(X,...Z)),await this.driver.fail(z,{error:B,retryInMs:null}),await this.releaseUnique(Y,Z,z);else await this.driver.fail(z,{error:B,retryInMs:s(Y.backoff,z.attempt)});return}await this.driver.complete(z),await this.releaseUnique(Y,Z,z)}batchHandle(z){let V=z.batchId,Y=this.driver;return{batch:{id:V,cancelled:async()=>(await Y.findBatch?.(V,{progress:!1}))?.cancelledAt!=null},progress:(Z)=>Y.reportProgress?.(z,Z)??Promise.resolve()}}async admit(z,V,Y){let Z=z.concurrency(...V),$=[z.throttle(...V)??[]].flat();if(!Z&&$.length===0)return{done:async()=>{}};let X=this.locks,H;if(Z&&Z.limit>0){let Q=this.config.visibilityTimeout;for(let B=0;B<Z.limit&&!H;B++)H=await X.acquire(`gemi:concurrency:${Z.key}:${B}`,{ttl:Q,renew:!0})??void 0;if(!H){await this.driver.release(Y,{retryInMs:Math.round(this.config.pollInterval*(1+Math.random()))});return}}let G=[];for(let Q of $){let B=`gemi:throttle:${Q.key}`,K=await X.store.hit(B,Q.limit,Q.window);if(!K.allowed){await Promise.all(G.map((A)=>X.store.refund(A))),await H?.release(),await this.driver.release(Y,{retryInMs:Math.max(1,K.resetInMs)});return}G.push(B)}return{done:async()=>{await H?.release().catch((Q)=>{console.error(`[gemi] Could not free a concurrency slot of ${Y.name}.`,Q)})}}}}function L0(z,V){return`gemi:job:${z}:${String(V)}`}function X0(z,V){try{V()}catch(Y){console.error(`${z} threw; the job's claim was ended anyway.`,Y)}}function r0(){return Bun.env.NODE_ENV==="production"}function t0(){if(!l0)return!1;if(e0())return!0;return process.env.ROOT_DIR!==void 0&&!o0()}function o0(z=process.env){return(z.GEMI_QUEUE_CLAIM??"").trim().toLowerCase()==="off"}var x0=Symbol.for("gemi.queue.worker");function tz(z=!0){globalThis[x0]=z}function e0(){return globalThis[x0]===!0}function zz(z,V){if(z==="memory")return new i;if(z==="database"||typeof z==="function"){if(!V&&(z==="database"||z.length>0))throw Error("The queue driver needs the application it belongs to, and this QueueManager was built without one. Pass { application }.");if(z==="database")return new z0(V.make(H0));return z(V)}if(typeof z==="string")throw Error(`Unknown queue driver "${z}". The queue slice's driver is "memory", "database", a QueueDriver, or a function returning one.`);return z}class S{static name="unset";worker=!1;maxAttempts=3;backoff=0;uniqueId(...z){return}uniqueFor=3600000;throttle(...z){return}concurrency(...z){return}release(z=0){this.$outcome={kind:"release",delayMs:z}}fail(z,V={}){this.$outcome={kind:"fail",error:z instanceof Error?z:Error(String(z)),retry:V.retry??!0}}batch=void 0;async progress(z){let V=E(z);await this.$progress?.(V)}$progress;$claimed;$outcome;run(...z){}onFail(z,...V){}onSuccess(z,...V){}onDeadletter(z,...V){}static dispatch(...z){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return b(h).push(this,JSON.stringify(z))}static dispatchBatch(z,V={}){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return b(h).pushBatch(this,z.map((Y)=>JSON.stringify(Y)),V)}static with(...z){if(this.name==="unset")throw Error("Cannot use a job with no name as a callback");return JSON.stringify(z),{name:this.name,args:z}}static findBatch(z){return b(h).findBatch(z)}static cancelBatch(z){return b(h).cancelBatch(z)}}
+export{p as Bc,y as Cc,o as Dc,F0 as Ec,z0 as Fc,S as Gc,Nz as Hc,C0 as Ic,V0 as Jc,i as Kc,I0 as Lc,Y0 as Mc,E0 as Nc,O0 as Oc,Z0 as Pc,$0 as Qc,h as Rc,t0 as Sc,o0 as Tc,tz as Uc,e0 as Vc};
+
+//# debugId=C7F8EB97FE1A446664756E2164756E21