emdash 1.0.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emdash",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Astro-native CMS with WordPress migration support",
   "type": "module",
   "main": "dist/index.mjs",
@@ -57,6 +57,7 @@
     "./ui": "./src/ui.ts",
     "./ui/comments": "./src/ui-comments.ts",
     "./ui/search": "./src/components/LiveSearch.astro",
+    "./ui/webmcp-search": "./src/components/WebMcpSearch.astro",
     "./cli": {
       "types": "./dist/cli/index.d.mts",
       "default": "./dist/cli/index.mjs"
@@ -84,6 +85,11 @@
       "default": "./dist/auth/providers/google.mjs"
     },
     "./auth/providers/google-admin": "./src/auth/providers/google-admin.tsx",
+    "./auth/providers/microsoft": {
+      "types": "./dist/auth/providers/microsoft.d.mts",
+      "default": "./dist/auth/providers/microsoft.mjs"
+    },
+    "./auth/providers/microsoft-admin": "./src/auth/providers/microsoft-admin.tsx",
     "./db": {
       "types": "./dist/db/index.d.mts",
       "default": "./dist/db/index.mjs"
@@ -259,6 +265,8 @@
     "@tiptap/extension-link": "^3.20.0",
     "@tiptap/extension-list": "^3.20.0",
     "@tiptap/extension-placeholder": "^3.20.0",
+    "@tiptap/extension-subscript": "^3.20.0",
+    "@tiptap/extension-superscript": "^3.20.0",
     "@tiptap/extension-text-align": "^3.20.0",
     "@tiptap/extension-typography": "^3.20.0",
     "@tiptap/extension-underline": "^3.20.0",
@@ -289,14 +297,14 @@
     "upng-js": "^2.1.0",
     "zod": "4.5.4",
     "@atcute/client": "^5.0.0",
-    "@emdash-cms/admin": "1.0.1",
-    "@emdash-cms/auth": "1.0.1",
-    "@emdash-cms/blocks": "1.0.1",
-    "@emdash-cms/gutenberg-to-portable-text": "1.0.1",
-    "@emdash-cms/plugin-types": "0.5.0",
+    "@emdash-cms/admin": "1.2.0",
+    "@emdash-cms/auth": "1.2.0",
+    "@emdash-cms/blocks": "1.2.0",
+    "@emdash-cms/gutenberg-to-portable-text": "1.2.0",
+    "@emdash-cms/plugin-types": "0.6.0",
     "@emdash-cms/registry-client": "0.7.0",
     "@emdash-cms/registry-lexicons": "0.7.0",
-    "@emdash-cms/registry-verification": "0.3.3"
+    "@emdash-cms/registry-verification": "0.3.4"
   },
   "optionalDependencies": {
     "@libsql/kysely-libsql": "^0.4.0",
@@ -317,10 +325,11 @@
   "devDependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
     "@arethetypeswrong/cli": "^0.18.2",
-    "@astrojs/react": "^6.0.5",
+    "@astrojs/react": "^7.0.0",
     "@cloudflare/vitest-plugin": "^1.0.0",
     "@types/pg": "^8.16.0",
     "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
     "@types/sanitize-html": "^2.16.0",
     "@types/sax": "^1.2.7",
     "@vitest/ui": "4.1.10",
@@ -333,7 +342,7 @@
     "vitest": "4.1.10",
     "zod-openapi": "^5.4.6",
     "@emdash-cms/atproto-test-utils": "0.0.0",
-    "@emdash-cms/registry-verification": "0.3.3"
+    "@emdash-cms/registry-verification": "0.3.4"
   },
   "repository": {
     "type": "git",
@@ -355,7 +364,7 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.components.json",
     "check": "publint && attw --pack --ignore-rules=cjs-resolves-to-esm --ignore-rules=no-resolution --ignore-rules=internal-resolution-error",
     "test": "vitest",
     "test:workerd": "vitest run --config vitest.workerd.config.ts",

package/src/api/errors.ts

@@ -28,6 +28,7 @@ export const ErrorCode = {
 	NOT_IMPLEMENTED: "NOT_IMPLEMENTED",
 	NOT_SUPPORTED: "NOT_SUPPORTED",
 	MISSING_PARAM: "MISSING_PARAM",
+	DOMAIN_CHECK_FAILED: "DOMAIN_CHECK_FAILED",
 	CSRF_REJECTED: "CSRF_REJECTED",
 
 	// Content
@@ -185,6 +186,9 @@ export const ErrorCode = {
 	SIGNUP_VERIFY_ERROR: "SIGNUP_VERIFY_ERROR",
 	SIGNUP_COMPLETE_ERROR: "SIGNUP_COMPLETE_ERROR",
 	RECOVERY_SEND_ERROR: "RECOVERY_SEND_ERROR",
+	MAGIC_LINK_VERIFY_ERROR: "MAGIC_LINK_VERIFY_ERROR",
+	NO_SITE_URL: "NO_SITE_URL",
+	SIGN_IN_HANDOVER_ERROR: "SIGN_IN_HANDOVER_ERROR",
 	USER_LIST_ERROR: "USER_LIST_ERROR",
 	USER_DETAIL_ERROR: "USER_DETAIL_ERROR",
 	USER_UPDATE_ERROR: "USER_UPDATE_ERROR",
@@ -360,6 +364,9 @@ export const ErrorCode = {
 	SETTINGS_UPDATE_ERROR: "SETTINGS_UPDATE_ERROR",
 	EMAIL_SETTINGS_READ_ERROR: "EMAIL_SETTINGS_READ_ERROR",
 	EMAIL_TEST_ERROR: "EMAIL_TEST_ERROR",
+	SITE_DOMAIN_ERROR: "SITE_DOMAIN_ERROR",
+	DOMAIN_PROOF_ERROR: "DOMAIN_PROOF_ERROR",
+	DOMAIN_MOVE_NOTICE_ERROR: "DOMAIN_MOVE_NOTICE_ERROR",
 
 	// Backups
 	BACKUP_SETTINGS_READ_ERROR: "BACKUP_SETTINGS_READ_ERROR",
@@ -391,6 +398,9 @@ export const ErrorCode = {
 	DASHBOARD_ERROR: "DASHBOARD_ERROR",
 	DASHBOARD_STATS_ERROR: "DASHBOARD_STATS_ERROR",
 
+	// Calendar
+	CALENDAR_ERROR: "CALENDAR_ERROR",
+
 	// Misc
 	SNAPSHOT_ERROR: "SNAPSHOT_ERROR",
 	TYPEGEN_ERROR: "TYPEGEN_ERROR",
@@ -510,6 +520,7 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.CREDENTIAL_EXISTS:
 		case ErrorCode.EMAIL_IN_USE:
 		case ErrorCode.USER_EXISTS:
+		case ErrorCode.NO_SITE_URL:
 		case ErrorCode.PLUGIN_ID_CONFLICT:
 		case ErrorCode.ALREADY_INSTALLED:
 		case ErrorCode.ALREADY_CONFIGURED:
@@ -540,6 +551,7 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.CHECKSUM_MISMATCH:
 		case ErrorCode.INVALID_BUNDLE:
 		case ErrorCode.BUNDLE_EXTRACT_FAILED:
+		case ErrorCode.DOMAIN_CHECK_FAILED:
 			return 422;
 
 		// 429 Too Many Requests

package/src/api/handlers/api-tokens.ts

@@ -9,6 +9,7 @@
 import type { Kysely } from "kysely";
 import { ulid } from "ulidx";
 
+import { after } from "../../after.js";
 import { hashApiToken, generatePrefixedToken } from "../../auth/api-tokens.js";
 import type { Database } from "../../database/types.js";
 import type { ApiResult } from "../types.js";
@@ -227,12 +228,17 @@ export async function resolveApiToken(
 		return null;
 	}
 
-	// Update last_used_at (fire-and-forget, don't block the request)
-	db.updateTable("_emdash_api_tokens")
-		.set({ last_used_at: new Date().toISOString() })
-		.where("id", "=", row.id)
-		.execute()
-		.catch(() => {}); // Non-critical, swallow errors
+	after(async () => {
+		try {
+			await db
+				.updateTable("_emdash_api_tokens")
+				.set({ last_used_at: new Date().toISOString() })
+				.where("id", "=", row.id)
+				.execute();
+		} catch (error) {
+			console.error("[api-tokens] failed to record token use:", error);
+		}
+	});
 
 	return {
 		userId: row.user_id,

package/src/api/handlers/bylines.ts

@@ -116,7 +116,10 @@ export async function handleBylineTranslations(
 
 /**
  * Create a new byline. When `translationOf` is supplied, the new row joins the
- * source byline's translation_group (a sibling in the same logical identity).
+ * source byline's translation_group (a sibling in the same logical identity)
+ * and keeps the source's linked user unless `userId` is given. A user can own
+ * one byline per locale, so linking a user who already has a byline in the
+ * target locale returns CONFLICT.
  *
  * Translating from a source row only makes sense when the caller names the
  * target locale, otherwise we'd silently clone into the configured default,
@@ -147,6 +150,7 @@ export async function handleBylineCreate(
 		// Existence check up front so the repo's "Source not found" throw
 		// becomes a clean NOT_FOUND on the API.
 		let sourceGroup: string | undefined;
+		let sourceUserId: string | null = null;
 		if (input.translationOf) {
 			const source = await repo.findById(input.translationOf);
 			if (!source) {
@@ -159,8 +163,10 @@ export async function handleBylineCreate(
 				};
 			}
 			sourceGroup = source.translationGroup ?? source.id;
+			sourceUserId = source.userId;
 		}
 
+		const userId = input.userId === undefined ? sourceUserId : input.userId;
 		const effectiveLocale = locale ?? getI18nConfig()?.defaultLocale ?? "en";
 
 		// Translation-group guard: the row-per-locale model (PR #916)
@@ -196,7 +202,7 @@ export async function handleBylineCreate(
 			const inputHasFields = !!input.customFields && Object.keys(input.customFields).length > 0;
 			if (
 				inputHasFields &&
-				bylineFixedFieldsMatch(existing, input, effectiveLocale) &&
+				bylineFixedFieldsMatch(existing, { ...input, userId }, effectiveLocale) &&
 				existing.translationGroup === expectedTranslationGroup &&
 				existingCustomFieldsAreSubsetOf(existing.customFields ?? {}, input.customFields)
 			) {
@@ -217,7 +223,22 @@ export async function handleBylineCreate(
 			};
 		}
 
-		const byline = await repo.create({ ...input, locale: effectiveLocale });
+		// Runs after the slug check: a retried partial create already owns this
+		// user link, and the recovery branch above has to see that row first.
+		if (userId) {
+			const linked = await repo.findByUserId(userId, { locale: effectiveLocale });
+			if (linked) {
+				return {
+					success: false,
+					error: {
+						code: "CONFLICT",
+						message: `This user is already linked to byline "${linked.slug}" in locale "${effectiveLocale}"`,
+					},
+				};
+			}
+		}
+
+		const byline = await repo.create({ ...input, userId, locale: effectiveLocale });
 		return { success: true, data: byline };
 	} catch (error) {
 		// Mirror handleBylineUpdate: surface customFields validation

package/src/api/handlers/calendar.ts

@@ -0,0 +1,246 @@
+/**
+ * Calendar handler
+ *
+ * Lists published entries at their publish time and scheduled entries at
+ * their scheduled time, across every visible collection, in time order.
+ */
+
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import {
+	InvalidCursorError,
+	decodeCursor,
+	encodeCursor,
+} from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import { validateIdentifier } from "../../database/validate.js";
+import type { ApiResult } from "../types.js";
+
+export type CalendarEntryKind = "published" | "scheduled";
+
+export interface CalendarEntry {
+	collection: string;
+	id: string;
+	locale: string;
+	title: string;
+	status: string;
+	kind: CalendarEntryKind;
+	at: string;
+}
+
+export interface CalendarEntriesResponse {
+	items: CalendarEntry[];
+	nextCursor?: string;
+}
+
+export interface CalendarEntriesParams {
+	from: string;
+	to: string;
+	cursor?: string;
+	limit: number;
+}
+
+const KINDS: readonly CalendarEntryKind[] = ["published", "scheduled"];
+const KIND_COLUMN = { published: "published_at", scheduled: "scheduled_at" } as const;
+const TITLE_FIELD_TYPES = ["string", "text", "slug"];
+const SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
+
+interface Stream {
+	collection: string;
+	kind: CalendarEntryKind;
+	title: RawBuilder<string>;
+}
+
+interface CalendarCursor {
+	at: string;
+	collection: string;
+	kind: CalendarEntryKind;
+	id: string;
+}
+
+interface StreamRow {
+	id: string;
+	locale: string;
+	status: string;
+	title: string;
+	event_at: string;
+}
+
+function compareText(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/** Streams run in collection slug order, published before scheduled. */
+function compareStreams(
+	a: { collection: string; kind: CalendarEntryKind },
+	b: { collection: string; kind: CalendarEntryKind },
+): number {
+	return compareText(a.collection, b.collection) || KINDS.indexOf(a.kind) - KINDS.indexOf(b.kind);
+}
+
+function isKind(value: string | undefined): value is CalendarEntryKind {
+	return value === "published" || value === "scheduled";
+}
+
+/** Stored timestamps are canonical `toISOString()` values. */
+function isCanonicalTime(value: string): boolean {
+	const time = Date.parse(value);
+	return !Number.isNaN(time) && new Date(time).toISOString() === value;
+}
+
+function encodeCalendarCursor(entry: CalendarEntry): string {
+	return encodeCursor(`${entry.at}|${entry.collection}|${entry.kind}`, entry.id);
+}
+
+function decodeCalendarCursor(cursor: string): CalendarCursor {
+	const { orderValue, id } = decodeCursor(cursor);
+	const [at = "", collection = "", kind, ...rest] = orderValue.split("|");
+	if (
+		rest.length > 0 ||
+		!isCanonicalTime(at) ||
+		!SLUG_PATTERN.test(collection) ||
+		!isKind(kind) ||
+		!id
+	) {
+		throw new InvalidCursorError(cursor);
+	}
+	return { at, collection, kind, id };
+}
+
+/**
+ * Title columns follow the admin's rule: the collection's title field, then
+ * `title`, then `name`, skipping empty values, then the slug and the id. A
+ * `title_field` that names no text field is ignored.
+ */
+async function loadStreams(db: Kysely<Database>): Promise<Stream[]> {
+	const rows = await db
+		.selectFrom("_emdash_collections as c")
+		.leftJoin("_emdash_fields as f", (join) =>
+			join
+				.onRef("f.collection_id", "=", "c.id")
+				.on("f.type", "in", TITLE_FIELD_TYPES)
+				.on((eb) =>
+					eb.or([
+						eb("f.slug", "in", ["title", "name"]),
+						eb("f.slug", "=", eb.ref("c.title_field")),
+					]),
+				),
+		)
+		.select(["c.slug as slug", "c.title_field as title_field", "f.slug as field"])
+		.where("c.hidden", "=", 0)
+		.execute();
+
+	const collections = new Map<string, { titleField: string | null; fields: Set<string> }>();
+	for (const row of rows) {
+		const collection = collections.get(row.slug) ?? {
+			titleField: row.title_field,
+			fields: new Set<string>(),
+		};
+		if (row.field) collection.fields.add(row.field);
+		collections.set(row.slug, collection);
+	}
+
+	return [...collections.entries()]
+		.toSorted(([a], [b]) => compareText(a, b))
+		.flatMap(([slug, { titleField, fields }]) => {
+			validateIdentifier(slug, "collection slug");
+			const columns = [...new Set([titleField, "title", "name"])].filter(
+				(column): column is string => !!column && fields.has(column),
+			);
+			const title = sql<string>`COALESCE(${sql.join(
+				[...columns, "slug"].map((column) => {
+					validateIdentifier(column, "title column");
+					return sql`NULLIF(${sql.ref(column)}, '')`;
+				}),
+			)}, id)`;
+			return KINDS.map((kind) => ({ collection: slug, kind, title }));
+		});
+}
+
+function keysetCondition(stream: Stream, cursor: CalendarCursor | undefined) {
+	if (!cursor) return sql``;
+	const column = sql.ref(KIND_COLUMN[stream.kind]);
+	const order = compareStreams(stream, cursor);
+	if (order < 0) return sql`AND ${column} > ${cursor.at}`;
+	if (order === 0) return sql`AND (${column} > ${cursor.at} OR id > ${cursor.id})`;
+	return sql``;
+}
+
+async function queryStream(
+	db: Kysely<Database>,
+	stream: Stream,
+	params: CalendarEntriesParams,
+	cursor: CalendarCursor | undefined,
+): Promise<StreamRow[]> {
+	const column = sql.ref(KIND_COLUMN[stream.kind]);
+	const lower = cursor && cursor.at > params.from ? cursor.at : params.from;
+	const result = await sql<StreamRow>`
+		SELECT id, locale, status, ${stream.title} AS title, ${column} AS event_at
+		FROM ${sql.ref(`ec_${stream.collection}`)}
+		WHERE deleted_at IS NULL
+			AND ${column} IS NOT NULL
+			AND ${column} >= ${lower}
+			AND ${column} < ${params.to}
+			${stream.kind === "published" ? sql`AND status = 'published'` : sql``}
+			${keysetCondition(stream, cursor)}
+		ORDER BY ${column} ASC, id ASC
+		LIMIT ${params.limit + 1}
+	`.execute(db);
+	return result.rows;
+}
+
+/**
+ * Each stream (one collection and kind) is read in its own query, and the
+ * rows are merged by time. Ties keep the stream order and then each stream's
+ * SQL order, which matches the next page's keyset conditions.
+ */
+export async function handleCalendarEntries(
+	db: Kysely<Database>,
+	params: CalendarEntriesParams,
+): Promise<ApiResult<CalendarEntriesResponse>> {
+	try {
+		const cursor = params.cursor ? decodeCalendarCursor(params.cursor) : undefined;
+		const streams = await loadStreams(db);
+		const results = await Promise.all(
+			streams.map(async (stream) => {
+				const rows = await queryStream(db, stream, params, cursor);
+				return rows.map((row, position) => ({ row, stream, position }));
+			}),
+		);
+
+		const merged = results
+			.flat()
+			.toSorted(
+				(a, b) =>
+					compareText(a.row.event_at, b.row.event_at) ||
+					compareStreams(a.stream, b.stream) ||
+					a.position - b.position,
+			);
+
+		const items = merged.slice(0, params.limit).map(
+			({ row, stream }): CalendarEntry => ({
+				collection: stream.collection,
+				id: row.id,
+				locale: row.locale,
+				title: row.title,
+				status: row.status,
+				kind: stream.kind,
+				at: row.event_at,
+			}),
+		);
+		const last = items.at(-1);
+		const nextCursor =
+			merged.length > params.limit && last ? encodeCalendarCursor(last) : undefined;
+
+		return { success: true, data: nextCursor ? { items, nextCursor } : { items } };
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return { success: false, error: { code: "INVALID_CURSOR", message: error.message } };
+		}
+		console.error("Calendar error:", error);
+		return {
+			success: false,
+			error: { code: "CALENDAR_ERROR", message: "Failed to load calendar" },
+		};
+	}
+}

package/src/api/handlers/content.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
+import { after } from "../../after.js";
 import type { ContentFieldFilters } from "../../content-list-query.js";
 import { isSqlite } from "../../database/dialect-helpers.js";
 import { BylineRepository } from "../../database/repositories/byline.js";
@@ -46,6 +47,7 @@ import {
 	scheduledPolicyRejectionKey,
 	type ScheduledPolicyRejection,
 } from "../../plugins/content-policy.js";
+import { publishRedirectChanges } from "../../redirects/artifacts.js";
 import { invalidateRedirectCache } from "../../redirects/cache.js";
 import { requestCached } from "../../request-cache.js";
 import { isStoragelessFieldRow } from "../../schema/types.js";
@@ -779,7 +781,7 @@ async function createSlugChangeRedirect(
 	contentId: string,
 	oldPublishedAt: string | null,
 	newPublishedAt: string | null,
-): Promise<void> {
+): Promise<boolean> {
 	// A URL pattern has no locale token, so every locale variant of an entry
 	// generates the same URL, and slugs are unique per (slug, locale) — a
 	// translation may still hold the old slug. Redirecting away from a URL
@@ -787,7 +789,7 @@ async function createSlugChangeRedirect(
 	// middleware runs `order: "pre"`, so routing never gets a chance.
 	// Any surviving row counts, published or not: a draft that publishes later
 	// would otherwise be shadowed by the redirect.
-	if (await slugStillTaken(db, collection, oldSlug, contentId)) return;
+	if (await slugStillTaken(db, collection, oldSlug, contentId)) return false;
 
 	const collectionRow = await db
 		.selectFrom("_emdash_collections")
@@ -796,7 +798,7 @@ async function createSlugChangeRedirect(
 		.executeTakeFirst();
 
 	const redirectRepo = new RedirectRepository(db);
-	await redirectRepo.createAutoRedirect(
+	const redirect = await redirectRepo.createAutoRedirect(
 		collection,
 		oldSlug,
 		newSlug,
@@ -806,6 +808,7 @@ async function createSlugChangeRedirect(
 		newPublishedAt,
 	);
 	invalidateRedirectCache();
+	return redirect !== null;
 }
 
 /** Whether a row other than `contentId` still holds `slug` in this collection. */
@@ -865,6 +868,23 @@ function resolveBylineFilter(
 	return { mode: "any", bylineIds, includeInferred, locale };
 }
 
+/**
+ * Rows to skip for a numbered page, or `null` when the page can't be served
+ * (combined with a cursor, or past the safe-integer range).
+ */
+function pageOffset(params: { page: number; limit: number; cursor?: string }): number | null {
+	const offset = (params.page - 1) * params.limit;
+	if (
+		params.cursor !== undefined ||
+		!Number.isSafeInteger(params.page) ||
+		params.page < 1 ||
+		!Number.isSafeInteger(offset)
+	) {
+		return null;
+	}
+	return offset;
+}
+
 /**
  * Create content list handler
  */
@@ -873,6 +893,7 @@ export async function handleContentList(
 	collection: string,
 	params: {
 		cursor?: string;
+		page?: number;
 		limit?: number;
 		status?: string;
 		orderBy?: string;
@@ -890,6 +911,18 @@ export async function handleContentList(
 	},
 ): Promise<ApiResult<ContentListResponse>> {
 	try {
+		const limit = Math.max(1, Math.min(params.limit || 50, 100));
+		const offset =
+			params.page === undefined
+				? undefined
+				: pageOffset({ page: params.page, limit, cursor: params.cursor });
+		if (offset === null) {
+			return {
+				success: false,
+				error: { code: "VALIDATION_ERROR", message: "Invalid content page" },
+			};
+		}
+
 		const repo = new ContentRepository(db);
 		const where: FindManyOptions["where"] = {};
 		if (params.status) where.status = params.status;
@@ -937,7 +970,8 @@ export async function handleContentList(
 
 		const result = await repo.findMany(collection, {
 			cursor: params.cursor,
-			limit: params.limit || 50,
+			offset,
+			limit,
 			where: Object.keys(where).length > 0 ? where : undefined,
 			orderBy: params.orderBy
 				? { field: params.orderBy, direction: params.order || "desc" }
@@ -1508,6 +1542,7 @@ export async function handleContentUpdate(
 		// Wrap content + SEO writes in a transaction for atomicity.
 		// The _rev check is inside the transaction so the read-then-write
 		// is atomic -- no concurrent write can slip between the check and update.
+		let redirectCreated = false;
 		const item = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
 			const bylineRepo = new BylineRepository(trx);
@@ -1597,7 +1632,7 @@ export async function handleContentUpdate(
 			// pre-update date (the URL that was actually live) and the new URL
 			// the post-update one.
 			if (oldSlug && body.slug) {
-				await createSlugChangeRedirect(
+				redirectCreated = await createSlugChangeRedirect(
 					trx,
 					collection,
 					oldSlug,
@@ -1652,6 +1687,7 @@ export async function handleContentUpdate(
 
 			return updated;
 		});
+		if (redirectCreated) after(() => publishRedirectChanges(db));
 
 		return {
 			success: true,
@@ -2028,15 +2064,32 @@ export async function handleContentPermanentDelete(
 export async function handleContentListTrashed(
 	db: Kysely<Database>,
 	collection: string,
-	options: { limit?: number; cursor?: string; locale?: string } = {},
-): Promise<ApiResult<{ items: TrashedContentItem[]; nextCursor?: string }>> {
+	options: { limit?: number; cursor?: string; page?: number; locale?: string } = {},
+): Promise<ApiResult<{ items: TrashedContentItem[]; nextCursor?: string; total?: number }>> {
 	try {
+		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		const offset =
+			options.page === undefined
+				? undefined
+				: pageOffset({ page: options.page, limit, cursor: options.cursor });
+		if (offset === null) {
+			return {
+				success: false,
+				error: { code: "VALIDATION_ERROR", message: "Invalid content page" },
+			};
+		}
+
 		const repo = new ContentRepository(db);
-		const result = await repo.findTrashed(collection, {
-			limit: options.limit,
-			cursor: options.cursor,
-			where: { locale: options.locale },
-		});
+		const where = { locale: options.locale };
+		// Settled like findMany's count, so a rejection can't leave the other
+		// query holding a pooled connection.
+		const [rowsResult, countResult] = await Promise.allSettled([
+			repo.findTrashed(collection, { limit, cursor: options.cursor, offset, where }),
+			offset === undefined ? undefined : repo.countTrashed(collection, where),
+		]);
+		if (rowsResult.status === "rejected") throw rowsResult.reason;
+		if (countResult.status === "rejected") throw countResult.reason;
+		const result = rowsResult.value;
 
 		return {
 			success: true,
@@ -2056,6 +2109,7 @@ export async function handleContentListTrashed(
 					deletedAt: item.deletedAt,
 				})),
 				nextCursor: result.nextCursor,
+				total: countResult.value,
 			},
 		};
 	} catch (error) {
@@ -2298,6 +2352,7 @@ export async function handleContentPublish(
 ): Promise<ApiResult<ContentResponse>> {
 	try {
 		const expectedRevision = decodeRevisionPrecondition(options._rev);
+		let redirectCreated = false;
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
@@ -2417,7 +2472,7 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				await createSlugChangeRedirect(
+				redirectCreated = await createSlugChangeRedirect(
 					trx,
 					collection,
 					existing.slug,
@@ -2430,6 +2485,7 @@ export async function handleContentPublish(
 
 			return published;
 		});
+		if (redirectCreated) after(() => publishRedirectChanges(db));
 
 		const hasSeo = await collectionHasSeo(db, collection);
 		await hydrateSeo(db, collection, item, hasSeo);