@orchestr-sh/orchestr 1.10.0 → 1.11.0

package/dist/Queue/Middleware/RateLimited.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimited.d.cts","names":[],"sources":["../../../src/Queue/Middleware/RateLimited.ts"],"mappings":";;;;cAwBa,WAAA,YAAuB,aAAA;EAetB;;;EAAA,UALA,GAAA;EAaC;;;EAAA,UARD,WAAA;EA0CZ;;;EAAA,UArCY,YAAA;;;;YAhBF,mBAAA;;;;;EAME,GAAA;;;;EAKA,WAAA;;;;EAKA,YAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;EAkCnD,YAAA,CAAa,OAAA;AAAA"}

package/dist/Queue/Middleware/RateLimited.d.mts

@@ -0,0 +1,43 @@
+import { JobMiddleware } from "./JobMiddleware.mjs";
+import { Job } from "../Job.mjs";
+
+//#region src/Queue/Middleware/RateLimited.d.ts
+declare class RateLimited implements JobMiddleware {
+  /**
+   * The rate limiter key
+   */
+  protected key: string;
+  /**
+   * The maximum number of attempts within the decay period
+   */
+  protected maxAttempts: number;
+  /**
+   * The number of seconds until the rate limit resets
+   */
+  protected decaySeconds: number;
+  /**
+   * The number of seconds to release the job for when rate limited
+   */
+  protected releaseAfterSeconds: number;
+  constructor(
+  /**
+   * The rate limiter key
+   */
+  key: string,
+  /**
+   * The maximum number of attempts within the decay period
+   */
+  maxAttempts?: number,
+  /**
+   * The number of seconds until the rate limit resets
+   */
+  decaySeconds?: number);
+  handle(job: Job, next: () => Promise<void>): Promise<void>;
+  /**
+   * Set the number of seconds to release the job for
+   */
+  releaseAfter(seconds: number): this;
+}
+//#endregion
+export { RateLimited };
+//# sourceMappingURL=RateLimited.d.mts.map

package/dist/Queue/Middleware/RateLimited.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimited.d.mts","names":[],"sources":["../../../src/Queue/Middleware/RateLimited.ts"],"mappings":";;;;cAwBa,WAAA,YAAuB,aAAA;EAetB;;;EAAA,UALA,GAAA;EAaC;;;EAAA,UARD,WAAA;EA0CZ;;;EAAA,UArCY,YAAA;;;;YAhBF,mBAAA;;;;;EAME,GAAA;;;;EAKA,WAAA;;;;EAKA,YAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;EAkCnD,YAAA,CAAa,OAAA;AAAA"}

package/dist/Queue/Middleware/RateLimited.mjs

@@ -0,0 +1,2 @@
+const e=new Map;var t=class{releaseAfterSeconds=0;constructor(e,t=1,n=60){this.key=e,this.maxAttempts=t,this.decaySeconds=n}async handle(t,n){let r=Math.floor(Date.now()/1e3),i=e.get(this.key);i&&i.resetAt<=r&&e.delete(this.key);let a=e.get(this.key);if(a&&a.count>=this.maxAttempts){let e=a.resetAt-r;t.release(this.releaseAfterSeconds||e);return}a?a.count++:e.set(this.key,{count:1,resetAt:r+this.decaySeconds}),await n()}releaseAfter(e){return this.releaseAfterSeconds=e,this}};export{t as RateLimited};
+//# sourceMappingURL=RateLimited.mjs.map

package/dist/Queue/Middleware/RateLimited.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimited.mjs","names":[],"sources":["../../../src/Queue/Middleware/RateLimited.ts"],"sourcesContent":["/**\n * RateLimited Middleware\n *\n * Rate limits job execution. When the rate limit is exceeded,\n * the job is released back onto the queue.\n *\n * Mirrors Laravel's Illuminate\\Queue\\Middleware\\RateLimited.\n *\n * @example\n * ```typescript\n * class ProcessPodcast extends Job {\n *   middleware() {\n *     return [new RateLimited('podcasts', 10, 60)];\n *   }\n * }\n * ```\n */\n\nimport type { Job } from '@/Queue/Job';\nimport type { JobMiddleware } from './JobMiddleware';\n\n// Simple in-memory rate limiter store\nconst rateLimiterStore: Map<string, { count: number; resetAt: number }> = new Map();\n\nexport class RateLimited implements JobMiddleware {\n  /**\n   * The number of seconds to release the job for when rate limited\n   */\n  protected releaseAfterSeconds: number = 0;\n\n  constructor(\n    /**\n     * The rate limiter key\n     */\n    protected key: string,\n\n    /**\n     * The maximum number of attempts within the decay period\n     */\n    protected maxAttempts: number = 1,\n\n    /**\n     * The number of seconds until the rate limit resets\n     */\n    protected decaySeconds: number = 60\n  ) {}\n\n  async handle(job: Job, next: () => Promise<void>): Promise<void> {\n    const now = Math.floor(Date.now() / 1000);\n    const limiter = rateLimiterStore.get(this.key);\n\n    // Check if the rate limit has expired\n    if (limiter && limiter.resetAt <= now) {\n      rateLimiterStore.delete(this.key);\n    }\n\n    const current = rateLimiterStore.get(this.key);\n\n    if (current && current.count >= this.maxAttempts) {\n      // Rate limited - release the job back\n      const retryAfter = current.resetAt - now;\n      job.release(this.releaseAfterSeconds || retryAfter);\n      return;\n    }\n\n    // Increment the counter\n    if (current) {\n      current.count++;\n    } else {\n      rateLimiterStore.set(this.key, {\n        count: 1,\n        resetAt: now + this.decaySeconds,\n      });\n    }\n\n    await next();\n  }\n\n  /**\n   * Set the number of seconds to release the job for\n   */\n  releaseAfter(seconds: number): this {\n    this.releaseAfterSeconds = seconds;\n    return this;\n  }\n}\n"],"mappings":"AAsBA,MAAM,EAAoE,IAAI,IAE9E,IAAa,EAAb,KAAkD,CAIhD,oBAAwC,EAExC,YAIE,EAKA,EAAgC,EAKhC,EAAiC,GACjC,CAXU,KAAA,IAAA,EAKA,KAAA,YAAA,EAKA,KAAA,aAAA,EAGZ,MAAM,OAAO,EAAU,EAA0C,CAC/D,IAAM,EAAM,KAAK,MAAM,KAAK,KAAK,CAAG,IAAK,CACnC,EAAU,EAAiB,IAAI,KAAK,IAAI,CAG1C,GAAW,EAAQ,SAAW,GAChC,EAAiB,OAAO,KAAK,IAAI,CAGnC,IAAM,EAAU,EAAiB,IAAI,KAAK,IAAI,CAE9C,GAAI,GAAW,EAAQ,OAAS,KAAK,YAAa,CAEhD,IAAM,EAAa,EAAQ,QAAU,EACrC,EAAI,QAAQ,KAAK,qBAAuB,EAAW,CACnD,OAIE,EACF,EAAQ,QAER,EAAiB,IAAI,KAAK,IAAK,CAC7B,MAAO,EACP,QAAS,EAAM,KAAK,aACrB,CAAC,CAGJ,MAAM,GAAM,CAMd,aAAa,EAAuB,CAElC,MADA,MAAK,oBAAsB,EACpB"}

package/dist/Queue/Middleware/ThrottlesExceptions.cjs

