refactor(orphan): separate reaper test responsibilities

apps/api/src/__tests__/helpers/deferred.ts

@@ -0,0 +1,13 @@
+type Resolve<T> = [T] extends [void]
+	? (value?: T | PromiseLike<T>) => void
+	: (value: T | PromiseLike<T>) => void;
+
+export function deferred<T = void>() {
+	let resolve!: Resolve<T>;
+	let reject!: (reason?: unknown) => void;
+	const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+		resolve = resolvePromise as Resolve<T>;
+		reject = rejectPromise;
+	});
+	return { promise, resolve, reject };
+}

apps/api/src/__tests__/helpers/orphan-service-fixture.ts

@@ -0,0 +1,87 @@
+import { vi } from 'vitest';
+
+import type { ObjectReferenceInventory } from '../../modules/orphan/reference-resolver.js';
+
+interface ClaimedOrphan {
+	id: number;
+	bucket: string;
+	storageKey: string;
+	targetKind: 'EXACT' | 'PREFIX';
+	attemptCount: number;
+}
+
+export function createOrphanServiceDependencies() {
+	const now = new Date('2026-07-21T05:00:00.000Z');
+	const repository = {
+		upsertOrphan: vi.fn(async () => undefined),
+		claimPendingOrphans: vi.fn(async (): Promise<ClaimedOrphan[]> => []),
+		markClaimResolved: vi.fn(async () => ({ count: 1 })),
+		renewActiveClaim: vi.fn(async (
+			_id: number,
+			_claimToken: string,
+			_claimLeaseMs: number,
+			_request?: { signal?: AbortSignal },
+		) => ({ count: 1 })),
+		markClaimCancelled: vi.fn(async () => ({ count: 1 })),
+		markClaimFailed: vi.fn(async () => ({ count: 1 })),
+	};
+
+	return {
+		now,
+		deps: {
+			clock: { now: () => now },
+			storage: {
+				delete: vi.fn(async (
+					_bucket: string,
+					_key: string,
+					_request?: { signal?: AbortSignal; requestTimeoutMs?: number },
+				): Promise<void> => undefined),
+				listKeys: vi.fn(async (
+					_bucket: string,
+					_prefix: string,
+					_request?: { signal?: AbortSignal; requestTimeoutMs?: number },
+				): Promise<string[]> => []),
+				listKeyPage: vi.fn(async (
+					_bucket: string,
+					_prefix: string,
+					_page: { startAfter?: string; maxKeys: number },
+					_request?: { signal?: AbortSignal; requestTimeoutMs?: number },
+				): Promise<{ keys: string[]; isTruncated: boolean }> => ({
+					keys: [], isTruncated: false,
+				})),
+				deleteKeys: vi.fn(async (
+					_bucket: string,
+					keys: readonly string[],
+					_request?: { signal?: AbortSignal; requestTimeoutMs?: number },
+				) => ({ deleted: [...keys], failures: [] })),
+			},
+			repository,
+			references: {
+				collect: vi.fn(async (): Promise<ObjectReferenceInventory> => ({
+					references: [],
+					unsafeBuckets: new Set<string>(),
+				})),
+			},
+			ids: { next: () => 'claim-token' },
+			logger: { info: vi.fn(), error: vi.fn() },
+		},
+	};
+}
+
+export function orphan(
+	id: number,
+	storageKey: string,
+	overrides: Partial<{
+		bucket: string;
+		targetKind: 'EXACT' | 'PREFIX';
+		attemptCount: number;
+	}> = {},
+): ClaimedOrphan {
+	return {
+		id,
+		bucket: overrides.bucket ?? 'public',
+		storageKey,
+		targetKind: overrides.targetKind ?? 'EXACT',
+		attemptCount: overrides.attemptCount ?? 0,
+	};
+}

apps/api/src/__tests__/object-deletion.test.ts

@@ -85,31 +85,6 @@ describe('object deletion coordinator', () => {
 		);
 	});
 
-	it('deletes prefix batches and hands confirmed partial failures to parent recovery', async () => {
-		const deleteKeys = vi.fn().mockResolvedValue({
-			deleted: ['site/1.js', 'site/3.js'],
-			failures: [{ key: 'site/2.js', code: 'SlowDown' }],
-		});
-		const record = vi.fn().mockResolvedValue(undefined);
-		const coordinator = createObjectDeletionCoordinator({
-			storage: {
-				delete: vi.fn(),
-				listKeyPage: vi.fn()
-					.mockResolvedValueOnce({ keys: ['site/1.js', 'site/2.js', 'site/3.js'], isTruncated: false })
-					.mockResolvedValueOnce({ keys: [], isTruncated: false }),
-				deleteKeys,
-			},
-			orphans: { record },
-			logger: { error: vi.fn() },
-		});
-
-		await expect(coordinator.deletePrefixOrQueue('public', 'site/', 'deployment-delete'))
-			.resolves.toBe(3);
-		expect(deleteKeys).toHaveBeenCalledOnce();
-		expect(record).toHaveBeenCalledOnce();
-		expect(record).toHaveBeenCalledWith('public', 'site/', 'deployment-delete', 'PREFIX');
-	});
-
 	it('queues the prefix itself when enumeration fails', async () => {
 		const record = vi.fn().mockResolvedValue(undefined);
 		const coordinator = createObjectDeletionCoordinator({