@shivaedev/jobs 0.35.1 → 0.37.0

package/dist/server/testing.js

@@ -1,12 +0,0 @@
-import { Effect } from "effect";
-import { testingController } from "#server/adapters/testingController.ts";
-export function makePgBossTesting(options = {}) {
-    return testingController(options);
-}
-export const testRetryPolicy = Object.freeze({ retryBackoff: false, retryDelay: 0 });
-export function linkedWorkerSpans(sender, spans) {
-    return Effect.sync(() => spans.filter((span) => span.kind === "consumer"
-        && span.attributes.get("messaging.system") === "pg-boss"
-        && span.links.some((link) => link.span.spanId === sender.spanId && link.span.traceId === sender.traceId)));
-}
-//# sourceMappingURL=testing.js.map

package/dist/server/testing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testing.js","sourceRoot":"","sources":["../../src/server/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,MAAM,EAAe,MAAM,QAAQ,CAAC;AAE5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE1E,MAAM,UAAU,iBAAiB,CAAC,OAAO,GAAyB,EAAE;IACnE,OAAO,iBAAiB,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAMD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;AAOrF,MAAM,UAAU,iBAAiB,CAAC,MAAkD,EAAE,KAA6B;IAClH,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CACvB,KAAK,CAAC,MAAM,CACX,CAAC,IAAI,EAAE,EAAE,CACR,IAAI,CAAC,IAAI,KAAK,UAAU;WACrB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,SAAS;WACrD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,CACzG,CACD,CAAC;AACH,CAAC"}

package/src/server/adapters/expireAttempt.ts

@@ -1,22 +0,0 @@
-import type { EngineClient } from "#server/engineClient.ts";
-import type { JobAttempt } from "#server/internal/engine.ts";
-import { quotedSchema } from "#server/internal/storedRows.ts";
-
-export async function expireAttempt(client: EngineClient, schema: string, job: JobAttempt, cause: "expiry" | "heartbeat" = "expiry"): Promise<void> {
-	if ((await client.schemaVersion()) !== 46) {
-		throw new Error("Testing expiry requires pg-boss schema version 46");
-	}
-	const quoted = quotedSchema(schema);
-	const timestamp = cause === "expiry" ? "started_on" : "heartbeat_on";
-	const seconds = cause === "expiry" ? "expire_seconds" : "heartbeat_seconds";
-	await client.getDb().executeSql(
-		`UPDATE ${quoted}.job SET ${timestamp} = ${quoted}.job_now() - (${seconds} + 1) * interval '1 second'
-		WHERE name = $1 AND id = $2 AND retry_count = $3 AND state = 'active'`,
-		[job.name, job.id, job.retryCount],
-	);
-	// Supervision owns expiry and dead lettering; make its claim due with the job's deadline.
-	await client
-		.getDb()
-		.executeSql(`UPDATE ${quoted}.queue SET monitor_claim_on = ${quoted}.job_now() - interval '1 week' WHERE name = $1`, [job.name]);
-	await client.supervise(job.name);
-}

package/src/server/adapters/testingClient.ts

