@warlock.js/queue 5.13.0

package/esm/duration.mjs

@@ -0,0 +1,28 @@
+import { InvalidDurationError } from "./errors.mjs";
+
+//#region ../queue/src/duration.ts
+const UNIT_MILLISECONDS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+const DURATION_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/;
+/**
+* Convert a {@link Duration} to milliseconds. Numbers are already
+* milliseconds. Anything else is rejected loudly rather than guessed at.
+*/
+function toMilliseconds(value) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new InvalidDurationError(value);
+		return Math.round(value);
+	}
+	const match = typeof value === "string" ? DURATION_PATTERN.exec(value.trim()) : null;
+	if (!match) throw new InvalidDurationError(value);
+	return Math.round(Number(match[1]) * UNIT_MILLISECONDS[match[2]]);
+}
+
+//#endregion
+export { toMilliseconds };
+//# sourceMappingURL=duration.mjs.map

package/esm/duration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.mjs","names":[],"sources":["../../../../../../queue/src/duration.ts"],"sourcesContent":["import { InvalidDurationError } from \"./errors\";\nimport type { Duration } from \"./types\";\n\nconst UNIT_MILLISECONDS: Record<string, number> = {\n  ms: 1,\n  s: 1_000,\n  m: 60_000,\n  h: 3_600_000,\n  d: 86_400_000,\n};\n\nconst DURATION_PATTERN = /^(\\d+(?:\\.\\d+)?)(ms|s|m|h|d)$/;\n\n/**\n * Convert a {@link Duration} to milliseconds. Numbers are already\n * milliseconds. Anything else is rejected loudly rather than guessed at.\n */\nexport function toMilliseconds(value: Duration | string): number {\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value < 0) {\n      throw new InvalidDurationError(value);\n    }\n\n    return Math.round(value);\n  }\n\n  const match = typeof value === \"string\" ? DURATION_PATTERN.exec(value.trim()) : null;\n\n  if (!match) {\n    throw new InvalidDurationError(value);\n  }\n\n  return Math.round(Number(match[1]) * UNIT_MILLISECONDS[match[2]!]!);\n}\n"],"mappings":";;;AAGA,MAAM,oBAA4C;CAChD,IAAI;CACJ,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACL;AAEA,MAAM,mBAAmB;;;;;AAMzB,SAAgB,eAAe,OAAkC;CAC/D,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,GACrC,MAAM,IAAI,qBAAqB,KAAK;EAGtC,OAAO,KAAK,MAAM,KAAK;CACzB;CAEA,MAAM,QAAQ,OAAO,UAAU,WAAW,iBAAiB,KAAK,MAAM,KAAK,CAAC,IAAI;CAEhF,IAAI,CAAC,OACH,MAAM,IAAI,qBAAqB,KAAK;CAGtC,OAAO,KAAK,MAAM,OAAO,MAAM,EAAE,IAAI,kBAAkB,MAAM,GAAK;AACpE"}

package/esm/errors.d.mts

@@ -0,0 +1,36 @@
+//#region ../queue/src/errors.d.ts
+/**
+ * Thrown when the queue is used before `setQueueConfig` (or the queue
+ * connector) supplied a configuration.
+ */
+declare class QueueNotConfiguredError extends Error {
+  constructor();
+}
+/**
+ * Thrown for a malformed duration such as `"10 minutes"`.
+ */
+declare class InvalidDurationError extends Error {
+  constructor(value: unknown);
+}
+/**
+ * Thrown by `defineJob` for an invalid definition.
+ */
+declare class InvalidJobDefinitionError extends Error {
+  constructor(message: string);
+}
+/**
+ * Thrown by `retryFailedJob` when no failed job has the given id.
+ */
+declare class FailedJobNotFoundError extends Error {
+  constructor(id: string, queue: string);
+}
+/**
+ * Thrown by `queueDashboard` when an optional bull-board package is not
+ * installed.
+ */
+declare class QueueDashboardDependencyError extends Error {
+  constructor(missing: string);
+}
+//#endregion
+export { FailedJobNotFoundError, InvalidDurationError, InvalidJobDefinitionError, QueueDashboardDependencyError, QueueNotConfiguredError };
+//# sourceMappingURL=errors.d.mts.map

package/esm/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../../../../../queue/src/errors.ts"],"mappings":";;AAIA;;;cAAa,uBAAA,SAAgC,KAAK;EAAL,WAAA;AAAA;;;;cAchC,oBAAA,SAA6B,KAAK;cAC1B,KAAA;AAAA;;AAAc;AAYnC;cAAa,yBAAA,SAAkC,KAAK;cAC/B,OAAA;AAAA;;;;cASR,sBAAA,SAA+B,KAAK;cAC5B,EAAA,UAAY,KAAA;AAAA;;;;;cAUpB,6BAAA,SAAsC,KAAK;cACnC,OAAA;AAAA"}

package/esm/errors.mjs

@@ -0,0 +1,55 @@
+//#region ../queue/src/errors.ts
+/**
+* Thrown when the queue is used before `setQueueConfig` (or the queue
+* connector) supplied a configuration.
+*/
+var QueueNotConfiguredError = class extends Error {
+	constructor() {
+		super("@warlock.js/queue is not configured. Add src/config/queue.ts exporting a QueueConfig and register queueConnector() in warlock.config.ts > connectors, or call setQueueConfig() yourself.");
+		this.name = "QueueNotConfiguredError";
+	}
+};
+/**
+* Thrown for a malformed duration such as `"10 minutes"`.
+*/
+var InvalidDurationError = class extends Error {
+	constructor(value) {
+		super(`Invalid duration ${JSON.stringify(value)}: expected milliseconds as a non-negative number or a string like "500ms", "30s", "10m", "2h", "1d".`);
+		this.name = "InvalidDurationError";
+	}
+};
+/**
+* Thrown by `defineJob` for an invalid definition.
+*/
+var InvalidJobDefinitionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidJobDefinitionError";
+	}
+};
+/**
+* Thrown by `retryFailedJob` when no failed job has the given id.
+*/
+var FailedJobNotFoundError = class extends Error {
+	constructor(id, queue) {
+		super(`No failed job with id "${id}" on queue "${queue}".`);
+		this.name = "FailedJobNotFoundError";
+	}
+};
+/**
+* Thrown by `queueDashboard` when an optional bull-board package is not
+* installed.
+*/
+var QueueDashboardDependencyError = class extends Error {
+	constructor(missing) {
+		super(`The queue dashboard needs the optional package "${missing}", which is not installed.\nInstall both bull-board packages:
+
+  npm install @bull-board/api @bull-board/fastify
+`);
+		this.name = "QueueDashboardDependencyError";
+	}
+};
+
+//#endregion
+export { FailedJobNotFoundError, InvalidDurationError, InvalidJobDefinitionError, QueueDashboardDependencyError, QueueNotConfiguredError };
+//# sourceMappingURL=errors.mjs.map

