@holo-js/queue 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1638 @@
+// src/contracts.ts
+function normalizeOptionalString(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`[Holo Queue] ${label} must be a non-empty string when provided.`);
+  }
+  return normalized;
+}
+function normalizeOptionalInteger(value, label, options = {}) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!Number.isInteger(value)) {
+    throw new Error(`[Holo Queue] ${label} must be an integer when provided.`);
+  }
+  if (typeof options.minimum === "number" && value < options.minimum) {
+    throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
+  }
+  return value;
+}
+function normalizeBackoff(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return normalizeOptionalInteger(value, "Job backoff", { minimum: 0 });
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("[Holo Queue] Job backoff must be a number or an array of integers.");
+  }
+  const normalized = value.map((entry, index) => {
+    if (!Number.isInteger(entry)) {
+      throw new Error(`[Holo Queue] Job backoff entry at index ${index} must be an integer.`);
+    }
+    if (entry < 0) {
+      throw new Error(`[Holo Queue] Job backoff entry at index ${index} must be greater than or equal to 0.`);
+    }
+    return entry;
+  });
+  return Object.freeze(normalized);
+}
+function normalizeOptionalHook(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value !== "function") {
+    throw new Error(`[Holo Queue] ${label} must be a function when provided.`);
+  }
+  return value;
+}
+function isQueueJobDefinition(value) {
+  return value !== null && typeof value === "object" && "handle" in value && typeof value.handle === "function";
+}
+function normalizeQueueJobDefinition(job) {
+  if (!isQueueJobDefinition(job)) {
+    throw new Error('[Holo Queue] Jobs must define a "handle" function.');
+  }
+  return {
+    ...job,
+    ...typeof job.connection === "undefined" ? {} : { connection: normalizeOptionalString(job.connection, "Job connection") },
+    ...typeof job.queue === "undefined" ? {} : { queue: normalizeOptionalString(job.queue, "Job queue") },
+    ...typeof job.tries === "undefined" ? {} : { tries: normalizeOptionalInteger(job.tries, "Job tries", { minimum: 1 }) },
+    ...typeof job.timeout === "undefined" ? {} : { timeout: normalizeOptionalInteger(job.timeout, "Job timeout", { minimum: 0 }) },
+    ...typeof job.backoff === "undefined" ? {} : { backoff: normalizeBackoff(job.backoff) },
+    ...typeof job.onCompleted === "undefined" ? {} : { onCompleted: normalizeOptionalHook(job.onCompleted, "Job onCompleted hook") },
+    ...typeof job.onFailed === "undefined" ? {} : { onFailed: normalizeOptionalHook(job.onFailed, "Job onFailed hook") }
+  };
+}
+function defineJob(job) {
+  return Object.freeze(normalizeQueueJobDefinition(job));
+}
+var queueJobInternals = {
+  normalizeQueueJobDefinition,
+  normalizeBackoff,
+  normalizeOptionalHook,
+  normalizeOptionalInteger,
+  normalizeOptionalString
+};
+
+// src/config.ts
+var DEFAULT_QUEUE_CONNECTION = "sync";
+var DEFAULT_QUEUE_NAME = "default";
+var DEFAULT_QUEUE_RETRY_AFTER = 90;
+var DEFAULT_QUEUE_BLOCK_FOR = 5;
+var DEFAULT_QUEUE_SLEEP = 1;
+var DEFAULT_FAILED_JOBS_CONNECTION = "default";
+var DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
+var DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
+var DEFAULT_QUEUE_CONFIG = Object.freeze({
+  default: DEFAULT_QUEUE_CONNECTION,
+  failed: Object.freeze({
+    driver: "database",
+    connection: DEFAULT_FAILED_JOBS_CONNECTION,
+    table: DEFAULT_FAILED_JOBS_TABLE
+  }),
+  connections: Object.freeze({
+    [DEFAULT_QUEUE_CONNECTION]: Object.freeze({
+      name: DEFAULT_QUEUE_CONNECTION,
+      driver: "sync",
+      queue: DEFAULT_QUEUE_NAME
+    })
+  })
+});
+function parseInteger(value, fallback, label, options = {}) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  const normalized = typeof value === "number" ? value : Number.parseInt(value, 10);
+  if (!Number.isInteger(normalized)) {
+    throw new Error(`[Holo Queue] ${label} must be an integer.`);
+  }
+  if (typeof options.minimum === "number" && normalized < options.minimum) {
+    throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
+  }
+  return normalized;
+}
+function normalizeConnectionName(value, label) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`[Holo Queue] ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function normalizeQueueName(value) {
+  return value?.trim() || DEFAULT_QUEUE_NAME;
+}
+function normalizeSyncConnection(name, config) {
+  return Object.freeze({
+    name,
+    driver: "sync",
+    queue: normalizeQueueName(config.queue)
+  });
+}
+function normalizeRedisConnection(name, config) {
+  const redis = config.redis ?? {};
+  return Object.freeze({
+    name,
+    driver: "redis",
+    queue: normalizeQueueName(config.queue),
+    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+      minimum: 0
+    }),
+    blockFor: parseInteger(config.blockFor, DEFAULT_QUEUE_BLOCK_FOR, `queue connection "${name}" blockFor`, {
+      minimum: 0
+    }),
+    redis: Object.freeze({
+      host: redis.host?.trim() || "127.0.0.1",
+      port: parseInteger(redis.port, 6379, `queue connection "${name}" redis.port`, {
+        minimum: 1
+      }),
+      password: redis.password?.trim() || void 0,
+      username: redis.username?.trim() || void 0,
+      db: parseInteger(redis.db, 0, `queue connection "${name}" redis.db`, {
+        minimum: 0
+      })
+    })
+  });
+}
+function normalizeDatabaseConnection(name, config) {
+  return Object.freeze({
+    name,
+    driver: "database",
+    queue: normalizeQueueName(config.queue),
+    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+      minimum: 0
+    }),
+    sleep: parseInteger(config.sleep, DEFAULT_QUEUE_SLEEP, `queue connection "${name}" sleep`, {
+      minimum: 0
+    }),
+    connection: config.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
+    table: config.table?.trim() || DEFAULT_DATABASE_QUEUE_TABLE
+  });
+}
+function normalizeConnectionConfig(name, config) {
+  switch (config.driver) {
+    case "sync":
+      return normalizeSyncConnection(name, config);
+    case "redis":
+      return normalizeRedisConnection(name, config);
+    case "database":
+      return normalizeDatabaseConnection(name, config);
+    default:
+      throw new Error(`[Holo Queue] Unsupported queue driver "${String(config.driver)}" on connection "${name}".`);
+  }
+}
+function normalizeConnections(connections) {
+  if (!connections || Object.keys(connections).length === 0) {
+    return DEFAULT_QUEUE_CONFIG.connections;
+  }
+  const normalizedEntries = Object.entries(connections).map(([name, config]) => {
+    const normalizedName = normalizeConnectionName(name, "Queue connection name");
+    return [normalizedName, normalizeConnectionConfig(normalizedName, config)];
+  });
+  return Object.freeze(Object.fromEntries(normalizedEntries));
+}
+function normalizeFailedStore(config) {
+  if (config === false) {
+    return false;
+  }
+  const normalized = config ?? DEFAULT_QUEUE_CONFIG.failed;
+  if (normalized.driver && normalized.driver !== "database") {
+    throw new Error(`[Holo Queue] Unsupported failed job store driver "${normalized.driver}".`);
+  }
+  return Object.freeze({
+    driver: "database",
+    connection: normalized.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
+    table: normalized.table?.trim() || DEFAULT_FAILED_JOBS_TABLE
+  });
+}
+function normalizeQueueConfig(config = {}) {
+  const connections = normalizeConnections(config.connections);
+  const connectionNames = Object.keys(connections);
+  const defaultConnection = config.default?.trim() || connectionNames[0];
+  if (!connections[defaultConnection]) {
+    throw new Error(
+      `[Holo Queue] default queue connection "${defaultConnection}" is not configured. Available connections: ${connectionNames.join(", ")}`
+    );
+  }
+  return Object.freeze({
+    default: defaultConnection,
+    failed: normalizeFailedStore(config.failed),
+    connections
+  });
+}
+var holoQueueDefaults = DEFAULT_QUEUE_CONFIG;
+var queueInternals = {
+  parseInteger
+};
+
+// src/registry.ts
+function toPosixPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function deriveJobNameFromSourcePath(sourcePath) {
+  const normalized = toPosixPath(sourcePath).replace(/\.[^.]+$/, "");
+  const jobRootIndex = normalized.lastIndexOf("/jobs/");
+  const relevant = jobRootIndex >= 0 ? normalized.slice(jobRootIndex + "/jobs/".length) : normalized;
+  return relevant.split("/").filter(Boolean).join(".");
+}
+function getQueueRegistryState() {
+  const runtime = globalThis;
+  runtime.__holoQueueRegistry__ ??= {
+    jobs: /* @__PURE__ */ new Map()
+  };
+  return runtime.__holoQueueRegistry__;
+}
+function resolveRegistrationName(definition, options = {}) {
+  const explicit = options.name?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromSource = options.sourcePath?.trim();
+  if (fromSource) {
+    return deriveJobNameFromSourcePath(fromSource);
+  }
+  throw new Error("[Holo Queue] Registered jobs require an explicit name or a sourcePath-derived name.");
+}
+function registerQueueJob(definition, options = {}) {
+  if (!isQueueJobDefinition(definition)) {
+    throw new Error('[Holo Queue] Jobs must define a "handle" function.');
+  }
+  const normalizedDefinition = normalizeQueueJobDefinition(definition);
+  const name = resolveRegistrationName(normalizedDefinition, options);
+  const registry = getQueueRegistryState().jobs;
+  if (registry.has(name) && options.replaceExisting !== true) {
+    throw new Error(`[Holo Queue] Queue job "${name}" is already registered.`);
+  }
+  const entry = Object.freeze({
+    name,
+    ...options.sourcePath ? { sourcePath: options.sourcePath } : {},
+    definition: Object.freeze({
+      ...normalizedDefinition
+    })
+  });
+  registry.set(name, entry);
+  return entry;
+}
+function registerQueueJobs(definitions) {
+  return Object.freeze(definitions.map((entry) => registerQueueJob(entry.definition, entry.options)));
+}
+function getRegisteredQueueJob(name) {
+  return getQueueRegistryState().jobs.get(name);
+}
+function listRegisteredQueueJobs() {
+  return Object.freeze([...getQueueRegistryState().jobs.values()].sort((left, right) => left.name.localeCompare(right.name)));
+}
+function unregisterQueueJob(name) {
+  return getQueueRegistryState().jobs.delete(name);
+}
+function resetQueueRegistry() {
+  getQueueRegistryState().jobs.clear();
+}
+var queueRegistryInternals = {
+  deriveJobNameFromSourcePath
+};
+
+// src/drivers/redis.ts
+import { randomUUID } from "crypto";
+import {
+  Queue as BullQueue,
+  Worker as BullWorker
+} from "bullmq";
+function normalizeRedisErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isQueueEnvelope(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.name === "string" && typeof value.connection === "string" && typeof value.queue === "string" && "payload" in value && typeof value.attempts === "number" && Number.isInteger(value.attempts) && value.attempts >= 0 && typeof value.maxAttempts === "number" && Number.isInteger(value.maxAttempts) && value.maxAttempts >= 1 && typeof value.createdAt === "number" && Number.isFinite(value.createdAt) && (typeof value.availableAt === "undefined" || typeof value.availableAt === "number" && Number.isFinite(value.availableAt));
+}
+function resolveBullConnectionOptions(connection) {
+  return {
+    host: connection.redis.host,
+    port: connection.redis.port,
+    username: connection.redis.username,
+    password: connection.redis.password,
+    db: connection.redis.db,
+    maxRetriesPerRequest: null
+  };
+}
+var RedisQueueDriverError = class extends Error {
+  constructor(connectionName, action, cause) {
+    super(
+      `[Holo Queue] Redis queue connection "${connectionName}" failed to ${action}: ${normalizeRedisErrorMessage(cause)}`,
+      { cause }
+    );
+    this.name = "RedisQueueDriverError";
+  }
+};
+function wrapRedisError(connectionName, action, error) {
+  if (error instanceof RedisQueueDriverError) {
+    return error;
+  }
+  return new RedisQueueDriverError(connectionName, action, error);
+}
+function resolveAttempts(job) {
+  return Math.max(
+    Number.isInteger(job.attemptsStarted) ? job.attemptsStarted - 1 : 0,
+    Number.isInteger(job.attemptsMade) ? job.attemptsMade : 0,
+    0
+  );
+}
+var RedisQueueDriver = class {
+  constructor(connection, context) {
+    this.context = context;
+    this.name = connection.name;
+    this.connection = connection;
+    this.bullConnection = resolveBullConnectionOptions(connection);
+  }
+  name;
+  driver = "redis";
+  mode = "async";
+  connection;
+  bullConnection;
+  queues = /* @__PURE__ */ new Map();
+  workers = /* @__PURE__ */ new Map();
+  reservations = /* @__PURE__ */ new Map();
+  queueCursor = 0;
+  getQueue(queueName) {
+    const cached = this.queues.get(queueName);
+    if (cached) {
+      return cached;
+    }
+    const queue = new BullQueue(queueName, {
+      connection: this.bullConnection,
+      defaultJobOptions: {
+        removeOnComplete: true,
+        removeOnFail: true
+      }
+    });
+    this.queues.set(queueName, queue);
+    return queue;
+  }
+  async getWorker(queueName) {
+    const cached = this.workers.get(queueName);
+    if (cached) {
+      return cached;
+    }
+    const worker = new BullWorker(
+      queueName,
+      null,
+      {
+        autorun: false,
+        concurrency: 1,
+        connection: this.bullConnection,
+        drainDelay: this.connection.blockFor,
+        lockDuration: this.connection.retryAfter * 1e3,
+        removeOnComplete: { count: 0 },
+        removeOnFail: { count: 0 }
+      }
+    );
+    await worker.waitUntilReady();
+    this.workers.set(queueName, worker);
+    return worker;
+  }
+  normalizeQueueNames(queueNames) {
+    if (!queueNames || queueNames.length === 0) {
+      return [.../* @__PURE__ */ new Set([
+        this.connection.queue,
+        ...this.queues.keys(),
+        ...this.workers.keys()
+      ])];
+    }
+    return [...new Set(queueNames)];
+  }
+  rotateQueueNames(queueNames) {
+    if (queueNames.length <= 1) {
+      return queueNames;
+    }
+    const offset = this.queueCursor % queueNames.length;
+    this.queueCursor = (this.queueCursor + 1) % queueNames.length;
+    return Object.freeze([
+      ...queueNames.slice(offset),
+      ...queueNames.slice(0, offset)
+    ]);
+  }
+  createReservedJob(job, token, queueName) {
+    if (!job.id) {
+      throw new Error("BullMQ returned a reserved job without an id.");
+    }
+    if (!isQueueEnvelope(job.data)) {
+      throw new Error(`BullMQ returned a malformed payload for job "${job.id}".`);
+    }
+    const attempts = resolveAttempts(job);
+    const envelope = Object.freeze({
+      id: job.id,
+      name: job.data.name,
+      connection: job.data.connection,
+      queue: job.data.queue || queueName,
+      payload: job.data.payload,
+      attempts,
+      maxAttempts: job.data.maxAttempts,
+      ...typeof job.data.availableAt === "number" ? { availableAt: job.data.availableAt } : {},
+      createdAt: job.data.createdAt
+    });
+    this.reservations.set(token, {
+      job,
+      token
+    });
+    return {
+      reservationId: token,
+      envelope,
+      reservedAt: Date.now()
+    };
+  }
+  getReservation(reserved) {
+    const reservation = this.reservations.get(reserved.reservationId);
+    if (!reservation) {
+      throw new Error(`Queue reservation "${reserved.reservationId}" is not active.`);
+    }
+    return reservation;
+  }
+  async settleReservation(reserved, action, callback) {
+    const reservation = this.getReservation(reserved);
+    try {
+      await callback(reservation);
+    } catch (error) {
+      throw wrapRedisError(this.name, action, error);
+    } finally {
+      this.reservations.delete(reserved.reservationId);
+    }
+  }
+  async dispatch(job) {
+    try {
+      const delay = typeof job.availableAt === "number" ? Math.max(job.availableAt - Date.now(), 0) : void 0;
+      const queued = await this.getQueue(job.queue).add(job.name, job, {
+        attempts: job.maxAttempts,
+        ...typeof delay === "number" ? { delay } : {},
+        jobId: job.id,
+        removeOnComplete: true,
+        removeOnFail: true,
+        timestamp: job.createdAt
+      });
+      return {
+        jobId: queued.id ?? job.id,
+        synchronous: false
+      };
+    } catch (error) {
+      throw wrapRedisError(this.name, "enqueue job", error);
+    }
+  }
+  async reserve(input) {
+    try {
+      const queueNames = this.rotateQueueNames(this.normalizeQueueNames(input.queueNames));
+      for (const queueName of queueNames) {
+        const token2 = `${input.workerId}:${randomUUID()}`;
+        const worker2 = await this.getWorker(queueName);
+        const job2 = await worker2.getNextJob(token2, { block: false });
+        if (job2) {
+          return this.createReservedJob(job2, token2, queueName);
+        }
+      }
+      const [blockingQueue] = queueNames;
+      if (!blockingQueue || this.connection.blockFor <= 0) {
+        return null;
+      }
+      const token = `${input.workerId}:${randomUUID()}`;
+      const worker = await this.getWorker(blockingQueue);
+      const job = await worker.getNextJob(token, { block: true });
+      if (!job) {
+        return null;
+      }
+      return this.createReservedJob(job, token, blockingQueue);
+    } catch (error) {
+      throw wrapRedisError(this.name, "reserve job", error);
+    }
+  }
+  async acknowledge(job) {
+    await this.settleReservation(job, "acknowledge job", async (reservation) => {
+      await reservation.job.moveToCompleted(null, reservation.token, false);
+    });
+  }
+  async release(job, options) {
+    await this.settleReservation(job, "release job", async (reservation) => {
+      if (typeof options?.delaySeconds === "number" && options.delaySeconds > 0) {
+        await reservation.job.moveToDelayed(Date.now() + options.delaySeconds * 1e3, reservation.token);
+        return;
+      }
+      await reservation.job.moveToWait(reservation.token);
+    });
+  }
+  async delete(job) {
+    await this.settleReservation(job, "delete job", async (reservation) => {
+      reservation.job.discard();
+      await reservation.job.moveToFailed(new Error("[Holo Queue] Job deleted."), reservation.token, false);
+    });
+  }
+  async clear(input) {
+    try {
+      const queueNames = this.normalizeQueueNames(input?.queueNames);
+      let cleared = 0;
+      for (const queueName of queueNames) {
+        const queue = this.getQueue(queueName);
+        cleared += await queue.getJobCountByTypes("wait", "waiting", "paused", "prioritized", "delayed");
+        await queue.drain(true);
+      }
+      return cleared;
+    } catch (error) {
+      throw wrapRedisError(this.name, "clear queued jobs", error);
+    }
+  }
+  async close() {
+    const resources = [
+      ...this.workers.values(),
+      ...this.queues.values()
+    ];
+    this.reservations.clear();
+    this.workers.clear();
+    this.queues.clear();
+    const results = await Promise.allSettled(resources.map(async (resource) => {
+      if (resource instanceof BullWorker) {
+        await resource.close(true);
+        return;
+      }
+      await resource.close();
+    }));
+    const rejection = results.find((result) => result.status === "rejected");
+    if (rejection) {
+      throw wrapRedisError(this.name, "close driver", rejection.reason);
+    }
+  }
+};
+var redisQueueDriverFactory = {
+  driver: "redis",
+  create(connection, context) {
+    return new RedisQueueDriver(connection, context);
+  }
+};
+var redisQueueDriverInternals = {
+  isQueueEnvelope,
+  normalizeRedisErrorMessage,
+  resolveAttempts,
+  resolveBullConnectionOptions,
+  wrapRedisError
+};
+
+// src/drivers/sync.ts
+var SyncQueueDriver = class {
+  name;
+  driver = "sync";
+  mode = "sync";
+  context;
+  constructor(connection, context) {
+    this.name = connection.name;
+    this.context = context;
+  }
+  async dispatch(job) {
+    const result = await this.context.execute(job);
+    return {
+      jobId: job.id,
+      synchronous: true,
+      result
+    };
+  }
+  async clear() {
+    return 0;
+  }
+  async close() {
+  }
+};
+var syncQueueDriverFactory = {
+  driver: "sync",
+  create(connection, context) {
+    return new SyncQueueDriver(connection, context);
+  }
+};
+var syncQueueDriverInternals = {
+  SyncQueueDriver
+};
+
+// src/runtime.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var INLINE_SYNC_DRIVER_KEY = "__inline_sync__";
+var QueueReleaseUnsupportedError = class extends Error {
+  constructor() {
+    super("[Holo Queue] release() is not supported during synchronous queue execution.");
+  }
+};
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertQueueJsonValue(value, path, state) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return;
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError(`[Holo Queue] Queue payload at "${path}" must be JSON-serializable.`);
+  }
+  if (typeof value === "number") {
+    return;
+  }
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new TypeError(`[Holo Queue] Queue payload at "${path}" must be JSON-serializable.`);
+  }
+  if (Array.isArray(value)) {
+    if (state.seen.has(value)) {
+      throw new TypeError(`[Holo Queue] Queue payload at "${path}" contains a circular reference.`);
+    }
+    state.seen.add(value);
+    for (let index = 0; index < value.length; index += 1) {
+      assertQueueJsonValue(value[index], `${path}[${index}]`, state);
+    }
+    state.seen.delete(value);
+    return;
+  }
+  if (!isPlainObject(value)) {
+    throw new TypeError(`[Holo Queue] Queue payload at "${path}" must be a plain JSON object, array, or primitive.`);
+  }
+  if (state.seen.has(value)) {
+    throw new TypeError(`[Holo Queue] Queue payload at "${path}" contains a circular reference.`);
+  }
+  state.seen.add(value);
+  for (const [key, nested] of Object.entries(value)) {
+    assertQueueJsonValue(nested, `${path}.${key}`, state);
+  }
+  state.seen.delete(value);
+}
+function validateQueuePayload(payload) {
+  assertQueueJsonValue(payload, "payload", { seen: /* @__PURE__ */ new Set() });
+}
+function normalizeConnectionName2(name) {
+  const normalized = name.trim();
+  if (!normalized) {
+    throw new Error("[Holo Queue] Queue connection names must be non-empty strings.");
+  }
+  return normalized;
+}
+function normalizeQueueName2(name) {
+  const normalized = name.trim();
+  if (!normalized) {
+    throw new Error("[Holo Queue] Queue names must be non-empty strings.");
+  }
+  return normalized;
+}
+function normalizeDispatchCompletedHook(callback) {
+  if (typeof callback !== "function") {
+    throw new Error("[Holo Queue] Queue dispatch onComplete hook must be a function.");
+  }
+  return callback;
+}
+function normalizeDispatchFailedHook(callback) {
+  if (typeof callback !== "function") {
+    throw new Error("[Holo Queue] Queue dispatch onFailed hook must be a function.");
+  }
+  return callback;
+}
+function normalizeDelay(delay) {
+  if (typeof delay === "undefined") {
+    return void 0;
+  }
+  if (typeof delay === "number") {
+    if (!Number.isFinite(delay) || delay < 0) {
+      throw new TypeError("[Holo Queue] Queue delay must be a finite number greater than or equal to 0.");
+    }
+    return Date.now() + Math.floor(delay * 1e3);
+  }
+  const timestamp = delay.getTime();
+  if (Number.isNaN(timestamp)) {
+    throw new TypeError("[Holo Queue] Queue delay dates must be valid Date instances.");
+  }
+  return timestamp;
+}
+function createDefaultDriverFactories() {
+  return /* @__PURE__ */ new Map([
+    [redisQueueDriverFactory.driver, redisQueueDriverFactory],
+    [syncQueueDriverFactory.driver, syncQueueDriverFactory]
+  ]);
+}
+function createQueueDriverFactoryMap(factories) {
+  const resolved = createDefaultDriverFactories();
+  if (!factories) {
+    return resolved;
+  }
+  if (!Array.isArray(factories)) {
+    for (const [name, factory] of factories.entries()) {
+      resolved.set(String(name), factory);
+    }
+    return resolved;
+  }
+  for (const factory of factories) {
+    resolved.set(factory.driver, factory);
+  }
+  return resolved;
+}
+function getQueueRuntimeState() {
+  const runtime = globalThis;
+  runtime.__holoQueueRuntime__ ??= {
+    config: holoQueueDefaults,
+    driverFactories: createDefaultDriverFactories(),
+    drivers: /* @__PURE__ */ new Map(),
+    failedJobStore: void 0
+  };
+  return runtime.__holoQueueRuntime__;
+}
+function createQueueRuntimeBinding(state) {
+  return Object.freeze({
+    config: state.config,
+    drivers: state.drivers
+  });
+}
+function requireRegisteredQueueJob(jobName) {
+  const registered = getRegisteredQueueJob(jobName);
+  if (!registered) {
+    throw new Error(`[Holo Queue] Queue job "${jobName}" is not registered.`);
+  }
+  return registered;
+}
+function resolveConnectionConfig(config, requestedConnection) {
+  const connectionName = requestedConnection ? normalizeConnectionName2(requestedConnection) : config.default;
+  const connection = config.connections[connectionName];
+  if (!connection) {
+    throw new Error(
+      `[Holo Queue] Queue connection "${connectionName}" is not configured. Available connections: ${Object.keys(config.connections).join(", ")}`
+    );
+  }
+  return connection;
+}
+function createJobContext(envelope, overrides = {}) {
+  return {
+    jobId: envelope.id,
+    jobName: envelope.name,
+    connection: envelope.connection,
+    queue: envelope.queue,
+    attempt: envelope.attempts + 1,
+    maxAttempts: overrides.maxAttempts ?? envelope.maxAttempts,
+    async release(delaySeconds) {
+      if (overrides.release) {
+        await overrides.release(delaySeconds);
+        return;
+      }
+      throw new QueueReleaseUnsupportedError();
+    },
+    async fail(error) {
+      if (overrides.fail) {
+        await overrides.fail(error);
+        return;
+      }
+      throw error;
+    }
+  };
+}
+async function executeRegisteredQueueJob(envelope, contextOverrides = {}) {
+  const registered = requireRegisteredQueueJob(envelope.name);
+  const context = createJobContext(envelope, contextOverrides);
+  const result = await registered.definition.handle(
+    envelope.payload,
+    context
+  );
+  if (contextOverrides.shouldSkipLifecycleHooks?.()) {
+    return result;
+  }
+  await executeRegisteredQueueJobCompletedHook(envelope, result, contextOverrides);
+  return result;
+}
+async function executeRegisteredQueueJobCompletedHook(envelope, result, contextOverrides = {}) {
+  const registered = requireRegisteredQueueJob(envelope.name);
+  if (!registered.definition.onCompleted) {
+    return;
+  }
+  try {
+    await registered.definition.onCompleted(
+      envelope.payload,
+      result,
+      createJobContext(envelope, contextOverrides)
+    );
+  } catch (error) {
+    const resolvedError = error instanceof Error ? error : new Error(String(error));
+    console.warn(`[Holo Queue] onCompleted hook failed for job "${envelope.name}": ${resolvedError.message}`);
+  }
+}
+async function executeRegisteredQueueJobFailedHook(envelope, error, contextOverrides = {}) {
+  const registered = requireRegisteredQueueJob(envelope.name);
+  if (!registered.definition.onFailed) {
+    return;
+  }
+  try {
+    await registered.definition.onFailed(
+      envelope.payload,
+      error,
+      createJobContext(envelope, contextOverrides)
+    );
+  } catch (hookError) {
+    const resolvedError = hookError instanceof Error ? hookError : new Error(String(hookError));
+    console.warn(`[Holo Queue] onFailed hook failed for job "${envelope.name}": ${resolvedError.message}`);
+  }
+}
+async function dispatchThroughDriver(driver, envelope) {
+  try {
+    return await driver.dispatch(envelope);
+  } catch (error) {
+    if (driver.mode === "sync") {
+      const resolvedError = error instanceof Error ? error : new Error(String(error));
+      await executeRegisteredQueueJobFailedHook(envelope, resolvedError, {
+        maxAttempts: envelope.maxAttempts
+      });
+    }
+    throw error;
+  }
+}
+function createQueueDriverFactoryContext() {
+  return {
+    async execute(job) {
+      return await executeRegisteredQueueJob(job);
+    }
+  };
+}
+function resolveDriverFactory(state, connection) {
+  const factory = state.driverFactories.get(connection.driver);
+  if (!factory) {
+    throw new Error(
+      `[Holo Queue] Queue connection "${connection.name}" uses driver "${connection.driver}" but no queue driver factory is registered.`
+    );
+  }
+  return factory;
+}
+function resolveConnectionDriver(connectionName) {
+  const state = getQueueRuntimeState();
+  const connection = resolveConnectionConfig(state.config, connectionName);
+  const cached = state.drivers.get(connection.name);
+  if (cached) {
+    return cached;
+  }
+  const driver = resolveDriverFactory(state, connection).create(
+    connection,
+    createQueueDriverFactoryContext()
+  );
+  state.drivers.set(connection.name, driver);
+  return driver;
+}
+function resolveSyncExecutionDriver() {
+  const state = getQueueRuntimeState();
+  const cached = state.drivers.get(INLINE_SYNC_DRIVER_KEY);
+  if (cached) {
+    return cached;
+  }
+  const syncConnection = normalizeQueueConfig().connections.sync;
+  const driver = resolveDriverFactory(state, syncConnection).create(
+    syncConnection,
+    createQueueDriverFactoryContext()
+  );
+  state.drivers.set(INLINE_SYNC_DRIVER_KEY, driver);
+  return driver;
+}
+function createJobEnvelope(jobName, payload, options) {
+  const runtime = getQueueRuntimeState();
+  const registered = requireRegisteredQueueJob(jobName);
+  const connection = resolveConnectionConfig(
+    runtime.config,
+    options.connection ?? registered.definition.connection
+  );
+  const queue = normalizeQueueName2(options.queue ?? registered.definition.queue ?? connection.queue ?? DEFAULT_QUEUE_NAME);
+  return Object.freeze({
+    id: randomUUID2(),
+    name: registered.name,
+    connection: connection.name,
+    queue,
+    payload,
+    attempts: 0,
+    maxAttempts: registered.definition.tries ?? 1,
+    ...typeof options.delay === "undefined" ? {} : { availableAt: normalizeDelay(options.delay) },
+    createdAt: Date.now()
+  });
+}
+function createDispatchEnvelope(jobName, payload, options = {}) {
+  validateQueuePayload(payload);
+  return createJobEnvelope(jobName, payload, options);
+}
+async function dispatchRecord(envelope) {
+  const driver = resolveConnectionDriver(envelope.connection);
+  const result = await dispatchThroughDriver(driver, envelope);
+  return {
+    jobId: result.jobId,
+    connection: envelope.connection,
+    queue: envelope.queue,
+    synchronous: result.synchronous
+  };
+}
+var PendingQueueDispatch = class _PendingQueueDispatch {
+  jobName;
+  payload;
+  options;
+  completedHooks;
+  failedHooks;
+  executionPromise;
+  constructor(jobName, payload, options = {}, completedHooks = [], failedHooks = []) {
+    this.jobName = jobName;
+    this.payload = payload;
+    this.options = options;
+    this.completedHooks = completedHooks;
+    this.failedHooks = failedHooks;
+  }
+  onConnection(name) {
+    return new _PendingQueueDispatch(this.jobName, this.payload, {
+      ...this.options,
+      connection: normalizeConnectionName2(name)
+    }, this.completedHooks, this.failedHooks);
+  }
+  onQueue(name) {
+    return new _PendingQueueDispatch(this.jobName, this.payload, {
+      ...this.options,
+      queue: normalizeQueueName2(name)
+    }, this.completedHooks, this.failedHooks);
+  }
+  delay(value) {
+    normalizeDelay(value);
+    return new _PendingQueueDispatch(this.jobName, this.payload, {
+      ...this.options,
+      delay: value
+    }, this.completedHooks, this.failedHooks);
+  }
+  onComplete(callback) {
+    return new _PendingQueueDispatch(
+      this.jobName,
+      this.payload,
+      this.options,
+      [...this.completedHooks, normalizeDispatchCompletedHook(callback)],
+      this.failedHooks
+    );
+  }
+  onFailed(callback) {
+    return new _PendingQueueDispatch(
+      this.jobName,
+      this.payload,
+      this.options,
+      this.completedHooks,
+      [...this.failedHooks, normalizeDispatchFailedHook(callback)]
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.execute().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.execute().finally(onfinally ?? void 0);
+  }
+  async dispatch() {
+    return this.execute();
+  }
+  execute() {
+    this.executionPromise ??= (async () => {
+      try {
+        const envelope = createDispatchEnvelope(this.jobName, this.payload, this.options);
+        const result = await dispatchRecord(envelope);
+        for (const hook of this.completedHooks) {
+          try {
+            await hook(result);
+          } catch (error) {
+            const resolvedError = error instanceof Error ? error : new Error(String(error));
+            console.warn(`[Holo Queue] onComplete hook failed during dispatch of "${this.jobName}": ${resolvedError.message}`);
+          }
+        }
+        return result;
+      } catch (error) {
+        for (const hook of this.failedHooks) {
+          try {
+            await hook(error);
+          } catch (hookError) {
+            const resolvedError = hookError instanceof Error ? hookError : new Error(String(hookError));
+            console.warn(`[Holo Queue] onFailed hook failed during dispatch of "${this.jobName}": ${resolvedError.message}`);
+          }
+        }
+        throw error;
+      }
+    })();
+    return this.executionPromise;
+  }
+};
+function createQueueConnection(name) {
+  const resolvedName = name ? normalizeConnectionName2(name) : getQueueRuntimeState().config.default;
+  const dispatchViaConnection = ((jobName, payload, options = {}) => {
+    return new PendingQueueDispatch(jobName, payload, {
+      ...options,
+      connection: resolvedName
+    });
+  });
+  const dispatchSyncViaConnection = (async (jobName, payload) => {
+    return dispatchSyncInternal(jobName, payload, {
+      connection: resolvedName
+    });
+  });
+  return {
+    name: resolvedName,
+    dispatch: dispatchViaConnection,
+    dispatchSync: dispatchSyncViaConnection
+  };
+}
+function configureQueueRuntime(options = {}) {
+  const state = getQueueRuntimeState();
+  let shouldResetDrivers = false;
+  if (options.config) {
+    state.config = normalizeQueueConfig(options.config);
+    shouldResetDrivers = true;
+  }
+  if (options.driverFactories) {
+    state.driverFactories = createQueueDriverFactoryMap(options.driverFactories);
+    shouldResetDrivers = true;
+  }
+  if (Object.prototype.hasOwnProperty.call(options, "failedJobStore")) {
+    state.failedJobStore = options.failedJobStore;
+  }
+  if (shouldResetDrivers) {
+    closeQueueDrivers(state.drivers.values());
+    state.drivers.clear();
+  }
+}
+function resetQueueRuntimeState(state) {
+  state.config = normalizeQueueConfig();
+  state.driverFactories = createDefaultDriverFactories();
+  state.drivers.clear();
+  state.failedJobStore = void 0;
+}
+async function shutdownQueueRuntime() {
+  const state = getQueueRuntimeState();
+  await closeQueueDrivers(state.drivers.values());
+  resetQueueRuntimeState(state);
+}
+function resetQueueRuntime() {
+  const state = getQueueRuntimeState();
+  void closeQueueDrivers(state.drivers.values());
+  resetQueueRuntimeState(state);
+}
+function getQueueRuntime() {
+  return createQueueRuntimeBinding(getQueueRuntimeState());
+}
+function useQueueConnection(name) {
+  return createQueueConnection(name);
+}
+function dispatchSyncInternal(jobName, payload, options = {}) {
+  return (async () => {
+    const envelope = createDispatchEnvelope(jobName, payload, options);
+    const result = await dispatchThroughDriver(
+      resolveSyncExecutionDriver(),
+      envelope
+    );
+    return result.result;
+  })();
+}
+async function dispatchSync(jobName, payload, options = {}) {
+  return await dispatchSyncInternal(jobName, payload, options);
+}
+function dispatch(jobName, payload, options = {}) {
+  return new PendingQueueDispatch(jobName, payload, options);
+}
+var Queue = {
+  connection(name) {
+    return createQueueConnection(name);
+  },
+  dispatch,
+  dispatchSync
+};
+var queueRuntimeInternals = {
+  assertQueueJsonValue,
+  createQueueRuntimeBinding,
+  createDefaultDriverFactories,
+  createDispatchEnvelope,
+  createJobContext,
+  createJobEnvelope,
+  createQueueConnection,
+  createQueueDriverFactoryContext,
+  createQueueDriverFactoryMap,
+  closeQueueDrivers,
+  dispatchRecord,
+  dispatchThroughDriver,
+  executeRegisteredQueueJob,
+  executeRegisteredQueueJobCompletedHook,
+  executeRegisteredQueueJobFailedHook,
+  getQueueRuntimeState,
+  isPlainObject,
+  normalizeConnectionName: normalizeConnectionName2,
+  normalizeDelay,
+  normalizeQueueName: normalizeQueueName2,
+  resolveConnectionConfig,
+  resolveConnectionDriver,
+  resolveDriverFactory,
+  resolveSyncExecutionDriver,
+  resetQueueRuntimeState,
+  validateQueuePayload
+};
+async function closeQueueDrivers(drivers) {
+  const pending = [...drivers].map(async (driver) => {
+    try {
+      await driver.close();
+    } catch {
+    }
+  });
+  if (pending.length === 0) {
+    return;
+  }
+  await Promise.allSettled(pending);
+}
+
+// src/failed.ts
+function normalizeFailedStoreErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var QueueFailedStoreError = class extends Error {
+  constructor(action, cause) {
+    super(
+      `[Holo Queue] Failed job store could not ${action}: ${normalizeFailedStoreErrorMessage(cause)}`,
+      { cause }
+    );
+    this.name = "QueueFailedStoreError";
+  }
+};
+function wrapFailedStoreError(action, error) {
+  if (error instanceof QueueFailedStoreError) {
+    return error;
+  }
+  return new QueueFailedStoreError(action, error);
+}
+function getFailedJobStore() {
+  return queueRuntimeInternals.getQueueRuntimeState().failedJobStore;
+}
+function createRetriedEnvelope(record) {
+  return Object.freeze({
+    ...record.job,
+    attempts: 0,
+    createdAt: Date.now(),
+    availableAt: void 0
+  });
+}
+async function persistFailedQueueJob(reserved, error) {
+  const store = getFailedJobStore();
+  if (!store) {
+    return null;
+  }
+  try {
+    return await store.persistFailedJob(reserved, error);
+  } catch (cause) {
+    throw wrapFailedStoreError("persist the failed job", cause);
+  }
+}
+async function listFailedQueueJobs() {
+  const store = getFailedJobStore();
+  if (!store) {
+    return Object.freeze([]);
+  }
+  try {
+    return await store.listFailedJobs();
+  } catch (cause) {
+    throw wrapFailedStoreError("list failed jobs", cause);
+  }
+}
+async function retryFailedQueueJobs(identifier) {
+  const store = getFailedJobStore();
+  if (!store) {
+    return 0;
+  }
+  try {
+    return await store.retryFailedJobs(identifier, async (record) => {
+      const driver = queueRuntimeInternals.resolveConnectionDriver(record.job.connection);
+      await driver.dispatch(createRetriedEnvelope(record));
+    });
+  } catch (cause) {
+    throw wrapFailedStoreError("retry failed jobs", cause);
+  }
+}
+async function forgetFailedQueueJob(id) {
+  const store = getFailedJobStore();
+  if (!store) {
+    return false;
+  }
+  try {
+    return await store.forgetFailedJob(id);
+  } catch (cause) {
+    throw wrapFailedStoreError("forget the failed job", cause);
+  }
+}
+async function flushFailedQueueJobs() {
+  const store = getFailedJobStore();
+  if (!store) {
+    return 0;
+  }
+  try {
+    return await store.flushFailedJobs();
+  } catch (cause) {
+    throw wrapFailedStoreError("flush failed jobs", cause);
+  }
+}
+var queueFailedInternals = {
+  createRetriedEnvelope,
+  getFailedJobStore,
+  normalizeFailedStoreErrorMessage,
+  wrapFailedStoreError
+};
+
+// src/worker.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var QueueWorkerUnsupportedDriverError = class extends Error {
+  constructor(connectionName, driverName) {
+    super(
+      `[Holo Queue] Queue worker requires an async-capable driver, but connection "${connectionName}" uses "${driverName}".`
+    );
+  }
+};
+var QueueWorkerTimeoutError = class extends Error {
+  constructor(jobName, timeoutSeconds) {
+    super(`[Holo Queue] Queue job "${jobName}" exceeded timeout of ${timeoutSeconds} seconds.`);
+  }
+};
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function requireAsyncDriver(driver, connectionName) {
+  if (driver.mode !== "async") {
+    throw new QueueWorkerUnsupportedDriverError(connectionName, driver.driver);
+  }
+  return driver;
+}
+function requireRegisteredDefinition(jobName) {
+  const registered = getRegisteredQueueJob(jobName);
+  if (!registered) {
+    throw new Error(`[Holo Queue] Queue job "${jobName}" is not registered.`);
+  }
+  return registered.definition;
+}
+function normalizeQueueNames(queueNames, fallbackQueueName) {
+  if (!queueNames || queueNames.length === 0) {
+    return Object.freeze([fallbackQueueName ?? DEFAULT_QUEUE_NAME]);
+  }
+  const normalized = [...new Set(queueNames.map((name) => name.trim()).filter(Boolean))];
+  if (normalized.length === 0) {
+    throw new Error("[Holo Queue] Queue worker queue names must be non-empty strings.");
+  }
+  return Object.freeze(normalized);
+}
+function normalizeNonNegativeInteger(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`[Holo Queue] ${label} must be a non-negative integer.`);
+  }
+  return value;
+}
+function normalizePositiveInteger(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`[Holo Queue] ${label} must be a positive integer.`);
+  }
+  return value;
+}
+function createWorkerEvent(envelope, maxAttempts) {
+  return {
+    jobId: envelope.id,
+    jobName: envelope.name,
+    connection: envelope.connection,
+    queue: envelope.queue,
+    attempt: envelope.attempts + 1,
+    maxAttempts
+  };
+}
+function resolveRetryDelaySeconds(definition, attempt) {
+  const { backoff } = definition;
+  if (typeof backoff === "undefined") {
+    return void 0;
+  }
+  if (typeof backoff === "number") {
+    return backoff;
+  }
+  return backoff[Math.min(Math.max(attempt - 1, 0), backoff.length - 1)];
+}
+async function runWithTimeout(callback, jobName, timeoutSeconds, onTimeout) {
+  if (typeof timeoutSeconds === "undefined") {
+    return await callback;
+  }
+  return await Promise.race([
+    callback,
+    new Promise((_, reject) => {
+      const timer = setTimeout(() => {
+        onTimeout?.();
+        reject(new QueueWorkerTimeoutError(jobName, timeoutSeconds));
+      }, timeoutSeconds * 1e3);
+      callback.finally(() => {
+        clearTimeout(timer);
+      }).catch(() => {
+      });
+    })
+  ]);
+}
+async function processReservedJob(driver, reserved, options) {
+  const envelope = reserved.envelope;
+  const definition = requireRegisteredDefinition(envelope.name);
+  const maxAttempts = options.tries ?? envelope.maxAttempts;
+  const event = createWorkerEvent(envelope, maxAttempts);
+  const executionState = {
+    timedOut: false
+  };
+  let requestedReleaseDelay;
+  let requestedFailure;
+  let action;
+  try {
+    await runWithTimeout(
+      queueRuntimeInternals.executeRegisteredQueueJob(envelope, {
+        maxAttempts,
+        shouldSkipLifecycleHooks() {
+          return executionState.timedOut || typeof action !== "undefined";
+        },
+        async release(delaySeconds) {
+          if (!action) {
+            action = "release";
+            requestedReleaseDelay = delaySeconds;
+          }
+        },
+        async fail(error) {
+          if (!action) {
+            action = "fail";
+            requestedFailure = error;
+          }
+          throw error;
+        }
+      }),
+      envelope.name,
+      options.timeout ?? definition.timeout,
+      () => {
+        executionState.timedOut = true;
+      }
+    );
+    if (action === "release") {
+      await driver.release(reserved, typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : void 0);
+      await options.onJobReleased?.({
+        ...event,
+        ...typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : {}
+      });
+      return {
+        kind: "released",
+        ...typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : {}
+      };
+    }
+    if (action === "fail") {
+      const failure = requestedFailure;
+      await persistFailedQueueJob(reserved, failure);
+      await driver.delete(reserved);
+      await queueRuntimeInternals.executeRegisteredQueueJobFailedHook(envelope, failure, {
+        maxAttempts
+      });
+      await options.onJobFailed?.({
+        ...event,
+        error: failure
+      });
+      return {
+        kind: "failed",
+        error: failure
+      };
+    }
+    await driver.acknowledge(reserved);
+    await options.onJobProcessed?.(event);
+    return { kind: "processed" };
+  } catch (error) {
+    const resolvedError = error instanceof Error ? error : new Error(String(error));
+    const failure = resolvedError instanceof QueueWorkerTimeoutError ? resolvedError : requestedFailure ?? resolvedError;
+    if (resolvedError instanceof QueueWorkerTimeoutError) {
+      await persistFailedQueueJob(reserved, failure);
+      await driver.delete(reserved);
+      await queueRuntimeInternals.executeRegisteredQueueJobFailedHook(envelope, failure, {
+        maxAttempts
+      });
+      await options.onJobFailed?.({
+        ...event,
+        error: failure
+      });
+      return {
+        kind: "failed",
+        error: failure
+      };
+    }
+    if (action === "release") {
+      await driver.release(reserved, typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : void 0);
+      await options.onJobReleased?.({
+        ...event,
+        ...typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : {},
+        error: failure
+      });
+      return {
+        kind: "released",
+        ...typeof requestedReleaseDelay === "number" ? { delaySeconds: requestedReleaseDelay } : {},
+        error: failure
+      };
+    }
+    if (action === "fail" || event.attempt >= maxAttempts) {
+      await persistFailedQueueJob(reserved, failure);
+      await driver.delete(reserved);
+      await queueRuntimeInternals.executeRegisteredQueueJobFailedHook(envelope, failure, {
+        maxAttempts
+      });
+      await options.onJobFailed?.({
+        ...event,
+        error: failure
+      });
+      return {
+        kind: "failed",
+        error: failure
+      };
+    }
+    const delaySeconds = resolveRetryDelaySeconds(definition, event.attempt);
+    await driver.release(reserved, typeof delaySeconds === "number" ? { delaySeconds } : void 0);
+    await options.onJobReleased?.({
+      ...event,
+      ...typeof delaySeconds === "number" ? { delaySeconds } : {},
+      error: failure
+    });
+    return {
+      kind: "released",
+      ...typeof delaySeconds === "number" ? { delaySeconds } : {},
+      error: failure
+    };
+  }
+}
+function resolveWorkerStopReason(options, state) {
+  const now = Date.now();
+  if (typeof options.maxJobs === "number" && state.processed >= options.maxJobs) {
+    return "max-jobs";
+  }
+  if (typeof options.maxTime === "number" && now - state.startedAt >= options.maxTime * 1e3) {
+    return "max-time";
+  }
+  return void 0;
+}
+async function runQueueWorker(options = {}) {
+  const connectionName = options.connection ?? queueRuntimeInternals.getQueueRuntimeState().config.default;
+  const connection = queueRuntimeInternals.resolveConnectionConfig(
+    queueRuntimeInternals.getQueueRuntimeState().config,
+    connectionName
+  );
+  const queueNames = normalizeQueueNames(options.queueNames, connection.queue);
+  const sleepSeconds = normalizeNonNegativeInteger(options.sleep, "Queue worker sleep") ?? ("sleep" in connection && typeof connection.sleep === "number" ? connection.sleep : 1);
+  const maxJobs = normalizePositiveInteger(options.maxJobs, "Queue worker maxJobs");
+  const maxTime = normalizePositiveInteger(options.maxTime, "Queue worker maxTime");
+  const workerId = options.workerId?.trim() || randomUUID3();
+  const sleepFn = options.sleepFn ?? sleep;
+  const driver = requireAsyncDriver(queueRuntimeInternals.resolveConnectionDriver(connection.name), connection.name);
+  const startedAt = Date.now();
+  let processed = 0;
+  let released = 0;
+  let failed = 0;
+  const normalizedOptions = {
+    ...options,
+    connection: connection.name,
+    maxJobs,
+    maxTime
+  };
+  while (true) {
+    if (await options.shouldStop?.()) {
+      return {
+        processed,
+        released,
+        failed,
+        stoppedBecause: "signal"
+      };
+    }
+    const stopReason = resolveWorkerStopReason(normalizedOptions, {
+      processed: processed + released + failed,
+      startedAt
+    });
+    if (stopReason) {
+      return {
+        processed,
+        released,
+        failed,
+        stoppedBecause: stopReason
+      };
+    }
+    const reserved = await driver.reserve({
+      queueNames,
+      workerId
+    });
+    if (!reserved) {
+      await options.onIdle?.();
+      if (options.once === true) {
+        return {
+          processed,
+          released,
+          failed,
+          stoppedBecause: "once"
+        };
+      }
+      if (options.stopWhenEmpty === true) {
+        return {
+          processed,
+          released,
+          failed,
+          stoppedBecause: "empty"
+        };
+      }
+      if (sleepSeconds > 0) {
+        await sleepFn(sleepSeconds * 1e3);
+      }
+      continue;
+    }
+    const outcome = await processReservedJob(driver, reserved, options);
+    if (outcome.kind === "processed") {
+      processed += 1;
+    } else if (outcome.kind === "released") {
+      released += 1;
+    } else {
+      failed += 1;
+    }
+    if (options.once === true) {
+      return {
+        processed,
+        released,
+        failed,
+        stoppedBecause: "once"
+      };
+    }
+  }
+}
+async function clearQueueConnection(connectionName, input = {}) {
+  const connection = queueRuntimeInternals.resolveConnectionConfig(
+    queueRuntimeInternals.getQueueRuntimeState().config,
+    connectionName
+  );
+  const driver = queueRuntimeInternals.resolveConnectionDriver(connection.name);
+  return await driver.clear(input);
+}
+var queueWorkerInternals = {
+  createWorkerEvent,
+  normalizeNonNegativeInteger,
+  normalizePositiveInteger,
+  normalizeQueueNames,
+  processReservedJob,
+  requireAsyncDriver,
+  requireRegisteredDefinition,
+  resolveRetryDelaySeconds,
+  resolveWorkerStopReason,
+  runWithTimeout,
+  sleep
+};
+export {
+  DEFAULT_DATABASE_QUEUE_TABLE,
+  DEFAULT_FAILED_JOBS_CONNECTION,
+  DEFAULT_FAILED_JOBS_TABLE,
+  DEFAULT_QUEUE_BLOCK_FOR,
+  DEFAULT_QUEUE_CONNECTION,
+  DEFAULT_QUEUE_NAME,
+  DEFAULT_QUEUE_RETRY_AFTER,
+  DEFAULT_QUEUE_SLEEP,
+  Queue,
+  QueueFailedStoreError,
+  QueueReleaseUnsupportedError,
+  QueueWorkerTimeoutError,
+  QueueWorkerUnsupportedDriverError,
+  RedisQueueDriver,
+  RedisQueueDriverError,
+  clearQueueConnection,
+  configureQueueRuntime,
+  defineJob,
+  dispatch,
+  dispatchSync,
+  flushFailedQueueJobs,
+  forgetFailedQueueJob,
+  getQueueRuntime,
+  getRegisteredQueueJob,
+  holoQueueDefaults,
+  isQueueJobDefinition,
+  listFailedQueueJobs,
+  listRegisteredQueueJobs,
+  normalizeQueueConfig,
+  normalizeQueueJobDefinition,
+  persistFailedQueueJob,
+  queueFailedInternals,
+  queueInternals,
+  queueJobInternals,
+  queueRegistryInternals,
+  queueRuntimeInternals,
+  queueWorkerInternals,
+  redisQueueDriverFactory,
+  redisQueueDriverInternals,
+  registerQueueJob,
+  registerQueueJobs,
+  resetQueueRegistry,
+  resetQueueRuntime,
+  retryFailedQueueJobs,
+  runQueueWorker,
+  shutdownQueueRuntime,
+  syncQueueDriverFactory,
+  syncQueueDriverInternals,
+  unregisterQueueJob,
+  useQueueConnection
+};