@@ -1,123 +0,0 @@
-import { Effect } from "effect";
-import { testingEngine } from "#server/adapters/testingEngine.ts";
-import { testingExpirations } from "#server/adapters/testingExpirations.ts";
-import type { ClientUpdateOptions, ClientUpdateRequest, ClientUpdateResult, PgBossClient } from "#server/client.ts";
-import type { EngineClient } from "#server/engineClient.ts";
-import type { EnqueueOptions } from "#server/enqueueOptions.ts";
-import { deferralChanges } from "#server/internal/adapters/deferralChanges.ts";
-import type { TestingBatch, TestingWork } from "#server/internal/testingIdle.ts";
-import type { WorkerJob } from "#server/job.ts";
-
-export interface TestingControls {
-	readonly changed: () => void;
-	readonly expirations: Map<string, number>;
-	readonly expirySeconds: Map<string, number>;
-	readonly failures: Set<string>;
-	readonly retryPolicy: Pick<EnqueueOptions, "retryBackoff" | "retryDelay">;
-	readonly work: TestingWork;
-}
-
-export function testingClient(client: EngineClient, schema: string, controls: TestingControls): EngineClient {
-	const engine = testingEngine(client, schema);
-	deferralChanges.set(client.getDb(), controls.changed);
-
-	const expirations = testingExpirations(client);
-	function update(request: ClientUpdateRequest): Promise<ClientUpdateResult>;
-	function update(name: string, data: object | null | undefined, options?: ClientUpdateOptions): Promise<ClientUpdateResult>;
-	async function update(request: string | ClientUpdateRequest, data?: object | null, options?: ClientUpdateOptions): Promise<ClientUpdateResult> {
-		const result = typeof request === "string" ? await client.update(request, data, options) : await client.update(request);
-		controls.changed();
-		return result;
-	}
-	const overrides: Partial<PgBossClient> = {
-		complete: async (...args) => {
-			const result = await client.complete(...args);
-			controls.changed();
-			return result;
-		},
-		createQueue: (name, options) => {
-			if (options?.deadLetter !== undefined) {
-				controls.work.queues.add(name);
-			}
-			const { retryDelayMax, ...rest } = options ?? {};
-			return client.createQueue(name, {
-				...rest,
-				...(controls.retryPolicy.retryBackoff === false || retryDelayMax === undefined ? {} : { retryDelayMax }),
-				...controls.retryPolicy,
-			});
-		},
-		fail: async (...args) => {
-			const result = await client.fail(...args);
-			controls.changed();
-			return result;
-		},
-		retry: async (...args) => {
-			const result = await client.retry(...args);
-			controls.changed();
-			return result;
-		},
-		send: async (name, data, options) => {
-			if (controls.failures.delete(name)) {
-				throw new Error("Injected pg-boss send failure");
-			}
-			const attempts = controls.expirations.get(name);
-			const expireInSeconds = controls.expirySeconds.get(name);
-			const { retryDelayMax, ...rest } = options ?? {};
-			const id = await expirations.send(
-				name,
-				data,
-				{
-					...rest,
-					...(controls.retryPolicy.retryBackoff === false || retryDelayMax === undefined ? {} : { retryDelayMax }),
-					...controls.retryPolicy,
-					...(attempts === undefined ? {} : { retryLimit: attempts - 1 }),
-					...(expireInSeconds === undefined ? {} : { expireInSeconds }),
-				},
-				attempts,
-			);
-			controls.changed();
-			return id;
-		},
-		update,
-		updateQueue: (name, options) =>
-			client.updateQueue(name, {
-				...options,
-				...controls.retryPolicy,
-				...(controls.retryPolicy.retryBackoff === false ? { retryDelayMax: null } : {}),
-			}),
-		work: async (name, options, handler) =>
-			client.work(name, options, async (jobs: readonly WorkerJob<unknown>[]) => {
-				const batch: TestingBatch = { jobs: new Map(jobs.map((job) => [job.id, job.retryCount])), name, settled: false };
-				controls.work.batches.add(batch);
-				controls.changed();
-				try {
-					const ready: WorkerJob<unknown>[] = [];
-					for (const job of jobs) {
-						const attempts = await expirations.attemptsFor(job);
-						if (attempts !== undefined && job.retryCount + 1 >= attempts) {
-							await Effect.runPromise(engine.expireAttempt(job));
-						} else {
-							ready.push(job);
-						}
-					}
-					if (ready.length > 0) {
-						await handler(ready);
-					}
-				} finally {
-					controls.work.batches.delete(batch);
-					controls.changed();
-				}
-			}),
-	};
-	const wrapped = new Proxy(client, {
-		get(target, property) {
-			if (Object.hasOwn(overrides, property)) {
-				const override: unknown = Reflect.get(overrides, property);
-				return override;
-			}
-			const value: unknown = Reflect.get(target, property);
-			return typeof value === "function" ? value.bind(target) : value;
-		},
-	});
-	return wrapped;
-}