@@ -0,0 +1 @@
+require(`../../_virtual/_rolldown/runtime.cjs`);const e=new Map;var t=class{backoffMinutes=5;keyPrefix=``;shouldRetryOnThrottle=!0;constructor(e=10,t=10){this.maxExceptions=e,this.decayMinutes=t}async handle(t,n){let r=this.getKey(t),i=Math.floor(Date.now()/1e3),a=e.get(r);a&&a.resetAt<=i&&e.delete(r);let o=e.get(r);if(o&&o.count>=this.maxExceptions){this.shouldRetryOnThrottle?t.release(this.backoffMinutes*60):t.delete();return}try{await n()}catch(t){throw o?o.count++:e.set(r,{count:1,resetAt:i+this.decayMinutes*60}),t}}getKey(e){return`throttle:${this.keyPrefix||e.displayName()}`}backoff(e){return this.backoffMinutes=e,this}by(e){return this.keyPrefix=e,this}dontRetry(){return this.shouldRetryOnThrottle=!1,this}};exports.ThrottlesExceptions=t;

package/dist/Queue/Middleware/ThrottlesExceptions.d.cts

@@ -0,0 +1,55 @@
+import { JobMiddleware } from "./JobMiddleware.cjs";
+import { Job } from "../Job.cjs";
+
+//#region src/Queue/Middleware/ThrottlesExceptions.d.ts
+declare class ThrottlesExceptions implements JobMiddleware {
+  /**
+   * The maximum number of exceptions allowed
+   */
+  protected maxExceptions: number;
+  /**
+   * The number of minutes in the decay window
+   */
+  protected decayMinutes: number;
+  /**
+   * The number of minutes to back off for
+   */
+  protected backoffMinutes: number;
+  /**
+   * The prefix for the throttle key
+   */
+  protected keyPrefix: string;
+  /**
+   * Whether to retry the job or delete it when throttled
+   */
+  protected shouldRetryOnThrottle: boolean;
+  constructor(
+  /**
+   * The maximum number of exceptions allowed
+   */
+  maxExceptions?: number,
+  /**
+   * The number of minutes in the decay window
+   */
+  decayMinutes?: number);
+  handle(job: Job, next: () => Promise<void>): Promise<void>;
+  /**
+   * Get the throttle key for this job
+   */
+  protected getKey(job: Job): string;
+  /**
+   * Set the number of minutes to back off for when throttled
+   */
+  backoff(minutes: number): this;
+  /**
+   * Set a custom key prefix
+   */
+  by(key: string): this;
+  /**
+   * Indicate the job should NOT be retried when throttled
+   */
+  dontRetry(): this;
+}
+//#endregion
+export { ThrottlesExceptions };
+//# sourceMappingURL=ThrottlesExceptions.d.cts.map

package/dist/Queue/Middleware/ThrottlesExceptions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThrottlesExceptions.d.cts","names":[],"sources":["../../../src/Queue/Middleware/ThrottlesExceptions.ts"],"mappings":";;;;cA2Ba,mBAAA,YAA+B,aAAA;EA4BpC;;;EAAA,UARM,aAAA;EAQW;;;EAAA,UAHX,YAAA;EA6CK;;;EAAA,UAlEP,cAAA;EAkFP;;;EAAA,UA7EO,SAAA;;;;YAKA,qBAAA;;;;;EAME,aAAA;;;;EAKA,YAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;YA0CzC,MAAA,CAAO,GAAA,EAAK,GAAA;;;;EAQtB,OAAA,CAAQ,OAAA;;;;EAQR,EAAA,CAAG,GAAA;;;;EAQH,SAAA,CAAA;AAAA"}

package/dist/Queue/Middleware/ThrottlesExceptions.d.mts

@@ -0,0 +1,55 @@
+import { JobMiddleware } from "./JobMiddleware.mjs";
+import { Job } from "../Job.mjs";
+
+//#region src/Queue/Middleware/ThrottlesExceptions.d.ts
+declare class ThrottlesExceptions implements JobMiddleware {
+  /**
+   * The maximum number of exceptions allowed
+   */
+  protected maxExceptions: number;
+  /**
+   * The number of minutes in the decay window
+   */
+  protected decayMinutes: number;
+  /**
+   * The number of minutes to back off for
+   */
+  protected backoffMinutes: number;
+  /**
+   * The prefix for the throttle key
+   */
+  protected keyPrefix: string;
+  /**
+   * Whether to retry the job or delete it when throttled
+   */
+  protected shouldRetryOnThrottle: boolean;
+  constructor(
+  /**
+   * The maximum number of exceptions allowed
+   */
+  maxExceptions?: number,
+  /**
+   * The number of minutes in the decay window
+   */
+  decayMinutes?: number);
+  handle(job: Job, next: () => Promise<void>): Promise<void>;
+  /**
+   * Get the throttle key for this job
+   */
+  protected getKey(job: Job): string;
+  /**
+   * Set the number of minutes to back off for when throttled
+   */
+  backoff(minutes: number): this;
+  /**
+   * Set a custom key prefix
+   */
+  by(key: string): this;
+  /**
+   * Indicate the job should NOT be retried when throttled
+   */
+  dontRetry(): this;
+}
+//#endregion
+export { ThrottlesExceptions };
+//# sourceMappingURL=ThrottlesExceptions.d.mts.map

package/dist/Queue/Middleware/ThrottlesExceptions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThrottlesExceptions.d.mts","names":[],"sources":["../../../src/Queue/Middleware/ThrottlesExceptions.ts"],"mappings":";;;;cA2Ba,mBAAA,YAA+B,aAAA;EA4BpC;;;EAAA,UARM,aAAA;EAQW;;;EAAA,UAHX,YAAA;EA6CK;;;EAAA,UAlEP,cAAA;EAkFP;;;EAAA,UA7EO,SAAA;;;;YAKA,qBAAA;;;;;EAME,aAAA;;;;EAKA,YAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;YA0CzC,MAAA,CAAO,GAAA,EAAK,GAAA;;;;EAQtB,OAAA,CAAQ,OAAA;;;;EAQR,EAAA,CAAG,GAAA;;;;EAQH,SAAA,CAAA;AAAA"}

package/dist/Queue/Middleware/ThrottlesExceptions.mjs

@@ -0,0 +1,2 @@
+const e=new Map;var t=class{backoffMinutes=5;keyPrefix=``;shouldRetryOnThrottle=!0;constructor(e=10,t=10){this.maxExceptions=e,this.decayMinutes=t}async handle(t,n){let r=this.getKey(t),i=Math.floor(Date.now()/1e3),a=e.get(r);a&&a.resetAt<=i&&e.delete(r);let o=e.get(r);if(o&&o.count>=this.maxExceptions){this.shouldRetryOnThrottle?t.release(this.backoffMinutes*60):t.delete();return}try{await n()}catch(t){throw o?o.count++:e.set(r,{count:1,resetAt:i+this.decayMinutes*60}),t}}getKey(e){return`throttle:${this.keyPrefix||e.displayName()}`}backoff(e){return this.backoffMinutes=e,this}by(e){return this.keyPrefix=e,this}dontRetry(){return this.shouldRetryOnThrottle=!1,this}};export{t as ThrottlesExceptions};
+//# sourceMappingURL=ThrottlesExceptions.mjs.map

