emdash 1.0.1 → 1.2.0

package/src/database/repositories/content.ts

@@ -1,4 +1,4 @@
-import { sql, type Kysely } from "kysely";
+import { sql, type Kysely, type RawBuilder } from "kysely";
 import { ulid } from "ulidx";
 
 import type { ContentFieldFilterValue, ContentFieldFilters } from "../../content-list-query.js";
@@ -11,7 +11,7 @@ import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isMissingTableError } from "../../utils/db-errors.js";
 import { slugify } from "../../utils/slugify.js";
 import { ContentDatetimeNormalizer, type DatetimeContextCache } from "../content-datetime.js";
-import { executeAtomicBatchIfSupported } from "../dialect-helpers.js";
+import { executeAtomicBatchIfSupported, isPostgres } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { validateIdentifier } from "../validate.js";
@@ -80,7 +80,7 @@ function sameStoredValue(left: unknown, right: unknown): boolean {
 function matchesPublication(
 	observed: ContentItem,
 	existing: ContentItem,
-	revision: { data: Record<string, unknown> },
+	revisionData: Record<string, unknown>,
 	revisionId: string,
 	slug: string | null,
 	publishedAt: string,
@@ -99,7 +99,7 @@ function matchesPublication(
 		return false;
 	}
 
-	return Object.entries(revision.data).every(
+	return Object.entries(revisionData).every(
 		([key, value]) =>
 			SYSTEM_COLUMNS.has(key) || key.startsWith("_") || sameStoredValue(observed.data[key], value),
 	);
@@ -154,35 +154,42 @@ interface ResolvedOrderField {
 	indexedCustomField: boolean;
 }
 
-type IndexedOrderValue = string | number | null;
+type NullableOrderValue = string | number | null;
 
-interface IndexedFieldCursorPayload {
+interface NullableOrderCursorPayload {
 	version: 1;
 	field: string;
-	value: IndexedOrderValue;
+	value: NullableOrderValue;
 }
 
-function encodeIndexedFieldCursor(field: string, value: IndexedOrderValue, id: string): string {
-	const payload: IndexedFieldCursorPayload = { version: 1, field, value };
+function encodeNullableOrderCursor(field: string, value: NullableOrderValue, id: string): string {
+	const payload: NullableOrderCursorPayload = { version: 1, field, value };
 	return encodeCursor(JSON.stringify(payload), id);
 }
 
-function decodeIndexedFieldCursor(
+/**
+ * `acceptPlain` also accepts the plain `{ orderValue, id }` cursor that
+ * built-in and collection sort fields were paged with before, which wrote a
+ * NULL as "".
+ */
+function decodeNullableOrderCursor(
 	cursor: string,
 	field: string,
-): { value: IndexedOrderValue; id: string } {
+	{ acceptPlain = false } = {},
+): { value: NullableOrderValue; id: string } {
 	const { orderValue, id } = decodeCursor(cursor);
 	let payload: unknown;
 	try {
 		payload = JSON.parse(orderValue);
 	} catch {
-		throw new InvalidCursorError(cursor);
+		payload = undefined;
 	}
 
 	if (payload === null || typeof payload !== "object") {
+		if (acceptPlain) return { value: orderValue === "" ? null : orderValue, id };
 		throw new InvalidCursorError(cursor);
 	}
-	const candidate = payload as Partial<IndexedFieldCursorPayload>;
+	const candidate = payload as Partial<NullableOrderCursorPayload>;
 	const validValue =
 		candidate.value === null ||
 		typeof candidate.value === "string" ||
@@ -191,7 +198,34 @@ function decodeIndexedFieldCursor(
 		throw new InvalidCursorError(cursor);
 	}
 
-	return { value: candidate.value as IndexedOrderValue, id };
+	return { value: candidate.value as NullableOrderValue, id };
+}
+
+/**
+ * Keyset condition for the rows after (`value`, `cursorId`) in a sort by the
+ * nullable `column`, then `id`. The ORDER BY keeps each dialect's own NULL
+ * position, lowest on SQLite and highest on Postgres, so the condition follows
+ * it.
+ */
+function nullableOrderCondition(
+	db: Kysely<Database>,
+	column: string,
+	direction: "ASC" | "DESC",
+	value: NullableOrderValue,
+	cursorId: string,
+): RawBuilder<boolean> {
+	const sort = sql.ref(column);
+	const id = sql.ref("id");
+	const cmp = direction === "ASC" ? sql.raw(">") : sql.raw("<");
+	const nullsFirst = (direction === "ASC") !== isPostgres(db);
+	if (value === null) {
+		return nullsFirst
+			? sql<boolean>`(${sort} IS NOT NULL OR ${id} ${cmp} ${cursorId})`
+			: sql<boolean>`(${sort} IS NULL AND ${id} ${cmp} ${cursorId})`;
+	}
+	// The row value, unlike the equivalent OR, lets SQLite keep reading the index in order.
+	const past = sql<boolean>`(${sort}, ${id}) ${cmp} (${value}, ${cursorId})`;
+	return nullsFirst ? past : sql<boolean>`(${past} OR ${sort} IS NULL)`;
 }
 
 /**
@@ -224,6 +258,13 @@ const ORDER_FIELD_COLUMNS: Record<string, string> = {
 	locale: "locale",
 };
 
+/**
+ * Order columns every row has a value for. Their cursors keep the plain
+ * `{ orderValue, id }` shape; a cursor for any other order column records a
+ * NULL explicitly.
+ */
+const NON_NULL_ORDER_COLUMNS = new Set(["created_at", "updated_at", "status", "locale"]);
+
 /** True when `field` maps to a system column and needs no per-collection resolution. */
 export function isSystemOrderField(field: string): boolean {
 	return field in ORDER_FIELD_COLUMNS;
@@ -258,6 +299,16 @@ function getTableName(type: string): string {
 	return `ec_${type}`;
 }
 
+function assertPageOffset(offset: number | undefined, cursor: string | undefined): void {
+	if (offset === undefined) return;
+	if (cursor !== undefined) {
+		throw new EmDashValidationError("cursor and offset cannot be used together");
+	}
+	if (!Number.isSafeInteger(offset) || offset < 0) {
+		throw new EmDashValidationError("offset must be a non-negative integer");
+	}
+}
+
 /**
  * Serialize a value for database storage
  * Objects/arrays are JSON-stringified
@@ -796,6 +847,7 @@ export class ContentRepository {
 	): Promise<FindManyResult<ContentItem>> {
 		const tableName = getTableName(type);
 		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		assertPageOffset(options.offset, options.cursor);
 
 		// Determine ordering
 		const orderField = options.orderBy?.field || "createdAt";
@@ -806,6 +858,8 @@ export class ContentRepository {
 			options.sortableExtras,
 		);
 		const dbField = resolvedOrderField.column;
+		const nullableOrder =
+			resolvedOrderField.indexedCustomField || !NON_NULL_ORDER_COLUMNS.has(dbField);
 		const resolvedFieldFilters = await this.resolveFieldFilters(type, options.where?.fieldFilters);
 
 		// Validate order direction to prevent injection
@@ -841,15 +895,17 @@ export class ContentRepository {
 		// structured INVALID_CURSOR rather than silently returning page 1.
 		if (options.cursor) {
 			if (resolvedOrderField.indexedCustomField) {
-				const { value, id: cursorId } = decodeIndexedFieldCursor(options.cursor, orderField);
+				const { value, id: cursorId } = decodeNullableOrderCursor(options.cursor, orderField);
 				const isPresent = sql<boolean>`${sql.ref(dbField)} IS NOT NULL`;
 				const falseLiteral = sql<boolean>`FALSE`;
 				const trueLiteral = sql<boolean>`TRUE`;
 				if (safeOrderDirection === "ASC" && value === null) {
-					query = query.where(sql<boolean>`
+					// Kysely joins a raw condition to the others with a bare AND, so the
+					// OR must carry its own parentheses to stay under every filter.
+					query = query.where(sql<boolean>`(
 						(${isPresent}) > ${falseLiteral}
 						OR ((${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} > ${cursorId})
-					`);
+					)`);
 				} else if (safeOrderDirection === "DESC" && value === null) {
 					query = query.where(sql<boolean>`
 						(${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} < ${cursorId}
@@ -865,6 +921,13 @@ export class ContentRepository {
 							< (${trueLiteral}, ${value}, ${cursorId})
 					`);
 				}
+			} else if (nullableOrder) {
+				const { value, id: cursorId } = decodeNullableOrderCursor(options.cursor, orderField, {
+					acceptPlain: true,
+				});
+				query = query.where(
+					nullableOrderCondition(this.db, dbField, safeOrderDirection, value, cursorId),
+				);
 			} else {
 				const { orderValue, id: cursorId } = decodeCursor(options.cursor);
 
@@ -899,7 +962,11 @@ export class ContentRepository {
 		if (indexedOrderFilter?.kind !== "null") {
 			query = query.orderBy(dbField as any, safeOrderDirection === "ASC" ? "asc" : "desc");
 		}
-		query = query.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
+		query = query.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc");
+		query =
+			options.offset === undefined
+				? query.limit(limit + 1)
+				: query.limit(limit).offset(options.offset);
 
 		// Run the page fetch and the unbounded count together — the UI needs
 		// both to render a stable denominator (kept on every page intentionally),
@@ -928,15 +995,15 @@ export class ContentRepository {
 		if (hasMore && items.length > 0) {
 			const lastRow = items.at(-1) as Record<string, unknown>;
 			const lastOrderValue = lastRow[dbField];
-			if (resolvedOrderField.indexedCustomField) {
+			if (nullableOrder) {
 				if (
 					lastOrderValue !== null &&
 					typeof lastOrderValue !== "string" &&
 					typeof lastOrderValue !== "number"
 				) {
-					throw new EmDashValidationError(`Invalid indexed value for order field: ${orderField}`);
+					throw new EmDashValidationError(`Invalid value for order field: ${orderField}`);
 				}
-				mappedResult.nextCursor = encodeIndexedFieldCursor(
+				mappedResult.nextCursor = encodeNullableOrderCursor(
 					orderField,
 					lastOrderValue,
 					String(lastRow.id),
@@ -1642,6 +1709,7 @@ export class ContentRepository {
 	): Promise<FindManyResult<ContentItem & { deletedAt: string }>> {
 		const tableName = getTableName(type);
 		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		assertPageOffset(options.offset, options.cursor);
 
 		// Determine ordering - default to most recently deleted
 		const orderField = options.orderBy?.field || "deletedAt";
@@ -1682,8 +1750,11 @@ export class ContentRepository {
 
 		query = query
 			.orderBy(dbField as any, safeOrderDirection === "ASC" ? "asc" : "desc")
-			.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc")
-			.limit(limit + 1);
+			.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc");
+		query =
+			options.offset === undefined
+				? query.limit(limit + 1)
+				: query.limit(limit).offset(options.offset);
 
 		const rows = await query.execute();
 		const hasMore = rows.length > limit;
@@ -1873,10 +1944,10 @@ export class ContentRepository {
 		// of translation groups — at the locale the list is scoped to. Matching
 		// the locale is what keeps the filter agreeing with the list: an
 		// inferred credit renders only when the author's byline has a row at
-		// that locale (`hydrateBylinesMany` -> `findByUserIds`), and byline
-		// translations start life with a null `user_id`, so a group translated
-		// into the locale but not re-linked resolves to no credit. `locale`
-		// falls back to each entry's own when the list spans locales.
+		// that locale (`hydrateBylinesMany` -> `findByUserIds`), so a group
+		// whose translation at the locale has no linked user resolves to no
+		// credit. `locale` falls back to each entry's own when the list spans
+		// locales.
 		const authorHasByline = (eb: any, bylineIds?: string[]) => {
 			let sub = eb
 				.selectFrom("_emdash_bylines as b")
@@ -2526,6 +2597,9 @@ export class ContentRepository {
 				throw new EmDashValidationError("Revision does not belong to the specified content item");
 			}
 
+			const writableFieldSlugs = await this.datetimes.writableFieldSlugs(type);
+			const revisionData = keepKnownFields(revision.data, writableFieldSlugs);
+
 			const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
 			const intendedSlug = stagedSlug ?? existing.slug;
 			if (requireSlug && !intendedSlug?.trim()) {
@@ -2545,7 +2619,7 @@ export class ContentRepository {
 
 			const assignments: ReturnType<typeof sql>[] = [];
 			if (stagedSlug !== null) assignments.push(sql`slug = ${stagedSlug}`);
-			for (const [key, value] of Object.entries(revision.data)) {
+			for (const [key, value] of Object.entries(revisionData)) {
 				if (SYSTEM_COLUMNS.has(key) || key.startsWith("_")) continue;
 				validateIdentifier(key, "content field name");
 				assignments.push(sql`${sql.ref(key)} = ${serializeValue(value)}`);
@@ -2603,7 +2677,7 @@ export class ContentRepository {
 				promoted = matchesPublication(
 					observed,
 					existing,
-					revision,
+					revisionData,
 					revisionToPublish,
 					intendedSlug,
 					intendedPublishedAt,

package/src/database/repositories/plugin-storage.ts

@@ -36,6 +36,7 @@ import type {
 	ConditionalWriteResult,
 	ConditionalDeleteResult,
 } from "../../plugins/types.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { pluginDataWriteExpr, pluginDataUpdateGuard } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
@@ -271,18 +272,20 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	async getMany(ids: string[]): Promise<Map<string, T>> {
 		if (ids.length === 0) return new Map();
 
-		const rows = await this.db
-			.selectFrom("_plugin_storage")
-			.select(["id", "data"])
-			.where("plugin_id", "=", this.pluginId)
-			.where("collection", "=", this.collection)
-			.where("id", "in", ids)
-			.execute();
-
 		const result = new Map<string, T>();
-		for (const row of rows) {
-			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
-			result.set(row.id, JSON.parse(row.data) as T);
+		for (const batch of chunks(ids, SQL_BATCH_SIZE)) {
+			const rows = await this.db
+				.selectFrom("_plugin_storage")
+				.select(["id", "data"])
+				.where("plugin_id", "=", this.pluginId)
+				.where("collection", "=", this.collection)
+				.where("id", "in", batch)
+				.execute();
+
+			for (const row of rows) {
+				// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
+				result.set(row.id, JSON.parse(row.data) as T);
+			}
 		}
 		return result;
 	}
@@ -330,14 +333,20 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	async deleteMany(ids: string[]): Promise<number> {
 		if (ids.length === 0) return 0;
 
-		const result = await this.db
-			.deleteFrom("_plugin_storage")
-			.where("plugin_id", "=", this.pluginId)
-			.where("collection", "=", this.collection)
-			.where("id", "in", ids)
-			.executeTakeFirst();
-
-		return Number(result.numDeletedRows ?? 0);
+		return withTransaction(this.db, async (trx) => {
+			let deleted = 0;
+			for (const batch of chunks(ids, SQL_BATCH_SIZE)) {
+				const result = await trx
+					.deleteFrom("_plugin_storage")
+					.where("plugin_id", "=", this.pluginId)
+					.where("collection", "=", this.collection)
+					.where("id", "in", batch)
+					.executeTakeFirst();
+
+				deleted += Number(result.numDeletedRows ?? 0);
+			}
+			return deleted;
+		});
 	}
 
 	/**

package/src/database/repositories/redirect.ts

@@ -428,13 +428,16 @@ export class RedirectRepository {
 
 	/**
 	 * Fetch all enabled redirects (for loop detection graph building).
-	 * Not paginated — returns the full set.
+	 * Not paginated — returns the full set. Ordered oldest first: the earliest
+	 * matching pattern rule wins, so this order is match precedence.
 	 */
 	async findAllEnabled(): Promise<Redirect[]> {
 		const rows = await this.db
 			.selectFrom("_emdash_redirects")
 			.selectAll()
 			.where("enabled", "=", 1)
+			.orderBy("created_at", (order) => order.asc().nullsFirst())
+			.orderBy("id", "asc")
 			.execute();
 		return rows.map(rowToRedirect);
 	}
@@ -458,6 +461,8 @@ export class RedirectRepository {
 			.selectAll()
 			.where("enabled", "=", 1)
 			.where("is_pattern", "=", 1)
+			.orderBy("created_at", (order) => order.asc().nullsFirst())
+			.orderBy("id", "asc")
 			.execute();
 		return rows.map(rowToRedirect);
 	}
@@ -469,7 +474,11 @@ export class RedirectRepository {
 	 */
 	async matchPath(path: string): Promise<RedirectMatch | null> {
 		// 1. Exact match (fast, indexed)
-		const exact = await this.findExactMatch(path);
+		let exact = await this.findExactMatch(path);
+		if (!exact && path.length > 1) {
+			const alt = path.endsWith("/") ? path.slice(0, -1) : `${path}/`;
+			exact = await this.findExactMatch(alt);
+		}
 		if (exact && isSiteRelativeDestination(exact.destination)) {
 			return { redirect: exact, resolvedDestination: exact.destination };
 		}
@@ -633,7 +642,7 @@ export class RedirectRepository {
 	 *
 	 * This is called from the public redirect middleware on every 404 and
 	 * must never throw for an unauthenticated caller — failures bubble up to
-	 * the middleware, which swallows them.
+	 * the middleware, which catches and logs them.
 	 */
 	async log404(entry: {
 		path: string;
@@ -683,6 +692,24 @@ export class RedirectRepository {
 	 * Called by scheduled system cleanup, never by the anonymous request path.
 	 */
 	async cleanup404Log(): Promise<number> {
+		// Cheap precheck: the expensive DELETE is only needed once the table
+		// has grown past MAX_404_LOG_ROWS. Counting a bounded sample avoids
+		// the full-table ORDER BY/NOT IN scan on the overwhelming majority
+		// of cron ticks when there is nothing to evict.
+		const probe = await this.db
+			.selectFrom(
+				this.db
+					.selectFrom("_emdash_404_log")
+					.select(sql`1`.as("one"))
+					.limit(MAX_404_LOG_ROWS + 1)
+					.as("sample"),
+			)
+			.select(({ fn }) => fn.countAll<number>().as("count"))
+			.executeTakeFirstOrThrow();
+		if (Number(probe.count) <= MAX_404_LOG_ROWS) {
+			return 0;
+		}
+
 		// Keep the newest rows in one statement. Deriving the victims inside the
 		// DELETE makes overlapping cleanup runs idempotent: each statement
 		// evaluates the current newest set instead of acting on a stale count.

package/src/database/repositories/taxonomy.ts

@@ -2,6 +2,7 @@ import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateTaxonomyObjectCache } from "../../object-cache/index.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { slugify } from "../../utils/slugify.js";
 import { withTransaction } from "../transaction.js";
 import type { Database, TaxonomyTable } from "../types.js";
@@ -19,6 +20,8 @@ export interface SiblingPosition {
  * statement inside D1's 100-parameter ceiling.
  */
 const GROUPS_PER_UPDATE = 32;
+/** Rows per `content_taxonomies` insert. Each row binds three parameters. */
+const ASSIGNMENTS_PER_INSERT = 32;
 const NUMERIC_SUFFIX_PATTERN = /^\d+$/;
 
 /** Deal the listed groups back out over the slots they hold, in the order given. */
@@ -618,8 +621,8 @@ export class TaxonomyRepository {
 	}
 
 	/**
-	 * Attach already-resolved term translation groups in one insert and return
-	 * the number of assignments that did not already exist.
+	 * Attach already-resolved term translation groups and return the number of
+	 * assignments that did not already exist.
 	 */
 	async attachGroupsToEntry(
 		collection: string,
@@ -631,22 +634,60 @@ export class TaxonomyRepository {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
 
-		const result = await this.db
-			.insertInto("content_taxonomies")
-			.values(
-				uniqueGroups.map((taxonomy_id) => ({
-					collection,
-					entry_id: entryGroup,
-					taxonomy_id,
-				})),
-			)
-			.onConflict((oc) => oc.doNothing())
-			.executeTakeFirst();
-		const inserted = Number(result.numInsertedOrUpdatedRows ?? 0n);
+		const inserted = await this.insertAssignments(collection, entryGroup, uniqueGroups);
 		if (inserted > 0) invalidateTaxonomyObjectCache();
 		return inserted;
 	}
 
+	private async insertAssignments(
+		collection: string,
+		entryGroup: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		let inserted = 0;
+		try {
+			for (const batch of chunks(taxonomyGroups, ASSIGNMENTS_PER_INSERT)) {
+				// oxlint-disable-next-line no-await-in-loop -- one statement per D1-safe batch
+				const result = await this.db
+					.insertInto("content_taxonomies")
+					.values(batch.map((taxonomy_id) => ({ collection, entry_id: entryGroup, taxonomy_id })))
+					.onConflict((oc) => oc.doNothing())
+					.executeTakeFirst();
+				inserted += Number(result.numInsertedOrUpdatedRows ?? 0n);
+			}
+		} catch (error) {
+			// Earlier batches are already written.
+			if (inserted > 0) invalidateTaxonomyObjectCache();
+			throw error;
+		}
+		return inserted;
+	}
+
+	private async deleteAssignments(
+		collection: string,
+		entryGroup: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		let removed = 0;
+		try {
+			for (const batch of chunks(taxonomyGroups, SQL_BATCH_SIZE)) {
+				// oxlint-disable-next-line no-await-in-loop -- one statement per D1-safe batch
+				const result = await this.db
+					.deleteFrom("content_taxonomies")
+					.where("collection", "=", collection)
+					.where("entry_id", "=", entryGroup)
+					.where("taxonomy_id", "in", batch)
+					.executeTakeFirst();
+				removed += Number(result.numDeletedRows ?? 0n);
+			}
+		} catch (error) {
+			// Earlier batches are already deleted.
+			if (removed > 0) invalidateTaxonomyObjectCache();
+			throw error;
+		}
+		return removed;
+	}
+
 	async detachFromEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
 		const [entryGroup, taxonomyGroup] = await Promise.all([
 			this.resolveEntryTranslationGroup(collection, entryId),
@@ -674,13 +715,7 @@ export class TaxonomyRepository {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
 
-		const result = await this.db
-			.deleteFrom("content_taxonomies")
-			.where("collection", "=", collection)
-			.where("entry_id", "=", entryGroup)
-			.where("taxonomy_id", "in", uniqueGroups)
-			.executeTakeFirst();
-		const removed = Number(result.numDeletedRows ?? 0n);
+		const removed = await this.deleteAssignments(collection, entryGroup, uniqueGroups);
 		if (removed > 0) invalidateTaxonomyObjectCache();
 		return removed;
 	}
@@ -792,31 +827,13 @@ export class TaxonomyRepository {
 		const currentGroups = new Set(current.map((r) => r.group));
 
 		const toRemove = [...currentGroups].filter((g) => !newGroups.has(g));
-		if (toRemove.length > 0) {
-			await this.db
-				.deleteFrom("content_taxonomies")
-				.where("collection", "=", collection)
-				.where("entry_id", "=", entryGroup)
-				.where("taxonomy_id", "in", toRemove)
-				.execute();
-		}
-
 		const toAdd = [...newGroups].filter((g) => !currentGroups.has(g));
-		if (toAdd.length > 0) {
-			await this.db
-				.insertInto("content_taxonomies")
-				.values(
-					toAdd.map((taxonomy_id) => ({
-						collection,
-						entry_id: entryGroup,
-						taxonomy_id,
-					})),
-				)
-				.onConflict((oc) => oc.doNothing())
-				.execute();
+		try {
+			if (toRemove.length > 0) await this.deleteAssignments(collection, entryGroup, toRemove);
+			if (toAdd.length > 0) await this.insertAssignments(collection, entryGroup, toAdd);
+		} finally {
+			if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 		}
-
-		if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 	}
 
 	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
@@ -921,8 +938,6 @@ export class TaxonomyRepository {
 	async countEntriesForTerms(translationGroups: string[]): Promise<Map<string, number>> {
 		if (translationGroups.length === 0) return new Map();
 
-		const { chunks, SQL_BATCH_SIZE } = await import("../../utils/chunks.js");
-
 		const counts = new Map<string, number>();
 		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
 			const rows = await this.db

package/src/database/repositories/types.ts

@@ -223,6 +223,8 @@ export interface FindManyOptions {
 	sortableExtras?: string[];
 	limit?: number;
 	cursor?: string; // Base64-encoded JSON: {orderValue: string, id: string}
+	/** Rows to skip before the page, for numbered pages. Cannot be combined with `cursor`. */
+	offset?: number;
 }
 
 export interface FindManyResult<T> {

package/src/database/request-scoped.ts

@@ -0,0 +1,34 @@
+/**
+ * Handles returned by the adapter's `createRequestScopedDb`. Some adapters
+ * (D1 with sessions, Hyperdrive, Durable Object SQL with sessions or on
+ * writes) build a new Kysely instance for each request or event, and every
+ * one addresses the configured database, so a cache keyed by instance uses
+ * `isRequestScopedDb` to treat them as one database. A database that other
+ * code puts in the request context (playground, Durable Object preview) is
+ * not registered.
+ */
+
+import type { Kysely } from "kysely";
+
+// On globalThis so Vite SSR chunk duplication cannot split the registry
+// between the middleware that registers handles and the caches that read it.
+const REQUEST_SCOPED_DBS_KEY = Symbol.for("emdash:request-scoped-dbs");
+
+function getRegistry(): WeakSet<object> {
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern
+	const holder = globalThis as Record<symbol, WeakSet<object> | undefined>;
+	let registry = holder[REQUEST_SCOPED_DBS_KEY];
+	if (!registry) {
+		registry = new WeakSet();
+		holder[REQUEST_SCOPED_DBS_KEY] = registry;
+	}
+	return registry;
+}
+
+export function markRequestScopedDb<DB>(db: Kysely<DB>): void {
+	getRegistry().add(db);
+}
+
+export function isRequestScopedDb<DB>(db: Kysely<DB>): boolean {
+	return getRegistry().has(db);
+}

package/src/database/types.ts

@@ -808,6 +808,9 @@ export interface Database {
 	_emdash_comment_reactions: CommentReactionTable;
 	_emdash_redirects: RedirectTable;
 	_emdash_redirect_write_lock: RedirectWriteLockTable;
+	_emdash_redirect_state: RedirectStateTable;
+	_emdash_redirect_artifacts: RedirectArtifactTable;
+	_emdash_redirect_generation_artifacts: RedirectGenerationArtifactTable;
 	_emdash_404_log: NotFoundLogTable;
 	_emdash_bylines: BylineTable;
 	_emdash_content_bylines: ContentBylineTable;
@@ -872,6 +875,26 @@ export interface RedirectWriteLockTable {
 	generation: number;
 }
 
+export interface RedirectStateTable {
+	id: number;
+	revision: Generated<number>;
+	generation: string | null;
+	generation_revision: Generated<number>;
+	repair_expires_at: Generated<number>;
+}
+
+export interface RedirectArtifactTable {
+	digest: string;
+	kind: string;
+	payload: string;
+}
+
+export interface RedirectGenerationArtifactTable {
+	generation: string;
+	position: number;
+	digest: string;
+}
+
 export interface NotFoundLogTable {
 	id: string;
 	path: string;