package/src/server/adapters/testingController.ts

@@ -1,137 +0,0 @@
-import { Duration, Effect, Redacted, type Schema } from "effect";
-import { TestClock as PgBossTestClock } from "pg-boss";
-import { defaultClientFactory } from "#server/adapters/defaultClientFactory.ts";
-import { testingClient } from "#server/adapters/testingClient.ts";
-import { testingDueNow } from "#server/adapters/testingDueNow.ts";
-import { testingTime } from "#server/adapters/testingTime.ts";
-import type { JobReadOptions, PgBossClientFactory } from "#server/client.ts";
-import type { JobPayloadSchema, QueueDefinition } from "#server/definition.ts";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService, SnapshotQueue } from "#server/inspection.ts";
-import { type TestingFetches, testingFetches } from "#server/internal/adapters/testingFetches.ts";
-import { type TestingWork, testingIdle } from "#server/internal/testingIdle.ts";
-import { testingInspection, testingOperation } from "#server/internal/testingOperation.ts";
-import { testingSchedules } from "#server/internal/testingSchedules.ts";
-import { testingWaits } from "#server/internal/testingWaits.ts";
-import type { PgBossTestingOptions } from "#server/testing.ts";
-import { queueSignal } from "./queueSignal.ts";
-import { testingInspectionClient } from "./testingInspectionClient.ts";
-export function testingController(settings: PgBossTestingOptions = {}) {
-	const clock = settings.clock === undefined ? undefined : new PgBossTestClock(settings.clock.currentTimeMillisUnsafe());
-	let current: EngineClient | undefined;
-	let fetches: TestingFetches | undefined;
-	let schema = "pgboss";
-	const signal = queueSignal();
-	let observed: PgBossInspectionService | undefined;
-	const work: TestingWork = { batches: new Set(), queues: new Set() };
-	const controls = {
-		changed: signal.changed,
-		expirations: new Map<string, number>(),
-		expirySeconds: new Map<string, number>(),
-		failures: new Set<string>(),
-		retryPolicy: settings.retryPolicy ?? {},
-		work,
-	};
-	function client(): EngineClient {
-		if (current === undefined) {
-			throw new Error("Provide the testing clientFactory to a jobs Layer first");
-		}
-		return current;
-	}
-	function inspection(): PgBossInspectionService {
-		if (observed === undefined) {
-			throw new Error("Provide the testing clientFactory to a jobs Layer first");
-		}
-		return observed;
-	}
-	const clientFactory: PgBossClientFactory = (clientOptions) => {
-		if (current !== undefined) {
-			throw new Error("A testing controller owns one jobs client; create a controller per runtime");
-		}
-		schema = clientOptions.schema ?? "pgboss";
-		current = defaultClientFactory({ ...clientOptions, ...(clock === undefined ? {} : { clock }) });
-		fetches = testingFetches(current.getDb(), signal.changed);
-		current = testingClient(current, schema, controls);
-		return testingInspectionClient(current, schema, work, signal.changed, (reads) => {
-			observed = reads;
-		});
-	};
-	const wake = Effect.sync(() => {
-		if (clock !== undefined) {
-			for (const worker of client().getWipData()) {
-				client().notifyWorker(worker.id);
-			}
-		}
-	});
-	const idle = testingIdle(inspection, work, signal, wake);
-	return {
-		deferred: (queue: Pick<QueueDefinition, "name">) => Effect.suspend(() => testingInspection("deferred", inspection().deferred(queue), queue.name)),
-		...testingDueNow(client, () => schema, signal.changed),
-		...testingSchedules(client, inspection),
-		...testingWaits(inspection, () => fetches, signal),
-		checkBatchWindow: (queue: Pick<QueueDefinition, "name" | "workerOptions">, millisecondsPerJob: number) =>
-			testingOperation(
-				"checkBatchWindow",
-				async () => {
-					const stored = await Effect.runPromise(inspection().queue(queue));
-					if (stored === null) {
-						throw new Error("Queue is not registered");
-					}
-					if (stored.expireInSeconds === undefined) {
-						throw new Error("Queue has no expiry window");
-					}
-					if (!Number.isFinite(millisecondsPerJob) || millisecondsPerJob < 0) {
-						throw new RangeError("Job duration must be nonnegative and finite");
-					}
-					const required = (queue.workerOptions.batchSize ?? 10) * millisecondsPerJob;
-					if (required >= stored.expireInSeconds * 1000) {
-						throw new Error("Sequential batch work must fit within the queue expiry window");
-					}
-				},
-				queue.name,
-			),
-		checkSchemaVersion: (expected: number) =>
-			testingOperation("checkSchemaVersion", async () => {
-				if ((await Effect.runPromise(inspection().schemaVersion())) !== expected) {
-					throw new Error(`Expected pg-boss schema version ${expected}`);
-				}
-			}),
-		clientFactory,
-		expireAfter: (queue: Pick<QueueDefinition, "name">, attempts: number) =>
-			Effect.try({
-				catch: (original) => new PgBossTestingError({ operation: "expireAfter", original: Redacted.make(original), queue: queue.name }),
-				try: () => {
-					if (!Number.isSafeInteger(attempts) || attempts < 1) {
-						throw new RangeError("Attempts must be a positive integer");
-					}
-					controls.expirations.set(queue.name, attempts);
-				},
-			}),
-		expireIn: (queue: Pick<QueueDefinition, "name">, duration: Duration.Input) =>
-			Effect.try({
-				catch: (original) => new PgBossTestingError({ operation: "expireIn", original: Redacted.make(original), queue: queue.name }),
-				try: () => {
-					const milliseconds = Duration.toMillis(Duration.fromInputUnsafe(duration));
-					if (!Number.isFinite(milliseconds) || milliseconds < 1000) {
-						throw new RangeError("Expiry must be finite and at least one second");
-					}
-					controls.expirySeconds.set(queue.name, Math.ceil(milliseconds / 1000));
-				},
-			}),
-		failNextSend: (queue: Pick<QueueDefinition, "name">) => Effect.sync(() => controls.failures.add(queue.name)).pipe(Effect.asVoid),
-		jobs: <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
-			queue: { readonly name: TName; readonly schema: TPayload },
-			readOptions?: JobReadOptions,
-		) => Effect.suspend(() => testingInspection("jobs", inspection().jobs(queue, readOptions), queue.name)),
-		refreshQueueStats: (queue?: Pick<QueueDefinition, "name">) =>
-			testingOperation("refreshQueueStats", () => client().supervise(queue?.name), queue?.name),
-		revision: signal.revision,
-		schemaVersion: Effect.suspend(() => testingInspection("schemaVersion", inspection().schemaVersion())),
-		snapshot: <const TQueues extends readonly SnapshotQueue[]>(queues: TQueues) =>
-			Effect.suspend(() => testingInspection("snapshot", inspection().snapshot(queues))),
-		waitForChange: signal.waitForChange,
-		waitForIdle: idle,
-		...testingTime(settings.clock, clock, idle),
-	};
-}