package/dist/Queue/Middleware/ThrottlesExceptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThrottlesExceptions.mjs","names":[],"sources":["../../../src/Queue/Middleware/ThrottlesExceptions.ts"],"sourcesContent":["/**\n * ThrottlesExceptions Middleware\n *\n * When a job throws too many exceptions within a given time window,\n * subsequent attempts are delayed to prevent rapid failure loops.\n *\n * Mirrors Laravel's Illuminate\\Queue\\Middleware\\ThrottlesExceptions.\n *\n * @example\n * ```typescript\n * class ProcessPodcast extends Job {\n *   middleware() {\n *     return [\n *       new ThrottlesExceptions(10, 5) // 10 exceptions per 5 minutes\n *         .backoff(5) // Wait 5 minutes before retrying\n *     ];\n *   }\n * }\n * ```\n */\n\nimport type { Job } from '@/Queue/Job';\nimport type { JobMiddleware } from './JobMiddleware';\n\n// In-memory exception tracking\nconst exceptionStore: Map<string, { count: number; resetAt: number }> = new Map();\n\nexport class ThrottlesExceptions implements JobMiddleware {\n  /**\n   * The number of minutes to back off for\n   */\n  protected backoffMinutes: number = 5;\n\n  /**\n   * The prefix for the throttle key\n   */\n  protected keyPrefix: string = '';\n\n  /**\n   * Whether to retry the job or delete it when throttled\n   */\n  protected shouldRetryOnThrottle: boolean = true;\n\n  constructor(\n    /**\n     * The maximum number of exceptions allowed\n     */\n    protected maxExceptions: number = 10,\n\n    /**\n     * The number of minutes in the decay window\n     */\n    protected decayMinutes: number = 10\n  ) {}\n\n  async handle(job: Job, next: () => Promise<void>): Promise<void> {\n    const key = this.getKey(job);\n    const now = Math.floor(Date.now() / 1000);\n\n    // Clean up expired entries\n    const existing = exceptionStore.get(key);\n    if (existing && existing.resetAt <= now) {\n      exceptionStore.delete(key);\n    }\n\n    const current = exceptionStore.get(key);\n\n    // Check if throttled\n    if (current && current.count >= this.maxExceptions) {\n      if (this.shouldRetryOnThrottle) {\n        job.release(this.backoffMinutes * 60);\n      } else {\n        job.delete();\n      }\n      return;\n    }\n\n    try {\n      await next();\n    } catch (error) {\n      // Record the exception\n      if (current) {\n        current.count++;\n      } else {\n        exceptionStore.set(key, {\n          count: 1,\n          resetAt: now + this.decayMinutes * 60,\n        });\n      }\n\n      throw error;\n    }\n  }\n\n  /**\n   * Get the throttle key for this job\n   */\n  protected getKey(job: Job): string {\n    const prefix = this.keyPrefix || job.displayName();\n    return `throttle:${prefix}`;\n  }\n\n  /**\n   * Set the number of minutes to back off for when throttled\n   */\n  backoff(minutes: number): this {\n    this.backoffMinutes = minutes;\n    return this;\n  }\n\n  /**\n   * Set a custom key prefix\n   */\n  by(key: string): this {\n    this.keyPrefix = key;\n    return this;\n  }\n\n  /**\n   * Indicate the job should NOT be retried when throttled\n   */\n  dontRetry(): this {\n    this.shouldRetryOnThrottle = false;\n    return this;\n  }\n}\n"],"mappings":"AAyBA,MAAM,EAAkE,IAAI,IAE5E,IAAa,EAAb,KAA0D,CAIxD,eAAmC,EAKnC,UAA8B,GAK9B,sBAA2C,GAE3C,YAIE,EAAkC,GAKlC,EAAiC,GACjC,CANU,KAAA,cAAA,EAKA,KAAA,aAAA,EAGZ,MAAM,OAAO,EAAU,EAA0C,CAC/D,IAAM,EAAM,KAAK,OAAO,EAAI,CACtB,EAAM,KAAK,MAAM,KAAK,KAAK,CAAG,IAAK,CAGnC,EAAW,EAAe,IAAI,EAAI,CACpC,GAAY,EAAS,SAAW,GAClC,EAAe,OAAO,EAAI,CAG5B,IAAM,EAAU,EAAe,IAAI,EAAI,CAGvC,GAAI,GAAW,EAAQ,OAAS,KAAK,cAAe,CAC9C,KAAK,sBACP,EAAI,QAAQ,KAAK,eAAiB,GAAG,CAErC,EAAI,QAAQ,CAEd,OAGF,GAAI,CACF,MAAM,GAAM,OACL,EAAO,CAWd,MATI,EACF,EAAQ,QAER,EAAe,IAAI,EAAK,CACtB,MAAO,EACP,QAAS,EAAM,KAAK,aAAe,GACpC,CAAC,CAGE,GAOV,OAAiB,EAAkB,CAEjC,MAAO,YADQ,KAAK,WAAa,EAAI,aAAa,GAOpD,QAAQ,EAAuB,CAE7B,MADA,MAAK,eAAiB,EACf,KAMT,GAAG,EAAmB,CAEpB,MADA,MAAK,UAAY,EACV,KAMT,WAAkB,CAEhB,MADA,MAAK,sBAAwB,GACtB"}

package/dist/Queue/Middleware/WithoutOverlapping.cjs

@@ -0,0 +1 @@
+require(`../../_virtual/_rolldown/runtime.cjs`);const e=new Map;var t=class{releaseAfterSeconds=0;lockExpiresAfter=0;shouldDontRelease=!1;constructor(e,t=`overlap:`){this.key=e,this.prefix=t}async handle(t,n){let r=`${this.prefix}${this.key}`,i=Math.floor(Date.now()/1e3),a=e.get(r);if(a&&a.expiresAt>0&&a.expiresAt<=i&&e.delete(r),e.has(r)){if(this.shouldDontRelease){t.delete();return}t.release(this.releaseAfterSeconds||5);return}let o=this.lockExpiresAfter>0?i+this.lockExpiresAfter:0;e.set(r,{expiresAt:o});try{await n()}finally{e.delete(r)}}releaseAfter(e){return this.releaseAfterSeconds=e,this}expireAfter(e){return this.lockExpiresAfter=e,this}dontRelease(){return this.shouldDontRelease=!0,this}};exports.WithoutOverlapping=t;

package/dist/Queue/Middleware/WithoutOverlapping.d.cts

@@ -0,0 +1,51 @@
+import { JobMiddleware } from "./JobMiddleware.cjs";
+import { Job } from "../Job.cjs";
+
+//#region src/Queue/Middleware/WithoutOverlapping.d.ts
+declare class WithoutOverlapping implements JobMiddleware {
+  /**
+   * The lock key to prevent overlapping
+   */
+  protected key: string | number;
+  /**
+   * The prefix for the lock key
+   */
+  protected prefix: string;
+  /**
+   * The number of seconds to release the job for if locked
+   */
+  protected releaseAfterSeconds: number;
+  /**
+   * The number of seconds the lock should be held
+   */
+  protected lockExpiresAfter: number;
+  /**
+   * Whether to skip the job entirely if locked (vs releasing back to queue)
+   */
+  protected shouldDontRelease: boolean;
+  constructor(
+  /**
+   * The lock key to prevent overlapping
+   */
+  key: string | number,
+  /**
+   * The prefix for the lock key
+   */
+  prefix?: string);
+  handle(job: Job, next: () => Promise<void>): Promise<void>;
+  /**
+   * Set the number of seconds to release the job for if locked
+   */
+  releaseAfter(seconds: number): this;
+  /**
+   * Set the lock expiration time in seconds
+   */
+  expireAfter(seconds: number): this;
+  /**
+   * Indicate the job should be deleted if locked (instead of released)
+   */
+  dontRelease(): this;
+}
+//#endregion
+export { WithoutOverlapping };
+//# sourceMappingURL=WithoutOverlapping.d.cts.map

