@remit/account-worker 0.0.26 → 0.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/account-worker",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -33,6 +33,7 @@
     "dev": "node --import tsx src/poller.ts"
   },
   "dependencies": {
+    "@remit/logger": "*",
     "@remit/data-ports": "*",
     "@remit/logger-lambda": "*",
     "@remit/drizzle-service": "*",
@@ -40,7 +41,6 @@
     "@remit/sqs-client": "*",
     "@remit/storage-service": "*",
     "@remit/electrodb-entities": "*",
-    "@remit/search-index-worker": "*",
     "@aws-sdk/client-sqs": "*",
     "archiver": "*",
     "electrodb": "*",

package/src/cascade-enumerate.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { MessageDescription } from "@remit/data-ports";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import {
 	type CascadeEntity,
 	type CascadeServices,
@@ -18,11 +18,10 @@ const messageWithChildren = {
 	bodyPartParameter: [{ bodyPartParameterId: "bpp-1" }],
 	rawMessageStorage: [{ rawStorageId: "rms-1" }],
 	bodyPartStorage: [{ bodyPartStorageId: "bps-1" }],
-	bodyPartContent: [{ bodyPartContentId: "bpc-1" }],
 } as unknown as MessageDescription;
 
 describe("collectMessageChildEntities", () => {
-	it("expands the nine child entities of one message", () => {
+	it("expands the eight child entities of one message", () => {
 		const entities: CascadeEntity[] = [];
 		collectMessageChildEntities(entities, messageWithChildren);
 
@@ -36,13 +35,7 @@ describe("collectMessageChildEntities", () => {
 			"BodyPartParameter",
 			"RawMessageStorage",
 			"BodyPartStorage",
-			"BodyPartContent",
 		]);
-		assert.equal(
-			entities.find((e) => e.entityType === "BodyPartContent")?.key
-				.bodyPartContentId,
-			"bpc-1",
-		);
 	});
 
 	it("appends nothing when every child list is empty", () => {
@@ -56,7 +49,6 @@ describe("collectMessageChildEntities", () => {
 			bodyPartParameter: [],
 			rawMessageStorage: [],
 			bodyPartStorage: [],
-			bodyPartContent: [],
 		} as unknown as MessageDescription);
 		assert.equal(entities.length, 0);
 	});
@@ -96,13 +88,7 @@ const fullServices = (): CascadeServices =>
 			listByAccountConfig: async () => [{ accountSettingId: "set-1" }],
 		},
 		filterService: {
-			listByAccountConfig: async () => [
-				{ filterId: "flt-1", hasAnchor: true },
-				{ filterId: "flt-2", hasAnchor: false },
-			],
-		},
-		filterAnchorService: {
-			get: async () => ({ filterId: "flt-1" }),
+			listByAccountConfig: async () => [{ filterId: "flt-1" }],
 		},
 		labelService: {
 			listByAccountConfig: async () => [{ labelId: "lbl-1" }],
@@ -128,7 +114,6 @@ describe("enumerateCascadeEntities", () => {
 			"Mailbox",
 			"Message",
 			"MessageFlag",
-			"BodyPartContent",
 			"OutboxMessage",
 			"MailboxLock",
 			"MessagePlacementMove",
@@ -136,7 +121,6 @@ describe("enumerateCascadeEntities", () => {
 			"ThreadMessage",
 			"AccountSetting",
 			"Filter",
-			"FilterAnchor",
 			"Label",
 			"MessageLabel",
 			"Address",
@@ -148,40 +132,6 @@ describe("enumerateCascadeEntities", () => {
 		assert.equal(types[types.length - 1], "AccountConfig");
 	});
 
-	it("emits a Filter without a FilterAnchor when the filter has no anchor", async () => {
-		const services = fullServices();
-		services.filterService.listByAccountConfig = async () =>
-			[{ filterId: "flt-2", hasAnchor: false }] as never;
-
-		const { entities } = await enumerateCascadeEntities(
-			"cfg-1",
-			services,
-			noopLogger,
-		);
-
-		assert.equal(entities.filter((e) => e.entityType === "Filter").length, 1);
-		assert.equal(
-			entities.filter((e) => e.entityType === "FilterAnchor").length,
-			0,
-		);
-	});
-
-	it("skips the FilterAnchor when the anchor lookup returns null", async () => {
-		const services = fullServices();
-		services.filterAnchorService.get = async () => null as never;
-
-		const { entities } = await enumerateCascadeEntities(
-			"cfg-1",
-			services,
-			noopLogger,
-		);
-
-		assert.equal(
-			entities.filter((e) => e.entityType === "FilterAnchor").length,
-			0,
-		);
-	});
-
 	it("yields only the AccountConfig row for an empty tenant", async () => {
 		const services = fullServices();
 		services.accountConfigService.describe = async () =>

package/src/cascade.ts

@@ -5,7 +5,6 @@ import type {
 	IAccountSettingRepository,
 	IAddressRepository,
 	IEnvelopeRepository,
-	IFilterAnchorRepository,
 	IFilterRepository,
 	ILabelRepository,
 	IMailboxLockRepository,
@@ -19,7 +18,7 @@ import type {
 	IThreadMessageRepository,
 	MessageDescription,
 } from "@remit/data-ports";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 
 export interface CascadeEntity {
 	entityType: string;
@@ -42,7 +41,6 @@ export interface CascadeServices {
 	accountExportRequestService: IAccountExportRequestRepository;
 	accountSettingService: IAccountSettingRepository;
 	filterService: IFilterRepository;
-	filterAnchorService: IFilterAnchorRepository;
 	labelService: ILabelRepository;
 	messageLabelService: IMessageLabelRepository;
 }
@@ -111,12 +109,6 @@ export const collectMessageChildEntities = (
 			key: { bodyPartStorageId: bps.bodyPartStorageId },
 		});
 	}
-	for (const bpc of messageData.bodyPartContent) {
-		entities.push({
-			entityType: "BodyPartContent",
-			key: { bodyPartContentId: bpc.bodyPartContentId },
-		});
-	}
 };
 
 export const enumerateCascadeEntities = async (
@@ -138,7 +130,6 @@ export const enumerateCascadeEntities = async (
 		messageFlagPushService,
 		accountSettingService,
 		filterService,
-		filterAnchorService,
 		labelService,
 		messageLabelService,
 	} = services;
@@ -225,13 +216,6 @@ export const enumerateCascadeEntities = async (
 						key: { bodyPartStorageId: bps.bodyPartStorageId },
 					});
 				}
-
-				for (const bpc of messageData.bodyPartContent) {
-					entities.push({
-						entityType: "BodyPartContent",
-						key: { bodyPartContentId: bpc.bodyPartContentId },
-					});
-				}
 			}
 		}
 
@@ -292,7 +276,7 @@ export const enumerateCascadeEntities = async (
 		});
 	}
 
-	// Filter/FilterAnchor/Label/MessageLabel are accountConfig-scoped (RFC 034),
+	// Filter/Label/MessageLabel are accountConfig-scoped (RFC 034),
 	// not per sub-account, so — like AccountSetting and ThreadMessage above —
 	// they are enumerated once here rather than inside the per-account loop.
 	const filters = await filterService.listByAccountConfig(accountConfigId);
@@ -301,16 +285,6 @@ export const enumerateCascadeEntities = async (
 			entityType: "Filter",
 			key: { accountConfigId, filterId: filter.filterId },
 		});
-		if (!filter.hasAnchor) continue;
-		const anchor = await filterAnchorService.get(
-			accountConfigId,
-			filter.filterId,
-		);
-		if (!anchor) continue;
-		entities.push({
-			entityType: "FilterAnchor",
-			key: { accountConfigId, filterId: filter.filterId },
-		});
 	}
 
 	const labels = await labelService.listByAccountConfig(accountConfigId);
@@ -354,30 +328,3 @@ export const enumerateCascadeEntities = async (
 
 	return { entities, messageIds };
 };
-
-export const COVERED_ENTITY_TYPES = [
-	"Account",
-	"AccountConfig",
-	"AccountSetting",
-	"Address",
-	"BodyPart",
-	"BodyPartContent",
-	"BodyPartParameter",
-	"BodyPartStorage",
-	"Envelope",
-	"EnvelopeAddress",
-	"Filter",
-	"FilterAnchor",
-	"Label",
-	"Mailbox",
-	"MailboxLock",
-	"Message",
-	"MessageFlag",
-	"MessageFlagPush",
-	"MessageLabel",
-	"MessagePlacementMove",
-	"MessageReference",
-	"OutboxMessage",
-	"RawMessageStorage",
-	"ThreadMessage",
-] as const;

package/src/compose-relational.test.ts

@@ -3,7 +3,7 @@ import { mkdir, mkdtemp, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import { buildRelationalDeletionCapabilities } from "./compose-relational.js";
 
 const exists = (path: string): Promise<boolean> =>
@@ -79,16 +79,3 @@ describe("relational deletion capabilities — filesystem storage cleanup", () =
 		await caps.deleteStoragePrefix("accounts/never-existed/", noopLogger);
 	});
 });
-
-describe("relational deletion capabilities — CDN and sign-out are no-ops", () => {
-	it("invalidateContent resolves without a CDN", async () => {
-		const caps = buildRelationalDeletionCapabilities();
-		await caps.invalidateContent("cfg-1", noopLogger);
-		await caps.invalidateContent("cfg-1/acc-1", noopLogger);
-	});
-
-	it("signOut resolves without a federated session store", async () => {
-		const caps = buildRelationalDeletionCapabilities();
-		await caps.signOut("user-123", noopLogger);
-	});
-});

package/src/compose-relational.ts

@@ -3,9 +3,9 @@ import { join } from "node:path";
 import {
 	type CascadeDeleter,
 	createSqliteCascadeDeleter,
+	sqliteDatabasePathsFromEnv,
 } from "@remit/drizzle-service";
-import type { Logger } from "@remit/logger-lambda";
-import { env } from "expect-env";
+import type { Logger } from "@remit/logger";
 import type { DeletionCapabilities } from "./deletion-capabilities.js";
 
 // Mirrors `@remit/storage-service`'s filesystem-backend default: bodies
@@ -30,14 +30,14 @@ const deleteStoragePrefix = async (
 };
 
 // The Drizzle cascade deleter is opened once, on first use, and reused: it
-// opens the shared file at `SQLITE_DB_PATH` (the native binding loads there,
+// opens the app, mail and search databases (the native binding loads there,
 // hence async). Built lazily so the fanout worker — which signs out but never
 // cascade-deletes — does not open a database handle it will not use.
 let deleterPromise: Promise<CascadeDeleter> | undefined;
 
 const getDeleter = (): Promise<CascadeDeleter> => {
 	if (!deleterPromise)
-		deleterPromise = createSqliteCascadeDeleter(env.SQLITE_DB_PATH);
+		deleterPromise = createSqliteCascadeDeleter(sqliteDatabasePathsFromEnv());
 	return deleterPromise;
 };
 
@@ -52,8 +52,7 @@ const getDeleter = (): Promise<CascadeDeleter> => {
  *   backend with no response cache (`deploy/vps/caddy/routes.caddy`), so there
  *   is nothing to invalidate.
  * - `deleteStoragePrefix`: recursive filesystem removal.
- * - `cascadeDelete`: the Drizzle cascade over SQLite. Message
- *   subtrees emit `message.removed` outbox rows the search-index worker relays.
+ * - `cascadeDelete`: the Drizzle cascade over SQLite.
  */
 export const buildRelationalDeletionCapabilities =
 	(): DeletionCapabilities => ({

package/src/config.test.ts

@@ -51,9 +51,4 @@ describe("getImapWorkerQueueUrl", () => {
 		delete process.env.SQS_QUEUE_URL_IMAP_WORKER;
 		assert.equal(getImapWorkerQueueUrl(), undefined);
 	});
-
-	it("returns the configured value when set", () => {
-		process.env.SQS_QUEUE_URL_IMAP_WORKER = "http://queue/imap-worker";
-		assert.equal(getImapWorkerQueueUrl(), "http://queue/imap-worker");
-	});
 });

package/src/config.ts

@@ -26,8 +26,6 @@ export const getSqsClient = (queueUrl: string): SQSClient => {
 // no queue, so its Lambda doesn't carry the env vars. Eager evaluation here would
 // crash finalize at module load — getters defer the read to the fanout-only call
 // sites.
-export const getSearchIndexQueueUrl = (): string =>
-	env.SQS_QUEUE_URL_SEARCH_INDEX;
 // Optional, and read through `process.env` rather than expect-env so an unset
 // var yields undefined instead of throwing. IMAP_WORKER_STOP is a no-op
 // acknowledgement in the cascade contract — the account tombstone fence is what
@@ -48,7 +46,7 @@ let cascadeServicesPromise: Promise<CascadeServices> | null = null;
 
 // Every cascade service is a `RemitClient` repository, so the whole enumeration
 // runs on whatever backend `getClient()` resolved — DynamoDB (ElectroDB) or
-// SQLite (Drizzle). Filter/FilterAnchor/Label/MessageLabel (Smart Organize,
+// SQLite (Drizzle). Filter/Label/MessageLabel (Smart Organize,
 // RFC 034) are present on both via the client, so they need no
 // backend-specific wiring here.
 export const getCascadeServices = (): Promise<CascadeServices> => {
@@ -69,7 +67,6 @@ export const getCascadeServices = (): Promise<CascadeServices> => {
 			accountExportRequestService: remitClient.accountExportRequest,
 			accountSettingService: remitClient.accountSetting,
 			filterService: remitClient.filter,
-			filterAnchorService: remitClient.filterAnchor,
 			labelService: remitClient.label,
 			messageLabelService: remitClient.messageLabel,
 		}));
@@ -84,5 +81,3 @@ export const getStorageService = (): StorageService => {
 	}
 	return storageService;
 };
-
-export const dataBackend = process.env.DATA_BACKEND;

package/src/deletion-capabilities.ts

@@ -1,4 +1,4 @@
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { CascadeEntity } from "./cascade.js";
 
 /**
@@ -71,7 +71,7 @@ export const setDeletionCapabilities = (
 const buildDeletionCapabilitiesFromEnv =
 	async (): Promise<DeletionCapabilities> => {
 		if (injectedCapabilities) return injectedCapabilities;
-		if (process.env.SQLITE_DB_PATH) {
+		if (process.env.SQLITE_APP_DB_PATH) {
 			const { buildRelationalDeletionCapabilities } = await import(
 				"./compose-relational.js"
 			);

package/src/events.ts

@@ -9,7 +9,7 @@ export type AccountDeleteEvent = {
 
 /**
  * Per-account hard-delete. Purges ONE mail account's data (mailboxes,
- * messages, body parts, thread messages, S3 objects, search vectors) while
+ * messages, body parts, thread messages, S3 objects) while
  * keeping the AccountConfig/tenant and any sibling accounts intact. Emitted
  * by the API on `deleteAccount`; consumed by the fanout worker.
  */

package/src/handlers/account-export.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { Readable } from "node:stream";
 import { describe, it } from "node:test";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { StorageService } from "@remit/storage-service";
 import type { CascadeServices } from "../cascade.js";
 import type { AccountExportEvent } from "../events.js";

package/src/handlers/account-export.ts

@@ -1,5 +1,5 @@
 import { PassThrough } from "node:stream";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { StorageService } from "@remit/storage-service";
 import { ZipArchive } from "archiver";
 import type { CascadeServices } from "../cascade.js";

package/src/handlers/account-fanout.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { afterEach, describe, it } from "node:test";
 import type { SQSClient } from "@aws-sdk/client-sqs";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import type { AccountDeleteEvent } from "../events.js";
 import { processAccountFanout } from "./account-fanout.js";
@@ -32,7 +32,6 @@ const buildServices = (): CascadeServices =>
 		threadMessageService: { listAllByAccount: async () => [] },
 		accountSettingService: { listByAccountConfig: async () => [] },
 		filterService: { listByAccountConfig: async () => [] },
-		filterAnchorService: { get: async () => null },
 		labelService: { listByAccountConfig: async () => [] },
 		messageLabelService: { listByLabelId: async () => [] },
 	}) as unknown as CascadeServices;