package/esm/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../queue/src/errors.ts"],"sourcesContent":["/**\n * Thrown when the queue is used before `setQueueConfig` (or the queue\n * connector) supplied a configuration.\n */\nexport class QueueNotConfiguredError extends Error {\n  public constructor() {\n    super(\n      \"@warlock.js/queue is not configured. Add src/config/queue.ts exporting a QueueConfig \" +\n        \"and register queueConnector() in warlock.config.ts > connectors, \" +\n        \"or call setQueueConfig() yourself.\",\n    );\n    this.name = \"QueueNotConfiguredError\";\n  }\n}\n\n/**\n * Thrown for a malformed duration such as `\"10 minutes\"`.\n */\nexport class InvalidDurationError extends Error {\n  public constructor(value: unknown) {\n    super(\n      `Invalid duration ${JSON.stringify(value)}: expected milliseconds as a non-negative number ` +\n        `or a string like \"500ms\", \"30s\", \"10m\", \"2h\", \"1d\".`,\n    );\n    this.name = \"InvalidDurationError\";\n  }\n}\n\n/**\n * Thrown by `defineJob` for an invalid definition.\n */\nexport class InvalidJobDefinitionError extends Error {\n  public constructor(message: string) {\n    super(message);\n    this.name = \"InvalidJobDefinitionError\";\n  }\n}\n\n/**\n * Thrown by `retryFailedJob` when no failed job has the given id.\n */\nexport class FailedJobNotFoundError extends Error {\n  public constructor(id: string, queue: string) {\n    super(`No failed job with id \"${id}\" on queue \"${queue}\".`);\n    this.name = \"FailedJobNotFoundError\";\n  }\n}\n\n/**\n * Thrown by `queueDashboard` when an optional bull-board package is not\n * installed.\n */\nexport class QueueDashboardDependencyError extends Error {\n  public constructor(missing: string) {\n    super(\n      `The queue dashboard needs the optional package \"${missing}\", which is not installed.\\n` +\n        \"Install both bull-board packages:\\n\\n\" +\n        \"  npm install @bull-board/api @bull-board/fastify\\n\",\n    );\n    this.name = \"QueueDashboardDependencyError\";\n  }\n}\n"],"mappings":";;;;;AAIA,IAAa,0BAAb,cAA6C,MAAM;CACjD,AAAO,cAAc;EACnB,MACE,0LAGF;EACA,KAAK,OAAO;CACd;AACF;;;;AAKA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,AAAO,YAAY,OAAgB;EACjC,MACE,oBAAoB,KAAK,UAAU,KAAK,EAAE,qGAE5C;EACA,KAAK,OAAO;CACd;AACF;;;;AAKA,IAAa,4BAAb,cAA+C,MAAM;CACnD,AAAO,YAAY,SAAiB;EAClC,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;;;;AAKA,IAAa,yBAAb,cAA4C,MAAM;CAChD,AAAO,YAAY,IAAY,OAAe;EAC5C,MAAM,0BAA0B,GAAG,cAAc,MAAM,GAAG;EAC1D,KAAK,OAAO;CACd;AACF;;;;;AAMA,IAAa,gCAAb,cAAmD,MAAM;CACvD,AAAO,YAAY,SAAiB;EAClC,MACE,mDAAmD,QAAQ;;;CAG7D;EACA,KAAK,OAAO;CACd;AACF"}

package/esm/failed-jobs.d.mts

@@ -0,0 +1,23 @@
+import { FailedJob } from "./types.mjs";
+
+//#region ../queue/src/failed-jobs.d.ts
+type FailedJobsOptions = {
+  /** Queue to read. Default: the default queue. */queue?: string; /** First index (newest first). Default `0`. */
+  start?: number; /** Last index, inclusive. Default `99`. */
+  end?: number;
+};
+/**
+ * List failed jobs, newest first — jobs that used up every attempt, or
+ * failed unrecoverably. Each entry can be retried.
+ */
+declare function failedJobs(options?: FailedJobsOptions): Promise<FailedJob[]>;
+/**
+ * Retry one failed job by id: it goes back to waiting with its attempts reset.
+ * Throws {@link FailedJobNotFoundError} when no FAILED job has that id.
+ */
+declare function retryFailedJob(id: string, options?: {
+  queue?: string;
+}): Promise<void>;
+//#endregion
+export { FailedJobsOptions, failedJobs, retryFailedJob };
+//# sourceMappingURL=failed-jobs.d.mts.map

package/esm/failed-jobs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failed-jobs.d.mts","names":[],"sources":["../../../../../../queue/src/failed-jobs.ts"],"mappings":";;;KAMY,iBAAA;mDAEV,KAAA,WAF2B;EAI3B,KAAA,WAJ2B;EAM3B,GAAA;AAAA;;;AAAG;AAOL;iBAAsB,UAAA,CAAW,OAAA,GAAS,iBAAA,GAAyB,OAAA,CAAQ,SAAA;;;;;iBAWrD,cAAA,CAAe,EAAA,UAAY,OAAA;EAAW,KAAA;AAAA,IAAwB,OAAO"}

package/esm/failed-jobs.mjs

@@ -0,0 +1,39 @@
+import { FailedJobNotFoundError } from "./errors.mjs";
+import { defaultQueueName } from "./config.mjs";
+import { getQueue } from "./queue-manager.mjs";
+
+//#region ../queue/src/failed-jobs.ts
+/**
+* List failed jobs, newest first — jobs that used up every attempt, or
+* failed unrecoverably. Each entry can be retried.
+*/
+async function failedJobs(options = {}) {
+	return (await getQueue(options.queue ?? defaultQueueName()).getFailed(options.start ?? 0, options.end ?? 99)).map((job) => toFailedJob(job));
+}
+/**
+* Retry one failed job by id: it goes back to waiting with its attempts reset.
+* Throws {@link FailedJobNotFoundError} when no FAILED job has that id.
+*/
+async function retryFailedJob(id, options = {}) {
+	const queueName = options.queue ?? defaultQueueName();
+	const job = await getQueue(queueName).getJob(id);
+	if (!job || !await job.isFailed()) throw new FailedJobNotFoundError(id, queueName);
+	await job.retry("failed");
+}
+function toFailedJob(job) {
+	return {
+		id: String(job.id),
+		name: job.name,
+		queue: job.queueName,
+		payload: job.data,
+		attemptsMade: job.attemptsMade,
+		failedReason: job.failedReason,
+		stacktrace: job.stacktrace ?? [],
+		failedAt: job.finishedOn ? new Date(job.finishedOn) : void 0,
+		retry: () => job.retry("failed")
+	};
+}
+
+//#endregion
+export { failedJobs, retryFailedJob };
+//# sourceMappingURL=failed-jobs.mjs.map

package/esm/failed-jobs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"failed-jobs.mjs","names":[],"sources":["../../../../../../queue/src/failed-jobs.ts"],"sourcesContent":["import type { Job } from \"bullmq\";\nimport { defaultQueueName } from \"./config\";\nimport { FailedJobNotFoundError } from \"./errors\";\nimport { getQueue } from \"./queue-manager\";\nimport type { FailedJob } from \"./types\";\n\nexport type FailedJobsOptions = {\n  /** Queue to read. Default: the default queue. */\n  queue?: string;\n  /** First index (newest first). Default `0`. */\n  start?: number;\n  /** Last index, inclusive. Default `99`. */\n  end?: number;\n};\n\n/**\n * List failed jobs, newest first — jobs that used up every attempt, or\n * failed unrecoverably. Each entry can be retried.\n */\nexport async function failedJobs(options: FailedJobsOptions = {}): Promise<FailedJob[]> {\n  const queueName = options.queue ?? defaultQueueName();\n  const jobs = await getQueue(queueName).getFailed(options.start ?? 0, options.end ?? 99);\n\n  return jobs.map((job) => toFailedJob(job));\n}\n\n/**\n * Retry one failed job by id: it goes back to waiting with its attempts reset.\n * Throws {@link FailedJobNotFoundError} when no FAILED job has that id.\n */\nexport async function retryFailedJob(id: string, options: { queue?: string } = {}): Promise<void> {\n  const queueName = options.queue ?? defaultQueueName();\n  const job = await getQueue(queueName).getJob(id);\n\n  if (!job || !(await job.isFailed())) {\n    throw new FailedJobNotFoundError(id, queueName);\n  }\n\n  await job.retry(\"failed\");\n}\n\nfunction toFailedJob(job: Job): FailedJob {\n  return {\n    id: String(job.id),\n    name: job.name,\n    queue: job.queueName,\n    payload: job.data,\n    attemptsMade: job.attemptsMade,\n    failedReason: job.failedReason,\n    stacktrace: job.stacktrace ?? [],\n    failedAt: job.finishedOn ? new Date(job.finishedOn) : undefined,\n    retry: () => job.retry(\"failed\"),\n  };\n}\n"],"mappings":";;;;;;;;;AAmBA,eAAsB,WAAW,UAA6B,CAAC,GAAyB;CAItF,QAAO,MAFY,SADD,QAAQ,SAAS,iBAAiB,CACf,CAAC,CAAC,UAAU,QAAQ,SAAS,GAAG,QAAQ,OAAO,EAAE,EAE3E,CAAC,KAAK,QAAQ,YAAY,GAAG,CAAC;AAC3C;;;;;AAMA,eAAsB,eAAe,IAAY,UAA8B,CAAC,GAAkB;CAChG,MAAM,YAAY,QAAQ,SAAS,iBAAiB;CACpD,MAAM,MAAM,MAAM,SAAS,SAAS,CAAC,CAAC,OAAO,EAAE;CAE/C,IAAI,CAAC,OAAO,CAAE,MAAM,IAAI,SAAS,GAC/B,MAAM,IAAI,uBAAuB,IAAI,SAAS;CAGhD,MAAM,IAAI,MAAM,QAAQ;AAC1B;AAEA,SAAS,YAAY,KAAqB;CACxC,OAAO;EACL,IAAI,OAAO,IAAI,EAAE;EACjB,MAAM,IAAI;EACV,OAAO,IAAI;EACX,SAAS,IAAI;EACb,cAAc,IAAI;EAClB,cAAc,IAAI;EAClB,YAAY,IAAI,cAAc,CAAC;EAC/B,UAAU,IAAI,aAAa,IAAI,KAAK,IAAI,UAAU,IAAI;EACtD,aAAa,IAAI,MAAM,QAAQ;CACjC;AACF"}

