@workglow/supabase 0.2.36 → 0.3.0

package/dist/job-queue/browser.js

@@ -1,7 +1,7 @@
 // src/job-queue/SupabaseQueueStorage.ts
-import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
+import { JobStatus, validateLeaseMs } from "@workglow/job-queue";
 import { PollingSubscriptionManager } from "@workglow/storage";
-import { JobStatus } from "@workglow/job-queue";
+import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
 var SUPABASE_QUEUE_STORAGE = createServiceToken("jobqueue.storage.supabase");
 
 class SupabaseQueueStorage {
@@ -81,7 +81,8 @@ class SupabaseQueueStorage {
     return value.replace(/'/g, "''");
   }
   async migrate() {
-    const createTypeSql = `CREATE TYPE job_status AS ENUM (${Object.values(JobStatus).map((v) => `'${v}'`).join(",")})`;
+    const enumValues = [...Object.values(JobStatus), "ABORTING"].filter((v, i, a) => a.indexOf(v) === i).map((v) => `'${v}'`).join(",");
+    const createTypeSql = `CREATE TYPE job_status AS ENUM (${enumValues})`;
     const { error: typeError } = await this.client.rpc("exec_sql", { query: createTypeSql });
     if (typeError && typeError.code !== "42710") {
       throw typeError;
@@ -99,10 +100,10 @@ class SupabaseQueueStorage {
       status job_status NOT NULL default 'PENDING',
       input jsonb NOT NULL,
       output jsonb,
-      run_attempts integer default 0,
-      max_retries integer default 20,
-      run_after timestamp with time zone DEFAULT now(),
-      last_ran_at timestamp with time zone,
+      attempts integer default 0,
+      max_attempts integer default 10,
+      visible_at timestamp with time zone DEFAULT now(),
+      last_attempted_at timestamp with time zone,
       created_at timestamp with time zone DEFAULT now(),
       deadline_at timestamp with time zone,
       completed_at timestamp with time zone,
@@ -111,7 +112,9 @@ class SupabaseQueueStorage {
       progress real DEFAULT 0,
       progress_message text DEFAULT '',
       progress_details jsonb,
-      worker_id text
+      lease_owner text,
+      abort_requested_at timestamp with time zone,
+      lease_expires_at timestamp with time zone
     )`;
     const { error: tableError } = await this.client.rpc("exec_sql", { query: createTableSql });
     if (tableError) {
@@ -119,10 +122,26 @@ class SupabaseQueueStorage {
         throw tableError;
       }
     }
+    const alterSqls = [
+      `ALTER TABLE ${this.tableName} ADD COLUMN IF NOT EXISTS abort_requested_at timestamp with time zone`,
+      `ALTER TABLE ${this.tableName} ADD COLUMN IF NOT EXISTS lease_expires_at timestamp with time zone`,
+      `ALTER TABLE ${this.tableName} RENAME COLUMN run_after TO visible_at`,
+      `ALTER TABLE ${this.tableName} RENAME COLUMN last_ran_at TO last_attempted_at`,
+      `ALTER TABLE ${this.tableName} RENAME COLUMN run_attempts TO attempts`,
+      `ALTER TABLE ${this.tableName} RENAME COLUMN max_retries TO max_attempts`,
+      `ALTER TABLE ${this.tableName} RENAME COLUMN worker_id TO lease_owner`
+    ];
+    for (const sql of alterSqls) {
+      const { error } = await this.client.rpc("exec_sql", { query: sql });
+      if (error && error.code !== "42703") {
+        throw new Error(`Failed to rename column: ${error.message}`);
+      }
+    }
     const indexes = [
-      `CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}id, status, run_after)`,
-      `CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`,
-      `CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`
+      `CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}id, status, visible_at)`,
+      `CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, status, visible_at)`,
+      `CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_${this.tableName}_fingerprint_active ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint) WHERE status IN ('PENDING','PROCESSING')`
     ];
     for (const indexSql of indexes) {
       await this.client.rpc("exec_sql", { query: indexSql });
@@ -135,30 +154,41 @@ class SupabaseQueueStorage {
     const now = new Date().toISOString();
     job.queue = this.queueName;
     job.job_run_id = job.job_run_id ?? uuid4();
-    job.fingerprint = await makeFingerprint(job.input);
+    job.fingerprint = job.fingerprint ?? await makeFingerprint(job.input);
     job.status = JobStatus.PENDING;
     job.progress = 0;
     job.progress_message = "";
     job.progress_details = null;
     job.created_at = now;
-    job.run_after = now;
+    job.visible_at = now;
     const prefixInsertValues = this.getPrefixInsertValues();
     const { data, error } = await this.client.from(this.tableName).insert({
       ...prefixInsertValues,
       queue: job.queue,
       fingerprint: job.fingerprint,
       input: job.input,
-      run_after: job.run_after,
+      visible_at: job.visible_at,
       created_at: job.created_at,
       deadline_at: job.deadline_at,
-      max_retries: job.max_retries,
+      max_attempts: job.max_attempts,
       job_run_id: job.job_run_id,
       progress: job.progress,
       progress_message: job.progress_message,
       progress_details: job.progress_details
     }).select("id").single();
-    if (error)
+    if (error) {
+      const e = error;
+      const isUniqueViolation = e?.code === "23505";
+      const involvesFingerprint = typeof e?.details === "string" && /fingerprint/i.test(e.details) || typeof e?.message === "string" && /fingerprint/i.test(e.message);
+      if (isUniqueViolation && involvesFingerprint && job.fingerprint) {
+        const winner = await this.findActiveByFingerprint(job.fingerprint, this.queueName);
+        if (winner?.id != null) {
+          job.id = winner.id;
+          return winner.id;
+        }
+      }
       throw error;
+    }
     if (!data)
       throw new Error("Failed to add to queue");
     job.id = data.id;
@@ -179,12 +209,14 @@ class SupabaseQueueStorage {
     num = Number(num) || 100;
     let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName).eq("status", status);
     query = this.applyPrefixFilters(query);
-    const { data, error } = await query.order("run_after", { ascending: true }).limit(num);
+    const { data, error } = await query.order("visible_at", { ascending: true }).limit(num);
     if (error)
       throw error;
     return data ?? [];
   }
-  async next(workerId) {
+  async next(workerId, opts) {
+    const leaseMs = opts?.leaseMs ?? 30000;
+    validateLeaseMs(leaseMs, "leaseMs");
     const prefixConditions = this.buildPrefixWhereSql();
     const validatedQueueName = this.validateSqlValue(this.queueName, "queueName");
     const validatedWorkerId = this.validateSqlValue(workerId, "workerId");
@@ -192,15 +224,27 @@ class SupabaseQueueStorage {
     const escapedWorkerId = this.escapeSqlString(validatedWorkerId);
     const sql = `
       UPDATE ${this.tableName}