package/src/server/adapters/testingDueNow.ts

@@ -1,32 +0,0 @@
-import type { QueueDefinition } from "#server/definition.ts";
-import type { EngineClient } from "#server/engineClient.ts";
-import { quotedSchema } from "#server/internal/storedRows.ts";
-import { testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingDueNow(client: () => EngineClient, schema: () => string, changed: () => void) {
-	function makeDue(queue: Pick<QueueDefinition, "name">, deferredOnly: boolean) {
-		return testingOperation(
-			deferredOnly ? "runDeferredNow" : "runDueNow",
-			async () => {
-				const quoted = quotedSchema(schema());
-				const condition = deferredOnly
-					? "state = 'retry' AND output ? 'jobDeferral' AND started_on IS NULL"
-					: `state IN ('created', 'retry') AND start_after > ${quoted}.job_now()`;
-				await client()
-					.getDb()
-					.executeSql(`UPDATE ${quoted}.job SET start_after = ${quoted}.job_now() WHERE name = $1 AND ${condition}`, [queue.name]);
-				changed();
-				for (const worker of client()
-					.getWipData()
-					.filter((candidate) => candidate.name === queue.name)) {
-					client().notifyWorker(worker.id);
-				}
-			},
-			queue.name,
-		);
-	}
-	return {
-		runDeferredNow: (queue: Pick<QueueDefinition, "name">) => makeDue(queue, true),
-		runDueNow: (queue: Pick<QueueDefinition, "name">) => makeDue(queue, false),
-	};
-}

package/src/server/adapters/testingEngine.ts

@@ -1,15 +0,0 @@
-import { type Context, Effect, Redacted } from "effect";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { TestingEngine } from "#server/internal/engine.ts";
-import { expireAttempt } from "./expireAttempt.ts";
-
-export function testingEngine(client: EngineClient, schema: string): Context.Service.Shape<typeof TestingEngine> {
-	return {
-		expireAttempt: (job, cause) =>
-			Effect.tryPromise({
-				catch: (original) => new PgBossTestingError({ operation: "expireAttempt", original: Redacted.make(original), queue: job.name }),
-				try: () => expireAttempt(client, schema, job, cause),
-			}),
-	};
-}

package/src/server/adapters/testingExpirations.ts

@@ -1,33 +0,0 @@
-import type { EngineClient } from "#server/engineClient.ts";
-import type { EnqueueOptions } from "#server/enqueueOptions.ts";
-import type { WorkerJob } from "#server/job.ts";
-
-export function testingExpirations(client: EngineClient) {
-	const snapshots = new Map<string, Promise<number | undefined>>();
-	return {
-		attemptsFor: (job: WorkerJob<unknown>) => snapshots.get(`${job.name}:${job.id}`),
-		send(name: string, data: object | null | undefined, options: EnqueueOptions, attempts: number | undefined) {
-			if (attempts === undefined && options.id === undefined) {
-				return client.send(name, data, options);
-			}
-			const id = options.id ?? crypto.randomUUID();
-			const key = `${name}:${id}`;
-			const previous = snapshots.get(key);
-			const sending = client.send(name, data, { ...options, id });
-			// A worker may claim the row before send returns. Wait for its result before applying the snapshot.
-			const snapshot = sending
-				.then(
-					(sent) => (sent === id ? attempts : previous),
-					() => previous,
-				)
-				.then((value) => {
-					if (value === undefined && snapshots.get(key) === snapshot) {
-						snapshots.delete(key);
-					}
-					return value;
-				});
-			snapshots.set(key, snapshot);
-			return sending;
-		},
-	};
-}

package/src/server/adapters/testingInspectionClient.ts

@@ -1,70 +0,0 @@
-import { Context, Effect, Exit, Layer, Scope } from "effect";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossInspection, type PgBossInspectionService } from "#server/inspection.ts";
-import type { TestingWork } from "#server/internal/testingIdle.ts";
-import { PgBoss } from "#server/PgBoss.ts";
-
-const settleBatches = Effect.fnUntraced(function* (inspection: PgBossInspectionService, work: TestingWork) {
-	for (const batch of work.batches) {
-		if (batch.settled) {
-			continue;
-		}
-		const stored = yield* inspection.storedJobs({ name: batch.name });
-		batch.settled = !stored.some((job) => job.state === "active" && batch.jobs.get(job.id) === job.retryCount);
-	}
-});
-
-export function testingInspectionClient(
-	source: EngineClient,
-	schema: string,
-	work: TestingWork,
-	changed: () => void,
-	observe: (inspection: PgBossInspectionService) => void,
-): EngineClient {
-	const scope = Effect.runSync(Scope.make());
-	const start = source.start.bind(source);
-	const stop = source.stop.bind(source);
-	async function startObserved() {
-		const result = await start();
-		const context = await Effect.runPromise(
-			Layer.buildWithScope(
-				PgBossInspection.layer.pipe(Layer.provide(Layer.succeed(PgBoss, { client: source, reused: false, schema, stop: undefined }))),
-				scope,
-			),
-		);
-		const inspection = Context.get(context, PgBossInspection);
-		observe(inspection);
-		await Effect.runPromise(
-			Effect.gen(function* () {
-				const changes = yield* inspection.changes();
-				const from = yield* changes.revision;
-				yield* Effect.forkScoped(
-					Effect.gen(function* () {
-						let revision = from;
-						while (true) {
-							revision = yield* changes.waitForChange(revision);
-							yield* settleBatches(inspection, work);
-							changed();
-						}
-					}),
-				);
-			}).pipe(Effect.provideService(Scope.Scope, scope)),
-		);
-		return result;
-	}
-	const stopObserved: EngineClient["stop"] = async (options) => {
-		await Promise.all([Effect.runPromise(Scope.close(scope, Exit.void)), stop(options)]);
-	};
-	return new Proxy(source, {
-		get(target, property) {
-			if (property === "start") {
-				return startObserved;
-			}
-			if (property === "stop") {
-				return stopObserved;
-			}
-			const value: unknown = Reflect.get(target, property);
-			return typeof value === "function" ? value.bind(target) : value;
-		},
-	});
-}

