@holo-js/queue 0.3.27 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holo-JS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/.holo-build-fingerprint

@@ -0,0 +1 @@
+b3ff4bfb2397046e791968a87d26b1663356144526c9d5ea746331426f2cb103

package/dist/{chunk-5MPOVBVE.mjs → chunk-CYZWPHVL.mjs}

@@ -1,3 +1,190 @@
+// src/contracts.ts
+var QUEUE_TIMER_MAX_SECONDS = Math.floor((2 ** 31 - 1) / 1e3);
+function getQueueJobDispatcher() {
+  return globalThis.__holoQueueJobDispatcher__;
+}
+function setQueueJobDispatcher(dispatcher) {
+  const runtime = globalThis;
+  runtime.__holoQueueJobDispatcher__ = dispatcher;
+}
+function getQueueJobSyncDispatcher() {
+  return globalThis.__holoQueueJobSyncDispatcher__;
+}
+function setQueueJobSyncDispatcher(dispatcher) {
+  const runtime = globalThis;
+  runtime.__holoQueueJobSyncDispatcher__ = dispatcher;
+}
+function getQueueJobDefinitionNames() {
+  const runtime = globalThis;
+  runtime.__holoQueueJobDefinitionNames__ ??= /* @__PURE__ */ new WeakMap();
+  return runtime.__holoQueueJobDefinitionNames__;
+}
+function getQueueJobDefinitionsByName() {
+  const runtime = globalThis;
+  runtime.__holoQueueJobDefinitionsByName__ ??= /* @__PURE__ */ new Map();
+  return runtime.__holoQueueJobDefinitionsByName__;
+}
+function setQueueJobDefinitionName(definition, name) {
+  getQueueJobDefinitionNames().set(definition, name);
+  const definitions = getQueueJobDefinitionsByName().get(name) ?? /* @__PURE__ */ new Set();
+  definitions.add(definition);
+  getQueueJobDefinitionsByName().set(name, definitions);
+}
+function deleteQueueJobDefinitionName(name) {
+  const definitions = getQueueJobDefinitionsByName().get(name);
+  for (const definition of definitions ?? []) {
+    if (getQueueJobDefinitionNames().get(definition) === name) {
+      getQueueJobDefinitionNames().delete(definition);
+    }
+  }
+  getQueueJobDefinitionsByName().delete(name);
+}
+function clearQueueJobDefinitionNames() {
+  for (const name of getQueueJobDefinitionsByName().keys()) {
+    deleteQueueJobDefinitionName(name);
+  }
+}
+function resolveQueueJobDefinitionName(definition) {
+  const name = getQueueJobDefinitionNames().get(definition);
+  if (name) {
+    return name;
+  }
+  throw new Error("[Holo Queue] Job definitions cannot dispatch before the job is registered.");
+}
+function dispatchDefinedQueueJob(definition, payload) {
+  const dispatcher = getQueueJobDispatcher();
+  if (!dispatcher) {
+    throw new Error("[Holo Queue] Job definitions cannot dispatch before the queue runtime is loaded.");
+  }
+  return dispatcher(resolveQueueJobDefinitionName(definition), payload);
+}
+function dispatchDefinedQueueJobSync(definition, payload) {
+  const dispatcher = getQueueJobSyncDispatcher();
+  if (!dispatcher) {
+    throw new Error("[Holo Queue] Job definitions cannot dispatch before the queue runtime is loaded.");
+  }
+  return dispatcher(resolveQueueJobDefinitionName(definition), payload);
+}
+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}.`);
+  }
+  if (typeof options.maximum === "number" && value > options.maximum) {
+    throw new Error(`[Holo Queue] ${label} must be less than or equal to ${options.maximum}.`);
+  }
+  return value;
+}
+function normalizeOptionalBoolean(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`[Holo Queue] ${label} must be a boolean when provided.`);
+  }
+  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, maximum: QUEUE_TIMER_MAX_SECONDS }) },
+    ...typeof job.failOnTimeout === "undefined" ? {} : { failOnTimeout: normalizeOptionalBoolean(job.failOnTimeout, "Job failOnTimeout") },
+    ...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) {
+  const normalized = normalizeQueueJobDefinition(job);
+  const registeredName = getQueueJobDefinitionNames().get(job);
+  if (registeredName) {
+    setQueueJobDefinitionName(normalized, registeredName);
+  }
+  Object.defineProperty(normalized, "dispatch", {
+    value(payload) {
+      return dispatchDefinedQueueJob(normalized, payload);
+    },
+    enumerable: false
+  });
+  Object.defineProperty(normalized, "dispatchSync", {
+    value(payload) {
+      return dispatchDefinedQueueJobSync(normalized, payload);
+    },
+    enumerable: false
+  });
+  return Object.freeze(normalized);
+}
+var queueJobInternals = {
+  clearQueueJobDefinitionNames,
+  deleteQueueJobDefinitionName,
+  dispatchDefinedQueueJob,
+  dispatchDefinedQueueJobSync,
+  normalizeQueueJobDefinition,
+  normalizeBackoff,
+  normalizeOptionalHook,
+  normalizeOptionalBoolean,
+  normalizeOptionalInteger,
+  normalizeOptionalString,
+  resolveQueueJobDefinitionName,
+  setQueueJobDefinitionName,
+  setQueueJobDispatcher,
+  setQueueJobSyncDispatcher
+};
+
 // src/config.ts
 import { registerConfigNormalizer } from "@holo-js/config/registry";
 var DEFAULT_QUEUE_CONNECTION = "sync";
@@ -22,7 +209,8 @@ var DEFAULT_QUEUE_CONFIG = Object.freeze({
     [DEFAULT_QUEUE_CONNECTION]: Object.freeze({
       name: DEFAULT_QUEUE_CONNECTION,
       driver: "sync",
-      queue: DEFAULT_QUEUE_NAME
+      queue: DEFAULT_QUEUE_NAME,
+      afterCommit: false
     })
   })
 });
@@ -41,6 +229,9 @@ function parseInteger(value, fallback, label, options = {}) {
   if (typeof options.minimum === "number" && integer < options.minimum) {
     throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
   }
+  if (typeof options.maximum === "number" && integer > options.maximum) {
+    throw new Error(`[Holo Queue] ${label} must be less than or equal to ${options.maximum}.`);
+  }
   return integer;
 }
 function normalizeConnectionName(value, label) {
@@ -56,11 +247,32 @@ function normalizeQueueName(value) {
 function normalizeOptionalRedisString(value) {
   return value?.trim() || void 0;
 }
+function assertQueueTimeoutBelowRetryAfter(subject, timeoutSeconds, connection) {
+  if (typeof timeoutSeconds !== "number" || !("retryAfter" in connection) || typeof connection.retryAfter !== "number") {
+    return;
+  }
+  if (timeoutSeconds < connection.retryAfter) {
+    return;
+  }
+  throw new Error(
+    `[Holo Queue] ${subject} timeout of ${timeoutSeconds} seconds must be less than connection "${connection.name}" retryAfter of ${connection.retryAfter} seconds.`
+  );
+}
+function normalizeConnectionAfterCommit(name, value) {
+  if (typeof value === "undefined") {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`[Holo Queue] queue connection "${name}" afterCommit must be a boolean.`);
+  }
+  return value;
+}
 function normalizeSyncConnection(name, config) {
   return Object.freeze({
     name,
     driver: "sync",
-    queue: normalizeQueueName(config.queue)
+    queue: normalizeQueueName(config.queue),
+    afterCommit: normalizeConnectionAfterCommit(name, config.afterCommit)
   });
 }
 function resolveSharedRedisConnection(redisConfig, connectionName) {
@@ -81,7 +293,7 @@ function parseRedisDatabaseFromUrl(url, label) {
   try {
     parsed = new URL(url);
   } catch (error) {
-    throw new Error(`[Holo Queue] ${label} is invalid: ${String(error)}`);
+    throw new Error(`[Holo Queue] ${label} is invalid: ${String(error)}`, { cause: error });
   }
   if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
     throw new Error(`[Holo Queue] ${label} is invalid: unsupported protocol "${parsed.protocol}".`);
@@ -160,8 +372,10 @@ function normalizeRedisConnection(name, config, redisConfig) {
     driver: "redis",
     connection: resolvedRedisConnection?.name ?? connectionName ?? name,
     queue: normalizeQueueName(config.queue),
+    afterCommit: normalizeConnectionAfterCommit(name, config.afterCommit),
     retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
-      minimum: 0
+      minimum: 1,
+      maximum: QUEUE_TIMER_MAX_SECONDS
     }),
     blockFor: parseInteger(config.blockFor, DEFAULT_QUEUE_BLOCK_FOR, `queue connection "${name}" blockFor`, {
       minimum: 0
@@ -174,23 +388,26 @@ function normalizeDatabaseConnection(name, config) {
     name,
     driver: "database",
     queue: normalizeQueueName(config.queue),
+    afterCommit: normalizeConnectionAfterCommit(name, config.afterCommit),
     retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
-      minimum: 0
+      minimum: 1
     }),
     sleep: parseInteger(config.sleep, DEFAULT_QUEUE_SLEEP, `queue connection "${name}" sleep`, {
-      minimum: 0
+      minimum: 0,
+      maximum: QUEUE_TIMER_MAX_SECONDS
     }),
     connection: config.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
     table: config.table?.trim() || DEFAULT_DATABASE_QUEUE_TABLE
   });
 }
 function normalizePluginConnection(name, config) {
-  const { driver, queue, ...options } = config;
+  const { driver, queue, afterCommit, ...options } = config;
   return Object.freeze({
     ...options,
     name,
     driver: normalizeConnectionName(driver, `queue connection "${name}" driver`),
-    queue: normalizeQueueName(queue)
+    queue: normalizeQueueName(queue),
+    afterCommit: normalizeConnectionAfterCommit(name, afterCommit)
   });
 }
 function normalizeConnectionConfig(name, config, redisConfig) {
@@ -257,6 +474,11 @@ registerConfigNormalizer({
 });
 
 export {
+  QUEUE_TIMER_MAX_SECONDS,
+  isQueueJobDefinition,
+  normalizeQueueJobDefinition,
+  defineJob,
+  queueJobInternals,
   DEFAULT_QUEUE_CONNECTION,
   DEFAULT_QUEUE_NAME,
   DEFAULT_QUEUE_RETRY_AFTER,
@@ -268,6 +490,7 @@ export {
   DEFAULT_REDIS_HOST,
   DEFAULT_REDIS_PORT,
   DEFAULT_REDIS_DB,
+  assertQueueTimeoutBelowRetryAfter,
   normalizeQueueConfig,
   holoQueueDefaults,
   queueInternals

package/dist/{config-Bleufve4.d.ts → config-Cztv8leT.d.ts}

@@ -15,7 +15,9 @@ declare function dispatchDefinedQueueJobSync<TPayload extends QueueJsonValue, TR
 declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
 declare function normalizeOptionalInteger(value: number | undefined, label: string, options?: {
     minimum?: number;
+    maximum?: number;
 }): number | undefined;
+declare function normalizeOptionalBoolean(value: boolean | undefined, label: string): boolean | undefined;
 declare function normalizeBackoff(value: number | readonly number[] | undefined): number | readonly number[] | undefined;
 declare function normalizeOptionalHook<THandler extends (...args: never[]) => unknown>(value: THandler | undefined, label: string): THandler | undefined;
 interface QueueJobContext {
@@ -40,6 +42,7 @@ interface QueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, T
     readonly tries?: number;
     readonly backoff?: number | readonly number[];
     readonly timeout?: number;
+    readonly failOnTimeout?: boolean;
     readonly onCompleted?: QueueJobCompletedHook<TPayload, TResult>;
     readonly onFailed?: QueueJobFailedHook<TPayload>;
     handle(payload: TPayload, context: QueueJobContext): Promise<TResult> | TResult;
@@ -64,6 +67,8 @@ interface QueueDispatchOptions {
     readonly connection?: string;
     readonly queue?: string;
     readonly delay?: QueueDelayValue;
+    readonly tries?: number;
+    readonly afterCommit?: boolean;
 }
 interface QueueDispatchResult {
     readonly jobId: string;
@@ -105,6 +110,7 @@ interface QueuePendingDispatch<TPayload extends QueueJsonValue = QueueJsonValue>
     onConnection(name: string): QueuePendingDispatch<TPayload>;
     onQueue(name: string): QueuePendingDispatch<TPayload>;
     delay(value: QueueDelayValue): QueuePendingDispatch<TPayload>;
+    afterCommit(): QueuePendingDispatch<TPayload>;
     onComplete(callback: QueueDispatchCompletedHook): QueuePendingDispatch<TPayload>;
     onFailed(callback: QueueDispatchFailedHook): QueuePendingDispatch<TPayload>;
     then<TResult1 = QueueDispatchResult, TResult2 = never>(onfulfilled?: ((value: QueueDispatchResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
@@ -151,6 +157,7 @@ interface QueueDriverBase {
     readonly name: string;
     readonly driver: NormalizedQueueConnectionConfig['driver'];
     readonly mode: 'sync' | 'async';
+    readonly acceptsJobId?: boolean;
     dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
     clear(input?: QueueClearInput): Promise<number>;
     close(): Promise<void>;
@@ -161,6 +168,7 @@ interface QueueAsyncDriver extends QueueDriverBase {
     acknowledge(job: QueueReservedJob): Promise<void>;
     release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
     delete(job: QueueReservedJob): Promise<void>;
+    abandon?(job: QueueReservedJob): void;
 }
 interface QueueSyncDriver extends QueueDriverBase {
     readonly mode: 'sync';
@@ -181,6 +189,7 @@ interface QueueWorkerOptions {
     readonly stopWhenEmpty?: boolean;
     readonly sleep?: number;
     readonly tries?: number;
+    readonly backoff?: number | readonly number[];
     readonly timeout?: number;
     readonly maxJobs?: number;
     readonly maxTime?: number;
@@ -241,6 +250,7 @@ interface QueueRedisConnectionConfig {
     readonly driver: 'redis';
     readonly connection?: string;
     readonly queue?: string;
+    readonly afterCommit?: boolean;
     readonly retryAfter?: number | string;
     readonly blockFor?: number | string;
     readonly redis?: {
@@ -260,6 +270,7 @@ interface QueueRedisConnectionConfig {
 interface QueueDatabaseConnectionConfig {
     readonly driver: 'database';
     readonly queue?: string;
+    readonly afterCommit?: boolean;
     readonly retryAfter?: number | string;
     readonly sleep?: number | string;
     readonly connection?: string;
@@ -268,6 +279,7 @@ interface QueueDatabaseConnectionConfig {
 interface QueueSyncConnectionConfig {
     readonly driver: 'sync';
     readonly queue?: string;
+    readonly afterCommit?: boolean;
 }
 interface QueuePluginConnectionConfig {
     readonly driver: string;
@@ -289,12 +301,14 @@ interface NormalizedQueueSyncConnectionConfig {
     readonly name: string;
     readonly driver: 'sync';
     readonly queue: string;
+    readonly afterCommit: boolean;
 }
 interface NormalizedQueueRedisConnectionConfig {
     readonly name: string;
     readonly driver: 'redis';
     readonly connection: string;
     readonly queue: string;
+    readonly afterCommit: boolean;
     readonly retryAfter: number;
     readonly blockFor: number;
     readonly redis: {
@@ -333,6 +347,7 @@ interface NormalizedQueueDatabaseConnectionConfig {
     readonly name: string;
     readonly driver: 'database';
     readonly queue: string;
+    readonly afterCommit: boolean;
     readonly retryAfter: number;
     readonly sleep: number;
     readonly connection: string;
@@ -342,6 +357,7 @@ interface NormalizedQueuePluginConnectionConfig {
     readonly name: string;
     readonly driver: string;
     readonly queue: string;
+    readonly afterCommit: boolean;
     readonly [key: string]: unknown;
 }
 type NormalizedQueueConnectionConfig = NormalizedQueueSyncConnectionConfig | NormalizedQueueRedisConnectionConfig | NormalizedQueueDatabaseConnectionConfig | NormalizedQueuePluginConnectionConfig;
@@ -358,6 +374,7 @@ declare const queueJobInternals: {
     normalizeQueueJobDefinition: typeof normalizeQueueJobDefinition;
     normalizeBackoff: typeof normalizeBackoff;
     normalizeOptionalHook: typeof normalizeOptionalHook;
+    normalizeOptionalBoolean: typeof normalizeOptionalBoolean;
     normalizeOptionalInteger: typeof normalizeOptionalInteger;
     normalizeOptionalString: typeof normalizeOptionalString;
     resolveQueueJobDefinitionName: typeof resolveQueueJobDefinitionName;
@@ -379,7 +396,9 @@ declare const DEFAULT_REDIS_PORT = 6379;
 declare const DEFAULT_REDIS_DB = 0;
 declare function parseInteger(value: number | string | undefined, fallback: number, label: string, options?: {
     minimum?: number;
+    maximum?: number;
 }): number;
+declare function assertQueueTimeoutBelowRetryAfter(subject: string, timeoutSeconds: number | undefined, connection: NormalizedQueueConnectionConfig): void;
 declare function normalizeQueueConfig(config?: HoloQueueConfig, redisConfig?: QueueSharedRedisConfig): NormalizedHoloQueueConfig;
 declare const holoQueueDefaults: Readonly<NormalizedHoloQueueConfig>;
 declare const queueInternals: {
@@ -391,4 +410,5 @@ declare module '@holo-js/config' {
     }
 }
 
-export { type QueueDispatchFailedHook as $, type QueueWorkerJobEvent as A, type QueueAsyncDriver as B, type QueueWorkerRunOptions as C, type QueueJobDefinition as D, type QueueWorkerOptions as E, type QueueWorkerResult as F, DEFAULT_DATABASE_QUEUE_TABLE as G, type HoloQueueJobRegistry as H, DEFAULT_FAILED_JOBS_CONNECTION as I, DEFAULT_FAILED_JOBS_TABLE as J, DEFAULT_QUEUE_BLOCK_FOR as K, DEFAULT_QUEUE_CONNECTION as L, DEFAULT_QUEUE_NAME as M, type NormalizedQueueSyncConnectionConfig as N, DEFAULT_QUEUE_RETRY_AFTER as O, DEFAULT_QUEUE_SLEEP as P, type QueueRegisteredJob as Q, type RegisterableQueueJobDefinition as R, type DefinedQueueJobDefinition as S, type ExportedQueueJobDefinition as T, type NormalizedQueueDatabaseConnectionConfig as U, type NormalizedQueueFailedStoreConfig as V, type NormalizedQueuePluginConnectionConfig as W, type NormalizedQueueRedisConnectionConfig as X, type QueueConnectionConfig as Y, type QueueDatabaseConnectionConfig as Z, type QueueDispatchCompletedHook as _, type QueueJsonValue as a, type QueueEnqueueResult as a0, type QueueFailedStoreConfig as a1, type QueuePluginConnectionConfig as a2, type QueueRedisConnectionConfig as a3, type QueueReleaseOptions as a4, type QueueReserveInput as a5, type QueueSharedRedisConnectionConfig as a6, type QueueSyncConnectionConfig as a7, type QueueWorkerHooks as a8, defineJob as a9, holoQueueDefaults as aa, isQueueJobDefinition as ab, normalizeQueueConfig as ac, normalizeQueueJobDefinition as ad, queueInternals as ae, queueJobInternals as af, DEFAULT_REDIS_DB as ag, DEFAULT_REDIS_HOST as ah, DEFAULT_REDIS_PORT as ai, type RegisterQueueJobOptions as b, type QueueDriverFactory as c, type QueueSyncDriver as d, type QueueDriverFactoryContext as e, type QueueJobEnvelope as f, type QueueDriverDispatchResult as g, type QueueConnectionFacade as h, type QueuePayloadFor as i, type QueueDispatchOptions as j, type QueuePendingDispatch as k, type QueueResultFor as l, type HoloQueueConfig as m, type NormalizedHoloQueueConfig as n, type QueueSharedRedisConfig as o, type QueueFailedJobStore as p, type QueueRuntimeBinding as q, type QueueDriver as r, type QueueJobContextOverrides as s, type QueueJobContext as t, type QueueDispatchResult as u, type QueueDelayValue as v, type NormalizedQueueConnectionConfig as w, type QueueFailedJobRecord as x, type QueueReservedJob as y, type QueueClearInput as z };
+export { DEFAULT_DATABASE_QUEUE_TABLE as F, DEFAULT_FAILED_JOBS_CONNECTION as G, DEFAULT_FAILED_JOBS_TABLE as I, DEFAULT_QUEUE_BLOCK_FOR as J, DEFAULT_QUEUE_CONNECTION as K, DEFAULT_QUEUE_NAME as L, DEFAULT_QUEUE_RETRY_AFTER as M, DEFAULT_QUEUE_SLEEP as O, defineJob as a9, holoQueueDefaults as aa, isQueueJobDefinition as ab, normalizeQueueConfig as ac, normalizeQueueJobDefinition as ad, queueInternals as ae, queueJobInternals as af, DEFAULT_REDIS_DB as ag, DEFAULT_REDIS_HOST as ah, DEFAULT_REDIS_PORT as ai, assertQueueTimeoutBelowRetryAfter as aj };
+export type { QueueEnqueueResult as $, QueueWorkerJobEvent as A, QueueAsyncDriver as B, QueueWorkerRunOptions as C, QueueWorkerOptions as D, QueueWorkerResult as E, HoloQueueJobRegistry as H, NormalizedQueueSyncConnectionConfig as N, DefinedQueueJobDefinition as P, QueueRegisteredJob as Q, RegisterableQueueJobDefinition as R, ExportedQueueJobDefinition as S, NormalizedQueueDatabaseConnectionConfig as T, NormalizedQueueFailedStoreConfig as U, NormalizedQueuePluginConnectionConfig as V, NormalizedQueueRedisConnectionConfig as W, QueueConnectionConfig as X, QueueDatabaseConnectionConfig as Y, QueueDispatchCompletedHook as Z, QueueDispatchFailedHook as _, QueueJsonValue as a, QueueFailedStoreConfig as a0, QueueJobDefinition as a1, QueuePluginConnectionConfig as a2, QueueRedisConnectionConfig as a3, QueueReleaseOptions as a4, QueueReserveInput as a5, QueueSharedRedisConnectionConfig as a6, QueueSyncConnectionConfig as a7, QueueWorkerHooks as a8, RegisterQueueJobOptions as b, QueueDriverFactory as c, QueueSyncDriver as d, QueueDriverFactoryContext as e, QueueJobEnvelope as f, QueueDriverDispatchResult as g, QueueConnectionFacade as h, QueuePayloadFor as i, QueueDispatchOptions as j, QueuePendingDispatch as k, QueueResultFor as l, HoloQueueConfig as m, NormalizedHoloQueueConfig as n, QueueSharedRedisConfig as o, QueueFailedJobStore as p, QueueRuntimeBinding as q, QueueDriver as r, QueueJobContextOverrides as s, QueueJobContext as t, QueueDispatchResult as u, QueueDelayValue as v, NormalizedQueueConnectionConfig as w, QueueFailedJobRecord as x, QueueReservedJob as y, QueueClearInput as z };

package/dist/config.d.ts

@@ -1 +1 @@
-export { G as DEFAULT_DATABASE_QUEUE_TABLE, I as DEFAULT_FAILED_JOBS_CONNECTION, J as DEFAULT_FAILED_JOBS_TABLE, K as DEFAULT_QUEUE_BLOCK_FOR, L as DEFAULT_QUEUE_CONNECTION, M as DEFAULT_QUEUE_NAME, O as DEFAULT_QUEUE_RETRY_AFTER, P as DEFAULT_QUEUE_SLEEP, ag as DEFAULT_REDIS_DB, ah as DEFAULT_REDIS_HOST, ai as DEFAULT_REDIS_PORT, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, w as NormalizedQueueConnectionConfig, U as NormalizedQueueDatabaseConnectionConfig, V as NormalizedQueueFailedStoreConfig, W as NormalizedQueuePluginConnectionConfig, X as NormalizedQueueRedisConnectionConfig, N as NormalizedQueueSyncConnectionConfig, Y as QueueConnectionConfig, Z as QueueDatabaseConnectionConfig, a1 as QueueFailedStoreConfig, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, o as QueueSharedRedisConfig, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, aa as holoQueueDefaults, ac as normalizeQueueConfig, ae as queueInternals } from './config-Bleufve4.js';
+export { F as DEFAULT_DATABASE_QUEUE_TABLE, G as DEFAULT_FAILED_JOBS_CONNECTION, I as DEFAULT_FAILED_JOBS_TABLE, J as DEFAULT_QUEUE_BLOCK_FOR, K as DEFAULT_QUEUE_CONNECTION, L as DEFAULT_QUEUE_NAME, M as DEFAULT_QUEUE_RETRY_AFTER, O as DEFAULT_QUEUE_SLEEP, ag as DEFAULT_REDIS_DB, ah as DEFAULT_REDIS_HOST, ai as DEFAULT_REDIS_PORT, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, w as NormalizedQueueConnectionConfig, T as NormalizedQueueDatabaseConnectionConfig, U as NormalizedQueueFailedStoreConfig, V as NormalizedQueuePluginConnectionConfig, W as NormalizedQueueRedisConnectionConfig, N as NormalizedQueueSyncConnectionConfig, X as QueueConnectionConfig, Y as QueueDatabaseConnectionConfig, a0 as QueueFailedStoreConfig, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, o as QueueSharedRedisConfig, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, aj as assertQueueTimeoutBelowRetryAfter, aa as holoQueueDefaults, ac as normalizeQueueConfig, ae as queueInternals } from './config-Cztv8leT.js';

package/dist/config.mjs

@@ -10,10 +10,11 @@ import {
   DEFAULT_REDIS_DB,
   DEFAULT_REDIS_HOST,
   DEFAULT_REDIS_PORT,
+  assertQueueTimeoutBelowRetryAfter,
   holoQueueDefaults,
   normalizeQueueConfig,
   queueInternals
-} from "./chunk-5MPOVBVE.mjs";
+} from "./chunk-CYZWPHVL.mjs";
 export {
   DEFAULT_DATABASE_QUEUE_TABLE,
   DEFAULT_FAILED_JOBS_CONNECTION,
@@ -26,6 +27,7 @@ export {
   DEFAULT_REDIS_DB,
   DEFAULT_REDIS_HOST,
   DEFAULT_REDIS_PORT,
+  assertQueueTimeoutBelowRetryAfter,
   holoQueueDefaults,
   normalizeQueueConfig,
   queueInternals

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Q as QueueRegisteredJob, a as QueueJsonValue, R as RegisterableQueueJobDefinition, b as RegisterQueueJobOptions, c as QueueDriverFactory, N as NormalizedQueueSyncConnectionConfig, d as QueueSyncDriver, e as QueueDriverFactoryContext, f as QueueJobEnvelope, g as QueueDriverDispatchResult, h as QueueConnectionFacade, H as HoloQueueJobRegistry, i as QueuePayloadFor, j as QueueDispatchOptions, k as QueuePendingDispatch, l as QueueResultFor, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, o as QueueSharedRedisConfig, p as QueueFailedJobStore, q as QueueRuntimeBinding, r as QueueDriver, s as QueueJobContextOverrides, t as QueueJobContext, u as QueueDispatchResult, v as QueueDelayValue, w as NormalizedQueueConnectionConfig, x as QueueFailedJobRecord, y as QueueReservedJob, z as QueueClearInput, A as QueueWorkerJobEvent, B as QueueAsyncDriver, C as QueueWorkerRunOptions, D as QueueJobDefinition, E as QueueWorkerOptions, F as QueueWorkerResult } from './config-Bleufve4.js';
-export { G as DEFAULT_DATABASE_QUEUE_TABLE, I as DEFAULT_FAILED_JOBS_CONNECTION, J as DEFAULT_FAILED_JOBS_TABLE, K as DEFAULT_QUEUE_BLOCK_FOR, L as DEFAULT_QUEUE_CONNECTION, M as DEFAULT_QUEUE_NAME, O as DEFAULT_QUEUE_RETRY_AFTER, P as DEFAULT_QUEUE_SLEEP, S as DefinedQueueJobDefinition, T as ExportedQueueJobDefinition, U as NormalizedQueueDatabaseConnectionConfig, V as NormalizedQueueFailedStoreConfig, W as NormalizedQueuePluginConnectionConfig, X as NormalizedQueueRedisConnectionConfig, Y as QueueConnectionConfig, Z as QueueDatabaseConnectionConfig, _ as QueueDispatchCompletedHook, $ as QueueDispatchFailedHook, a0 as QueueEnqueueResult, a1 as QueueFailedStoreConfig, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, a4 as QueueReleaseOptions, a5 as QueueReserveInput, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, a8 as QueueWorkerHooks, a9 as defineJob, aa as holoQueueDefaults, ab as isQueueJobDefinition, ac as normalizeQueueConfig, ad as normalizeQueueJobDefinition, ae as queueInternals, af as queueJobInternals } from './config-Bleufve4.js';
+import { Q as QueueRegisteredJob, a as QueueJsonValue, R as RegisterableQueueJobDefinition, b as RegisterQueueJobOptions, c as QueueDriverFactory, N as NormalizedQueueSyncConnectionConfig, d as QueueSyncDriver, e as QueueDriverFactoryContext, f as QueueJobEnvelope, g as QueueDriverDispatchResult, h as QueueConnectionFacade, H as HoloQueueJobRegistry, i as QueuePayloadFor, j as QueueDispatchOptions, k as QueuePendingDispatch, l as QueueResultFor, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, o as QueueSharedRedisConfig, p as QueueFailedJobStore, q as QueueRuntimeBinding, r as QueueDriver, s as QueueJobContextOverrides, t as QueueJobContext, u as QueueDispatchResult, v as QueueDelayValue, w as NormalizedQueueConnectionConfig, x as QueueFailedJobRecord, y as QueueReservedJob, z as QueueClearInput, A as QueueWorkerJobEvent, B as QueueAsyncDriver, C as QueueWorkerRunOptions, D as QueueWorkerOptions, E as QueueWorkerResult } from './config-Cztv8leT.js';
+export { F as DEFAULT_DATABASE_QUEUE_TABLE, G as DEFAULT_FAILED_JOBS_CONNECTION, I as DEFAULT_FAILED_JOBS_TABLE, J as DEFAULT_QUEUE_BLOCK_FOR, K as DEFAULT_QUEUE_CONNECTION, L as DEFAULT_QUEUE_NAME, M as DEFAULT_QUEUE_RETRY_AFTER, O as DEFAULT_QUEUE_SLEEP, P as DefinedQueueJobDefinition, S as ExportedQueueJobDefinition, T as NormalizedQueueDatabaseConnectionConfig, U as NormalizedQueueFailedStoreConfig, V as NormalizedQueuePluginConnectionConfig, W as NormalizedQueueRedisConnectionConfig, X as QueueConnectionConfig, Y as QueueDatabaseConnectionConfig, Z as QueueDispatchCompletedHook, _ as QueueDispatchFailedHook, $ as QueueEnqueueResult, a0 as QueueFailedStoreConfig, a1 as QueueJobDefinition, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, a4 as QueueReleaseOptions, a5 as QueueReserveInput, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, a8 as QueueWorkerHooks, a9 as defineJob, aa as holoQueueDefaults, ab as isQueueJobDefinition, ac as normalizeQueueConfig, ad as normalizeQueueJobDefinition, ae as queueInternals, af as queueJobInternals } from './config-Cztv8leT.js';
 
 declare function deriveJobNameFromSourcePath(sourcePath: string): string;
 declare function registerQueueJob<TPayload extends QueueJsonValue, TResult>(definition: RegisterableQueueJobDefinition<TPayload, TResult>, options?: RegisterQueueJobOptions): QueueRegisteredJob<TPayload, TResult>;
@@ -19,6 +19,7 @@ declare class SyncQueueDriver implements QueueSyncDriver {
     readonly name: string;
     readonly driver: "sync";
     readonly mode: "sync";
+    readonly acceptsJobId = true;
     private readonly context;
     constructor(connection: NormalizedQueueSyncConnectionConfig, context: QueueDriverFactoryContext);
     dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
@@ -69,10 +70,26 @@ declare function resolveDriverFactory(state: RuntimeQueueState, connection: Norm
 declare function loadQueuePluginDrivers(projectRoot?: string, pluginNames?: readonly string[]): Promise<void>;
 declare function resolveConnectionDriver(connectionName?: string): QueueDriver;
 declare function resolveSyncExecutionDriver(): QueueDriver;
-declare function createJobEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options: QueueDispatchOptions): QueueJobEnvelope<TPayload>;
-declare function createDispatchEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options?: QueueDispatchOptions): QueueJobEnvelope<TPayload>;
-declare function dispatchRecord(envelope: QueueJobEnvelope): Promise<QueueDispatchResult>;
+declare function createJobEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options: QueueDispatchOptions, { validateTimeout }?: {
+    validateTimeout?: boolean;
+}): QueueJobEnvelope<TPayload>;
+declare function createDispatchEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options?: QueueDispatchOptions, { runsInline }?: {
+    runsInline?: boolean;
+}): QueueJobEnvelope<TPayload>;
+type DispatchOutcomeHandlers = {
+    completed(result: QueueDispatchResult): Promise<void>;
+    failed(error: unknown): Promise<void>;
+};
+declare function dispatchRecord(envelope: QueueJobEnvelope, options: Pick<QueueDispatchOptions, 'afterCommit'>, handlers: DispatchOutcomeHandlers): Promise<QueueDispatchResult>;
 declare function createQueueConnection(name?: string): QueueConnectionFacade;
+type QueueJobTimeoutCandidate = {
+    readonly name: string;
+    readonly definition: {
+        readonly timeout?: number;
+        readonly connection?: string;
+    };
+};
+declare function assertQueueJobTimeouts(jobs: readonly QueueJobTimeoutCandidate[]): void;
 declare function configureQueueRuntime(options?: ConfigureQueueRuntimeOptions): void;
 declare function resetQueueRuntimeState(state: RuntimeQueueState): void;
 declare function shutdownQueueRuntime(): Promise<void>;
@@ -170,15 +187,16 @@ type QueueWorkerProcessingOutcome = {
 };
 declare function sleep(milliseconds: number): Promise<void>;
 declare function requireAsyncDriver(driver: QueueDriver, connectionName: string): QueueAsyncDriver;
-declare function requireRegisteredDefinition(jobName: string): QueueJobDefinition;
 declare function normalizeQueueNames(queueNames: readonly string[] | undefined, fallbackQueueName: string | undefined): readonly string[];
-declare function normalizeNonNegativeInteger(value: number | undefined, label: string): number | undefined;
+declare function normalizeNonNegativeInteger(value: number | undefined, label: string, options?: {
+    maximum?: number;
+}): number | undefined;
 declare function normalizePositiveInteger(value: number | undefined, label: string): number | undefined;
 declare function createWorkerEvent(envelope: QueueJobEnvelope, maxAttempts: number): QueueWorkerJobEvent;
-declare function resolveRetryDelaySeconds(definition: QueueJobDefinition, attempt: number): number | undefined;
-declare function runWorkerHook(jobName: string, hookName: 'onJobFailed' | 'onJobProcessed' | 'onJobReleased', callback: () => void | Promise<void>): Promise<void>;
+declare function resolveRetryDelaySeconds(backoff: number | readonly number[] | undefined, attempt: number): number | undefined;
+declare function runWorkerHook(hookName: 'onJobFailed' | 'onJobProcessed' | 'onJobReleased', callback: () => void | Promise<void>): Promise<void>;
 declare function runWithTimeout<TResult>(callback: Promise<TResult>, jobName: string, timeoutSeconds: number | undefined, onTimeout?: () => void): Promise<TResult>;
-declare function processReservedJob(driver: QueueAsyncDriver, reserved: QueueReservedJob<QueueJsonValue>, options: Pick<QueueWorkerRunOptions, 'timeout' | 'tries' | 'onJobFailed' | 'onJobProcessed' | 'onJobReleased'>): Promise<QueueWorkerProcessingOutcome>;
+declare function processReservedJob(driver: QueueAsyncDriver, reserved: QueueReservedJob<QueueJsonValue>, options: Pick<QueueWorkerRunOptions, 'timeout' | 'tries' | 'backoff' | 'onJobFailed' | 'onJobProcessed' | 'onJobReleased'>): Promise<QueueWorkerProcessingOutcome>;
 declare function resolveWorkerStopReason(options: QueueWorkerOptions, state: {
     readonly processed: number;
     readonly startedAt: number;
@@ -192,7 +210,6 @@ declare const queueWorkerInternals: {
     normalizeQueueNames: typeof normalizeQueueNames;
     processReservedJob: typeof processReservedJob;
     requireAsyncDriver: typeof requireAsyncDriver;
-    requireRegisteredDefinition: typeof requireRegisteredDefinition;
     resolveRetryDelaySeconds: typeof resolveRetryDelaySeconds;
     resolveWorkerStopReason: typeof resolveWorkerStopReason;
     runWithTimeout: typeof runWithTimeout;
@@ -202,4 +219,4 @@ declare const queueWorkerInternals: {
 
 declare function defineQueueConfig<TConfig extends HoloQueueConfig>(config: TConfig): Readonly<TConfig>;
 
-export { HoloQueueConfig, HoloQueueJobRegistry, NormalizedHoloQueueConfig, NormalizedQueueConnectionConfig, NormalizedQueueSyncConnectionConfig, Queue, QueueAsyncDriver, QueueClearInput, QueueConnectionFacade, QueueDelayValue, QueueDispatchOptions, QueueDispatchResult, QueueDriver, QueueDriverDispatchResult, QueueDriverFactory, QueueDriverFactoryContext, QueueFailedJobRecord, QueueFailedJobStore, QueueFailedStoreError, QueueJobContext, QueueJobContextOverrides, QueueJobDefinition, QueueJobEnvelope, QueueJsonValue, QueuePayloadFor, QueuePendingDispatch, QueueRegisteredJob, QueueReleaseUnsupportedError, QueueReservedJob, QueueResultFor, QueueRuntimeBinding, QueueSharedRedisConfig, QueueSyncDriver, QueueWorkerJobEvent, QueueWorkerOptions, QueueWorkerResult, QueueWorkerRunOptions, QueueWorkerTimeoutError, QueueWorkerUnsupportedDriverError, RegisterQueueJobOptions, RegisterableQueueJobDefinition, clearQueueConnection, configureQueueRuntime, defineQueueConfig, dispatch, dispatchSync, flushFailedQueueJobs, forgetFailedQueueJob, getQueueRuntime, getRegisteredQueueJob, listFailedQueueJobs, listRegisteredQueueJobs, loadQueuePluginDriverFactories, loadQueuePluginDrivers, persistFailedQueueJob, queueFailedInternals, queueRegistryInternals, queueRuntimeInternals, queueWorkerInternals, registerQueueJob, registerQueueJobs, resetQueuePluginDriverFactories, resetQueueRegistry, resetQueueRuntime, retryFailedQueueJobs, runQueueWorker, shutdownQueueRuntime, syncQueueDriverFactory, syncQueueDriverInternals, unregisterQueueJob, useQueueConnection };
+export { HoloQueueConfig, HoloQueueJobRegistry, NormalizedHoloQueueConfig, NormalizedQueueConnectionConfig, NormalizedQueueSyncConnectionConfig, Queue, QueueAsyncDriver, QueueClearInput, QueueConnectionFacade, QueueDelayValue, QueueDispatchOptions, QueueDispatchResult, QueueDriver, QueueDriverDispatchResult, QueueDriverFactory, QueueDriverFactoryContext, QueueFailedJobRecord, QueueFailedJobStore, QueueFailedStoreError, QueueJobContext, QueueJobContextOverrides, QueueJobEnvelope, QueueJsonValue, QueuePayloadFor, QueuePendingDispatch, QueueRegisteredJob, QueueReleaseUnsupportedError, QueueReservedJob, QueueResultFor, QueueRuntimeBinding, QueueSharedRedisConfig, QueueSyncDriver, QueueWorkerJobEvent, QueueWorkerOptions, QueueWorkerResult, QueueWorkerRunOptions, QueueWorkerTimeoutError, QueueWorkerUnsupportedDriverError, RegisterQueueJobOptions, RegisterableQueueJobDefinition, assertQueueJobTimeouts, clearQueueConnection, configureQueueRuntime, defineQueueConfig, dispatch, dispatchSync, flushFailedQueueJobs, forgetFailedQueueJob, getQueueRuntime, getRegisteredQueueJob, listFailedQueueJobs, listRegisteredQueueJobs, loadQueuePluginDriverFactories, loadQueuePluginDrivers, persistFailedQueueJob, queueFailedInternals, queueRegistryInternals, queueRuntimeInternals, queueWorkerInternals, registerQueueJob, registerQueueJobs, resetQueuePluginDriverFactories, resetQueueRegistry, resetQueueRuntime, retryFailedQueueJobs, runQueueWorker, shutdownQueueRuntime, syncQueueDriverFactory, syncQueueDriverInternals, unregisterQueueJob, useQueueConnection };