emdash 1.1.0 → 1.3.0

package/src/import/index.ts

@@ -69,6 +69,7 @@ export {
 	getUrlSources,
 	probeUrl,
 	clearSources,
+	SiteChallengeError,
 } from "./registry.js";
 
 // SSRF protection

package/src/import/registry.ts

@@ -13,6 +13,20 @@ const TRAILING_SLASHES_PATTERN = /\/+$/;
 /** Registered import sources */
 const sources = new Map<string, ImportSource>();
 
+/**
+ * A bot-protection challenge page (for example Cloudflare's "Just a moment...")
+ * answered instead of the source's API. Server-side requests can't solve it,
+ * so the site owner has to let the importer's requests through.
+ */
+export class SiteChallengeError extends Error {
+	constructor() {
+		super(
+			"Cloudflare's bot protection answered with a challenge page instead of the EmDash Exporter API. Let requests to /wp-json/emdash/v1/ and ?rest_route=/emdash/v1/ through (for example with a WAF custom rule that skips bot protection), or pause bot protection during the migration.",
+		);
+		this.name = "SiteChallengeError";
+	}
+}
+
 /**
  * Register an import source
  */
@@ -69,6 +83,7 @@ export async function probeUrl(url: string): Promise<ProbeResult> {
 
 	const results: SourceProbeResult[] = [];
 	const urlSources = getUrlSources();
+	let challenged = false;
 
 	// Probe all sources in parallel
 	const probePromises = urlSources.map(async (source) => {
@@ -78,6 +93,7 @@ export async function probeUrl(url: string): Promise<ProbeResult> {
 				return result;
 			}
 		} catch (error) {
+			if (error instanceof SiteChallengeError) challenged = true;
 			// Probe failed, skip this source
 			console.debug(`Probe failed for ${source.id}:`, error);
 		}
@@ -101,6 +117,7 @@ export async function probeUrl(url: string): Promise<ProbeResult> {
 		isWordPress: results.length > 0,
 		bestMatch: results[0] ?? null,
 		allMatches: results,
+		...(challenged && results.length === 0 ? { challenged: true } : {}),
 	};
 }
 

package/src/import/sources/wordpress-plugin.ts

@@ -10,6 +10,7 @@ import { gutenbergToPortableText } from "@emdash-cms/gutenberg-to-portable-text"
 import { encodeBase64 } from "../../utils/base64.js";
 import type { PluginComment } from "../comments.js";
 import type { PluginMenu } from "../menus.js";
+import { SiteChallengeError } from "../registry.js";
 import { ssrfSafeFetch, validateExternalUrl } from "../ssrf.js";
 import type {
 	ImportSource,
@@ -31,9 +32,11 @@ import {
 	normalizeUrl,
 	checkSchemaCompatibility,
 	isPluginBookkeepingMeta,
+	isTypeCompatible,
 	relativizeContentLinks,
 	sanitizeFieldSlug,
 } from "../utils.js";
+import { parseWxrDate } from "./wxr.js";
 
 // =============================================================================
 // API Response Types
@@ -127,6 +130,8 @@ interface PluginAnalyzeResponse {
 	acf?: Array<{
 		key: string;
 		title: string;
+		/** ACF location rules: OR-groups of AND-ed rules */
+		location?: Array<Array<{ param: string; operator: string; value: string }>>;
 		fields: Array<{
 			key: string;
 			name: string;
@@ -221,6 +226,16 @@ interface PluginMediaItem {
 /** Pattern to remove spaces from application passwords */
 const SPACE_PATTERN = /\s/g;
 
+/**
+ * Identifying User-Agent for outbound WordPress plugin importer requests.
+ *
+ * The importer sends this on both plugin API calls and direct media downloads.
+ * Cloudflare Workers' fetch() has no default User-Agent, and some hosts reject
+ * requests without one (returning 403). Using the same value everywhere keeps
+ * behavior predictable when the importer is retried against a bot-filtered host.
+ */
+const IMPORTER_USER_AGENT = "EmDash-Importer/1.0";
+
 /**
  * Build the REST API URL for a plugin endpoint.
  *
@@ -259,9 +274,12 @@ async function fetchPluginApi(
 	siteUrl: string,
 	path: string,
 	params: Record<string, string>,
-	headers: HeadersInit,
+	headersInit: HeadersInit,
 	timeoutMs: number,
 ): Promise<Response> {
+	const headers = new Headers(headersInit);
+	headers.set("User-Agent", IMPORTER_USER_AGENT);
+
 	let pretty: Response | null = null;
 	try {
 		pretty = await ssrfSafeFetch(pluginApiUrl(siteUrl, path, params), {
@@ -273,13 +291,17 @@ async function fetchPluginApi(
 	}
 	// Any response other than 404 (including 401/403/500) is authoritative:
 	// the route exists, so don't mask the real error with a fallback attempt.
-	if (pretty && pretty.status !== 404) {
-		return pretty;
+	const response =
+		pretty && pretty.status !== 404
+			? pretty
+			: await ssrfSafeFetch(pluginApiUrl(siteUrl, path, params, true), {
+					headers,
+					signal: AbortSignal.timeout(timeoutMs),
+				});
+	if (response.headers.get("cf-mitigated") === "challenge") {
+		throw new SiteChallengeError();
 	}
-	return ssrfSafeFetch(pluginApiUrl(siteUrl, path, params, true), {
-		headers,
-		signal: AbortSignal.timeout(timeoutMs),
-	});
+	return response;
 }
 
 // =============================================================================
@@ -352,7 +374,8 @@ export const wordpressPluginSource: ImportSource = {
 				},
 				i18n: pluginI18nToDetection(data.i18n),
 			};
-		} catch {
+		} catch (error) {
+			if (error instanceof SiteChallengeError) throw error;
 			return null;
 		}
 	},
@@ -398,8 +421,33 @@ export const wordpressPluginSource: ImportSource = {
 				// the prepare step creates them — without this, execute() has no
 				// matching schema fields and silently drops the values.
 				const knownSlugs = new Set(requiredFields.map((f) => f.slug));
+				const metaTypes = new Map(
+					(pt.custom_fields ?? []).map((field) => [
+						sanitizeFieldSlug(field.key),
+						mapInferredFieldType(field.inferred_type),
+					]),
+				);
+				const jsonAcfFields: AcfFieldInfo[] = [];
+				for (const acfField of acfFieldsForPostType(data.acf, pt.name)) {
+					const slug = sanitizeFieldSlug(acfField.name);
+					if (knownSlugs.has(slug)) continue;
+					knownSlugs.add(slug);
+					const type = acfImportFieldType(
+						acfField,
+						existingCollection?.fields.get(slug)?.type,
+						metaTypes.get(slug),
+					);
+					if (type === "json") jsonAcfFields.push(acfField);
+					requiredFields.push({
+						slug,
+						label: acfField.label || fieldLabelFromKey(acfField.name),
+						type,
+						required: false,
+					});
+				}
 				for (const customField of pt.custom_fields ?? []) {
 					if (isPluginBookkeepingMeta(customField.key)) continue;
+					if (isAcfRowMeta(customField.key, jsonAcfFields)) continue;
 					const slug = sanitizeFieldSlug(customField.key);
 					if (knownSlugs.has(slug)) continue;
 					knownSlugs.add(slug);
@@ -454,6 +502,7 @@ export const wordpressPluginSource: ImportSource = {
 					page++;
 				}
 			} catch (e) {
+				if (e instanceof SiteChallengeError) throw e;
 				console.warn("Failed to fetch media list:", e);
 			}
 		}
@@ -530,7 +579,11 @@ export const wordpressPluginSource: ImportSource = {
 		validateExternalUrl(url);
 
 		// Media URLs are publicly accessible on WP (ssrfSafeFetch validates redirects)
-		const response = await ssrfSafeFetch(url);
+		const response = await ssrfSafeFetch(url, {
+			headers: {
+				"User-Agent": IMPORTER_USER_AGENT,
+			},
+		});
 		if (!response.ok) {
 			throw new Error(`Failed to fetch media: ${response.statusText}`);
 		}
@@ -606,6 +659,96 @@ function mapInferredFieldType(inferredType: string): string {
 	return VALID_INFERRED_TYPES.has(inferredType) ? inferredType : "string";
 }
 
+/**
+ * EmDash field types for ACF field types that hold a single value and return
+ * a scalar by default. When a return format makes `get_fields()` give an
+ * array, the raw meta value fills the field instead. Every other ACF type
+ * (select, checkbox, relationship, repeater, gallery, ...) can return several
+ * values or an object and is stored as JSON.
+ */
+const ACF_FIELD_TYPES: Record<string, string> = {
+	text: "string",
+	email: "string",
+	url: "string",
+	password: "string",
+	radio: "string",
+	button_group: "string",
+	color_picker: "string",
+	oembed: "string",
+	date_picker: "string",
+	date_time_picker: "string",
+	time_picker: "string",
+	textarea: "text",
+	wysiwyg: "text",
+	number: "number",
+	range: "number",
+	true_false: "boolean",
+};
+
+type AcfFieldInfo = NonNullable<PluginAnalyzeResponse["acf"]>[number]["fields"][number];
+
+/**
+ * The field type for an ACF field. A collection created by an earlier
+ * import holds the type the raw meta suggested for that key; that type is
+ * kept so the collection still imports, and the field's flattened row
+ * keys then keep filling their own fields.
+ */
+function acfImportFieldType(
+	field: AcfFieldInfo,
+	existingType: string | undefined,
+	metaType: string | undefined,
+): string {
+	const acfType = ACF_FIELD_TYPES[field.type] ?? "json";
+	if (
+		existingType &&
+		metaType &&
+		!isTypeCompatible(acfType, existingType) &&
+		isTypeCompatible(metaType, existingType)
+	) {
+		return existingType;
+	}
+	return acfType;
+}
+
+/** ACF layout-only field types that hold no value */
+const ACF_LAYOUT_TYPES = new Set(["tab", "message", "accordion"]);
+
+/** Fields of the ACF field groups whose location rules include `post_type == <postType>` */
+function acfFieldsForPostType(
+	groups: PluginAnalyzeResponse["acf"],
+	postType: string,
+): AcfFieldInfo[] {
+	const fields: AcfFieldInfo[] = [];
+	for (const group of groups ?? []) {
+		const assigned = group.location?.some((rules) =>
+			rules.some(
+				(rule) => rule.param === "post_type" && rule.operator === "==" && rule.value === postType,
+			),
+		);
+		if (!assigned) continue;
+		for (const field of group.fields) {
+			if (field.name && !ACF_LAYOUT_TYPES.has(field.type)) fields.push(field);
+		}
+	}
+	return fields;
+}
+
+const ACF_ROW_SUFFIX = /^_\d+_/;
+
+/**
+ * ACF stores repeater and flexible content rows as `<name>_<row>_<sub>`
+ * meta keys. Their values already arrive whole under the parent field in
+ * `get_fields()`.
+ */
+function isAcfRowMeta(key: string, acfFields: AcfFieldInfo[]): boolean {
+	return acfFields.some(
+		(field) =>
+			(field.type === "repeater" || field.type === "flexible_content") &&
+			key.startsWith(field.name) &&
+			ACF_ROW_SUFFIX.test(key.slice(field.name.length)),
+	);
+}
+
 const FIELD_KEY_SEPARATORS = /[_-]+/;
 
 /** Derive a human label from a meta key: "event_start-date" -> "Event Start Date" */
@@ -722,8 +865,8 @@ function pluginPostToNormalizedItem(post: PluginPost, siteUrl: string): Normaliz
 		title: post.title,
 		content,
 		excerpt: post.excerpt || undefined,
-		date: new Date(post.date_gmt || post.date),
-		modified: post.modified_gmt ? new Date(post.modified_gmt) : new Date(post.modified),
+		date: parseWxrDate(post.date_gmt, undefined, post.date) ?? new Date(Number.NaN),
+		modified: parseWxrDate(post.modified_gmt, undefined, post.modified),
 		author: post.author?.login,
 		categories,
 		tags,

package/src/import/types.ts

@@ -139,6 +139,8 @@ export interface ProbeResult {
 	bestMatch: SourceProbeResult | null;
 	/** All matching sources */
 	allMatches: SourceProbeResult[];
+	/** No source matched because a bot-protection challenge blocked the probe */
+	challenged?: boolean;
 }
 
 // =============================================================================
@@ -350,6 +352,7 @@ export interface FetchOptions {
 export interface ImportResult {
 	success: boolean;
 	imported: number;
+	/** Entries not imported because the slug already exists in the collection and locale. */
 	skipped: number;
 	errors: Array<{ title: string; error: string }>;
 	byCollection: Record<string, number>;

package/src/import/utils.ts

@@ -27,6 +27,11 @@ export const INTERNAL_POST_TYPES = [
 	"wp_template_part",
 	"attachment", // Handled separately as media
 	"wp_block", // Handled separately as sections (reusable blocks)
+	"acf-field-group",
+	"acf-field",
+	"acf-post-type",
+	"acf-taxonomy",
+	"acf-ui-options-page",
 ];
 
 /** Internal meta key prefixes to filter out */
@@ -378,9 +383,8 @@ export function relativizeContentLinks(blocks: PortableTextBlock[], siteUrl: str
 			case "htmlBlock":
 				block.html = block.html.replace(
 					hrefPattern,
-					(_m, _quote: string, path: string | undefined) => {
-						return `href="${path || "/"}"`;
-					},
+					(match, _quote: string, path: string | undefined) =>
+						path?.startsWith("/wp-content/") ? match : `href="${path || "/"}"`,
 				);
 				break;
 			// URL-less or media-only blocks: media URLs are the media pass's job

package/src/index.ts

@@ -132,6 +132,7 @@ export type {
 	PortableTextCodeBlock,
 	PortableTextHtmlBlock,
 	PortableTextIframeBlock,
+	PortableTextVideoBlock,
 	PortableTextTableAlignment,
 	PortableTextTableBlock,
 	PortableTextTableCell,
@@ -235,6 +236,8 @@ export type {
 	SignedUploadOptions,
 	UploadResult,
 	DownloadResult,
+	DownloadOptions,
+	ByteRange,
 	ListResult,
 	ListOptions,
 	FileInfo,

package/src/loader.ts

@@ -16,6 +16,7 @@ import { Kysely, type RawBuilder, sql, type Dialect } from "kysely";
 
 import { buildStatusCondition, isPostgres } from "./database/dialect-helpers.js";
 import { kyselyLogOption } from "./database/instrumentation.js";
+import { jsonTextValues } from "./database/json-recordset.js";
 import { selectTaxonomyDefs } from "./database/repositories/taxonomy-def.js";
 import { decodeCursor, encodeCursor, InvalidCursorError } from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
@@ -565,6 +566,21 @@ function mapRowToData(
 		}
 	}
 
+	stashSortValue(data, row, sortColumn, rawValues);
+
+	return data;
+}
+
+/**
+ * Keep the row's raw sort value on `data` (non-enumerable) so the next-page
+ * cursor is encoded from the same value the keyset query compares against.
+ */
+function stashSortValue(
+	data: Record<string, unknown>,
+	row: Record<string, unknown>,
+	sortColumn: string | undefined,
+	rawValues: Record<string, SortCursorValue> = {},
+): void {
 	if (sortColumn !== undefined && sortColumn in row) {
 		rawValues[sortColumn] = sortCursorValue(row[sortColumn]);
 	}
@@ -574,8 +590,92 @@ function mapRowToData(
 		configurable: false,
 		writable: false,
 	});
+}
 
-	return data;
+/**
+ * Fetch the draft revision snapshots for the rows a collection read should
+ * serve as drafts, keyed by content row ID. One query per `SQL_BATCH_SIZE`
+ * revisions; nothing runs unless `scope` is set.
+ */
+async function loadDraftRevisions(
+	db: Kysely<Database>,
+	rows: Record<string, unknown>[],
+	scope: DraftRevisionScope | undefined,
+): Promise<Map<string, Record<string, unknown>>> {
+	const drafts = new Map<string, Record<string, unknown>>();
+	if (!scope) return drafts;
+	const wanted = new Map<string, string>();
+	for (const row of rows) {
+		const draftId = rowStr(row, "draft_revision_id");
+		if (!draftId) continue;
+		if (
+			scope !== "all" &&
+			scope.id !== rowStr(row, "id") &&
+			scope.id !== rowStr(row, "slug") &&
+			scope.id !== entryIdForRow(row)
+		) {
+			continue;
+		}
+		wanted.set(draftId, rowStr(row, "id"));
+	}
+	for (const ids of chunks([...wanted.keys()], SQL_BATCH_SIZE)) {
+		const result = await sql<{ id: string; data: string }>`
+			SELECT id, data FROM revisions WHERE id IN (${sql.join(ids)})
+		`.execute(db);
+		for (const revision of result.rows) {
+			const rowId = wanted.get(revision.id);
+			if (rowId) drafts.set(rowId, JSON.parse(revision.data));
+		}
+	}
+	return drafts;
+}
+
+/**
+ * Build an entry whose content fields come from a revision snapshot, keeping
+ * the system metadata of the content table row.
+ */
+function revisionEntry(
+	row: Record<string, unknown>,
+	parsed: Record<string, unknown>,
+	booleanFields: ReturnType<typeof parseFoldedBooleanFields>,
+	sortColumn?: string,
+) {
+	const systemData: Record<string, unknown> = {};
+	for (const [key, mappedKey] of Object.entries(INCLUDE_IN_DATA)) {
+		if (key in row) {
+			if (DATE_COLUMNS.has(key)) {
+				systemData[mappedKey] = typeof row[key] === "string" ? new Date(row[key]) : null;
+			} else {
+				systemData[mappedKey] = row[key];
+			}
+		}
+	}
+	// Use slug from revision metadata if present, else from content table
+	const slug = typeof parsed._slug === "string" ? parsed._slug : rowStr(row, "slug");
+	const revSlug = slug || rowStr(row, "id");
+	const i18nConfig = virtualConfig?.i18n;
+	const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
+	const revLocale = rowStr(row, "locale");
+	const shouldPrefixRev =
+		i18nEnabled &&
+		revLocale !== "" &&
+		(revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
+	const data: Record<string, unknown> = {
+		...systemData,
+		slug,
+		...mapRevisionData(parsed, booleanFields),
+	};
+	stashSortValue(data, row, sortColumn);
+	return {
+		id: shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug,
+		slug,
+		status: rowStr(row, "status", "draft"),
+		data,
+		cacheHint: {
+			tags: [rowStr(row, "id")],
+			lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
+		},
+	};
 }
 
 /**
@@ -723,13 +823,17 @@ let virtualConfig:
 	| undefined;
 let virtualCreateDialect: ((config: unknown) => Dialect) | undefined;
 
-async function loadVirtualModules() {
+async function loadVirtualConfig() {
 	if (virtualConfig === undefined) {
 		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 		// @ts-ignore - virtual module
 		const configModule = await import("virtual:emdash/config");
 		virtualConfig = configModule.default;
 	}
+}
+
+async function loadVirtualModules() {
+	await loadVirtualConfig();
 	if (virtualCreateDialect === undefined) {
 		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 		// @ts-ignore - virtual module
@@ -991,13 +1095,34 @@ function bindableFilterValue(value: unknown): unknown {
  * Build AND conditions for non-taxonomy field filters.
  * Returns an array of sql fragments; empty if no field filters apply.
  * Field names are validated against FIELD_NAME_PATTERN to prevent injection.
+ *
+ * D1 allows 100 bound parameters per statement, and an array filter binds one
+ * per value. So when the arrays in `fields` hold more than `SQL_BATCH_SIZE`
+ * values between them, the longest arrays are bound as a single JSON parameter
+ * each (`IN (SELECT value FROM json_each(?))`, or `jsonb_array_elements_text`
+ * on PostgreSQL) until the rest fit. The statement stays one query, so
+ * ordering, cursors, limit and offset stay in the database. Values bound that
+ * way compare as text.
  */
 function buildFieldConditions(
+	db: Kysely<Database>,
 	fields: Record<string, WhereValue>,
 	tablePrefix?: string,
 ): ReturnType<typeof sql>[] {
 	const conditions: ReturnType<typeof sql>[] = [];
 
+	const arrayLengths = Object.entries(fields)
+		.filter((entry): entry is [string, string[]] => Array.isArray(entry[1]))
+		.map(([key, value]) => [key, value.length] as const)
+		.toSorted((a, b) => b[1] - a[1]);
+	let inlineValues = arrayLengths.reduce((sum, [, length]) => sum + length, 0);
+	const asJson = new Set<string>();
+	for (const [key, length] of arrayLengths) {
+		if (inlineValues <= SQL_BATCH_SIZE) break;
+		asJson.add(key);
+		inlineValues -= length;
+	}
+
 	for (const [key, value] of Object.entries(fields)) {
 		if (!FIELD_NAME_PATTERN.test(key)) {
 			console.warn(`[emdash] where filter: invalid field name "${key}" ignored`);
@@ -1008,12 +1133,24 @@ function buildFieldConditions(
 
 		if (isWhereRange(value)) {
 			const { gt, gte, lt, lte } = value;
+			if (gt === undefined && gte === undefined && lt === undefined && lte === undefined) {
+				// An object with no bound (for example `{ in: [...] }`) would add no
+				// condition, and the query would return unfiltered rows.
+				console.warn(
+					`[emdash] where filter: "${key}" is an object with none of gt/gte/lt/lte and was ignored (use an array for IN)`,
+				);
+				continue;
+			}
 			if (gt !== undefined) conditions.push(sql`${ref} > ${bindableFilterValue(gt)}`);
 			if (gte !== undefined) conditions.push(sql`${ref} >= ${bindableFilterValue(gte)}`);
 			if (lt !== undefined) conditions.push(sql`${ref} < ${bindableFilterValue(lt)}`);
 			if (lte !== undefined) conditions.push(sql`${ref} <= ${bindableFilterValue(lte)}`);
 		} else if (Array.isArray(value)) {
-			if (value.length > 0) {
+			if (value.length === 0) continue;
+			if (asJson.has(key)) {
+				const values = value.map((v) => String(bindableFilterValue(v)));
+				conditions.push(sql`${ref} IN (${jsonTextValues(db, values)})`);
+			} else {
 				conditions.push(
 					sql`${ref} IN (${sql.join(value.map((v) => sql`${bindableFilterValue(v)}`))})`,
 				);
@@ -1429,6 +1566,16 @@ export interface OffsetCollectionFilter extends CollectionFilterBase {
  */
 export type CollectionFilter = CursorCollectionFilter | OffsetCollectionFilter;
 
+/**
+ * Which entries a collection read serves from their draft revision: `"all"`
+ * (edit mode) or one entry's ID or slug (a preview token, scoped to that
+ * entry). Set by `getEmDashCollection` from the request context; not part of
+ * the public filter.
+ */
+type DraftRevisionScope = "all" | { id: string };
+
+type LoaderCollectionFilter = CollectionFilter & { draftRevisions?: DraftRevisionScope };
+
 /**
  * Filter for loadEntry - type and id are required
  */
@@ -1461,6 +1608,9 @@ let dbInstance: Kysely<Database> | null = null;
  * Initializes the default database on first call using config from virtual module.
  */
 export async function getDb(): Promise<Kysely<Database>> {
+	// Entry IDs depend on the i18n config, so it must be loaded on the
+	// request-scoped path too, not only when the default database is opened.
+	await loadVirtualConfig();
 	// Per-request DB override via ALS (normal mode)
 	const ctx = getRequestContext();
 	if (ctx?.db) {
@@ -1516,7 +1666,7 @@ export async function loadPublishedDates(type: string, locale?: string) {
  * };
  * ```
  */
-export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFilter> {
+export function emdashLoader(): LiveLoader<EntryData, EntryFilter, LoaderCollectionFilter> {
 	return {
 		name: "emdash",
 
@@ -1705,7 +1855,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					const statusCondition = buildStatusCondition(db, status);
 					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
 					const cursorCond = cursorCondition ? sql`AND ${cursorCondition}` : sql``;
-					const fieldConds = buildFieldConditions(fieldFilters);
+					const fieldConds = buildFieldConditions(db, fieldFilters);
 					const fieldCondsSQL =
 						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
 
@@ -1790,7 +1940,14 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Map rows to entries
 				const booleanFields = parseFoldedBooleanFields(rows[0]);
+				const drafts = await loadDraftRevisions(db, rows, filter?.draftRevisions);
 				const entries = rows.map((row) => {
+					const draft = drafts.get(rowStr(row, "id"));
+					if (draft) {
+						const revEntry = revisionEntry(row, draft, booleanFields, sortColumn);
+						stashFolded(revEntry.data, row);
+						return revEntry;
+					}
 					const id = entryIdForRow(row);
 					const data = mapRowToData(row, booleanFields, sortColumn);
 					stashFolded(data, row);
@@ -1941,8 +2098,6 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				// no-op: extractSeo() returns null when the aliases are absent.
 				expandFoldedSeo(row);
 
-				const i18nConfig = virtualConfig?.i18n;
-				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
 				const entryId = entryIdForRow(row);
 
 				// Preview mode: override content fields with revision data,
@@ -1957,52 +2112,22 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 					const revData = revRow.rows[0];
 					if (revData) {
-						const parsed: Record<string, unknown> = JSON.parse(revData.data);
-						// System metadata from content table + content fields from revision
-						const systemData: Record<string, unknown> = {};
-						for (const [key, mappedKey] of Object.entries(INCLUDE_IN_DATA)) {
-							if (key in row) {
-								if (DATE_COLUMNS.has(key)) {
-									systemData[mappedKey] = typeof row[key] === "string" ? new Date(row[key]) : null;
-								} else {
-									systemData[mappedKey] = row[key];
-								}
-							}
-						}
-						// Use slug from revision metadata if present, else from content table
-						const slug = typeof parsed._slug === "string" ? parsed._slug : rowStr(row, "slug");
-						const revSlug = slug || rowStr(row, "id");
-						const revLocale = rowStr(row, "locale");
-						const shouldPrefixRev =
-							i18nEnabled &&
-							revLocale !== "" &&
-							(revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
-						const revId = shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug;
+						const revEntry = revisionEntry(
+							row,
+							JSON.parse(revData.data),
+							parseFoldedBooleanFields(row),
+						);
 						// SEO is not revisioned — it comes from the content row's
 						// joined _emdash_seo columns, not the revision snapshot.
-						const revEntryData: Record<string, unknown> = {
-							...systemData,
-							slug,
-							...mapRevisionData(parsed, parseFoldedBooleanFields(row)),
-						};
 						const revSeo = extractSeo(row);
 						if (revSeo) {
-							revEntryData.seo = revSeo;
+							revEntry.data.seo = revSeo;
 							// SEO comes from the content row, so the panel data is
 							// valid for the entry regardless of the revision shown.
 							primeSeoPanel(type, rowStr(row, "id"), revSeo);
 						}
-						stashFolded(revEntryData, row);
-						return {
-							id: revId,
-							slug,
-							status: rowStr(row, "status", "draft"),
-							data: revEntryData,
-							cacheHint: {
-								tags: [rowStr(row, "id")],
-								lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
-							},
-						};
+						stashFolded(revEntry.data, row);
+						return revEntry;
 					}
 				}