package/dist/Queue/Middleware/WithoutOverlapping.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithoutOverlapping.d.cts","names":[],"sources":["../../../src/Queue/Middleware/WithoutOverlapping.ts"],"mappings":";;;;cAwBa,kBAAA,YAA8B,aAAA;EAoB7B;;;EAAA,UAAA,GAAA;EAQC;;;EAAA,UAHD,MAAA;EAyCZ;;;EAAA,UA9DU,mBAAA;EA8EV;;;EAAA,UAzEU,gBAAA;;;;YAKA,iBAAA;;;;;EAME,GAAA;;;;EAKA,MAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;EAsCnD,YAAA,CAAa,OAAA;;;;EAQb,WAAA,CAAY,OAAA;;;;EAQZ,WAAA,CAAA;AAAA"}

package/dist/Queue/Middleware/WithoutOverlapping.d.mts

@@ -0,0 +1,51 @@
+import { JobMiddleware } from "./JobMiddleware.mjs";
+import { Job } from "../Job.mjs";
+
+//#region src/Queue/Middleware/WithoutOverlapping.d.ts
+declare class WithoutOverlapping implements JobMiddleware {
+  /**
+   * The lock key to prevent overlapping
+   */
+  protected key: string | number;
+  /**
+   * The prefix for the lock key
+   */
+  protected prefix: string;
+  /**
+   * The number of seconds to release the job for if locked
+   */
+  protected releaseAfterSeconds: number;
+  /**
+   * The number of seconds the lock should be held
+   */
+  protected lockExpiresAfter: number;
+  /**
+   * Whether to skip the job entirely if locked (vs releasing back to queue)
+   */
+  protected shouldDontRelease: boolean;
+  constructor(
+  /**
+   * The lock key to prevent overlapping
+   */
+  key: string | number,
+  /**
+   * The prefix for the lock key
+   */
+  prefix?: string);
+  handle(job: Job, next: () => Promise<void>): Promise<void>;
+  /**
+   * Set the number of seconds to release the job for if locked
+   */
+  releaseAfter(seconds: number): this;
+  /**
+   * Set the lock expiration time in seconds
+   */
+  expireAfter(seconds: number): this;
+  /**
+   * Indicate the job should be deleted if locked (instead of released)
+   */
+  dontRelease(): this;
+}
+//#endregion
+export { WithoutOverlapping };
+//# sourceMappingURL=WithoutOverlapping.d.mts.map

package/dist/Queue/Middleware/WithoutOverlapping.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithoutOverlapping.d.mts","names":[],"sources":["../../../src/Queue/Middleware/WithoutOverlapping.ts"],"mappings":";;;;cAwBa,kBAAA,YAA8B,aAAA;EAoB7B;;;EAAA,UAAA,GAAA;EAQC;;;EAAA,UAHD,MAAA;EAyCZ;;;EAAA,UA9DU,mBAAA;EA8EV;;;EAAA,UAzEU,gBAAA;;;;YAKA,iBAAA;;;;;EAME,GAAA;;;;EAKA,MAAA;EAGN,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,IAAA,QAAY,OAAA,SAAgB,OAAA;;;;EAsCnD,YAAA,CAAa,OAAA;;;;EAQb,WAAA,CAAY,OAAA;;;;EAQZ,WAAA,CAAA;AAAA"}

package/dist/Queue/Middleware/WithoutOverlapping.mjs

@@ -0,0 +1,2 @@
+const e=new Map;var t=class{releaseAfterSeconds=0;lockExpiresAfter=0;shouldDontRelease=!1;constructor(e,t=`overlap:`){this.key=e,this.prefix=t}async handle(t,n){let r=`${this.prefix}${this.key}`,i=Math.floor(Date.now()/1e3),a=e.get(r);if(a&&a.expiresAt>0&&a.expiresAt<=i&&e.delete(r),e.has(r)){if(this.shouldDontRelease){t.delete();return}t.release(this.releaseAfterSeconds||5);return}let o=this.lockExpiresAfter>0?i+this.lockExpiresAfter:0;e.set(r,{expiresAt:o});try{await n()}finally{e.delete(r)}}releaseAfter(e){return this.releaseAfterSeconds=e,this}expireAfter(e){return this.lockExpiresAfter=e,this}dontRelease(){return this.shouldDontRelease=!0,this}};export{t as WithoutOverlapping};
+//# sourceMappingURL=WithoutOverlapping.mjs.map

package/dist/Queue/Middleware/WithoutOverlapping.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithoutOverlapping.mjs","names":[],"sources":["../../../src/Queue/Middleware/WithoutOverlapping.ts"],"sourcesContent":["/**\n * WithoutOverlapping Middleware\n *\n * Prevents a job from running if another instance with the same\n * key is currently being processed.\n *\n * Mirrors Laravel's Illuminate\\Queue\\Middleware\\WithoutOverlapping.\n *\n * @example\n * ```typescript\n * class UpdateSearchIndex extends Job {\n *   middleware() {\n *     return [new WithoutOverlapping(this.productId)];\n *   }\n * }\n * ```\n */\n\nimport type { Job } from '@/Queue/Job';\nimport type { JobMiddleware } from './JobMiddleware';\n\n// Simple in-memory lock store\nconst lockStore: Map<string, { expiresAt: number }> = new Map();\n\nexport class WithoutOverlapping implements JobMiddleware {\n  /**\n   * The number of seconds to release the job for if locked\n   */\n  protected releaseAfterSeconds: number = 0;\n\n  /**\n   * The number of seconds the lock should be held\n   */\n  protected lockExpiresAfter: number = 0;\n\n  /**\n   * Whether to skip the job entirely if locked (vs releasing back to queue)\n   */\n  protected shouldDontRelease: boolean = false;\n\n  constructor(\n    /**\n     * The lock key to prevent overlapping\n     */\n    protected key: string | number,\n\n    /**\n     * The prefix for the lock key\n     */\n    protected prefix: string = 'overlap:'\n  ) {}\n\n  async handle(job: Job, next: () => Promise<void>): Promise<void> {\n    const lockKey = `${this.prefix}${this.key}`;\n    const now = Math.floor(Date.now() / 1000);\n\n    // Clean up expired locks\n    const existing = lockStore.get(lockKey);\n    if (existing && existing.expiresAt > 0 && existing.expiresAt <= now) {\n      lockStore.delete(lockKey);\n    }\n\n    // Check if locked\n    if (lockStore.has(lockKey)) {\n      if (this.shouldDontRelease) {\n        // Skip the job entirely\n        job.delete();\n        return;\n      }\n\n      // Release back onto the queue\n      job.release(this.releaseAfterSeconds || 5);\n      return;\n    }\n\n    // Acquire lock\n    const expiresAt = this.lockExpiresAfter > 0 ? now + this.lockExpiresAfter : 0;\n    lockStore.set(lockKey, { expiresAt });\n\n    try {\n      await next();\n    } finally {\n      // Release lock\n      lockStore.delete(lockKey);\n    }\n  }\n\n  /**\n   * Set the number of seconds to release the job for if locked\n   */\n  releaseAfter(seconds: number): this {\n    this.releaseAfterSeconds = seconds;\n    return this;\n  }\n\n  /**\n   * Set the lock expiration time in seconds\n   */\n  expireAfter(seconds: number): this {\n    this.lockExpiresAfter = seconds;\n    return this;\n  }\n\n  /**\n   * Indicate the job should be deleted if locked (instead of released)\n   */\n  dontRelease(): this {\n    this.shouldDontRelease = true;\n    return this;\n  }\n}\n"],"mappings":"AAsBA,MAAM,EAAgD,IAAI,IAE1D,IAAa,EAAb,KAAyD,CAIvD,oBAAwC,EAKxC,iBAAqC,EAKrC,kBAAuC,GAEvC,YAIE,EAKA,EAA2B,WAC3B,CANU,KAAA,IAAA,EAKA,KAAA,OAAA,EAGZ,MAAM,OAAO,EAAU,EAA0C,CAC/D,IAAM,EAAU,GAAG,KAAK,SAAS,KAAK,MAChC,EAAM,KAAK,MAAM,KAAK,KAAK,CAAG,IAAK,CAGnC,EAAW,EAAU,IAAI,EAAQ,CAMvC,GALI,GAAY,EAAS,UAAY,GAAK,EAAS,WAAa,GAC9D,EAAU,OAAO,EAAQ,CAIvB,EAAU,IAAI,EAAQ,CAAE,CAC1B,GAAI,KAAK,kBAAmB,CAE1B,EAAI,QAAQ,CACZ,OAIF,EAAI,QAAQ,KAAK,qBAAuB,EAAE,CAC1C,OAIF,IAAM,EAAY,KAAK,iBAAmB,EAAI,EAAM,KAAK,iBAAmB,EAC5E,EAAU,IAAI,EAAS,CAAE,YAAW,CAAC,CAErC,GAAI,CACF,MAAM,GAAM,QACJ,CAER,EAAU,OAAO,EAAQ,EAO7B,aAAa,EAAuB,CAElC,MADA,MAAK,oBAAsB,EACpB,KAMT,YAAY,EAAuB,CAEjC,MADA,MAAK,iBAAmB,EACjB,KAMT,aAAoB,CAElB,MADA,MAAK,kBAAoB,GAClB"}