package/src/server/adapters/testingTime.ts

@@ -1,25 +0,0 @@
-import { Duration, Effect } from "effect";
-import type { TestClock } from "effect/testing";
-import type { PgBossTestingError } from "#server/error.ts";
-import { testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingTime(
-	clock: TestClock.TestClock | undefined,
-	jobs: { readonly setTime: (time: number) => Promise<void>; readonly tick: (milliseconds: number) => Promise<void> } | undefined,
-	idle: Effect.Effect<void, PgBossTestingError>,
-) {
-	return {
-		timePasses: (duration: Duration.Input) =>
-			Effect.gen(function* () {
-				if (clock === undefined || jobs === undefined) {
-					return yield* Effect.die(new Error("Provide the story's TestClock to makePgBossTesting before passing time"));
-				}
-				yield* idle;
-				const next = clock.currentTimeMillisUnsafe() + Duration.toMillis(Duration.fromInputUnsafe(duration));
-				yield* testingOperation("timePasses", () => jobs.setTime(next));
-				yield* clock.adjust(duration);
-				yield* testingOperation("timePasses", () => jobs.tick(0));
-				yield* idle;
-			}),
-	};
-}

package/src/server/internal/adapters/deferralChanges.ts

@@ -1,3 +0,0 @@
-import type { ClientDatabase } from "#server/ClientDatabase.ts";
-
-export const deferralChanges = new WeakMap<ClientDatabase, () => void>();

package/src/server/internal/adapters/testingFetches.ts

@@ -1,36 +0,0 @@
-import type { ClientDatabase } from "#server/ClientDatabase.ts";
-
-// pg-boss offers no hook for a worker fetch that finds nothing, so the controller recognizes its claim statement on the client's database.
-const claim = /UPDATE\s+\S+\s+j\s+SET\s+state\s*=\s*'active'/u;
-const claimedQueue = /\bj\.name\s*=\s*'(?<queue>[^']+)'/u;
-
-export interface TestingFetches {
-	readonly begun: (queue: string) => number;
-	readonly passedSince: (queue: string, begun: number) => number;
-}
-
-export function testingFetches(db: ClientDatabase, changed: () => void): TestingFetches {
-	const begun = new Map<string, number>();
-	const passed = new Map<string, number[]>();
-	const executeSql = db.executeSql.bind(db);
-	db.executeSql = async (text: string, values?: unknown[]) => {
-		const queue = claim.test(text) ? claimedQueue.exec(text)?.groups?.queue : undefined;
-		if (queue === undefined) {
-			return executeSql(text, values);
-		}
-		const ordinal = (begun.get(queue) ?? 0) + 1;
-		begun.set(queue, ordinal);
-		try {
-			return await executeSql(text, values);
-		} finally {
-			const ordinals = passed.get(queue) ?? [];
-			ordinals.push(ordinal);
-			passed.set(queue, ordinals);
-			changed();
-		}
-	};
-	return {
-		begun: (queue) => begun.get(queue) ?? 0,
-		passedSince: (queue, mark) => (passed.get(queue) ?? []).filter((ordinal) => ordinal > mark).length,
-	};
-}

