@shivaedev/jobs 0.22.1 → 0.23.1

package/src/server/internal/batchHandler.ts

@@ -1,71 +1,90 @@
 import { Cause, Clock, Effect, Exit } from "effect";
 import type { Job } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
+import { toPgBossError } from "#error.ts";
 import { deadlineOf } from "#internal/deadlineOf.ts";
 import { deferredAttempt } from "#internal/deferral.ts";
+import { failureOutput } from "#internal/failureOutput.ts";
 import { waitForBatchExpiry } from "#internal/waitForBatchExpiry.ts";
 
-function failureOutput(cause: Cause.Cause<unknown>): object {
-	const error = Cause.squash(cause);
-	return typeof error === "object" && error !== null ? error : { message: String(error) };
-}
-
-async function settleAttempt(
+function settleAttempt(
 	complete: NonNullable<PgBossClient["complete"]>,
 	fail: NonNullable<PgBossClient["fail"]>,
 	name: string,
 	job: Job<unknown>,
 	exit: Exit.Exit<unknown, unknown>,
-	afterFailure?: (job: Job<unknown>) => Promise<void>,
 ) {
-	if (Exit.isSuccess(exit)) {
-		if (exit.value !== deferredAttempt) {
-			await complete(name, job);
-		}
-	} else {
-		await fail(name, job, failureOutput(exit.cause));
-		await afterFailure?.(job);
+	if (Exit.isSuccess(exit) && exit.value === deferredAttempt) {
+		return Effect.void;
 	}
+	return Effect.tryPromise({
+		catch: (error) => toPgBossError("settle", error, name),
+		try: () => (Exit.isSuccess(exit) ? complete(name, job) : fail(name, job, failureOutput(exit.cause))),
+	});
+}
+
+export type PgBossRunner = <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
+
+function aborted(signal: AbortSignal) {
+	return Effect.callback<never>((resume) => {
+		function interrupt() {
+			resume(Effect.interrupt);
+		}
+		if (signal.aborted) {
+			interrupt();
+		} else {
+			signal.addEventListener("abort", interrupt, { once: true });
+		}
+		return Effect.sync(() => signal.removeEventListener("abort", interrupt));
+	});
 }
 
 export function batchHandler(
 	client: PgBossClient,
 	name: string,
 	run: (job: Job<unknown>) => Effect.Effect<unknown, unknown>,
-	afterFailure?: (job: Job<unknown>) => Promise<void>,
-	execute: typeof Effect.runPromise = Effect.runPromise,
+	afterFailure: (job: Job<unknown>) => Effect.Effect<void, unknown> = () => Effect.void,
 ) {
 	const complete = client.complete?.bind(client);
 	const fail = client.fail?.bind(client);
 	if (complete === undefined || fail === undefined) {
 		throw new TypeError("This pg-boss client does not support complete and fail");
 	}
-	function waitForExpiry(jobs: readonly Job<unknown>[]) {
-		return execute(waitForBatchExpiry(client, name, jobs).pipe(Effect.tapError(Effect.logError)));
-	}
-
-	return async (jobs: readonly Job<unknown>[]): Promise<void> => {
-		let expired = false;
-		for (const job of jobs) {
-			const deadline = deadlineOf(job);
-			if ((await Effect.runPromise(Clock.currentTimeMillis)) >= deadline) {
-				expired = true;
-				continue;
-			}
-			const exit = await Effect.runPromiseExit(
-				Effect.flatMap(Clock.currentTimeMillis, (now) => {
-					const remaining = deadline - now;
-					return remaining <= 0 ? Effect.interrupt : run(job).pipe(Effect.timeoutOrElse({ duration: remaining, orElse: () => Effect.interrupt }));
-				}),
-				{ signal: job.signal },
-			);
-			if (job.signal.aborted || (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause))) {
-				return waitForExpiry(jobs);
-			}
-			await settleAttempt(complete, fail, name, job, exit, afterFailure);
+	const handle = Effect.fnUntraced(function* (job: Job<unknown>) {
+		if (job.signal.aborted) {
+			return "interrupted";
 		}
-		if (expired) {
-			return waitForExpiry(jobs);
+		const remaining = deadlineOf(job) - (yield* Clock.currentTimeMillis);
+		if (remaining <= 0) {
+			return "expired";
 		}
-	};
+		const exit = yield* run(job).pipe(
+			Effect.timeoutOrElse({ duration: remaining, orElse: () => Effect.interrupt }),
+			Effect.raceFirst(aborted(job.signal)),
+			Effect.exit,
+		);
+		if (job.signal.aborted || (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause))) {
+			return "interrupted";
+		}
+		yield* settleAttempt(complete, fail, name, job, exit);
+		if (Exit.isFailure(exit)) {
+			yield* afterFailure(job);
+		}
+		return "settled";
+	});
+	return (jobs: readonly Job<unknown>[]) =>
+		Effect.gen(function* () {
+			const waitForExpiry = waitForBatchExpiry(client, name, jobs).pipe(Effect.tapError(Effect.logError));
+			let expired = false;
+			for (const job of jobs) {
+				const outcome = yield* handle(job);
+				if (outcome === "interrupted") {
+					return yield* waitForExpiry;
+				}
+				expired ||= outcome === "expired";
+			}
+			if (expired) {
+				yield* waitForExpiry;
+			}
+		});
 }

package/src/server/internal/clientErrors.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { isSensitiveKey, redactText } from "@shivaedev/errors/sensitive.ts";
 import type { PgBossClient } from "#client.ts";
 
 type Listener = (error: Error) => void;
@@ -14,7 +15,7 @@ const observers: WeakMap<WeakKey, unknown> = shared instanceof WeakMap ? shared
 Reflect.set(globalThis, key, observers);
 
 export function logClientError(error: Error): Effect.Effect<void> {
-	const message = { event: "pg_boss_error", message: error.message };
+	const message = { event: "pg_boss_error", message: redactText(error.message, isSensitiveKey) };
 	return Reflect.get(error, "code") === "57P01" ? Effect.logDebug(message) : Effect.logError(message);
 }
 

package/src/server/internal/deferrableAttempt.ts

@@ -2,6 +2,7 @@ import { Clock, DateTime, Effect, Schema } from "effect";
 import type { Job } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
 import { RetryAt } from "#definition.ts";
+import { toPgBossError } from "#error.ts";
 import { deferralObservers, deferredAttempt } from "#internal/deferral.ts";
 import { settleDeferral } from "#internal/settleDeferral.ts";
 
@@ -23,7 +24,10 @@ export function deferrableAttempt<A, E, R>(
 				return Effect.fail(error);
 			}
 			const at = DateTime.formatIso(error.at);
-			return Effect.promise(() => settleDeferral(client, schema, job, at, error.reason, maxDeferrals)).pipe(
+			return Effect.tryPromise({
+				catch: (failure) => toPgBossError("settle", failure, job.name),
+				try: () => settleDeferral(client, schema, job, at, error.reason, maxDeferrals),
+			}).pipe(
 				Effect.flatMap((settled) => {
 					if (settled.claimed && !settled.deferred) {
 						return Effect.fail(error);

package/src/server/internal/ensureQueue.ts

@@ -1,3 +1,4 @@
+import { Effect, Schedule } from "effect";
 import type { Queue } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
 import { PgBossQueueOptionsError } from "#error.ts";
@@ -8,40 +9,37 @@ const CREATE_QUEUE_ATTEMPTS = 6;
 
 // A partitioned queue attaches its table to pg-boss's job table, which can deadlock with job traffic on other queues.
 // PostgreSQL rolls the whole creation back, so trying it again is safe.
-async function createQueue(client: PgBossClient, name: string, options?: Omit<Queue, "name">): Promise<void> {
-	for (let attempt = 1; ; attempt += 1) {
-		try {
-			return await client.createQueue(name, options);
-		} catch (error) {
-			if (attempt === CREATE_QUEUE_ATTEMPTS || !(error instanceof Error) || Reflect.get(error, "code") !== DEADLOCK_DETECTED) {
-				throw error;
-			}
-			await new Promise((resolve) => setTimeout(resolve, 25 * 2 ** (attempt - 1)));
-		}
-	}
+function createQueue(client: PgBossClient, name: string, options?: Omit<Queue, "name">) {
+	return Effect.tryPromise({ catch: (error) => error, try: () => client.createQueue(name, options) }).pipe(
+		Effect.retry({
+			schedule: Schedule.exponential(25).pipe(Schedule.upTo({ times: CREATE_QUEUE_ATTEMPTS - 1 })),
+			while: (error) => error instanceof Error && Reflect.get(error, "code") === DEADLOCK_DETECTED,
+		}),
+	);
 }
 
-export async function ensureQueue(client: PgBossClient, name: string, options: Omit<Queue, "name" | "deadLetter">): Promise<void> {
+export const ensureQueue = Effect.fnUntraced(function* (client: PgBossClient, name: string, options: Omit<Queue, "name" | "deadLetter">) {
 	const deadLetter = deadLetterQueueName(name);
 	const desired = { retryBackoff: true, retryLimit: 3, ...options, deadLetter };
-	await createQueue(client, deadLetter);
-	await createQueue(client, name, desired);
-	const existing = await client.getQueue(name);
+	yield* createQueue(client, deadLetter);
+	yield* createQueue(client, name, desired);
+	const existing = yield* Effect.tryPromise({ catch: (error) => error, try: () => client.getQueue(name) });
 	if (existing === null) {
 		return;
 	}
 	const immutable = (["partition", "policy"] as const).filter((key) => desired[key] !== undefined && desired[key] !== existing[key]);
 	if (immutable.length > 0) {
-		throw new PgBossQueueOptionsError({ options: immutable, queue: name });
+		return yield* new PgBossQueueOptionsError({ options: immutable, queue: name });
 	}
+	const updateQueue = client.updateQueue?.bind(client);
 	const { partition: _partition, policy: _policy, ...mutable } = desired;
 	const changed = Object.entries(mutable).some(([key, value]) => value !== undefined && value !== Reflect.get(existing, key));
 	if (!changed) {
 		return;
 	}
-	if (client.updateQueue === undefined) {
-		throw new TypeError("This pg-boss client does not support updateQueue");
+	if (updateQueue === undefined) {
+		return yield* Effect.fail(new TypeError("This pg-boss client does not support updateQueue"));
 	}
 	// pg-boss validates retryDelayMax against retryBackoff in the same update.
-	await client.updateQueue(name, mutable);
-}
+	yield* Effect.tryPromise({ catch: (error) => error, try: () => updateQueue(name, mutable) });
+});

package/src/server/internal/failureOutput.ts

@@ -0,0 +1,9 @@
+import { Cause, Predicate, Schema } from "effect";
+import { JobFailure } from "#JobFailure.ts";
+
+export function failureOutput(cause: Cause.Cause<unknown>): typeof JobFailure.Encoded {
+	const error = Cause.squash(cause);
+	const tag = Predicate.hasProperty(error, "_tag") && typeof error._tag === "string" ? error._tag : "Error";
+	const message = Predicate.hasProperty(error, "message") && typeof error.message === "string" ? error.message : String(error);
+	return Schema.encodeSync(JobFailure)({ _tag: tag, message });
+}

package/src/server/internal/lifecycle.ts

@@ -4,7 +4,7 @@ import { defaultClientFactory, type PgBossClient, type PgBossClientFactory } fro
 import { PgBossClientOptionsError, type PgBossError, toPgBossError } from "#error.ts";
 import { deferralStorePlan } from "#internal/deferralStorePlan.ts";
 import { acquireCachedClient, releaseCachedClient } from "./clientCache.ts";
-import { logClientError, observeClientErrors } from "./clientErrors.ts";
+import { observeClientErrors } from "./clientErrors.ts";
 
 export interface AcquireClientOptions {
 	readonly clientCacheKey?: string | symbol | undefined;
@@ -37,21 +37,18 @@ async function startClient(options: AcquireClientOptions, report: (error: Error)
 	}
 }
 
-export function acquireClient(options: AcquireClientOptions): Effect.Effect<AcquiredClient, PgBossError | PgBossClientOptionsError> {
-	return Effect.contextWith((context) => {
-		const run = Effect.runForkWith(context);
-		function report(error: Error) {
-			run(logClientError(error));
-		}
-		return Effect.tryPromise({
-			catch: (error) => (error instanceof PgBossClientOptionsError ? error : toPgBossError("start", error)),
-			try: async () => {
-				const cacheKey = options.clientCacheKey;
-				return cacheKey === undefined
-					? { client: await startClient(options, report), reused: false }
-					: { cacheKey, ...(await acquireCachedClient(cacheKey, options.constructor, () => startClient(options, report))) };
-			},
-		});
+export function acquireClient(
+	options: AcquireClientOptions,
+	report: (error: Error) => void,
+): Effect.Effect<AcquiredClient, PgBossError | PgBossClientOptionsError> {
+	return Effect.tryPromise({
+		catch: (error) => (error instanceof PgBossClientOptionsError ? error : toPgBossError("start", error)),
+		try: async () => {
+			const cacheKey = options.clientCacheKey;
+			return cacheKey === undefined
+				? { client: await startClient(options, report), reused: false }
+				: { cacheKey, ...(await acquireCachedClient(cacheKey, options.constructor, () => startClient(options, report))) };
+		},
 	});
 }
 

package/src/server/internal/listJobs.ts

@@ -1,12 +1,26 @@
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Redacted, Schema } from "effect";
 import type { PgBossClient } from "#client.ts";
 import type { JobPayloadSchema } from "#definition.ts";
-import { type PgBossError, type PgBossPayloadError, toPgBossError } from "#error.ts";
+import { type PgBossError, PgBossPayloadError, toPgBossError } from "#error.ts";
 import { type DeadLetteredJob, deadLetterQueueName, type JobPage, type JobPageOptions } from "#health.ts";
 import { decodeStoredData, quotedSchema } from "#internal/storedRows.ts";
+import { JobFailure } from "#JobFailure.ts";
 import type { PgBossService } from "#service.ts";
 
-const Cursor = Schema.StringFromBase64Url.pipe(Schema.decodeTo(Schema.fromJsonString(Schema.Tuple([Schema.String, Schema.String]))));
+const Cursor = Schema.StringFromBase64Url.pipe(
+	Schema.decodeTo(
+		Schema.fromJsonString(
+			Schema.Tuple([
+				Schema.String.check(Schema.makeFilter((value) => Option.isSome(Schema.decodeUnknownOption(Schema.DateTimeUtcFromString)(value)))),
+				Schema.String.check(Schema.isUUID()),
+			]),
+		),
+	),
+);
+const PageOptions = Schema.Struct({
+	cursor: Schema.optionalKey(Schema.UndefinedOr(Cursor)),
+	limit: Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)),
+});
 
 const Row = Schema.Struct({
 	completedOn: Schema.OptionFromNullOr(Schema.DateTimeUtcFromDate),
@@ -14,12 +28,12 @@ const Row = Schema.Struct({
 	cursorAt: Schema.String,
 	data: Schema.Unknown,
 	id: Schema.String,
-	output: Schema.Unknown,
+	output: Schema.NullOr(JobFailure),
 	queue: Schema.String,
 	retryCount: Schema.Number,
 	retryLimit: Schema.Number,
 	sourceId: Schema.OptionFromNullOr(Schema.String),
-	sourceOutput: Schema.Unknown,
+	sourceOutput: Schema.NullOr(JobFailure),
 	startedOn: Schema.OptionFromNullOr(Schema.DateTimeUtcFromDate),
 	state: Schema.Literals(["created", "retry", "active", "completed", "cancelled", "failed"]),
 });
@@ -39,60 +53,56 @@ export function deadLetteredJobsFor(client: PgBossClient, schema: string): PgBos
 	return (queue, options) => listJobs(client, schema, "deadLetteredJobs", queue, options);
 }
 
-function listJobs<const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
+const listJobs = Effect.fnUntraced(function* <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 	client: PgBossClient,
 	schema: string,
 	listing: Listing,
 	queue: { readonly name: TName; readonly schema: TPayload },
 	options: JobPageOptions,
-): Effect.Effect<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]> {
-	return Effect.tryPromise({
+): Effect.fn.Return<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]> {
+	const { cursor: after, limit } = yield* Schema.decodeUnknownEffect(PageOptions)(options);
+	const rows = yield* Effect.tryPromise({
 		catch: (error) => toPgBossError(listing, error, queue.name),
 		try: async () => {
 			if (client.getDb === undefined) {
 				throw new TypeError("This pg-boss client does not support getDb");
 			}
-			if (!Number.isSafeInteger(options.limit) || options.limit < 1) {
-				throw new RangeError("The page limit must be a positive integer");
-			}
-			const after = options.cursor === undefined ? undefined : await Schema.decodeUnknownPromise(Cursor)(options.cursor);
 			const quoted = quotedSchema(schema);
-			const { rows } = await client.getDb().executeSql(
+			const { rows: storedRows } = await client.getDb().executeSql(
 				`SELECT
-						id,
-						name AS queue,
-						state,
-						retry_count AS "retryCount",
-						retry_limit AS "retryLimit",
-						created_on AS "createdOn",
-						started_on AS "startedOn",
-						completed_on AS "completedOn",
-						output,
-						data,
-						source_id AS "sourceId",
-						source_output AS "sourceOutput",
-						to_json(created_on) #>> '{}' AS "cursorAt"
-					FROM ${quoted}.job
-					WHERE name = $1
-						${listing === "failedJobs" ? "AND state = 'failed'" : ""}
-						AND ($2::timestamptz IS NULL OR (created_on, id) < ($2::timestamptz, $3::uuid))
-					ORDER BY created_on DESC, id DESC
-					LIMIT $4`,
-				[listing === "failedJobs" ? queue.name : deadLetterQueueName(queue.name), after?.[0] ?? null, after?.[1] ?? null, options.limit + 1],
+					id,
+					name AS queue,
+					state,
+					retry_count AS "retryCount",
+					retry_limit AS "retryLimit",
+					created_on AS "createdOn",
+					started_on AS "startedOn",
+					completed_on AS "completedOn",
+					output,
+					data,
+					source_id AS "sourceId",
+					source_output AS "sourceOutput",
+					to_json(created_on) #>> '{}' AS "cursorAt"
+				FROM ${quoted}.job
+				WHERE name = $1
+					${listing === "failedJobs" ? "AND state = 'failed'" : ""}
+					AND ($2::timestamptz IS NULL OR (created_on, id) < ($2::timestamptz, $3::uuid))
+				ORDER BY created_on DESC, id DESC
+				LIMIT $4`,
+				[listing === "failedJobs" ? queue.name : deadLetterQueueName(queue.name), after?.[0] ?? null, after?.[1] ?? null, limit + 1],
 			);
-			return Schema.decodeUnknownPromise(Rows)(rows);
+			return storedRows;
 		},
-	}).pipe(
-		Effect.flatMap((rows) => {
-			const page = rows.slice(0, options.limit);
-			const last = page.at(-1);
-			const next =
-				rows.length > options.limit && last !== undefined ? Option.some(Schema.encodeSync(Cursor)([last.cursorAt, last.id])) : Option.none();
-			return Effect.forEach(page, ({ cursorAt: _, data, ...row }) =>
-				decodeStoredData(queue, data).pipe(
-					Effect.map((decoded) => ({ ...row, attempt: Option.isSome(row.startedOn) ? row.retryCount + 1 : 0, data: decoded })),
-				),
-			).pipe(Effect.map((jobs) => ({ jobs, next })));
-		}),
+	});
+	const decodedRows = yield* Schema.decodeUnknownEffect(Rows)(rows).pipe(
+		Effect.mapError((error) => new PgBossPayloadError({ direction: "decode", original: Redacted.make(error), queue: queue.name })),
 	);
-}
+	const page = decodedRows.slice(0, limit);
+	const last = page.at(-1);
+	const next = decodedRows.length > limit && last !== undefined ? Option.some(Schema.encodeSync(Cursor)([last.cursorAt, last.id])) : Option.none();
+	return yield* Effect.forEach(page, ({ cursorAt: _, data, ...row }) =>
+		decodeStoredData(queue, data).pipe(
+			Effect.map((decoded) => ({ ...row, attempt: Option.isSome(row.startedOn) ? row.retryCount + 1 : 0, data: decoded })),
+		),
+	).pipe(Effect.map((jobs) => ({ jobs, next })));
+});

package/src/server/internal/makeService.ts

@@ -13,7 +13,7 @@ export function makeService(client: PgBossClient, names: readonly string[], sche
 		enqueue: enqueueFor(client),
 		failedJobs: failedJobsFor(client, schema),
 		getJob: getJobFor(client),
-		health: healthFor(client, names),
+		health: () => healthFor(client, names),
 		retry: retryFor(client),
 	};
 }

package/src/server/internal/register.ts

@@ -1,18 +1,11 @@
-import { type Context, Effect, Redacted, Schema, type Scope } from "effect";
-import type { Job } from "pg-boss";
+import { type Context, Effect, type Scope } from "effect";
 import type { PgBossClient } from "#client.ts";
-import {
-	type JobRegistration,
-	jobContext,
-	type QueueDefinition,
-	type QueueWorker,
-	type ScheduleDefinition,
-	type ScheduledWorker,
-} from "#definition.ts";
-import { PgBossError, PgBossPayloadError, PgBossQueueOptionsError, toPgBossError } from "#error.ts";
+import type { JobRegistration, QueueDefinition, QueueWorker, ScheduleDefinition, ScheduledWorker } from "#definition.ts";
+import { PgBossQueueOptionsError, toPgBossError } from "#error.ts";
+import type { PgBossRunner } from "#internal/batchHandler.ts";
 import { ensureQueue } from "#internal/ensureQueue.ts";
 import { registerWorker } from "#internal/registerWorker.ts";
-import { payloadOf } from "#internal/tracing.ts";
+import { runQueueWorker } from "#internal/runQueueWorker.ts";
 
 function isQueueWorker(registration: JobRegistration): registration is QueueWorker {
 	return registration._tag === "QueueWorker";
@@ -43,21 +36,19 @@ export function registrationName(registration: JobRegistration): string {
 	return registrationDefinition(registration).name;
 }
 
-async function prepareQueues(client: PgBossClient, registrations: readonly JobRegistration[], replaceWorkers: boolean): Promise<void> {
+const prepareQueues = Effect.fnUntraced(function* (client: PgBossClient, registrations: readonly JobRegistration[], replaceWorkers: boolean) {
 	for (const registration of registrations) {
 		if (replaceWorkers && !isQueueDefinition(registration)) {
-			await client.offWork(registrationName(registration));
+			yield* Effect.tryPromise({ catch: (error) => toPgBossError("register", error), try: () => client.offWork(registrationName(registration)) });
 		}
 	}
 	for (const registration of registrations) {
 		const definition = registrationDefinition(registration);
-		try {
-			await ensureQueue(client, definition.name, definition.queueOptions);
-		} catch (error) {
-			throw error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error, definition.name);
-		}
+		yield* ensureQueue(client, definition.name, definition.queueOptions).pipe(
+			Effect.mapError((error) => (error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error, definition.name))),
+		);
 	}
-}
+});
 
 // The layer requires RegistrationRequirements of its jobs, so its context provides every registered worker.
 function workerContext<R>(context: Context.Context<R>): Context.Context<unknown>;
@@ -65,46 +56,61 @@ function workerContext(context: unknown): unknown {
 	return context;
 }
 
-function runQueueWorker(worker: QueueWorker, job: Job<unknown>) {
-	return Schema.decodeUnknownEffect(worker.queue.schema)(payloadOf(job.data)).pipe(
-		Effect.mapError(
-			(error) =>
-				new PgBossPayloadError({
-					direction: "decode",
-					original: Redacted.make(error),
-					queue: worker.queue.name,
-				}),
-		),
-		Effect.flatMap((payload) => worker.handler(payload, jobContext(job))),
-	);
-}
-
-async function registerQueue(
+const registerQueue = Effect.fnUntraced(function* (
 	client: PgBossClient,
 	registration: QueueWorker | QueueDefinition,
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-): Promise<void> {
+	execute: PgBossRunner,
+	graceful: boolean,
+) {
 	const queue = registration._tag === "QueueWorker" ? registration.queue : registration;
 	const name = queue.name;
 	if (registration._tag === "QueueDefinition") {
 		return;
 	}
-	await registerWorker(client, name, queue.workerOptions, (job) => runQueueWorker(registration, job), scope, schema, queue.maxDeferrals, context);
-}
+	yield* registerWorker(
+		client,
+		name,
+		queue.workerOptions,
+		(job) => runQueueWorker(registration, job),
+		scope,
+		schema,
+		queue.maxDeferrals,
+		context,
+		execute,
+		graceful,
+	);
+});
 
-async function registerSchedule(
+const registerSchedule = Effect.fnUntraced(function* (
 	client: PgBossClient,
 	worker: ScheduledWorker,
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-): Promise<void> {
+	execute: PgBossRunner,
+	graceful: boolean,
+) {
 	const { schedule } = worker;
-	await registerWorker(client, schedule.name, schedule.workerOptions, () => worker.effect, scope, schema, schedule.maxDeferrals, context);
-	await client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions);
-}
+	yield* registerWorker(
+		client,
+		schedule.name,
+		schedule.workerOptions,
+		() => worker.effect,
+		scope,
+		schema,
+		schedule.maxDeferrals,
+		context,
+		execute,
+		graceful,
+	);
+	yield* Effect.tryPromise({
+		catch: (error) => toPgBossError("register", error, schedule.name),
+		try: () => client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions),
+	});
+});
 
 export function registrationNames(registrations: readonly JobRegistration[]): readonly string[] {
 	const names = registrations.map(registrationName);
@@ -114,32 +120,28 @@ export function registrationNames(registrations: readonly JobRegistration[]): re
 	return names;
 }
 
-export function registerJobs<R>(
+export const registerJobs = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	registrations: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
+	execute: PgBossRunner,
 	schema = "pgboss",
 	startWorkers = true,
-): Effect.Effect<void, PgBossError | PgBossQueueOptionsError, Scope.Scope> {
-	return Effect.flatMap(Effect.scope, (scope) =>
-		Effect.tryPromise({
-			catch: (error) => (error instanceof PgBossQueueOptionsError || error instanceof PgBossError ? error : toPgBossError("register", error)),
-			try: async () => {
-				registrationNames(registrations);
-				await prepareQueues(client, registrations, replaceWorkers);
-				if (!startWorkers) {
-					return;
-				}
-				const provided = workerContext(context);
-				for (const registration of registrations) {
-					if (isQueueWorker(registration) || isQueueDefinition(registration)) {
-						await registerQueue(client, registration, provided, scope, schema);
-					} else if (isScheduledWorker(registration)) {
-						await registerSchedule(client, registration, provided, scope, schema);
-					}
-				}
-			},
-		}),
-	);
-}
+	graceful = true,
+) {
+	const scope = yield* Effect.scope;
+	yield* Effect.try({ catch: (error) => toPgBossError("register", error), try: () => registrationNames(registrations) });
+	yield* prepareQueues(client, registrations, replaceWorkers);
+	if (!startWorkers) {
+		return;
+	}
+	const provided = workerContext(context);
+	for (const registration of registrations) {
+		if (isQueueWorker(registration) || isQueueDefinition(registration)) {
+			yield* registerQueue(client, registration, provided, scope, schema, execute, graceful);
+		} else if (isScheduledWorker(registration)) {
+			yield* registerSchedule(client, registration, provided, scope, schema, execute, graceful);
+		}
+	}
+});