-      SET status = '${JobStatus.PROCESSING}', last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = '${escapedWorkerId}'
+      SET status = '${JobStatus.PROCESSING}',
+          last_attempted_at = NOW() AT TIME ZONE 'UTC',
+          lease_owner = '${escapedWorkerId}',
+          lease_expires_at = NOW() AT TIME ZONE 'UTC' + (${Number(leaseMs)} * INTERVAL '1 millisecond'),
+          -- Lease-expiry reclaim consumes one attempt against max_attempts;
+          -- PENDING claims do not (the worker's validateJobState will FAIL
+          -- the job when attempts >= max_attempts at next-step time).
+          attempts = CASE WHEN status = '${JobStatus.PROCESSING}' THEN attempts + 1 ELSE attempts END,
+          -- Always clear stale abort_requested_at on (re)claim so a flag set
+          -- by an earlier worker doesn't immediately abort the new lease.
+          abort_requested_at = NULL
       WHERE id = (
         SELECT id
         FROM ${this.tableName}
         WHERE queue = '${escapedQueueName}'
-        AND status = '${JobStatus.PENDING}'
+        AND (
+          (status = '${JobStatus.PENDING}' AND visible_at <= NOW() AT TIME ZONE 'UTC')
+          OR (status = '${JobStatus.PROCESSING}' AND (lease_expires_at IS NULL OR lease_expires_at < NOW() AT TIME ZONE 'UTC'))
+        )
         ${prefixConditions}
-        AND run_after <= NOW() AT TIME ZONE 'UTC'
-        ORDER BY run_after ASC
+        ORDER BY visible_at ASC
         FOR UPDATE SKIP LOCKED
         LIMIT 1
       )