package/src/server/internal/testingIdle.ts

@@ -1,36 +0,0 @@
-import { Effect } from "effect";
-import type { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService } from "#server/inspection.ts";
-import { testingInspection } from "#server/internal/testingOperation.ts";
-
-export interface TestingBatch {
-	readonly jobs: ReadonlyMap<string, number>;
-	readonly name: string;
-	settled: boolean;
-}
-
-export interface TestingWork {
-	readonly batches: Set<TestingBatch>;
-	readonly queues: Set<string>;
-}
-
-export function testingIdle(
-	inspection: () => PgBossInspectionService,
-	work: TestingWork,
-	signal: { readonly revision: Effect.Effect<number>; readonly waitForChange: (after: number) => Effect.Effect<number> },
-	wake: Effect.Effect<void> = Effect.void,
-): Effect.Effect<void, PgBossTestingError> {
-	const busy = Effect.suspend(() => testingInspection("waitForIdle", inspection().busy([...work.queues].map((name) => ({ name })))));
-	return Effect.gen(function* () {
-		while (true) {
-			const revision = yield* signal.revision;
-			// A batch with no settlement since its fetch still holds active jobs, so it is busy without a read.
-			const unsettled = [...work.batches].some((batch) => !batch.settled);
-			if (work.queues.size === 0 || !(unsettled || (yield* busy))) {
-				return;
-			}
-			yield* wake;
-			yield* signal.waitForChange(revision);
-		}
-	});
-}