package/esm/index.d.mts

@@ -0,0 +1,10 @@
+import { DispatchOptions, DispatchedJob, Duration, DurationUnit, FailedJob, JobBackoff, JobContext, JobDefinition, JobOptions, JobProgress, JobRetention, JobSnapshot, JobState, QueueConfig, QueueJob, QueueWorkersConfig } from "./types.mjs";
+import { defaultQueueName, getQueueConfig, resetQueueConfig, setQueueConfig } from "./config.mjs";
+import { DashboardServer, QueueDashboardOptions, loadBullBoard, queueDashboard } from "./dashboard.mjs";
+import { defineJob } from "./define-job.mjs";
+import { toMilliseconds } from "./duration.mjs";
+import { FailedJobNotFoundError, InvalidDurationError, InvalidJobDefinitionError, QueueDashboardDependencyError, QueueNotConfiguredError } from "./errors.mjs";
+import { FailedJobsOptions, failedJobs, retryFailedJob } from "./failed-jobs.mjs";
+import { QUEUE_CONNECTOR_PRIORITY, QueueConnectorOptions, queueConnector } from "./queue-connector.mjs";
+import { CloseQueueOptions, closeQueue, getQueue, runningWorkers, startWorkers } from "./queue-manager.mjs";
+export { type CloseQueueOptions, DashboardServer, DispatchOptions, DispatchedJob, Duration, DurationUnit, FailedJob, FailedJobNotFoundError, FailedJobsOptions, InvalidDurationError, InvalidJobDefinitionError, JobBackoff, JobContext, JobDefinition, JobOptions, JobProgress, JobRetention, JobSnapshot, JobState, QUEUE_CONNECTOR_PRIORITY, QueueConfig, QueueConnectorOptions, QueueDashboardDependencyError, QueueDashboardOptions, QueueJob, QueueNotConfiguredError, QueueWorkersConfig, closeQueue, defaultQueueName, defineJob, failedJobs, getQueue, getQueueConfig, loadBullBoard, queueConnector, queueDashboard, resetQueueConfig, retryFailedJob, runningWorkers, setQueueConfig, startWorkers, toMilliseconds };

package/esm/index.mjs