package/src/handlers/account-fanout.ts

@@ -1,11 +1,10 @@
 import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import { createLogger, type Logger } from "@remit/logger";
 import {
-	createLogger,
-	type Logger,
 	queueNameFromEventSource,
 	recordQueueEvent,
-	withTelemetry,
-} from "@remit/logger-lambda";
+} from "@remit/logger-lambda/metrics";
+import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { SQSBatchResponse, SQSEvent, SQSHandler } from "aws-lambda";
 import type { CascadeServices } from "../cascade.js";
 import { enumerateCascadeEntities } from "../cascade.js";
@@ -30,6 +29,8 @@ import { processAccountDataPurge } from "./account-purge.js";
 import { processOrganizeJob } from "./organize-job.js";
 import { processSenderCategoryBackApply } from "./sender-category-backapply.js";
 
+installNodeLogger();
+
 export interface ProcessAccountFanoutDeps {
 	services?: CascadeServices;
 	sqs?: SQSClient;
@@ -41,8 +42,8 @@ export interface ProcessAccountFanoutDeps {
 
 /**
  * Fanout step of the account-deletion cascade. Read-only: enumerates the
- * AccountConfig's data and dispatches downstream work — search-index
- * deletes, per-account imap-worker stops, a sign-out, and the finalize
+ * AccountConfig's data and dispatches downstream work — per-account
+ * imap-worker stops, a sign-out, and the finalize
  * enqueue. Throws on any non-swallowable error so SQS partial batch-failure
  * retries the whole record.
  */

package/src/handlers/account-finalize.ts

@@ -1,11 +1,10 @@
 import { inspect } from "node:util";
+import { createLogger, type Logger } from "@remit/logger";
 import {
-	createLogger,
-	type Logger,
 	queueNameFromEventSource,
 	recordQueueEvent,
-	withTelemetry,
-} from "@remit/logger-lambda";
+} from "@remit/logger-lambda/metrics";
+import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { SQSEvent, SQSHandler } from "aws-lambda";
 import {
 	type CascadeEntity,
@@ -24,6 +23,8 @@ import type {
 	AccountFinalizeEvent,
 } from "../events.js";
 
+installNodeLogger();
+
 export interface ProcessFinalizeDeps {
 	capabilities?: DeletionCapabilities;
 	cascadeServices?: CascadeServices;
@@ -131,10 +132,7 @@ export const processAccountFinalize = async (
  * the work; this worker only ever consumes.
  *
  * Idempotency: the cascade on a missing key is a no-op, so a redelivered batch
- * (or container) no-ops on already-gone rows. Search-index cleanup is not driven
- * from here: on DynamoDB the fanout step enqueues a REMOVE per message id up
- * front; on the relational backends the cascade emits a `message.removed` outbox
- * row the search-index worker relays.
+ * (or container) no-ops on already-gone rows.
  */
 export const processAccountDataPurgeFinalize = async (
 	event: AccountDataPurgeFinalizeEvent,

package/src/handlers/account-purge.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { SQSClient } from "@aws-sdk/client-sqs";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import type { AccountDataPurgeEvent } from "../events.js";
 import {
@@ -12,28 +12,19 @@ import {
 interface Sent {
 	queueUrl: string | undefined;
 	body: Record<string, unknown>;
-	entries?: Array<{ Id: string; MessageBody: string }>;
 }
 
-const recordingSqs = (sent: Sent[], failBatch = false): SQSClient =>
+const recordingSqs = (sent: Sent[]): SQSClient =>
 	({
 		send: async (command: {
-			input: {
-				QueueUrl?: string;
-				MessageBody?: string;
-				Entries?: Array<{ Id: string; MessageBody: string }>;
-			};
+			input: { QueueUrl?: string; MessageBody?: string };
 		}) => {
 			sent.push({
 				queueUrl: command.input.QueueUrl,
 				body: command.input.MessageBody
 					? JSON.parse(command.input.MessageBody)
 					: {},
-				entries: command.input.Entries,
 			});
-			if (command.input.Entries && failBatch) {
-				return { Failed: [{ Id: "0" }] };
-			}
 			return {};
 		},
 	}) as unknown as SQSClient;
@@ -73,19 +64,14 @@ const baseDeps = (
 	]),
 	sqs: recordingSqs(sent),
 	accountPurgeDeleteQueueUrl: "http://queue/purge",
-	searchIndexQueueUrl: "http://queue/search",
-	dataBackend: "dynamodb",
 	...overrides,
 });
 
 describe("processAccountDataPurge", () => {
-	it("enqueues vector deletes then a subtrees batch and one container leftover", async () => {
+	it("enqueues a subtrees batch and one container leftover", async () => {
 		const sent: Sent[] = [];
 		await processAccountDataPurge(event, noopLogger, baseDeps(sent));
 
-		const vectorBatch = sent.find((m) => m.queueUrl === "http://queue/search");
-		assert.equal(vectorBatch?.entries?.length, 2, "one entry per message");
-
 		const finalize = sent.filter((m) => m.queueUrl === "http://queue/purge");
 		const kinds = finalize.map((m) => m.body.kind);
 		assert.deepEqual(kinds, ["subtrees", "container"]);
@@ -96,27 +82,6 @@ describe("processAccountDataPurge", () => {
 		);
 	});
 
-	it("skips vector deletes on the relational backend, still enqueuing finalize", async () => {
-		const sent: Sent[] = [];
-		await processAccountDataPurge(
-			event,
-			noopLogger,
-			baseDeps(sent, { dataBackend: "sqlite" }),
-		);
-
-		assert.equal(
-			sent.some((m) => m.queueUrl === "http://queue/search"),
-			false,
-			"no search-index enqueue on the relational backend",
-		);
-		assert.deepEqual(
-			sent
-				.filter((m) => m.queueUrl === "http://queue/purge")
-				.map((m) => m.body.kind),
-			["subtrees", "container"],
-		);
-	});
-
 	it("drops manifest rows outside the account's mailbox set", async () => {
 		const sent: Sent[] = [];
 		await processAccountDataPurge(event, noopLogger, {
@@ -167,15 +132,4 @@ describe("processAccountDataPurge", () => {
 			/dynamo throttled/,
 		);
 	});
-
-	it("throws when a vector-delete batch reports failed entries", async () => {
-		const sent: Sent[] = [];
-		await assert.rejects(
-			processAccountDataPurge(event, noopLogger, {
-				...baseDeps(sent),
-				sqs: recordingSqs(sent, true),
-			}),
-			/failed entries/,
-		);
-	});
 });

package/src/handlers/account-purge.ts

@@ -1,19 +1,9 @@
-import { randomUUID } from "node:crypto";
-import {
-	SendMessageBatchCommand,
-	SendMessageCommand,
-	type SQSClient,
-} from "@aws-sdk/client-sqs";
-import { Message } from "@remit/electrodb-entities";
-import type { Logger } from "@remit/logger-lambda";
-import type { SearchIndexMessage } from "@remit/search-index-worker";
-import { Entity } from "electrodb";
+import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import type { Logger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import {
-	dataBackend as defaultDataBackend,
 	getAccountPurgeDeleteQueueUrl,
 	getCascadeServices,
-	getSearchIndexQueueUrl,
 	getSqsClient,
 } from "../config.js";
 import type {
@@ -26,12 +16,8 @@ export interface ProcessPurgeFanoutDeps {
 	services?: CascadeServices;
 	sqs?: SQSClient;
 	accountPurgeDeleteQueueUrl?: string;
-	searchIndexQueueUrl?: string;
-	dataBackend?: string;
 }
 
-const SQS_BATCH_SIZE = 10;
-
 /**
  * Message subtrees carried per FIFO finalize message. Each item is two ids
  * (~70 bytes of JSON), so 100 stays far under the 256 KB SQS limit, and the
@@ -40,59 +26,6 @@ const SQS_BATCH_SIZE = 10;
  */
 const SUBTREE_BATCH_SIZE = 100;
 
-const messageEntity = new Entity(Message, { table: "purge-keys" });
-
-const messageKeys = (messageId: string): { pk: string; sk: string } => {
-	const { Key } = messageEntity.delete({ messageId }).params<{
-		Key: { pk: string; sk: string };
-	}>();
-	return Key;
-};
-
-const buildVectorDeleteEvent = (
-	accountId: string,
-	messageId: string,
-): SearchIndexMessage => ({
-	eventName: "REMOVE",
-	entity: "Message",
-	eventID: randomUUID(),
-	eventTimestamp: Date.now(),
-	accountId,
-	keys: messageKeys(messageId),
-	messageId,
-});
-
-const enqueueVectorDeletes = async (
-	sqs: SQSClient,
-	queueUrl: string,
-	accountId: string,
-	messageIds: string[],
-): Promise<void> => {
-	for (let i = 0; i < messageIds.length; i += SQS_BATCH_SIZE) {
-		const batch = messageIds.slice(i, i + SQS_BATCH_SIZE);
-		const result = await sqs.send(
-			new SendMessageBatchCommand({
-				QueueUrl: queueUrl,
-				Entries: batch.map((messageId, idx) => ({
-					Id: `${i + idx}`,
-					MessageBody: JSON.stringify(
-						buildVectorDeleteEvent(accountId, messageId),
-					),
-				})),
-			}),
-		);
-		// SendMessageBatch returns HTTP 200 with per-entry failures in `Failed`;
-		// throw so the failed deletes surface to the DLQ and the whole fanout
-		// replays idempotently rather than silently skipping vector deletes.
-		if (result.Failed?.length) {
-			const failedIds = result.Failed.map((f) => f.Id).join(", ");
-			throw new Error(
-				`Search-index vector-delete batch had ${result.Failed.length} failed entries: ${failedIds}`,
-			);
-		}
-	}
-};
-
 /**
  * Enqueue the destructive purge work onto the FIFO finalize queue, single
  * message group per account so the worker processes everything strictly in
@@ -141,9 +74,8 @@ const enqueuePurgeFinalize = async (
  * manifest (`pk = accountConfigId`, scoped to this account's mailbox set) —
  * since the threading-visibility fix every persisted Message has exactly one
  * manifest row, so the partition is a complete, describe-free index of the
- * account's messages. Enqueues the per-message search-index (vector) deletes
- * (#457), then hands the destructive DDB+S3+CloudFront work to the finalize
- * worker as a stream of FIFO messages (subtree batches + one container
+ * account's messages. Hands the destructive DDB+S3+CloudFront work to the
+ * finalize worker as a stream of FIFO messages (subtree batches + one container
  * leftover, single message group). No self-loop, no recursion: the producer
  * enqueues all the work and the worker only ever consumes (#1069).
  *
@@ -151,8 +83,8 @@ const enqueuePurgeFinalize = async (
  * its sibling accounts, the tenant-shared Address rows, and the soft-deleted
  * account row are untouched.
  *
- * Replay-safe: the manifest read is read-only and the search-index/finalize
- * enqueues are idempotent. A redelivery after the account's rows are gone reads
+ * Replay-safe: the manifest read is read-only and the finalize enqueues are
+ * idempotent. A redelivery after the account's rows are gone reads
  * an empty manifest and enqueues only a container leftover that no-ops.
  */
 export const processAccountDataPurge = async (
@@ -162,13 +94,8 @@ export const processAccountDataPurge = async (
 ): Promise<void> => {
 	const { accountId, accountConfigId } = event;
 	const services = deps.services ?? (await getCascadeServices());
-	const sqsFor = (queueUrl: string): SQSClient =>
-		deps.sqs ?? getSqsClient(queueUrl);
 	const accountPurgeDeleteQueueUrl =
 		deps.accountPurgeDeleteQueueUrl ?? getAccountPurgeDeleteQueueUrl();
-	const searchIndexQueueUrl =
-		deps.searchIndexQueueUrl ?? getSearchIndexQueueUrl();
-	const dataBackend = deps.dataBackend ?? defaultDataBackend;
 
 	let mailboxIds: Set<string>;
 	try {
@@ -194,27 +121,8 @@ export const processAccountDataPurge = async (
 			messageId: tm.messageId,
 		}));
 
-	const messageIds = [...new Set(items.map((i) => i.messageId))];
-
-	// On the relational backend the destructive delete emits a `message.removed`
-	// outbox row per message, which the search-index worker relays as a
-	// search-index REMOVE; enqueuing here too would double the removal. On
-	// DynamoDB this fanout is the sole producer of the vector deletes (#457).
-	if (dataBackend !== "sqlite") {
-		await enqueueVectorDeletes(
-			sqsFor(searchIndexQueueUrl),
-			searchIndexQueueUrl,
-			accountId,
-			messageIds,
-		);
-		log.info(
-			{ accountConfigId, accountId, count: messageIds.length },
-			"Enqueued search-index deletes for purged account",
-		);
-	}
-
 	await enqueuePurgeFinalize(
-		sqsFor(accountPurgeDeleteQueueUrl),
+		deps.sqs ?? getSqsClient(accountPurgeDeleteQueueUrl),
 		accountPurgeDeleteQueueUrl,
 		accountId,
 		accountConfigId,

package/src/handlers/organize-job.test.ts

@@ -1,18 +1,19 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { afterEach, describe, it } from "node:test";
 import type { RemitClient } from "@remit/backend/client";
 import {
 	buildOrganizeMatchDeps,
 	type OrganizeMatchDeps,
-	type OrganizeSemanticDeps,
 } from "@remit/backend/organize";
-import type { FilterAnchorItem, FilterItem } from "@remit/data-ports";
+import type { FilterItem } from "@remit/data-ports";
 import { NotFoundError } from "@remit/data-ports/errors";
-import { DrizzleThreadMessageRepository } from "@remit/drizzle-service";
+import {
+	DrizzleThreadMessageRepository,
+	SearchIndex,
+} from "@remit/drizzle-service";
 import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { OrganizeJobEvent } from "../events.js";
 import {
 	type ProcessOrganizeJobDeps,
@@ -43,10 +44,8 @@ const jobClient = (
 				organizeJobId: "job-1",
 				accountConfigId: "cfg-1",
 				filterId: "None",
-				anchorMessageId: "None",
 				matchOperator: "And",
 				literalClauses,
-				similarityThreshold: 0.75,
 				actionLabelId: "lbl-1",
 				actionMailboxId: "None",
 			}),
@@ -63,20 +62,10 @@ const jobClient = (
  */
 const explodingMatchDeps = (): OrganizeMatchDeps =>
 	({
-		semantic: () => {
-			throw new Error("the vector pipeline must not be reached");
-		},
 		listAccountFilterMessages: async () => {
 			throw new Error("SQLITE_BUSY");
 		},
-		filterAnchors: {
-			get: async () => null,
-			listByAccountConfig: async () => [],
-			put: async () => {
-				throw new Error("unreachable");
-			},
-		},
-	}) as unknown as OrganizeMatchDeps;
+	}) as OrganizeMatchDeps;
 
 describe("processOrganizeJob (reader #463)", () => {
 	it("fails the job on a refused rule and acknowledges the record", async () => {
@@ -136,7 +125,6 @@ const standingFilter = (over: Partial<FilterItem> = {}): FilterItem => ({
 	scope: "Standing",
 	state: "Active",
 	disabledReason: "None",
-	hasAnchor: false,
 	ruleChangedAt: 1,
 	actionChangedAt: 1,
 	matchOperator: "And",
@@ -187,28 +175,21 @@ interface World {
 	inbox: string;
 	archive: string;
 	updates: Update[];
+	filterUpdates: Array<{ filterId: string; patch: Record<string, unknown> }>;
 	moves: Move[];
 	labeled: string[];
 	close: () => void;
 }
 
-const world = async (
-	filters: FilterItem[],
-	anchors: FilterAnchorItem[] = [],
-): Promise<World> => {
+const world = async (filters: FilterItem[]): Promise<World> => {
 	const store = createShippedSqliteDb();
-	store.sqlite.exec(
-		readFileSync(
-			new URL(
-				"../../../../npm-scripts/sqlite-search-index.sql",
-				import.meta.url,
-			),
-			"utf8",
-		),
+	const threadMessage = new DrizzleThreadMessageRepository(
+		store.db as never,
+		new SearchIndex(store.db as never, store.db as never),
 	);
-	const threadMessage = new DrizzleThreadMessageRepository(store.db as never);
 	const { inbox, archive } = await seedThreads(threadMessage);
 	const updates: Update[] = [];
+	const filterUpdates: World["filterUpdates"] = [];
 	const labeled: string[] = [];
 	const mailboxOf: Record<string, string> = {
 		[inbox]: INBOX,
@@ -221,10 +202,8 @@ const world = async (
 				organizeJobId: "job-1",
 				accountConfigId: CONFIG,
 				filterId: "flt-1",
-				anchorMessageId: "None",
 				matchOperator: "And",
 				literalClauses: [],
-				similarityThreshold: 0.75,
 				actionLabelId: "None",
 				actionMailboxId: "None",
 			}),
@@ -241,13 +220,21 @@ const world = async (
 			refreshExpiry: async (filter: FilterItem) => filter,
 			listByAccountAndState: async (_cfg: string, state: string) =>
 				filters.filter((f) => f.state === state),
-		},
-		filterAnchor: {
-			get: async (_cfg: string, filterId: string) =>
-				anchors.find((anchor) => anchor.filterId === filterId) ?? null,
+			update: async (
+				_cfg: string,
+				filterId: string,
+				patch: Record<string, unknown>,
+			) => {
+				filterUpdates.push({ filterId, patch });
+				return {};
+			},
 		},
 		account: {
 			listMailSourcesByAccountConfig: async () => [{ accountId: "acct-1" }],
+			get: async (accountId: string) => ({
+				accountId,
+				email: accountId === "acct-1" ? "me@example.com" : "me-too@example.com",
+			}),
 		},
 		mailboxSpecialUse: {
 			findInboxMailbox: async () => ({ mailboxId: INBOX, fullPath: "INBOX" }),
@@ -258,7 +245,18 @@ const world = async (
 				mailboxId: mailboxOf[messageId],
 			}),
 		},
-		mailbox: { resolveAccountId: async () => "acct-1" },
+		mailbox: {
+			resolveAccountId: async (mailboxId: string) =>
+				mailboxId === "mbx-gone"
+					? null
+					: mailboxId === "mbx-sibling-travel"
+						? "acct-2"
+						: "acct-1",
+			get: async (_accountId: string, mailboxId: string) => ({
+				mailboxId,
+				fullPath: mailboxId === "mbx-sibling-travel" ? "Travel" : "Invoices",
+			}),
+		},
 		messageLabel: {
 			apply: async (input: { messageId: string }) => {
 				labeled.push(input.messageId);
@@ -271,6 +269,7 @@ const world = async (
 		inbox,
 		archive,
 		updates,
+		filterUpdates,
 		moves: [],
 		labeled,
 		close: store.close,
@@ -295,50 +294,6 @@ const runFilterJob = (w: World) =>
 		moveService: recordingMoves(w.moves),
 	});
 
-const EMBEDDING_ID = "test-model@4";
-const ANCHOR_VECTOR = [1, 0, 0, 0];
-const ORTHOGONAL_VECTOR = [0, 1, 0, 0];
-
-const persistedAnchor: FilterAnchorItem = {
-	filterId: "flt-1",
-	accountConfigId: CONFIG,
-	anchorMessageId: "msg-anchor",
-	anchorEmbedding: ANCHOR_VECTOR,
-	anchorEmbeddingId: EMBEDDING_ID,
-	anchorSourceText: "Your invoice",
-	createdAt: 0,
-	updatedAt: 0,
-};
-
-/**
- * The vector index answers the anchor with the inbox invoice, and only when
- * asked about the inbox: the kNN read is where a similarity filter finds its
- * candidates.
- */
-const vectorMatchDeps = (w: World): OrganizeMatchDeps => ({
-	...buildOrganizeMatchDeps(w.client),
-	semantic: () => ({
-		buildAnchor: async () => {
-			throw new Error("a filter widens on its persisted anchor");
-		},
-		vectorStore: {
-			query: async (query: { filter?: { mailboxId?: string } }) =>
-				query.filter?.mailboxId === INBOX
-					? [
-							{
-								chunkId: `${w.inbox}#body`,
-								score: 0.9,
-								metadata: { messageId: w.inbox, mailboxIds: [INBOX] },
-							},
-						]
-					: [],
-			getByMessage: async () => [],
-		} as unknown as OrganizeSemanticDeps["vectorStore"],
-		embed: async () => ANCHOR_VECTOR,
-		embeddingId: EMBEDDING_ID,
-	}),
-});
-
 describe("processOrganizeJob for a filter job (#1354)", () => {
 	let current: World | undefined;
 	afterEach(() => current?.close());
@@ -390,6 +345,42 @@ describe("processOrganizeJob for a filter job (#1354)", () => {
 		assert.equal(current.updates.at(-1)?.state, "Complete");
 	});
 
+	it("skips another account's mail, as if the filter had not matched", async () => {
+		current = await world([
+			standingFilter({
+				actionLabelId: "lbl-trips",
+				actionMailboxId: "mbx-sibling-travel",
+			}),
+		]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.deepEqual(current.labeled, []);
+		assert.deepEqual(current.filterUpdates, []);
+		const done = current.updates.at(-1);
+		assert.equal(done?.state, "Complete");
+		assert.equal(done?.appliedCount, 0);
+		assert.equal(done?.failedCount, 0);
+	});
+
+	it("turns the filter off and fails the job when no account holds its folder", async () => {
+		current = await world([standingFilter({ actionMailboxId: "mbx-gone" })]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.deepEqual(current.filterUpdates, [
+			{
+				filterId: "flt-1",
+				patch: { state: "Disabled", disabledReason: "FolderMissing" },
+			},
+		]);
+		const done = current.updates.at(-1);
+		assert.equal(done?.state, "Failed");
+		assert.match(String(done?.errorMessage), /no longer exists/);
+	});
+
 	it("fails the job without a retry when the filter is turned off", async () => {
 		current = await world([
 			standingFilter({ state: "Disabled", disabledReason: "UserDisabled" }),
@@ -410,32 +401,4 @@ describe("processOrganizeJob for a filter job (#1354)", () => {
 		assert.equal(current.updates.at(-1)?.state, "Failed");
 		assert.match(String(current.updates.at(-1)?.errorMessage), /deleted/);
 	});
-
-	it("moves a message the vector query found, though the preview scores below the threshold", async () => {
-		current = await world(
-			[standingFilter({ hasAnchor: true, literalClauses: [] })],
-			[persistedAnchor],
-		);
-
-		// The index-time evaluator embeds subject and preview; this embedder puts
-		// that text orthogonal to the anchor, so evaluate alone would call the
-		// message a miss. It only orders the move, so the vector match stands.
-		await processOrganizeJob(event, noopLogger, {
-			client: current.client,
-			matchDeps: vectorMatchDeps(current),
-			moveService: recordingMoves(current.moves),
-			embedder: {
-				embed: async () => ORTHOGONAL_VECTOR,
-				embeddingId: EMBEDDING_ID,
-			},
-		});
-
-		assert.deepEqual(current.moves, [
-			{ messageId: current.inbox, destinationMailboxId: "mbx-invoices" },
-		]);
-		const done = current.updates.at(-1);
-		assert.equal(done?.state, "Complete");
-		assert.equal(done?.matchedCount, 1);
-		assert.equal(done?.appliedCount, 1);
-	});
 });

package/src/handlers/organize-job.ts

@@ -5,7 +5,6 @@ import {
 	backApplyFilter,
 	buildOrganizeMatchDeps,
 	buildOrganizeMoveService,
-	type FilterBackApplyDeps,
 	isFilterJob,
 	matchOrganize,
 	ORGANIZE_MATCH_LIMIT,
@@ -13,14 +12,13 @@ import {
 	type OrganizeRejection,
 	predicateFromJob,
 } from "@remit/backend/organize";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { OrganizeJobEvent } from "../events.js";
 
 export interface ProcessOrganizeJobDeps {
 	client?: RemitClient;
 	matchDeps?: OrganizeMatchDeps;
 	moveService?: ApplyOrganizeDeps["moveService"];
-	embedder?: FilterBackApplyDeps["embedder"];
 }
 
 interface OrganizeOutcome {
@@ -28,7 +26,7 @@ interface OrganizeOutcome {
 	matched: number;
 	applied: number;
 	failed: number;
-	semanticUnavailable: boolean;
+	failures: string[];
 }
 
 const rejectedOutcome = (rejected: OrganizeRejection): OrganizeOutcome => ({
@@ -36,7 +34,7 @@ const rejectedOutcome = (rejected: OrganizeRejection): OrganizeOutcome => ({
 	matched: 0,
 	applied: 0,
 	failed: 0,
-	semanticUnavailable: false,
+	failures: [],
 });
 
 /**
@@ -57,7 +55,7 @@ const runSnapshot = async (
 		ORGANIZE_MATCH_LIMIT,
 	);
 	if (match.rejected) return rejectedOutcome(match.rejected);
-	const { applied, failed } = await applyOrganize(
+	const { applied, failed, failures } = await applyOrganize(
 		{ client, moveService },
 		job.accountConfigId,
 		match.messageIds,
@@ -68,7 +66,7 @@ const runSnapshot = async (
 		matched: match.messageIds.length,
 		applied,
 		failed,
-		semanticUnavailable: match.semanticUnavailable,
+		failures,
 	};
 };
 
@@ -81,7 +79,7 @@ const runSnapshot = async (
  *
  * Reuses the shared matcher (so the applied set equals what preview returned)
  * and the idempotent apply plumbing; `appliedByFilterId` is never written and no
- * Filter/FilterAnchor row is ever created. Both back-apply actions run here: the
+ * Filter row is ever created. Both back-apply actions run here: the
  * additive label upsert and the exclusive folder move, the latter through the
  * same local-first placement mover body sync uses (`buildOrganizeMoveService`),
  * so a redelivered job re-applies both idempotently.
@@ -114,7 +112,7 @@ export const processOrganizeJob = async (
 		const moveService = deps.moveService ?? buildOrganizeMoveService(client);
 		const outcome = isFilterJob(job)
 			? await backApplyFilter(
-					{ client, matchDeps, moveService, embedder: deps.embedder },
+					{ client, matchDeps, moveService },
 					accountConfigId,
 					job.filterId,
 				).then((result) =>
@@ -137,12 +135,13 @@ export const processOrganizeJob = async (
 			return;
 		}
 
-		const { matched, applied, failed, semanticUnavailable } = outcome;
+		const { matched, applied, failed, failures } = outcome;
 		await client.organizeJobRequest.update(organizeJobId, {
 			state: "Complete",
 			matchedCount: matched,
 			appliedCount: applied,
 			failedCount: failed,
+			errorMessage: failures[0] ?? "",
 		});
 		log.info(
 			{
@@ -152,7 +151,6 @@ export const processOrganizeJob = async (
 				matched,
 				applied,
 				failed,
-				semanticUnavailable,
 			},
 			"Organize back-apply complete",
 		);

package/src/handlers/sender-category-backapply.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { RemitClient } from "@remit/backend/client";
 import { NotFoundError } from "@remit/data-ports/errors";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { SenderCategoryBackApplyEvent } from "../events.js";
 import { processSenderCategoryBackApply } from "./sender-category-backapply.js";
 

package/src/handlers/sender-category-backapply.ts

@@ -4,7 +4,7 @@ import {
 	SENDER_CATEGORY_BACKAPPLY_LIMIT,
 } from "@remit/backend/sender-category";
 import { NotFoundError } from "@remit/data-ports/errors";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { SenderCategoryBackApplyEvent } from "../events.js";
 
 export interface ProcessSenderCategoryBackApplyDeps {

package/src/poller.ts

@@ -1,8 +1,12 @@
-import { createLogger, startMetricsServer } from "@remit/logger-lambda";
+import { createLogger } from "@remit/logger";
+import { startMetricsServer } from "@remit/logger-lambda/metrics";
+import { installNodeLogger } from "@remit/logger-lambda/node";
 import { runQueuePoller } from "@remit/sqs-client/poller";
 import { env } from "expect-env";
 import { fanoutHandler, finalizeHandler } from "./index.js";
 
+installNodeLogger();
+
 /**
  * Production queue poller, and the standalone entrypoint for the dedicated
  * image. The sibling workers carry a separate `e2e-processor-shim.ts` because

package/src/cascade.test.ts

@@ -1,77 +0,0 @@
-import assert from "node:assert";
-import { existsSync, readdirSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, it } from "node:test";
-import { COVERED_ENTITY_TYPES } from "./cascade.js";
-
-// The snapshot enumerates electrodb-service's models; that package is stripped
-// from the open-core tree, so the check skips there and runs where it ships.
-const modelsDir = resolve(
-	import.meta.dirname,
-	"../../remit-electrodb-service/src/models",
-);
-
-describe("cascade entity coverage snapshot", () => {
-	it("covers every entity model in remit-electrodb-service", {
-		skip: !existsSync(modelsDir),
-	}, () => {
-		const modelFiles = readdirSync(modelsDir)
-			.filter(
-				(f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && f !== "index.ts",
-			)
-			.map((f) => f.replace(".ts", ""));
-
-		// Map model file names to the entity types they contain
-		const entityTypesByFile: Record<string, string[]> = {
-			"account-config": ["AccountConfig"],
-			"account-export-request": [],
-			"account-setting": ["AccountSetting"],
-			"account-setting-registry": [],
-			account: ["Account"],
-			address: ["Address", "EnvelopeAddress"],
-			envelope: [
-				"Envelope",
-				"MessageReference",
-				"BodyPart",
-				"BodyPartParameter",
-				"RawMessageStorage",
-				"BodyPartStorage",
-				"BodyPartContent",
-			],
-			filter: ["Filter"],
-			"filter-anchor": ["FilterAnchor"],
-			label: ["Label"],
-			mailbox: ["Mailbox"],
-			"mailbox-lock": ["MailboxLock"],
-			"mailbox-special-use": [],
-			message: ["Message"],
-			"message-flag": ["MessageFlag"],
-			"message-flag-push": ["MessageFlagPush"],
-			"message-label": ["MessageLabel"],
-			"message-placement-move": ["MessagePlacementMove"],
-			"organize-job-request": [],
-			"outbox-message": ["OutboxMessage"],
-			"thread-message": ["ThreadMessage"],
-			"wellknown-rule": [],
-		};
-
-		const allEntityTypes = Object.values(entityTypesByFile).flat().sort();
-		const coveredSorted = [...COVERED_ENTITY_TYPES].sort();
-
-		assert.deepStrictEqual(
-			coveredSorted,
-			allEntityTypes,
-			`Cascade does not cover all entity types.\n` +
-				`Missing: ${allEntityTypes.filter((t) => !(coveredSorted as readonly string[]).includes(t)).join(", ")}\n` +
-				`Extra: ${(coveredSorted as readonly string[]).filter((t) => !allEntityTypes.includes(t)).join(", ")}`,
-		);
-
-		// Verify all model files are accounted for
-		const unmappedFiles = modelFiles.filter((f) => !(f in entityTypesByFile));
-		assert.deepStrictEqual(
-			unmappedFiles,
-			[],
-			`Model files not mapped to entity types: ${unmappedFiles.join(", ")}`,
-		);
-	});
-});