@remit/imap-worker 0.0.89 → 0.0.90

package/src/handlers/probe-message-id.sqlite.test.ts

@@ -177,7 +177,7 @@ describe("the Message-ID the move, delete and copy probes ask with", () => {
 			mailboxSpecialUseService: repos.mailboxSpecialUse,
 			threadMessageService: threadMessages,
 			addressService: repos.address,
-			queue: recordingQueue(),
+			queue: recordingQueue().fifo,
 		}).copyMessage(ACCOUNT_CONFIG_ID, sourceId, archive.mailboxId, accountId);
 
 		assert.notEqual(copyId, sourceId);

package/src/handlers/sync-mailboxes.ts

@@ -21,6 +21,7 @@ import {
 	MailboxSyncService,
 	MailConnectionError,
 	type MailCredentials,
+	standardMailboxManagement,
 } from "@remit/mailbox-service";
 import pMap from "p-map";
 import {
@@ -28,9 +29,9 @@ import {
 	isMailSyncDisabled,
 	isUnsyncableHost,
 } from "../account-check.js";
-import { emitEvent } from "../emit.js";
+import { createEmitEvent, type EmitEvent } from "../emit.js";
 import type { SyncMailboxesEvent, SyncMessagesEvent } from "../events.js";
-import { workerQueues } from "../queues.js";
+import type { WorkerQueues } from "../queues.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { createImportedFolder } from "./imported-folder.js";
@@ -95,6 +96,7 @@ export const mailboxNeedsSync = (
 export const syncMailboxes = async (
 	event: SyncMailboxesEvent,
 	log: Logger,
+	queues: WorkerQueues,
 ): Promise<void> => {
 	const client = await getClient();
 	const {
@@ -118,7 +120,7 @@ export const syncMailboxes = async (
 			mailboxService,
 			new MailboxQueueService({
 				mailboxService,
-				queue: workerQueues().mailboxManagement,
+				enqueue: standardMailboxManagement(queues.mailboxManagement),
 				logger: log,
 			}),
 		),
@@ -166,6 +168,7 @@ export const syncMailboxes = async (
 					accountService,
 					binder,
 					log,
+					createEmitEvent(queues),
 				);
 			} catch (err) {
 				// Auth failures are handled by the wrapper — rethrow untouched so it
@@ -199,6 +202,7 @@ const syncMailboxesForAccount = async (
 	accountService: IAccountRepository,
 	binder: ConfigBinderDeps,
 	log: Logger,
+	emit: EmitEvent,
 ): Promise<void> => {
 	const { accountId } = account;
 
@@ -330,7 +334,7 @@ const syncMailboxesForAccount = async (
 		mailboxCountSynced: skipped,
 	});
 
-	await emitSyncMessagesEvents(accountId, mailboxes, emitEvent);
+	await emitSyncMessagesEvents(accountId, mailboxes, emit);
 };
 
 type SyncMessagesInput = Omit<SyncMessagesEvent, "eventId" | "timestamp">;

package/src/handlers/sync-message-body.sqlite.test.ts

@@ -73,7 +73,7 @@ const arrange = async (): Promise<Arranged> => {
 };
 
 const run = (a: Arranged, receiveCount = 1) =>
-	syncMessageBody(a.event, a.w.log, receiveCount, a.w.scope);
+	syncMessageBody(a.event, a.w.log, a.w.queues, receiveCount, a.w.scope);
 
 const bodyFetches = (a: Arranged): string[] => a.w.imap.commands("BODY");
 
@@ -160,7 +160,7 @@ const batchOf = (
 });
 
 const runBatch = (w: World, event: SyncMessageBodyEvent, receiveCount = 1) =>
-	syncMessageBody(event, w.log, receiveCount, w.scope);
+	syncMessageBody(event, w.log, w.queues, receiveCount, w.scope);
 
 const arrangeFiling = async () => {
 	const w = await store.world();

package/src/handlers/sync-message-body.ts

@@ -25,6 +25,7 @@ import {
 	createConnectionScopeWithCredentials,
 } from "../connection-scope.js";
 import type { SyncMessageBodyEvent } from "../events.js";
+import type { WorkerQueues } from "../queues.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { workerVersion } from "../worker-version.js";
@@ -87,6 +88,7 @@ export const buildRetryableFailureError = (
 export const syncMessageBody = async (
 	event: SyncMessageBodyEvent,
 	log: Logger,
+	queues: WorkerQueues,
 	receiveCount = 1,
 	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
@@ -142,7 +144,6 @@ export const syncMessageBody = async (
 		flagQueue: flagQueueService,
 		calendarSuggestion: calendarSuggestionService,
 		calendarStore,
-		queues,
 	} = await getClient();
 
 	const account = await accountService.get(accountId);

package/src/handlers/sync-messages.sqlite.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { after, before, describe, it } from "node:test";
+import { createEmitEvent } from "../emit.js";
 import type { SyncMessagesEvent } from "../events.js";
 import { openStore, type World } from "../test-helpers/test-world.js";
 import { drainPendingFlagPushes, syncMessages } from "./sync-messages.js";
@@ -21,7 +22,12 @@ const syncEvent = (w: World, mailboxId: string): SyncMessagesEvent => ({
 });
 
 const sync = async (w: World, mailboxId: string): Promise<number> => {
-	await syncMessages(syncEvent(w, mailboxId), w.log, w.connectionFactory);
+	await syncMessages(
+		syncEvent(w, mailboxId),
+		w.log,
+		w.queues,
+		w.connectionFactory,
+	);
 	return w.imap.connections;
 };
 
@@ -106,7 +112,12 @@ describe("a folder deleted while its sync is in flight", () => {
 			return { getConnection: () => connection, close: factory.close };
 		};
 
-		await syncMessages(syncEvent(w, old.mailboxId), w.log, connectionFactory);
+		await syncMessages(
+			syncEvent(w, old.mailboxId),
+			w.log,
+			w.queues,
+			connectionFactory,
+		);
 
 		const account = await w.client.account.get(w.account.accountId);
 		assert.notEqual(account.syncPhase, "error");
@@ -142,6 +153,7 @@ describe("drainPendingFlagPushes (issue #1273)", () => {
 			w.account,
 			inbox.mailboxId,
 			w.log,
+			createEmitEvent(w.queues),
 		);
 
 		assert.deepEqual(

package/src/handlers/sync-messages.ts

@@ -35,12 +35,17 @@ import {
 	isMailSyncDisabled,
 	isUnsyncableHost,
 } from "../account-check.js";
-import { emitEvent, SYNC_MESSAGES_PENDING } from "../emit.js";
+import {
+	createEmitEvent,
+	type EmitEvent,
+	SYNC_MESSAGES_PENDING,
+} from "../emit.js";
 import type {
 	FlagPushEvent,
 	SyncMessageBodyEvent,
 	SyncMessagesEvent,
 } from "../events.js";
+import type { WorkerQueues } from "../queues.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { workerVersion } from "../worker-version.js";
@@ -77,6 +82,7 @@ export const managedConnectionFor = (
 export const syncMessages = async (
 	event: SyncMessagesEvent,
 	log: Logger,
+	queues: WorkerQueues,
 	createConnectionFactory = managedConnectionFor,
 ): Promise<void> => {
 	log.info(
@@ -212,6 +218,7 @@ export const syncMessages = async (
 								syncWarningRepository,
 								flagPushMarkerService,
 								messageFlagService,
+								emit: createEmitEvent(queues),
 							},
 							log,
 						);
@@ -290,6 +297,7 @@ interface SyncDeps {
 	syncWarningRepository: ISyncWarningRepository;
 	flagPushMarkerService: IMessageFlagPushRepository;
 	messageFlagService: IMessageFlagRepository;
+	emit: EmitEvent;
 }
 
 // Bounds concurrent SQS sends while re-arming stuck flag-push markers —
@@ -314,16 +322,13 @@ const FLAG_PUSH_DRAIN_CONCURRENCY = 5;
  * loudly — it must never fail the surrounding SYNC_MESSAGES batch, which is
  * unrelated message-header sync work. The marker stays durable regardless;
  * the next periodic tick tries again.
- *
- * `emit` defaults to the real `emitEvent` (imap-worker's shared SQS
- * producer) and is only ever overridden in tests.
  */
 export const drainPendingFlagPushes = async (
 	flagPushMarkerService: IMessageFlagPushRepository,
 	account: AccountItem,
 	mailboxId: string,
 	log: Logger,
-	emit: typeof emitEvent = emitEvent,
+	emit: EmitEvent,
 ): Promise<void> => {
 	const markers = await flagPushMarkerService.listByMailboxId(mailboxId);
 	const stuck = markers.filter((marker) => marker.state === "pending");
@@ -383,6 +388,7 @@ const syncMailboxMessages = async (
 		syncWarningRepository,
 		flagPushMarkerService,
 		messageFlagService,
+		emit,
 	} = deps;
 
 	// Get the mailbox - it must exist (should have been created by mailbox sync)
@@ -392,7 +398,13 @@ const syncMailboxMessages = async (
 	// Periodic drain (issue #1273): independent of the IMAP sync below — no
 	// connection needed, just an SQS re-arm — so it runs regardless of this
 	// round's sync outcome.
-	await drainPendingFlagPushes(flagPushMarkerService, account, mailboxId, log);
+	await drainPendingFlagPushes(
+		flagPushMarkerService,
+		account,
+		mailboxId,
+		log,
+		emit,
+	);
 	const isInbox = mailbox.fullPath.toUpperCase() === "INBOX";
 
 	const syncService = new MessageSyncService(
@@ -466,7 +478,7 @@ const syncMailboxMessages = async (
 					messageIds: batch.map((m) => m.messageId),
 					messages: batch.map((m) => ({ messageId: m.messageId, uid: m.uid })),
 				};
-				return emitEvent(bodyEvent);
+				return emit(bodyEvent);
 			},
 			{ concurrency: EVENT_EMIT_CONCURRENCY },
 		);
@@ -484,7 +496,7 @@ const syncMailboxMessages = async (
 			accountId: event.accountId,
 			mailboxId,
 		};
-		await emitEvent(nextSyncEvent);
+		await emit(nextSyncEvent);
 		return;
 	}
 

package/src/index.ts

@@ -9,14 +9,10 @@ import type { SQSBatchResponse, SQSEvent, SQSHandler } from "aws-lambda";
 import type { WorkerEvent } from "./events.js";
 import { imapFailureKind } from "./failure-kind.js";
 import { processEvent } from "./processor.js";
-import {
-	setWorkerQueues,
-	sqsWorkerQueues,
-	workerQueueUrlsFromEnv,
-} from "./queues.js";
+import { sqsWorkerQueues, workerQueueUrlsFromEnv } from "./queues.js";
 
 installNodeLogger();
-setWorkerQueues(sqsWorkerQueues(workerQueueUrlsFromEnv()));
+const queues = sqsWorkerQueues(workerQueueUrlsFromEnv());
 
 const log = createLogger();
 
@@ -51,7 +47,7 @@ export const handler: SQSHandler = withTelemetry(
 
 			const queue = queueNameFromEventSource(record.eventSourceARN);
 			const opStart = Date.now();
-			const failed = await processEvent(imapEvent, log, receiveCount)
+			const failed = await processEvent(imapEvent, log, queues, receiveCount)
 				.then(() => {
 					recordQueueEvent({
 						queue,

package/src/mail-sync-selection.sqlite.test.ts

@@ -25,8 +25,8 @@ import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
 import type { Logger } from "@remit/logger";
 import { syncMailboxes } from "./handlers/sync-mailboxes.js";
 import { syncMessages } from "./handlers/sync-messages.js";
-import { setWorkerQueues } from "./queues.js";
 import { runSchedulerTick } from "./scheduler/run-tick.js";
+import { workerQueuesOn } from "./test-helpers/worker-queues.js";
 
 const NOW = 1_700_000_000_000;
 
@@ -70,15 +70,6 @@ beforeEach(() => {
 		mailboxLock: locks,
 	} as unknown as RemitClient;
 	setClient(client);
-	const queue = recordingQueue();
-	setWorkerQueues({
-		mailboxes: queue,
-		messages: queue,
-		flags: queue,
-		body: queue,
-		mailboxManagement: queue,
-		messageManagement: queue,
-	});
 });
 
 afterEach(() => {
@@ -144,7 +135,7 @@ const tick = async (): Promise<{ enqueued: number; accountIds: string[] }> => {
 	const result = await runSchedulerTick({
 		redriveStrandedPlacements: async () => 0,
 		accountService: accounts,
-		queue,
+		queue: queue.fifo,
 		log: silentLogger,
 		tickIntervalMs: 60_000,
 		offlineIntervalMs: 0,
@@ -179,6 +170,7 @@ describe("turning mail sync off and on again", () => {
 				accountId: account.accountId,
 			},
 			silentLogger,
+			workerQueuesOn(recordingQueue()),
 		);
 
 		let connections = 0;
@@ -191,6 +183,7 @@ describe("turning mail sync off and on again", () => {
 				mailboxId,
 			},
 			silentLogger,
+			workerQueuesOn(recordingQueue()),
 			() => {
 				connections += 1;
 				throw new Error("a sync that is off must not connect");

package/src/pending-sync.sqlite.test.ts

@@ -11,11 +11,15 @@ import {
 } from "@remit/data-ports/recording-queue";
 import { MailboxLockRepo } from "@remit/drizzle-service";
 import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import { emitEvent, SYNC_MESSAGES_PENDING } from "./emit.js";
+import {
+	createEmitEvent,
+	type EmitEvent,
+	SYNC_MESSAGES_PENDING,
+} from "./emit.js";
 import type { SyncMessagesEvent } from "./events.js";
 import { emitMailboxResync, emitMoveResync } from "./handlers/message-move.js";
 import { emitSyncMessagesEvents } from "./handlers/sync-mailboxes.js";
-import { setWorkerQueues } from "./queues.js";
+import { workerQueuesOn } from "./test-helpers/worker-queues.js";
 
 const ACCOUNT = "account-1366";
 const FOLDERS = [
@@ -42,19 +46,14 @@ const inboxSync = (): Omit<SyncMessagesEvent, "eventId" | "timestamp"> => ({
 	mailboxId: "mbx-inbox",
 });
 
+const emitEvent: EmitEvent = (event) =>
+	createEmitEvent(workerQueuesOn(queue))(event);
+
 const fanOut = (): Promise<void> =>
 	emitSyncMessagesEvents(ACCOUNT, FOLDERS, emitEvent);
 
 beforeEach(() => {
 	queue = recordingQueue();
-	setWorkerQueues({
-		mailboxes: queue,
-		messages: queue,
-		flags: queue,
-		body: queue,
-		mailboxManagement: queue,
-		messageManagement: queue,
-	});
 	const store = createShippedSqliteDb();
 	closeStore = store.close;
 	locks = new MailboxLockRepo(store.db);

package/src/processor.ts

@@ -12,10 +12,12 @@ import { handlePlacementMovePush } from "./handlers/placement-move-push.js";
 import { syncMailboxes } from "./handlers/sync-mailboxes.js";
 import { syncMessageBody } from "./handlers/sync-message-body.js";
 import { syncMessages } from "./handlers/sync-messages.js";
+import type { WorkerQueues } from "./queues.js";
 
 export const processEvent = async (
 	event: WorkerEvent,
 	log: Logger,
+	queues: WorkerQueues,
 	/**
 	 * SQS's own delivery count for the record carrying this event (1 on first
 	 * delivery). Read by SYNC_MESSAGE_BODY, PLACEMENT_MOVE_PUSH, FLAG_PUSH,
@@ -29,31 +31,31 @@ export const processEvent = async (
 ): Promise<void> => {
 	switch (event.type) {
 		case "SYNC_MAILBOXES":
-			return syncMailboxes(event, log);
+			return syncMailboxes(event, log, queues);
 		case "SYNC_MESSAGES":
-			return syncMessages(event, log);
+			return syncMessages(event, log, queues);
 		case "SYNC_MESSAGE_BODY":
-			return syncMessageBody(event, log, receiveCount);
+			return syncMessageBody(event, log, queues, receiveCount);
 		case "MAILBOX_CREATE":
 		case "MAILBOX_RENAME":
 		case "MAILBOX_DELETE":
 			return processMailboxManagement(event, log);
 		case "MESSAGE_DELETE":
-			return handleMessageDelete(event, log, receiveCount);
+			return handleMessageDelete(event, log, queues, receiveCount);
 		case "MESSAGE_MOVE":
-			return handleMessageMove(event, log, receiveCount);
+			return handleMessageMove(event, log, queues, receiveCount);
 		case "PLACEMENT_MOVE_PUSH":
-			return handlePlacementMovePush(event, log, receiveCount);
+			return handlePlacementMovePush(event, log, queues, receiveCount);
 		case "FLAG_PUSH":
 			return handleFlagPush(event, log, receiveCount);
 		case "MESSAGE_COPY":
-			return handleMessageCopy(event, log, receiveCount);
+			return handleMessageCopy(event, log, queues, receiveCount);
 		case "EMPTY_TRASH":
 			return handleEmptyTrash(event, log);
 		case "APPEND_SENT_MESSAGE":
 			return handleAppendSentMessage(event, log, receiveCount);
 		case "DELETE_ACCOUNT_OBJECTS":
-			return handleDeleteAccountObjects(event, log);
+			return handleDeleteAccountObjects(event, log, queues);
 		default:
 			throw new Error(`Unknown event type: ${(event as WorkerEvent).type}`);
 	}

package/src/queues.ts

@@ -1,5 +1,8 @@
 import type { FifoQueueProducer, QueueProducer } from "@remit/data-ports";
-import { createQueueProducer } from "@remit/sqs-client/producer";
+import {
+	createFifoQueueProducer,
+	createStandardQueueProducer,
+} from "@remit/sqs-client/producer";
 import { env } from "expect-env";
 import type { ImapEvent, WorkerEvent } from "./events.js";
 
@@ -24,26 +27,14 @@ export const workerQueueUrlsFromEnv = (): WorkerQueueUrls => ({
 });
 
 export const sqsWorkerQueues = (urls: WorkerQueueUrls): WorkerQueues => ({
-	mailboxes: createQueueProducer({ queueUrl: urls.mailboxes }),
-	messages: createQueueProducer({ queueUrl: urls.messages }),
-	flags: createQueueProducer({ queueUrl: urls.flags }),
-	body: createQueueProducer({ queueUrl: urls.body }),
-	mailboxManagement: createQueueProducer({ queueUrl: urls.mailboxManagement }),
-	messageManagement: createQueueProducer({ queueUrl: urls.messageManagement }),
+	mailboxes: createFifoQueueProducer({ queueUrl: urls.mailboxes }),
+	messages: createFifoQueueProducer({ queueUrl: urls.messages }),
+	flags: createFifoQueueProducer({ queueUrl: urls.flags }),
+	body: createStandardQueueProducer({ queueUrl: urls.body }),
+	mailboxManagement: createStandardQueueProducer({
+		queueUrl: urls.mailboxManagement,
+	}),
+	messageManagement: createStandardQueueProducer({
+		queueUrl: urls.messageManagement,
+	}),
 });
-
-let composed: WorkerQueues | null = null;
-
-/** Register the worker's queues from its entry, before the first event. */
-export const setWorkerQueues = (queues: WorkerQueues): void => {
-	composed = queues;
-};
-
-export const workerQueues = (): WorkerQueues => {
-	if (!composed) {
-		throw new Error(
-			"no worker queues registered — register them with setWorkerQueues() from the entry",
-		);
-	}
-	return composed;
-};

package/src/scheduler/attachment-sweep.sqlite.test.ts

@@ -57,9 +57,8 @@ describe("the outbox attachment sweep", () => {
 		const second = await store.world();
 		const secondDraft = await arrange(second);
 
-		const { handler } = await import("./handler.js");
-		store.bindWorkerQueues();
-		await handler(
+		const { buildScheduledHandler } = await import("./handler.js");
+		await buildScheduledHandler(second.queues)(
 			{ time: new Date().toISOString() } as never,
 			{} as never,
 			() => {},

package/src/scheduler/handler.ts

@@ -2,11 +2,10 @@ import { getClient } from "@remit/backend/client";
 import { createLogger } from "@remit/logger";
 import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { ScheduledHandler } from "aws-lambda";
-import { emitEvent } from "../emit.js";
+import { createEmitEvent } from "../emit.js";
 import {
-	setWorkerQueues,
 	sqsWorkerQueues,
-	workerQueues,
+	type WorkerQueues,
 	workerQueueUrlsFromEnv,
 } from "../queues.js";
 import { buildAttachmentSweep } from "./attachment-sweep.js";
@@ -19,8 +18,6 @@ installNodeLogger();
 
 const log = createLogger();
 
-setWorkerQueues(sqsWorkerQueues(workerQueueUrlsFromEnv()));
-
 /**
  * EventBridge-scheduled entry point for the periodic mailbox-sync tick
  * (#1247, restructured #1251). Ticks at `MAILBOX_SYNC_TICK_INTERVAL_SECONDS`
@@ -38,27 +35,35 @@ setWorkerQueues(sqsWorkerQueues(workerQueueUrlsFromEnv()));
  * while a genuine retry of the same invocation carries the same `time` and
  * correctly dedupes.
  */
-export const handler: ScheduledHandler = withTelemetry(async (event) => {
-	const client = await getClient();
-	const now = Date.parse(event.time);
+export const buildScheduledHandler = (queues: WorkerQueues): ScheduledHandler =>
+	withTelemetry(async (event) => {
+		const client = await getClient();
+		const now = Date.parse(event.time);
 
-	await runSchedulerTick({
-		accountService: client.account,
-		queue: workerQueues().mailboxes,
-		log,
-		tickIntervalMs: getTickIntervalMs(),
-		offlineIntervalMs: getOfflineIntervalMs(),
-		now,
-		// The hosted side is the one that needs this: a browser PUTs straight
-		// to block storage, so nothing refuses an upload against a draft that is
-		// already gone and this sweep is the only thing that collects it.
-		sweepAttachments: buildAttachmentSweep(client, log),
-		refreshCalendarSubscriptions: buildCalendarSubscriptionRefresh(client, log),
-		redriveStrandedPlacements: (account, tickNow) =>
-			redriveStrandedPlacements(
-				{ client, emit: emitEvent, log },
-				account,
-				tickNow,
+		await runSchedulerTick({
+			accountService: client.account,
+			queue: queues.mailboxes,
+			log,
+			tickIntervalMs: getTickIntervalMs(),
+			offlineIntervalMs: getOfflineIntervalMs(),
+			now,
+			// The hosted side is the one that needs this: a browser PUTs straight
+			// to block storage, so nothing refuses an upload against a draft that is
+			// already gone and this sweep is the only thing that collects it.
+			sweepAttachments: buildAttachmentSweep(client, log),
+			refreshCalendarSubscriptions: buildCalendarSubscriptionRefresh(
+				client,
+				log,
 			),
+			redriveStrandedPlacements: (account, tickNow) =>
+				redriveStrandedPlacements(
+					{ client, emit: createEmitEvent(queues), log },
+					account,
+					tickNow,
+				),
+		});
 	});
-});
+
+export const handler: ScheduledHandler = buildScheduledHandler(
+	sqsWorkerQueues(workerQueueUrlsFromEnv()),
+);

package/src/scheduler/run-tick.sqlite.test.ts

@@ -65,7 +65,7 @@ const tick = async (
 	const logs: LogLine[] = [];
 	const result = await runSchedulerTick({
 		accountService: accounts,
-		queue,
+		queue: queue.fifo,
 		log: capturingLogger(logs),
 		tickIntervalMs: TICK_INTERVAL_MS,
 		offlineIntervalMs: OFFLINE_INTERVAL_MS,

package/src/scheduler/runner.ts

@@ -7,13 +7,8 @@ import { installNodeLogger } from "@remit/logger-lambda/node";
 import { backfillSearchText } from "@remit/mailbox-service";
 import { clearHeartbeats, createHeartbeat } from "@remit/sqs-client/heartbeat";
 
-import { emitEvent } from "../emit.js";
-import {
-	setWorkerQueues,
-	sqsWorkerQueues,
-	workerQueues,
-	workerQueueUrlsFromEnv,
-} from "../queues.js";
+import { createEmitEvent } from "../emit.js";
+import { sqsWorkerQueues, workerQueueUrlsFromEnv } from "../queues.js";
 import { buildAttachmentSweep } from "./attachment-sweep.js";
 import { buildCalendarSubscriptionRefresh } from "./calendar-subscriptions.js";
 import { getOfflineIntervalMs, getTickIntervalMs } from "./config.js";
@@ -45,7 +40,7 @@ installNodeLogger();
 
 const log = createLogger();
 
-setWorkerQueues(sqsWorkerQueues(workerQueueUrlsFromEnv()));
+const queues = sqsWorkerQueues(workerQueueUrlsFromEnv());
 
 const tickIntervalMs = getTickIntervalMs();
 const offlineIntervalMs = getOfflineIntervalMs();
@@ -97,7 +92,7 @@ const runLoop = async (): Promise<void> => {
 		tick: runSchedulerTick,
 		tickDeps: {
 			accountService: account,
-			queue: workerQueues().mailboxes,
+			queue: queues.mailboxes,
 			log,
 			tickIntervalMs,
 			offlineIntervalMs,
@@ -108,7 +103,7 @@ const runLoop = async (): Promise<void> => {
 			),
 			redriveStrandedPlacements: (stranded, now) =>
 				redriveStrandedPlacements(
-					{ client, emit: emitEvent, log },
+					{ client, emit: createEmitEvent(queues), log },
 					stranded,
 					now,
 				),

package/src/stranded-placement.sqlite.test.ts

@@ -447,6 +447,7 @@ describe("the reconcile re-drives a move or delete already stranded", () => {
 		await handleMessageMove(
 			stamped<MessageMoveEvent>(move),
 			a.w.log,
+			a.w.queues,
 			1,
 			a.w.scope,
 		);
@@ -469,6 +470,7 @@ describe("the reconcile re-drives a move or delete already stranded", () => {
 		await handlePlacementMovePush(
 			stamped<PlacementMovePushEvent>(push),
 			a.w.log,
+			a.w.queues,
 			1,
 			a.w.scope,
 		);
@@ -500,6 +502,7 @@ describe("the reconcile re-drives a move or delete already stranded", () => {
 		await handleMessageMove(
 			stamped<MessageMoveEvent>(emitted[0]),
 			a.w.log,
+			a.w.queues,
 			1,
 			a.w.scope,
 		);
@@ -520,6 +523,7 @@ describe("the reconcile re-drives a move or delete already stranded", () => {
 				messageId: a.message.messageId,
 			}),
 			a.w.log,
+			a.w.queues,
 			1,
 			a.w.scope,
 		);
@@ -645,6 +649,7 @@ describe("a uid-0 copy whose event is gone", () => {
 		await handleMessageCopy(
 			stamped<MessageCopyEvent>(copy),
 			a.w.log,
+			a.w.queues,
 			1,
 			a.w.scope,
 		);