@@ -0,0 +1,10 @@
+import { FailedJobNotFoundError, InvalidDurationError, InvalidJobDefinitionError, QueueDashboardDependencyError, QueueNotConfiguredError } from "./errors.mjs";
+import { defaultQueueName, getQueueConfig, resetQueueConfig, setQueueConfig } from "./config.mjs";
+import { closeQueue, getQueue, runningWorkers, startWorkers } from "./queue-manager.mjs";
+import { loadBullBoard, queueDashboard } from "./dashboard.mjs";
+import { toMilliseconds } from "./duration.mjs";
+import { defineJob } from "./define-job.mjs";
+import { failedJobs, retryFailedJob } from "./failed-jobs.mjs";
+import { QUEUE_CONNECTOR_PRIORITY, queueConnector } from "./queue-connector.mjs";
+
+export { FailedJobNotFoundError, InvalidDurationError, InvalidJobDefinitionError, QUEUE_CONNECTOR_PRIORITY, QueueDashboardDependencyError, QueueNotConfiguredError, closeQueue, defaultQueueName, defineJob, failedJobs, getQueue, getQueueConfig, loadBullBoard, queueConnector, queueDashboard, resetQueueConfig, retryFailedJob, runningWorkers, setQueueConfig, startWorkers, toMilliseconds };

package/esm/job-registry.mjs

@@ -0,0 +1,39 @@
+import { defaultQueueName } from "./config.mjs";
+
+//#region ../queue/src/job-registry.ts
+const jobs = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Register a definition under its name.
+*
+* Re-registering a name REPLACES the previous definition: in development a
+* job module is re-evaluated on every reload, and refusing the second
+* evaluation would break the reload. Job names must therefore be unique
+* across the app — two different modules using one name leave only the
+* later handler active.
+*/
+function registerJob(job) {
+	jobs.set(job.name, job);
+	for (const listener of listeners) listener(job);
+}
+/** The definition registered under `name`, if any. */
+function findRegisteredJob(name) {
+	return jobs.get(name);
+}
+/** Every registered definition. */
+function registeredJobs() {
+	return [...jobs.values()];
+}
+/** The queue a definition runs on, resolved against the active config. */
+function queueOf(job) {
+	return job.queue ?? defaultQueueName();
+}
+/** Be told whenever a job is registered. Returns an unsubscribe function. */
+function onJobRegistered(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+
+//#endregion
+export { findRegisteredJob, onJobRegistered, queueOf, registerJob, registeredJobs };
+//# sourceMappingURL=job-registry.mjs.map

package/esm/job-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-registry.mjs","names":[],"sources":["../../../../../../queue/src/job-registry.ts"],"sourcesContent":["import { defaultQueueName } from \"./config\";\nimport type { JobDefinition } from \"./types\";\n\n/** A registered definition, payload/result erased for storage. */\nexport type RegisteredJob = JobDefinition<unknown, unknown>;\n\ntype RegistryListener = (job: RegisteredJob) => void;\n\nconst jobs = new Map<string, RegisteredJob>();\nconst listeners = new Set<RegistryListener>();\n\n/**\n * Register a definition under its name.\n *\n * Re-registering a name REPLACES the previous definition: in development a\n * job module is re-evaluated on every reload, and refusing the second\n * evaluation would break the reload. Job names must therefore be unique\n * across the app — two different modules using one name leave only the\n * later handler active.\n */\nexport function registerJob(job: RegisteredJob): void {\n  jobs.set(job.name, job);\n\n  for (const listener of listeners) {\n    listener(job);\n  }\n}\n\n/** The definition registered under `name`, if any. */\nexport function findRegisteredJob(name: string): RegisteredJob | undefined {\n  return jobs.get(name);\n}\n\n/** Every registered definition. */\nexport function registeredJobs(): RegisteredJob[] {\n  return [...jobs.values()];\n}\n\n/** The queue a definition runs on, resolved against the active config. */\nexport function queueOf(job: Pick<RegisteredJob, \"queue\">): string {\n  return job.queue ?? defaultQueueName();\n}\n\n/** Be told whenever a job is registered. Returns an unsubscribe function. */\nexport function onJobRegistered(listener: RegistryListener): () => void {\n  listeners.add(listener);\n\n  return () => listeners.delete(listener);\n}\n"],"mappings":";;;AAQA,MAAM,uBAAO,IAAI,IAA2B;AAC5C,MAAM,4BAAY,IAAI,IAAsB;;;;;;;;;;AAW5C,SAAgB,YAAY,KAA0B;CACpD,KAAK,IAAI,IAAI,MAAM,GAAG;CAEtB,KAAK,MAAM,YAAY,WACrB,SAAS,GAAG;AAEhB;;AAGA,SAAgB,kBAAkB,MAAyC;CACzE,OAAO,KAAK,IAAI,IAAI;AACtB;;AAGA,SAAgB,iBAAkC;CAChD,OAAO,CAAC,GAAG,KAAK,OAAO,CAAC;AAC1B;;AAGA,SAAgB,QAAQ,KAA2C;CACjE,OAAO,IAAI,SAAS,iBAAiB;AACvC;;AAGA,SAAgB,gBAAgB,UAAwC;CACtE,UAAU,IAAI,QAAQ;CAEtB,aAAa,UAAU,OAAO,QAAQ;AACxC"}

package/esm/notifications/index.d.mts

@@ -0,0 +1,2 @@
+import { NOTIFICATION_JOB_NAME, NotificationJobPayload, QueueNotificationDispatcherOptions, queueNotificationDispatcher } from "./queue-notification-dispatcher.mjs";
+export { NOTIFICATION_JOB_NAME, NotificationJobPayload, QueueNotificationDispatcherOptions, queueNotificationDispatcher };

package/esm/notifications/index.mjs

@@ -0,0 +1,3 @@
+import { NOTIFICATION_JOB_NAME, queueNotificationDispatcher } from "./queue-notification-dispatcher.mjs";
+
+export { NOTIFICATION_JOB_NAME, queueNotificationDispatcher };

package/esm/notifications/queue-notification-dispatcher.d.mts

