@monque/core 1.3.0 → 1.4.0

package/dist/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @monque/core
 
+## 1.4.0
+
+### Minor Changes
+
+- [#188](https://github.com/ueberBrot/monque/pull/188) [`9ce0ade`](https://github.com/ueberBrot/monque/commit/9ce0adebda2d47841a4420e94a440b62d10396a0) Thanks [@ueberBrot](https://github.com/ueberBrot)! - Optimize MongoDB index creation by batching 7 sequential `createIndex()` calls into a single `createIndexes()` call. This reduces index creation from 7 round-trips to 1, significantly speeding up `initialize()` on first run.
+
+  Also adds `skipIndexCreation` option to `MonqueOptions` for production deployments where indexes are managed externally (e.g., via migrations or DBA tooling).
+
+### Patch Changes
+
+- [#187](https://github.com/ueberBrot/monque/pull/187) [`67c9d9a`](https://github.com/ueberBrot/monque/commit/67c9d9a2a5df6c493d5f51c15a33cd38db49cbe0) Thanks [@ueberBrot](https://github.com/ueberBrot)! - Use atomic `findOneAndUpdate` with status preconditions in `completeJob` and `failJob` to prevent phantom events when the DB write is a no-op. Events are now only emitted when the transition actually occurred, and `willRetry` is derived from the actual DB document state.
+
+- [#173](https://github.com/ueberBrot/monque/pull/173) [`df0630a`](https://github.com/ueberBrot/monque/commit/df0630a5e5c84e3216f5b65a999ce618502f89ab) Thanks [@ueberBrot](https://github.com/ueberBrot)! - Replace unsafe `as unknown as WithId<Job>` type casts in `job-manager` with bracket notation, consistent with the existing pattern in `retryJob`.
+
+- [#186](https://github.com/ueberBrot/monque/pull/186) [`5697370`](https://github.com/ueberBrot/monque/commit/5697370cf278302ffa6dcaaf0a4fb34ed9c3bc00) Thanks [@ueberBrot](https://github.com/ueberBrot)! - Replace 7 unsafe `error as Error` casts with a new `toError()` utility that safely normalizes unknown caught values into proper `Error` instances, preventing silent type lies when non-Error values are thrown.
+
+- [#189](https://github.com/ueberBrot/monque/pull/189) [`1e32439`](https://github.com/ueberBrot/monque/commit/1e324395caf25309dfb7c40bc35edac60b8d80ad) Thanks [@ueberBrot](https://github.com/ueberBrot)! - Extract `documentToPersistedJob` mapper into a standalone function for testability and add round-trip unit tests to guard against silent field-dropping when new Job fields are added.
+
 ## 1.3.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -4,6 +4,40 @@ let cron_parser = require("cron-parser");
 let node_crypto = require("node:crypto");
 let node_events = require("node:events");
 
+//#region src/jobs/document-to-persisted-job.ts
+/**
+* Convert a raw MongoDB document to a strongly-typed {@link PersistedJob}.
+*
+* Maps required fields directly and conditionally includes optional fields
+* only when they are present in the document (`!== undefined`).
+*
+* @internal Not part of the public API.
+* @template T - The job data payload type
+* @param doc - The raw MongoDB document with `_id`
+* @returns A strongly-typed PersistedJob object with guaranteed `_id`
+*/
+function documentToPersistedJob(doc) {
+	const job = {
+		_id: doc._id,
+		name: doc["name"],
+		data: doc["data"],
+		status: doc["status"],
+		nextRunAt: doc["nextRunAt"],
+		failCount: doc["failCount"],
+		createdAt: doc["createdAt"],
+		updatedAt: doc["updatedAt"]
+	};
+	if (doc["lockedAt"] !== void 0) job.lockedAt = doc["lockedAt"];
+	if (doc["claimedBy"] !== void 0) job.claimedBy = doc["claimedBy"];
+	if (doc["lastHeartbeat"] !== void 0) job.lastHeartbeat = doc["lastHeartbeat"];
+	if (doc["heartbeatInterval"] !== void 0) job.heartbeatInterval = doc["heartbeatInterval"];
+	if (doc["failReason"] !== void 0) job.failReason = doc["failReason"];
+	if (doc["repeatInterval"] !== void 0) job.repeatInterval = doc["repeatInterval"];
+	if (doc["uniqueKey"] !== void 0) job.uniqueKey = doc["uniqueKey"];
+	return job;
+}
+
+//#endregion
 //#region src/jobs/types.ts
 /**
 * Represents the lifecycle states of a job in the queue.
@@ -562,6 +596,39 @@ function handleCronParseError(expression, error) {
 	throw new InvalidCronError(expression, `Invalid cron expression "${expression}": ${error instanceof Error ? error.message : "Unknown parsing error"}. Expected 5-field format: "minute hour day-of-month month day-of-week" or predefined expression (e.g. @daily). Example: "0 9 * * 1" (every Monday at 9am)`);
 }
 
+//#endregion
+//#region src/shared/utils/error.ts
+/**
+* Normalize an unknown caught value into a proper `Error` instance.
+*
+* In JavaScript, any value can be thrown — strings, numbers, objects, `undefined`, etc.
+* This function ensures we always have a real `Error` with a proper stack trace and message.
+*
+* @param value - The caught value (typically from a `catch` block typed as `unknown`).
+* @returns The original value if already an `Error`, otherwise a new `Error` wrapping `String(value)`.
+*
+* @example
+* ```ts
+* try {
+*   riskyOperation();
+* } catch (error: unknown) {
+*   const normalized = toError(error);
+*   console.error(normalized.message);
+* }
+* ```
+*
+* @internal
+*/
+function toError(value) {
+	if (value instanceof Error) return value;
+	try {
+		return new Error(String(value));
+	} catch (conversionError) {
+		const detail = conversionError instanceof Error ? conversionError.message : "unknown conversion failure";
+		return /* @__PURE__ */ new Error(`Unserializable value (${detail})`);
+	}
+}
+
 //#endregion
 //#region src/scheduler/helpers.ts
 /**
@@ -711,7 +778,7 @@ var ChangeStreamHandler = class {
 			this.debounceTimer = setTimeout(() => {
 				this.debounceTimer = null;
 				this.onPoll().catch((error) => {
-					this.ctx.emit("job:error", { error });
+					this.ctx.emit("job:error", { error: toError(error) });
 				});
 			}, 100);
 		}
@@ -820,9 +887,8 @@ var JobManager = class {
 		const _id = new mongodb.ObjectId(jobId);
 		const jobDoc = await this.ctx.collection.findOne({ _id });
 		if (!jobDoc) return null;
-		const currentJob = jobDoc;
-		if (currentJob.status === JobStatus.CANCELLED) return this.ctx.documentToPersistedJob(currentJob);
-		if (currentJob.status !== JobStatus.PENDING) throw new JobStateError(`Cannot cancel job in status '${currentJob.status}'`, jobId, currentJob.status, "cancel");
+		if (jobDoc["status"] === JobStatus.CANCELLED) return this.ctx.documentToPersistedJob(jobDoc);
+		if (jobDoc["status"] !== JobStatus.PENDING) throw new JobStateError(`Cannot cancel job in status '${jobDoc["status"]}'`, jobId, jobDoc["status"], "cancel");
 		const result = await this.ctx.collection.findOneAndUpdate({
 			_id,
 			status: JobStatus.PENDING
@@ -907,8 +973,7 @@ var JobManager = class {
 		const _id = new mongodb.ObjectId(jobId);
 		const currentJobDoc = await this.ctx.collection.findOne({ _id });
 		if (!currentJobDoc) return null;
-		const currentJob = currentJobDoc;
-		if (currentJob.status !== JobStatus.PENDING) throw new JobStateError(`Cannot reschedule job in status '${currentJob.status}'`, jobId, currentJob.status, "reschedule");
+		if (currentJobDoc["status"] !== JobStatus.PENDING) throw new JobStateError(`Cannot reschedule job in status '${currentJobDoc["status"]}'`, jobId, currentJobDoc["status"], "reschedule");
 		const result = await this.ctx.collection.findOneAndUpdate({
 			_id,
 			status: JobStatus.PENDING
@@ -970,21 +1035,20 @@ var JobManager = class {
 		const cancelledIds = [];
 		const cursor = this.ctx.collection.find(baseQuery);
 		for await (const doc of cursor) {
-			const job = doc;
-			const jobId = job._id.toString();
-			if (job.status !== JobStatus.PENDING && job.status !== JobStatus.CANCELLED) {
+			const jobId = doc._id.toString();
+			if (doc["status"] !== JobStatus.PENDING && doc["status"] !== JobStatus.CANCELLED) {
 				errors.push({
 					jobId,
-					error: `Cannot cancel job in status '${job.status}'`
+					error: `Cannot cancel job in status '${doc["status"]}'`
 				});
 				continue;
 			}
-			if (job.status === JobStatus.CANCELLED) {
+			if (doc["status"] === JobStatus.CANCELLED) {
 				cancelledIds.push(jobId);
 				continue;
 			}
 			if (await this.ctx.collection.findOneAndUpdate({
-				_id: job._id,
+				_id: doc._id,
 				status: JobStatus.PENDING
 			}, { $set: {
 				status: JobStatus.CANCELLED,
@@ -1028,17 +1092,16 @@ var JobManager = class {
 		const retriedIds = [];
 		const cursor = this.ctx.collection.find(baseQuery);
 		for await (const doc of cursor) {
-			const job = doc;
-			const jobId = job._id.toString();
-			if (job.status !== JobStatus.FAILED && job.status !== JobStatus.CANCELLED) {
+			const jobId = doc._id.toString();
+			if (doc["status"] !== JobStatus.FAILED && doc["status"] !== JobStatus.CANCELLED) {
 				errors.push({
 					jobId,
-					error: `Cannot retry job in status '${job.status}'`
+					error: `Cannot retry job in status '${doc["status"]}'`
 				});
 				continue;
 			}
 			if (await this.ctx.collection.findOneAndUpdate({
-				_id: job._id,
+				_id: doc._id,
 				status: { $in: [JobStatus.FAILED, JobStatus.CANCELLED] }
 			}, {
 				$set: {
@@ -1174,7 +1237,7 @@ var JobProcessor = class {
 					worker.activeJobs.set(job._id.toString(), job);
 					this.processJob(job, worker).catch((error) => {
 						this.ctx.emit("job:error", {
-							error,
+							error: toError(error),
 							job
 						});
 					});
@@ -1226,6 +1289,10 @@ var JobProcessor = class {
 	* both success and failure cases. On success, calls `completeJob()`. On failure,
 	* calls `failJob()` which implements exponential backoff retry logic.
 	*
+	* Events are only emitted when the underlying atomic status transition succeeds,
+	* ensuring event consumers receive reliable, consistent data backed by the actual
+	* database state.
+	*
 	* @param job - The job to process
 	* @param worker - The worker registration containing the handler and active job tracking
 	*/
@@ -1236,38 +1303,50 @@ var JobProcessor = class {
 		try {
 			await worker.handler(job);
 			const duration = Date.now() - startTime;
-			await this.completeJob(job);
-			this.ctx.emit("job:complete", {
-				job,
+			const updatedJob = await this.completeJob(job);
+			if (updatedJob) this.ctx.emit("job:complete", {
+				job: updatedJob,
 				duration
 			});
 		} catch (error) {
 			const err = error instanceof Error ? error : new Error(String(error));
-			await this.failJob(job, err);
-			const willRetry = job.failCount + 1 < this.ctx.options.maxRetries;
-			this.ctx.emit("job:fail", {
-				job,
-				error: err,
-				willRetry
-			});
+			const updatedJob = await this.failJob(job, err);
+			if (updatedJob) {
+				const willRetry = updatedJob.status === JobStatus.PENDING;
+				this.ctx.emit("job:fail", {
+					job: updatedJob,
+					error: err,
+					willRetry
+				});
+			}
 		} finally {
 			worker.activeJobs.delete(jobId);
 		}
 	}
 	/**
-	* Mark a job as completed successfully.
+	* Mark a job as completed successfully using an atomic status transition.
+	*
+	* Uses `findOneAndUpdate` with `status: processing` and `claimedBy: instanceId`
+	* preconditions to ensure the transition only occurs if the job is still owned by this
+	* scheduler instance. Returns `null` if the job was concurrently modified (e.g., reclaimed
+	* by another instance after stale recovery).
 	*
 	* For recurring jobs (with `repeatInterval`), schedules the next run based on the cron
 	* expression and resets `failCount` to 0. For one-time jobs, sets status to `completed`.
 	* Clears `lockedAt` and `failReason` fields in both cases.
 	*
 	* @param job - The job that completed successfully
+	* @returns The updated job document, or `null` if the transition could not be applied
 	*/
 	async completeJob(job) {
-		if (!isPersistedJob(job)) return;
+		if (!isPersistedJob(job)) return null;
 		if (job.repeatInterval) {
 			const nextRunAt = getNextCronDate(job.repeatInterval);
-			await this.ctx.collection.updateOne({ _id: job._id }, {
+			const result = await this.ctx.collection.findOneAndUpdate({
+				_id: job._id,
+				status: JobStatus.PROCESSING,
+				claimedBy: this.ctx.instanceId
+			}, {
 				$set: {
 					status: JobStatus.PENDING,
 					nextRunAt,
@@ -1281,61 +1360,59 @@ var JobProcessor = class {
 					heartbeatInterval: "",
 					failReason: ""
 				}
-			});
-		} else {
-			await this.ctx.collection.updateOne({ _id: job._id }, {
-				$set: {
-					status: JobStatus.COMPLETED,
-					updatedAt: /* @__PURE__ */ new Date()
-				},
-				$unset: {
-					lockedAt: "",
-					claimedBy: "",
-					lastHeartbeat: "",
-					heartbeatInterval: "",
-					failReason: ""
-				}
-			});
-			job.status = JobStatus.COMPLETED;
+			}, { returnDocument: "after" });
+			return result ? this.ctx.documentToPersistedJob(result) : null;
 		}
+		const result = await this.ctx.collection.findOneAndUpdate({
+			_id: job._id,
+			status: JobStatus.PROCESSING,
+			claimedBy: this.ctx.instanceId
+		}, {
+			$set: {
+				status: JobStatus.COMPLETED,
+				updatedAt: /* @__PURE__ */ new Date()
+			},
+			$unset: {
+				lockedAt: "",
+				claimedBy: "",
+				lastHeartbeat: "",
+				heartbeatInterval: "",
+				failReason: ""
+			}
+		}, { returnDocument: "after" });
+		return result ? this.ctx.documentToPersistedJob(result) : null;
 	}
 	/**
-	* Handle job failure with exponential backoff retry logic.
+	* Handle job failure with exponential backoff retry logic using an atomic status transition.
+	*
+	* Uses `findOneAndUpdate` with `status: processing` and `claimedBy: instanceId`
+	* preconditions to ensure the transition only occurs if the job is still owned by this
+	* scheduler instance. Returns `null` if the job was concurrently modified (e.g., reclaimed
+	* by another instance after stale recovery).
 	*
 	* Increments `failCount` and calculates next retry time using exponential backoff:
-	* `nextRunAt = 2^failCount × baseRetryInterval` (capped by optional `maxBackoffDelay`).
+	* `nextRunAt = 2^failCount * baseRetryInterval` (capped by optional `maxBackoffDelay`).
 	*
 	* If `failCount >= maxRetries`, marks job as permanently `failed`. Otherwise, resets
 	* to `pending` status for retry. Stores error message in `failReason` field.
 	*
 	* @param job - The job that failed
 	* @param error - The error that caused the failure
+	* @returns The updated job document, or `null` if the transition could not be applied
 	*/
 	async failJob(job, error) {
-		if (!isPersistedJob(job)) return;
+		if (!isPersistedJob(job)) return null;
 		const newFailCount = job.failCount + 1;
-		if (newFailCount >= this.ctx.options.maxRetries) await this.ctx.collection.updateOne({ _id: job._id }, {
-			$set: {
-				status: JobStatus.FAILED,
-				failCount: newFailCount,
-				failReason: error.message,
-				updatedAt: /* @__PURE__ */ new Date()
-			},
-			$unset: {
-				lockedAt: "",
-				claimedBy: "",
-				lastHeartbeat: "",
-				heartbeatInterval: ""
-			}
-		});
-		else {
-			const nextRunAt = calculateBackoff(newFailCount, this.ctx.options.baseRetryInterval, this.ctx.options.maxBackoffDelay);
-			await this.ctx.collection.updateOne({ _id: job._id }, {
+		if (newFailCount >= this.ctx.options.maxRetries) {
+			const result = await this.ctx.collection.findOneAndUpdate({
+				_id: job._id,
+				status: JobStatus.PROCESSING,
+				claimedBy: this.ctx.instanceId
+			}, {
 				$set: {
-					status: JobStatus.PENDING,
+					status: JobStatus.FAILED,
 					failCount: newFailCount,
 					failReason: error.message,
-					nextRunAt,
 					updatedAt: /* @__PURE__ */ new Date()
 				},
 				$unset: {
@@ -1344,8 +1421,30 @@ var JobProcessor = class {
 					lastHeartbeat: "",
 					heartbeatInterval: ""
 				}
-			});
+			}, { returnDocument: "after" });
+			return result ? this.ctx.documentToPersistedJob(result) : null;
 		}
+		const nextRunAt = calculateBackoff(newFailCount, this.ctx.options.baseRetryInterval, this.ctx.options.maxBackoffDelay);
+		const result = await this.ctx.collection.findOneAndUpdate({
+			_id: job._id,
+			status: JobStatus.PROCESSING,
+			claimedBy: this.ctx.instanceId
+		}, {
+			$set: {
+				status: JobStatus.PENDING,
+				failCount: newFailCount,
+				failReason: error.message,
+				nextRunAt,
+				updatedAt: /* @__PURE__ */ new Date()
+			},
+			$unset: {
+				lockedAt: "",
+				claimedBy: "",
+				lastHeartbeat: "",
+				heartbeatInterval: ""
+			}
+		}, { returnDocument: "after" });
+		return result ? this.ctx.documentToPersistedJob(result) : null;
 	}
 	/**
 	* Update heartbeats for all jobs claimed by this scheduler instance.
@@ -1961,7 +2060,8 @@ var Monque = class extends node_events.EventEmitter {
 			instanceConcurrency: options.instanceConcurrency ?? options.maxConcurrency,
 			schedulerInstanceId: options.schedulerInstanceId ?? (0, node_crypto.randomUUID)(),
 			heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-			jobRetention: options.jobRetention
+			jobRetention: options.jobRetention,
+			skipIndexCreation: options.skipIndexCreation ?? false
 		};
 	}
 	/**
@@ -1974,7 +2074,7 @@ var Monque = class extends node_events.EventEmitter {
 		if (this.isInitialized) return;
 		try {
 			this.collection = this.db.collection(this.options.collectionName);
-			await this.createIndexes();
+			if (!this.options.skipIndexCreation) await this.createIndexes();
 			if (this.options.recoverStaleJobs) await this.recoverStaleJobs();
 			const ctx = this.buildContext();
 			this._scheduler = new JobScheduler(ctx);
@@ -2024,7 +2124,7 @@ var Monque = class extends node_events.EventEmitter {
 			workers: this.workers,
 			isRunning: () => this.isRunning,
 			emit: (event, payload) => this.emit(event, payload),
-			documentToPersistedJob: (doc) => this.documentToPersistedJob(doc)
+			documentToPersistedJob: (doc) => documentToPersistedJob(doc)
 		};
 	}
 	/**
@@ -2041,43 +2141,64 @@ var Monque = class extends node_events.EventEmitter {
 	*/
 	async createIndexes() {
 		if (!this.collection) throw new ConnectionError("Collection not initialized");
-		await this.collection.createIndex({
-			status: 1,
-			nextRunAt: 1
-		}, { background: true });
-		await this.collection.createIndex({
-			name: 1,
-			uniqueKey: 1
-		}, {
-			unique: true,
-			partialFilterExpression: {
-				uniqueKey: { $exists: true },
-				status: { $in: [JobStatus.PENDING, JobStatus.PROCESSING] }
+		await this.collection.createIndexes([
+			{
+				key: {
+					status: 1,
+					nextRunAt: 1
+				},
+				background: true
 			},
-			background: true
-		});
-		await this.collection.createIndex({
-			name: 1,
-			status: 1
-		}, { background: true });
-		await this.collection.createIndex({
-			claimedBy: 1,
-			status: 1
-		}, { background: true });
-		await this.collection.createIndex({
-			lastHeartbeat: 1,
-			status: 1
-		}, { background: true });
-		await this.collection.createIndex({
-			status: 1,
-			nextRunAt: 1,
-			claimedBy: 1
-		}, { background: true });
-		await this.collection.createIndex({
-			status: 1,
-			lockedAt: 1,
-			lastHeartbeat: 1
-		}, { background: true });
+			{
+				key: {
+					name: 1,
+					uniqueKey: 1
+				},
+				unique: true,
+				partialFilterExpression: {
+					uniqueKey: { $exists: true },
+					status: { $in: [JobStatus.PENDING, JobStatus.PROCESSING] }
+				},
+				background: true
+			},
+			{
+				key: {
+					name: 1,
+					status: 1
+				},
+				background: true
+			},
+			{
+				key: {
+					claimedBy: 1,
+					status: 1
+				},
+				background: true
+			},
+			{
+				key: {
+					lastHeartbeat: 1,
+					status: 1
+				},
+				background: true
+			},
+			{
+				key: {
+					status: 1,
+					nextRunAt: 1,
+					claimedBy: 1
+				},
+				background: true
+			},
+			{
+				key: {
+					status: 1,
+					lockedAt: 1,
+					lastHeartbeat: 1
+				},
+				background: true
+			}
+		]);
 	}
 	/**
 	* Recover stale jobs that were left in 'processing' status.
@@ -2679,27 +2800,27 @@ var Monque = class extends node_events.EventEmitter {
 		this.changeStreamHandler.setup();
 		this.pollIntervalId = setInterval(() => {
 			this.processor.poll().catch((error) => {
-				this.emit("job:error", { error });
+				this.emit("job:error", { error: toError(error) });
 			});
 		}, this.options.pollInterval);
 		this.heartbeatIntervalId = setInterval(() => {
 			this.processor.updateHeartbeats().catch((error) => {
-				this.emit("job:error", { error });
+				this.emit("job:error", { error: toError(error) });
 			});
 		}, this.options.heartbeatInterval);
 		if (this.options.jobRetention) {
 			const interval = this.options.jobRetention.interval ?? DEFAULTS.retentionInterval;
 			this.cleanupJobs().catch((error) => {
-				this.emit("job:error", { error });
+				this.emit("job:error", { error: toError(error) });
 			});
 			this.cleanupIntervalId = setInterval(() => {
 				this.cleanupJobs().catch((error) => {
-					this.emit("job:error", { error });
+					this.emit("job:error", { error: toError(error) });
 				});
 			}, interval);
 		}
 		this.processor.poll().catch((error) => {
-			this.emit("job:error", { error });
+			this.emit("job:error", { error: toError(error) });
 		});
 	}
 	/**
@@ -2857,37 +2978,6 @@ var Monque = class extends node_events.EventEmitter {
 		return activeJobs;
 	}
 	/**
-	* Convert a MongoDB document to a typed PersistedJob object.
-	*
-	* Maps raw MongoDB document fields to the strongly-typed `PersistedJob<T>` interface,
-	* ensuring type safety and handling optional fields (`lockedAt`, `failReason`, etc.).
-	*
-	* @private
-	* @template T - The job data payload type
-	* @param doc - The raw MongoDB document with `_id`
-	* @returns A strongly-typed PersistedJob object with guaranteed `_id`
-	*/
-	documentToPersistedJob(doc) {
-		const job = {
-			_id: doc._id,
-			name: doc["name"],
-			data: doc["data"],
-			status: doc["status"],
-			nextRunAt: doc["nextRunAt"],
-			failCount: doc["failCount"],
-			createdAt: doc["createdAt"],
-			updatedAt: doc["updatedAt"]
-		};
-		if (doc["lockedAt"] !== void 0) job.lockedAt = doc["lockedAt"];
-		if (doc["claimedBy"] !== void 0) job.claimedBy = doc["claimedBy"];
-		if (doc["lastHeartbeat"] !== void 0) job.lastHeartbeat = doc["lastHeartbeat"];
-		if (doc["heartbeatInterval"] !== void 0) job.heartbeatInterval = doc["heartbeatInterval"];
-		if (doc["failReason"] !== void 0) job.failReason = doc["failReason"];
-		if (doc["repeatInterval"] !== void 0) job.repeatInterval = doc["repeatInterval"];
-		if (doc["uniqueKey"] !== void 0) job.uniqueKey = doc["uniqueKey"];
-		return job;
-	}
-	/**
 	* Type-safe event emitter methods
 	*/
 	emit(event, payload) {