gemi 0.116.0 → 0.117.0

package/dist/chunk-y0en07zh.js

@@ -0,0 +1,302 @@
+// @bun
+import{Bh as s,zh as L}from"./chunk-jpetnpzn.js";import{Ch as d}from"./chunk-dz99g58c.js";import{Eh as p,Fh as w,Gh as v,Ih as _,Kh as x,Th as k}from"./chunk-t65074mw.js";import{gi as f}from"./chunk-5w6kyxsj.js";import{Di as b,Gi as O}from"./chunk-076jezzg.js";import{Ji as l}from"./chunk-a32wfzdq.js";class D{entries=new Map;counters=new Map;async acquire(z,G,V){let Y=Date.now(),Z=this.entries.get(z);if(Z&&(Z.expiresAt>Y||Z.fences>0))return null;let $=(Z?.token??0)+1;return this.entries.set(z,{owner:G,token:$,expiresAt:Y+Math.max(0,V),fences:0}),$}async extend(z,G,V,Y){let Z=this.current(z,G,V);if(!Z)return!1;return Z.expiresAt=Date.now()+Math.max(0,Y),!0}async release(z,G,V){let Y=this.current(z,G,V);if(!Y)return!1;return Y.owner="",Y.expiresAt=0,!0}async holder(z){let G=this.entries.get(z);if(!G||G.expiresAt<=Date.now())return null;return{owner:G.owner,token:G.token}}async held(z,G,V){return this.current(z,G,V)!==void 0}async advance(z,G){if((this.counters.get(z)??-1/0)>=G)return!1;return this.counters.set(z,G),!0}async fence(z,G,V,Y){let Z=this.current(z,G,V);if(!Z)throw new L(z,V);Z.fences++;try{return await Y()}finally{Z.fences--}}windows=new Map;async hit(z,G,V){let Y=Date.now(),Z=this.windows.get(z);if(!Z||Z.endsAt<=Y)Z={count:0,endsAt:Y+Math.max(1,V)},this.windows.set(z,Z);if(Z.count>=G)return{allowed:!1,resetInMs:Z.endsAt-Y};return Z.count++,{allowed:!0,resetInMs:Z.endsAt-Y}}async refund(z){let G=this.windows.get(z);if(G&&G.endsAt>Date.now()&&G.count>0)G.count--}current(z,G,V){let Y=this.entries.get(z);if(!Y||Y.owner!==G||Y.expiresAt<=Date.now())return;if(V!==void 0&&Y.token!==V)return;return Y}}class N{table;sql;dialect;connection;busyTimeout;configured;constructor(z,G={}){let V=G.table??"gemi_locks";if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(V))throw Error(`The lock table name "${V}" is not a plain identifier. Use letters, digits and underscores.`);this.table=V,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=G.busyTimeout??1000}async createTable(){await this.configure();for(let z of n(this.dialect,this.table))await this.sql.unsafe(z)}async acquire(z,G,V){await this.configure();let Y=this.sql,Z=this.now(Y);if(await this.seed(Y,z),this.mysql){let X=await Y`
+        UPDATE ${this.name(Y)}
+        SET owner = ${G}, token = token + 1, expires_at = ${Z} + ${this.ms(Y,V)},
+            updated_at = ${Z}
+        WHERE name = ${z} AND expires_at <= ${Z}
+      `;if(W(X)===0)return null;let[F]=await Y`
+        SELECT token FROM ${this.name(Y)} WHERE name = ${z} AND owner = ${G}
+      `;return F?Number(F.token):null}let $=await Y`
+      UPDATE ${this.name(Y)}
+      SET owner = ${G}, token = token + 1, expires_at = ${Z} + ${this.ms(Y,V)},
+          updated_at = ${Z}
+      WHERE name = ${z} AND expires_at <= ${Z}
+      RETURNING token
+    `;return $[0]?Number($[0].token):null}async extend(z,G,V,Y){await this.configure();let Z=this.sql,$=this.now(Z),X=await Z`
+      UPDATE ${this.name(Z)}
+      SET expires_at = ${$} + ${this.ms(Z,Y)}, updated_at = ${$}
+      WHERE name = ${z} AND owner = ${G} AND token = ${V} AND expires_at > ${$}
+    `;if(W(X)>0)return!0;return this.mysql?this.held(z,G,V):!1}async release(z,G,V){await this.configure();let Y=this.sql,Z=this.now(Y),$=V===void 0?Y`1 = 1`:Y`token = ${V}`,X=await Y`
+      UPDATE ${this.name(Y)}
+      SET owner = '', expires_at = 0, updated_at = ${Z}
+      WHERE name = ${z} AND owner = ${G} AND ${$} AND expires_at > ${Z}
+    `;return W(X)>0}async holder(z){await this.configure();let G=this.sql,[V]=await G`
+      SELECT owner, token FROM ${this.name(G)}
+      WHERE name = ${z} AND expires_at > ${this.now(G)}
+    `;return V?{owner:String(V.owner),token:Number(V.token)}:null}async held(z,G,V){await this.configure();let Y=this.sql;return(await Y`
+      SELECT 1 AS held FROM ${this.name(Y)}
+      WHERE name = ${z} AND owner = ${G} AND token = ${V} AND expires_at > ${this.now(Y)}
+    `).length>0}async advance(z,G){await this.configure();let V=this.sql;await this.seed(V,z);let Y=await V`
+      UPDATE ${this.name(V)}
+      SET token = ${this.int(V,G)}, updated_at = ${this.now(V)}
+      WHERE name = ${z} AND token < ${this.int(V,G)}
+    `;return W(Y)>0}async fence(z,G,V,Y){await this.configure();let Z=async(X)=>{let F=this.now(X),H;if(this.dialect==="sqlite"){let K=await X`
+          UPDATE ${this.name(X)} SET updated_at = ${F}
+          WHERE name = ${z} AND owner = ${G} AND token = ${V} AND expires_at > ${F}
+        `;H=W(K)>0}else H=(await X`
+          SELECT 1 AS held FROM ${this.name(X)}
+          WHERE name = ${z} AND owner = ${G} AND token = ${V} AND expires_at > ${F}
+          FOR UPDATE
+        `).length>0;if(!H)throw new L(z,V);return Y()},$=this.connection;if($===void 0)return await this.sql.begin((X)=>Z(X));return k(this.sql,(X)=>v($,()=>Z(X)),{connection:$})}async hit(z,G,V){await this.configure();let Y=this.sql,Z=this.now(Y);await this.seed(Y,z);let $=this.ms(Y,Math.max(1,V)),X=await Y`
+      UPDATE ${this.name(Y)}
+      SET token = CASE WHEN expires_at <= ${Z} THEN 1 ELSE token + 1 END,
+          expires_at = CASE WHEN expires_at <= ${Z} THEN ${Z} + ${$} ELSE expires_at END,
+          updated_at = ${Z}
+      WHERE name = ${z} AND (expires_at <= ${Z} OR token < ${this.int(Y,G)})
+    `,F=W(X)>0,[H]=await Y`
+      SELECT expires_at - ${Z} AS reset FROM ${this.name(Y)} WHERE name = ${z}
+    `;return{allowed:F,resetInMs:Math.max(0,Number(H?.reset??0))}}async refund(z){await this.configure();let G=this.sql,V=this.now(G);await G`
+      UPDATE ${this.name(G)} SET token = token - 1, updated_at = ${V}
+      WHERE name = ${z} AND token > 0 AND expires_at > ${V}
+    `}async prune(z){await this.configure();let G=this.sql,V=this.now(G),Y=await G`
+      DELETE FROM ${this.name(G)}
+      WHERE expires_at <= ${V} AND updated_at <= ${V} - ${this.ms(G,z)}
+    `;return W(Y)}async seed(z,G){let V=this.now(z);if(this.mysql){await z`
+        INSERT IGNORE INTO ${this.name(z)} (name, owner, token, expires_at, updated_at)
+        VALUES (${G}, '', 0, 0, ${V})
+      `;return}await z`
+      INSERT INTO ${this.name(z)} (name, owner, token, expires_at, updated_at)
+      VALUES (${G}, '', 0, 0, ${V})
+      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,G){return this.int(z,Math.max(0,Math.round(G)))}int(z,G){let V=Math.round(G);return this.mysql?z`CAST(${V} AS SIGNED)`:z`CAST(${V} AS BIGINT)`}}function W(z){let G=z;return Math.max(Number(G.count??0),Number(G.affectedRows??0))}function n(z,G){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${G}\` (
+    \`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 V=z==="sqlite"?'"name" TEXT NOT NULL PRIMARY KEY,':'"name" TEXT NOT NULL,',Y=z==="sqlite"?"":`,
+
+    CONSTRAINT "${G}_pkey" PRIMARY KEY ("name")`;return[`CREATE TABLE IF NOT EXISTS "${G}" (
+    ${V}
+    "owner" TEXT NOT NULL,
+    "token" BIGINT NOT NULL DEFAULT 0,
+    "expires_at" BIGINT NOT NULL,
+    "updated_at" BIGINT NOT NULL${Y}
+)`]}function C(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 I(z,G,V){if(z.pending<=0)return z;let Y={...z,pending:z.pending-1};if(G==="succeeded")Y.succeeded++;else if(G==="cancelled")Y.cancelled++;else Y.failed++,Y.failedJobIds=[...z.failedJobIds,V];return Y}function S(z,G){return!G.allowFailures&&G.cancelledAt===null&&G.finishedAt===null&&G.failed>z.failed}function B(z,G,V){let Y=Math.min(Math.max(0,V),z.pending);return{...z,cancelledAt:z.cancelledAt??G,pending:z.pending-Y,cancelled:z.cancelled+Y}}function P(z,G,V){let Y=G,Z=[],$=G.callbacks,X=z.failed===0&&z.cancelledAt===null,F=G.failed===0&&G.cancelledAt===null;if(X&&!F&&$.catch)Z.push($.catch);if(G.pending===0&&G.finishedAt===null){if(Y={...G,finishedAt:V},G.cancelledAt===null&&(G.failed===0||G.allowFailures)&&$.then)Z.push($.then);if($.finally)Z.push($.finally)}let H=A(Y);return{record:Y,calls:Z.map((K)=>({name:K.name,args:JSON.stringify([...K.args,H])}))}}function A(z,G=0){let{allowFailures:V,callbacks:Y,...Z}=z,$=z.total-z.pending,X=z.total===0?1:Math.min(1,Math.max(0,($+Math.max(0,G))/z.total));return{...Z,failedJobIds:[...z.failedJobIds],progress:X}}function U(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 h=200,a="Its batch was cancelled before it ran.";class y{table;batchTable;sql;dialect;connection;busyTimeout;configured;sqliteTail=Promise.resolve();constructor(z,G={}){let V=G.table??"gemi_jobs",Y=G.batchTable??(V==="gemi_jobs"?"gemi_job_batches":`${V}_batches`);for(let $ of[V,Y])if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test($))throw Error(`The queue table name "${$}" is not a plain identifier. Use letters, digits and underscores.`);let Z=G.busyTimeout??1000;if(!Number.isInteger(Z)||Z<0)throw Error(`The queue's busyTimeout must be a whole number of milliseconds, 0 or more; got ${Z}.`);this.table=V,this.batchTable=Y,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=Z}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,...G]=r(this.dialect,this.table);if(await this.sql.unsafe(z),!await this.hasBatchColumns())for(let V of t(this.dialect,this.table))await this.sql.unsafe(V);for(let V of G)await this.sql.unsafe(V);for(let V of o(this.dialect,this.batchTable))await this.sql.unsafe(V)}async hasBatchColumns(){try{return await this.sql.unsafe(`SELECT batch_id, progress FROM ${this.quoted(this.table)} WHERE 1 = 0`),!0}catch(z){if(u(z))return!1;throw z}}enqueue(z){let G=this.transaction(),V=this.insert(G??this.sql,z);if(G)x(V);return V}async insert(z,{name:G,args:V,delayMs:Y=0,id:Z=Bun.randomUUIDv7()}){await this.configure();let $=this.now(z);return await z`
+      INSERT INTO ${this.name(z)}
+        (id, name, payload, status, attempts, available_at, created_at, updated_at)
+      VALUES
+        (${Z}, ${G}, ${V}, 'pending', 0, ${$} + ${this.ms(z,Y)}, ${$}, ${$})
+    `,Z}lockStore(){return new N({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=p();if(z===void 0||w()!==this.connection)return;return z}async claim(z,G){let V=Math.max(0,Math.floor(z));if(V===0)return[];return await this.configure(),(this.dialect==="mysql"||this.dialect==="mariadb"?await this.claimLocking(V,G):await this.claimUpdating(V,G)).map((Z)=>({order:Number(Z.available_at),job:{id:String(Z.id),name:String(Z.name),args:String(Z.payload),attempt:Number(Z.attempts),createdAt:Number(Z.created_at),...Z.batch_id==null?{}:{batchId:String(Z.batch_id)}}})).sort((Z,$)=>Z.order-$.order||(Z.job.id<$.job.id?-1:1)).map(({job:Z})=>Z)}async complete(z){if(z.batchId!==void 0)return this.endBatchJob(z,"succeeded");await this.configure();let G=this.sql;await G`
+      DELETE FROM ${this.name(G)}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async fail(z,G){if(z.batchId!==void 0)return this.endBatchJob(z,"failed",G);await this.configure();let V=this.sql,Y=this.now(V);if(G.retryInMs===null){await V`
+        UPDATE ${this.name(V)}
+        SET status = 'dead', lease_expires_at = NULL, last_error = ${G.error},
+            updated_at = ${Y}
+        WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+      `;return}await V`
+      UPDATE ${this.name(V)}
+      SET status = 'pending', available_at = ${Y} + ${this.ms(V,G.retryInMs)},
+          lease_expires_at = NULL, last_error = ${G.error}, updated_at = ${Y}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async release(z,G){let V=this.sql,Y=this.now(V);await V`
+      UPDATE ${this.name(V)}
+      SET status = 'pending', attempts = attempts - 1,
+          available_at = ${Y} + ${this.ms(V,G.retryInMs)},
+          lease_expires_at = NULL, updated_at = ${Y}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async heartbeat(z,G){await this.configure();let V=this.sql;await Promise.all(z.map((Y)=>{let Z=this.now(V);return V`
+          UPDATE ${this.name(V)}
+          SET lease_expires_at = ${Z} + ${this.ms(V,G.visibilityTimeoutMs)},
+              updated_at = ${Z}
+          WHERE id = ${Y.id} AND status = 'claimed' AND attempts = ${Y.attempt}
+        `}))}async retryDead(z){await this.configure();let G=this.sql,[V]=await G`
+      SELECT * FROM ${this.name(G)} WHERE id = ${z} AND status = 'dead'
+    `;if(!V||V.batch_id!=null)return!1;let Y=this.now(G),Z=await G`
+      UPDATE ${this.name(G)}
+      SET status = 'pending', attempts = 0, available_at = ${Y}, lease_expires_at = NULL,
+          updated_at = ${Y}
+      WHERE id = ${z} AND status = 'dead'
+    `;return Q(Z)>0}async prune(z){await this.configure();let G=this.sql,V=await G`
+      DELETE FROM ${this.name(G)}
+      WHERE status = 'dead' AND updated_at <= ${this.now(G)} - ${this.ms(G,z)}
+    `;return Q(V)}enqueueBatch(z){let G=this.transaction(),V=G?this.insertBatch(G,z):this.atomically((Y)=>this.insertBatch(Y,z));if(G)x(V);return V}async insertBatch(z,G){await this.configure();let V=await this.clock(z),Y=C({...G,total:G.args.length,now:V}),{record:Z,calls:$}=P(Y,Y,V);await M(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
+          (${Z.id}, ${Z.name}, ${Z.total}, ${Z.pending}, 0, 0, 0,
+           '[]', ${e(Z)}, NULL, ${this.timeOrNull(z,Z.finishedAt)},
+           ${this.ms(z,V)}, ${this.ms(z,V)})
+      `,this.batchTable);let X=this.ms(z,V);for(let F=0;F<G.args.length;F+=h){let H=G.args.slice(F,F+h).map((K)=>z`(${Bun.randomUUIDv7()}, ${G.job}, ${K}, 'pending', 0, ${X}, ${X}, ${X}, ${G.id}, 0)`).reduce((K,J)=>z`${K}, ${J}`);await M(z`
+          INSERT INTO ${this.name(z)}
+            (id, name, payload, status, attempts, available_at, created_at, updated_at, batch_id, progress)
+          VALUES ${H}
+        `,this.table)}for(let F of $)await this.insert(z,F)}async findBatch(z,G={}){await this.configure();let V=this.sql,[Y]=await M(V`SELECT * FROM ${this.batches(V)} WHERE id = ${z}`,this.batchTable);if(!Y)return null;let Z=j(Y);if(G.progress===!1||Z.pending===0)return A(Z);let[$]=await V`
+      SELECT COALESCE(SUM(progress), 0) AS running FROM ${this.name(V)}
+      WHERE batch_id = ${z} AND status IN ('pending', 'claimed')
+    `;return A(Z,Number($?.running??0))}async cancelBatch(z){return this.atomically(async(G)=>{let V=await this.lockBatch(G,z);if(!V||V.finishedAt!==null||V.cancelledAt!==null)return!1;let Y=await this.clock(G),Z=B(V,Y,await this.cancelWaiting(G,z));return await this.saveBatch(G,V,Z,Y),!0})}async reportProgress(z,G){let V=U(G);await this.configure();let Y=this.sql;await Y`
+      UPDATE ${this.name(Y)} SET progress = ${this.fraction(Y,V)}
+      WHERE id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}
+    `}async pruneBatches(z){await this.configure();let G=this.sql,V=await G`
+      DELETE FROM ${this.batches(G)}
+      WHERE finished_at IS NOT NULL AND finished_at <= ${this.now(G)} - ${this.ms(G,z)}
+    `;return Q(V)}endBatchJob(z,G,V){let Y=z.batchId;return this.atomically(async(Z)=>{let $=await this.lockBatch(Z,Y),X=Z`id = ${z.id} AND status = 'claimed' AND attempts = ${z.attempt}`,F=this.now(Z);if(G==="succeeded"){let J=await Z`DELETE FROM ${this.name(Z)} WHERE ${X}`;if(Q(J)===0||!$)return;return this.count(Z,$,"succeeded",z.id)}let H=V.cancelled===!0||V.retryInMs!==null&&$!==void 0&&$.cancelledAt!==null;if(V.retryInMs!==null&&!H){await Z`
+          UPDATE ${this.name(Z)}
+          SET status = 'pending', available_at = ${F} + ${this.ms(Z,V.retryInMs)},
+              lease_expires_at = NULL, last_error = ${V.error}, progress = 0,
+              updated_at = ${F}
+          WHERE ${X}
+        `;return}let K=await Z`
+        UPDATE ${this.name(Z)}
+        SET status = 'dead', lease_expires_at = NULL, last_error = ${V.error},
+            updated_at = ${F}
+        WHERE ${X}
+      `;if(Q(K)===0||!$)return;return this.count(Z,$,H?"cancelled":"failed",z.id)})}async count(z,G,V,Y){let Z=await this.clock(z),$=I(G,V,Y);if(S(G,$))$=B($,Z,await this.cancelWaiting(z,G.id));await this.saveBatch(z,G,$,Z)}async cancelWaiting(z,G){let V=this.now(z),Y=await z`
+      UPDATE ${this.name(z)}
+      SET status = 'dead', last_error = ${a}, updated_at = ${V}
+      WHERE batch_id = ${G} AND status = 'pending'
+    `;return Q(Y)}async saveBatch(z,G,V,Y){let{record:Z,calls:$}=P(G,V,Y);await z`
+      UPDATE ${this.batches(z)}
+      SET pending = ${Z.pending}, succeeded = ${Z.succeeded}, failed = ${Z.failed},
+          cancelled = ${Z.cancelled}, failed_job_ids = ${JSON.stringify(Z.failedJobIds)},
+          cancelled_at = ${this.timeOrNull(z,Z.cancelledAt)},
+          finished_at = ${this.timeOrNull(z,Z.finishedAt)}, updated_at = ${this.ms(z,Y)}
+      WHERE id = ${Z.id}
+    `;for(let X of $)await this.insert(z,X)}async lockBatch(z,G){let V;if(this.dialect==="sqlite")await z`UPDATE ${this.batches(z)} SET updated_at = updated_at WHERE id = ${G}`,V=await z`SELECT * FROM ${this.batches(z)} WHERE id = ${G}`;else V=await z`SELECT * FROM ${this.batches(z)} WHERE id = ${G} FOR UPDATE`;return V[0]?j(V[0]):void 0}atomically(z){let G=async()=>{await this.configure();for(let Y=0;;Y++)try{return await this.sql.begin((Z)=>z(Z))}catch(Z){if(this.dialect!=="sqlite"||Y>=50||!/within a transaction/i.test(String(Z?.message??Z)))throw Z;await new Promise(($)=>setTimeout($,20))}};if(this.dialect!=="sqlite")return G();let V=this.sqliteTail.then(G,G);return this.sqliteTail=V.catch(()=>{}),V}async clock(z){let[G]=await z`SELECT ${this.now(z)} AS now`;return Number(G.now)}timeOrNull(z,G){return G===null?z`NULL`:this.ms(z,G)}fraction(z,G){return this.dialect==="postgres"?z`CAST(${G} AS DOUBLE PRECISION)`:z`${G}`}async claimUpdating(z,G){let V=this.sql,Y=this.now(V),Z=this.ms(V,G.visibilityTimeoutMs),$=this.name(V);if(this.dialect==="postgres")return await V`
+        WITH next AS (
+          SELECT id FROM ${$}
+          WHERE ${this.claimable(V,G)}
+          ORDER BY available_at, id
+          LIMIT ${z}
+          FOR UPDATE SKIP LOCKED
+        )
+        UPDATE ${$} AS job
+        SET status = 'claimed', attempts = job.attempts + 1, claimed_at = ${Y},
+            lease_expires_at = ${Y} + ${Z}, updated_at = ${Y}
+        FROM next
+        WHERE job.id = next.id
+        RETURNING job.*
+      `;return await V`
+      UPDATE ${$}
+      SET status = 'claimed', attempts = attempts + 1, claimed_at = ${Y},
+          lease_expires_at = ${Y} + ${Z}, updated_at = ${Y}
+      WHERE id IN (
+        SELECT id FROM ${$}
+        WHERE ${this.claimable(V,G)}
+        ORDER BY available_at, id
+        LIMIT ${z}
+      )
+      RETURNING *
+    `}async claimLocking(z,G){let V=await this.sql.reserve(),[Y]=await V`
+      SELECT @@transaction_isolation AS level
+    `;await V`SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED`;try{return await this.claimLockingOn(V,z,G)}finally{let Z=Y?.level?.replaceAll("-"," ");if(Z&&/^[A-Z ]+$/.test(Z))await V.unsafe(`SET SESSION TRANSACTION ISOLATION LEVEL ${Z}`);V.release()}}async claimLockingOn(z,G,V){return await z.begin(async(Y)=>{let Z=this.name(Y),$=Y.unsafe("*"),X=await Y`
+        SELECT ${$} FROM ${Z}
+        WHERE status = 'pending' AND available_at <= ${this.now(Y)}
+          AND ${this.runnable(Y,V,"available_at")}
+        ORDER BY available_at, id
+        LIMIT ${G}
+        FOR UPDATE SKIP LOCKED
+      `;if(X.length<G){let F=await Y`
+          SELECT ${$} FROM ${Z}
+          WHERE status = 'claimed' AND lease_expires_at <= ${this.now(Y)}
+            AND ${this.runnable(Y,V,"lease_expires_at")}
+          ORDER BY lease_expires_at, id
+          LIMIT ${G-X.length}
+          FOR UPDATE SKIP LOCKED
+        `;X.push(...F)}for(let F of X){let H=this.now(Y);await Y`
+          UPDATE ${Z}
+          SET status = 'claimed', attempts = attempts + 1, claimed_at = ${H},
+              lease_expires_at = ${H} + ${this.ms(Y,V.visibilityTimeoutMs)},
+              updated_at = ${H}
+          WHERE id = ${F.id}
+        `}return X.map((F)=>({...F,attempts:Number(F.attempts)+1}))})}claimable(z,G){let V=this.now(z);return z`(
+      (status = 'pending' AND available_at <= ${V}
+        AND ${this.runnable(z,G,"available_at")})
+      OR (status = 'claimed' AND lease_expires_at <= ${V}
+        AND ${this.runnable(z,G,"lease_expires_at")})
+    )`}runnable(z,G,V){let Y=G.registered;if(!Y)return z`1 = 1`;let Z=Y.names.length?z`name IN (${Y.names.map((X)=>z`${X}`).reduce((X,F)=>z`${X}, ${F}`)})`:z`1 = 0`;if(!Number.isFinite(Y.graceMs))return Z;let $=z.unsafe(V);return z`(${Z} OR ${$} <= ${this.now(z)} - ${this.ms(z,Y.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,G){let V=Math.max(0,Math.round(G));return this.dialect==="mysql"||this.dialect==="mariadb"?z`CAST(${V} AS SIGNED)`:z`CAST(${V} AS BIGINT)`}}function Q(z){let G=z;return Math.max(Number(G.count??0),Number(G.affectedRows??0))}function r(z,G){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${G}\` (
+    \`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 \`${G}_status_available_at_idx\`(\`status\`, \`available_at\`),
+    INDEX \`${G}_status_lease_expires_at_idx\`(\`status\`, \`lease_expires_at\`),
+    INDEX \`${G}_batch_id_idx\`(\`batch_id\`),
+    PRIMARY KEY (\`id\`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`];let V=z==="sqlite"?'"id" TEXT NOT NULL PRIMARY KEY,':'"id" TEXT NOT NULL,',Y=z==="sqlite"?"":`,
+
+    CONSTRAINT "${G}_pkey" PRIMARY KEY ("id")`;return[`CREATE TABLE IF NOT EXISTS "${G}" (
+    ${V}
+    "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"}${Y}
+)`,`CREATE INDEX IF NOT EXISTS "${G}_status_available_at_idx" ON "${G}"("status", "available_at")`,`CREATE INDEX IF NOT EXISTS "${G}_status_lease_expires_at_idx" ON "${G}"("status", "lease_expires_at")`,`CREATE INDEX IF NOT EXISTS "${G}_batch_id_idx" ON "${G}"("batch_id")`]}function t(z,G){if(z==="mysql"||z==="mariadb")return[`ALTER TABLE \`${G}\` ADD COLUMN \`batch_id\` VARCHAR(191) NULL,
+    ADD COLUMN \`progress\` DOUBLE NULL,
+    ADD INDEX \`${G}_batch_id_idx\`(\`batch_id\`)`];let V=z==="sqlite"?"REAL":"DOUBLE PRECISION";if(z==="sqlite")return[`ALTER TABLE "${G}" ADD COLUMN "batch_id" TEXT`,`ALTER TABLE "${G}" ADD COLUMN "progress" ${V}`,`CREATE INDEX IF NOT EXISTS "${G}_batch_id_idx" ON "${G}"("batch_id")`];return[`ALTER TABLE "${G}" ADD COLUMN IF NOT EXISTS "batch_id" TEXT,
+ADD COLUMN IF NOT EXISTS "progress" ${V}`,`CREATE INDEX IF NOT EXISTS "${G}_batch_id_idx" ON "${G}"("batch_id")`]}function o(z,G){if(z==="mysql"||z==="mariadb")return[`CREATE TABLE IF NOT EXISTS \`${G}\` (
+    \`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 V=z==="sqlite"?'"id" TEXT NOT NULL PRIMARY KEY,':'"id" TEXT NOT NULL,',Y=z==="sqlite"?"":`,
+
+    CONSTRAINT "${G}_pkey" PRIMARY KEY ("id")`;return[`CREATE TABLE IF NOT EXISTS "${G}" (
+    ${V}
+    "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${Y}
+)`]}function j(z){let G=JSON.parse(z.options),V=(Y)=>Y==null?null:Number(Y);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:V(z.cancelled_at),finishedAt:V(z.finished_at),createdAt:Number(z.created_at),allowFailures:G.allowFailures===!0,callbacks:G.callbacks??{}}}function e(z){return JSON.stringify({allowFailures:z.allowFailures,callbacks:z.callbacks})}function u(z){let G=String(z?.message??z);return/does not exist|doesn't exist|unknown column|no such (table|column)|has no column/i.test(G)}async function M(z,G){try{return await z}catch(V){if(!u(V))throw V;throw Error(`Job batches need the "${G}" 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:V})}}import{AsyncResource as Gz}from"async_hooks";import{isMainThread as Vz}from"worker_threads";function Dz(z){return z}function q(){return{jobs:[],jobsDir:"app/jobs",concurrency:1,driver:"memory",visibilityTimeout:300000,pollInterval:1000,unknownJobGrace:3600000,locks:"auto"}}var zz=86400000;class T{entries=new Map;batches=new Map;listeners=new Set;timer;timerAt=1/0;seq=0;get waiting(){let z=0;for(let G of this.entries.values())if(!G.leased)z++;return z}get leased(){return this.entries.size-this.waiting}async enqueue(z){let G=this.add(z);return this.changed(),G}add({name:z,args:G,delayMs:V=0,id:Y=crypto.randomUUID()},Z){let $=Date.now();return this.entries.set(Y,{job:{id:Y,name:z,args:G,attempt:0,createdAt:$,...Z===void 0?{}:{batchId:Z}},until:$+Math.max(0,V),leased:!1,seq:this.seq++,progress:0}),Y}async enqueueBatch(z){let G=Date.now();this.forgetFinishedBatches(G);let V=C({...z,total:z.args.length,now:G});for(let $ of z.args)this.add({name:z.job,args:$},z.id);let{record:Y,calls:Z}=P(V,V,G);this.batches.set(z.id,Y);for(let $ of Z)this.add($);this.changed()}async findBatch(z,G={}){let V=this.batches.get(z);if(!V)return null;if(G.progress===!1||V.pending===0)return A(V);let Y=0;for(let Z of this.entries.values())if(Z.job.batchId===z)Y+=Z.progress;return A(V,Y)}async cancelBatch(z){let G=this.batches.get(z);if(!G||G.finishedAt!==null||G.cancelledAt!==null)return!1;let V=Date.now(),Y=B(G,V,this.cancelWaiting(z));return this.save(G,Y,V),this.changed(),!0}async reportProgress(z,G){let V=this.current(z);if(V)V.progress=U(G)}async claim(z,G){let V=Date.now(),Y=[...this.entries.values()].filter((Z)=>Z.until<=V).sort((Z,$)=>Z.until-$.until||Z.seq-$.seq).slice(0,Math.max(0,z));for(let Z of Y)Z.job={...Z.job,attempt:Z.job.attempt+1},Z.leased=!0,Z.until=V+G.visibilityTimeoutMs;if(Y.length>0)this.schedule();return Y.map((Z)=>({...Z.job}))}async complete(z){let G=this.current(z);if(!G)return;this.entries.delete(z.id),this.count(G,"succeeded"),this.schedule()}async fail(z,G){let V=this.current(z);if(!V)return;let Y=V.job.batchId===void 0?void 0:this.batches.get(V.job.batchId),Z=G.cancelled===!0||G.retryInMs!==null&&Y?.cancelledAt!=null;if(G.retryInMs===null||Z){this.entries.delete(z.id),this.count(V,Z?"cancelled":"failed"),this.schedule();return}V.leased=!1,V.until=Date.now()+Math.max(0,G.retryInMs),V.seq=this.seq++,V.progress=0,this.changed()}async release(z,G){let V=this.current(z);if(!V)return;V.job={...V.job,attempt:V.job.attempt-1},V.leased=!1,V.until=Date.now()+Math.max(0,G.retryInMs),V.seq=this.seq++,this.changed()}async heartbeat(z,G){let V=Date.now()+G.visibilityTimeoutMs;for(let Y of z){let Z=this.current(Y);if(Z)Z.until=V}this.schedule()}count(z,G){let V=z.job.batchId;if(V===void 0)return;let Y=this.batches.get(V);if(!Y)return;let Z=Date.now(),$=I(Y,G,z.job.id);if(S(Y,$))$=B($,Z,this.cancelWaiting(V));this.save(Y,$,Z),this.changed()}save(z,G,V){let{record:Y,calls:Z}=P(z,G,V);this.batches.set(Y.id,Y);for(let $ of Z)this.add($)}cancelWaiting(z){let G=0;for(let[V,Y]of this.entries)if(Y.job.batchId===z&&!Y.leased)this.entries.delete(V),G++;return G}forgetFinishedBatches(z){for(let[G,V]of this.batches)if(V.finishedAt!==null&&z-V.finishedAt>zz)this.batches.delete(G)}subscribe(z){return this.listeners.add(z),()=>void this.listeners.delete(z)}current(z){let G=this.entries.get(z.id);if(!G||!G.leased||G.job.attempt!==z.attempt)return;return G}changed(){this.schedule();let z=Date.now();for(let G of this.entries.values())if(G.until<=z){this.wake();return}}wake(){for(let z of[...this.listeners])z()}schedule(){let z=Date.now(),G=1/0;for(let V of this.entries.values())if(V.until>z&&V.until<G)G=V.until;if(G===this.timerAt)return;if(clearTimeout(this.timer),this.timer=void 0,this.timerAt=G,G===1/0)return;this.timer=setTimeout(()=>{this.timer=void 0,this.timerAt=1/0,this.changed()},G-z),this.timer.unref?.()}}function Yz(){let z=process.env.APP_DIR,G=process.env.ROOT_DIR,V=Bun.env.NODE_ENV==="production"?`${G}/dist/server/bootstrap.mjs`:`${z}/bootstrap.ts`,Y=new File([`
+      import { app } from "${V}"
+      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"),Z=URL.createObjectURL(Y);return new Worker(Z)}async function Zz(z,G){let V=Yz();return V.postMessage({jobName:z,args:G}),await new Promise((Y,Z)=>{V.onmessage=($)=>{let X=$.data;if("error"in X)Z(X.error);else Y(X.result)}})}var $z=new Gz("gemi.queue"),Xz=60000;class E{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;constructor(z={},G={}){this.config=d(q(),z),this.application=G.application,this.driver=Az(this.config.driver,this.application),this.useJobs(this.config.jobs)}useJobs(z){this.config.jobs=z,this.jobs={};for(let G of z)this.claim(G)}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,G){if(this.jobs[z])return new this.jobs[z]().run(JSON.parse(G))}push(z,G,V={}){let Y=this.uniqueKey(z,G);if(Y)return this.pushUnique(z,G,Y,V);let Z=this.driver.joinsTransaction?.()===!0;if(!Z){let $=Bun.randomUUIDv7();if(_(()=>this.record(z,G,{id:$,reportFailure:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve($)}return this.record(z,G,{reportFailure:V.reportFailure,joins:Z})}pushBatch(z,G,V={}){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!==R.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 Z={};for(let H of["then","catch","finally"]){let K=V[H];if(K===void 0)continue;if(typeof K?.name!=="string"||!Array.isArray(K.args))throw Error(`The batch's ${H} callback is not a job call. Build it with SomeJob.with(...args).`);Z[H]={name:K.name,args:K.args}}let $={id:Bun.randomUUIDv7(),name:V.name??null,job:z.name,args:G,allowFailures:V.allowFailures===!0,callbacks:Z},X={id:$.id,total:G.length},F=this.driver.joinsTransaction?.()===!0;if(!F){if(_(()=>this.recordBatch($,{committed:!0}).then(()=>{},()=>{})))return Promise.resolve(X)}return this.recordBatch($,{joins:F}).then(()=>X)}recordBatch(z,G){let V=this.driver.enqueueBatch(z);this.startIfIdle();let Y=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),Z=G.joins===!0&&_(Y);return V.then(()=>Z||Y(),($)=>{if(!G.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.`,$)}),V}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 G=await this.driver.cancelBatch(z);if(G)this.claimSoon();return G}get locks(){return this.lockManager??=new s(this.resolveLockStore()),this.lockManager}resolveLockStore(){let z=this.config.locks;if(z==="auto"){let G=this.driver.lockStore?.();if(G)return G;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 D}if(z==="memory")return new D;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 N(this.application.make(f));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,G){if(z.prototype.uniqueId===R.prototype.uniqueId)return;let V=new z,Y=V.uniqueId(...JSON.parse(G));if(Y===void 0||Y===null||Y==="")return;return{key:m(z.name,Y),ttl:Math.max(1,V.uniqueFor)}}pushUnique(z,G,V,Y){let Z=Bun.randomUUIDv7();if(_(()=>this.recordUnique(z,G,V,Z,{report:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve(Z);return this.recordUnique(z,G,V,Z,{report:Y.reportFailure!==!1,committed:!1})}recordUnique(z,G,V,Y,Z){let $=this.locks.store,X=(async()=>{for(let F=0;F<5;F++){if(await $.acquire(V.key,Y,V.ttl)!==null)try{return await this.record(z,G,{id:Y,reportFailure:!1})}catch(K){throw await $.release(V.key,Y).catch(()=>{}),K}let H=await $.holder(V.key);if(H)return H.owner}throw Error(`The unique key "${V.key}" kept changing hands, so ${z.name} was not queued.`)})();return X.catch((F)=>{if(!Z.report)return;console.error(`[gemi] The queue could not record the unique job ${z.name}`+(Z.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."),F)}),X}async releaseUnique(z,G,V){if(z.uniqueId===R.prototype.uniqueId)return;try{let Y=z.uniqueId(...G);if(Y===void 0||Y===null||Y==="")return;await this.locks.store.release(m(V.name,Y),V.id)}catch(Y){console.error(`[gemi] Could not free the unique key of ${V.name} (${V.id}); it frees itself after uniqueFor.`,Y)}}record(z,G,V){let Y=this.driver.enqueue({name:z.name,args:G,...V.id===void 0?{}:{id:V.id}});this.startIfIdle();let Z=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),$=V.joins===!0&&_(Z);return Y.then(()=>$||Z(),(X)=>{if(V.reportFailure===!1)return;console.error(`[gemi] The queue driver could not record ${z.name}`+(V.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."),X)}),Y}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 G=await this.driver.retryDead(z);if(G)this.claimSoon();return G}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()&&!Fz())globalThis.__gemiDevQueue=this;if(this.unsubscribe=this.driver.subscribe?.(()=>this.wake()),this.looping)return this.wake();$z.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 G,V=new Promise((Z)=>{if(z!==1/0)G=setTimeout(Z,z)}),Y=(async()=>{await this.claiming?.catch(()=>{}),await Promise.allSettled([...this.inFlight.values()].map((Z)=>Z.done))})();return await Promise.race([Y,V]),clearTimeout(G),{unfinished:[...this.inFlight.values()].map((Z)=>({...Z.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&&l()?0:this.config.concurrency-this.inFlight.size;if(z>0){this.woken=!1;let G=this.driver.claim(z,{...this.lease(),registered:{names:Object.keys(this.jobs),graceMs:this.config.unknownJobGrace}});this.claiming=G;let V=[];try{V=await G,this.claimFailures=0}catch(Y){this.claimFailures++,console.error(`The queue could not claim jobs from its driver; it will try again in ${this.retryDelay()}ms.`,Y)}finally{this.claiming=void 0}for(let Y of V)this.execute(Y);if(V.length===z)continue;if(this.woken&&this.inFlight.size<this.config.concurrency)continue}await this.sleep()}}sleep(){return new Promise((z)=>{let G,V=this.claimFailures>0?this.retryDelay():this.driver.subscribe?void 0:this.config.pollInterval;if(V!==void 0)G=setTimeout(()=>this.wake(),V),G.unref?.();this.resume=()=>{clearTimeout(G),z()}})}retryDelay(){let z=Math.min(Math.max(0,this.claimFailures-1),30);return Math.min(this.config.pollInterval*2**z,Xz)}wake(){this.woken=!0;let z=this.resume;this.resume=void 0,z?.()}get durable(){return!(this.driver instanceof T)}mayClaimHere(){return!this.application||Kz()}lease(){return{visibilityTimeoutMs:this.config.visibilityTimeout}}execute(z){let G=`${z.id}:${z.attempt}`,V=()=>this.run(z),Y=(this.application?b.run(this.application,V):V()).catch((Z)=>{console.error(`The queue could not record the outcome of ${z.name}.`,Z)}).finally(()=>{this.inFlight.delete(G),this.wake()});this.inFlight.set(G,{job:z,done:Y}),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 G=[...this.inFlight.values()].map((V)=>V.job);z.heartbeat(G,this.lease()).catch((V)=>{console.error("The queue could not extend its job leases.",V)})},Math.max(1,Math.floor(this.config.visibilityTimeout/3))),this.heartbeatTimer.unref?.()}async run(z){let G=this.jobs[z.name];if(!G){let K=Date.now()-z.createdAt;if(this.durable&&K<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 V;try{V=new G}catch(K){console.error(`Dropped a queued ${z.name}: it could not be constructed.`,K),await this.driver.fail(z,{error:`The job could not be constructed: ${String(K)}`,retryInMs:null});return}let Y;try{Y=JSON.parse(z.args)}catch(K){console.error(`Dropped a queued ${z.name}: its arguments are not JSON.`,K),await this.driver.fail(z,{error:`The arguments are not JSON: ${String(K)}`,retryInMs:null});return}if(z.attempt>Math.max(1,V.maxAttempts)){let K=Error(`${z.name} was claimed for attempt ${z.attempt} of ${V.maxAttempts}: an earlier attempt never finished, most likely because the process running it exited. Dead-lettered without running it again.`);g(`${z.name}.onDeadletter`,()=>V.onDeadletter(K,...Y)),await this.driver.fail(z,{error:K.message,retryInMs:null}),await this.releaseUnique(V,Y,z);return}if(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 J=this.batchHandle(z);V.batch=J.batch,V.$progress=J.progress}let Z=await this.admit(V,Y,z);if(!Z)return;let $,X;try{X=await(V.worker?Zz(z.name,z.args):V.run(...Y))}catch(K){$=K}finally{await Z.done()}let F=V.$outcome;if($===void 0&&F?.kind==="release"){await this.driver.release(z,{retryInMs:Math.max(0,F.delayMs)});return}if($===void 0&&F?.kind==="fail")$=F.error;let H=F?.kind==="fail"?F.retry:!0;if($===void 0)try{V.onSuccess(X,...Y)}catch(K){$=K}if($!==void 0){let K=String($?.stack??$);if(g(`${z.name}.onFail`,()=>V.onFail($,...Y)),!H||z.attempt>=V.maxAttempts)g(`${z.name}.onDeadletter`,()=>V.onDeadletter($,...Y)),await this.driver.fail(z,{error:K,retryInMs:null}),await this.releaseUnique(V,Y,z);else await this.driver.fail(z,{error:K,retryInMs:Wz(V.backoff,z.attempt)});return}await this.driver.complete(z),await this.releaseUnique(V,Y,z)}batchHandle(z){let G=z.batchId,V=this.driver;return{batch:{id:G,cancelled:async()=>(await V.findBatch?.(G,{progress:!1}))?.cancelledAt!=null},progress:(Y)=>V.reportProgress?.(z,Y)??Promise.resolve()}}async admit(z,G,V){let Y=z.concurrency(...G),Z=[z.throttle(...G)??[]].flat();if(!Y&&Z.length===0)return{done:async()=>{}};let $=this.locks,X;if(Y&&Y.limit>0){let H=this.config.visibilityTimeout;for(let K=0;K<Y.limit&&!X;K++)X=await $.acquire(`gemi:concurrency:${Y.key}:${K}`,{ttl:H,renew:!0})??void 0;if(!X){await this.driver.release(V,{retryInMs:Math.round(this.config.pollInterval*(1+Math.random()))});return}}let F=[];for(let H of Z){let K=`gemi:throttle:${H.key}`,J=await $.store.hit(K,H.limit,H.window);if(!J.allowed){await Promise.all(F.map((i)=>$.store.refund(i))),await X?.release(),await this.driver.release(V,{retryInMs:Math.max(1,J.resetInMs)});return}F.push(K)}return{done:async()=>{await X?.release().catch((H)=>{console.error(`[gemi] Could not free a concurrency slot of ${V.name}.`,H)})}}}}function m(z,G){return`gemi:job:${z}:${String(G)}`}function g(z,G){try{G()}catch(V){console.error(`${z} threw; the job's claim was ended anyway.`,V)}}function Fz(){return Bun.env.NODE_ENV==="production"}function Kz(){if(!Vz)return!1;if(Jz())return!0;return process.env.ROOT_DIR!==void 0&&!Hz()}function Hz(z=process.env){return(z.GEMI_QUEUE_CLAIM??"").trim().toLowerCase()==="off"}var c=Symbol.for("gemi.queue.worker");function mz(z=!0){globalThis[c]=z}function Jz(){return globalThis[c]===!0}function Wz(z,G){let V=Array.isArray(z)?z[Math.min(G,z.length)-1]:z;return Math.max(0,V??0)}function Az(z,G){if(z==="memory")return new T;if(z==="database"||typeof z==="function"){if(!G&&(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 y(G.make(f));return z(G)}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 R{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,G={}){this.$outcome={kind:"fail",error:z instanceof Error?z:Error(String(z)),retry:G.retry??!0}}batch=void 0;async progress(z){let G=U(z);await this.$progress?.(G)}$progress;$outcome;run(...z){}onFail(z,...G){}onSuccess(z,...G){}onDeadletter(z,...G){}static dispatch(...z){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return O(E).push(this,JSON.stringify(z))}static dispatchBatch(z,G={}){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return O(E).pushBatch(this,z.map((V)=>JSON.stringify(V)),G)}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 O(E).findBatch(z)}static cancelBatch(z){return O(E).cancelBatch(z)}}
+export{D as zc,N as Ac,y as Bc,R as Cc,Dz as Dc,q as Ec,T as Fc,E as Gc,Kz as Hc,Hz as Ic,mz as Jc,Jz as Kc};
+
+//# debugId=803B45721DCF33DC64756E2164756E21