@valentinkolb/sync 0.1.0 → 1.0.2

package/index.js

@@ -0,0 +1,1059 @@
+// @bun
+// src/ratelimit.ts
+var {redis } = globalThis.Bun;
+import { createHash } from "crypto";
+
+class RateLimitError extends Error {
+  remaining;
+  resetIn;
+  constructor(result) {
+    super("Rate limit exceeded");
+    this.name = "RateLimitError";
+    this.remaining = result.remaining;
+    this.resetIn = result.resetIn;
+  }
+}
+var RATE_LIMIT_SCRIPT = `
+  local currentKey = KEYS[1]
+  local previousKey = KEYS[2]
+  local windowSecs = tonumber(ARGV[1])
+  local limit = tonumber(ARGV[2])
+  local elapsedRatio = tonumber(ARGV[3])
+
+  -- Get previous window count
+  local previousCount = tonumber(redis.call("GET", previousKey) or "0")
+
+  -- Increment current window and set expiry atomically
+  local currentCount = redis.call("INCR", currentKey)
+  if currentCount == 1 then
+    redis.call("EXPIRE", currentKey, windowSecs * 2)
+  end
+
+  -- Calculate weighted count
+  local weightedCount = previousCount * (1 - elapsedRatio) + currentCount
+
+  return {currentCount, previousCount, weightedCount}
+`;
+var MAX_IDENTIFIER_LENGTH = 128;
+var normalizeIdentifier = (identifier) => {
+  if (identifier.length <= MAX_IDENTIFIER_LENGTH)
+    return identifier;
+  const hash = createHash("sha256").update(identifier).digest("hex");
+  return `hash:${hash}`;
+};
+var create = (config) => {
+  const { limit, windowSecs = 1, prefix = "ratelimit" } = config;
+  const check = async (identifier) => {
+    const safeIdentifier = normalizeIdentifier(identifier);
+    const now = Date.now();
+    const windowMs = windowSecs * 1000;
+    const currentWindow = Math.floor(now / windowMs);
+    const previousWindow = currentWindow - 1;
+    const elapsedInWindow = now % windowMs;
+    const elapsedRatio = elapsedInWindow / windowMs;
+    const currentKey = `${prefix}:${safeIdentifier}:${currentWindow}`;
+    const previousKey = `${prefix}:${safeIdentifier}:${previousWindow}`;
+    const result = await redis.send("EVAL", [
+      RATE_LIMIT_SCRIPT,
+      "2",
+      currentKey,
+      previousKey,
+      windowSecs.toString(),
+      limit.toString(),
+      elapsedRatio.toString()
+    ]);
+    const [, , weightedCount] = result;
+    const limited = weightedCount > limit;
+    const remaining = Math.max(0, Math.floor(limit - weightedCount));
+    const resetIn = windowMs - elapsedInWindow;
+    return { limited, remaining, resetIn };
+  };
+  const checkOrThrow = async (identifier) => {
+    const result = await check(identifier);
+    if (result.limited) {
+      throw new RateLimitError(result);
+    }
+    return result;
+  };
+  return { check, checkOrThrow };
+};
+var ratelimit = { create, RateLimitError };
+// src/mutex.ts
+var {redis: redis2, sleep } = globalThis.Bun;
+import { createHash as createHash2, randomBytes } from "crypto";
+var DEFAULT_RETRY_COUNT = 10;
+var DEFAULT_RETRY_DELAY = 200;
+var DEFAULT_TTL = 1e4;
+var MAX_RESOURCE_LENGTH = 128;
+var normalizeResource = (resource) => {
+  if (resource.length <= MAX_RESOURCE_LENGTH)
+    return resource;
+  const hash = createHash2("sha256").update(resource).digest("hex");
+  return `hash:${hash}`;
+};
+
+class LockError extends Error {
+  resource;
+  constructor(resource) {
+    super(`Failed to acquire lock on resource: ${resource}`);
+    this.name = "LockError";
+    this.resource = resource;
+  }
+}
+var create2 = (config = {}) => {
+  const {
+    prefix = "mutex",
+    retryCount = DEFAULT_RETRY_COUNT,
+    retryDelay = DEFAULT_RETRY_DELAY,
+    defaultTtl = DEFAULT_TTL
+  } = config;
+  const acquire = async (resource, ttl = defaultTtl) => {
+    const safeResource = normalizeResource(resource);
+    const key = `${prefix}:${safeResource}`;
+    const value = randomBytes(16).toString("hex");
+    for (let attempt = 0;attempt <= retryCount; attempt++) {
+      try {
+        const result = await redis2.send("SET", [key, value, "NX", "PX", ttl.toString()]);
+        if (result === "OK") {
+          return {
+            resource: key,
+            value,
+            ttl,
+            expiration: Date.now() + ttl
+          };
+        }
+      } catch (error) {
+        console.error(`Lock acquire attempt ${attempt} failed:`, error);
+      }
+      if (attempt < retryCount) {
+        await sleep(retryDelay + Math.random() * 100);
+      }
+    }
+    return null;
+  };
+  const release = async (lock) => {
+    try {
+      const releaseScript = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+      await redis2.send("EVAL", [releaseScript, "1", lock.resource, lock.value]);
+    } catch (error) {
+      console.error("Error releasing lock:", error);
+    }
+  };
+  const extend = async (lock, ttl = defaultTtl) => {
+    try {
+      const extendScript = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("pexpire", KEYS[1], ARGV[2])
+        else
+          return 0
+        end
+      `;
+      const result = await redis2.send("EVAL", [extendScript, "1", lock.resource, lock.value, ttl.toString()]);
+      if (result === 1) {
+        lock.ttl = ttl;
+        lock.expiration = Date.now() + ttl;
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error extending lock:", error);
+      return false;
+    }
+  };
+  const withLock = async (resource, fn, ttl) => {
+    const lock = await acquire(resource, ttl);
+    if (!lock)
+      return null;
+    try {
+      return await fn(lock);
+    } finally {
+      await release(lock);
+    }
+  };
+  const withLockOrThrow = async (resource, fn, ttl) => {
+    const lock = await acquire(resource, ttl);
+    if (!lock) {
+      throw new LockError(resource);
+    }
+    try {
+      return await fn(lock);
+    } finally {
+      await release(lock);
+    }
+  };
+  return { acquire, release, withLock, withLockOrThrow, extend };
+};
+var mutex = { create: create2 };
+// src/jobs.ts
+var {redis: redis3, RedisClient, sleep: sleep2 } = globalThis.Bun;
+import { randomBytes as randomBytes2 } from "crypto";
+var DEFAULT_TIMEOUT = 30000;
+var DEFAULT_RETRIES = 0;
+var DEFAULT_POLL_INTERVAL = 1000;
+var DEFAULT_CONCURRENCY = 1;
+
+class JobsError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "JobsError";
+    this.code = code;
+  }
+}
+
+class ValidationError extends JobsError {
+  issues;
+  constructor(issues) {
+    super("Job data validation failed", "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.issues = issues;
+  }
+}
+
+class DuplicateJobError extends JobsError {
+  key;
+  constructor(key) {
+    super(`Job with key "${key}" already exists`, "DUPLICATE_JOB");
+    this.name = "DuplicateJobError";
+    this.key = key;
+  }
+}
+var CLAIM_JOB_BY_ID_SCRIPT = `
+  local jobId = ARGV[1]
+  local jobData = redis.call("HGET", KEYS[1], jobId)
+  if not jobData then
+    redis.call("LREM", KEYS[2], 1, jobId)
+    return nil
+  end
+
+  local ok, job = pcall(cjson.decode, jobData)
+  if not ok then
+    local now = tonumber(ARGV[2])
+    local failedJob = {
+      id = jobId,
+      data = cjson.null,
+      status = "failed",
+      attempts = 1,
+      maxRetries = 0,
+      timeout = 0,
+      createdAt = now,
+      completedAt = now,
+      error = "Invalid job payload in Redis",
+      invalidData = true
+    }
+
+    redis.call("LREM", KEYS[2], 1, jobId)
+    redis.call("HSET", KEYS[1], jobId, cjson.encode(failedJob))
+    redis.call("SADD", KEYS[4], jobId)
+
+    return {jobId, cjson.encode(failedJob), "invalid"}
+  end
+
+  job.status = "active"
+  job.startedAt = tonumber(ARGV[2])
+  job.attempts = job.attempts + 1
+
+  redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+
+  local deadline = tonumber(ARGV[2]) + job.timeout
+  redis.call("ZADD", KEYS[3], deadline, jobId)
+
+  return {jobId, cjson.encode(job)}
+`;
+var COMPLETE_JOB_SCRIPT = `
+  local jobId = ARGV[1]
+  local completedAt = tonumber(ARGV[2])
+
+  local jobData = redis.call("HGET", KEYS[1], jobId)
+  if not jobData then
+    return 0
+  end
+
+  local job = cjson.decode(jobData)
+
+  redis.call("LREM", KEYS[2], 1, jobId)
+  redis.call("ZREM", KEYS[4], jobId)
+
+  -- If job has interval, reschedule it (keep unique key active)
+  if job.interval and job.interval > 0 then
+    job.status = "delayed"
+    job.attempts = 0
+    job.error = cjson.null
+    job.startedAt = cjson.null
+    job.completedAt = cjson.null
+    job.scheduledAt = completedAt + job.interval
+
+    redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+    redis.call("ZADD", KEYS[5], job.scheduledAt, jobId)
+    return 2
+  else
+    job.status = "completed"
+    job.completedAt = completedAt
+
+    redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+    redis.call("SADD", KEYS[3], jobId)
+
+    -- Release unique key
+    if job.key then
+      redis.call("HDEL", KEYS[6], job.key)
+    end
+
+    return 1
+  end
+`;
+var FAIL_OR_RETRY_SCRIPT = `
+  local jobId = ARGV[1]
+  local errorMsg = ARGV[2]
+  local completedAt = tonumber(ARGV[3])
+
+  local jobData = redis.call("HGET", KEYS[1], jobId)
+  if not jobData then
+    return 0
+  end
+
+  local job = cjson.decode(jobData)
+  job.error = errorMsg
+
+  redis.call("LREM", KEYS[2], 1, jobId)
+  redis.call("ZREM", KEYS[5], jobId)
+
+  -- Check if we can retry (attempts <= maxRetries means 1 initial + N retries)
+  if job.attempts <= job.maxRetries then
+    -- Check for backoff
+    if job.backoff and job.backoff > 0 then
+      -- Exponential backoff: backoff * 2^(attempts-1)
+      local delay = job.backoff * math.pow(2, job.attempts - 1)
+      job.status = "delayed"
+      job.scheduledAt = completedAt + delay
+      redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+      redis.call("ZADD", KEYS[6], job.scheduledAt, jobId)
+      return 4
+    else
+      job.status = "waiting"
+      redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+      redis.call("LPUSH", KEYS[3], jobId)
+      return 1
+    end
+  end
+
+  -- No more retries - check if interval job should be rescheduled
+  if job.interval and job.interval > 0 then
+    job.status = "delayed"
+    job.attempts = 0
+    job.startedAt = cjson.null
+    job.scheduledAt = completedAt + job.interval
+    redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+    redis.call("ZADD", KEYS[6], job.scheduledAt, jobId)
+    return 3
+  end
+
+  -- Permanent failure
+  job.status = "failed"
+  job.completedAt = completedAt
+  redis.call("HSET", KEYS[1], jobId, cjson.encode(job))
+  redis.call("SADD", KEYS[4], jobId)
+
+  -- Release unique key
+  if job.key then
+    redis.call("HDEL", KEYS[7], job.key)
+  end
+
+  return 2
+`;
+var FAIL_TIMED_OUT_SCRIPT = `
+  local now = tonumber(ARGV[1])
+
+  local timedOutJobs = redis.call("ZRANGEBYSCORE", KEYS[1], "0", tostring(now))
+  local failed = 0
+
+  for _, jobId in ipairs(timedOutJobs) do
+    local jobData = redis.call("HGET", KEYS[2], jobId)
+    if jobData then
+      local job = cjson.decode(jobData)
+
+      redis.call("ZREM", KEYS[1], jobId)
+      redis.call("LREM", KEYS[3], 0, jobId)
+
+      job.status = "failed"
+      job.completedAt = now
+      job.error = "Job timed out"
+      redis.call("HSET", KEYS[2], jobId, cjson.encode(job))
+      redis.call("SADD", KEYS[4], jobId)
+
+      -- Release unique key
+      if job.key then
+        redis.call("HDEL", KEYS[5], job.key)
+      end
+
+      failed = failed + 1
+    else
+      redis.call("ZREM", KEYS[1], jobId)
+    end
+  end
+
+  return failed
+`;
+var RECOVER_ACTIVE_JOBS_SCRIPT = `
+  local now = tonumber(ARGV[1])
+  local activeJobs = redis.call("LRANGE", KEYS[1], 0, -1)
+  local recovered = 0
+
+  for _, jobId in ipairs(activeJobs) do
+    local jobData = redis.call("HGET", KEYS[2], jobId)
+    if jobData then
+      local job = cjson.decode(jobData)
+      local startedAt = tonumber(job.startedAt) or 0
+      local timeout = tonumber(job.timeout) or 30000
+
+      if startedAt > 0 and (startedAt + timeout) < now then
+        redis.call("LREM", KEYS[1], 1, jobId)
+        redis.call("ZREM", KEYS[3], jobId)
+        job.error = "Recovered after worker failure"
+
+        if job.attempts <= job.maxRetries then
+          job.status = "waiting"
+          redis.call("HSET", KEYS[2], jobId, cjson.encode(job))
+          redis.call("LPUSH", KEYS[4], jobId)
+        elseif job.interval and job.interval > 0 then
+          job.status = "delayed"
+          job.attempts = 0
+          job.startedAt = cjson.null
+          job.scheduledAt = now + job.interval
+          redis.call("HSET", KEYS[2], jobId, cjson.encode(job))
+          redis.call("ZADD", KEYS[6], job.scheduledAt, jobId)
+        else
+          job.status = "failed"
+          job.completedAt = now
+          redis.call("HSET", KEYS[2], jobId, cjson.encode(job))
+          redis.call("SADD", KEYS[5], jobId)
+
+          -- Release unique key on permanent failure
+          if job.key then
+            redis.call("HDEL", KEYS[7], job.key)
+          end
+        end
+        recovered = recovered + 1
+      end
+    else
+      redis.call("LREM", KEYS[1], 1, jobId)
+      redis.call("ZREM", KEYS[3], jobId)
+    end
+  end
+
+  return recovered
+`;
+var LIST_JOBS_SCRIPT = `
+  local filterByTag = ARGV[1] == "1"
+  local filterByStatus = ARGV[2] == "1"
+  local statusFilter = ARGV[3]
+  local offset = tonumber(ARGV[4])
+  local limit = tonumber(ARGV[5])
+
+  local candidateIds
+  if filterByTag then
+    candidateIds = redis.call("SMEMBERS", KEYS[2])
+  else
+    candidateIds = redis.call("HKEYS", KEYS[1])
+  end
+
+  local matched = {}
+  for _, jobId in ipairs(candidateIds) do
+    local jobData = redis.call("HGET", KEYS[1], jobId)
+    if jobData then
+      if filterByStatus then
+        local job = cjson.decode(jobData)
+        if job.status == statusFilter then
+          matched[#matched + 1] = { id = jobId, data = jobData }
+        end
+      else
+        matched[#matched + 1] = { id = jobId, data = jobData }
+      end
+    end
+  end
+
+  table.sort(matched, function(a, b) return a.id < b.id end)
+
+  local total = #matched
+  local startIdx = offset + 1
+  local endIdx = math.min(startIdx + limit - 1, total)
+
+  local results = {}
+  for i = startIdx, endIdx do
+    results[#results + 1] = matched[i].data
+  end
+
+  if #results == 0 then
+    return { total }
+  end
+  return { total, unpack(results) }
+`;
+var CANCEL_JOB_SCRIPT = `
+  local jobId = ARGV[1]
+  local prefix = ARGV[2]
+
+  local jobData = redis.call("HGET", KEYS[1], jobId)
+  if not jobData then
+    return 0
+  end
+
+  local job = cjson.decode(jobData)
+
+  if job.status == "waiting" then
+    redis.call("LREM", KEYS[2], 0, jobId)
+  elseif job.status == "delayed" then
+    redis.call("ZREM", KEYS[3], jobId)
+  elseif job.status == "active" then
+    redis.call("LREM", KEYS[4], 0, jobId)
+    redis.call("ZREM", KEYS[5], jobId)
+  elseif job.status == "completed" then
+    redis.call("SREM", KEYS[6], jobId)
+  elseif job.status == "failed" then
+    redis.call("SREM", KEYS[7], jobId)
+  end
+
+  redis.call("HDEL", KEYS[1], jobId)
+
+  if job.tag then
+    redis.call("SREM", prefix .. ":tag:" .. job.tag, jobId)
+  end
+
+  -- Release unique key
+  if job.key then
+    redis.call("HDEL", KEYS[8], job.key)
+  end
+
+  return 1
+`;
+var PROMOTE_DELAYED_SCRIPT = `
+  local now = tonumber(ARGV[1])
+  local readyJobs = redis.call("ZRANGEBYSCORE", KEYS[1], "0", tostring(now))
+  local promoted = 0
+
+  for _, jobId in ipairs(readyJobs) do
+    local removed = redis.call("ZREM", KEYS[1], jobId)
+    if removed > 0 then
+      local jobData = redis.call("HGET", KEYS[3], jobId)
+      if jobData then
+        local job = cjson.decode(jobData)
+        job.status = "waiting"
+        redis.call("HSET", KEYS[3], jobId, cjson.encode(job))
+        redis.call("LPUSH", KEYS[2], jobId)
+        promoted = promoted + 1
+      end
+    end
+  end
+
+  return promoted
+`;
+var create3 = (config) => {
+  const { name, schema, prefix = "jobs" } = config;
+  const keyPrefix = `${prefix}:${name}`;
+  const keys = {
+    jobs: `${keyPrefix}:data`,
+    waiting: `${keyPrefix}:waiting`,
+    delayed: `${keyPrefix}:delayed`,
+    active: `${keyPrefix}:active`,
+    deadlines: `${keyPrefix}:deadlines`,
+    completed: `${keyPrefix}:completed`,
+    failed: `${keyPrefix}:failed`,
+    id: `${keyPrefix}:id`,
+    tags: `${keyPrefix}:tags`,
+    unique: `${keyPrefix}:unique`
+  };
+  const generateId = async () => {
+    const counter = await redis3.incr(keys.id);
+    const random = randomBytes2(4).toString("hex");
+    return `${counter}-${random}`;
+  };
+  const deserializeJob = (data) => {
+    let job;
+    try {
+      job = JSON.parse(data);
+    } catch (error) {
+      throw new JobsError("Invalid job payload in Redis", "INVALID_JOB_DATA");
+    }
+    if (job.invalidData) {
+      return job;
+    }
+    const result = schema.safeParse(job.data);
+    if (!result.success) {
+      throw new ValidationError(result.error.issues);
+    }
+    return job;
+  };
+  const markPoisonedJob = async (jobId, jobData, error) => {
+    const now = Date.now();
+    let parsed = null;
+    try {
+      parsed = JSON.parse(jobData);
+    } catch {
+      parsed = null;
+    }
+    const poisoned = parsed ? {
+      ...parsed,
+      status: "failed",
+      completedAt: now,
+      error: error.message,
+      invalidData: true
+    } : {
+      id: jobId,
+      data: null,
+      status: "failed",
+      attempts: 1,
+      maxRetries: 0,
+      timeout: 0,
+      createdAt: now,
+      completedAt: now,
+      error: error.message,
+      invalidData: true
+    };
+    await redis3.send("LREM", [keys.active, "0", jobId]);
+    await redis3.send("ZREM", [keys.deadlines, jobId]);
+    await redis3.send("HSET", [keys.jobs, jobId, JSON.stringify(poisoned)]);
+    await redis3.send("SADD", [keys.failed, jobId]);
+    if (parsed?.key) {
+      await redis3.send("HDEL", [keys.unique, parsed.key]);
+    }
+  };
+  const send = async (data, options = {}) => {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new ValidationError(result.error.issues);
+    }
+    const id = await generateId();
+    const now = Date.now();
+    const interval = "interval" in options ? options.interval : undefined;
+    const startImmediately = "startImmediately" in options ? options.startImmediately : undefined;
+    const tag = options.tag;
+    const key = options.key;
+    const backoff = options.backoff;
+    if (key) {
+      const added = await redis3.send("HSETNX", [keys.unique, key, id]);
+      if (added === 0) {
+        throw new DuplicateJobError(key);
+      }
+    }
+    const job = {
+      id,
+      data: result.data,
+      status: "waiting",
+      attempts: 0,
+      maxRetries: options.retries ?? DEFAULT_RETRIES,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      backoff,
+      interval,
+      tag,
+      key,
+      createdAt: now
+    };
+    if ("delay" in options && options.delay !== undefined) {
+      job.status = "delayed";
+      job.scheduledAt = now + options.delay;
+      await redis3.hset(keys.jobs, id, JSON.stringify(job));
+      await redis3.send("ZADD", [keys.delayed, job.scheduledAt.toString(), id]);
+    } else if ("at" in options && options.at !== undefined) {
+      job.status = "delayed";
+      job.scheduledAt = options.at;
+      await redis3.hset(keys.jobs, id, JSON.stringify(job));
+      await redis3.send("ZADD", [keys.delayed, job.scheduledAt.toString(), id]);
+    } else if (interval !== undefined && !startImmediately) {
+      job.status = "delayed";
+      job.scheduledAt = now + interval;
+      await redis3.hset(keys.jobs, id, JSON.stringify(job));
+      await redis3.send("ZADD", [keys.delayed, job.scheduledAt.toString(), id]);
+    } else {
+      await redis3.hset(keys.jobs, id, JSON.stringify(job));
+      await redis3.lpush(keys.waiting, id);
+    }
+    if (tag) {
+      await redis3.sadd(keys.tags, tag);
+      await redis3.sadd(`${keyPrefix}:tag:${tag}`, id);
+    }
+    return job;
+  };
+  const process = (handler, options = {}) => {
+    const {
+      concurrency = DEFAULT_CONCURRENCY,
+      blockingTimeoutSecs,
+      pollInterval,
+      maintenanceIntervalMs,
+      onSuccess,
+      onError,
+      onFinally
+    } = options;
+    const blockingTimeoutSecsValue = blockingTimeoutSecs ?? Math.max(1, Math.ceil((pollInterval ?? DEFAULT_POLL_INTERVAL) / 1000));
+    const maintenanceIntervalMsValue = Math.max(10, maintenanceIntervalMs ?? pollInterval ?? DEFAULT_POLL_INTERVAL);
+    let running = true;
+    let activeCount = 0;
+    let drainResolve = null;
+    redis3.send("EVAL", [
+      RECOVER_ACTIVE_JOBS_SCRIPT,
+      "7",
+      keys.active,
+      keys.jobs,
+      keys.deadlines,
+      keys.waiting,
+      keys.failed,
+      keys.delayed,
+      keys.unique,
+      Date.now().toString()
+    ]).catch((err) => {
+      console.error("Recovery of active jobs failed:", err);
+    });
+    const processLoop = async (client) => {
+      if (!client.connected) {
+        await client.connect();
+      }
+      while (running) {
+        try {
+          const jobId = await client.send("BRPOPLPUSH", [
+            keys.waiting,
+            keys.active,
+            blockingTimeoutSecsValue.toString()
+          ]);
+          if (!jobId) {
+            continue;
+          }
+          const now = Date.now();
+          const claimResult = await redis3.send("EVAL", [
+            CLAIM_JOB_BY_ID_SCRIPT,
+            "4",
+            keys.jobs,
+            keys.active,
+            keys.deadlines,
+            keys.failed,
+            jobId,
+            now.toString()
+          ]);
+          if (!claimResult) {
+            continue;
+          }
+          const [, jobData, claimStatus] = claimResult;
+          if (claimStatus === "invalid") {
+            continue;
+          }
+          let job;
+          try {
+            job = deserializeJob(jobData);
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            await markPoisonedJob(jobId, jobData, err);
+            continue;
+          }
+          activeCount++;
+          try {
+            await handler(job);
+            await redis3.send("EVAL", [
+              COMPLETE_JOB_SCRIPT,
+              "6",
+              keys.jobs,
+              keys.active,
+              keys.completed,
+              keys.deadlines,
+              keys.delayed,
+              keys.unique,
+              job.id,
+              Date.now().toString()
+            ]);
+            if (onSuccess) {
+              try {
+                await onSuccess(job);
+              } catch (onSuccessError) {
+                console.error("onSuccess callback failed:", onSuccessError);
+              }
+            }
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            const result = await redis3.send("EVAL", [
+              FAIL_OR_RETRY_SCRIPT,
+              "7",
+              keys.jobs,
+              keys.active,
+              keys.waiting,
+              keys.failed,
+              keys.deadlines,
+              keys.delayed,
+              keys.unique,
+              job.id,
+              err.message,
+              Date.now().toString()
+            ]);
+            if (onError && (result === 2 || result === 3)) {
+              try {
+                await onError(job, err);
+              } catch (onErrorError) {
+                console.error("onError callback failed:", onErrorError);
+              }
+            }
+          } finally {
+            activeCount--;
+            if (onFinally) {
+              try {
+                await onFinally(job);
+              } catch (onFinallyError) {
+                console.error("onFinally callback failed:", onFinallyError);
+              }
+            }
+            if (!running && activeCount === 0 && drainResolve) {
+              drainResolve();
+            }
+          }
+        } catch (error) {
+          if (!running)
+            break;
+          console.error("Worker error:", error);
+          await sleep2(100);
+        }
+      }
+    };
+    const workerPromises = [];
+    const workerClients = [];
+    for (let i = 0;i < concurrency; i++) {
+      const workerClient = new RedisClient;
+      workerClients.push(workerClient);
+      workerPromises.push(processLoop(workerClient));
+    }
+    const maintenanceLoop = async () => {
+      while (running) {
+        try {
+          await redis3.send("EVAL", [
+            PROMOTE_DELAYED_SCRIPT,
+            "3",
+            keys.delayed,
+            keys.waiting,
+            keys.jobs,
+            Date.now().toString()
+          ]);
+          await redis3.send("EVAL", [
+            FAIL_TIMED_OUT_SCRIPT,
+            "5",
+            keys.deadlines,
+            keys.jobs,
+            keys.active,
+            keys.failed,
+            keys.unique,
+            Date.now().toString()
+          ]);
+        } catch (error) {
+          if (!running)
+            break;
+          console.error("Worker error:", error);
+        }
+        await sleep2(maintenanceIntervalMsValue);
+      }
+    };
+    maintenanceLoop();
+    const safeClose = (client) => {
+      if (!client.connected)
+        return;
+      try {
+        client.close();
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (!("code" in err) || err.code !== "ERR_REDIS_CONNECTION_CLOSED") {
+          console.error("Failed to close worker client:", error);
+        }
+      }
+    };
+    return async () => {
+      running = false;
+      for (const client of workerClients) {
+        safeClose(client);
+      }
+      if (activeCount > 0) {
+        await new Promise((resolve) => {
+          drainResolve = resolve;
+        });
+      }
+    };
+  };
+  const list = async (options = {}) => {
+    const { tag, status, offset = 0, limit = 100 } = options;
+    const filterByTag = tag ? "1" : "0";
+    const filterByStatus = status ? "1" : "0";
+    const tagKey = tag ? `${keyPrefix}:tag:${tag}` : "";
+    const result = await redis3.send("EVAL", [
+      LIST_JOBS_SCRIPT,
+      "2",
+      keys.jobs,
+      tagKey,
+      filterByTag,
+      filterByStatus,
+      status ?? "",
+      offset.toString(),
+      limit.toString()
+    ]);
+    const [total, ...jobStrings] = result;
+    const jobList = jobStrings.map((str) => deserializeJob(str));
+    return { total, jobs: jobList };
+  };
+  const cancel = async (jobId) => {
+    const result = await redis3.send("EVAL", [
+      CANCEL_JOB_SCRIPT,
+      "8",
+      keys.jobs,
+      keys.waiting,
+      keys.delayed,
+      keys.active,
+      keys.deadlines,
+      keys.completed,
+      keys.failed,
+      keys.unique,
+      jobId,
+      keyPrefix
+    ]);
+    return result === 1;
+  };
+  return { send, process, list, cancel };
+};
+var jobs = { create: create3 };
+// src/queue.ts
+var {redis: redis4, RedisClient: RedisClient2, sleep: sleep3 } = globalThis.Bun;
+var DEFAULT_POLL_INTERVAL2 = 1000;
+var DEFAULT_CONCURRENCY2 = 1;
+
+class QueueError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "QueueError";
+    this.code = code;
+  }
+}
+
+class QueueValidationError extends QueueError {
+  issues;
+  constructor(issues) {
+    super("Queue message validation failed", "VALIDATION_ERROR");
+    this.name = "QueueValidationError";
+    this.issues = issues;
+  }
+}
+var create4 = (config) => {
+  const { name, schema, prefix = "queue" } = config;
+  const key = `${prefix}:${name}`;
+  const send = async (data) => {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new QueueValidationError(result.error.issues);
+    }
+    await redis4.lpush(key, JSON.stringify(result.data));
+  };
+  const sendBatch = async (data) => {
+    if (data.length === 0)
+      return;
+    const serialized = [];
+    for (const item of data) {
+      const result = schema.safeParse(item);
+      if (!result.success) {
+        throw new QueueValidationError(result.error.issues);
+      }
+      serialized.push(JSON.stringify(result.data));
+    }
+    await redis4.send("LPUSH", [key, ...serialized]);
+  };
+  const process = (handler, options = {}) => {
+    const {
+      concurrency = DEFAULT_CONCURRENCY2,
+      blockingTimeoutSecs,
+      pollInterval,
+      onSuccess,
+      onError
+    } = options;
+    const blockingTimeoutSecsValue = blockingTimeoutSecs ?? Math.max(1, Math.ceil((pollInterval ?? DEFAULT_POLL_INTERVAL2) / 1000));
+    let running = true;
+    const processLoop = async (client) => {
+      if (!client.connected) {
+        await client.connect();
+      }
+      while (running) {
+        try {
+          const popResult = await client.send("BRPOP", [key, blockingTimeoutSecsValue.toString()]);
+          if (!popResult) {
+            continue;
+          }
+          const [, raw] = popResult;
+          const parsed = JSON.parse(raw);
+          const parsedResult = schema.safeParse(parsed);
+          if (!parsedResult.success) {
+            console.error("Invalid message in queue:", parsedResult.error.issues);
+            continue;
+          }
+          const data = parsedResult.data;
+          try {
+            await handler(data);
+            if (onSuccess) {
+              try {
+                await onSuccess(data);
+              } catch (callbackError) {
+                console.error("onSuccess callback failed:", callbackError);
+              }
+            }
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            if (onError) {
+              try {
+                await onError(data, err);
+              } catch (callbackError) {
+                console.error("onError callback failed:", callbackError);
+              }
+            }
+          }
+        } catch (error) {
+          if (!running)
+            break;
+          console.error("Queue worker error:", error);
+          await sleep3(100);
+        }
+      }
+    };
+    const workerClients = [];
+    for (let i = 0;i < concurrency; i++) {
+      const workerClient = new RedisClient2;
+      workerClients.push(workerClient);
+      processLoop(workerClient);
+    }
+    return () => {
+      running = false;
+      for (const client of workerClients) {
+        if (!client.connected)
+          continue;
+        try {
+          client.close();
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          if (!("code" in err) || err.code !== "ERR_REDIS_CONNECTION_CLOSED") {
+            console.error("Failed to close worker client:", error);
+          }
+        }
+      }
+    };
+  };
+  const size = async () => {
+    return await redis4.llen(key);
+  };
+  const purge = async () => {
+    await redis4.del(key);
+  };
+  return { send, sendBatch, process, size, purge };
+};
+var queue = { create: create4 };
+export {
+  ratelimit,
+  queue,
+  mutex,
+  jobs,
+  ValidationError,
+  RateLimitError,
+  QueueValidationError,
+  QueueError,
+  LockError,
+  JobsError,
+  DuplicateJobError
+};