@@ -0,0 +1,34 @@
+import { JobBackoff } from "../types.mjs";
+import { QueueDispatcher } from "@warlock.js/notifications";
+
+//#region ../queue/src/notifications/queue-notification-dispatcher.d.ts
+/** The job name notification deliveries run under. */
+declare const NOTIFICATION_JOB_NAME = "warlock.notifications.deliver";
+type NotificationJobPayload = Parameters<QueueDispatcher["dispatch"]>[0];
+type QueueNotificationDispatcherOptions = {
+  /** Queue to deliver on. Default: the default queue. */queue?: string; /** Attempts per delivery. Default: `queue.defaultJobOptions.attempts`, else `1`. */
+  attempts?: number; /** Backoff between attempts. */
+  backoff?: JobBackoff;
+};
+/**
+ * Create the dispatcher for `NotificationConfig.queue`.
+ *
+ * - `SendOptions.delay` is honoured: a number is SECONDS (notifications'
+ *   convention), a string is a duration such as `"10m"`.
+ * - A failing `channel.send` throws, so the delivery is retried per
+ *   `attempts` / `backoff` and ends in `failedJobs()` when exhausted.
+ * - A channel missing from the worker's notifications config fails at once,
+ *   without retries.
+ *
+ * @example src/config/notifications.ts
+ * import { queueNotificationDispatcher } from "@warlock.js/queue/notifications";
+ *
+ * const config: NotificationConfig = {
+ *   channels: { mail: mailChannel() },
+ *   queue: queueNotificationDispatcher({ attempts: 3, backoff: { type: "exponential", delay: 5000 } }),
+ * };
+ */
+declare function queueNotificationDispatcher(options?: QueueNotificationDispatcherOptions): QueueDispatcher;
+//#endregion
+export { NOTIFICATION_JOB_NAME, NotificationJobPayload, QueueNotificationDispatcherOptions, queueNotificationDispatcher };
+//# sourceMappingURL=queue-notification-dispatcher.d.mts.map

package/esm/notifications/queue-notification-dispatcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-notification-dispatcher.d.mts","names":[],"sources":["../../../../../../../queue/src/notifications/queue-notification-dispatcher.ts"],"mappings":";;;;AAoB+D;AAAA,cAFlD,qBAAA;AAAA,KAED,sBAAA,GAAyB,UAAU,CAAC,eAAA;AAAA,KAEpC,kCAAA;EAMU,uDAJpB,KAAA,WAEA;EAAA,QAAA,WAEU;EAAV,OAAA,GAAU,UAAU;AAAA;AAqBtB;;;;;;;;AAEkB;;;;;;;;;;AAFlB,iBAAgB,2BAAA,CACd,OAAA,GAAS,kCAAA,GACR,eAAe"}

package/esm/notifications/queue-notification-dispatcher.mjs

@@ -0,0 +1,67 @@
+import { toMilliseconds } from "../duration.mjs";
+import { defineJob } from "../define-job.mjs";
+import { UnrecoverableError } from "bullmq";
+import { getNotificationConfig } from "@warlock.js/notifications";
+
+//#region ../queue/src/notifications/queue-notification-dispatcher.ts
+/**
+* BullMQ-backed `QueueDispatcher` for `@warlock.js/notifications`.
+*
+* Notifications renders the payload and resolves the route BEFORE handing a
+* job to its dispatcher, so the job (`{ channel, route, payload, options }`)
+* is plain JSON. This adapter enqueues it as a queue job; the job's handler,
+* running in any worker process, looks the channel up by name in that
+* process's notifications config and calls `channel.send`.
+*
+* Notifications itself has no dependency on this package.
+*/
+/** The job name notification deliveries run under. */
+const NOTIFICATION_JOB_NAME = "warlock.notifications.deliver";
+/**
+* Create the dispatcher for `NotificationConfig.queue`.
+*
+* - `SendOptions.delay` is honoured: a number is SECONDS (notifications'
+*   convention), a string is a duration such as `"10m"`.
+* - A failing `channel.send` throws, so the delivery is retried per
+*   `attempts` / `backoff` and ends in `failedJobs()` when exhausted.
+* - A channel missing from the worker's notifications config fails at once,
+*   without retries.
+*
+* @example src/config/notifications.ts
+* import { queueNotificationDispatcher } from "@warlock.js/queue/notifications";
+*
+* const config: NotificationConfig = {
+*   channels: { mail: mailChannel() },
+*   queue: queueNotificationDispatcher({ attempts: 3, backoff: { type: "exponential", delay: 5000 } }),
+* };
+*/
+function queueNotificationDispatcher(options = {}) {
+	const deliver = defineNotificationJob(options);
+	return { async dispatch(job) {
+		await deliver.dispatch(job, { delay: job.options.delay === void 0 ? void 0 : notificationDelay(job.options.delay) });
+	} };
+}
+function defineNotificationJob(options) {
+	return defineJob({
+		name: NOTIFICATION_JOB_NAME,
+		queue: options.queue,
+		attempts: options.attempts,
+		backoff: options.backoff,
+		async handle(job) {
+			const channel = getNotificationConfig().channels[job.channel];
+			if (!channel) throw new UnrecoverableError(`Notification channel "${job.channel}" is not configured in this worker's notifications config.`);
+			await channel.send({
+				payload: job.payload,
+				route: job.route,
+				options: job.options
+			});
+		}
+	});
+}
+function notificationDelay(delay) {
+	return typeof delay === "number" ? delay * 1e3 : toMilliseconds(delay);
+}
+
+//#endregion
+export { NOTIFICATION_JOB_NAME, queueNotificationDispatcher };
+//# sourceMappingURL=queue-notification-dispatcher.mjs.map