package/dist/Queue/PendingChain.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);var e=class{_connection;_queue;_delay;_catchCallback;_finallyCallback;constructor(e,t){this.manager=e,this.jobs=t}onConnection(e){return this._connection=e,this}onQueue(e){return this._queue=e,this}delay(e){return this._delay=e,this}catch(e){return this._catchCallback=e,this}finally(e){return this._finallyCallback=e,this}async dispatch(){if(this.jobs.length===0)throw Error(`Cannot dispatch an empty chain.`);for(let e of this.jobs)this._connection&&(e.connection=this._connection),this._queue&&(e.queue=this._queue);let e=this.jobs[0];return e._chainJobs=this.jobs.slice(1).map(e=>({class:e.constructor.name,data:e.toJSON()})),e._chainCatch=this._catchCallback,e._chainFinally=this._finallyCallback,this._delay&&(e.delay=this._delay),this.manager.dispatch(e)}};exports.PendingChain=e;

package/dist/Queue/PendingChain.d.cts

@@ -0,0 +1,45 @@
+import { Job } from "./Job.cjs";
+import { QueueManager } from "./QueueManager.cjs";
+
+//#region src/Queue/PendingChain.d.ts
+declare class PendingChain {
+  protected manager: QueueManager;
+  protected jobs: Job[];
+  protected _connection?: string;
+  protected _queue?: string;
+  protected _delay?: number | Date;
+  protected _catchCallback?: (error: Error) => void | Promise<void>;
+  protected _finallyCallback?: () => void | Promise<void>;
+  constructor(manager: QueueManager, jobs: Job[]);
+  /**
+   * Set the connection for all jobs in the chain
+   */
+  onConnection(connection: string): this;
+  /**
+   * Set the queue for all jobs in the chain
+   */
+  onQueue(queue: string): this;
+  /**
+   * Set the delay before the first job starts
+   */
+  delay(delay: number | Date): this;
+  /**
+   * Set a callback to execute if any job in the chain fails
+   */
+  catch(callback: (error: Error) => void | Promise<void>): this;
+  /**
+   * Set a callback to execute when the chain completes (success or failure)
+   */
+  finally(callback: () => void | Promise<void>): this;
+  /**
+   * Dispatch the chain
+   *
+   * The first job is dispatched immediately. Each subsequent job
+   * stores the remaining chain and dispatches the next job upon
+   * successful completion.
+   */
+  dispatch(): Promise<string>;
+}
+//#endregion
+export { PendingChain };
+//# sourceMappingURL=PendingChain.d.cts.map

package/dist/Queue/PendingChain.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingChain.d.cts","names":[],"sources":["../../src/Queue/PendingChain.ts"],"mappings":";;;;cA0Ba,YAAA;EAAA,UAQC,OAAA,EAAS,YAAA;EAAA,UACT,IAAA,EAAM,GAAA;EAAA,UARR,WAAA;EAAA,UACA,MAAA;EAAA,UACA,MAAA,YAAkB,IAAA;EAAA,UAClB,cAAA,IAAkB,KAAA,EAAO,KAAA,YAAiB,OAAA;EAAA,UAC1C,gBAAA,gBAAgC,OAAA;cAG9B,OAAA,EAAS,YAAA,EACT,IAAA,EAAM,GAAA;EALkC;;;EAWpD,YAAA,CAAa,UAAA;EAPQ;;;EAerB,OAAA,CAAQ,KAAA;EARR;;;EAgBA,KAAA,CAAM,KAAA,WAAgB,IAAA;EAAtB;;;EAQA,KAAA,CAAM,QAAA,GAAW,KAAA,EAAO,KAAA,YAAiB,OAAA;EAAjB;;;EAQxB,OAAA,CAAQ,QAAA,eAAuB,OAAA;EAA/B;;;;;;;EAYM,QAAA,CAAA,GAAY,OAAA;AAAA"}

package/dist/Queue/PendingChain.d.mts

@@ -0,0 +1,45 @@
+import { Job } from "./Job.mjs";
+import { QueueManager } from "./QueueManager.mjs";
+
+//#region src/Queue/PendingChain.d.ts
+declare class PendingChain {
+  protected manager: QueueManager;
+  protected jobs: Job[];
+  protected _connection?: string;
+  protected _queue?: string;
+  protected _delay?: number | Date;
+  protected _catchCallback?: (error: Error) => void | Promise<void>;
+  protected _finallyCallback?: () => void | Promise<void>;
+  constructor(manager: QueueManager, jobs: Job[]);
+  /**
+   * Set the connection for all jobs in the chain
+   */
+  onConnection(connection: string): this;
+  /**
+   * Set the queue for all jobs in the chain
+   */
+  onQueue(queue: string): this;
+  /**
+   * Set the delay before the first job starts
+   */
+  delay(delay: number | Date): this;
+  /**
+   * Set a callback to execute if any job in the chain fails
+   */
+  catch(callback: (error: Error) => void | Promise<void>): this;
+  /**
+   * Set a callback to execute when the chain completes (success or failure)
+   */
+  finally(callback: () => void | Promise<void>): this;
+  /**
+   * Dispatch the chain
+   *
+   * The first job is dispatched immediately. Each subsequent job
+   * stores the remaining chain and dispatches the next job upon
+   * successful completion.
+   */
+  dispatch(): Promise<string>;
+}
+//#endregion
+export { PendingChain };
+//# sourceMappingURL=PendingChain.d.mts.map

