@lara-node/queue 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1782 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_queue_config = require("./queue.config.cjs");
+let crypto = require("crypto");
+crypto = __toESM(crypto, 1);
+let _lara_node_db = require("@lara-node/db");
+let redis = require("redis");
+let _lara_node_cache = require("@lara-node/cache");
+let events = require("events");
+let cron_parser = require("cron-parser");
+let _lara_node_core = require("@lara-node/core");
+//#region src/Job.ts
+var Job_exports = /* @__PURE__ */ __exportAll({
+	Job: () => Job,
+	PendingDispatch: () => PendingDispatch,
+	Queueable: () => Queueable,
+	decryptPayload: () => decryptPayload,
+	dispatch: () => dispatch,
+	encryptPayload: () => encryptPayload,
+	getJobClass: () => getJobClass,
+	getRegisteredJobs: () => getRegisteredJobs,
+	registerJob: () => registerJob
+});
+let _encryptionKey;
+function getEncryptionKey() {
+	if (_encryptionKey) return _encryptionKey;
+	const raw = process.env.APP_KEY;
+	if (!raw) throw new Error("APP_KEY is not set — cannot encrypt job payload.");
+	const stripped = raw.replace(/^base64:/, "");
+	const decoded = Buffer.from(stripped, "base64");
+	_encryptionKey = decoded.length === 32 ? decoded : crypto.default.createHash("sha256").update(decoded).digest();
+	return _encryptionKey;
+}
+function encryptPayload(data) {
+	const key = getEncryptionKey();
+	const iv = crypto.default.randomBytes(12);
+	const cipher = crypto.default.createCipheriv("aes-256-gcm", key, iv);
+	let encrypted = cipher.update(data, "utf8", "base64");
+	encrypted += cipher.final("base64");
+	const tag = cipher.getAuthTag();
+	return [
+		iv.toString("base64"),
+		tag.toString("base64"),
+		encrypted
+	].join(":");
+}
+function decryptPayload(data) {
+	const key = getEncryptionKey();
+	const [ivB64, tagB64, encrypted] = data.split(":");
+	const iv = Buffer.from(ivB64, "base64");
+	const tag = Buffer.from(tagB64, "base64");
+	const decipher = crypto.default.createDecipheriv("aes-256-gcm", key, iv);
+	decipher.setAuthTag(tag);
+	let decrypted = decipher.update(encrypted, "base64", "utf8");
+	decrypted += decipher.final("utf8");
+	return decrypted;
+}
+const jobRegistry = /* @__PURE__ */ new Map();
+function registerJob(name, jobClass) {
+	jobRegistry.set(name, jobClass);
+}
+function getJobClass(name) {
+	return jobRegistry.get(name);
+}
+function getRegisteredJobs() {
+	return jobRegistry;
+}
+function Queueable(name) {
+	return function(constructor) {
+		registerJob(name || constructor.name, constructor);
+		return constructor;
+	};
+}
+var Job = class {
+	constructor() {
+		this.queue = "default";
+		this.connection = require_queue_config.queueConfig.default;
+		this.tries = require_queue_config.queueConfig.defaults.tries;
+		this.maxExceptions = require_queue_config.queueConfig.defaults.maxExceptions;
+		this.timeout = require_queue_config.queueConfig.defaults.timeout;
+		this.backoff = require_queue_config.queueConfig.defaults.backoff;
+		this.shouldBeEncrypted = false;
+		this.delay = 0;
+		this._uuid = "";
+		this._attempts = 0;
+	}
+	/**
+	* Handle a job failure.
+	*/
+	failed(exception) {}
+	/**
+	* Determine the time at which the job should timeout.
+	*/
+	retryUntil() {
+		return null;
+	}
+	/**
+	* Get the middleware the job should pass through.
+	*/
+	middleware() {
+		return [];
+	}
+	/**
+	* Get the tags that should be assigned to the job.
+	*/
+	tags() {
+		return [];
+	}
+	get uuid() {
+		return this._uuid;
+	}
+	get attempts() {
+		return this._attempts;
+	}
+	/**
+	* Get the display name for the queued job.
+	*/
+	displayName() {
+		return this.constructor.name;
+	}
+	/**
+	* Prepare the job for serialization.
+	*/
+	getSerializableProperties() {
+		const props = {};
+		for (const key of Object.keys(this)) if (!key.startsWith("_")) props[key] = this[key];
+		return props;
+	}
+	/**
+	* Serialize the job to a format that can be stored.
+	*/
+	serialize() {
+		const uuid = this._uuid || crypto.default.randomUUID();
+		this._uuid = uuid;
+		const retryUntilDate = this.retryUntil();
+		const rawData = JSON.stringify(this.getSerializableProperties());
+		return {
+			id: crypto.default.randomUUID(),
+			uuid,
+			displayName: this.displayName(),
+			job: this.constructor.name,
+			data: this.shouldBeEncrypted ? encryptPayload(rawData) : rawData,
+			encrypted: this.shouldBeEncrypted,
+			queue: this.queue,
+			attempts: this._attempts,
+			maxTries: this.tries,
+			maxExceptions: this.maxExceptions,
+			exceptionCount: 0,
+			timeout: this.timeout,
+			backoff: this.backoff,
+			retryUntil: retryUntilDate ? retryUntilDate.getTime() : null,
+			createdAt: Date.now(),
+			availableAt: Date.now() + this.delay * 1e3,
+			reservedAt: null
+		};
+	}
+	/**
+	* Restore the job from serialized data.
+	*/
+	static deserialize(serialized) {
+		const JobClass = getJobClass(serialized.job);
+		if (!JobClass) {
+			console.error(`Job class "${serialized.job}" not found in registry. Make sure to use @Queueable decorator.`);
+			return null;
+		}
+		const instance = new JobClass();
+		let rawData = serialized.data;
+		if (serialized.encrypted) try {
+			rawData = decryptPayload(rawData);
+		} catch (e) {
+			console.error(`[Job] Failed to decrypt payload for ${serialized.job}:`, e);
+			return null;
+		}
+		const data = JSON.parse(rawData);
+		for (const [key, value] of Object.entries(data)) instance[key] = value;
+		instance._uuid = serialized.uuid;
+		instance._attempts = serialized.attempts;
+		return instance;
+	}
+	/**
+	* Dispatch the job with the given arguments.
+	*/
+	static dispatch(...args) {
+		return new PendingDispatch(new this());
+	}
+	/**
+	* Dispatch the job synchronously.
+	*/
+	static dispatchSync() {
+		return new this().handle();
+	}
+	/**
+	* Dispatch the job after the response is sent.
+	*/
+	static dispatchAfterResponse() {
+		return new PendingDispatch(new this()).afterResponse();
+	}
+	onQueue(queue) {
+		this.queue = queue;
+		return this;
+	}
+	onConnection(connection) {
+		this.connection = connection;
+		return this;
+	}
+	withDelay(seconds) {
+		this.delay = seconds;
+		return this;
+	}
+	withTries(tries) {
+		this.tries = tries;
+		return this;
+	}
+	withTimeout(seconds) {
+		this.timeout = seconds;
+		return this;
+	}
+	withBackoff(backoff) {
+		this.backoff = backoff;
+		return this;
+	}
+};
+var PendingDispatch = class {
+	constructor(job) {
+		this.job = job;
+		this._afterResponse = false;
+	}
+	onQueue(queue) {
+		this.job.onQueue(queue);
+		return this;
+	}
+	onConnection(connection) {
+		this.job.onConnection(connection);
+		return this;
+	}
+	delay(seconds) {
+		this.job.withDelay(seconds);
+		return this;
+	}
+	tries(n) {
+		this.job.withTries(n);
+		return this;
+	}
+	timeout(seconds) {
+		this.job.withTimeout(seconds);
+		return this;
+	}
+	backoff(b) {
+		this.job.withBackoff(b);
+		return this;
+	}
+	maxExceptions(n) {
+		this.job.maxExceptions = n;
+		return this;
+	}
+	afterResponse() {
+		this._afterResponse = true;
+		return this;
+	}
+	async dispatch() {
+		const { Queue } = await Promise.resolve().then(() => Queue_exports);
+		if (this._afterResponse) {
+			setImmediate(async () => {
+				await Queue.push(this.job);
+			});
+			return this.job.uuid;
+		}
+		return Queue.push(this.job);
+	}
+};
+function dispatch(job) {
+	return new PendingDispatch(job);
+}
+//#endregion
+//#region src/Drivers/SyncDriver.ts
+var SyncDriver = class {
+	constructor() {
+		this.jobs = /* @__PURE__ */ new Map();
+	}
+	async size(queue = "default") {
+		return this.jobs.get(queue)?.length ?? 0;
+	}
+	async push(job, queue = "default") {
+		if (!this.jobs.has(queue)) this.jobs.set(queue, []);
+		const { Job: JobBase } = await Promise.resolve().then(() => Job_exports);
+		const maxTries = job.maxTries || require_queue_config.queueConfig.defaults.tries;
+		const maxExceptions = job.maxExceptions ?? require_queue_config.queueConfig.defaults.maxExceptions;
+		let lastError = null;
+		while (job.attempts < maxTries && (job.exceptionCount ?? 0) < maxExceptions) {
+			job.attempts += 1;
+			job.exceptionCount = job.exceptionCount ?? 0;
+			const instance = JobBase.deserialize(job);
+			if (!instance) break;
+			try {
+				await instance.handle();
+				return job.id;
+			} catch (error) {
+				lastError = error;
+				job.exceptionCount += 1;
+				if (!(job.attempts < maxTries && job.exceptionCount < maxExceptions)) break;
+				console.warn(`[Sync] Job ${job.displayName} failed (attempt ${job.attempts}/${maxTries}), retrying...`);
+			}
+		}
+		if (lastError) {
+			console.error(`[Sync] Job ${job.displayName} failed permanently after ${job.attempts} attempt(s):`, lastError.message);
+			const instance = JobBase.deserialize(job);
+			if (instance) try {
+				instance.failed(lastError);
+			} catch {}
+			throw lastError;
+		}
+		return job.id;
+	}
+	async later(delay, job, queue = "default") {
+		setTimeout(() => {
+			this.push(job, queue).catch((err) => {
+				console.error(`[Sync] Delayed job ${job.displayName} failed:`, err);
+			});
+		}, delay * 1e3);
+		return job.id;
+	}
+	async pop(queue = "default") {
+		const jobs = this.jobs.get(queue);
+		if (!jobs || jobs.length === 0) return null;
+		return jobs.shift() ?? null;
+	}
+	async delete(job, queue = "default") {
+		const jobs = this.jobs.get(queue);
+		if (jobs) {
+			const index = jobs.findIndex((j) => j.id === job.id);
+			if (index > -1) jobs.splice(index, 1);
+		}
+	}
+	async release(job, delay, queue = "default") {
+		job.availableAt = Date.now() + delay * 1e3;
+		job.reservedAt = null;
+		if (!this.jobs.has(queue)) this.jobs.set(queue, []);
+		this.jobs.get(queue).push(job);
+	}
+	async clear(queue = "default") {
+		const count = this.jobs.get(queue)?.length ?? 0;
+		this.jobs.set(queue, []);
+		return count;
+	}
+	async getJobs(queue = "default") {
+		return this.jobs.get(queue) ?? [];
+	}
+};
+//#endregion
+//#region src/Queue/QueueJob.ts
+var QueueJob = class extends _lara_node_db.Model {
+	static {
+		this.table = "jobs";
+	}
+	static {
+		this.primaryKey = "id";
+	}
+	static {
+		this.timestamps = false;
+	}
+	static {
+		this.fillable = [
+			"uuid",
+			"queue",
+			"payload",
+			"attempts",
+			"reserved_at",
+			"available_at",
+			"created_at"
+		];
+	}
+	static {
+		this.casts = {
+			attempts: "int",
+			reserved_at: "int",
+			available_at: "int",
+			created_at: "int"
+		};
+	}
+	/**
+	* Scope to get jobs for a specific queue.
+	*/
+	static scopeForQueue(query, queue) {
+		return query.where("queue", queue);
+	}
+	/**
+	* Scope to get available jobs (not reserved or reservation expired).
+	*/
+	static scopeAvailable(query, now, retryAfter) {
+		const expiredReservation = now - retryAfter;
+		return query.where(function(q) {
+			q.whereNull("reserved_at").orWhere("reserved_at", "<", expiredReservation);
+		}).where("available_at", "<=", now);
+	}
+	/**
+	* Scope to get the next available job.
+	*/
+	static scopeNextAvailable(query, queue, now, retryAfter) {
+		return query.forQueue(queue).available(now, retryAfter).orderBy("id", "asc");
+	}
+	/**
+	* Get the parsed payload.
+	*/
+	getParsedPayload() {
+		try {
+			return JSON.parse(this.payload);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Mark the job as reserved.
+	*/
+	async reserve(timestamp) {
+		this.reserved_at = timestamp;
+		this.attempts = (this.attempts || 0) + 1;
+		await this.save();
+	}
+	/**
+	* Release the job back to the queue.
+	*/
+	async release(availableAt, payload) {
+		this.reserved_at = null;
+		this.available_at = availableAt;
+		if (payload) this.payload = payload;
+		await this.save();
+	}
+};
+//#endregion
+//#region src/Queue/FailedJob.ts
+var FailedJob = class extends _lara_node_db.Model {
+	static {
+		this.table = "failed_jobs";
+	}
+	static {
+		this.primaryKey = "id";
+	}
+	static {
+		this.timestamps = false;
+	}
+	static {
+		this.fillable = [
+			"uuid",
+			"connection",
+			"queue",
+			"payload",
+			"exception",
+			"failed_at"
+		];
+	}
+	static {
+		this.casts = {
+			id: "int",
+			failed_at: "datetime"
+		};
+	}
+	/**
+	* Scope to find by UUID.
+	*/
+	static scopeByUuid(query, uuid) {
+		return query.where("uuid", uuid);
+	}
+	/**
+	* Scope to get jobs for a specific queue.
+	*/
+	static scopeForQueue(query, queue) {
+		return query.where("queue", queue);
+	}
+	/**
+	* Scope to get jobs for a specific connection.
+	*/
+	static scopeForConnection(query, connection) {
+		return query.where("connection", connection);
+	}
+	/**
+	* Get the parsed payload.
+	*/
+	getParsedPayload() {
+		try {
+			return JSON.parse(this.payload);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get a summary of the exception.
+	*/
+	getExceptionSummary(maxLength = 100) {
+		if (!this.exception) return "";
+		const firstLine = this.exception.split("\n")[0];
+		return firstLine.length > maxLength ? firstLine.substring(0, maxLength) + "..." : firstLine;
+	}
+};
+//#endregion
+//#region src/Drivers/DatabaseDriver.ts
+var DatabaseDriver = class {
+	constructor(config) {
+		const dbConfig = require_queue_config.queueConfig.connections.database;
+		this.defaultQueue = config?.queue || dbConfig.queue || "default";
+		this.retryAfter = config?.retry_after || dbConfig.retry_after || 90;
+	}
+	async size(queue = this.defaultQueue) {
+		return await QueueJob.query().where("queue", queue).count();
+	}
+	async push(job, queue = this.defaultQueue) {
+		const now = Math.floor(Date.now() / 1e3);
+		const availableAt = Math.floor(job.availableAt / 1e3);
+		await QueueJob.create({
+			uuid: job.uuid,
+			queue,
+			payload: JSON.stringify(job),
+			attempts: 0,
+			available_at: availableAt,
+			created_at: now
+		});
+		return job.id;
+	}
+	async later(delay, job, queue = this.defaultQueue) {
+		job.availableAt = Date.now() + delay * 1e3;
+		return this.push(job, queue);
+	}
+	async pop(queue = this.defaultQueue) {
+		const now = Math.floor(Date.now() / 1e3);
+		const expiredReservation = now - this.retryAfter;
+		const queueJob = await QueueJob.query().where("queue", queue).where(function(q) {
+			q.whereNull("reserved_at").orWhere("reserved_at", "<", expiredReservation);
+		}).where("available_at", "<=", now).orderBy("id", "asc").first();
+		if (!queueJob) return null;
+		const newAttempts = (queueJob.attempts || 0) + 1;
+		await QueueJob.query().where("id", queueJob.id).update({
+			reserved_at: now,
+			attempts: newAttempts
+		});
+		const job = JSON.parse(queueJob.payload);
+		job.reservedAt = now * 1e3;
+		job.attempts = newAttempts;
+		job.__dbRowId = queueJob.id;
+		return job;
+	}
+	async delete(job, _queue = this.defaultQueue) {
+		const rowId = job.__dbRowId;
+		if (rowId != null) await QueueJob.query().where("id", rowId).delete();
+		else await QueueJob.query().where("uuid", job.uuid).delete();
+	}
+	async release(job, delay, _queue = this.defaultQueue) {
+		const availableAt = Math.floor((Date.now() + delay * 1e3) / 1e3);
+		const rowId = job.__dbRowId;
+		job.availableAt = availableAt * 1e3;
+		job.reservedAt = null;
+		const { __dbRowId: _strip, ...cleanJob } = job;
+		const payload = JSON.stringify(cleanJob);
+		if (rowId != null) await QueueJob.query().where("id", rowId).update({
+			reserved_at: null,
+			available_at: availableAt,
+			attempts: job.attempts,
+			payload
+		});
+		else await QueueJob.query().where("uuid", job.uuid).update({
+			reserved_at: null,
+			available_at: availableAt,
+			attempts: job.attempts,
+			payload
+		});
+	}
+	async clear(queue = this.defaultQueue) {
+		const count = await this.size(queue);
+		await QueueJob.query().where("queue", queue).delete();
+		return count;
+	}
+	async getJobs(queue = this.defaultQueue) {
+		return (await QueueJob.query().where("queue", queue).orderBy("id", "asc").get()).map((job) => JSON.parse(job.payload));
+	}
+	async logFailed(connection, queue, job, exception) {
+		const { __dbRowId: _strip, ...cleanJob } = job;
+		await FailedJob.create({
+			uuid: job.uuid,
+			connection,
+			queue,
+			payload: JSON.stringify(cleanJob),
+			exception: exception.stack || exception.message
+		});
+	}
+	async getFailedJobs() {
+		return (await FailedJob.query().orderBy("failed_at", "desc").get()).map((job) => job.toJSON());
+	}
+	async retryFailed(uuid) {
+		const failedJob = await FailedJob.query().where("uuid", uuid).first();
+		if (!failedJob) return false;
+		const job = JSON.parse(failedJob.payload);
+		job.attempts = 0;
+		job.exceptionCount = 0;
+		job.reservedAt = null;
+		job.availableAt = Date.now();
+		await this.push(job, failedJob.queue);
+		await this.forgetFailed(uuid);
+		return true;
+	}
+	async forgetFailed(uuid) {
+		return await FailedJob.query().where("uuid", uuid).delete() > 0;
+	}
+	async flushFailed() {
+		const count = await FailedJob.query().count();
+		await FailedJob.query().delete();
+		return count;
+	}
+};
+//#endregion
+//#region src/Drivers/RedisDriver.ts
+var RedisDriver = class {
+	constructor(config) {
+		this.client = null;
+		this.initialized = false;
+		const redisConfig = require_queue_config.queueConfig.connections.redis;
+		this.defaultQueue = config?.queue || redisConfig.queue || "default";
+		this.retryAfter = config?.retry_after || redisConfig.retry_after || 90;
+		const appName = process.env.APP_NAME || "app";
+		this.prefix = config?.prefix || process.env.REDIS_PREFIX || `${appName}_queue`;
+	}
+	key(queue, suffix = "") {
+		const base = `${this.prefix}:${queue}`;
+		return suffix ? `${base}:${suffix}` : base;
+	}
+	async init() {
+		if (this.initialized && this.client) return;
+		try {
+			const redisUrl = process.env.REDIS_URL || `redis://${process.env.REDIS_HOST || "localhost"}:${process.env.REDIS_PORT || 6379}`;
+			this.client = (0, redis.createClient)({
+				url: redisUrl,
+				password: process.env.REDIS_PASSWORD || void 0
+			});
+			this.client.on("error", (err) => {
+				console.error("[RedisDriver] Connection error:", err);
+			});
+			await this.client.connect();
+			this.initialized = true;
+		} catch (error) {
+			console.error("[RedisDriver] Failed to connect:", error);
+			throw error;
+		}
+	}
+	async ensureConnected() {
+		if (!this.client || !this.initialized) await this.init();
+		return this.client;
+	}
+	async size(queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		const pending = await client.lLen(this.key(queue));
+		const delayed = await client.zCard(this.key(queue, "delayed:score"));
+		const reserved = await client.hLen(this.key(queue, "reserved"));
+		return pending + delayed + reserved;
+	}
+	async push(job, queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		if (job.availableAt > Date.now()) {
+			await client.hSet(this.key(queue, "delayed:body"), job.uuid, JSON.stringify(job));
+			await client.zAdd(this.key(queue, "delayed:score"), {
+				score: job.availableAt,
+				value: job.uuid
+			});
+		} else await client.rPush(this.key(queue), JSON.stringify(job));
+		return job.id;
+	}
+	async later(delay, job, queue = this.defaultQueue) {
+		job.availableAt = Date.now() + delay * 1e3;
+		return this.push(job, queue);
+	}
+	async pop(queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		await this.migrateDelayedJobs(queue);
+		await this.migrateExpiredReserved(queue);
+		const payload = await client.lPop(this.key(queue));
+		if (!payload) return null;
+		const job = JSON.parse(payload);
+		job.attempts += 1;
+		job.reservedAt = Date.now();
+		await client.hSet(this.key(queue, "reserved"), job.uuid, JSON.stringify(job));
+		return job;
+	}
+	async migrateDelayedJobs(queue) {
+		const client = await this.ensureConnected();
+		const now = Date.now();
+		const uuids = await client.zRangeByScore(this.key(queue, "delayed:score"), "-inf", now.toString());
+		for (const uuid of uuids) {
+			const body = await client.hGet(this.key(queue, "delayed:body"), uuid);
+			if (body) {
+				await client.rPush(this.key(queue), body);
+				await client.hDel(this.key(queue, "delayed:body"), uuid);
+			}
+			await client.zRem(this.key(queue, "delayed:score"), uuid);
+		}
+	}
+	async migrateExpiredReserved(queue) {
+		const client = await this.ensureConnected();
+		const cutoff = Date.now() - this.retryAfter * 1e3;
+		const entries = await client.hGetAll(this.key(queue, "reserved"));
+		for (const [uuid, body] of Object.entries(entries)) {
+			const job = JSON.parse(body);
+			if (job.reservedAt != null && job.reservedAt < cutoff) {
+				await client.rPush(this.key(queue), body);
+				await client.hDel(this.key(queue, "reserved"), uuid);
+			}
+		}
+	}
+	async delete(job, queue = this.defaultQueue) {
+		await (await this.ensureConnected()).hDel(this.key(queue, "reserved"), job.uuid);
+	}
+	async release(job, delay, queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		await client.hDel(this.key(queue, "reserved"), job.uuid);
+		job.reservedAt = null;
+		job.availableAt = Date.now() + delay * 1e3;
+		const newPayload = JSON.stringify(job);
+		if (delay > 0) {
+			await client.hSet(this.key(queue, "delayed:body"), job.uuid, newPayload);
+			await client.zAdd(this.key(queue, "delayed:score"), {
+				score: job.availableAt,
+				value: job.uuid
+			});
+		} else await client.rPush(this.key(queue), newPayload);
+	}
+	async clear(queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		const size = await this.size(queue);
+		await client.del(this.key(queue));
+		await client.del(this.key(queue, "delayed:score"));
+		await client.del(this.key(queue, "delayed:body"));
+		await client.del(this.key(queue, "reserved"));
+		return size;
+	}
+	async getJobs(queue = this.defaultQueue) {
+		const client = await this.ensureConnected();
+		const pending = await client.lRange(this.key(queue), 0, -1);
+		const delayedBodies = Object.values(await client.hGetAll(this.key(queue, "delayed:body")));
+		const reservedBodies = Object.values(await client.hGetAll(this.key(queue, "reserved")));
+		return [
+			...pending,
+			...delayedBodies,
+			...reservedBodies
+		].map((p) => JSON.parse(p));
+	}
+	async logFailed(connection, queue, job, exception) {
+		const client = await this.ensureConnected();
+		const failedJob = {
+			uuid: job.uuid,
+			connection,
+			queue,
+			payload: job,
+			exception: exception.stack || exception.message,
+			failed_at: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await client.hSet(`${this.prefix}:failed_jobs`, job.uuid, JSON.stringify(failedJob));
+	}
+	async getFailedJobs() {
+		const jobs = await (await this.ensureConnected()).hGetAll(`${this.prefix}:failed_jobs`);
+		return Object.values(jobs).map((j) => JSON.parse(j));
+	}
+	async retryFailed(uuid) {
+		const data = await (await this.ensureConnected()).hGet(`${this.prefix}:failed_jobs`, uuid);
+		if (!data) return false;
+		const failedJob = JSON.parse(data);
+		const job = failedJob.payload;
+		job.attempts = 0;
+		job.exceptionCount = 0;
+		job.reservedAt = null;
+		job.availableAt = Date.now();
+		await this.push(job, failedJob.queue);
+		await this.forgetFailed(uuid);
+		return true;
+	}
+	async forgetFailed(uuid) {
+		return await (await this.ensureConnected()).hDel(`${this.prefix}:failed_jobs`, uuid) > 0;
+	}
+	async flushFailed() {
+		const client = await this.ensureConnected();
+		const count = await client.hLen(`${this.prefix}:failed_jobs`);
+		await client.del(`${this.prefix}:failed_jobs`);
+		return count;
+	}
+	async disconnect() {
+		if (this.client) {
+			await this.client.quit();
+			this.client = null;
+			this.initialized = false;
+		}
+	}
+};
+//#endregion
+//#region src/Queue.ts
+var Queue_exports = /* @__PURE__ */ __exportAll({
+	Queue: () => Queue,
+	QueueManager: () => QueueManager
+});
+var QueueManager = class {
+	constructor() {
+		this.connections = /* @__PURE__ */ new Map();
+		this.defaultConnection = require_queue_config.queueConfig.default;
+	}
+	/**
+	* Get a queue connection instance.
+	* All drivers are cached — database queries are stateless per-call so sharing
+	* the driver instance is safe and avoids repeated object allocation on every poll.
+	*/
+	connection(name) {
+		const connectionName = name || this.defaultConnection;
+		if (!this.connections.has(connectionName)) {
+			if (!require_queue_config.queueConfig.connections[connectionName]) throw new Error(`Queue connection [${connectionName}] is not defined.`);
+			this.connections.set(connectionName, this.resolve(connectionName));
+		}
+		return this.connections.get(connectionName);
+	}
+	/**
+	* Resolve a queue connection instance.
+	*/
+	resolve(name) {
+		const config = require_queue_config.queueConfig.connections[name];
+		if (!config) throw new Error(`Queue connection [${name}] is not defined.`);
+		switch (config.driver) {
+			case "sync": return new SyncDriver();
+			case "database": return new DatabaseDriver({
+				table: config.table,
+				queue: config.queue,
+				retry_after: config.retry_after
+			});
+			case "redis": return new RedisDriver({
+				queue: config.queue,
+				retry_after: config.retry_after
+			});
+			default: throw new Error(`Queue driver [${config.driver}] is not supported.`);
+		}
+	}
+	/**
+	* Get the default connection name.
+	*/
+	getDefaultDriver() {
+		return this.defaultConnection;
+	}
+	/**
+	* Set the default connection name.
+	*/
+	setDefaultDriver(name) {
+		this.defaultConnection = name;
+	}
+	/**
+	* Push a new job onto the queue.
+	* Respects uniqueId/uniqueFor — silently deduplicates if a lock already exists.
+	*/
+	async push(job, queue) {
+		if (job.uniqueId) {
+			const lockKey = `queue:unique:${job.uniqueId}`;
+			const existingUuid = await _lara_node_cache.Cache.get(lockKey).catch(() => null);
+			if (existingUuid != null) return existingUuid ?? job.uniqueId;
+			const ttl = job.uniqueFor && job.uniqueFor > 0 ? job.uniqueFor : null;
+			await _lara_node_cache.Cache.set(lockKey, job.uuid || "pending", ttl).catch(() => {});
+		}
+		const serialized = job.serialize();
+		const connection = this.connection(job.connection);
+		const queueName = queue || job.queue;
+		if (job.delay > 0) return connection.later(job.delay, serialized, queueName);
+		return connection.push(serialized, queueName);
+	}
+	/**
+	* Release the unique lock for a job after it completes or permanently fails.
+	*/
+	async releaseUniqueLock(job) {
+		const uniqueId = job.uniqueId;
+		if (uniqueId) await _lara_node_cache.Cache.del(`queue:unique:${uniqueId}`).catch(() => {});
+	}
+	/**
+	* Push a new job onto the queue after a delay.
+	*/
+	async later(delay, job, queue) {
+		job.withDelay(delay);
+		return this.push(job, queue);
+	}
+	/**
+	* Push a raw payload onto the queue.
+	*/
+	async pushRaw(payload, queue, connection) {
+		return this.connection(connection).push(payload, queue);
+	}
+	/**
+	* Push multiple jobs onto the queue.
+	*/
+	async bulk(jobs, queue) {
+		return Promise.all(jobs.map((job) => this.push(job, queue)));
+	}
+	/**
+	* Pop the next job from the queue.
+	*/
+	async pop(queue, connection) {
+		return this.connection(connection).pop(queue);
+	}
+	/**
+	* Get the size of the queue.
+	*/
+	async size(queue, connection) {
+		return this.connection(connection).size(queue);
+	}
+	/**
+	* Clear all jobs from the queue.
+	*/
+	async clear(queue, connection) {
+		return this.connection(connection).clear(queue);
+	}
+	/**
+	* Get all jobs from a queue.
+	*/
+	async getJobs(queue, connection) {
+		return this.connection(connection).getJobs(queue);
+	}
+	asFailedDriver(driver) {
+		return "logFailed" in driver ? driver : null;
+	}
+	async logFailed(connectionName, queue, job, exception) {
+		const failed = this.asFailedDriver(this.connection(connectionName));
+		if (failed) await failed.logFailed(connectionName, queue, job, exception);
+	}
+	async getFailedJobs(connection) {
+		const failed = this.asFailedDriver(this.connection(connection));
+		return failed ? failed.getFailedJobs() : [];
+	}
+	async retryFailed(uuid, connection) {
+		const failed = this.asFailedDriver(this.connection(connection));
+		return failed ? failed.retryFailed(uuid) : false;
+	}
+	async forgetFailed(uuid, connection) {
+		const failed = this.asFailedDriver(this.connection(connection));
+		return failed ? failed.forgetFailed(uuid) : false;
+	}
+	async flushFailed(connection) {
+		const failed = this.asFailedDriver(this.connection(connection));
+		return failed ? failed.flushFailed() : 0;
+	}
+};
+const Queue = new QueueManager();
+//#endregion
+//#region src/Worker.ts
+let signalsRegistered = false;
+var Worker = class Worker extends events.EventEmitter {
+	static {
+		this.IDLE_CHECK_INTERVAL = 5;
+	}
+	constructor(connectionName, queues = "default", options = {}) {
+		super();
+		this.running = false;
+		this.paused = false;
+		this.shouldQuit = false;
+		this.jobsProcessed = 0;
+		this.startTime = 0;
+		this.currentJob = null;
+		this.idleTicks = 0;
+		this.connectionName = connectionName || require_queue_config.queueConfig.default;
+		this.queues = Array.isArray(queues) ? queues : [queues];
+		this.restartKey = `${process.env.APP_NAME || "app"}:queue:restart`;
+		this.horizonCtrlPrefix = `${process.env.APP_NAME || "app"}:horizon:ctrl`;
+		this.workerId = options.workerId;
+		this.options = {
+			connection: this.connectionName,
+			queue: queues,
+			delay: options.delay ?? 0,
+			memory: options.memory ?? 128,
+			timeout: options.timeout ?? require_queue_config.queueConfig.defaults.timeout,
+			sleep: options.sleep ?? 3,
+			maxTries: options.maxTries ?? require_queue_config.queueConfig.defaults.tries,
+			maxJobs: options.maxJobs ?? 0,
+			maxTime: options.maxTime ?? 0,
+			force: options.force ?? false,
+			stopWhenEmpty: options.stopWhenEmpty ?? false,
+			rest: options.rest ?? 0,
+			verbose: options.verbose ?? false
+		};
+	}
+	async daemon() {
+		if (this.running) return;
+		this.running = true;
+		this.shouldQuit = false;
+		this.startTime = Date.now();
+		this.jobsProcessed = 0;
+		console.log(`[Worker] Starting on connection [${this.connectionName}] processing queues: ${this.queues.join(", ")}`);
+		this.emit("worker:start", {
+			connection: this.connectionName,
+			queues: this.queues
+		});
+		this.registerSignalHandlers();
+		while (this.running && !this.shouldQuit) {
+			if (this.paused) {
+				await this.sleep(this.options.sleep * 1e3);
+				continue;
+			}
+			if (this.options.maxJobs > 0 && this.jobsProcessed >= this.options.maxJobs) {
+				console.log(`[Worker] Max jobs (${this.options.maxJobs}) reached, stopping...`);
+				this.stop();
+				break;
+			}
+			if (this.options.maxTime > 0) {
+				if ((Date.now() - this.startTime) / 1e3 >= this.options.maxTime) {
+					console.log(`[Worker] Max time (${this.options.maxTime}s) reached, stopping...`);
+					this.stop();
+					break;
+				}
+			}
+			if (this.idleTicks % Worker.IDLE_CHECK_INTERVAL === 0) {
+				if (this.memoryExceeded()) {
+					console.log("[Worker] Memory limit exceeded, stopping...");
+					this.stop();
+					break;
+				}
+				const [inMaintenance, restart, horizonSignal] = await Promise.all([
+					this.options.force ? Promise.resolve(false) : this.isInMaintenanceMode(),
+					this.shouldRestart(),
+					this.checkHorizonSignal()
+				]);
+				if (horizonSignal === "stop") {
+					console.log("[Worker] Horizon stop signal received, stopping...");
+					this.stop();
+					break;
+				}
+				if (horizonSignal === "pause" && !this.paused) {
+					console.log("[Worker] Horizon pause signal received.");
+					this.pause();
+				}
+				if (horizonSignal === "resume" && this.paused) {
+					console.log("[Worker] Horizon resume signal received.");
+					this.resume();
+				}
+				if (restart) {
+					console.log("[Worker] Restart signal detected, stopping...");
+					this.stop();
+					break;
+				}
+				if (inMaintenance) {
+					if (this.options.verbose) console.log("[Worker] Application in maintenance mode, sleeping...");
+					this.idleTicks++;
+					await this.sleep(this.options.sleep * 1e3);
+					continue;
+				}
+			}
+			const job = await this.getNextJob();
+			if (job) {
+				this.idleTicks = 0;
+				await this.process(job);
+				this.jobsProcessed++;
+				if (this.options.rest > 0) await this.sleep(this.options.rest * 1e3);
+			} else {
+				if (this.options.stopWhenEmpty) {
+					console.log("[Worker] Queue is empty, stopping...");
+					this.stop();
+					break;
+				}
+				this.idleTicks++;
+				await this.sleep(this.options.sleep * 1e3);
+			}
+		}
+		this.emit("worker:stop", {
+			connection: this.connectionName,
+			jobsProcessed: this.jobsProcessed,
+			runtime: (Date.now() - this.startTime) / 1e3
+		});
+		console.log(`[Worker] Stopped. Processed ${this.jobsProcessed} jobs.`);
+	}
+	async runNextJob() {
+		const job = await this.getNextJob();
+		if (!job) return false;
+		await this.process(job);
+		return true;
+	}
+	stop() {
+		this.shouldQuit = true;
+		this.running = false;
+	}
+	pause() {
+		this.paused = true;
+		this.emit("worker:pause");
+	}
+	resume() {
+		this.paused = false;
+		this.emit("worker:resume");
+	}
+	async getNextJob() {
+		for (const queue of this.queues) try {
+			if (this.options.verbose) console.log(`[Worker] Polling queue [${queue}] on connection [${this.connectionName}]...`);
+			const job = await Queue.pop(queue, this.connectionName);
+			if (job) return job;
+		} catch (error) {
+			console.error(`[Worker] Error popping job from queue [${queue}]:`, error);
+		}
+		if (this.options.verbose) console.log(`[Worker] No jobs found, sleeping for ${this.options.sleep}s...`);
+		return null;
+	}
+	async process(serializedJob) {
+		this.currentJob = serializedJob;
+		this.emit("job:processing", {
+			connectionName: this.connectionName,
+			job: serializedJob
+		});
+		console.log(`[Worker] Processing job: ${serializedJob.displayName} (${serializedJob.uuid})`);
+		try {
+			const job = Job.deserialize(serializedJob);
+			if (!job) throw new Error(`Failed to deserialize job: ${serializedJob.job}`);
+			const timeoutMs = (serializedJob.timeout || this.options.timeout) * 1e3;
+			let timeoutHandle;
+			const timeoutPromise = new Promise((_, reject) => {
+				timeoutHandle = setTimeout(() => reject(/* @__PURE__ */ new Error("Job timed out")), timeoutMs);
+			});
+			try {
+				await Promise.race([job.handle(), timeoutPromise]);
+			} finally {
+				clearTimeout(timeoutHandle);
+			}
+			await this.handleSuccess(serializedJob);
+		} catch (error) {
+			await this.handleFailure(serializedJob, error);
+		} finally {
+			this.currentJob = null;
+		}
+	}
+	async handleSuccess(job) {
+		await Queue.connection(this.connectionName).delete(job, job.queue);
+		await Queue.releaseUniqueLock(job);
+		this.emit("job:processed", {
+			connectionName: this.connectionName,
+			job
+		});
+		console.log(`[Worker] Job completed: ${job.displayName} (${job.uuid})`);
+	}
+	async handleFailure(job, error) {
+		console.error(`[Worker] Job failed: ${job.displayName} (${job.uuid}) — ${error.message}`);
+		this.emit("job:exception", {
+			connectionName: this.connectionName,
+			job,
+			exception: error
+		});
+		job.exceptionCount = (job.exceptionCount ?? 0) + 1;
+		const maxTries = job.maxTries || this.options.maxTries;
+		const maxExceptions = job.maxExceptions ?? require_queue_config.queueConfig.defaults.maxExceptions;
+		const retryUntilExpired = job.retryUntil != null && Date.now() > job.retryUntil;
+		const shouldFailPermanently = retryUntilExpired || job.attempts >= maxTries || job.exceptionCount >= maxExceptions;
+		const driver = Queue.connection(this.connectionName);
+		if (!shouldFailPermanently) {
+			const delay = this.calculateBackoff(job);
+			console.log(`[Worker] Releasing job for retry — attempt ${job.attempts}/${maxTries}, exceptions ${job.exceptionCount}/${maxExceptions}, delay ${delay}s`);
+			await driver.release(job, delay, job.queue);
+		} else {
+			const reason = retryUntilExpired ? "retryUntil deadline passed" : job.exceptionCount >= maxExceptions ? `maxExceptions (${maxExceptions}) reached` : `maxTries (${maxTries}) reached`;
+			console.log(`[Worker] Job failed permanently after ${job.attempts} attempt(s): ${reason}`);
+			await driver.delete(job, job.queue);
+			await Queue.logFailed(this.connectionName, job.queue, job, error);
+			await Queue.releaseUniqueLock(job);
+			const jobInstance = Job.deserialize(job);
+			if (jobInstance) try {
+				jobInstance.failed(error);
+			} catch (e) {
+				console.error("[Worker] Error in job.failed():", e);
+			}
+			this.emit("job:failed", {
+				connectionName: this.connectionName,
+				job,
+				exception: error
+			});
+		}
+	}
+	calculateBackoff(job) {
+		const backoff = job.backoff || require_queue_config.queueConfig.defaults.backoff;
+		if (typeof backoff === "number") return backoff;
+		if (Array.isArray(backoff)) {
+			const index = Math.min(job.attempts - 1, backoff.length - 1);
+			return backoff[Math.max(0, index)];
+		}
+		return 0;
+	}
+	memoryExceeded() {
+		return process.memoryUsage().heapUsed / 1024 / 1024 >= this.options.memory;
+	}
+	async isInMaintenanceMode() {
+		try {
+			return await _lara_node_cache.Cache.has(`${process.env.APP_NAME || "app"}:maintenance`);
+		} catch {
+			return false;
+		}
+	}
+	async shouldRestart() {
+		try {
+			const restartTs = await _lara_node_cache.Cache.get(this.restartKey);
+			return restartTs != null && Number(restartTs) > this.startTime;
+		} catch {
+			return false;
+		}
+	}
+	/** Read and immediately clear a Horizon dashboard control signal for this worker. */
+	async checkHorizonSignal() {
+		if (!this.workerId) return null;
+		const key = `${this.horizonCtrlPrefix}:${this.workerId}`;
+		try {
+			const sig = await _lara_node_cache.Cache.get(key);
+			if (sig) await _lara_node_cache.Cache.del(key);
+			return sig ?? null;
+		} catch {
+			return null;
+		}
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	registerSignalHandlers() {
+		if (signalsRegistered) return;
+		signalsRegistered = true;
+		for (const signal of [
+			"SIGINT",
+			"SIGTERM",
+			"SIGQUIT"
+		]) process.on(signal, () => {
+			console.log(`\n[Worker] Received ${signal}, stopping gracefully...`);
+			this.stop();
+		});
+	}
+	isRunning() {
+		return this.running;
+	}
+	isPaused() {
+		return this.paused;
+	}
+	getJobsProcessed() {
+		return this.jobsProcessed;
+	}
+	getCurrentJob() {
+		return this.currentJob;
+	}
+	getRuntime() {
+		return this.startTime > 0 ? (Date.now() - this.startTime) / 1e3 : 0;
+	}
+	getStatus() {
+		return {
+			running: this.running,
+			paused: this.paused,
+			jobsProcessed: this.jobsProcessed,
+			runtime: this.getRuntime(),
+			currentJob: this.currentJob,
+			memory: process.memoryUsage().heapUsed / 1024 / 1024
+		};
+	}
+};
+//#endregion
+//#region src/Scheduler.ts
+const SCHEDULER_LOCK_PREFIX = `${process.env.APP_NAME || "app"}:scheduler:lock`;
+async function acquireLock(key, ttlSeconds) {
+	const lockKey = `${SCHEDULER_LOCK_PREFIX}:${key}`;
+	if (await _lara_node_cache.Cache.get(lockKey)) return false;
+	await _lara_node_cache.Cache.set(lockKey, Date.now(), ttlSeconds);
+	return true;
+}
+async function releaseLock(key) {
+	await _lara_node_cache.Cache.del(`${SCHEDULER_LOCK_PREFIX}:${key}`);
+}
+function createObservableTask(task) {
+	try {
+		task.nextRun = cron_parser.CronExpressionParser.parse(task.expression, { tz: task.timezone || "UTC" }).next().toDate();
+	} catch {}
+	return task;
+}
+var Schedule = class {
+	constructor() {
+		this.tasks = [];
+		this.running = false;
+		this.events = new events.EventEmitter();
+		this.cronPartsCache = /* @__PURE__ */ new Map();
+		this.options = { verbose: false };
+	}
+	call(callback) {
+		const task = createObservableTask(this.defaultTask(`closure-${Date.now()}`, callback));
+		this.tasks.push(task);
+		return new ScheduledTaskBuilder(task);
+	}
+	command(command, args = []) {
+		const callback = async () => {
+			const { exec } = await import("child_process");
+			const { promisify } = await import("util");
+			const execAsync = promisify(exec);
+			const fullCommand = `npm run artisan -- ${command} ${args.join(" ")}`;
+			console.log(`[Scheduler] Running command: ${fullCommand}`);
+			const { stdout, stderr } = await execAsync(fullCommand);
+			if (stdout) console.log(stdout);
+			if (stderr) console.error(stderr);
+		};
+		const task = createObservableTask(this.defaultTask(`command:${command}`, callback, `Artisan command: ${command}`));
+		this.tasks.push(task);
+		return new ScheduledTaskBuilder(task);
+	}
+	exec(command) {
+		const callback = async () => {
+			const { exec } = await import("child_process");
+			const { promisify } = await import("util");
+			const execAsync = promisify(exec);
+			console.log(`[Scheduler] Executing: ${command}`);
+			const { stdout, stderr } = await execAsync(command);
+			if (stdout) console.log(stdout);
+			if (stderr) console.error(stderr);
+		};
+		const task = createObservableTask(this.defaultTask(`exec:${command.slice(0, 50)}`, callback, `Shell command: ${command}`));
+		this.tasks.push(task);
+		return new ScheduledTaskBuilder(task);
+	}
+	job(JobClass, queue) {
+		const callback = async () => {
+			const pending = JobClass.dispatch();
+			if (queue) pending.onQueue(queue);
+			await pending.dispatch();
+		};
+		const task = createObservableTask(this.defaultTask(`job:${JobClass.name || "anonymous"}`, callback, `Dispatch job: ${JobClass.name}`));
+		this.tasks.push(task);
+		return new ScheduledTaskBuilder(task);
+	}
+	defaultTask(name, callback, description) {
+		return {
+			name,
+			callback,
+			expression: "* * * * *",
+			description,
+			withoutOverlapping: false,
+			onOneServer: false,
+			evenInMaintenanceMode: false,
+			runInBackground: false,
+			conditions: [],
+			skipConditions: [],
+			isRunning: false
+		};
+	}
+	updateNextTaskRun(task) {
+		task.nextRun = cron_parser.CronExpressionParser.parse(task.expression, { tz: task.timezone || "UTC" }).next().toDate();
+	}
+	getTasks() {
+		return this.tasks;
+	}
+	getDueTasks() {
+		const now = /* @__PURE__ */ new Date();
+		return this.tasks.filter((task) => this.isDue(task, now));
+	}
+	isDue(task, now = /* @__PURE__ */ new Date()) {
+		if (!this.matchesCronExpression(task.expression, now)) return false;
+		if (task.betweenStart && task.betweenEnd) {
+			const [sh, sm] = task.betweenStart.split(":").map(Number);
+			const [eh, em] = task.betweenEnd.split(":").map(Number);
+			const current = now.getHours() * 60 + now.getMinutes();
+			const start = sh * 60 + sm;
+			const end = eh * 60 + em;
+			if (current < start || current > end) return false;
+		}
+		return true;
+	}
+	matchesCronExpression(expression, date) {
+		let parts = this.cronPartsCache.get(expression);
+		if (!parts) {
+			parts = expression.split(" ");
+			if (parts.length !== 5) {
+				console.warn(`[Scheduler] Invalid cron expression: ${expression}`);
+				return false;
+			}
+			this.cronPartsCache.set(expression, parts);
+		}
+		const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+		return this.matchCronPart(minute, date.getMinutes()) && this.matchCronPart(hour, date.getHours()) && this.matchCronPart(dayOfMonth, date.getDate()) && this.matchCronPart(month, date.getMonth() + 1) && this.matchCronPart(dayOfWeek, date.getDay());
+	}
+	matchCronPart(pattern, value) {
+		if (pattern === "*") return true;
+		if (pattern.startsWith("*/")) return value % parseInt(pattern.slice(2), 10) === 0;
+		if (pattern.includes("-")) {
+			const [start, end] = pattern.split("-").map(Number);
+			return value >= start && value <= end;
+		}
+		if (pattern.includes(",")) return pattern.split(",").map(Number).includes(value);
+		return parseInt(pattern, 10) === value;
+	}
+	async runDueTasks() {
+		const maintenanceKey = `${process.env.APP_NAME || "app"}:maintenance`;
+		const inMaintenance = await _lara_node_cache.Cache.has(maintenanceKey).catch(() => false);
+		const dueTasks = this.getDueTasks();
+		console.log(`[Scheduler] Found ${dueTasks.length} due task(s)`);
+		for (const task of dueTasks) {
+			if (inMaintenance && !task.evenInMaintenanceMode) {
+				console.log(`[Scheduler] Skipping task in maintenance mode: ${task.name}`);
+				continue;
+			}
+			if (task.conditions.length > 0) {
+				if (!(await Promise.all(task.conditions.map((fn) => fn()))).every(Boolean)) {
+					if (this.options.verbose) console.log(`[Scheduler] Skipping task (when() failed): ${task.name}`);
+					continue;
+				}
+			}
+			if (task.skipConditions.length > 0) {
+				if ((await Promise.all(task.skipConditions.map((fn) => fn()))).some(Boolean)) {
+					if (this.options.verbose) console.log(`[Scheduler] Skipping task (skip() matched): ${task.name}`);
+					continue;
+				}
+			}
+			if (task.withoutOverlapping && task.isRunning) {
+				console.log(`[Scheduler] Skipping overlapping task (in-memory): ${task.name}`);
+				continue;
+			}
+			if (task.withoutOverlapping) {
+				if (!await acquireLock(`overlap:${task.name}`, 300).catch(() => false)) {
+					console.log(`[Scheduler] Skipping overlapping task (distributed lock): ${task.name}`);
+					continue;
+				}
+			}
+			if (task.onOneServer) {
+				if (!await acquireLock(`once:${task.name}:${Math.floor(Date.now() / 6e4)}`, 65).catch(() => false)) {
+					console.log(`[Scheduler] Skipping task (onOneServer, another server has it): ${task.name}`);
+					continue;
+				}
+			}
+			await this.runTask(task);
+		}
+	}
+	async runTask(task) {
+		task.isRunning = true;
+		task.lastRun = /* @__PURE__ */ new Date();
+		this.updateNextTaskRun(task);
+		console.log(`[Scheduler] Running task: ${task.name}`);
+		this.events.emit("task:start", task);
+		const finalize = async (error) => {
+			task.isRunning = false;
+			if (task.withoutOverlapping) await releaseLock(`overlap:${task.name}`).catch(() => {});
+			if (error) task.onFailureHook?.(task, error);
+			else task.onSuccessHook?.(task);
+		};
+		try {
+			if (task.runInBackground) setImmediate(async () => {
+				try {
+					await task.callback();
+					this.events.emit("task:success", task);
+					await finalize();
+				} catch (error) {
+					console.error(`[Scheduler] Task failed: ${task.name}`, error);
+					this.events.emit("task:failed", task, error);
+					await finalize(error);
+				}
+			});
+			else {
+				await task.callback();
+				this.events.emit("task:success", task);
+				await finalize();
+			}
+		} catch (error) {
+			console.error(`[Scheduler] Task failed: ${task.name}`, error);
+			this.events.emit("task:failed", task, error);
+			await finalize(error);
+		}
+	}
+	async start() {
+		if (this.running) {
+			console.log("[Scheduler] Already running");
+			return;
+		}
+		this.running = true;
+		console.log("[Scheduler] Starting scheduler daemon...");
+		await this.runDueTasks();
+		while (this.running) {
+			const now = /* @__PURE__ */ new Date();
+			const msUntilNextMinute = (60 - now.getSeconds()) * 1e3 - now.getMilliseconds();
+			await this.sleep(msUntilNextMinute);
+			if (this.running) await this.runDueTasks();
+		}
+	}
+	stop() {
+		this.running = false;
+		console.log("[Scheduler] Stopping...");
+	}
+	isRunning() {
+		return this.running;
+	}
+	on(event, listener) {
+		this.events.on(event, listener);
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+var ScheduledTaskBuilder = class {
+	constructor(task) {
+		this.task = task;
+	}
+	everyMinute() {
+		return this.cron("* * * * *");
+	}
+	everyTwoMinutes() {
+		return this.cron("*/2 * * * *");
+	}
+	everyThreeMinutes() {
+		return this.cron("*/3 * * * *");
+	}
+	everyFiveMinutes() {
+		return this.cron("*/5 * * * *");
+	}
+	everyTenMinutes() {
+		return this.cron("*/10 * * * *");
+	}
+	everyFifteenMinutes() {
+		return this.cron("*/15 * * * *");
+	}
+	everyTwentyMinutes() {
+		return this.cron("*/20 * * * *");
+	}
+	everyThirtyMinutes() {
+		return this.cron("*/30 * * * *");
+	}
+	everyFortyFiveMinutes() {
+		return this.cron("*/45 * * * *");
+	}
+	/** Run every N minutes (arbitrary interval). */
+	everyNMinutes(n) {
+		return this.cron(`*/${n} * * * *`);
+	}
+	hourly() {
+		return this.cron("0 * * * *");
+	}
+	hourlyAt(minute) {
+		return this.cron(`${minute} * * * *`);
+	}
+	everyTwoHours() {
+		return this.cron("0 */2 * * *");
+	}
+	everyFourHours() {
+		return this.cron("0 */4 * * *");
+	}
+	everySixHours() {
+		return this.cron("0 */6 * * *");
+	}
+	/** Run every N hours (arbitrary interval). */
+	everyNHours(n) {
+		return this.cron(`0 */${n} * * *`);
+	}
+	daily() {
+		return this.cron("0 0 * * *");
+	}
+	dailyAt(time) {
+		const [hour, minute] = time.split(":").map(Number);
+		return this.cron(`${minute ?? 0} ${hour} * * *`);
+	}
+	twiceDaily(firstHour = 1, secondHour = 13) {
+		return this.cron(`0 ${firstHour},${secondHour} * * *`);
+	}
+	twiceDailyAt(firstHour, firstMinute, secondHour, secondMinute) {
+		return this.cron(`${firstMinute} ${firstHour},${secondHour} * * *`);
+	}
+	weekly() {
+		return this.cron("0 0 * * 0");
+	}
+	weeklyOn(dayOfWeek, time = "0:0") {
+		const [hour, minute] = time.split(":").map(Number);
+		return this.cron(`${minute ?? 0} ${hour} * * ${dayOfWeek}`);
+	}
+	monthly() {
+		return this.cron("0 0 1 * *");
+	}
+	monthlyOn(day, time = "0:0") {
+		const [hour, minute] = time.split(":").map(Number);
+		return this.cron(`${minute ?? 0} ${hour} ${day} * *`);
+	}
+	/**
+	* Run on the last day of the month at midnight.
+	* Uses day 28 as a universally-safe proxy (real last-day check runs at runtime).
+	*/
+	lastDayOfMonth(time = "0:0") {
+		const [hour, minute] = time.split(":").map(Number);
+		this.cron(`${minute ?? 0} ${hour} 28-31 * *`);
+		this.task.conditions.push(() => {
+			const now = /* @__PURE__ */ new Date();
+			const tomorrow = new Date(now);
+			tomorrow.setDate(now.getDate() + 1);
+			return tomorrow.getDate() === 1;
+		});
+		return this;
+	}
+	quarterly() {
+		return this.cron("0 0 1 1,4,7,10 *");
+	}
+	yearly() {
+		return this.cron("0 0 1 1 *");
+	}
+	yearlyOn(month, day = 1, time = "0:0") {
+		const [hour, minute] = time.split(":").map(Number);
+		return this.cron(`${minute ?? 0} ${hour} ${day} ${month} *`);
+	}
+	weekdays() {
+		const parts = this.task.expression.split(" ");
+		parts[4] = "1-5";
+		return this.cron(parts.join(" "));
+	}
+	weekends() {
+		const parts = this.task.expression.split(" ");
+		parts[4] = "0,6";
+		return this.cron(parts.join(" "));
+	}
+	sundays() {
+		return this._setDow("0");
+	}
+	mondays() {
+		return this._setDow("1");
+	}
+	tuesdays() {
+		return this._setDow("2");
+	}
+	wednesdays() {
+		return this._setDow("3");
+	}
+	thursdays() {
+		return this._setDow("4");
+	}
+	fridays() {
+		return this._setDow("5");
+	}
+	saturdays() {
+		return this._setDow("6");
+	}
+	_setDow(dow) {
+		const parts = this.task.expression.split(" ");
+		parts[4] = dow;
+		return this.cron(parts.join(" "));
+	}
+	/**
+	* Only run the task if current time is between start and end (inclusive).
+	* @param start "HH:MM"
+	* @param end   "HH:MM"
+	*/
+	between(start, end) {
+		this.task.betweenStart = start;
+		this.task.betweenEnd = end;
+		return this;
+	}
+	/** Only run when all provided callbacks return true. */
+	when(callback) {
+		this.task.conditions.push(callback);
+		return this;
+	}
+	/** Skip the task when callback returns true. */
+	skip(callback) {
+		this.task.skipConditions.push(callback);
+		return this;
+	}
+	cron(expression) {
+		this.task.expression = expression;
+		try {
+			const interval = cron_parser.CronExpressionParser.parse(expression, { tz: this.task.timezone || "UTC" });
+			this.task.nextRun = interval.next().toDate();
+		} catch {}
+		return this;
+	}
+	name(name) {
+		this.task.name = name;
+		return this;
+	}
+	description(description) {
+		this.task.description = description;
+		return this;
+	}
+	timezone(timezone) {
+		this.task.timezone = timezone;
+		try {
+			const interval = cron_parser.CronExpressionParser.parse(this.task.expression, { tz: timezone });
+			this.task.nextRun = interval.next().toDate();
+		} catch {}
+		return this;
+	}
+	withoutOverlapping() {
+		this.task.withoutOverlapping = true;
+		return this;
+	}
+	onOneServer() {
+		this.task.onOneServer = true;
+		return this;
+	}
+	evenInMaintenanceMode() {
+		this.task.evenInMaintenanceMode = true;
+		return this;
+	}
+	runInBackground() {
+		this.task.runInBackground = true;
+		return this;
+	}
+	onSuccess(callback) {
+		this.task.onSuccessHook = callback;
+		return this;
+	}
+	onFailure(callback) {
+		this.task.onFailureHook = callback;
+		return this;
+	}
+};
+const scheduler = new Schedule();
+//#endregion
+//#region src/QueueServiceProvider.ts
+/**
+* Framework QueueServiceProvider.
+*
+* Override `schedule()` in your app's Console Kernel (or your own QueueServiceProvider)
+* to register cron tasks.
+*
+* @example
+* // app/Providers/QueueServiceProvider.ts
+* import { QueueServiceProvider as BaseProvider } from '@lara-node/queue';
+*
+* export class QueueServiceProvider extends BaseProvider {
+*   protected schedule(): void {
+*     this.scheduler.command('invoice:mark-overdue').dailyAt('00:00');
+*   }
+* }
+*/
+var QueueServiceProvider = class extends _lara_node_core.ServiceProvider {
+	constructor(..._args) {
+		super(..._args);
+		this.scheduler = scheduler;
+	}
+	register() {
+		this.container.singleton(QueueManager, () => Queue);
+		this.container.alias(QueueManager, "queue");
+		this.container.singleton(Schedule, () => scheduler);
+		this.container.alias(Schedule, "schedule");
+	}
+	boot() {
+		this.schedule();
+	}
+	/** Override to define scheduled tasks. */
+	schedule() {}
+	provides() {
+		return [
+			"queue",
+			"schedule",
+			QueueManager.name,
+			Schedule.name
+		];
+	}
+};
+//#endregion
+exports.DatabaseDriver = DatabaseDriver;
+exports.Job = Job;
+exports.PendingDispatch = PendingDispatch;
+exports.Queue = Queue;
+exports.QueueManager = QueueManager;
+exports.QueueServiceProvider = QueueServiceProvider;
+exports.Queueable = Queueable;
+exports.RedisDriver = RedisDriver;
+exports.Schedule = Schedule;
+exports.ScheduledTaskBuilder = ScheduledTaskBuilder;
+exports.SyncDriver = SyncDriver;
+exports.Worker = Worker;
+exports.decryptPayload = decryptPayload;
+exports.dispatch = dispatch;
+exports.encryptPayload = encryptPayload;
+exports.getJobClass = getJobClass;
+exports.getRegisteredJobs = getRegisteredJobs;
+exports.queueConfig = require_queue_config.queueConfig;
+exports.registerJob = registerJob;
+exports.scheduler = scheduler;