emdash 0.29.0 → 0.31.0

package/src/database/repositories/content.ts

@@ -590,11 +590,16 @@ export class ContentRepository {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
 
-		// Build update object with parameterized values
-		const updates: Record<string, unknown> = {
-			updated_at: now,
-			version: sql`version + 1`,
-		};
+		// Build update object with parameterized values. `version` bumps on
+		// every update so the _rev optimistic-concurrency token
+		// (version:updated_at) always moves — concurrent editors still get a
+		// 409 on stale saves. `updated_at` is stamped only when the request
+		// actually carries column writes: a draft-only save on a
+		// revision-supporting collection resolves to a column no-op here (all
+		// data went into draft storage), and stamping it anyway would register
+		// a phantom modification for public "last modified" consumers like
+		// sitemap <lastmod> and JSON-LD dateModified (#2143).
+		const updates: Record<string, unknown> = {};
 
 		if (input.status !== undefined) {
 			updates.status = input.status;
@@ -630,6 +635,12 @@ export class ContentRepository {
 			}
 		}
 
+		const hasColumnWrites = Object.keys(updates).length > 0;
+		if (hasColumnWrites) {
+			updates.updated_at = now;
+		}
+		updates.version = sql`version + 1`;
+
 		await this.db
 			.updateTable(tableName as keyof Database)
 			.set(updates)
@@ -637,6 +648,18 @@ export class ContentRepository {
 			.where("deleted_at" as never, "is", null)
 			.execute();
 
+		// Re-stamp the taxonomy pivot only when a denormalized column actually
+		// moved (status/publishedAt/scheduledAt). A plain content edit bumps
+		// `updated_at` — which is not denormalized — so it needs no pivot write,
+		// keeping the common edit path free of taxonomy write amplification.
+		if (
+			input.status !== undefined ||
+			input.publishedAt !== undefined ||
+			input.scheduledAt !== undefined
+		) {
+			await this.restampEntryPivot(type, id);
+		}
+
 		invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
@@ -662,7 +685,10 @@ export class ContentRepository {
 		`.execute(this.db);
 
 		const changed = (result.numAffectedRows ?? 0n) > 0n;
-		if (changed) invalidateCollectionCache(type);
+		if (changed) {
+			await this.restampEntryPivot(type, id);
+			invalidateCollectionCache(type);
+		}
 		return changed;
 	}
 
@@ -683,10 +709,36 @@ export class ContentRepository {
 		const restored = result.rows[0];
 		if (!restored) return null;
 
+		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 		return this.mapRow(type, restored);
 	}
 
+	/**
+	 * Re-stamp the denormalized filter + sort columns on every
+	 * `content_taxonomies` pivot row for an entry from its authoritative `ec_*`
+	 * row (migration 051). Called after any mutation that moves one of those
+	 * columns so a taxonomy-filtered listing can seek the entry directly.
+	 *
+	 * A single correlated `UPDATE` reads the post-mutation values from `ec_*`, so
+	 * the pivot converges to the authoritative row. This is NOT atomic with the
+	 * `ec_*` mutation on D1 (no transactions), which is why the read path
+	 * re-checks the real predicates on the joined `ec_*` row. Untagged entries
+	 * have no pivot rows, so the statement is a cheap no-op for them.
+	 */
+	private async restampEntryPivot(type: string, id: string): Promise<void> {
+		const tableName = getTableName(type);
+		await sql`
+			UPDATE content_taxonomies
+			SET (status, scheduled_at, deleted_at, locale, published_at, created_at) = (
+				SELECT status, scheduled_at, deleted_at, locale, published_at, created_at
+				FROM ${sql.ref(tableName)}
+				WHERE ${sql.ref(tableName)}.id = ${id}
+			)
+			WHERE collection = ${type} AND entry_id = ${id}
+		`.execute(this.db);
+	}
+
 	/**
 	 * Permanently delete content (cannot be undone)
 	 */
@@ -996,6 +1048,7 @@ export class ContentRepository {
 			AND deleted_at IS NULL
 		`.execute(this.db);
 
+		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
@@ -1035,6 +1088,7 @@ export class ContentRepository {
 			AND deleted_at IS NULL
 		`.execute(this.db);
 
+		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
@@ -1296,16 +1350,39 @@ export class ContentRepository {
 			// so the content table always holds the published version
 			const revision = await revisionRepo.findById(revisionToPublish);
 			if (revision) {
-				await this.syncDataColumns(type, id, revision.data);
+				// A staged slug lands on the live column only here — it never
+				// passes through update(), so its uniqueness was never checked.
+				// Validate before any write: the `(slug, locale)` unique index
+				// covers every row (drafts and trashed entries included), and
+				// letting the constraint fire mid-publish would surface as an
+				// opaque 500 after draft data already hit the live columns.
+				// A NULL locale never collides (unique indexes treat NULLs as
+				// distinct), so the check only applies to localized rows.
+				const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
+				if (stagedSlug !== null && stagedSlug !== existing.slug && existing.locale !== null) {
+					const conflict = await this.findBySlugIncludingTrashed(type, stagedSlug, existing.locale);
+					if (conflict && conflict.id !== id) {
+						throw new EmDashValidationError(
+							`Cannot publish: slug '${stagedSlug}' is already used by another entry` +
+								` in this collection (id: ${conflict.id}). Choose a different slug.`,
+							{ code: "SLUG_CONFLICT" },
+						);
+					}
+				}
 
-				// Sync slug from revision if stored there
-				if (typeof revision.data._slug === "string") {
+				// Write the slug before the data columns: the slug UPDATE is the
+				// only statement here that can hit the unique constraint (if a
+				// concurrent write took the slug after the check above), and on
+				// D1 there is no transaction to roll back earlier statements.
+				if (stagedSlug !== null) {
 					await sql`
 						UPDATE ${sql.ref(tableName)}
-						SET slug = ${revision.data._slug}
+						SET slug = ${stagedSlug}
 						WHERE id = ${id}
 					`.execute(this.db);
 				}
+
+				await this.syncDataColumns(type, id, revision.data);
 			}
 
 			if (publishedAt !== undefined) {
@@ -1339,6 +1416,8 @@ export class ContentRepository {
 			}
 			publishCommitted = true;
 
+			await this.restampEntryPivot(type, id);
+
 			const updated = await this.findById(type, id);
 			if (!updated) {
 				throw new Error("Content not found");
@@ -1427,6 +1506,7 @@ export class ContentRepository {
 			AND deleted_at IS NULL
 		`.execute(this.db);
 
+		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
@@ -1450,7 +1530,6 @@ export class ContentRepository {
 	 */
 	async setDraftRevision(type: string, id: string, revisionId: string): Promise<void> {
 		const tableName = getTableName(type);
-		const now = new Date().toISOString();
 
 		const existing = await this.findById(type, id);
 		if (!existing) {
@@ -1467,10 +1546,12 @@ export class ContentRepository {
 			throw new EmDashValidationError("Revision does not belong to the specified content item");
 		}
 
+		// Draft staging leaves live content untouched, so it must not bump
+		// updated_at — public "content last modified" consumers (sitemap
+		// <lastmod>, dateModified) would see a phantom modification (#2143).
 		await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = ${revisionId},
-				updated_at = ${now}
+			SET draft_revision_id = ${revisionId}
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
@@ -1486,7 +1567,6 @@ export class ContentRepository {
 	 */
 	async discardDraft(type: string, id: string): Promise<ContentItem> {
 		const tableName = getTableName(type);
-		const now = new Date().toISOString();
 
 		const existing = await this.findById(type, id);
 		if (!existing) {
@@ -1498,10 +1578,12 @@ export class ContentRepository {
 			return existing;
 		}
 
+		// Discarding a draft restores the state from before the draft was
+		// staged — nothing about the live entry changed in between, so
+		// updated_at stays at its pre-draft value (#2143).
 		await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = NULL,
-				updated_at = ${now}
+			SET draft_revision_id = NULL
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);

package/src/database/repositories/media-usage.ts

@@ -20,7 +20,7 @@ import type {
 	MediaUsageTable,
 } from "../types.js";
 import { validateIdentifier } from "../validate.js";
-import { decodeCursor, encodeCursor, type FindManyResult } from "./types.js";
+import { decodeCursor, encodeCursor, InvalidCursorError, type FindManyResult } from "./types.js";
 
 type DatabaseExecutor = Kysely<Database> | Transaction<Database>;
 type MediaUsageSourceNullableStringColumn =
@@ -36,6 +36,23 @@ const OCCURRENCE_INSERT_BATCH_SIZE = Math.max(
 	1,
 	Math.floor(SQL_BATCH_SIZE / OCCURRENCE_BIND_COLUMNS),
 );
+const CONTENT_SOURCE_ELIGIBILITY = sql<boolean>`(
+	s.source_variant = 'draft_overlay'
+	OR (
+		s.source_variant = 'columns'
+		AND (
+			s.content_status = 'published'
+			OR NOT EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_sources AS overlay
+				WHERE overlay.source_type = 'content'
+					AND overlay.collection_slug = s.collection_slug
+					AND overlay.content_id = s.content_id
+					AND overlay.source_variant = 'draft_overlay'
+			)
+		)
+	)
+)`;
 
 export interface MediaUsageSourceInput {
 	sourceKey: string;
@@ -193,6 +210,24 @@ export interface FindMediaUsageOptions {
 	cursor?: string;
 }
 
+export interface MediaUsageCollectionIndexStatusScope {
+	collectionSlug: string;
+	status: string | null;
+	schemaVersion: number | null;
+}
+
+export interface MediaUsageEntrySource {
+	source: MediaUsageSource;
+	occurrences: MediaUsageOccurrence[];
+}
+
+export interface MediaUsageEntryGroup {
+	collectionSlug: string;
+	contentId: string;
+	contentDeletedAt: string | null;
+	sources: MediaUsageEntrySource[];
+}
+
 interface MediaUsageSourceRow {
 	source_key: string;
 	source_type: string;
@@ -280,6 +315,11 @@ interface JoinedUsageRow {
 	occurrence_created_at: string;
 }
 
+interface GroupedUsageRow extends JoinedUsageRow {
+	entry_deleted_at: string | null;
+	has_more: number;
+}
+
 /** Persistence-only repository for the internal media usage projection tables. */
 export class MediaUsageRepository {
 	constructor(private db: Kysely<Database>) {}
@@ -420,6 +460,169 @@ export class MediaUsageRepository {
 		};
 	}
 
+	async findActiveEntryCountsByMediaIds(mediaIds: readonly string[]): Promise<Map<string, number>> {
+		const uniqueMediaIds = [...new Set(mediaIds)];
+		const counts = new Map(uniqueMediaIds.map((mediaId) => [mediaId, 0]));
+
+		for (const mediaIdBatch of chunks(uniqueMediaIds, SQL_BATCH_SIZE)) {
+			const visibleEntries = this.currentContentMediaUsageBaseQuery()
+				.select([
+					"u.media_id as media_id",
+					"s.collection_slug as collection_slug",
+					"s.content_id as content_id",
+				])
+				.where("u.media_id", "in", mediaIdBatch)
+				.where((eb) =>
+					eb.not(
+						eb.exists(
+							eb
+								.selectFrom("_emdash_media_usage_sources as deleted_source")
+								.select("deleted_source.source_key")
+								.where("deleted_source.source_type", "=", "content")
+								.whereRef("deleted_source.collection_slug", "=", "s.collection_slug")
+								.whereRef("deleted_source.content_id", "=", "s.content_id")
+								.where("deleted_source.source_variant", "in", ["columns", "draft_overlay"])
+								.where("deleted_source.content_deleted_at", "is not", null),
+						),
+					),
+				)
+				.distinct()
+				.as("visible_entries");
+
+			const rows = await this.db
+				.selectFrom(visibleEntries)
+				.select("media_id")
+				.select((eb) => eb.fn.countAll<number>().as("usage_count"))
+				.groupBy("media_id")
+				.execute();
+
+			for (const row of rows) {
+				if (row.media_id !== null) counts.set(row.media_id, Number(row.usage_count));
+			}
+		}
+
+		return counts;
+	}
+
+	async findCollectionIndexStatusScopes(
+		identity: Pick<MediaUsageIndexStatusIdentity, "adapterId" | "scopeType">,
+	): Promise<MediaUsageCollectionIndexStatusScope[]> {
+		const rows = await this.db
+			.selectFrom("_emdash_collections as collection")
+			.leftJoin("_emdash_media_usage_index_status as status", (join) =>
+				join
+					.on("status.adapter_id", "=", identity.adapterId)
+					.on("status.scope_type", "=", identity.scopeType)
+					.onRef("status.scope_key", "=", "collection.slug"),
+			)
+			.select([
+				"collection.slug as collection_slug",
+				"status.status as status",
+				"status.schema_version as schema_version",
+			])
+			.orderBy("collection.slug", "asc")
+			.execute();
+
+		return rows.map((row) => ({
+			collectionSlug: row.collection_slug,
+			status: row.status,
+			schemaVersion: row.schema_version === null ? null : Number(row.schema_version),
+		}));
+	}
+
+	async findCurrentEntryUsagePageByMediaId(
+		mediaId: string,
+		options: FindMediaUsageOptions = {},
+	): Promise<FindManyResult<MediaUsageEntryGroup>> {
+		const requestedLimit = Math.floor(options.limit ?? 50);
+		const limit = Number.isFinite(requestedLimit) ? Math.min(Math.max(1, requestedLimit), 100) : 50;
+		const cursor = options.cursor ? decodeCursor(options.cursor) : null;
+		if (cursor && (cursor.orderValue.length === 0 || cursor.id.length === 0)) {
+			throw new InvalidCursorError(options.cursor ?? "");
+		}
+		let matchedGroups = this.currentContentMediaUsageBaseQuery()
+			.select(["s.collection_slug as collection_slug", "s.content_id as content_id"])
+			.where("u.media_id", "=", mediaId)
+			.distinct();
+		if (cursor) {
+			matchedGroups = matchedGroups.where((eb) =>
+				eb.or([
+					eb("s.collection_slug", ">", cursor.orderValue),
+					eb.and([
+						eb("s.collection_slug", "=", cursor.orderValue),
+						eb("s.content_id", ">", cursor.id),
+					]),
+				]),
+			);
+		}
+		matchedGroups = matchedGroups
+			.orderBy("s.collection_slug", "asc")
+			.orderBy("s.content_id", "asc")
+			.limit(limit + 1);
+
+		const rows: GroupedUsageRow[] = await this.db
+			.with("matched_groups", () => matchedGroups)
+			.with("page_groups", (db) =>
+				db
+					.selectFrom("matched_groups")
+					.selectAll()
+					.orderBy("collection_slug", "asc")
+					.orderBy("content_id", "asc")
+					.limit(limit),
+			)
+			.with("entry_state", (db) =>
+				db
+					.selectFrom("page_groups as page")
+					.crossJoin("_emdash_media_usage_sources as state")
+					.select(["page.collection_slug", "page.content_id"])
+					.select((eb) =>
+						eb.fn.max<string | null>("state.content_deleted_at").as("entry_deleted_at"),
+					)
+					.whereRef("page.collection_slug", "=", "state.collection_slug")
+					.whereRef("page.content_id", "=", "state.content_id")
+					.where("state.source_type", "=", "content")
+					.where("state.source_variant", "in", ["columns", "draft_overlay"])
+					.groupBy(["page.collection_slug", "page.content_id"]),
+			)
+			.selectFrom("entry_state as page")
+			.crossJoin("_emdash_media_usage_sources as s")
+			.crossJoin("_emdash_media_usage as u")
+			.whereRef("page.collection_slug", "=", "s.collection_slug")
+			.whereRef("page.content_id", "=", "s.content_id")
+			.whereRef("s.source_key", "=", "u.source_key")
+			.whereRef("s.current_generation", "=", "u.generation")
+			.select(currentUsageSelect)
+			.select("page.entry_deleted_at")
+			.select(
+				sql<number>`CASE
+					WHEN (SELECT COUNT(*) FROM matched_groups) > ${limit} THEN 1
+					ELSE 0
+				END`.as("has_more"),
+			)
+			.where("u.media_id", "=", mediaId)
+			.where("s.source_type", "=", "content")
+			.where("s.collection_slug", "is not", null)
+			.where("s.content_id", "is not", null)
+			.where("s.source_variant", "in", ["columns", "draft_overlay"])
+			.where(CONTENT_SOURCE_ELIGIBILITY)
+			.orderBy("s.collection_slug", "asc")
+			.orderBy("s.content_id", "asc")
+			.orderBy("s.source_variant", "asc")
+			.orderBy("s.source_key", "asc")
+			.orderBy("u.field_path", "asc")
+			.orderBy("u.occurrence_index", "asc")
+			.orderBy("u.id", "asc")
+			.execute();
+
+		const items = groupUsageRows(rows);
+		const result: FindManyResult<MediaUsageEntryGroup> = { items };
+		if (Number(rows[0]?.has_more ?? 0) === 1 && items.length > 0) {
+			const last = items.at(-1)!;
+			result.nextCursor = encodeCursor(last.collectionSlug, last.contentId);
+		}
+		return result;
+	}
+
 	async findCurrentUsageByMediaId(mediaId: string): Promise<MediaUsageRecord[]> {
 		const rows = await this.db
 			.selectFrom("_emdash_media_usage_sources as s")
@@ -889,6 +1092,20 @@ export class MediaUsageRepository {
 			.select(currentUsageSelect);
 	}
 
+	private currentContentMediaUsageBaseQuery() {
+		return this.db
+			.selectFrom("_emdash_media_usage as u")
+			.crossJoin("_emdash_media_usage_sources as s")
+			.innerJoin("_emdash_collections as collection", "collection.slug", "s.collection_slug")
+			.whereRef("s.source_key", "=", "u.source_key")
+			.whereRef("s.current_generation", "=", "u.generation")
+			.where("s.source_type", "=", "content")
+			.where("s.collection_slug", "is not", null)
+			.where("s.content_id", "is not", null)
+			.where("s.source_variant", "in", ["columns", "draft_overlay"])
+			.where(CONTENT_SOURCE_ELIGIBILITY);
+	}
+
 	private async deleteSourceKeys(sourceKeys: readonly string[]): Promise<number> {
 		const uniqueSourceKeys = [...new Set(sourceKeys)];
 		if (uniqueSourceKeys.length === 0) return 0;
@@ -1229,6 +1446,38 @@ const currentUsageSelect = [
 	"u.created_at as occurrence_created_at",
 ] as const;
 
+function groupUsageRows(rows: readonly GroupedUsageRow[]): MediaUsageEntryGroup[] {
+	const groups: MediaUsageEntryGroup[] = [];
+
+	for (const row of rows) {
+		if (row.collection_slug === null || row.content_id === null) continue;
+		const record = rowToUsageRecord(row);
+		let group = groups.at(-1);
+		if (
+			!group ||
+			group.collectionSlug !== row.collection_slug ||
+			group.contentId !== row.content_id
+		) {
+			group = {
+				collectionSlug: row.collection_slug,
+				contentId: row.content_id,
+				contentDeletedAt: row.entry_deleted_at,
+				sources: [],
+			};
+			groups.push(group);
+		}
+
+		let source = group.sources.at(-1);
+		if (!source || source.source.sourceKey !== record.source.sourceKey) {
+			source = { source: record.source, occurrences: [] };
+			group.sources.push(source);
+		}
+		source.occurrences.push(record.occurrence);
+	}
+
+	return groups;
+}
+
 function rowToSource(row: MediaUsageSourceRow): MediaUsageSource {
 	return {
 		sourceKey: row.source_key,

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

@@ -7,7 +7,7 @@
  * @see PLUGIN-SYSTEM.md § Plugin Storage > Full API Reference
  */
 
-import type { Kysely } from "kysely";
+import type { Kysely, RawBuilder } from "kysely";
 import { sql } from "kysely";
 
 import {
@@ -15,7 +15,7 @@ import {
 	validateWhereClause,
 	validateOrderByClause,
 	getIndexedFields,
-	jsonExtract,
+	jsonOrderExtract,
 } from "../../plugins/storage-query.js";
 import type {
 	StorageCollection,
@@ -27,6 +27,26 @@ import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { encodeCursor, decodeCursor } from "./types.js";
 
+/**
+ * Interleave a `?`-placeholder SQL string with its params into a single
+ * boolean raw expression. Used as a WHERE predicate directly — wrapping it
+ * in `(...) = 1` breaks on Postgres, which has a strict boolean type (#920).
+ */
+function rawWhereExpr(sqlText: string, params: unknown[]): RawBuilder<boolean> {
+	const parts: ReturnType<typeof sql>[] = [];
+	let paramIndex = 0;
+	const sqlParts = sqlText.split("?");
+	for (let i = 0; i < sqlParts.length; i++) {
+		if (i > 0) {
+			parts.push(sql`${params[paramIndex++]}`);
+		}
+		if (sqlParts[i]) {
+			parts.push(sql.raw(sqlParts[i]));
+		}
+	}
+	return sql<boolean>`(${sql.join(parts, sql.raw(""))})`;
+}
+
 /**
  * Plugin Storage Repository
  *
@@ -211,19 +231,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		// Add JSON extraction WHERE conditions
 		const whereResult = buildWhereClause(this.db, where);
 		if (whereResult.sql) {
-			// Use sql template to add the raw WHERE conditions with params
-			const whereSqlParts: ReturnType<typeof sql>[] = [];
-			let paramIndex = 0;
-			const sqlParts = whereResult.sql.split("?");
-			for (let i = 0; i < sqlParts.length; i++) {
-				if (i > 0) {
-					whereSqlParts.push(sql`${whereResult.params[paramIndex++]}`);
-				}
-				if (sqlParts[i]) {
-					whereSqlParts.push(sql.raw(sqlParts[i]));
-				}
-			}
-			query = query.where(({ eb }) => eb(sql.join(whereSqlParts, sql.raw("")), "=", sql.raw("1")));
+			query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
 		}
 
 		// Handle cursor-based pagination — throws on invalid cursor.
@@ -237,7 +245,9 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		// Build ORDER BY using sql template
 		if (Object.keys(orderBy).length > 0) {
 			for (const [field, direction] of Object.entries(orderBy)) {
-				const extract = jsonExtract(this.db, field);
+				// Order over the jsonb-native value on Postgres so numeric fields sort
+				// numerically, not lexically. See pluginDataOrderExpr.
+				const extract = jsonOrderExtract(this.db, field);
 				const orderExpr =
 					direction === "desc" ? sql`${sql.raw(extract)} desc` : sql`${sql.raw(extract)} asc`;
 				query = query.orderBy(orderExpr);
@@ -289,26 +299,13 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		if (where && Object.keys(where).length > 0) {
 			const whereResult = buildWhereClause(this.db, where);
 			if (whereResult.sql) {
-				// Use sql template to add the raw WHERE conditions with params
-				const whereSqlParts: ReturnType<typeof sql>[] = [];
-				let paramIndex = 0;
-				const sqlParts = whereResult.sql.split("?");
-				for (let i = 0; i < sqlParts.length; i++) {
-					if (i > 0) {
-						whereSqlParts.push(sql`${whereResult.params[paramIndex++]}`);
-					}
-					if (sqlParts[i]) {
-						whereSqlParts.push(sql.raw(sqlParts[i]));
-					}
-				}
-				query = query.where(({ eb }) =>
-					eb(sql.join(whereSqlParts, sql.raw("")), "=", sql.raw("1")),
-				);
+				query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
 			}
 		}
 
 		const result = await query.executeTakeFirst();
-		return result?.count ?? 0;
+		// Number() because the pg driver returns COUNT(*) (bigint) as a string.
+		return Number(result?.count ?? 0);
 	}
 }
 

package/src/database/repositories/redirect.ts

@@ -347,7 +347,11 @@ export class RedirectRepository {
 	/**
 	 * Create an auto-redirect when a content slug changes.
 	 * Uses the collection's URL pattern to compute old/new URLs.
-	 * Collapses existing redirect chains pointing to the old URL.
+	 * Collapses existing redirect chains pointing to the old URL and
+	 * removes redirects that would shadow the now-live new URL, so a
+	 * rename that is later reverted cannot form a loop (#1986).
+	 *
+	 * Returns null when old and new URL are identical (nothing to redirect).
 	 */
 	async createAutoRedirect(
 		collection: string,
@@ -355,7 +359,7 @@ export class RedirectRepository {
 		newSlug: string,
 		contentId: string,
 		urlPattern: string | null,
-	): Promise<Redirect> {
+	): Promise<Redirect | null> {
 		const oldUrl = urlPattern
 			? urlPattern.replace("{slug}", oldSlug).replace("{id}", contentId)
 			: `/${collection}/${oldSlug}`;
@@ -363,9 +367,17 @@ export class RedirectRepository {
 			? urlPattern.replace("{slug}", newSlug).replace("{id}", contentId)
 			: `/${collection}/${newSlug}`;
 
+		// A redirect from a URL to itself would make the page unreachable
+		if (oldUrl === newUrl) return null;
+
 		// Collapse chains: update any existing redirects pointing to the old URL
 		await this.collapseChains(oldUrl, newUrl);
 
+		// The new URL serves live content again — any redirect from it would
+		// shadow the page. This also removes the self-redirect that chain
+		// collapsing produces when a rename A → B is reverted (A → A).
+		await this.db.deleteFrom("_emdash_redirects").where("source", "=", newUrl).execute();
+
 		// Check if a redirect from this source already exists
 		const existing = await this.findBySource(oldUrl);
 		if (existing) {