package/esm/notifications/queue-notification-dispatcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-notification-dispatcher.mjs","names":[],"sources":["../../../../../../../queue/src/notifications/queue-notification-dispatcher.ts"],"sourcesContent":["/**\n * BullMQ-backed `QueueDispatcher` for `@warlock.js/notifications`.\n *\n * Notifications renders the payload and resolves the route BEFORE handing a\n * job to its dispatcher, so the job (`{ channel, route, payload, options }`)\n * is plain JSON. This adapter enqueues it as a queue job; the job's handler,\n * running in any worker process, looks the channel up by name in that\n * process's notifications config and calls `channel.send`.\n *\n * Notifications itself has no dependency on this package.\n */\nimport { getNotificationConfig, type QueueDispatcher } from \"@warlock.js/notifications\";\nimport { UnrecoverableError } from \"bullmq\";\nimport { defineJob } from \"../define-job\";\nimport { toMilliseconds } from \"../duration\";\nimport type { Duration, JobBackoff, QueueJob } from \"../types\";\n\n/** The job name notification deliveries run under. */\nexport const NOTIFICATION_JOB_NAME = \"warlock.notifications.deliver\";\n\nexport type NotificationJobPayload = Parameters<QueueDispatcher[\"dispatch\"]>[0];\n\nexport type QueueNotificationDispatcherOptions = {\n  /** Queue to deliver on. Default: the default queue. */\n  queue?: string;\n  /** Attempts per delivery. Default: `queue.defaultJobOptions.attempts`, else `1`. */\n  attempts?: number;\n  /** Backoff between attempts. */\n  backoff?: JobBackoff;\n};\n\n/**\n * Create the dispatcher for `NotificationConfig.queue`.\n *\n * - `SendOptions.delay` is honoured: a number is SECONDS (notifications'\n *   convention), a string is a duration such as `\"10m\"`.\n * - A failing `channel.send` throws, so the delivery is retried per\n *   `attempts` / `backoff` and ends in `failedJobs()` when exhausted.\n * - A channel missing from the worker's notifications config fails at once,\n *   without retries.\n *\n * @example src/config/notifications.ts\n * import { queueNotificationDispatcher } from \"@warlock.js/queue/notifications\";\n *\n * const config: NotificationConfig = {\n *   channels: { mail: mailChannel() },\n *   queue: queueNotificationDispatcher({ attempts: 3, backoff: { type: \"exponential\", delay: 5000 } }),\n * };\n */\nexport function queueNotificationDispatcher(\n  options: QueueNotificationDispatcherOptions = {},\n): QueueDispatcher {\n  const deliver = defineNotificationJob(options);\n\n  return {\n    async dispatch(job) {\n      await deliver.dispatch(job, {\n        delay: job.options.delay === undefined ? undefined : notificationDelay(job.options.delay),\n      });\n    },\n  };\n}\n\nfunction defineNotificationJob(\n  options: QueueNotificationDispatcherOptions,\n): QueueJob<NotificationJobPayload, void> {\n  return defineJob<NotificationJobPayload, void>({\n    name: NOTIFICATION_JOB_NAME,\n    queue: options.queue,\n    attempts: options.attempts,\n    backoff: options.backoff,\n    async handle(job) {\n      const channels = getNotificationConfig().channels as Record<\n        string,\n        { send(context: never): Promise<void> } | undefined\n      >;\n      const channel = channels[job.channel];\n\n      if (!channel) {\n        throw new UnrecoverableError(\n          `Notification channel \"${job.channel}\" is not configured in this worker's notifications config.`,\n        );\n      }\n\n      await channel.send({ payload: job.payload, route: job.route, options: job.options } as never);\n    },\n  });\n}\n\nfunction notificationDelay(delay: number | string): Duration {\n  return typeof delay === \"number\" ? delay * 1_000 : toMilliseconds(delay);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAa,wBAAwB;;;;;;;;;;;;;;;;;;;AA+BrC,SAAgB,4BACd,UAA8C,CAAC,GAC9B;CACjB,MAAM,UAAU,sBAAsB,OAAO;CAE7C,OAAO,EACL,MAAM,SAAS,KAAK;EAClB,MAAM,QAAQ,SAAS,KAAK,EAC1B,OAAO,IAAI,QAAQ,UAAU,SAAY,SAAY,kBAAkB,IAAI,QAAQ,KAAK,EAC1F,CAAC;CACH,EACF;AACF;AAEA,SAAS,sBACP,SACwC;CACxC,OAAO,UAAwC;EAC7C,MAAM;EACN,OAAO,QAAQ;EACf,UAAU,QAAQ;EAClB,SAAS,QAAQ;EACjB,MAAM,OAAO,KAAK;GAKhB,MAAM,UAJW,sBAAsB,CAAC,CAAC,SAIhB,IAAI;GAE7B,IAAI,CAAC,SACH,MAAM,IAAI,mBACR,yBAAyB,IAAI,QAAQ,2DACvC;GAGF,MAAM,QAAQ,KAAK;IAAE,SAAS,IAAI;IAAS,OAAO,IAAI;IAAO,SAAS,IAAI;GAAQ,CAAU;EAC9F;CACF,CAAC;AACH;AAEA,SAAS,kBAAkB,OAAkC;CAC3D,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAQ,eAAe,KAAK;AACzE"}

package/esm/process-job.mjs

@@ -0,0 +1,32 @@
+import { findRegisteredJob } from "./job-registry.mjs";
+import { UnrecoverableError } from "bullmq";
+
+//#region ../queue/src/process-job.ts
+/**
+* The single BullMQ processor every worker runs: route the job to the
+* handler registered under its name.
+*
+* A name with no handler in this process fails with `UnrecoverableError` —
+* retrying cannot make a missing definition appear, so it must not burn
+* through its attempts.
+*/
+async function processJob(job) {
+	const definition = findRegisteredJob(job.name);
+	if (!definition) throw new UnrecoverableError(`No job named "${job.name}" is defined in this process. Make sure the module that calls defineJob() is imported by the worker process.`);
+	const context = {
+		id: String(job.id),
+		name: job.name,
+		queue: job.queueName,
+		attempt: job.attemptsMade + 1,
+		maxAttempts: job.opts.attempts ?? 1,
+		progress: (value) => job.updateProgress(value),
+		log: async (line) => {
+			await job.log(line);
+		}
+	};
+	return definition.handle(job.data, context);
+}
+
+//#endregion
+export { processJob };
+//# sourceMappingURL=process-job.mjs.map

package/esm/process-job.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-job.mjs","names":[],"sources":["../../../../../../queue/src/process-job.ts"],"sourcesContent":["import { type Job, UnrecoverableError } from \"bullmq\";\nimport { findRegisteredJob } from \"./job-registry\";\nimport type { JobContext } from \"./types\";\n\n/**\n * The single BullMQ processor every worker runs: route the job to the\n * handler registered under its name.\n *\n * A name with no handler in this process fails with `UnrecoverableError` —\n * retrying cannot make a missing definition appear, so it must not burn\n * through its attempts.\n */\nexport async function processJob(job: Job): Promise<unknown> {\n  const definition = findRegisteredJob(job.name);\n\n  if (!definition) {\n    throw new UnrecoverableError(\n      `No job named \"${job.name}\" is defined in this process. ` +\n        \"Make sure the module that calls defineJob() is imported by the worker process.\",\n    );\n  }\n\n  const context: JobContext = {\n    id: String(job.id),\n    name: job.name,\n    queue: job.queueName,\n    attempt: job.attemptsMade + 1,\n    maxAttempts: job.opts.attempts ?? 1,\n    progress: (value) => job.updateProgress(value),\n    log: async (line) => {\n      await job.log(line);\n    },\n  };\n\n  return definition.handle(job.data, context);\n}\n"],"mappings":";;;;;;;;;;;;AAYA,eAAsB,WAAW,KAA4B;CAC3D,MAAM,aAAa,kBAAkB,IAAI,IAAI;CAE7C,IAAI,CAAC,YACH,MAAM,IAAI,mBACR,iBAAiB,IAAI,KAAK,6GAE5B;CAGF,MAAM,UAAsB;EAC1B,IAAI,OAAO,IAAI,EAAE;EACjB,MAAM,IAAI;EACV,OAAO,IAAI;EACX,SAAS,IAAI,eAAe;EAC5B,aAAa,IAAI,KAAK,YAAY;EAClC,WAAW,UAAU,IAAI,eAAe,KAAK;EAC7C,KAAK,OAAO,SAAS;GACnB,MAAM,IAAI,IAAI,IAAI;EACpB;CACF;CAEA,OAAO,WAAW,OAAO,IAAI,MAAM,OAAO;AAC5C"}

