@nicnocquee/dataqueue 1.24.0 → 1.26.0

package/dist/index.cjs

@@ -1,1420 +0,0 @@
-'use strict';
-
-var async_hooks = require('async_hooks');
-var worker_threads = require('worker_threads');
-var pg = require('pg');
-var pgConnectionString = require('pg-connection-string');
-var fs = require('fs');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-
-// src/types.ts
-var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
-  JobEventType2["Added"] = "added";
-  JobEventType2["Processing"] = "processing";
-  JobEventType2["Completed"] = "completed";
-  JobEventType2["Failed"] = "failed";
-  JobEventType2["Cancelled"] = "cancelled";
-  JobEventType2["Retried"] = "retried";
-  JobEventType2["Edited"] = "edited";
-  return JobEventType2;
-})(JobEventType || {});
-var FailureReason = /* @__PURE__ */ ((FailureReason3) => {
-  FailureReason3["Timeout"] = "timeout";
-  FailureReason3["HandlerError"] = "handler_error";
-  FailureReason3["NoHandler"] = "no_handler";
-  return FailureReason3;
-})(FailureReason || {});
-var logStorage = new async_hooks.AsyncLocalStorage();
-var setLogContext = (verbose) => {
-  logStorage.enterWith({ verbose });
-};
-var getLogContext = () => {
-  return logStorage.getStore();
-};
-var log = (message) => {
-  const context = getLogContext();
-  if (context?.verbose) {
-    console.log(message);
-  }
-};
-
-// src/queue.ts
-var recordJobEvent = async (pool, jobId, eventType, metadata) => {
-  const client = await pool.connect();
-  try {
-    await client.query(
-      `INSERT INTO job_events (job_id, event_type, metadata) VALUES ($1, $2, $3)`,
-      [jobId, eventType, metadata ? JSON.stringify(metadata) : null]
-    );
-  } catch (error) {
-    log(`Error recording job event for job ${jobId}: ${error}`);
-  } finally {
-    client.release();
-  }
-};
-var addJob = async (pool, {
-  jobType,
-  payload,
-  maxAttempts = 3,
-  priority = 0,
-  runAt = null,
-  timeoutMs = void 0,
-  forceKillOnTimeout = false,
-  tags = void 0
-}) => {
-  const client = await pool.connect();
-  try {
-    let result;
-    if (runAt) {
-      result = await client.query(
-        `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
-         RETURNING id`,
-        [
-          jobType,
-          payload,
-          maxAttempts,
-          priority,
-          runAt,
-          timeoutMs ?? null,
-          forceKillOnTimeout ?? false,
-          tags ?? null
-        ]
-      );
-      log(
-        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, runAt ${runAt.toISOString()}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}, tags ${JSON.stringify(tags)}`
-      );
-    } else {
-      result = await client.query(
-        `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, timeout_ms, force_kill_on_timeout, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6, $7) 
-         RETURNING id`,
-        [
-          jobType,
-          payload,
-          maxAttempts,
-          priority,
-          timeoutMs ?? null,
-          forceKillOnTimeout ?? false,
-          tags ?? null
-        ]
-      );
-      log(
-        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}, tags ${JSON.stringify(tags)}`
-      );
-    }
-    await recordJobEvent(pool, result.rows[0].id, "added" /* Added */, {
-      jobType,
-      payload,
-      tags
-    });
-    return result.rows[0].id;
-  } catch (error) {
-    log(`Error adding job: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJob = async (pool, id) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags FROM job_queue WHERE id = $1`,
-      [id]
-    );
-    if (result.rows.length === 0) {
-      log(`Job ${id} not found`);
-      return null;
-    }
-    log(`Found job ${id}`);
-    const job = result.rows[0];
-    return {
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout,
-      failureReason: job.failureReason
-    };
-  } catch (error) {
-    log(`Error getting job ${id}: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJobsByStatus = async (pool, status, limit = 100, offset = 0) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
-      [status, limit, offset]
-    );
-    log(`Found ${result.rows.length} jobs by status ${status}`);
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout,
-      failureReason: job.failureReason
-    }));
-  } catch (error) {
-    log(`Error getting jobs by status ${status}: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getNextBatch = async (pool, workerId, batchSize = 10, jobType) => {
-  const client = await pool.connect();
-  try {
-    await client.query("BEGIN");
-    let jobTypeFilter = "";
-    let params = [workerId, batchSize];
-    if (jobType) {
-      if (Array.isArray(jobType)) {
-        jobTypeFilter = ` AND job_type = ANY($3)`;
-        params.push(jobType);
-      } else {
-        jobTypeFilter = ` AND job_type = $3`;
-        params.push(jobType);
-      }
-    }
-    const result = await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'processing', 
-          locked_at = NOW(), 
-          locked_by = $1,
-          attempts = attempts + 1,
-          updated_at = NOW(),
-          pending_reason = NULL,
-          started_at = COALESCE(started_at, NOW()),
-          last_retried_at = CASE WHEN attempts > 0 THEN NOW() ELSE last_retried_at END
-      WHERE id IN (
-        SELECT id FROM job_queue
-        WHERE (status = 'pending' OR (status = 'failed' AND next_attempt_at <= NOW()))
-        AND (attempts < max_attempts)
-        AND run_at <= NOW()
-        ${jobTypeFilter}
-        ORDER BY priority DESC, created_at ASC
-        LIMIT $2
-        FOR UPDATE SKIP LOCKED
-      )
-      RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason"
-    `,
-      params
-    );
-    log(`Found ${result.rows.length} jobs to process`);
-    await client.query("COMMIT");
-    for (const row of result.rows) {
-      await recordJobEvent(pool, row.id, "processing" /* Processing */);
-    }
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout
-    }));
-  } catch (error) {
-    log(`Error getting next batch: ${error}`);
-    await client.query("ROLLBACK");
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var completeJob = async (pool, jobId) => {
-  const client = await pool.connect();
-  try {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'completed', updated_at = NOW(), completed_at = NOW()
-      WHERE id = $1
-    `,
-      [jobId]
-    );
-    await recordJobEvent(pool, jobId, "completed" /* Completed */);
-  } catch (error) {
-    log(`Error completing job ${jobId}: ${error}`);
-    throw error;
-  } finally {
-    log(`Completed job ${jobId}`);
-    client.release();
-  }
-};
-var failJob = async (pool, jobId, error, failureReason) => {
-  const client = await pool.connect();
-  try {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'failed', 
-          updated_at = NOW(),
-          next_attempt_at = CASE 
-            WHEN attempts < max_attempts THEN NOW() + (POWER(2, attempts) * INTERVAL '1 minute')
-            ELSE NULL
-          END,
-          error_history = COALESCE(error_history, '[]'::jsonb) || $2::jsonb,
-          failure_reason = $3,
-          last_failed_at = NOW()
-      WHERE id = $1
-    `,
-      [
-        jobId,
-        JSON.stringify([
-          {
-            message: error.message || String(error),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        ]),
-        failureReason ?? null
-      ]
-    );
-    await recordJobEvent(pool, jobId, "failed" /* Failed */, {
-      message: error.message || String(error),
-      failureReason
-    });
-  } catch (error2) {
-    log(`Error failing job ${jobId}: ${error2}`);
-    throw error2;
-  } finally {
-    log(`Failed job ${jobId}`);
-    client.release();
-  }
-};
-var retryJob = async (pool, jobId) => {
-  const client = await pool.connect();
-  try {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'pending', 
-          updated_at = NOW(),
-          locked_at = NULL,
-          locked_by = NULL,
-          next_attempt_at = NOW(),
-          last_retried_at = NOW()
-      WHERE id = $1
-    `,
-      [jobId]
-    );
-    await recordJobEvent(pool, jobId, "retried" /* Retried */);
-  } catch (error) {
-    log(`Error retrying job ${jobId}: ${error}`);
-    throw error;
-  } finally {
-    log(`Retried job ${jobId}`);
-    client.release();
-  }
-};
-var cleanupOldJobs = async (pool, daysToKeep = 30) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`
-      DELETE FROM job_queue
-      WHERE status = 'completed'
-      AND updated_at < NOW() - INTERVAL '${daysToKeep} days'
-      RETURNING id
-    `);
-    log(`Deleted ${result.rowCount} old jobs`);
-    return result.rowCount || 0;
-  } catch (error) {
-    log(`Error cleaning up old jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var cancelJob = async (pool, jobId) => {
-  const client = await pool.connect();
-  try {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'cancelled', updated_at = NOW(), last_cancelled_at = NOW()
-      WHERE id = $1 AND status = 'pending'
-    `,
-      [jobId]
-    );
-    await recordJobEvent(pool, jobId, "cancelled" /* Cancelled */);
-  } catch (error) {
-    log(`Error cancelling job ${jobId}: ${error}`);
-    throw error;
-  } finally {
-    log(`Cancelled job ${jobId}`);
-    client.release();
-  }
-};
-var editJob = async (pool, jobId, updates) => {
-  const client = await pool.connect();
-  try {
-    const updateFields = [];
-    const params = [];
-    let paramIdx = 1;
-    if (updates.payload !== void 0) {
-      updateFields.push(`payload = $${paramIdx++}`);
-      params.push(updates.payload);
-    }
-    if (updates.maxAttempts !== void 0) {
-      updateFields.push(`max_attempts = $${paramIdx++}`);
-      params.push(updates.maxAttempts);
-    }
-    if (updates.priority !== void 0) {
-      updateFields.push(`priority = $${paramIdx++}`);
-      params.push(updates.priority);
-    }
-    if (updates.runAt !== void 0) {
-      if (updates.runAt === null) {
-        updateFields.push(`run_at = NOW()`);
-      } else {
-        updateFields.push(`run_at = $${paramIdx++}`);
-        params.push(updates.runAt);
-      }
-    }
-    if (updates.timeoutMs !== void 0) {
-      updateFields.push(`timeout_ms = $${paramIdx++}`);
-      params.push(updates.timeoutMs ?? null);
-    }
-    if (updates.tags !== void 0) {
-      updateFields.push(`tags = $${paramIdx++}`);
-      params.push(updates.tags ?? null);
-    }
-    if (updateFields.length === 0) {
-      log(`No fields to update for job ${jobId}`);
-      return;
-    }
-    updateFields.push(`updated_at = NOW()`);
-    params.push(jobId);
-    const query = `
-      UPDATE job_queue
-      SET ${updateFields.join(", ")}
-      WHERE id = $${paramIdx} AND status = 'pending'
-    `;
-    await client.query(query, params);
-    const metadata = {};
-    if (updates.payload !== void 0) metadata.payload = updates.payload;
-    if (updates.maxAttempts !== void 0)
-      metadata.maxAttempts = updates.maxAttempts;
-    if (updates.priority !== void 0) metadata.priority = updates.priority;
-    if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
-    if (updates.timeoutMs !== void 0) metadata.timeoutMs = updates.timeoutMs;
-    if (updates.tags !== void 0) metadata.tags = updates.tags;
-    await recordJobEvent(pool, jobId, "edited" /* Edited */, metadata);
-    log(`Edited job ${jobId}: ${JSON.stringify(metadata)}`);
-  } catch (error) {
-    log(`Error editing job ${jobId}: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var editAllPendingJobs = async (pool, filters = void 0, updates) => {
-  const client = await pool.connect();
-  try {
-    const updateFields = [];
-    const params = [];
-    let paramIdx = 1;
-    if (updates.payload !== void 0) {
-      updateFields.push(`payload = $${paramIdx++}`);
-      params.push(updates.payload);
-    }
-    if (updates.maxAttempts !== void 0) {
-      updateFields.push(`max_attempts = $${paramIdx++}`);
-      params.push(updates.maxAttempts);
-    }
-    if (updates.priority !== void 0) {
-      updateFields.push(`priority = $${paramIdx++}`);
-      params.push(updates.priority);
-    }
-    if (updates.runAt !== void 0) {
-      if (updates.runAt === null) {
-        updateFields.push(`run_at = NOW()`);
-      } else {
-        updateFields.push(`run_at = $${paramIdx++}`);
-        params.push(updates.runAt);
-      }
-    }
-    if (updates.timeoutMs !== void 0) {
-      updateFields.push(`timeout_ms = $${paramIdx++}`);
-      params.push(updates.timeoutMs ?? null);
-    }
-    if (updates.tags !== void 0) {
-      updateFields.push(`tags = $${paramIdx++}`);
-      params.push(updates.tags ?? null);
-    }
-    if (updateFields.length === 0) {
-      log(`No fields to update for batch edit`);
-      return 0;
-    }
-    updateFields.push(`updated_at = NOW()`);
-    let query = `
-      UPDATE job_queue
-      SET ${updateFields.join(", ")}
-      WHERE status = 'pending'`;
-    if (filters) {
-      if (filters.jobType) {
-        query += ` AND job_type = $${paramIdx++}`;
-        params.push(filters.jobType);
-      }
-      if (filters.priority !== void 0) {
-        query += ` AND priority = $${paramIdx++}`;
-        params.push(filters.priority);
-      }
-      if (filters.runAt) {
-        if (filters.runAt instanceof Date) {
-          query += ` AND run_at = $${paramIdx++}`;
-          params.push(filters.runAt);
-        } else if (typeof filters.runAt === "object") {
-          const ops = filters.runAt;
-          if (ops.gt) {
-            query += ` AND run_at > $${paramIdx++}`;
-            params.push(ops.gt);
-          }
-          if (ops.gte) {
-            query += ` AND run_at >= $${paramIdx++}`;
-            params.push(ops.gte);
-          }
-          if (ops.lt) {
-            query += ` AND run_at < $${paramIdx++}`;
-            params.push(ops.lt);
-          }
-          if (ops.lte) {
-            query += ` AND run_at <= $${paramIdx++}`;
-            params.push(ops.lte);
-          }
-          if (ops.eq) {
-            query += ` AND run_at = $${paramIdx++}`;
-            params.push(ops.eq);
-          }
-        }
-      }
-      if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
-        const mode = filters.tags.mode || "all";
-        const tagValues = filters.tags.values;
-        switch (mode) {
-          case "exact":
-            query += ` AND tags = $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "all":
-            query += ` AND tags @> $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "any":
-            query += ` AND tags && $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "none":
-            query += ` AND NOT (tags && $${paramIdx++})`;
-            params.push(tagValues);
-            break;
-          default:
-            query += ` AND tags @> $${paramIdx++}`;
-            params.push(tagValues);
-        }
-      }
-    }
-    query += "\nRETURNING id";
-    const result = await client.query(query, params);
-    const editedCount = result.rowCount || 0;
-    const metadata = {};
-    if (updates.payload !== void 0) metadata.payload = updates.payload;
-    if (updates.maxAttempts !== void 0)
-      metadata.maxAttempts = updates.maxAttempts;
-    if (updates.priority !== void 0) metadata.priority = updates.priority;
-    if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
-    if (updates.timeoutMs !== void 0) metadata.timeoutMs = updates.timeoutMs;
-    if (updates.tags !== void 0) metadata.tags = updates.tags;
-    for (const row of result.rows) {
-      await recordJobEvent(pool, row.id, "edited" /* Edited */, metadata);
-    }
-    log(`Edited ${editedCount} pending jobs: ${JSON.stringify(metadata)}`);
-    return editedCount;
-  } catch (error) {
-    log(`Error editing pending jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var cancelAllUpcomingJobs = async (pool, filters) => {
-  const client = await pool.connect();
-  try {
-    let query = `
-      UPDATE job_queue
-      SET status = 'cancelled', updated_at = NOW()
-      WHERE status = 'pending'`;
-    const params = [];
-    let paramIdx = 1;
-    if (filters) {
-      if (filters.jobType) {
-        query += ` AND job_type = $${paramIdx++}`;
-        params.push(filters.jobType);
-      }
-      if (filters.priority !== void 0) {
-        query += ` AND priority = $${paramIdx++}`;
-        params.push(filters.priority);
-      }
-      if (filters.runAt) {
-        if (filters.runAt instanceof Date) {
-          query += ` AND run_at = $${paramIdx++}`;
-          params.push(filters.runAt);
-        } else if (typeof filters.runAt === "object") {
-          const ops = filters.runAt;
-          if (ops.gt) {
-            query += ` AND run_at > $${paramIdx++}`;
-            params.push(ops.gt);
-          }
-          if (ops.gte) {
-            query += ` AND run_at >= $${paramIdx++}`;
-            params.push(ops.gte);
-          }
-          if (ops.lt) {
-            query += ` AND run_at < $${paramIdx++}`;
-            params.push(ops.lt);
-          }
-          if (ops.lte) {
-            query += ` AND run_at <= $${paramIdx++}`;
-            params.push(ops.lte);
-          }
-          if (ops.eq) {
-            query += ` AND run_at = $${paramIdx++}`;
-            params.push(ops.eq);
-          }
-        }
-      }
-      if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
-        const mode = filters.tags.mode || "all";
-        const tagValues = filters.tags.values;
-        switch (mode) {
-          case "exact":
-            query += ` AND tags = $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "all":
-            query += ` AND tags @> $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "any":
-            query += ` AND tags && $${paramIdx++}`;
-            params.push(tagValues);
-            break;
-          case "none":
-            query += ` AND NOT (tags && $${paramIdx++})`;
-            params.push(tagValues);
-            break;
-          default:
-            query += ` AND tags @> $${paramIdx++}`;
-            params.push(tagValues);
-        }
-      }
-    }
-    query += "\nRETURNING id";
-    const result = await client.query(query, params);
-    log(`Cancelled ${result.rowCount} jobs`);
-    return result.rowCount || 0;
-  } catch (error) {
-    log(`Error cancelling upcoming jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getAllJobs = async (pool, limit = 100, offset = 0) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
-      [limit, offset]
-    );
-    log(`Found ${result.rows.length} jobs (all)`);
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout
-    }));
-  } catch (error) {
-    log(`Error getting all jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var setPendingReasonForUnpickedJobs = async (pool, reason, jobType) => {
-  const client = await pool.connect();
-  try {
-    let jobTypeFilter = "";
-    let params = [reason];
-    if (jobType) {
-      if (Array.isArray(jobType)) {
-        jobTypeFilter = ` AND job_type = ANY($2)`;
-        params.push(jobType);
-      } else {
-        jobTypeFilter = ` AND job_type = $2`;
-        params.push(jobType);
-      }
-    }
-    await client.query(
-      `UPDATE job_queue SET pending_reason = $1 WHERE status = 'pending'${jobTypeFilter}`,
-      params
-    );
-  } finally {
-    client.release();
-  }
-};
-var reclaimStuckJobs = async (pool, maxProcessingTimeMinutes = 10) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'pending', locked_at = NULL, locked_by = NULL, updated_at = NOW()
-      WHERE status = 'processing'
-        AND locked_at < NOW() - INTERVAL '${maxProcessingTimeMinutes} minutes'
-      RETURNING id
-      `
-    );
-    log(`Reclaimed ${result.rowCount} stuck jobs`);
-    return result.rowCount || 0;
-  } catch (error) {
-    log(`Error reclaiming stuck jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJobEvents = async (pool, jobId) => {
-  const client = await pool.connect();
-  try {
-    const res = await client.query(
-      `SELECT id, job_id AS "jobId", event_type AS "eventType", metadata, created_at AS "createdAt" FROM job_events WHERE job_id = $1 ORDER BY created_at ASC`,
-      [jobId]
-    );
-    return res.rows;
-  } finally {
-    client.release();
-  }
-};
-var getJobsByTags = async (pool, tags, mode = "all", limit = 100, offset = 0) => {
-  const client = await pool.connect();
-  try {
-    let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags
-       FROM job_queue`;
-    let params = [];
-    switch (mode) {
-      case "exact":
-        query += " WHERE tags = $1";
-        params = [tags];
-        break;
-      case "all":
-        query += " WHERE tags @> $1";
-        params = [tags];
-        break;
-      case "any":
-        query += " WHERE tags && $1";
-        params = [tags];
-        break;
-      case "none":
-        query += " WHERE NOT (tags && $1)";
-        params = [tags];
-        break;
-      default:
-        query += " WHERE tags @> $1";
-        params = [tags];
-    }
-    query += " ORDER BY created_at DESC LIMIT $2 OFFSET $3";
-    params.push(limit, offset);
-    const result = await client.query(query, params);
-    log(
-      `Found ${result.rows.length} jobs by tags ${JSON.stringify(tags)} (mode: ${mode})`
-    );
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout,
-      failureReason: job.failureReason
-    }));
-  } catch (error) {
-    log(
-      `Error getting jobs by tags ${JSON.stringify(tags)} (mode: ${mode}): ${error}`
-    );
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJobs = async (pool, filters, limit = 100, offset = 0) => {
-  const client = await pool.connect();
-  try {
-    let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags FROM job_queue`;
-    const params = [];
-    let where = [];
-    let paramIdx = 1;
-    if (filters) {
-      if (filters.jobType) {
-        where.push(`job_type = $${paramIdx++}`);
-        params.push(filters.jobType);
-      }
-      if (filters.priority !== void 0) {
-        where.push(`priority = $${paramIdx++}`);
-        params.push(filters.priority);
-      }
-      if (filters.runAt) {
-        if (filters.runAt instanceof Date) {
-          where.push(`run_at = $${paramIdx++}`);
-          params.push(filters.runAt);
-        } else if (typeof filters.runAt === "object" && (filters.runAt.gt !== void 0 || filters.runAt.gte !== void 0 || filters.runAt.lt !== void 0 || filters.runAt.lte !== void 0 || filters.runAt.eq !== void 0)) {
-          const ops = filters.runAt;
-          if (ops.gt) {
-            where.push(`run_at > $${paramIdx++}`);
-            params.push(ops.gt);
-          }
-          if (ops.gte) {
-            where.push(`run_at >= $${paramIdx++}`);
-            params.push(ops.gte);
-          }
-          if (ops.lt) {
-            where.push(`run_at < $${paramIdx++}`);
-            params.push(ops.lt);
-          }
-          if (ops.lte) {
-            where.push(`run_at <= $${paramIdx++}`);
-            params.push(ops.lte);
-          }
-          if (ops.eq) {
-            where.push(`run_at = $${paramIdx++}`);
-            params.push(ops.eq);
-          }
-        }
-      }
-      if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
-        const mode = filters.tags.mode || "all";
-        const tagValues = filters.tags.values;
-        switch (mode) {
-          case "exact":
-            where.push(`tags = $${paramIdx++}`);
-            params.push(tagValues);
-            break;
-          case "all":
-            where.push(`tags @> $${paramIdx++}`);
-            params.push(tagValues);
-            break;
-          case "any":
-            where.push(`tags && $${paramIdx++}`);
-            params.push(tagValues);
-            break;
-          case "none":
-            where.push(`NOT (tags && $${paramIdx++})`);
-            params.push(tagValues);
-            break;
-          default:
-            where.push(`tags @> $${paramIdx++}`);
-            params.push(tagValues);
-        }
-      }
-    }
-    if (where.length > 0) {
-      query += ` WHERE ${where.join(" AND ")}`;
-    }
-    paramIdx = params.length + 1;
-    query += ` ORDER BY created_at DESC LIMIT $${paramIdx++} OFFSET $${paramIdx}`;
-    params.push(limit, offset);
-    const result = await client.query(query, params);
-    log(`Found ${result.rows.length} jobs`);
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      forceKillOnTimeout: job.forceKillOnTimeout,
-      failureReason: job.failureReason
-    }));
-  } catch (error) {
-    log(`Error getting jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-function validateHandlerSerializable(handler, jobType) {
-  try {
-    const handlerString = handler.toString();
-    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
-      throw new Error(
-        `Handler for job type "${jobType}" uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
-      );
-    }
-    if (handlerString.includes("[native code]")) {
-      throw new Error(
-        `Handler for job type "${jobType}" contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
-      );
-    }
-    try {
-      new Function("return " + handlerString);
-    } catch (parseError) {
-      throw new Error(
-        `Handler for job type "${jobType}" cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
-      );
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-    throw new Error(
-      `Failed to validate handler serialization for job type "${jobType}": ${String(error)}`
-    );
-  }
-}
-async function runHandlerInWorker(handler, payload, timeoutMs, jobType) {
-  validateHandlerSerializable(handler, jobType);
-  return new Promise((resolve, reject) => {
-    const workerCode = `
-      (function() {
-        const { parentPort, workerData } = require('worker_threads');
-        const { handlerCode, payload, timeoutMs } = workerData;
-        
-        // Create an AbortController for the handler
-        const controller = new AbortController();
-        const signal = controller.signal;
-        
-        // Set up timeout
-        const timeoutId = setTimeout(() => {
-          controller.abort();
-          parentPort.postMessage({ type: 'timeout' });
-        }, timeoutMs);
-        
-        try {
-          // Execute the handler
-          // Note: This uses Function constructor which requires the handler to be serializable.
-          // The handler should be validated before reaching this point.
-          let handlerFn;
-          try {
-            // Wrap handlerCode in parentheses to ensure it's treated as an expression
-            // This handles both arrow functions and regular functions
-            const wrappedCode = handlerCode.trim().startsWith('async') || handlerCode.trim().startsWith('function')
-              ? handlerCode
-              : '(' + handlerCode + ')';
-            handlerFn = new Function('return ' + wrappedCode)();
-          } catch (parseError) {
-            clearTimeout(timeoutId);
-            parentPort.postMessage({
-              type: 'error',
-              error: {
-                message: 'Handler cannot be deserialized in worker thread. ' +
-                  'Ensure your handler is a standalone function without closures over external variables. ' +
-                  'Original error: ' + (parseError instanceof Error ? parseError.message : String(parseError)),
-                stack: parseError instanceof Error ? parseError.stack : undefined,
-                name: 'SerializationError',
-              },
-            });
-            return;
-          }
-          
-          // Ensure handlerFn is actually a function
-          if (typeof handlerFn !== 'function') {
-            clearTimeout(timeoutId);
-            parentPort.postMessage({
-              type: 'error',
-              error: {
-                message: 'Handler deserialization did not produce a function. ' +
-                  'Ensure your handler is a valid function when forceKillOnTimeout is enabled.',
-                name: 'SerializationError',
-              },
-            });
-            return;
-          }
-          
-          handlerFn(payload, signal)
-            .then(() => {
-              clearTimeout(timeoutId);
-              parentPort.postMessage({ type: 'success' });
-            })
-            .catch((error) => {
-              clearTimeout(timeoutId);
-              parentPort.postMessage({
-                type: 'error',
-                error: {
-                  message: error.message,
-                  stack: error.stack,
-                  name: error.name,
-                },
-              });
-            });
-        } catch (error) {
-          clearTimeout(timeoutId);
-          parentPort.postMessage({
-            type: 'error',
-            error: {
-              message: error.message,
-              stack: error.stack,
-              name: error.name,
-            },
-          });
-        }
-      })();
-    `;
-    const worker = new worker_threads.Worker(workerCode, {
-      eval: true,
-      workerData: {
-        handlerCode: handler.toString(),
-        payload,
-        timeoutMs
-      }
-    });
-    let resolved = false;
-    worker.on("message", (message) => {
-      if (resolved) return;
-      resolved = true;
-      if (message.type === "success") {
-        resolve();
-      } else if (message.type === "timeout") {
-        const timeoutError = new Error(
-          `Job timed out after ${timeoutMs} ms and was forcefully terminated`
-        );
-        timeoutError.failureReason = "timeout" /* Timeout */;
-        reject(timeoutError);
-      } else if (message.type === "error") {
-        const error = new Error(message.error.message);
-        error.stack = message.error.stack;
-        error.name = message.error.name;
-        reject(error);
-      }
-    });
-    worker.on("error", (error) => {
-      if (resolved) return;
-      resolved = true;
-      reject(error);
-    });
-    worker.on("exit", (code) => {
-      if (resolved) return;
-      if (code !== 0) {
-        resolved = true;
-        reject(new Error(`Worker stopped with exit code ${code}`));
-      }
-    });
-    setTimeout(() => {
-      if (!resolved) {
-        resolved = true;
-        worker.terminate().then(() => {
-          const timeoutError = new Error(
-            `Job timed out after ${timeoutMs} ms and was forcefully terminated`
-          );
-          timeoutError.failureReason = "timeout" /* Timeout */;
-          reject(timeoutError);
-        }).catch((err) => {
-          reject(err);
-        });
-      }
-    }, timeoutMs + 100);
-  });
-}
-async function processJobWithHandlers(pool, job, jobHandlers) {
-  const handler = jobHandlers[job.jobType];
-  if (!handler) {
-    await setPendingReasonForUnpickedJobs(
-      pool,
-      `No handler registered for job type: ${job.jobType}`,
-      job.jobType
-    );
-    await failJob(
-      pool,
-      job.id,
-      new Error(`No handler registered for job type: ${job.jobType}`),
-      "no_handler" /* NoHandler */
-    );
-    return;
-  }
-  const timeoutMs = job.timeoutMs ?? void 0;
-  const forceKillOnTimeout = job.forceKillOnTimeout ?? false;
-  let timeoutId;
-  const controller = new AbortController();
-  try {
-    if (forceKillOnTimeout && timeoutMs && timeoutMs > 0) {
-      await runHandlerInWorker(handler, job.payload, timeoutMs, job.jobType);
-    } else {
-      const jobPromise = handler(job.payload, controller.signal);
-      if (timeoutMs && timeoutMs > 0) {
-        await Promise.race([
-          jobPromise,
-          new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-              controller.abort();
-              const timeoutError = new Error(
-                `Job timed out after ${timeoutMs} ms`
-              );
-              timeoutError.failureReason = "timeout" /* Timeout */;
-              reject(timeoutError);
-            }, timeoutMs);
-          })
-        ]);
-      } else {
-        await jobPromise;
-      }
-    }
-    if (timeoutId) clearTimeout(timeoutId);
-    await completeJob(pool, job.id);
-  } catch (error) {
-    if (timeoutId) clearTimeout(timeoutId);
-    console.error(`Error processing job ${job.id}:`, error);
-    let failureReason = "handler_error" /* HandlerError */;
-    if (error && typeof error === "object" && "failureReason" in error && error.failureReason === "timeout" /* Timeout */) {
-      failureReason = "timeout" /* Timeout */;
-    }
-    await failJob(
-      pool,
-      job.id,
-      error instanceof Error ? error : new Error(String(error)),
-      failureReason
-    );
-  }
-}
-async function processBatchWithHandlers(pool, workerId, batchSize, jobType, jobHandlers, concurrency) {
-  const jobs = await getNextBatch(
-    pool,
-    workerId,
-    batchSize,
-    jobType
-  );
-  if (!concurrency || concurrency >= jobs.length) {
-    await Promise.all(
-      jobs.map((job) => processJobWithHandlers(pool, job, jobHandlers))
-    );
-    return jobs.length;
-  }
-  let idx = 0;
-  let running = 0;
-  let finished = 0;
-  return new Promise((resolve, reject) => {
-    const next = () => {
-      if (finished === jobs.length) return resolve(jobs.length);
-      while (running < concurrency && idx < jobs.length) {
-        const job = jobs[idx++];
-        running++;
-        processJobWithHandlers(pool, job, jobHandlers).then(() => {
-          running--;
-          finished++;
-          next();
-        }).catch((err) => {
-          running--;
-          finished++;
-          next();
-        });
-      }
-    };
-    next();
-  });
-}
-var createProcessor = (pool, handlers, options = {}) => {
-  const {
-    workerId = `worker-${Math.random().toString(36).substring(2, 9)}`,
-    batchSize = 10,
-    pollInterval = 5e3,
-    onError = (error) => console.error("Job processor error:", error),
-    jobType,
-    concurrency = 3
-  } = options;
-  let running = false;
-  let intervalId = null;
-  setLogContext(options.verbose ?? false);
-  const processJobs = async () => {
-    if (!running) return 0;
-    log(
-      `Processing jobs with workerId: ${workerId}${jobType ? ` and jobType: ${Array.isArray(jobType) ? jobType.join(",") : jobType}` : ""}`
-    );
-    try {
-      const processed = await processBatchWithHandlers(
-        pool,
-        workerId,
-        batchSize,
-        jobType,
-        handlers,
-        concurrency
-      );
-      return processed;
-    } catch (error) {
-      onError(error instanceof Error ? error : new Error(String(error)));
-    }
-    return 0;
-  };
-  return {
-    /**
-     * Start the job processor in the background.
-     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs as they become available.
-     * - You have to call the stop method to stop the processor.
-     */
-    startInBackground: () => {
-      if (running) return;
-      log(`Starting job processor with workerId: ${workerId}`);
-      running = true;
-      const processBatches = async () => {
-        if (!running) return;
-        const processed = await processJobs();
-        if (processed === batchSize && running) {
-          setImmediate(processBatches);
-        }
-      };
-      processBatches();
-      intervalId = setInterval(processJobs, pollInterval);
-    },
-    /**
-     * Stop the job processor that runs in the background
-     */
-    stop: () => {
-      log(`Stopping job processor with workerId: ${workerId}`);
-      running = false;
-      if (intervalId) {
-        clearInterval(intervalId);
-        intervalId = null;
-      }
-    },
-    /**
-     * Start the job processor synchronously.
-     * - This will process all jobs immediately and then stop.
-     * - The pollInterval is ignored.
-     */
-    start: async () => {
-      log(`Starting job processor with workerId: ${workerId}`);
-      running = true;
-      const processed = await processJobs();
-      running = false;
-      return processed;
-    },
-    isRunning: () => running
-  };
-};
-function loadPemOrFile(value) {
-  if (!value) return void 0;
-  if (value.startsWith("file://")) {
-    const filePath = value.slice(7);
-    return fs__default.default.readFileSync(filePath, "utf8");
-  }
-  return value;
-}
-var createPool = (config) => {
-  let searchPath;
-  let ssl = void 0;
-  let customCA;
-  let sslmode;
-  if (config.connectionString) {
-    try {
-      const url = new URL(config.connectionString);
-      searchPath = url.searchParams.get("search_path") || void 0;
-      sslmode = url.searchParams.get("sslmode") || void 0;
-      if (sslmode === "no-verify") {
-        ssl = { rejectUnauthorized: false };
-      }
-    } catch (e) {
-      const parsed = pgConnectionString.parse(config.connectionString);
-      if (parsed.options) {
-        const match = parsed.options.match(/search_path=([^\s]+)/);
-        if (match) {
-          searchPath = match[1];
-        }
-      }
-      sslmode = typeof parsed.sslmode === "string" ? parsed.sslmode : void 0;
-      if (sslmode === "no-verify") {
-        ssl = { rejectUnauthorized: false };
-      }
-    }
-  }
-  if (config.ssl) {
-    if (typeof config.ssl.ca === "string") {
-      customCA = config.ssl.ca;
-    } else if (typeof process.env.PGSSLROOTCERT === "string") {
-      customCA = process.env.PGSSLROOTCERT;
-    } else {
-      customCA = void 0;
-    }
-    const caValue = typeof customCA === "string" ? loadPemOrFile(customCA) : void 0;
-    ssl = {
-      ...ssl,
-      ...caValue ? { ca: caValue } : {},
-      cert: loadPemOrFile(
-        typeof config.ssl.cert === "string" ? config.ssl.cert : process.env.PGSSLCERT
-      ),
-      key: loadPemOrFile(
-        typeof config.ssl.key === "string" ? config.ssl.key : process.env.PGSSLKEY
-      ),
-      rejectUnauthorized: config.ssl.rejectUnauthorized !== void 0 ? config.ssl.rejectUnauthorized : true
-    };
-  }
-  if (sslmode && customCA) {
-    const warning = `
-
-\x1B[33m**************************************************
-\u26A0\uFE0F  WARNING: SSL CONFIGURATION ISSUE
-**************************************************
-Both sslmode ('${sslmode}') is set in the connection string
-and a custom CA is provided (via config.ssl.ca or PGSSLROOTCERT).
-This combination may cause connection failures or unexpected behavior.
-
-Recommended: Remove sslmode from the connection string when using a custom CA.
-**************************************************\x1B[0m
-`;
-    console.warn(warning);
-  }
-  const pool = new pg.Pool({
-    ...config,
-    ...ssl ? { ssl } : {}
-  });
-  if (searchPath) {
-    pool.on("connect", (client) => {
-      client.query(`SET search_path TO ${searchPath}`);
-    });
-  }
-  return pool;
-};
-
-// src/handler-validation.ts
-function validateHandlerSerializable2(handler, jobType) {
-  try {
-    const handlerString = handler.toString();
-    const typeLabel = jobType ? `job type "${jobType}"` : "handler";
-    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
-      return {
-        isSerializable: false,
-        error: `Handler for ${typeLabel} uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
-      };
-    }
-    if (handlerString.includes("[native code]")) {
-      return {
-        isSerializable: false,
-        error: `Handler for ${typeLabel} contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
-      };
-    }
-    try {
-      new Function("return " + handlerString);
-    } catch (parseError) {
-      return {
-        isSerializable: false,
-        error: `Handler for ${typeLabel} cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
-      };
-    }
-    const hasPotentialClosure = /const\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString) || /let\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString);
-    if (hasPotentialClosure) {
-      return {
-        isSerializable: true,
-        // Still serializable, but might have issues
-        error: `Warning: Handler for ${typeLabel} may have closures over external variables. Test thoroughly with forceKillOnTimeout enabled. If the handler fails to execute in a worker thread, ensure all dependencies are imported within the handler function.`
-      };
-    }
-    return { isSerializable: true };
-  } catch (error) {
-    return {
-      isSerializable: false,
-      error: `Failed to validate handler serialization${jobType ? ` for job type "${jobType}"` : ""}: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-async function testHandlerSerialization(handler, jobType) {
-  const basicValidation = validateHandlerSerializable2(handler, jobType);
-  if (!basicValidation.isSerializable) {
-    return basicValidation;
-  }
-  try {
-    const handlerString = handler.toString();
-    const handlerFn = new Function("return " + handlerString)();
-    const testPromise = handlerFn({}, new AbortController().signal);
-    const timeoutPromise = new Promise(
-      (_, reject) => setTimeout(() => reject(new Error("Handler test timeout")), 100)
-    );
-    try {
-      await Promise.race([testPromise, timeoutPromise]);
-    } catch (execError) {
-      if (execError instanceof Error && execError.message === "Handler test timeout") {
-        return { isSerializable: true };
-      }
-    }
-    return { isSerializable: true };
-  } catch (error) {
-    return {
-      isSerializable: false,
-      error: `Handler failed serialization test: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-
-// src/index.ts
-var initJobQueue = (config) => {
-  const { databaseConfig } = config;
-  const pool = createPool(databaseConfig);
-  setLogContext(config.verbose ?? false);
-  return {
-    // Job queue operations
-    addJob: withLogContext(
-      (job) => addJob(pool, job),
-      config.verbose ?? false
-    ),
-    getJob: withLogContext(
-      (id) => getJob(pool, id),
-      config.verbose ?? false
-    ),
-    getJobsByStatus: withLogContext(
-      (status, limit, offset) => getJobsByStatus(pool, status, limit, offset),
-      config.verbose ?? false
-    ),
-    getAllJobs: withLogContext(
-      (limit, offset) => getAllJobs(pool, limit, offset),
-      config.verbose ?? false
-    ),
-    getJobs: withLogContext(
-      (filters, limit, offset) => getJobs(pool, filters, limit, offset),
-      config.verbose ?? false
-    ),
-    retryJob: (jobId) => retryJob(pool, jobId),
-    cleanupOldJobs: (daysToKeep) => cleanupOldJobs(pool, daysToKeep),
-    cancelJob: withLogContext(
-      (jobId) => cancelJob(pool, jobId),
-      config.verbose ?? false
-    ),
-    editJob: withLogContext(
-      (jobId, updates) => editJob(pool, jobId, updates),
-      config.verbose ?? false
-    ),
-    editAllPendingJobs: withLogContext(
-      (filters, updates) => editAllPendingJobs(pool, filters, updates),
-      config.verbose ?? false
-    ),
-    cancelAllUpcomingJobs: withLogContext(
-      (filters) => cancelAllUpcomingJobs(pool, filters),
-      config.verbose ?? false
-    ),
-    reclaimStuckJobs: withLogContext(
-      (maxProcessingTimeMinutes) => reclaimStuckJobs(pool, maxProcessingTimeMinutes),
-      config.verbose ?? false
-    ),
-    getJobsByTags: withLogContext(
-      (tags, mode = "all", limit, offset) => getJobsByTags(pool, tags, mode, limit, offset),
-      config.verbose ?? false
-    ),
-    // Job processing
-    createProcessor: (handlers, options) => createProcessor(pool, handlers, options),
-    // Advanced access (for custom operations)
-    getPool: () => pool,
-    // Job events
-    getJobEvents: withLogContext(
-      (jobId) => getJobEvents(pool, jobId),
-      config.verbose ?? false
-    )
-  };
-};
-var withLogContext = (fn, verbose) => (...args) => {
-  setLogContext(verbose);
-  return fn(...args);
-};
-
-exports.FailureReason = FailureReason;
-exports.JobEventType = JobEventType;
-exports.initJobQueue = initJobQueue;
-exports.testHandlerSerialization = testHandlerSerialization;
-exports.validateHandlerSerializable = validateHandlerSerializable2;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map