@remit/drizzle-service 0.0.99 → 0.0.100

package/src/repos/i4-mailbox.sqlite.test.ts

@@ -5,9 +5,10 @@ import { MailboxSyncStatus } from "@remit/domain-enums";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { mailboxTable } from "../schema.js";
+import { SearchIndex } from "../search/thread-message-search.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
-	applyMigration,
+	applyMigrationSet,
 	shippedTableDdl,
 } from "../test-shipped-sqlite-schema.js";
 import { MailboxRepo } from "./i4-mailbox.js";
@@ -40,7 +41,10 @@ describe("MailboxRepo (sqlite)", () => {
 	before(async () => {
 		const testDb = await createSqliteTestDb({ mailbox: mailboxTable });
 		close = testDb.close;
-		repo = new MailboxRepo(testDb.db as never);
+		repo = new MailboxRepo(
+			testDb.db as never,
+			new SearchIndex(testDb.db as never, testDb.db as never),
+		);
 	});
 
 	after(async () => {
@@ -204,15 +208,12 @@ describe("MailboxRepo (sqlite, shipped migrations)", () => {
 
 	before(() => {
 		const sqlite = new Database(":memory:");
-		sqlite.exec(shippedTableDdl("0000_happy_roland_deschain", "mailbox"));
-		applyMigration(sqlite, "0002_highest_modseq_text");
-		applyMigration(sqlite, "0026_mailbox_sync_status_backfill");
-		applyMigration(sqlite, "0027_mailbox_sync_status_total");
-		applyMigration(sqlite, "0028_mailbox_pending_path");
-		applyMigration(sqlite, "0031_mailbox_path_unique");
-		applyMigration(sqlite, "0033_mailbox_sync_failure_reason");
+		applyMigrationSet(sqlite, "mail");
 		const db = drizzle(sqlite, { schema: { mailbox: mailboxTable } });
-		repo = new MailboxRepo(db as never);
+		repo = new MailboxRepo(
+			db as never,
+			new SearchIndex(db as never, db as never),
+		);
 		close = async () => {
 			sqlite.close();
 		};
@@ -223,10 +224,7 @@ describe("MailboxRepo (sqlite, shipped migrations)", () => {
 	});
 
 	test("declares highest_modseq as text", () => {
-		assert.match(
-			shippedTableDdl("0002_highest_modseq_text", "__new_mailbox"),
-			/`highest_modseq` text NOT NULL/,
-		);
+		assert.match(shippedTableDdl("mailbox"), /`highest_modseq` text NOT NULL/);
 	});
 
 	test("reads a plain-digit cursor back as a string", async () => {

package/src/repos/i4-mailbox.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import { eq } from "drizzle-orm";
+import { runBatch } from "../batch.js";
 import {
 	envelopeId as deriveEnvelopeId,
 	rootBodyPartId as deriveRootBodyPartId,
@@ -11,11 +12,10 @@ import {
 	mailboxSpecialUseTable,
 	mailboxTable,
 	messageTable,
-	outboxTable,
 	threadMessageTable,
 } from "../schema.js";
+import { SearchIndex } from "../search/thread-message-search.js";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
-import { runInTransaction } from "../tx.js";
 import { MailboxRepo } from "./i4-mailbox.js";
 import { DrizzleMessageRepository, deleteMessageSubtree } from "./message.js";
 import { mailboxCreated } from "./test-helpers.js";
@@ -55,7 +55,10 @@ describe("MailboxRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = new MailboxRepo(db as never);
+		repo = new MailboxRepo(
+			db as never,
+			new SearchIndex(db as never, db as never),
+		);
 	});
 
 	after(async () => {
@@ -476,9 +479,7 @@ describe("MailboxRepo", () => {
 				{
 					from: [MailboxSyncStatus.synced, MailboxSyncStatus.failed],
 					to: MailboxSyncStatus.pending,
-					rowSet: (row) => ({
-						pendingPath: row.fullPath.replace("Work", "Archive"),
-					}),
+					newPath: "Archive",
 				},
 			);
 
@@ -511,7 +512,7 @@ describe("MailboxRepo", () => {
 				{
 					from: [MailboxSyncStatus.synced],
 					to: MailboxSyncStatus.pending,
-					rowSet: (row) => ({ pendingPath: `Moved/${row.fullPath}` }),
+					newPath: "Moved/Work",
 				},
 			);
 
@@ -527,46 +528,12 @@ describe("MailboxRepo", () => {
 			);
 		});
 
-		test("the from-state predicate rides each UPDATE, not a prior read", async () => {
-			// A read-then-check-then-write version passes the case above and still
-			// misses a row that leaves an accepted state after the read. The
-			// predicate is on the UPDATE, so the affected-row count catches it.
-			const accountId = randomId();
-			const { parent, child } = await seedSubtree(accountId);
-
-			const refused = await repo.transitionSubtree(
-				accountId,
-				parent.mailboxId,
-				{
-					from: [MailboxSyncStatus.synced],
-					to: MailboxSyncStatus.pending,
-					rowSet: (row) => {
-						if (row.mailboxId === parent.mailboxId) {
-							// Not a real concurrent writer — the shape of one. The row
-							// leaves `synced` after the subtree was resolved.
-							db.update(mailboxTable)
-								.set({ syncStatus: MailboxSyncStatus.deleting })
-								.where(eq(mailboxTable.mailboxId, child.mailboxId))
-								.run();
-						}
-						return { pendingPath: row.fullPath };
-					},
-				},
-			);
-
-			assert.equal(refused, null);
-			assert.equal(
-				(await repo.get(accountId, parent.mailboxId)).syncStatus,
-				MailboxSyncStatus.synced,
-			);
-		});
-
 		test("an absent folder is a null", async () => {
 			assert.equal(
 				await repo.transitionSubtree(randomId(), "no-such-mailbox", {
 					from: EVERY_STATE,
 					to: MailboxSyncStatus.pending,
-					rowSet: () => ({}),
+					newPath: "Anywhere",
 				}),
 				null,
 			);
@@ -576,7 +543,10 @@ describe("MailboxRepo", () => {
 	describe("deleteMailboxWithMail — the folder's mail goes with it (D8)", () => {
 		const seedMessage = async (mailboxId: string, uid: number) => {
 			const messageId = randomId();
-			await new DrizzleMessageRepository(db as never).create({
+			await new DrizzleMessageRepository(
+				db as never,
+				new SearchIndex(db as never, db as never),
+			).create({
 				messageId,
 				mailboxId,
 				uid,
@@ -606,9 +576,6 @@ describe("MailboxRepo", () => {
 			return messageId;
 		};
 
-		const outboxEventsFor = async (messageId: string) =>
-			db.select().from(outboxTable).where(eq(outboxTable.messageId, messageId));
-
 		test("removes the folder, its mail and its own child rows, and nothing else's", async () => {
 			const accountId = randomId();
 			const doomed = mailboxCreated(
@@ -617,8 +584,8 @@ describe("MailboxRepo", () => {
 			const spared = mailboxCreated(
 				await repo.create(makeMailboxInput(accountId, "Keep")),
 			);
-			const doomedMessage = await seedMessage(doomed.mailboxId, 1);
-			const sparedMessage = await seedMessage(spared.mailboxId, 1);
+			await seedMessage(doomed.mailboxId, 1);
+			await seedMessage(spared.mailboxId, 1);
 			await db.insert(mailboxSpecialUseTable).values({
 				mailboxSpecialUseId: randomId(),
 				mailboxId: doomed.mailboxId,
@@ -653,24 +620,11 @@ describe("MailboxRepo", () => {
 				[],
 			);
 
-			// The search index is cleared by the outbox row, not by the delete.
-			const removals = await outboxEventsFor(doomedMessage);
-			assert.deepEqual(
-				removals.map((row) => row.event),
-				["message.removed"],
-			);
-
 			const survivors = await db
 				.select()
 				.from(messageTable)
 				.where(eq(messageTable.mailboxId, spared.mailboxId));
 			assert.equal(survivors.length, 1);
-			assert.equal(
-				(await outboxEventsFor(sparedMessage)).some(
-					(row) => row.event === "message.removed",
-				),
-				false,
-			);
 			assert.equal(
 				(await repo.get(accountId, spared.mailboxId)).mailboxId,
 				spared.mailboxId,
@@ -692,6 +646,7 @@ describe("MailboxRepo", () => {
 				accountConfigId: accountId,
 				name: "Invoices → Bound",
 				scope: "Standing",
+				literalClauses: [{ field: "Subject", value: "invoice" }],
 				ruleChangedAt: 0,
 				actionChangedAt: 0,
 				actionMailboxId: mailbox.mailboxId,
@@ -719,7 +674,7 @@ describe("MailboxRepo", () => {
 
 			// The shape an interruption leaves: one message's rows already gone,
 			// the mailbox row still there and still `deleting`.
-			await runInTransaction(db, (tx) => deleteMessageSubtree(tx, [first]));
+			await runBatch(db, deleteMessageSubtree(db, [first]));
 			await repo.transition(accountId, mailbox.mailboxId, {
 				from: EVERY_STATE,
 				to: MailboxSyncStatus.deleting,

package/src/repos/i4-mailbox.ts

@@ -12,8 +12,22 @@ import type {
 	UpdateMailboxInput,
 } from "@remit/data-ports";
 import { MailboxCursorState } from "@remit/domain-enums";
-import { and, asc, eq, gt, inArray, isNull, or, type SQL } from "drizzle-orm";
+import {
+	and,
+	asc,
+	eq,
+	exists,
+	gt,
+	inArray,
+	isNull,
+	not,
+	notInArray,
+	or,
+	type SQL,
+	sql,
+} from "drizzle-orm";
 import shortUuid from "short-uuid";
+import { runBatch } from "../batch.js";
 import type { Db } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { decodeToken, resultList } from "../pagination.js";
@@ -27,8 +41,9 @@ import { mailboxLockTable } from "../schema/i4-mailbox-lock.js";
 import { messageFlagPushTable } from "../schema/i4-message-flag-push.js";
 import { messagePlacementMoveTable } from "../schema/i4-message-placement-move.js";
 import { messageTable } from "../schema/message-data.js";
+import { syncWarningTable } from "../schema/sync-warning.js";
 import { threadMessageTable } from "../schema/thread-message.js";
-import { runInTransaction } from "../tx.js";
+import type { SearchIndex } from "../search/thread-message-search.js";
 import { deleteMessageSubtree } from "./message.js";
 
 const base36Translator = shortUuid.createTranslator(
@@ -39,20 +54,24 @@ const generateMailboxId = () => base36Translator.fromUUID(randomUUID());
 type DB = Db<Record<string, unknown>>;
 
 /**
- * Message subtrees removed per transaction by {@link MailboxRepo.deleteMailboxWithMail},
+ * Message subtrees removed per batch by {@link MailboxRepo.deleteMailboxWithMail},
  * matching `SUBTREE_BATCH_SIZE` in the account purge. On SQLite each batch holds
- * the process's only write slot, so the bound is what keeps a large folder's
- * delete from parking every other writer behind it (D8).
+ * the file's write lock, so the bound is what keeps a large folder's delete from
+ * parking every other writer behind it (D8).
  */
 const MAIL_DELETE_BATCH_SIZE = 100;
 
-/** Refuses a subtree intent from inside the transaction, so the throw is the rollback. */
-class SubtreeContested extends Error {
-	constructor() {
-		super("mailbox subtree transition contested");
-		this.name = "SubtreeContested";
-	}
-}
+/**
+ * The folders under `path`. A flat namespace nests nothing: with no delimiter
+ * the prefix is the folder's own path, which would match every sibling
+ * starting with it. Lengths are SQL's, so a path is measured the way `substr`
+ * cuts it, in characters rather than UTF-16 units.
+ */
+const descendantOf = (path: string, delimiter: string): SQL => {
+	if (delimiter.length === 0) return sql`0`;
+	const prefix = `${path}${delimiter}`;
+	return sql`substr(${mailboxTable.fullPath}, 1, length(${prefix})) = ${prefix}`;
+};
 
 /** The WHERE terms of a folder-state transition (folder-rename-and-delete.md D3). */
 const stateTerms = (expected: MailboxStatePredicate): SQL[] => {
@@ -129,7 +148,10 @@ export function rowToMailbox(
 }
 
 export class MailboxRepo implements IMailboxRepository {
-	constructor(private db: DB) {}
+	constructor(
+		private db: DB,
+		private search: SearchIndex,
+	) {}
 
 	async create(input: CreateMailboxInput): Promise<CreateMailboxResult> {
 		const now = Date.now();
@@ -291,55 +313,55 @@ export class MailboxRepo implements IMailboxRepository {
 		mailboxId: string,
 		intent: MailboxSubtreeTransitionIntent,
 	): Promise<MailboxItem[] | null> {
-		return runInTransaction(this.db, async (tx) => {
-			const repo = new MailboxRepo(tx);
-			const root = await repo
-				.get(accountId, mailboxId)
-				.catch((error: unknown) => {
-					if (error instanceof NotFoundError) return null;
-					throw error;
-				});
-			if (!root) return null;
-
-			const subtree = [
-				root,
-				...(await repo.findByPathPrefix(
-					accountId,
-					root.fullPath,
-					root.hierarchyDelimiter,
-				)),
-			];
-
-			const written: MailboxItem[] = [];
-			for (const row of subtree) {
-				// The from-state predicate rides each UPDATE rather than a read
-				// taken before them (D3). Read-then-check-then-write is safe on
-				// SQLite only because `runInTransaction` serializes top-level
-				// writes; under Postgres READ COMMITTED a single-row transition
-				// committing in between is missed entirely.
-				const [updated] = await tx
-					.update(mailboxTable)
-					.set(transitionSet(intent.to, intent.rowSet(row)))
-					.where(
-						and(
-							eq(mailboxTable.accountId, accountId),
-							eq(mailboxTable.mailboxId, row.mailboxId),
-							inArray(mailboxTable.syncStatus, [...intent.from]),
-						),
-					)
-					.returning();
-				if (updated) written.push(rowToMailbox(updated));
-			}
+		const root = await this.get(accountId, mailboxId).catch(
+			(error: unknown) => {
+				if (error instanceof NotFoundError) return null;
+				throw error;
+			},
+		);
+		if (!root) return null;
+
+		const inSubtree = and(
+			eq(mailboxTable.accountId, accountId),
+			or(
+				eq(mailboxTable.mailboxId, root.mailboxId),
+				descendantOf(root.fullPath, root.hierarchyDelimiter),
+			),
+		);
 
-			// A subtree cannot be half-renamed: one row that moved out from under
-			// this call refuses the whole intent, and the throw is what rolls the
-			// rest back.
-			if (written.length !== subtree.length) throw new SubtreeContested();
-			return written;
-		}).catch((error: unknown) => {
-			if (error instanceof SubtreeContested) return null;
-			throw error;
-		});
+		// One statement, so a subtree is never half-renamed: every row takes its
+		// rebased target together, and only while none of them is outside a
+		// from-state. Lengths are SQL's, counted the way `substr` counts.
+		const written = await this.db
+			.update(mailboxTable)
+			.set({
+				...transitionSet(intent.to, undefined),
+				pendingPath: sql`${intent.newPath} || substr(${mailboxTable.fullPath}, length(${root.fullPath}) + 1)`,
+			})
+			.where(
+				and(
+					inSubtree,
+					not(
+						exists(
+							this.db
+								.select({ mailboxId: mailboxTable.mailboxId })
+								.from(mailboxTable)
+								.where(
+									and(
+										inSubtree,
+										notInArray(mailboxTable.syncStatus, [...intent.from]),
+									),
+								),
+						),
+					),
+				),
+			)
+			.returning();
+		if (written.length === 0) return null;
+		return [
+			...written.filter((row) => row.mailboxId === root.mailboxId),
+			...written.filter((row) => row.mailboxId !== root.mailboxId),
+		].map(rowToMailbox);
 	}
 
 	async resolveAccountId(mailboxId: string): Promise<string | null> {
@@ -351,26 +373,29 @@ export class MailboxRepo implements IMailboxRepository {
 	}
 
 	async delete(accountId: string, mailboxId: string): Promise<void> {
-		await this.db
-			.delete(mailboxTable)
-			.where(
-				and(
-					eq(mailboxTable.accountId, accountId),
-					eq(mailboxTable.mailboxId, mailboxId),
-				),
-			);
+		await this.deleteMany(accountId, [mailboxId]);
 	}
 
 	async deleteMany(accountId: string, mailboxIds: string[]): Promise<void> {
 		if (mailboxIds.length === 0) return;
-		await this.db
-			.delete(mailboxTable)
-			.where(
-				and(
-					eq(mailboxTable.accountId, accountId),
-					inArray(mailboxTable.mailboxId, mailboxIds),
+		await runBatch(this.db, [
+			this.db
+				.delete(syncWarningTable)
+				.where(
+					and(
+						eq(syncWarningTable.accountId, accountId),
+						inArray(syncWarningTable.mailboxId, mailboxIds),
+					),
 				),
-			);
+			this.db
+				.delete(mailboxTable)
+				.where(
+					and(
+						eq(mailboxTable.accountId, accountId),
+						inArray(mailboxTable.mailboxId, mailboxIds),
+					),
+				),
+		]);
 	}
 
 	async listByAccount(
@@ -465,17 +490,16 @@ export class MailboxRepo implements IMailboxRepository {
 		pathPrefix: string,
 		delimiter = "/",
 	): Promise<MailboxItem[]> {
-		// A flat namespace nests nothing: with no delimiter the prefix is the
-		// folder’s own path, which would match every sibling starting with it.
-		if (delimiter.length === 0) return [];
 		const rows = await this.db
 			.select()
 			.from(mailboxTable)
-			.where(eq(mailboxTable.accountId, accountId));
-		const fullPrefix = `${pathPrefix}${delimiter}`;
-		return rows
-			.filter((r) => r.fullPath.startsWith(fullPrefix))
-			.map(rowToMailbox);
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					descendantOf(pathPrefix, delimiter),
+				),
+			);
+		return rows.map(rowToMailbox);
 	}
 
 	async findBySyncStatus(
@@ -524,17 +548,20 @@ export class MailboxRepo implements IMailboxRepository {
 				.limit(MAIL_DELETE_BATCH_SIZE);
 			if (rows.length === 0) break;
 			const messageIds = rows.map((row) => row.messageId);
-
-			await runInTransaction(this.db, async (tx) => {
-				// The primitive the rest of the codebase deletes mail with: nine
-				// per-message child tables plus one `message.removed` outbox row
-				// each, which is what clears the search index. A bespoke table
-				// list would orphan those nine and leave deleted mail searchable.
-				await deleteMessageSubtree(tx, messageIds);
-				await tx
+			const listings = await this.db
+				.select({ threadMessageId: threadMessageTable.threadMessageId })
+				.from(threadMessageTable)
+				.where(inArray(threadMessageTable.messageId, messageIds));
+
+			// The primitive the rest of the codebase deletes mail with: nine
+			// per-message child tables. A bespoke table list would orphan them.
+			await runBatch(this.db, [
+				...deleteMessageSubtree(this.db, messageIds),
+				this.db
 					.delete(threadMessageTable)
-					.where(inArray(threadMessageTable.messageId, messageIds));
-			});
+					.where(inArray(threadMessageTable.messageId, messageIds)),
+			]);
+			await this.search.sync(listings.map((row) => row.threadMessageId));
 		}
 
 		await this.db

package/src/repos/i4-organize-job-request.ts

@@ -23,11 +23,9 @@ function rowToItem(
 		userId: row.userId,
 		state: row.state as OrganizeJobRequestItem["state"],
 		filterId: row.filterId,
-		anchorMessageId: row.anchorMessageId,
 		matchOperator: row.matchOperator as OrganizeJobRequestItem["matchOperator"],
 		literalClauses:
 			row.literalClauses as OrganizeJobRequestItem["literalClauses"],
-		similarityThreshold: row.similarityThreshold,
 		actionLabelId: row.actionLabelId,
 		actionMailboxId: row.actionMailboxId,
 		matchedCount: row.matchedCount,
@@ -55,10 +53,8 @@ export class OrganizeJobRequestRepo implements IOrganizeJobRequestRepository {
 				userId: input.userId,
 				state: input.state ?? "Pending",
 				filterId: input.filterId,
-				anchorMessageId: input.anchorMessageId,
 				matchOperator: input.matchOperator,
 				literalClauses: input.literalClauses,
-				similarityThreshold: input.similarityThreshold,
 				actionLabelId: input.actionLabelId,
 				actionMailboxId: input.actionMailboxId,
 				matchedCount: 0,

package/src/repos/i4-outbox-attachment.ts

@@ -6,11 +6,11 @@ import type {
 	ReserveOutboxAttachmentResult,
 } from "@remit/data-ports";
 import { holdsRoom } from "@remit/data-ports";
-import { and, eq, inArray, lt } from "drizzle-orm";
+import { and, eq, gt, gte, inArray, lt, or, sum } from "drizzle-orm";
+import { runBatch } from "../batch.js";
 import type { Db } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { outboxAttachmentTable } from "../schema/i4-outbox-attachment.js";
-import { runInTransaction } from "../tx.js";
 
 type DB = Db<Record<string, unknown>>;
 
@@ -37,40 +37,30 @@ export class OutboxAttachmentRepo implements IOutboxAttachmentRepository {
 	constructor(private db: DB) {}
 
 	/**
-	 * The per-message cap: the count and the insert are one transaction, on the
-	 * transaction's own handle, so a concurrent reservation cannot land between
-	 * them. See the port's contract for the invariant this owes its callers and
-	 * what an adapter on another engine has to do to keep it.
+	 * The per-message cap. The insert, the read of the draft's live rows and a
+	 * delete of the new row when it breaks the cap run as one batch, which
+	 * commits as a unit and serializes against every other batch. Of two
+	 * concurrent reservations the later one sees the earlier one's row, so it
+	 * is the one removed when the two together do not fit.
 	 */
 	async reserve(
 		input: CreateOutboxAttachmentInput,
 		cap: OutboxAttachmentCap,
 	): Promise<ReserveOutboxAttachmentResult> {
-		return runInTransaction(this.db, async (tx) => {
-			const existing = await tx
-				.select()
-				.from(outboxAttachmentTable)
-				.where(
-					and(
-						eq(outboxAttachmentTable.accountConfigId, input.accountConfigId),
-						eq(outboxAttachmentTable.outboxMessageId, input.outboxMessageId),
-					),
-				);
-
-			const live = existing
-				.map(rowToOutboxAttachment)
-				.filter((item) => holdsRoom(item, cap.nowSeconds));
-			const usedBytes = live.reduce((total, item) => total + item.sizeBytes, 0);
-
-			if (live.length >= cap.maxCount) {
-				return { outcome: "OverCountCap", usedBytes };
-			}
-			if (usedBytes + input.sizeBytes > cap.maxTotalBytes) {
-				return { outcome: "OverByteCap", usedBytes };
-			}
-
-			const now = Date.now();
-			const [row] = await tx
+		const now = Date.now();
+		const draft = and(
+			eq(outboxAttachmentTable.accountConfigId, input.accountConfigId),
+			eq(outboxAttachmentTable.outboxMessageId, input.outboxMessageId),
+		);
+		const live = and(
+			draft,
+			or(
+				eq(outboxAttachmentTable.state, "Stored"),
+				gte(outboxAttachmentTable.reservationExpiresAt, cap.nowSeconds),
+			),
+		);
+		const [inserted, rows, removed] = await runBatch(this.db, [
+			this.db
 				.insert(outboxAttachmentTable)
 				.values({
 					outboxAttachmentId: input.outboxAttachmentId,
@@ -86,10 +76,49 @@ export class OutboxAttachmentRepo implements IOutboxAttachmentRepository {
 					createdAt: now,
 					updatedAt: now,
 				})
-				.returning();
+				.returning(),
+			this.db.select().from(outboxAttachmentTable).where(draft),
+			this.db
+				.delete(outboxAttachmentTable)
+				.where(
+					and(
+						eq(
+							outboxAttachmentTable.outboxAttachmentId,
+							input.outboxAttachmentId,
+						),
+						or(
+							gt(this.db.$count(outboxAttachmentTable, live), cap.maxCount),
+							gt(
+								this.db
+									.select({ total: sum(outboxAttachmentTable.sizeBytes) })
+									.from(outboxAttachmentTable)
+									.where(live),
+								cap.maxTotalBytes,
+							),
+						),
+					),
+				)
+				.returning({
+					outboxAttachmentId: outboxAttachmentTable.outboxAttachmentId,
+				}),
+		] as const);
 
+		const others = rows
+			.map(rowToOutboxAttachment)
+			.filter(
+				(item) =>
+					item.outboxAttachmentId !== input.outboxAttachmentId &&
+					holdsRoom(item, cap.nowSeconds),
+			);
+		const usedBytes = others.reduce((total, item) => total + item.sizeBytes, 0);
+		const [row] = inserted;
+		if (removed.length === 0 && row) {
 			return { outcome: "Reserved", item: rowToOutboxAttachment(row) };
-		});
+		}
+		if (others.length >= cap.maxCount) {
+			return { outcome: "OverCountCap", usedBytes };
+		}
+		return { outcome: "OverByteCap", usedBytes };
 	}
 
 	async get(