package/esm/queue-connector.d.mts

@@ -0,0 +1,36 @@
+import { QueueConfig } from "./types.mjs";
+import { Connector } from "@warlock.js/core";
+
+//#region ../queue/src/queue-connector.d.ts
+/**
+ * Boots after every built-in connector (`ConnectorPriority.AI` is `10`), so
+ * the logger is up and anything a job handler needs is already connected;
+ * shuts down before them for the same reason.
+ */
+declare const QUEUE_CONNECTOR_PRIORITY = 11;
+type QueueConnectorOptions = {
+  /**
+   * Supply the configuration directly instead of reading the `queue` config
+   * key (`src/config/queue.ts`).
+   */
+  config?: QueueConfig;
+};
+/**
+ * Construct the queue connector.
+ *
+ * Runs in the `late` lifecycle phase — after app code is imported — so every
+ * `defineJob` in the app has registered before workers start. At start it
+ * reads the `queue` config and starts in-process workers unless
+ * `workers.enabled` is `false`; at shutdown it closes workers (waiting for
+ * active jobs, bounded by `workers.shutdownTimeout`) and then the queues.
+ *
+ * @example
+ * // warlock.config.ts
+ * import { queueConnector } from "@warlock.js/queue";
+ *
+ * export default defineConfig({ connectors: [queueConnector()] });
+ */
+declare function queueConnector(options?: QueueConnectorOptions): Connector;
+//#endregion
+export { QUEUE_CONNECTOR_PRIORITY, QueueConnectorOptions, queueConnector };
+//# sourceMappingURL=queue-connector.d.mts.map

package/esm/queue-connector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-connector.d.mts","names":[],"sources":["../../../../../../queue/src/queue-connector.ts"],"mappings":";;;;;;;AA4BsB;AAkBtB;cA3Ba,wBAAA;AAAA,KAID,qBAAA;EAuBkE;;;;EAlB5E,MAAA,GAAS,WAAW;AAAA;;;;;;;;;;;;;;;;iBAkBN,cAAA,CAAe,OAAA,GAAS,qBAAA,GAA6B,SAAS"}

package/esm/queue-connector.mjs

@@ -0,0 +1,73 @@
+import { resetQueueConfig, setQueueConfig } from "./config.mjs";
+import { closeQueue, startWorkers } from "./queue-manager.mjs";
+import { log } from "@warlock.js/logger";
+
+//#region ../queue/src/queue-connector.ts
+/**
+* Boots after every built-in connector (`ConnectorPriority.AI` is `10`), so
+* the logger is up and anything a job handler needs is already connected;
+* shuts down before them for the same reason.
+*/
+const QUEUE_CONNECTOR_PRIORITY = 11;
+const WATCHED_FILES = ["src/config/queue.ts"];
+/**
+* Construct the queue connector.
+*
+* Runs in the `late` lifecycle phase — after app code is imported — so every
+* `defineJob` in the app has registered before workers start. At start it
+* reads the `queue` config and starts in-process workers unless
+* `workers.enabled` is `false`; at shutdown it closes workers (waiting for
+* active jobs, bounded by `workers.shutdownTimeout`) and then the queues.
+*
+* @example
+* // warlock.config.ts
+* import { queueConnector } from "@warlock.js/queue";
+*
+* export default defineConfig({ connectors: [queueConnector()] });
+*/
+function queueConnector(options = {}) {
+	let active = false;
+	const connector = {
+		name: "queue",
+		priority: 11,
+		lifecyclePhase: "late",
+		isActive: () => active,
+		boot: () => void 0,
+		async start() {
+			const queueConfig = options.config ?? await readQueueConfig();
+			if (!queueConfig) {
+				log.warn("queue", "configured", "queueConnector() is registered but no `queue` config was found (src/config/queue.ts); queue not started");
+				return;
+			}
+			setQueueConfig(queueConfig);
+			const started = await startWorkers();
+			active = true;
+			log.info("queue", "configured", started.length > 0 ? `Queue workers running for: ${started.join(", ")}` : "Queue configured (no in-process workers)");
+		},
+		async restart() {
+			await connector.shutdown();
+			await connector.start();
+		},
+		async shutdown() {
+			if (!active) return;
+			await closeQueue();
+			resetQueueConfig();
+			active = false;
+		},
+		shouldRestart(changedFiles) {
+			return changedFiles.some((file) => {
+				const normalized = file.replace(/\\/g, "/");
+				return WATCHED_FILES.some((watched) => normalized === watched || normalized.endsWith(`/${watched}`));
+			});
+		}
+	};
+	return connector;
+}
+async function readQueueConfig() {
+	const { config } = await import("@warlock.js/core");
+	return config.get("queue");
+}
+
+//#endregion
+export { QUEUE_CONNECTOR_PRIORITY, queueConnector };
+//# sourceMappingURL=queue-connector.mjs.map