@@ -213,6 +257,31 @@ class SupabaseQueueStorage {
     }
     return data[0];
   }
+  async extendLease(id, workerId, ms) {
+    validateLeaseMs(ms, "ms");
+    const validatedWorkerId = this.validateSqlValue(workerId, "workerId");
+    const escapedWorkerId = this.escapeSqlString(validatedWorkerId);
+    const numericId = Number(id);
+    if (!Number.isFinite(numericId)) {
+      throw new Error(`Invalid job id: ${id}`);
+    }
+    const prefixConditions = this.buildPrefixWhereSql();
+    const sql = `
+      UPDATE ${this.tableName}
+        SET lease_expires_at = NOW() AT TIME ZONE 'UTC' + (${Number(ms)} * INTERVAL '1 millisecond')
+        WHERE id = ${numericId}
+          AND queue = '${this.escapeSqlString(this.validateSqlValue(this.queueName, "queueName"))}'
+          AND lease_owner = '${escapedWorkerId}'
+          AND status = '${JobStatus.PROCESSING}'
+          ${prefixConditions}
+        RETURNING id`;
+    const { data, error } = await this.client.rpc("exec_sql", { query: sql });
+    if (error)
+      throw error;
+    if (!data || !Array.isArray(data) || data.length === 0) {
+      throw new Error(`extendLease failed: job ${String(id)} is not PROCESSING or lease is not owned by worker ${workerId}`);
+    }
+  }
   async size(status = JobStatus.PENDING) {
     let query = this.client.from(this.tableName).select("*", { count: "exact", head: true }).eq("queue", this.queueName).eq("status", status);
     query = this.applyPrefixFilters(query);
@@ -238,7 +307,7 @@ class SupabaseQueueStorage {
         progress_message: "",
         progress_details: null,
         completed_at: now,
-        last_ran_at: now
+        last_attempted_at: now
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
       query2 = this.applyPrefixFilters(query2);
       const { error: error2 } = await query2;
@@ -246,25 +315,25 @@ class SupabaseQueueStorage {
         throw error2;
       return;
     }
-    let getQuery = this.client.from(this.tableName).select("run_attempts, max_retries").eq("id", jobDetails.id).eq("queue", this.queueName);
+    let getQuery = this.client.from(this.tableName).select("attempts, max_attempts").eq("id", jobDetails.id).eq("queue", this.queueName);
     getQuery = this.applyPrefixFilters(getQuery);
     const { data: current, error: getError } = await getQuery.single();
     if (getError)
       throw getError;
-    const currentAttempts = current?.run_attempts ?? 0;
-    const maxRetries = current?.max_retries ?? jobDetails.max_retries ?? 10;
+    const currentAttempts = current?.attempts ?? 0;
+    const maxAttempts = current?.max_attempts ?? jobDetails.max_attempts ?? 10;
     const nextAttempts = currentAttempts + 1;
     if (jobDetails.status === JobStatus.PENDING) {
-      if (nextAttempts > maxRetries) {
+      if (nextAttempts >= maxAttempts) {
         let failQuery = this.client.from(this.tableName).update({
           status: JobStatus.FAILED,
-          error: "Max retries reached",
-          error_code: "MAX_RETRIES_REACHED",
+          error: "Max attempts reached",
+          error_code: "MAX_ATTEMPTS_REACHED",
           progress: 100,
           progress_message: "",
           progress_details: null,
           completed_at: now,
-          last_ran_at: now
+          last_attempted_at: now
         }).eq("id", jobDetails.id).eq("queue", this.queueName);
         failQuery = this.applyPrefixFilters(failQuery);
         const { error: failError } = await failQuery;
@@ -276,12 +345,13 @@ class SupabaseQueueStorage {
         error: jobDetails.error ?? null,
         error_code: jobDetails.error_code ?? null,
         status: jobDetails.status,
-        run_after: jobDetails.run_after,
+        visible_at: jobDetails.visible_at,
         progress: 0,
         progress_message: "",
         progress_details: null,
-        run_attempts: nextAttempts,
-        last_ran_at: now
+        attempts: nextAttempts,
+        last_attempted_at: now,
+        abort_requested_at: null
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
       query2 = this.applyPrefixFilters(query2);
       const { error: error2 } = await query2;
@@ -298,9 +368,9 @@ class SupabaseQueueStorage {
         progress: 100,
         progress_message: "",
         progress_details: null,
-        run_attempts: nextAttempts,
+        attempts: nextAttempts,
         completed_at: now,
-        last_ran_at: now
+        last_attempted_at: now
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
       query2 = this.applyPrefixFilters(query2);
       const { error: error2 } = await query2;
@@ -313,28 +383,62 @@ class SupabaseQueueStorage {
       output: jobDetails.output ?? null,
       error: jobDetails.error ?? null,
       error_code: jobDetails.error_code ?? null,
-      run_after: jobDetails.run_after ?? null,
-      run_attempts: nextAttempts,
-      last_ran_at: now
+      visible_at: jobDetails.visible_at ?? null,
+      attempts: nextAttempts,
+      last_attempted_at: now
     }).eq("id", jobDetails.id).eq("queue", this.queueName);
     query = this.applyPrefixFilters(query);
     const { error } = await query;
     if (error)
       throw error;
   }
-  async release(jobId) {
+  async releaseClaim(jobId) {
     let query = this.client.from(this.tableName).update({
       status: JobStatus.PENDING,
-      worker_id: null,
+      lease_owner: null,
       progress: 0,
       progress_message: "",
-      progress_details: null
+      progress_details: null,
+      abort_requested_at: null
     }).eq("id", jobId).eq("queue", this.queueName);
     query = this.applyPrefixFilters(query);
     const { error } = await query;
     if (error)
       throw error;
   }
+  async finalize(id, fields) {
+    const patch = {};
+    if ("output" in fields)
+      patch.output = fields.output ?? null;
+    if ("error" in fields)
+      patch.error = fields.error ?? null;
+    if ("error_code" in fields)
+      patch.error_code = fields.error_code ?? null;
+    if ("status" in fields)
+      patch.status = fields.status;
+    if ("completed_at" in fields)
+      patch.completed_at = fields.completed_at ?? null;
+    if ("abort_requested_at" in fields) {
+      patch.abort_requested_at = fields.abort_requested_at ?? null;
+    }
+    if ("lease_owner" in fields)
+      patch.lease_owner = fields.lease_owner ?? null;
+    if ("progress" in fields)
+      patch.progress = fields.progress ?? 0;
+    if ("progress_message" in fields)
+      patch.progress_message = fields.progress_message ?? "";
+    if ("progress_details" in fields)
+      patch.progress_details = fields.progress_details ?? null;
+    if ("visible_at" in fields)
+      patch.visible_at = fields.visible_at ?? null;
+    if (Object.keys(patch).length === 0)
+      return;
+    let query = this.client.from(this.tableName).update(patch).eq("id", id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
   async deleteAll() {
     let query = this.client.from(this.tableName).delete().eq("queue", this.queueName);
     query = this.applyPrefixFilters(query);
@@ -355,7 +459,28 @@ class SupabaseQueueStorage {
     return data?.output ?? null;
   }
   async abort(jobId) {
-    let query = this.client.from(this.tableName).update({ status: JobStatus.ABORTING }).eq("id", jobId).eq("queue", this.queueName);
+    const now = new Date().toISOString();
+    {
+      let query = this.client.from(this.tableName).update({
+        status: JobStatus.FAILED,
+        abort_requested_at: now,
+        completed_at: now
+      }).eq("id", jobId).eq("queue", this.queueName).eq("status", JobStatus.PENDING);
+      query = this.applyPrefixFilters(query);
+      const { error } = await query;
+      if (error)
+        throw error;
+    }
+    {
+      let query = this.client.from(this.tableName).update({ abort_requested_at: now }).eq("id", jobId).eq("queue", this.queueName).eq("status", JobStatus.PROCESSING);
+      query = this.applyPrefixFilters(query);
+      const { error } = await query;
+      if (error)
+        throw error;
+    }
+  }
+  async saveStatus(jobId, status) {
+    let query = this.client.from(this.tableName).update({ status }).eq("id", jobId).eq("queue", this.queueName);
     query = this.applyPrefixFilters(query);
     const { error } = await query;
     if (error)
@@ -387,6 +512,76 @@ class SupabaseQueueStorage {
     if (error)
       throw error;
   }
+  async findActiveByFingerprint(fingerprint, queueName) {
+    const prefixConditions = this.buildPrefixWhereSql();
+    const validatedQueueName = this.validateSqlValue(queueName, "queueName");
+    const escapedQueueName = this.escapeSqlString(validatedQueueName);
+    const escapedFingerprint = this.escapeSqlString(fingerprint);
+    const sql = `
+      SELECT * FROM ${this.tableName}
+        WHERE fingerprint = '${escapedFingerprint}' AND queue = '${escapedQueueName}'
+          AND status IN ('PENDING','PROCESSING')${prefixConditions}
+        ORDER BY created_at DESC
+        LIMIT 1`;
+    const { data, error } = await this.client.rpc("exec_sql", { query: sql });
+    if (error)
+      throw error;
+    if (!data || !Array.isArray(data) || data.length === 0)
+      return;
+    return data[0];
+  }
+  async getMany(ids) {
+    if (ids.length === 0)
+      return [];
+    let query = this.client.from(this.tableName).select("*").in("id", ids).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    const map = new Map;
+    for (const row of data ?? []) {
+      map.set(row.id, row);
+    }
+    return ids.map((id) => map.get(id));
+  }
+  async completeWithResult(id, result) {
+    const now = new Date().toISOString();
+    let query = this.client.from(this.tableName).update({
+      output: result ?? null,
+      status: "COMPLETED",
+      progress: 100,
+      progress_message: "",
+      progress_details: null,
+      completed_at: now
+    }).eq("id", id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  async failWithError(id, opts) {
+    const numericId = Number(id);
+    if (!Number.isFinite(numericId)) {
+      throw new Error(`Invalid job id: ${id}`);
+    }
+    const prefixConditions = this.buildPrefixWhereSql();
+    const validatedQueueName = this.validateSqlValue(this.queueName, "queueName");
+    const escapedQueueName = this.escapeSqlString(validatedQueueName);
+    const errorLiteral = "error" in opts ? opts.error != null ? `'${this.escapeSqlString(opts.error)}'` : "NULL" : "NULL";
+    const errorCodeLiteral = "errorCode" in opts ? opts.errorCode != null ? `'${this.escapeSqlString(opts.errorCode)}'` : "NULL" : "NULL";
+    const abortClause = opts.abortRequested === true ? `CASE WHEN abort_requested_at IS NOT NULL THEN abort_requested_at ELSE NOW() AT TIME ZONE 'UTC' END` : `abort_requested_at`;
+    const sql = `
+      UPDATE ${this.tableName}
+          SET error = COALESCE(${errorLiteral}, error),
+              error_code = COALESCE(${errorCodeLiteral}, error_code),
+              abort_requested_at = ${abortClause},
+              status = 'FAILED',
+              completed_at = COALESCE(completed_at, NOW() AT TIME ZONE 'UTC')
+        WHERE id = ${numericId} AND queue = '${escapedQueueName}'${prefixConditions}`;
+    const { error } = await this.client.rpc("exec_sql", { query: sql });
+    if (error)
+      throw error;
+  }
   async deleteJobsByStatusAndAge(status, olderThanMs) {
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
     let query = this.client.from(this.tableName).delete().eq("queue", this.queueName).eq("status", status).not("completed_at", "is", null).lte("completed_at", cutoffDate);
@@ -761,11 +956,250 @@ class SupabaseRateLimiterStorage {
       throw nextError;
   }
 }
+// src/job-queue/SupabaseMessageQueue.ts
+class SupabaseClaim {
+  core;
+  pending;
+  id;
+  body;
+  attempts;
+  workerId;
+  constructor(core, pending, id, body, attempts, workerId) {
+    this.core = core;
+    this.pending = pending;
+    this.id = id;
+    this.body = body;
+    this.attempts = attempts;
+    this.workerId = workerId;
+  }
+  async ack(result) {
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const output = result !== undefined ? result : buf?.output !== undefined ? buf.output : current.output ?? null;
+    await this.core.finalize(this.id, {
+      output,
+      error: null,
+      error_code: null,
+      status: "COMPLETED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async retry(opts) {
+    this.pending.delete(this.id);
+    const delay = opts?.delaySeconds ?? 0;
+    const current = await this.core.get(this.id) ?? this.body;
+    await this.core.complete({
+      ...current,
+      status: "PENDING",
+      lease_owner: null,
+      lease_expires_at: null,
+      visible_at: new Date(Date.now() + delay * 1000).toISOString(),
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+  async fail(opts) {
+    opts?.permanent;
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const error = opts?.error !== undefined ? opts.error : buf?.error !== undefined ? buf.error : current.error ?? null;
+    const errorCode = opts?.errorCode !== undefined ? opts.errorCode : buf?.errorCode !== undefined ? buf.errorCode : current.error_code ?? null;
+    const abortRequested = opts?.abortRequested !== undefined ? opts.abortRequested : buf?.abortRequested ?? false;
+    await this.core.finalize(this.id, {
+      error,
+      error_code: errorCode,
+      abort_requested_at: abortRequested ? current.abort_requested_at ?? new Date().toISOString() : current.abort_requested_at ?? null,
+      status: "FAILED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async extendLease(ms) {
+    await this.core.extendLease(this.id, this.workerId, ms);
+  }
+  async disable() {
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id);
+    const completedAt = current?.completed_at ?? new Date().toISOString();
+    await this.core.finalize(this.id, {
+      status: "DISABLED",
+      completed_at: completedAt,
+      lease_owner: null,
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+}
+
+class SupabaseMessageQueue {
+  scope;
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+    this.scope = core.scope;
+  }
+  async send(body, opts) {
+    return this.core.add(applySendOptions(body, opts));
+  }
+  async sendBatch(bodies, opts) {
+    const ids = [];
+    for (const body of bodies) {
+      ids.push(await this.send(body, opts));
+    }
+    return ids;
+  }
+  async receive(opts) {
+    const max = Math.max(1, opts.max ?? 1);
+    const claims = [];
+    while (claims.length < max) {
+      const job = await this.core.next(opts.workerId, { leaseMs: opts.leaseMs });
+      if (!job)
+        break;
+      claims.push(new SupabaseClaim(this.core, this.pending, job.id, job, job.attempts ?? 0, opts.workerId));
+    }
+    return claims;
+  }
+  async releaseClaim(id) {
+    this.pending.delete(id);
+    await this.core.releaseClaim(id);
+  }
+  async migrate() {
+    await this.core.migrate();
+  }
+  getMigrations() {
+    return this.core.getMigrations();
+  }
+  subscribeToChanges(callback, options) {
+    return this.core.subscribeToChanges(callback, options);
+  }
+}
+function applySendOptions(body, opts) {
+  if (!opts)
+    return body;
+  const out = { ...body };
+  if (opts.delaySeconds != null) {
+    out.visible_at = new Date(Date.now() + opts.delaySeconds * 1000).toISOString();
+  }
+  if (opts.timeoutSeconds != null) {
+    out.deadline_at = new Date(Date.now() + opts.timeoutSeconds * 1000).toISOString();
+  }
+  if (opts.fingerprint != null)
+    out.fingerprint = opts.fingerprint;
+  if (opts.jobRunId != null)
+    out.job_run_id = opts.jobRunId;
+  if (opts.maxAttempts != null)
+    out.max_attempts = opts.maxAttempts;
+  return out;
+}
+// src/job-queue/SupabaseJobStore.ts
+class SupabaseJobStore {
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+  }
+  get(id) {
+    return this.core.get(id);
+  }
+  async peek(status, num) {
+    return this.core.peek(status, num);
+  }
+  size(status) {
+    return this.core.size(status);
+  }
+  async getByRunId(runId) {
+    return this.core.getByRunId(runId);
+  }
+  outputForInput(input) {
+    return this.core.outputForInput(input);
+  }
+  async saveProgress(id, progress, message, details) {
+    await this.core.saveProgress(id, progress, message, details);
+  }
+  async saveResult(id, output) {
+    const buf = this.pending.get(id) ?? {};
+    buf.output = output ?? null;
+    this.pending.set(id, buf);
+  }
+  async saveError(id, error, errorCode, abortRequested) {
+    const buf = this.pending.get(id) ?? {};
+    buf.error = error;
+    buf.errorCode = errorCode;
+    buf.abortRequested = abortRequested;
+    this.pending.set(id, buf);
+  }
+  async deleteByStatusAndAge(status, olderThanMs) {
+    await this.core.deleteJobsByStatusAndAge(status, olderThanMs);
+  }
+  async delete(id) {
+    this.pending.delete(id);
+    await this.core.delete(id);
+  }
+  async deleteAll() {
+    this.pending.clear();
+    await this.core.deleteAll();
+  }
+  async abort(id) {
+    await this.core.abort(id);
+  }
+  async saveStatus(id, status) {
+    await this.core.saveStatus(id, status);
+  }
+  async create(body, opts) {
+    const enriched = {
+      ...body,
+      fingerprint: opts.fingerprint ?? body.fingerprint,
+      job_run_id: opts.jobRunId ?? body.job_run_id,
+      max_attempts: opts.maxAttempts ?? body.max_attempts,
+      deadline_at: opts.timeoutSeconds != null ? new Date(Date.now() + opts.timeoutSeconds * 1000).toISOString() : body.deadline_at
+    };
+    return this.core.add(enriched);
+  }
+  async findActiveByFingerprint(fingerprint, queueName) {
+    return this.core.findActiveByFingerprint(fingerprint, queueName);
+  }
+  async getMany(ids) {
+    return this.core.getMany(ids);
+  }
+  async completeWithResult(id, result) {
+    this.pending.delete(id);
+    await this.core.completeWithResult(id, result);
+  }
+  async failWithError(id, opts) {
+    this.pending.delete(id);
+    await this.core.failWithError(id, opts);
+  }
+  async markEnqueueDeferred(id, opts) {
+    await this.core.finalize(id, {
+      visible_at: opts.visible_at.toISOString(),
+      error_code: opts.errorCode
+    });
+  }
+}
+// src/job-queue/createSupabaseQueue.ts
+function createSupabaseQueue(queueName, client, opts) {
+  const core = new SupabaseQueueStorage(client, queueName, opts);
+  const pending = new Map;
+  return {
+    messageQueue: new SupabaseMessageQueue(core, pending),
+    jobStore: new SupabaseJobStore(core, pending),
+    core
+  };
+}
 export {
+  createSupabaseQueue,
   SupabaseRateLimiterStorage,
   SupabaseQueueStorage,
+  SupabaseMessageQueue,
+  SupabaseJobStore,
   SUPABASE_RATE_LIMITER_STORAGE,
   SUPABASE_QUEUE_STORAGE
 };
 
-//# debugId=E7022DCB352EE4D964756E2164756E21
+//# debugId=9D95D30C4B098D6464756E2164756E21