package/dist/Queue/PendingChain.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingChain.d.mts","names":[],"sources":["../../src/Queue/PendingChain.ts"],"mappings":";;;;cA0Ba,YAAA;EAAA,UAQC,OAAA,EAAS,YAAA;EAAA,UACT,IAAA,EAAM,GAAA;EAAA,UARR,WAAA;EAAA,UACA,MAAA;EAAA,UACA,MAAA,YAAkB,IAAA;EAAA,UAClB,cAAA,IAAkB,KAAA,EAAO,KAAA,YAAiB,OAAA;EAAA,UAC1C,gBAAA,gBAAgC,OAAA;cAG9B,OAAA,EAAS,YAAA,EACT,IAAA,EAAM,GAAA;EALkC;;;EAWpD,YAAA,CAAa,UAAA;EAPQ;;;EAerB,OAAA,CAAQ,KAAA;EARR;;;EAgBA,KAAA,CAAM,KAAA,WAAgB,IAAA;EAAtB;;;EAQA,KAAA,CAAM,QAAA,GAAW,KAAA,EAAO,KAAA,YAAiB,OAAA;EAAjB;;;EAQxB,OAAA,CAAQ,QAAA,eAAuB,OAAA;EAA/B;;;;;;;EAYM,QAAA,CAAA,GAAY,OAAA;AAAA"}

package/dist/Queue/PendingChain.mjs

@@ -0,0 +1,2 @@
+var e=class{_connection;_queue;_delay;_catchCallback;_finallyCallback;constructor(e,t){this.manager=e,this.jobs=t}onConnection(e){return this._connection=e,this}onQueue(e){return this._queue=e,this}delay(e){return this._delay=e,this}catch(e){return this._catchCallback=e,this}finally(e){return this._finallyCallback=e,this}async dispatch(){if(this.jobs.length===0)throw Error(`Cannot dispatch an empty chain.`);for(let e of this.jobs)this._connection&&(e.connection=this._connection),this._queue&&(e.queue=this._queue);let e=this.jobs[0];return e._chainJobs=this.jobs.slice(1).map(e=>({class:e.constructor.name,data:e.toJSON()})),e._chainCatch=this._catchCallback,e._chainFinally=this._finallyCallback,this._delay&&(e.delay=this._delay),this.manager.dispatch(e)}};export{e as PendingChain};
+//# sourceMappingURL=PendingChain.mjs.map