package/esm/queue-connector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-connector.mjs","names":[],"sources":["../../../../../../queue/src/queue-connector.ts"],"sourcesContent":["/**\n * The queue's connector for `warlock.config.ts > connectors`.\n *\n * Deliberately a plain object with TYPE-ONLY imports from core: the config\n * file that constructs it must not drag core's runtime graph (or BullMQ) in\n * at config-load time. Core is imported lazily inside `start()`, where the\n * app has already loaded it.\n */\nimport type { Connector, ConnectorLifecyclePhase } from \"@warlock.js/core\";\nimport { log } from \"@warlock.js/logger\";\nimport { resetQueueConfig, setQueueConfig } from \"./config\";\nimport { closeQueue, startWorkers } from \"./queue-manager\";\nimport type { QueueConfig } from \"./types\";\n\n/**\n * Boots after every built-in connector (`ConnectorPriority.AI` is `10`), so\n * the logger is up and anything a job handler needs is already connected;\n * shuts down before them for the same reason.\n */\nexport const QUEUE_CONNECTOR_PRIORITY = 11;\n\nconst WATCHED_FILES = [\"src/config/queue.ts\"];\n\nexport type QueueConnectorOptions = {\n  /**\n   * Supply the configuration directly instead of reading the `queue` config\n   * key (`src/config/queue.ts`).\n   */\n  config?: QueueConfig;\n};\n\n/**\n * Construct the queue connector.\n *\n * Runs in the `late` lifecycle phase — after app code is imported — so every\n * `defineJob` in the app has registered before workers start. At start it\n * reads the `queue` config and starts in-process workers unless\n * `workers.enabled` is `false`; at shutdown it closes workers (waiting for\n * active jobs, bounded by `workers.shutdownTimeout`) and then the queues.\n *\n * @example\n * // warlock.config.ts\n * import { queueConnector } from \"@warlock.js/queue\";\n *\n * export default defineConfig({ connectors: [queueConnector()] });\n */\nexport function queueConnector(options: QueueConnectorOptions = {}): Connector {\n  let active = false;\n\n  const connector: Connector = {\n    name: \"queue\",\n    priority: QUEUE_CONNECTOR_PRIORITY,\n    // Core's `ConnectorLifecyclePhase.Late`; the value is spelled out so this\n    // module stays free of a runtime import of core.\n    lifecyclePhase: \"late\" as ConnectorLifecyclePhase,\n    isActive: () => active,\n    boot: () => undefined,\n    async start() {\n      const queueConfig = options.config ?? (await readQueueConfig());\n\n      if (!queueConfig) {\n        log.warn(\n          \"queue\",\n          \"configured\",\n          \"queueConnector() is registered but no `queue` config was found (src/config/queue.ts); queue not started\",\n        );\n        return;\n      }\n\n      setQueueConfig(queueConfig);\n      const started = await startWorkers();\n      active = true;\n\n      log.info(\n        \"queue\",\n        \"configured\",\n        started.length > 0\n          ? `Queue workers running for: ${started.join(\", \")}`\n          : \"Queue configured (no in-process workers)\",\n      );\n    },\n    async restart() {\n      await connector.shutdown();\n      await connector.start();\n    },\n    async shutdown() {\n      if (!active) {\n        return;\n      }\n\n      await closeQueue();\n      resetQueueConfig();\n      active = false;\n    },\n    shouldRestart(changedFiles) {\n      return changedFiles.some((file) => {\n        const normalized = file.replace(/\\\\/g, \"/\");\n\n        return WATCHED_FILES.some((watched) => normalized === watched || normalized.endsWith(`/${watched}`));\n      });\n    },\n  };\n\n  return connector;\n}\n\nasync function readQueueConfig(): Promise<QueueConfig | undefined> {\n  const { config } = await import(\"@warlock.js/core\");\n\n  return config.get<QueueConfig | undefined>(\"queue\");\n}\n"],"mappings":";;;;;;;;;;AAmBA,MAAa,2BAA2B;AAExC,MAAM,gBAAgB,CAAC,qBAAqB;;;;;;;;;;;;;;;;AAyB5C,SAAgB,eAAe,UAAiC,CAAC,GAAc;CAC7E,IAAI,SAAS;CAEb,MAAM,YAAuB;EAC3B,MAAM;EACN;EAGA,gBAAgB;EAChB,gBAAgB;EAChB,YAAY;EACZ,MAAM,QAAQ;GACZ,MAAM,cAAc,QAAQ,UAAW,MAAM,gBAAgB;GAE7D,IAAI,CAAC,aAAa;IAChB,IAAI,KACF,SACA,cACA,yGACF;IACA;GACF;GAEA,eAAe,WAAW;GAC1B,MAAM,UAAU,MAAM,aAAa;GACnC,SAAS;GAET,IAAI,KACF,SACA,cACA,QAAQ,SAAS,IACb,8BAA8B,QAAQ,KAAK,IAAI,MAC/C,0CACN;EACF;EACA,MAAM,UAAU;GACd,MAAM,UAAU,SAAS;GACzB,MAAM,UAAU,MAAM;EACxB;EACA,MAAM,WAAW;GACf,IAAI,CAAC,QACH;GAGF,MAAM,WAAW;GACjB,iBAAiB;GACjB,SAAS;EACX;EACA,cAAc,cAAc;GAC1B,OAAO,aAAa,MAAM,SAAS;IACjC,MAAM,aAAa,KAAK,QAAQ,OAAO,GAAG;IAE1C,OAAO,cAAc,MAAM,YAAY,eAAe,WAAW,WAAW,SAAS,IAAI,SAAS,CAAC;GACrG,CAAC;EACH;CACF;CAEA,OAAO;AACT;AAEA,eAAe,kBAAoD;CACjE,MAAM,EAAE,WAAW,MAAM,OAAO;CAEhC,OAAO,OAAO,IAA6B,OAAO;AACpD"}

package/esm/queue-manager.d.mts

@@ -0,0 +1,36 @@
+import { Queue } from "bullmq";
+
+//#region ../queue/src/queue-manager.d.ts
+/**
+ * The BullMQ queue for `name`, created on first use with the configured
+ * connection and prefix.
+ */
+declare function getQueue(name: string): Queue;
+/**
+ * Start one worker per queue that has a registered job, and keep starting
+ * workers for queues whose first job is defined later.
+ *
+ * A no-op returning `[]` when `workers.enabled` is `false`. Calling it again
+ * while workers run starts only the missing ones.
+ *
+ * @returns the queue names that now have a worker in this process.
+ */
+declare function startWorkers(): Promise<string[]>;
+/** The queue names with a running worker in this process. */
+declare function runningWorkers(): string[];
+type CloseQueueOptions = {
+  /**
+   * How long to wait for active jobs before force-closing workers, in
+   * milliseconds. Default: `workers.shutdownTimeout`, else `30000`.
+   */
+  timeout?: number;
+};
+/**
+ * Graceful shutdown: stop workers taking new jobs and wait for active ones
+ * (bounded by `timeout`, then force-close), then close every queue
+ * connection. Safe to call when nothing was started, and more than once.
+ */
+declare function closeQueue(options?: CloseQueueOptions): Promise<void>;
+//#endregion
+export { CloseQueueOptions, closeQueue, getQueue, runningWorkers, startWorkers };
+//# sourceMappingURL=queue-manager.d.mts.map

package/esm/queue-manager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-manager.d.mts","names":[],"sources":["../../../../../../queue/src/queue-manager.ts"],"mappings":";;;;;AAgBA;;iBAAgB,QAAA,CAAS,IAAA,WAAe,KAAK;;AAAA;AA8B7C;;;;AAA6C;AAqB7C;;iBArBsB,YAAA,IAAgB,OAAO;;iBAqB7B,cAAA;AAAA,KA4BJ,iBAAA;EAAiB;;;AAKpB;EAAP,OAAO;AAAA;;;;;;iBAQa,UAAA,CAAW,OAAA,GAAS,iBAAA,GAAyB,OAAO"}