package/src/server/internal/testingOperation.ts

@@ -1,18 +0,0 @@
-import { Effect, Redacted } from "effect";
-import { PgBossError, PgBossTestingError } from "#server/error.ts";
-
-export function testingOperation<A>(operation: string, run: () => Promise<A>, queue?: string) {
-	return Effect.tryPromise({
-		catch: (original) => new PgBossTestingError({ operation, original: Redacted.make(original), queue }),
-		try: run,
-	});
-}
-
-export function testingInspection<A, E, R>(operation: string, effect: Effect.Effect<A, E | PgBossError, R>, queue?: string) {
-	return effect.pipe(
-		Effect.catchIf(
-			(error): error is PgBossError => error instanceof PgBossError,
-			(error) => Effect.fail(new PgBossTestingError({ operation, original: error.original, queue: queue ?? error.queue })),
-		),
-	);
-}

package/src/server/internal/testingSchedules.ts

@@ -1,35 +0,0 @@
-import { Effect, Redacted } from "effect";
-import type { PgBossClient } from "#server/client.ts";
-import type { ScheduleDefinition } from "#server/definition.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService } from "#server/inspection.ts";
-import { testingInspection, testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingSchedules(client: () => PgBossClient, inspection: () => PgBossInspectionService) {
-	return {
-		schedules: () =>
-			Effect.suspend(() => testingInspection("schedules", inspection().schedules())).pipe(
-				Effect.map((schedules) => schedules.map(({ name, cron, timezone }) => ({ cron, name, timezone }))),
-			),
-		trigger: (schedule: Pick<ScheduleDefinition, "name" | "scheduleOptions">) =>
-			Effect.gen(function* () {
-				const [registered] = yield* testingInspection(
-					"trigger",
-					inspection().schedules(schedule.name, schedule.scheduleOptions.key ?? ""),
-					schedule.name,
-				);
-				if (registered === undefined) {
-					return yield* new PgBossTestingError({
-						operation: "trigger",
-						original: Redacted.make(new Error("Schedule is not registered")),
-						queue: schedule.name,
-					});
-				}
-				return yield* testingOperation(
-					"trigger",
-					() => client().send(registered.name, registered.data, { ...registered.options, startAfter: 0 }),
-					schedule.name,
-				);
-			}),
-	};
-}