package/dist/Queue/PendingChain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingChain.mjs","names":[],"sources":["../../src/Queue/PendingChain.ts"],"sourcesContent":["/**\n * PendingChain\n *\n * Fluent builder for chaining multiple jobs together.\n * Jobs in a chain are executed sequentially - if one fails,\n * the remaining jobs in the chain are not executed.\n *\n * Mirrors Laravel's Illuminate\\Foundation\\Bus\\PendingChain.\n *\n * @example\n * ```typescript\n * await Bus.chain([\n *   new ProcessPodcast(id),\n *   new OptimizePodcast(id),\n *   new ReleasePodcast(id),\n * ])\n *   .onConnection('redis')\n *   .onQueue('processing')\n *   .catch((error) => console.error('Chain failed:', error))\n *   .dispatch();\n * ```\n */\n\nimport type { Job } from './Job';\nimport type { QueueManager } from './QueueManager';\n\nexport class PendingChain {\n  protected _connection?: string;\n  protected _queue?: string;\n  protected _delay?: number | Date;\n  protected _catchCallback?: (error: Error) => void | Promise<void>;\n  protected _finallyCallback?: () => void | Promise<void>;\n\n  constructor(\n    protected manager: QueueManager,\n    protected jobs: Job[]\n  ) {}\n\n  /**\n   * Set the connection for all jobs in the chain\n   */\n  onConnection(connection: string): this {\n    this._connection = connection;\n    return this;\n  }\n\n  /**\n   * Set the queue for all jobs in the chain\n   */\n  onQueue(queue: string): this {\n    this._queue = queue;\n    return this;\n  }\n\n  /**\n   * Set the delay before the first job starts\n   */\n  delay(delay: number | Date): this {\n    this._delay = delay;\n    return this;\n  }\n\n  /**\n   * Set a callback to execute if any job in the chain fails\n   */\n  catch(callback: (error: Error) => void | Promise<void>): this {\n    this._catchCallback = callback;\n    return this;\n  }\n\n  /**\n   * Set a callback to execute when the chain completes (success or failure)\n   */\n  finally(callback: () => void | Promise<void>): this {\n    this._finallyCallback = callback;\n    return this;\n  }\n\n  /**\n   * Dispatch the chain\n   *\n   * The first job is dispatched immediately. Each subsequent job\n   * stores the remaining chain and dispatches the next job upon\n   * successful completion.\n   */\n  async dispatch(): Promise<string> {\n    if (this.jobs.length === 0) {\n      throw new Error('Cannot dispatch an empty chain.');\n    }\n\n    // Apply connection/queue to all jobs\n    for (const job of this.jobs) {\n      if (this._connection) {\n        job.connection = this._connection;\n      }\n      if (this._queue) {\n        job.queue = this._queue;\n      }\n    }\n\n    // Store chain metadata on the first job\n    const firstJob = this.jobs[0];\n    const remainingJobs = this.jobs.slice(1);\n\n    // Store chain info as serializable data\n    (firstJob as any)._chainJobs = remainingJobs.map((j) => ({\n      class: j.constructor.name,\n      data: j.toJSON(),\n    }));\n    (firstJob as any)._chainCatch = this._catchCallback;\n    (firstJob as any)._chainFinally = this._finallyCallback;\n\n    // Apply delay to first job only\n    if (this._delay) {\n      firstJob.delay = this._delay;\n    }\n\n    return this.manager.dispatch(firstJob);\n  }\n}\n"],"mappings":"AA0BA,IAAa,EAAb,KAA0B,CACxB,YACA,OACA,OACA,eACA,iBAEA,YACE,EACA,EACA,CAFU,KAAA,QAAA,EACA,KAAA,KAAA,EAMZ,aAAa,EAA0B,CAErC,MADA,MAAK,YAAc,EACZ,KAMT,QAAQ,EAAqB,CAE3B,MADA,MAAK,OAAS,EACP,KAMT,MAAM,EAA4B,CAEhC,MADA,MAAK,OAAS,EACP,KAMT,MAAM,EAAwD,CAE5D,MADA,MAAK,eAAiB,EACf,KAMT,QAAQ,EAA4C,CAElD,MADA,MAAK,iBAAmB,EACjB,KAUT,MAAM,UAA4B,CAChC,GAAI,KAAK,KAAK,SAAW,EACvB,MAAU,MAAM,kCAAkC,CAIpD,IAAK,IAAM,KAAO,KAAK,KACjB,KAAK,cACP,EAAI,WAAa,KAAK,aAEpB,KAAK,SACP,EAAI,MAAQ,KAAK,QAKrB,IAAM,EAAW,KAAK,KAAK,GAgB3B,MAZC,GAAiB,WAHI,KAAK,KAAK,MAAM,EAAE,CAGK,IAAK,IAAO,CACvD,MAAO,EAAE,YAAY,KACrB,KAAM,EAAE,QAAQ,CACjB,EAAE,CACF,EAAiB,YAAc,KAAK,eACpC,EAAiB,cAAgB,KAAK,iBAGnC,KAAK,SACP,EAAS,MAAQ,KAAK,QAGjB,KAAK,QAAQ,SAAS,EAAS"}

package/dist/Queue/PendingDispatch.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);var e=class{_afterCommit=!1;constructor(e,t){this.manager=e,this.job=t}onConnection(e){return this.job.connection=e,this}onQueue(e){return this.job.queue=e,this}delay(e){return this.job.delay=e,this}tries(e){return this.job.tries=e,this}timeout(e){return this.job.timeout=e,this}backoff(e){return this.job.backoff=e,this}afterCommit(){return this._afterCommit=!0,this.job.afterCommit=!0,this}beforeCommit(){return this._afterCommit=!1,this.job.afterCommit=!1,this}async dispatch(){return this.manager.dispatch(this.job)}then(e,t){return this.dispatch().then(e,t)}};exports.PendingDispatch=e;

package/dist/Queue/PendingDispatch.d.cts

@@ -0,0 +1,53 @@
+import { Job } from "./Job.cjs";
+import { QueueManager } from "./QueueManager.cjs";
+
+//#region src/Queue/PendingDispatch.d.ts
+declare class PendingDispatch implements PromiseLike<string> {
+  protected manager: QueueManager;
+  protected job: Job;
+  protected _afterCommit: boolean;
+  constructor(manager: QueueManager, job: Job);
+  /**
+   * Set the desired connection for the job
+   */
+  onConnection(connection: string): this;
+  /**
+   * Set the desired queue for the job
+   */
+  onQueue(queue: string): this;
+  /**
+   * Set the delay for the job
+   */
+  delay(delay: number | Date): this;
+  /**
+   * Set the number of times the job may be attempted
+   */
+  tries(tries: number): this;
+  /**
+   * Set the timeout for the job
+   */
+  timeout(timeout: number): this;
+  /**
+   * Set the backoff strategy for the job
+   */
+  backoff(backoff: number | number[]): this;
+  /**
+   * Indicate that the job should be dispatched after all DB transactions commit
+   */
+  afterCommit(): this;
+  /**
+   * Indicate that the job should not wait for DB transactions
+   */
+  beforeCommit(): this;
+  /**
+   * Dispatch the job to the queue
+   */
+  dispatch(): Promise<string>;
+  /**
+   * PromiseLike implementation - allows `await ProcessPodcast.dispatch(id)`
+   */
+  then<TResult1 = string, TResult2 = never>(onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+//#endregion
+export { PendingDispatch };
+//# sourceMappingURL=PendingDispatch.d.cts.map

package/dist/Queue/PendingDispatch.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingDispatch.d.cts","names":[],"sources":["../../src/Queue/PendingDispatch.ts"],"mappings":";;;;cAqBa,eAAA,YAA2B,WAAA;EAAA,UAI1B,OAAA,EAAS,YAAA;EAAA,UACT,GAAA,EAAK,GAAA;EAAA,UAJP,YAAA;cAGE,OAAA,EAAS,YAAA,EACT,GAAA,EAAK,GAAA;EALgC;;;EAWjD,YAAA,CAAa,UAAA;EAND;;;EAcZ,OAAA,CAAQ,KAAA;EAfa;;;EAuBrB,KAAA,CAAM,KAAA,WAAgB,IAAA;EAhBtB;;;EAwBA,KAAA,CAAM,KAAA;EARN;;;EAgBA,OAAA,CAAQ,OAAA;EARF;;;EAgBN,OAAA,CAAQ,OAAA;EAAA;;;EAQR,WAAA,CAAA;EAkBkB;;;EATlB,YAAA,CAAA;EAiBkB;;;EARZ,QAAA,CAAA,GAAY,OAAA;EAQhB;;;EADF,IAAA,qCAAA,CACE,WAAA,KAAgB,KAAA,aAAkB,QAAA,GAAW,WAAA,CAAY,QAAA,WACzD,UAAA,KAAe,MAAA,UAAgB,QAAA,GAAW,WAAA,CAAY,QAAA,YACrD,WAAA,CAAY,QAAA,GAAW,QAAA;AAAA"}

package/dist/Queue/PendingDispatch.d.mts

@@ -0,0 +1,53 @@
+import { Job } from "./Job.mjs";
+import { QueueManager } from "./QueueManager.mjs";
+
+//#region src/Queue/PendingDispatch.d.ts
+declare class PendingDispatch implements PromiseLike<string> {
+  protected manager: QueueManager;
+  protected job: Job;
+  protected _afterCommit: boolean;
+  constructor(manager: QueueManager, job: Job);
+  /**
+   * Set the desired connection for the job
+   */
+  onConnection(connection: string): this;
+  /**
+   * Set the desired queue for the job
+   */
+  onQueue(queue: string): this;
+  /**
+   * Set the delay for the job
+   */
+  delay(delay: number | Date): this;
+  /**
+   * Set the number of times the job may be attempted
+   */
+  tries(tries: number): this;
+  /**
+   * Set the timeout for the job
+   */
+  timeout(timeout: number): this;
+  /**
+   * Set the backoff strategy for the job
+   */
+  backoff(backoff: number | number[]): this;
+  /**
+   * Indicate that the job should be dispatched after all DB transactions commit
+   */
+  afterCommit(): this;
+  /**
+   * Indicate that the job should not wait for DB transactions
+   */
+  beforeCommit(): this;
+  /**
+   * Dispatch the job to the queue
+   */
+  dispatch(): Promise<string>;
+  /**
+   * PromiseLike implementation - allows `await ProcessPodcast.dispatch(id)`
+   */
+  then<TResult1 = string, TResult2 = never>(onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+//#endregion
+export { PendingDispatch };
+//# sourceMappingURL=PendingDispatch.d.mts.map

package/dist/Queue/PendingDispatch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingDispatch.d.mts","names":[],"sources":["../../src/Queue/PendingDispatch.ts"],"mappings":";;;;cAqBa,eAAA,YAA2B,WAAA;EAAA,UAI1B,OAAA,EAAS,YAAA;EAAA,UACT,GAAA,EAAK,GAAA;EAAA,UAJP,YAAA;cAGE,OAAA,EAAS,YAAA,EACT,GAAA,EAAK,GAAA;EALgC;;;EAWjD,YAAA,CAAa,UAAA;EAND;;;EAcZ,OAAA,CAAQ,KAAA;EAfa;;;EAuBrB,KAAA,CAAM,KAAA,WAAgB,IAAA;EAhBtB;;;EAwBA,KAAA,CAAM,KAAA;EARN;;;EAgBA,OAAA,CAAQ,OAAA;EARF;;;EAgBN,OAAA,CAAQ,OAAA;EAAA;;;EAQR,WAAA,CAAA;EAkBkB;;;EATlB,YAAA,CAAA;EAiBkB;;;EARZ,QAAA,CAAA,GAAY,OAAA;EAQhB;;;EADF,IAAA,qCAAA,CACE,WAAA,KAAgB,KAAA,aAAkB,QAAA,GAAW,WAAA,CAAY,QAAA,WACzD,UAAA,KAAe,MAAA,UAAgB,QAAA,GAAW,WAAA,CAAY,QAAA,YACrD,WAAA,CAAY,QAAA,GAAW,QAAA;AAAA"}

package/dist/Queue/PendingDispatch.mjs

@@ -0,0 +1,2 @@
+var e=class{_afterCommit=!1;constructor(e,t){this.manager=e,this.job=t}onConnection(e){return this.job.connection=e,this}onQueue(e){return this.job.queue=e,this}delay(e){return this.job.delay=e,this}tries(e){return this.job.tries=e,this}timeout(e){return this.job.timeout=e,this}backoff(e){return this.job.backoff=e,this}afterCommit(){return this._afterCommit=!0,this.job.afterCommit=!0,this}beforeCommit(){return this._afterCommit=!1,this.job.afterCommit=!1,this}async dispatch(){return this.manager.dispatch(this.job)}then(e,t){return this.dispatch().then(e,t)}};export{e as PendingDispatch};
+//# sourceMappingURL=PendingDispatch.mjs.map

package/dist/Queue/PendingDispatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingDispatch.mjs","names":[],"sources":["../../src/Queue/PendingDispatch.ts"],"sourcesContent":["/**\n * PendingDispatch\n *\n * Provides a fluent interface for configuring job dispatch.\n * Mirrors Laravel's Illuminate\\Foundation\\Bus\\PendingDispatch.\n *\n * @example\n * ```typescript\n * await ProcessPodcast.dispatch(podcastId)\n *   .onConnection('redis')\n *   .onQueue('processing')\n *   .delay(60);\n *\n * // The dispatch happens when the PendingDispatch is awaited\n * // or when .dispatch() is explicitly called\n * ```\n */\n\nimport type { Job } from './Job';\nimport type { QueueManager } from './QueueManager';\n\nexport class PendingDispatch implements PromiseLike<string> {\n  protected _afterCommit: boolean = false;\n\n  constructor(\n    protected manager: QueueManager,\n    protected job: Job\n  ) {}\n\n  /**\n   * Set the desired connection for the job\n   */\n  onConnection(connection: string): this {\n    this.job.connection = connection;\n    return this;\n  }\n\n  /**\n   * Set the desired queue for the job\n   */\n  onQueue(queue: string): this {\n    this.job.queue = queue;\n    return this;\n  }\n\n  /**\n   * Set the delay for the job\n   */\n  delay(delay: number | Date): this {\n    this.job.delay = delay;\n    return this;\n  }\n\n  /**\n   * Set the number of times the job may be attempted\n   */\n  tries(tries: number): this {\n    this.job.tries = tries;\n    return this;\n  }\n\n  /**\n   * Set the timeout for the job\n   */\n  timeout(timeout: number): this {\n    this.job.timeout = timeout;\n    return this;\n  }\n\n  /**\n   * Set the backoff strategy for the job\n   */\n  backoff(backoff: number | number[]): this {\n    this.job.backoff = backoff;\n    return this;\n  }\n\n  /**\n   * Indicate that the job should be dispatched after all DB transactions commit\n   */\n  afterCommit(): this {\n    this._afterCommit = true;\n    this.job.afterCommit = true;\n    return this;\n  }\n\n  /**\n   * Indicate that the job should not wait for DB transactions\n   */\n  beforeCommit(): this {\n    this._afterCommit = false;\n    this.job.afterCommit = false;\n    return this;\n  }\n\n  /**\n   * Dispatch the job to the queue\n   */\n  async dispatch(): Promise<string> {\n    return this.manager.dispatch(this.job);\n  }\n\n  /**\n   * PromiseLike implementation - allows `await ProcessPodcast.dispatch(id)`\n   */\n  then<TResult1 = string, TResult2 = never>(\n    onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.dispatch().then(onfulfilled, onrejected);\n  }\n}\n"],"mappings":"AAqBA,IAAa,EAAb,KAA4D,CAC1D,aAAkC,GAElC,YACE,EACA,EACA,CAFU,KAAA,QAAA,EACA,KAAA,IAAA,EAMZ,aAAa,EAA0B,CAErC,MADA,MAAK,IAAI,WAAa,EACf,KAMT,QAAQ,EAAqB,CAE3B,MADA,MAAK,IAAI,MAAQ,EACV,KAMT,MAAM,EAA4B,CAEhC,MADA,MAAK,IAAI,MAAQ,EACV,KAMT,MAAM,EAAqB,CAEzB,MADA,MAAK,IAAI,MAAQ,EACV,KAMT,QAAQ,EAAuB,CAE7B,MADA,MAAK,IAAI,QAAU,EACZ,KAMT,QAAQ,EAAkC,CAExC,MADA,MAAK,IAAI,QAAU,EACZ,KAMT,aAAoB,CAGlB,MAFA,MAAK,aAAe,GACpB,KAAK,IAAI,YAAc,GAChB,KAMT,cAAqB,CAGnB,MAFA,MAAK,aAAe,GACpB,KAAK,IAAI,YAAc,GAChB,KAMT,MAAM,UAA4B,CAChC,OAAO,KAAK,QAAQ,SAAS,KAAK,IAAI,CAMxC,KACE,EACA,EACkC,CAClC,OAAO,KAAK,UAAU,CAAC,KAAK,EAAa,EAAW"}

package/dist/Queue/QueueManager.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);var e=class{connections=new Map;driverFactories=new Map;jobRegistry=new Map;beforeCallbacks=[];afterCallbacks=[];failingCallbacks=[];loopingCallbacks=[];constructor(e){this.config=e}registerDriver(e,t){this.driverFactories.set(e,t)}registerJob(e,t){this.jobRegistry.set(e,t)}getJobClass(e){return this.jobRegistry.get(e)}connection(e){let t=e||this.config.default;if(this.connections.has(t))return this.connections.get(t);let n=this.createConnection(t);return this.connections.set(t,n),n}createConnection(e){let t=this.config.connections[e];if(!t)throw Error(`Queue connection [${e}] not configured.`);let n=this.driverFactories.get(t.driver);if(!n)throw Error(`Queue driver [${t.driver}] not registered. Available drivers: ${Array.from(this.driverFactories.keys()).join(`, `)}`);let r=n(t);return r.setConnectionName(e),r}async dispatch(e){let t=e.connection||this.config.default,n=this.connection(t),r=e.queue;return e.delay?n.later(e.delay,e,r):n.push(e,r)}async dispatchSync(e){try{await e.handle()}catch(t){throw e.failed&&await e.failed(t),t}}async push(e,t){let n=e.connection||this.config.default;return this.connection(n).push(e,t)}async pushOn(e,t){return t.queue=e,this.push(t)}async later(e,t,n){let r=t.connection||this.config.default;return this.connection(r).later(e,t,n)}async bulk(e,t){let n=this.config.default;return this.connection(n).bulk(e,t)}before(e){this.beforeCallbacks.push(e)}after(e){this.afterCallbacks.push(e)}failing(e){this.failingCallbacks.push(e)}looping(e){this.loopingCallbacks.push(e)}fireBeforeCallbacks(e,t){for(let n of this.beforeCallbacks)n(e,t)}fireAfterCallbacks(e,t){for(let n of this.afterCallbacks)n(e,t)}fireFailingCallbacks(e,t,n){for(let r of this.failingCallbacks)r(e,t,n)}fireLoopingCallbacks(){for(let e of this.loopingCallbacks)e()}disconnect(e){let t=e||this.config.default;this.connections.delete(t)}getDefaultConnection(){return this.config.default}setDefaultConnection(e){this.config.default=e}getConnections(){return Object.keys(this.config.connections)}getConfig(){return this.config}getConnectionConfig(e){let t=e||this.config.default,n=this.config.connections[t];if(!n)throw Error(`Queue connection [${t}] not configured.`);return n}};exports.QueueManager=e;