emdash 0.32.0 → 0.34.0

package/dist/{content-CpfKV9QE.mjs → content-BNfwh7xX.mjs}

@@ -1,10 +1,11 @@
-import { o as __exportAll } from "./runner-BsI18UgP.mjs";
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { o as invalidateCollectionCache } from "./object-cache-Bok5j2ae.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-D5dlPeRb.mjs";
-import { n as isMissingTableError } from "./db-errors-CcWLaRiR.mjs";
-import { n as slugify } from "./slugify-C_tqlU4G.mjs";
-import { a as encodeCursor, i as decodeCursor, r as ScheduledNotDueError, t as EmDashValidationError } from "./types-XrQQ-Aex.mjs";
+import { o as __exportAll } from "./runner-BiDvq5dv.mjs";
+import { t as validateIdentifier } from "./validate-BpwoDOgt.mjs";
+import { c as invalidateCollectionCache } from "./object-cache-71tPfV4A.mjs";
+import { c as isIndexableFieldType } from "./types-75KIqzL9.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-DfPax1I0.mjs";
+import { n as isMissingTableError } from "./db-errors-Cl-sKYTm.mjs";
+import { n as slugify } from "./slugify-B994zkXC.mjs";
+import { a as ScheduledNotDueError, i as InvalidCursorError, n as ContentMutationConflictError, o as decodeCursor, r as EmDashValidationError, s as encodeCursor, t as ContentCollectionNotFoundError } from "./types-CQPWhPxE.mjs";
 import { sql } from "kysely";
 import { monotonicFactory, ulid } from "ulidx";
 
@@ -76,6 +77,15 @@ var RevisionRepository = class {
 		await this.db.insertInto("revisions").values(row).execute();
 		const revision = await this.findById(id);
 		if (!revision) throw new Error("Failed to create revision");
+		try {
+			await this.db.insertInto("_emdash_revision_prune_queue").values({
+				collection: input.collection,
+				entry_id: input.entryId,
+				revision_id: id
+			}).onConflict((conflict) => conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: id })).execute();
+		} catch (error) {
+			console.error(`[revisions] Failed to queue revision pruning for ${input.collection}/${input.entryId}:`, error);
+		}
 		return revision;
 	}
 	/**
@@ -115,23 +125,56 @@ var RevisionRepository = class {
 	*/
 	async deleteByEntry(collection, entryId) {
 		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
+		try {
+			await this.db.deleteFrom("_emdash_revision_prune_queue").where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+		} catch (error) {
+			console.error(`[revisions] Failed to clear queued revision pruning for ${collection}/${entryId}:`, error);
+		}
 		return Number(result.numDeletedRows ?? 0);
 	}
 	/**
 	* Delete old revisions, keeping the most recent N
 	*/
-	async pruneOldRevisions(collection, entryId, keepCount) {
-		const keepIds = (await this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount).execute()).map((r) => r.id);
+	async pruneOldRevisions(collection, entryId, keepCount, throughRevisionId) {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		let keepQuery = this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount);
+		if (throughRevisionId) keepQuery = keepQuery.where("id", "<=", throughRevisionId);
+		const keepIds = (await keepQuery.execute()).map((r) => r.id);
 		if (keepIds.length === 0) return 0;
-		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).where("id", "not in", keepIds).executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0);
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE collection = ${collection}
+			AND entry_id = ${entryId}
+			${throughRevisionId ? sql`AND id <= ${throughRevisionId}` : sql``}
+			AND id NOT IN (${sql.join(keepIds.map((id) => sql`${id}`))})
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
+		return Number(result.numAffectedRows ?? 0);
 	}
-	/**
-	* Update revision data in place
-	* Used for autosave to avoid creating many small revisions.
-	*/
-	async updateData(id, data) {
-		await this.db.updateTable("revisions").set({ data: JSON.stringify(data) }).where("id", "=", id).execute();
+	async pruneQueuedEntry(collection, entryId, queuedRevisionId, keepCount) {
+		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount, queuedRevisionId);
+		await this.db.deleteFrom("_emdash_revision_prune_queue").where("collection", "=", collection).where("entry_id", "=", entryId).where("revision_id", "=", queuedRevisionId).execute();
+		return pruned;
+	}
+	async deleteIfUnreferenced(collection, entryId, revisionId) {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		return ((await sql`
+			DELETE FROM revisions
+			WHERE id = ${revisionId}
+			AND collection = ${collection}
+			AND entry_id = ${entryId}
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
 	}
 	/**
 	* Convert database row to Revision object
@@ -150,9 +193,65 @@ var RevisionRepository = class {
 
 //#endregion
 //#region src/database/repositories/content.ts
-var content_exports = /* @__PURE__ */ __exportAll({ ContentRepository: () => ContentRepository });
+var content_exports = /* @__PURE__ */ __exportAll({
+	ContentRepository: () => ContentRepository,
+	isSystemOrderField: () => isSystemOrderField
+});
 const ULID_PATTERN = /^[0-9A-Z]{26}$/;
+const SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+const MAX_DRAFT_STAGE_ATTEMPTS = 32;
 const LIKE_WILDCARD_RE = /[\\%_]/g;
+const MAX_INDEXED_FIELD_FILTERS = 20;
+const MAX_IN_FILTER_VALUES = SQL_BATCH_SIZE;
+const MAX_FILTER_STRING_LENGTH = 2048;
+function nullableColumnMatch(column, value) {
+	validateIdentifier(column, "content column");
+	return value === null ? sql`${sql.ref(column)} IS NULL` : sql`${sql.ref(column)} = ${value}`;
+}
+function sameStoredValue(left, right) {
+	return Object.is(serializeValue(left), serializeValue(right));
+}
+function matchesPublication(observed, existing, revision, revisionId, slug, publishedAt, updatedAt) {
+	if (observed.version !== existing.version + 1 || observed.status !== "published" || observed.slug !== slug || observed.liveRevisionId !== revisionId || observed.draftRevisionId !== null || observed.scheduledAt !== null || observed.publishedAt !== publishedAt || observed.updatedAt !== updatedAt) return false;
+	return Object.entries(revision.data).every(([key, value]) => SYSTEM_COLUMNS.has(key) || key.startsWith("_") || sameStoredValue(observed.data[key], value));
+}
+function matchesLifecyclePublication(observed, existing, liveRevisionId, publishedAt, updatedAt) {
+	if (observed.version !== existing.version + 1 || observed.status !== "published" || observed.slug !== existing.slug || observed.liveRevisionId !== liveRevisionId || observed.draftRevisionId !== null || observed.scheduledAt !== null || observed.publishedAt !== publishedAt || observed.updatedAt !== updatedAt) return false;
+	return Object.entries(existing.data).every(([key, value]) => sameStoredValue(observed.data[key], value));
+}
+function matchesPublicationFence(observed, existing) {
+	return observed.version === existing.version && observed.status === existing.status && observed.liveRevisionId === existing.liveRevisionId && observed.draftRevisionId === existing.draftRevisionId && observed.scheduledAt === existing.scheduledAt;
+}
+function isConfirmedStatementFailure(error) {
+	if (typeof error !== "object" || error === null || !("code" in error)) return false;
+	const code = error.code;
+	return typeof code === "string" && (code.startsWith("SQLITE_") || SQLSTATE_PATTERN.test(code));
+}
+function encodeIndexedFieldCursor(field, value, id) {
+	const payload = {
+		version: 1,
+		field,
+		value
+	};
+	return encodeCursor(JSON.stringify(payload), id);
+}
+function decodeIndexedFieldCursor(cursor, field) {
+	const { orderValue, id } = decodeCursor(cursor);
+	let payload;
+	try {
+		payload = JSON.parse(orderValue);
+	} catch {
+		throw new InvalidCursorError(cursor);
+	}
+	if (payload === null || typeof payload !== "object") throw new InvalidCursorError(cursor);
+	const candidate = payload;
+	const validValue = candidate.value === null || typeof candidate.value === "string" || typeof candidate.value === "number";
+	if (candidate.version !== 1 || candidate.field !== field || !validValue) throw new InvalidCursorError(cursor);
+	return {
+		value: candidate.value,
+		id
+	};
+}
 /**
 * Whitelist mapping a public date-filter field to its physical column. Keeping
 * this separate from `mapOrderField` makes the filterable set explicit and
@@ -164,6 +263,27 @@ const DATE_FILTER_COLUMNS = {
 	publishedAt: "published_at"
 };
 /**
+* Built-in sort fields → their physical columns. A closed set that blocks
+* sorting by arbitrary columns; per-collection fields are allowed
+* separately via `mapOrderField`'s `sortableExtras`.
+*/
+const ORDER_FIELD_COLUMNS = {
+	createdAt: "created_at",
+	updatedAt: "updated_at",
+	publishedAt: "published_at",
+	scheduledAt: "scheduled_at",
+	deletedAt: "deleted_at",
+	title: "title",
+	name: "name",
+	slug: "slug",
+	status: "status",
+	locale: "locale"
+};
+/** True when `field` maps to a system column and needs no per-collection resolution. */
+function isSystemOrderField(field) {
+	return field in ORDER_FIELD_COLUMNS;
+}
+/**
 * System columns that exist in every ec_* table
 */
 const SYSTEM_COLUMNS = new Set([
@@ -201,6 +321,15 @@ function serializeValue(value) {
 	if (typeof value === "object") return JSON.stringify(value);
 	return value;
 }
+function writableContentData(data) {
+	const writable = {};
+	for (const [key, value] of Object.entries(data)) {
+		if (SYSTEM_COLUMNS.has(key)) continue;
+		validateIdentifier(key, "content field name");
+		writable[key] = value;
+	}
+	return writable;
+}
 /**
 * Deserialize a value from database storage
 * Attempts to parse JSON strings that look like objects/arrays
@@ -237,7 +366,7 @@ var ContentRepository = class {
 	* Create a new content item
 	*/
 	async create(input) {
-		const id = ulid();
+		const id = input.id ?? ulid();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const { type, slug, data, status = "draft", authorId, primaryBylineId, locale, translationOf, publishedAt, createdAt } = input;
 		if (!type) throw new EmDashValidationError("Content type is required");
@@ -299,7 +428,7 @@ var ContentRepository = class {
 	* (optionally scoped to a locale) and appends a numeric suffix (`-1`,
 	* `-2`, etc.) on collision to guarantee uniqueness.
 	*
-	* Returns `null` if `baseSlug` is empty after slugification.
+	* Returns null when slug normalization cannot produce a value.
 	*/
 	async generateUniqueSlug(type, text, locale) {
 		const baseSlug = slugify(text);
@@ -462,7 +591,9 @@ var ContentRepository = class {
 		const limit = Math.min(options.limit || 50, 100);
 		const orderField = options.orderBy?.field || "createdAt";
 		const orderDirection = options.orderBy?.direction || "desc";
-		const dbField = this.mapOrderField(orderField);
+		const resolvedOrderField = await this.resolveOrderField(type, orderField, options.sortableExtras);
+		const dbField = resolvedOrderField.column;
+		const resolvedFieldFilters = await this.resolveFieldFilters(type, options.where?.fieldFilters);
 		const safeOrderDirection = orderDirection.toLowerCase() === "asc" ? "ASC" : "DESC";
 		let query = this.db.selectFrom(tableName).selectAll().where("deleted_at", "is", null);
 		if (options.where?.status) query = query.where("status", "=", options.where.status);
@@ -470,13 +601,42 @@ var ContentRepository = class {
 		if (options.where?.locale) query = query.where("locale", "=", options.where.locale);
 		query = this.applySearchFilter(query, options.where, type);
 		query = this.applyDateFilter(query, options.where);
-		if (options.cursor) {
+		query = this.applyBylineFilter(query, options.where, type);
+		query = this.applyFieldFilters(query, resolvedFieldFilters);
+		if (options.cursor) if (resolvedOrderField.indexedCustomField) {
+			const { value, id: cursorId } = decodeIndexedFieldCursor(options.cursor, orderField);
+			const isPresent = sql`${sql.ref(dbField)} IS NOT NULL`;
+			const falseLiteral = sql`FALSE`;
+			const trueLiteral = sql`TRUE`;
+			if (safeOrderDirection === "ASC" && value === null) query = query.where(sql`
+						(${isPresent}) > ${falseLiteral}
+						OR ((${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} > ${cursorId})
+					`);
+			else if (safeOrderDirection === "DESC" && value === null) query = query.where(sql`
+						(${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} < ${cursorId}
+					`);
+			else if (safeOrderDirection === "ASC") query = query.where(sql`
+						(${isPresent}, ${sql.ref(dbField)}, ${sql.ref("id")})
+							> (${trueLiteral}, ${value}, ${cursorId})
+					`);
+			else query = query.where(sql`
+						(${isPresent}, ${sql.ref(dbField)}, ${sql.ref("id")})
+							< (${trueLiteral}, ${value}, ${cursorId})
+					`);
+		} else {
 			const { orderValue, id: cursorId } = decodeCursor(options.cursor);
 			if (safeOrderDirection === "DESC") query = query.where((eb) => eb.or([eb(dbField, "<", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", "<", cursorId)])]));
 			else query = query.where((eb) => eb.or([eb(dbField, ">", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", ">", cursorId)])]));
 		}
-		query = query.orderBy(dbField, safeOrderDirection === "ASC" ? "asc" : "desc").orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
-		const [rows, total] = await Promise.all([query.execute(), this.count(type, options.where)]);
+		const indexedOrderFilter = resolvedOrderField.indexedCustomField ? resolvedFieldFilters.find((filter) => filter.column === dbField) : void 0;
+		if (resolvedOrderField.indexedCustomField && !indexedOrderFilter) query = query.orderBy(sql`${sql.ref(dbField)} IS NOT NULL`, safeOrderDirection === "ASC" ? "asc" : "desc");
+		if (indexedOrderFilter?.kind !== "null") query = query.orderBy(dbField, safeOrderDirection === "ASC" ? "asc" : "desc");
+		query = query.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
+		const [rowsResult, countResult] = await Promise.allSettled([query.execute(), this.countWithResolvedFilters(type, options.where, resolvedFieldFilters)]);
+		if (rowsResult.status === "rejected") throw rowsResult.reason;
+		if (countResult.status === "rejected") throw countResult.reason;
+		const rows = rowsResult.value;
+		const total = countResult.value;
 		const hasMore = rows.length > limit;
 		const items = rows.slice(0, limit);
 		const mappedResult = {
@@ -486,7 +646,10 @@ var ContentRepository = class {
 		if (hasMore && items.length > 0) {
 			const lastRow = items.at(-1);
 			const lastOrderValue = lastRow[dbField];
-			mappedResult.nextCursor = encodeCursor(typeof lastOrderValue === "string" || typeof lastOrderValue === "number" ? String(lastOrderValue) : "", String(lastRow.id));
+			if (resolvedOrderField.indexedCustomField) {
+				if (lastOrderValue !== null && typeof lastOrderValue !== "string" && typeof lastOrderValue !== "number") throw new EmDashValidationError(`Invalid indexed value for order field: ${orderField}`);
+				mappedResult.nextCursor = encodeIndexedFieldCursor(orderField, lastOrderValue, String(lastRow.id));
+			} else mappedResult.nextCursor = encodeCursor(typeof lastOrderValue === "string" || typeof lastOrderValue === "number" ? String(lastOrderValue) : "", String(lastRow.id));
 		}
 		return mappedResult;
 	}
@@ -503,23 +666,137 @@ var ContentRepository = class {
 		if (input.scheduledAt !== void 0) updates.scheduled_at = input.scheduledAt;
 		if (input.authorId !== void 0) updates.author_id = input.authorId;
 		if (input.primaryBylineId !== void 0) updates.primary_byline_id = input.primaryBylineId;
-		if (input.data !== void 0 && typeof input.data === "object") {
-			for (const [key, value] of Object.entries(input.data)) if (!SYSTEM_COLUMNS.has(key)) {
-				validateIdentifier(key, "content field name");
-				updates[key] = serializeValue(value);
-			}
-		}
+		if (input.data !== void 0 && typeof input.data === "object") for (const [key, value] of Object.entries(writableContentData(input.data))) updates[key] = serializeValue(value);
 		const hasColumnWrites = Object.keys(updates).length > 0;
 		if (hasColumnWrites) updates.updated_at = now;
 		updates.version = sql`version + 1`;
 		await this.db.updateTable(tableName).set(updates).where("id", "=", id).where("deleted_at", "is", null).execute();
-		if (input.status !== void 0 || input.publishedAt !== void 0 || input.scheduledAt !== void 0) await this.restampEntryPivot(type, id);
 		if (hasColumnWrites) invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
 		return updated;
 	}
 	/**
+	* Update plugin-authored fields without letting content columns diverge
+	* from the revision pointers that publication promotes.
+	*/
+	async updateDraftAware(type, id, input) {
+		const data = input.data ? writableContentData(input.data) : {};
+		const stagedSlug = typeof input.slug === "string" ? input.slug : void 0;
+		if (!(Object.keys(data).length > 0 || stagedSlug !== void 0)) return this.update(type, id, {
+			...input,
+			data
+		});
+		const collectionRows = await this.db.selectFrom("_emdash_collections as collection").leftJoin("_emdash_fields as field", "field.collection_id", "collection.id").select(["collection.supports", "field.slug as fieldSlug"]).where("collection.slug", "=", type).execute();
+		const supportsRaw = collectionRows[0]?.supports;
+		const supports = supportsRaw ? JSON.parse(supportsRaw) : [];
+		if (!Array.isArray(supports) || !supports.includes("revisions")) return this.update(type, id, {
+			...input,
+			data
+		});
+		const fieldSlugs = new Set(collectionRows.map((row) => row.fieldSlug).filter(Boolean));
+		for (const field of Object.keys(data)) if (!fieldSlugs.has(field)) throw new EmDashValidationError(`Unknown field '${field}' in collection '${type}'`);
+		const revisionRepo = new RevisionRepository(this.db);
+		let existing = await this.findById(type, id);
+		for (let attempt = 0; existing && attempt < MAX_DRAFT_STAGE_ATTEMPTS; attempt++) {
+			let baseData = existing.data;
+			if (existing.draftRevisionId) {
+				const draft = await revisionRepo.findById(existing.draftRevisionId);
+				if (draft) baseData = draft.data;
+			}
+			const mergedData = {
+				...baseData,
+				...data
+			};
+			if (stagedSlug !== void 0) mergedData._slug = stagedSlug;
+			const revision = await revisionRepo.create({
+				collection: type,
+				entryId: id,
+				data: mergedData,
+				...input.authorId ? { authorId: input.authorId } : {}
+			});
+			let staged;
+			try {
+				staged = await this.replaceDraftRevisionForUpdate(type, id, revision.id, existing, input);
+			} catch (error) {
+				await this.deleteUnstagedRevision(revisionRepo, type, id, revision.id);
+				throw error;
+			}
+			if (staged) {
+				const updated = await this.findById(type, id);
+				if (!updated) throw new Error("Content not found");
+				const draftData = {};
+				for (const [key, value] of Object.entries(mergedData)) if (!key.startsWith("_")) draftData[key] = value;
+				return {
+					...updated,
+					data: {
+						...updated.data,
+						...draftData
+					}
+				};
+			}
+			await this.deleteUnstagedRevision(revisionRepo, type, id, revision.id);
+			existing = await this.findById(type, id);
+		}
+		if (!existing) throw new Error("Content not found");
+		throw new ContentMutationConflictError();
+	}
+	async deleteUnstagedRevision(revisionRepo, type, id, revisionId) {
+		try {
+			await revisionRepo.deleteIfUnreferenced(type, id, revisionId);
+		} catch (error) {
+			console.error(`[content] Failed to clean up unstaged revision ${revisionId}:`, error);
+		}
+	}
+	async replaceDraftRevisionForUpdate(type, id, revisionId, expected, input) {
+		const tableName = getTableName(type);
+		const assignments = [sql`draft_revision_id = ${revisionId}`];
+		let liveMetadataChanged = false;
+		if (input.status !== void 0) {
+			assignments.push(sql`status = ${input.status}`);
+			liveMetadataChanged = true;
+		}
+		if (input.slug === null) {
+			assignments.push(sql`slug = NULL`);
+			liveMetadataChanged = true;
+		}
+		if (input.publishedAt !== void 0) {
+			assignments.push(sql`published_at = ${input.publishedAt}`);
+			liveMetadataChanged = true;
+		}
+		if (input.scheduledAt !== void 0) {
+			assignments.push(sql`scheduled_at = ${input.scheduledAt}`);
+			liveMetadataChanged = true;
+		}
+		if (input.authorId !== void 0) {
+			assignments.push(sql`author_id = ${input.authorId}`);
+			liveMetadataChanged = true;
+		}
+		if (input.primaryBylineId !== void 0) {
+			assignments.push(sql`primary_byline_id = ${input.primaryBylineId}`);
+			liveMetadataChanged = true;
+		}
+		if (liveMetadataChanged) assignments.push(sql`updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}`);
+		assignments.push(sql`version = version + 1`);
+		const changed = ((await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET ${sql.join(assignments, sql`, `)}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+			AND version = ${expected.version}
+			AND ${nullableColumnMatch("live_revision_id", expected.liveRevisionId)}
+			AND ${nullableColumnMatch("draft_revision_id", expected.draftRevisionId)}
+			AND EXISTS (
+				SELECT 1 FROM revisions
+				WHERE revisions.id = ${revisionId}
+				AND revisions.collection = ${type}
+				AND revisions.entry_id = ${id}
+			)
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+		if (changed && liveMetadataChanged) invalidateCollectionCache(type);
+		return changed;
+	}
+	/**
 	* Delete content (soft delete - moves to trash)
 	*/
 	async delete(type, id) {
@@ -531,10 +808,7 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
-		if (changed) {
-			await this.restampEntryPivot(type, id);
-			invalidateCollectionCache(type);
-		}
+		if (changed) invalidateCollectionCache(type);
 		return changed;
 	}
 	/**
@@ -550,35 +824,10 @@ var ContentRepository = class {
 			RETURNING *
 		`.execute(this.db)).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.
-	*/
-	async restampEntryPivot(type, id) {
-		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)
 	*/
 	/**
@@ -675,7 +924,7 @@ var ContentRepository = class {
 		const pattern = `%${term.replace(LIKE_WILDCARD_RE, (c) => `\\${c}`)}%`;
 		return query.where((eb) => eb.or(columns.map((col) => {
 			validateIdentifier(col, "search column");
-			return eb(sql`lower(${sql.ref(col)})`, "like", sql`lower(${pattern}) escape '\\'`);
+			return sql`lower(CAST(${sql.ref(col)} AS TEXT)) LIKE lower(${pattern}) ESCAPE '\\'`;
 		})));
 	}
 	/**
@@ -697,9 +946,57 @@ var ContentRepository = class {
 		return next;
 	}
 	/**
+	* Apply the optional byline filter as a correlated (NOT) EXISTS against
+	* `_emdash_content_bylines`.
+	*
+	* Correlating from the content table preserves the outer sort index so
+	* `LIMIT` can short-circuit. `mode: "none"` tests the junction rather than
+	* `primary_byline_id` because the two are written in the same call but
+	* are not atomically consistent, so the junction is authoritative.
+	*
+	* Whether a credit *renders* is locale-scoped; whether one *exists* is
+	* not. Both are needed: the first decides what the filter matches, the
+	* second decides whether the author fallback applies at all.
+	*/
+	applyBylineFilter(query, where, type) {
+		const filter = where?.bylineFilter;
+		if (!filter) return query;
+		const tableName = getTableName(type);
+		const idColumn = `${tableName}.id`;
+		const authorColumn = `${tableName}.author_id`;
+		const localeColumn = `${tableName}.locale`;
+		const creditRenders = (eb, bylineIds) => {
+			let sub = eb.selectFrom("_emdash_content_bylines as cb").innerJoin("_emdash_bylines as b", "b.translation_group", "cb.byline_id").select("cb.id").where("cb.collection_slug", "=", type).whereRef("cb.content_id", "=", idColumn);
+			sub = filter.locale ? sub.where("b.locale", "=", filter.locale) : sub.whereRef("b.locale", "=", localeColumn);
+			if (bylineIds) sub = sub.where("cb.byline_id", "in", bylineIds);
+			return eb.exists(sub);
+		};
+		const hasExplicitCredit = (eb) => eb.exists(eb.selectFrom("_emdash_content_bylines as cb").select("cb.id").where("cb.collection_slug", "=", type).whereRef("cb.content_id", "=", idColumn));
+		const authorHasByline = (eb, bylineIds) => {
+			let sub = eb.selectFrom("_emdash_bylines as b").select("b.id").whereRef("b.user_id", "=", authorColumn);
+			sub = filter.locale ? sub.where("b.locale", "=", filter.locale) : sub.whereRef("b.locale", "=", localeColumn);
+			if (bylineIds) sub = sub.where("b.translation_group", "in", bylineIds);
+			return eb.exists(sub);
+		};
+		if (filter.mode === "none") return query.where((eb) => {
+			const uncredited = eb.not(creditRenders(eb));
+			return filter.includeInferred ? eb.and([uncredited, eb.or([hasExplicitCredit(eb), eb.not(authorHasByline(eb))])]) : uncredited;
+		});
+		const bylineIds = filter.bylineIds ?? [];
+		if (bylineIds.length === 0) return query.where(() => sql`1 = 0`);
+		return query.where((eb) => {
+			if (!filter.includeInferred) return creditRenders(eb, bylineIds);
+			return eb.or([creditRenders(eb, bylineIds), eb.and([eb.not(hasExplicitCredit(eb)), authorHasByline(eb, bylineIds)])]);
+		});
+	}
+	/**
 	* Count content items
 	*/
 	async count(type, where) {
+		const resolvedFieldFilters = await this.resolveFieldFilters(type, where?.fieldFilters);
+		return this.countWithResolvedFilters(type, where, resolvedFieldFilters);
+	}
+	async countWithResolvedFilters(type, where, resolvedFieldFilters) {
 		const tableName = getTableName(type);
 		let query = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count")).where("deleted_at", "is", null);
 		if (where?.status) query = query.where("status", "=", where.status);
@@ -707,6 +1004,8 @@ var ContentRepository = class {
 		if (where?.locale) query = query.where("locale", "=", where.locale);
 		query = this.applySearchFilter(query, where, type);
 		query = this.applyDateFilter(query, where);
+		query = this.applyBylineFilter(query, where, type);
+		query = this.applyFieldFilters(query, resolvedFieldFilters);
 		const result = await query.executeTakeFirst();
 		return Number(result?.count || 0);
 	}
@@ -720,19 +1019,22 @@ var ContentRepository = class {
 		const tableName = getTableName(type);
 		return (await this.db.selectFrom(tableName).select("author_id").distinct().where("deleted_at", "is", null).where("author_id", "is not", null).execute()).map((row) => row.author_id).filter((id) => id !== null);
 	}
-	async getStats(type) {
+	async getStats(type, now = /* @__PURE__ */ new Date()) {
 		const tableName = getTableName(type);
+		const nowIso = now.toISOString();
 		const result = await this.db.selectFrom(tableName).select((eb) => [
 			eb.fn.count("id").as("total"),
 			eb.fn.sum(eb.case().when("status", "=", "published").then(1).else(0).end()).as("published"),
 			eb.fn.sum(eb.case().when("status", "=", "draft").then(1).else(0).end()).as("draft"),
-			sql`SUM(CASE WHEN scheduled_at IS NOT NULL THEN 1 ELSE 0 END)`.as("scheduled")
+			sql`SUM(CASE WHEN scheduled_at IS NOT NULL THEN 1 ELSE 0 END)`.as("scheduled"),
+			sql`SUM(CASE WHEN scheduled_at IS NOT NULL AND scheduled_at <= ${nowIso} THEN 1 ELSE 0 END)`.as("overdue_scheduled")
 		]).where("deleted_at", "is", null).executeTakeFirst();
 		return {
 			total: Number(result?.total || 0),
 			published: Number(result?.published || 0),
 			draft: Number(result?.draft || 0),
-			scheduled: Number(result?.scheduled || 0)
+			scheduled: Number(result?.scheduled || 0),
+			overdueScheduled: Number(result?.overdue_scheduled || 0)
 		};
 	}
 	/**
@@ -758,7 +1060,6 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
-		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -785,7 +1086,6 @@ var ContentRepository = class {
 			AND scheduled_at IS NOT NULL
 			AND deleted_at IS NULL
 		`.execute(this.db);
-		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -835,6 +1135,10 @@ var ContentRepository = class {
 	* Lets callers resolve many edge groups without an N+1 per group. The caller
 	* groups the flat result by `translationGroup` itself.
 	*
+	* `translation_group` leads the sort so the ordering follows
+	* `idx_{table}_del_tg_locale` past its `deleted_at` equality; callers group by
+	* `translationGroup`, so the per-group locale order they rely on is preserved.
+	*
 	* `publishedOnly` restricts the result to `status = 'published'` — reference
 	* reads pass this for callers without `content:read_drafts` so draft/scheduled
 	* entries never leak through an edge traversal.
@@ -856,7 +1160,7 @@ var ContentRepository = class {
 					WHERE translation_group IN (${sql.join(chunk)})
 					AND deleted_at IS NULL
 					${publishedFilter}
-					ORDER BY locale ASC
+					ORDER BY translation_group ASC, locale ASC
 				`.execute(this.db);
 				for (const row of result.rows) items.push(this.mapRow(type, row));
 			}
@@ -925,6 +1229,8 @@ var ContentRepository = class {
 	* Syncs the draft revision's data into the content table columns so the
 	* content table always reflects the published version.
 	* If no draft revision exists, creates one from current data and publishes it.
+	* When `promoteRevision` is false, publishes the current content-table data
+	* by changing lifecycle metadata only.
 	*
 	* `publishedAt` (optional) overrides the publication timestamp. If omitted,
 	* the existing `published_at` is preserved (idempotent re-publish keeps the
@@ -932,98 +1238,155 @@ var ContentRepository = class {
 	* an explicit value to backdate a publish (e.g. when migrating content from
 	* another CMS).
 	*
-	* `requireDue` (optional) gates the publish on the row still being due:
-	* `scheduled_at` non-null and in the past. Used by the scheduled-publishing
-	* sweep to avoid publishing content an editor unscheduled or rescheduled
-	* between selection and publish. It claims the row with a single conditional
-	* UPDATE (clearing `scheduled_at`) before any other write, so it is atomic
-	* even on D1 (no multi-statement transactions) and serialises against
-	* `unschedule()` and concurrent sweeps — no TOCTOU and no double publish.
+	* `requireDue` gates the final update on the row still being due.
+	* `expectedScheduledAt` additionally fences changes made after a sweep
+	* selected the row but before publication preparation began.
 	*/
-	async publish(type, id, publishedAt, requireDue = false) {
+	async publish(type, id, publishedAt, requireDue = false, expectedScheduledAt, promoteRevision = true, requireSlug = true) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const existing = await this.findById(type, id);
 		if (!existing) throw new EmDashValidationError("Content item not found");
-		let claimedScheduledAt = null;
-		let claimedUpdatedAt = null;
-		if (requireDue) {
-			if (((await sql`
-				UPDATE ${sql.ref(tableName)}
-				SET scheduled_at = NULL,
-					updated_at = ${now}
-				WHERE id = ${id}
-				AND scheduled_at IS NOT NULL
-				AND scheduled_at <= ${now}
-				AND deleted_at IS NULL
-			`.execute(this.db)).numAffectedRows ?? 0n) === 0n) throw new ScheduledNotDueError();
-			claimedScheduledAt = existing.scheduledAt;
-			claimedUpdatedAt = existing.updatedAt;
-		}
-		let publishCommitted = false;
-		try {
+		if (requireDue && expectedScheduledAt !== void 0 && existing.scheduledAt !== expectedScheduledAt) throw new ScheduledNotDueError();
+		if (!promoteRevision && requireSlug && !existing.slug?.trim()) throw new EmDashValidationError("Cannot publish routable content without a slug");
+		if (!promoteRevision) {
 			const revisionRepo = new RevisionRepository(this.db);
-			let revisionToPublish = existing.draftRevisionId || existing.liveRevisionId;
-			if (!revisionToPublish) revisionToPublish = (await revisionRepo.create({
-				collection: type,
-				entryId: id,
-				data: existing.data
-			})).id;
-			const revision = await revisionRepo.findById(revisionToPublish);
-			if (revision) {
-				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" });
+			let provisionalRevisionId = null;
+			try {
+				let liveRevisionId = existing.liveRevisionId;
+				if (!liveRevisionId) {
+					const revision = await revisionRepo.create({
+						collection: type,
+						entryId: id,
+						data: existing.data
+					});
+					liveRevisionId = revision.id;
+					provisionalRevisionId = revision.id;
 				}
-				if (stagedSlug !== null) await sql`
+				const intendedPublishedAt = publishedAt ?? existing.publishedAt ?? now;
+				const duePredicate = requireDue ? sql`AND scheduled_at IS NOT NULL AND scheduled_at <= ${now}` : sql``;
+				let published = false;
+				try {
+					published = ((await sql`
 						UPDATE ${sql.ref(tableName)}
-						SET slug = ${stagedSlug}
+						SET live_revision_id = ${liveRevisionId},
+							draft_revision_id = NULL,
+							status = 'published',
+							scheduled_at = NULL,
+							published_at = ${intendedPublishedAt},
+							updated_at = ${now},
+							version = version + 1
 						WHERE id = ${id}
-					`.execute(this.db);
-				await this.syncDataColumns(type, id, revision.data);
+						AND deleted_at IS NULL
+						AND version = ${existing.version}
+						AND status = ${existing.status}
+						AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+						AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+						AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
+						${duePredicate}
+					`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+				} catch (error) {
+					if (isConfirmedStatementFailure(error)) throw error;
+					let observed;
+					try {
+						observed = await this.findById(type, id);
+					} catch (reconciliationError) {
+						throw new Error("Unable to confirm whether content publication completed", { cause: reconciliationError });
+					}
+					if (!observed) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+					published = matchesLifecyclePublication(observed, existing, liveRevisionId, intendedPublishedAt, now);
+					if (!published && matchesPublicationFence(observed, existing)) throw error;
+					if (!published) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+				}
+				if (!published) throw requireDue ? new ScheduledNotDueError() : new ContentMutationConflictError();
+				invalidateCollectionCache(type);
+				const updated = await this.findById(type, id);
+				if (!updated) throw new Error("Content not found");
+				return updated;
+			} catch (error) {
+				if (provisionalRevisionId) try {
+					await revisionRepo.deleteIfUnreferenced(type, id, provisionalRevisionId);
+				} catch (cleanupError) {
+					console.error(`[content] Failed to clean up provisional revision ${provisionalRevisionId}:`, cleanupError);
+				}
+				throw error;
 			}
-			if (publishedAt !== void 0) await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET live_revision_id = ${revisionToPublish},
-						draft_revision_id = NULL,
-						status = 'published',
-						scheduled_at = NULL,
-						published_at = ${publishedAt},
-						updated_at = ${now}
-					WHERE id = ${id}
-					AND deleted_at IS NULL
-				`.execute(this.db);
-			else await sql`
+		}
+		const revisionRepo = new RevisionRepository(this.db);
+		let provisionalRevisionId = null;
+		try {
+			let revisionToPublish = existing.draftRevisionId || existing.liveRevisionId;
+			if (!revisionToPublish) {
+				const revision = await revisionRepo.create({
+					collection: type,
+					entryId: id,
+					data: existing.data
+				});
+				revisionToPublish = revision.id;
+				provisionalRevisionId = revision.id;
+			}
+			const revision = await revisionRepo.findById(revisionToPublish);
+			if (!revision || revision.collection !== type || revision.entryId !== id) throw new EmDashValidationError("Revision does not belong to the specified content item");
+			const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
+			const intendedSlug = stagedSlug ?? existing.slug;
+			if (requireSlug && !intendedSlug?.trim()) throw new EmDashValidationError("Cannot publish routable content without a slug");
+			const intendedPublishedAt = publishedAt ?? existing.publishedAt ?? now;
+			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" });
+			}
+			const assignments = [];
+			if (stagedSlug !== null) assignments.push(sql`slug = ${stagedSlug}`);
+			for (const [key, value] of Object.entries(revision.data)) {
+				if (SYSTEM_COLUMNS.has(key) || key.startsWith("_")) continue;
+				validateIdentifier(key, "content field name");
+				assignments.push(sql`${sql.ref(key)} = ${serializeValue(value)}`);
+			}
+			assignments.push(sql`live_revision_id = ${revisionToPublish}`, sql`draft_revision_id = NULL`, sql`status = 'published'`, sql`scheduled_at = NULL`, sql`published_at = ${intendedPublishedAt}`, sql`updated_at = ${now}`, sql`version = version + 1`);
+			const duePredicate = requireDue ? sql`AND scheduled_at IS NOT NULL AND scheduled_at <= ${now}` : sql``;
+			let promoted = false;
+			try {
+				promoted = ((await sql`
 					UPDATE ${sql.ref(tableName)}
-					SET live_revision_id = ${revisionToPublish},
-						draft_revision_id = NULL,
-						status = 'published',
-						scheduled_at = NULL,
-						published_at = COALESCE(published_at, ${now}),
-						updated_at = ${now}
+					SET ${sql.join(assignments, sql`, `)}
 					WHERE id = ${id}
 					AND deleted_at IS NULL
-				`.execute(this.db);
-			publishCommitted = true;
-			await this.restampEntryPivot(type, id);
+					AND version = ${existing.version}
+					AND status = ${existing.status}
+					AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+					AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+					AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
+					${duePredicate}
+					AND EXISTS (
+						SELECT 1 FROM revisions
+						WHERE revisions.id = ${revisionToPublish}
+						AND revisions.collection = ${type}
+						AND revisions.entry_id = ${id}
+					)
+				`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+			} catch (error) {
+				if (isConfirmedStatementFailure(error)) throw error;
+				let observed;
+				try {
+					observed = await this.findById(type, id);
+				} catch (reconciliationError) {
+					throw new Error("Unable to confirm whether content publication completed", { cause: reconciliationError });
+				}
+				if (!observed) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+				promoted = matchesPublication(observed, existing, revision, revisionToPublish, intendedSlug, intendedPublishedAt, now);
+				if (!promoted && matchesPublicationFence(observed, existing)) throw error;
+				if (!promoted) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+			}
+			if (!promoted) throw requireDue ? new ScheduledNotDueError() : new ContentMutationConflictError();
+			invalidateCollectionCache(type);
 			const updated = await this.findById(type, id);
 			if (!updated) throw new Error("Content not found");
-			invalidateCollectionCache(type);
 			return updated;
 		} catch (error) {
-			if (requireDue && claimedScheduledAt && !publishCommitted) try {
-				await sql`
-						UPDATE ${sql.ref(tableName)}
-						SET scheduled_at = ${claimedScheduledAt},
-							updated_at = ${claimedUpdatedAt ?? now}
-						WHERE id = ${id}
-						AND scheduled_at IS NULL
-						AND deleted_at IS NULL
-						AND (status != 'published' OR draft_revision_id IS NOT NULL)
-					`.execute(this.db);
-			} catch (restoreError) {
-				console.error(`[content] Failed to restore schedule for ${type}/${id} after publish failure:`, restoreError);
+			if (provisionalRevisionId) try {
+				await revisionRepo.deleteIfUnreferenced(type, id, provisionalRevisionId);
+			} catch (cleanupError) {
+				console.error(`[content] Failed to clean up provisional revision ${provisionalRevisionId}:`, cleanupError);
 			}
 			throw error;
 		}
@@ -1064,7 +1427,6 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
-		await this.restampEntryPivot(type, id);
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -1082,17 +1444,31 @@ var ContentRepository = class {
 	* content row pointing at a missing or unrelated revision.
 	*/
 	async setDraftRevision(type, id, revisionId) {
-		const tableName = getTableName(type);
-		if (!await this.findById(type, id)) throw new EmDashValidationError("Content item not found");
+		const existing = await this.findById(type, id);
+		if (!existing) throw new EmDashValidationError("Content item not found");
 		const revision = await new RevisionRepository(this.db).findById(revisionId);
 		if (!revision) throw new EmDashValidationError("Revision not found");
 		if (revision.collection !== type || revision.entryId !== id) throw new EmDashValidationError("Revision does not belong to the specified content item");
-		await sql`
+		if (!await this.replaceDraftRevision(type, id, revisionId, existing)) throw new ContentMutationConflictError();
+	}
+	async replaceDraftRevision(type, id, revisionId, expected) {
+		const tableName = getTableName(type);
+		return ((await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = ${revisionId}
+			SET draft_revision_id = ${revisionId},
+				version = version + 1
 			WHERE id = ${id}
 			AND deleted_at IS NULL
-		`.execute(this.db);
+			AND version = ${expected.version}
+			AND ${nullableColumnMatch("live_revision_id", expected.liveRevisionId)}
+			AND ${nullableColumnMatch("draft_revision_id", expected.draftRevisionId)}
+			AND EXISTS (
+				SELECT 1 FROM revisions
+				WHERE revisions.id = ${revisionId}
+				AND revisions.collection = ${type}
+				AND revisions.entry_id = ${id}
+			)
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
 	}
 	/**
 	* Discard pending draft changes
@@ -1116,23 +1492,6 @@ var ContentRepository = class {
 		return updated;
 	}
 	/**
-	* Sync data columns in the content table from a data object.
-	* Used to promote revision data into the content table on publish.
-	* Keys starting with _ are revision metadata (e.g. _slug) and are skipped.
-	*/
-	async syncDataColumns(type, id, data) {
-		const tableName = getTableName(type);
-		const updates = {};
-		for (const [key, value] of Object.entries(data)) {
-			if (SYSTEM_COLUMNS.has(key)) continue;
-			if (key.startsWith("_")) continue;
-			validateIdentifier(key, "content field name");
-			updates[key] = serializeValue(value);
-		}
-		if (Object.keys(updates).length === 0) return;
-		await this.db.updateTable(tableName).set(updates).where("id", "=", id).execute();
-	}
-	/**
 	* Count content items with a pending schedule.
 	* Includes both draft-scheduled (status='scheduled') and published
 	* posts with scheduled draft changes (status='published', scheduled_at set).
@@ -1173,28 +1532,153 @@ var ContentRepository = class {
 			translationGroup: row.translation_group ?? null
 		};
 	}
+	normalizeFilterScalar(field, type, value) {
+		if (type === "number" || type === "integer") {
+			if (typeof value !== "number" || !Number.isFinite(value)) throw new EmDashValidationError(`Filter for field "${field}" must use a finite number`);
+			if (type === "integer" && !Number.isInteger(value)) throw new EmDashValidationError(`Filter for field "${field}" must use an integer`);
+			return value;
+		}
+		if (type === "boolean") {
+			if (typeof value !== "boolean") throw new EmDashValidationError(`Filter for field "${field}" must use a boolean`);
+			return value ? 1 : 0;
+		}
+		if (typeof value !== "string") throw new EmDashValidationError(`Filter for field "${field}" must use a string`);
+		if (value.length > MAX_FILTER_STRING_LENGTH) throw new EmDashValidationError(`Filter value for field "${field}" exceeds ${MAX_FILTER_STRING_LENGTH} characters`);
+		return value;
+	}
+	normalizeFieldFilter(field, type, value) {
+		if (value === null) return {
+			column: field,
+			kind: "null"
+		};
+		if (typeof value !== "object") return {
+			column: field,
+			kind: "exact",
+			value: this.normalizeFilterScalar(field, type, value)
+		};
+		if (Array.isArray(value)) throw new EmDashValidationError(`Invalid filter for field "${field}"`);
+		const record = value;
+		const keys = Object.keys(record);
+		if (keys.length === 1 && keys[0] === "in") {
+			if (!Array.isArray(record.in) || record.in.length === 0) throw new EmDashValidationError(`IN filter for field "${field}" must not be empty`);
+			if (record.in.length > MAX_IN_FILTER_VALUES) throw new EmDashValidationError(`IN filter for field "${field}" exceeds ${MAX_IN_FILTER_VALUES} values`);
+			return {
+				column: field,
+				kind: "in",
+				values: record.in.map((entry) => this.normalizeFilterScalar(field, type, entry))
+			};
+		}
+		const rangeKeys = new Set([
+			"gt",
+			"gte",
+			"lt",
+			"lte"
+		]);
+		if (keys.length === 0 || keys.some((key) => !rangeKeys.has(key))) throw new EmDashValidationError(`Invalid filter operator for field "${field}"`);
+		if (type === "boolean") throw new EmDashValidationError(`Boolean field "${field}" does not support range filters`);
+		const bounds = {};
+		for (const key of keys) {
+			if (record[key] === void 0) continue;
+			bounds[key] = this.normalizeFilterScalar(field, type, record[key]);
+		}
+		if (Object.keys(bounds).length === 0) throw new EmDashValidationError(`Range filter for field "${field}" has no bounds`);
+		return {
+			column: field,
+			kind: "range",
+			bounds
+		};
+	}
+	async collectionExists(type) {
+		return await this.db.selectFrom("_emdash_collections").where("slug", "=", type).select("id").executeTakeFirst() !== void 0;
+	}
+	async resolveFieldFilters(type, filters) {
+		const resolvedFilters = filters ?? {};
+		const fields = Object.keys(resolvedFilters);
+		if (fields.length === 0) return [];
+		if (fields.length > MAX_INDEXED_FIELD_FILTERS) {
+			if (!await this.collectionExists(type)) return [];
+			throw new EmDashValidationError(`Content list queries support at most ${MAX_INDEXED_FIELD_FILTERS} indexed field filters`);
+		}
+		const rows = await this.db.selectFrom("_emdash_fields as field").innerJoin("_emdash_collections as collection", "collection.id", "field.collection_id").where("collection.slug", "=", type).where("field.slug", "in", fields).where("field.indexed", "=", 1).select(["field.slug", "field.type"]).execute();
+		const metadata = new Map(rows.map((row) => [row.slug, row.type]));
+		if (metadata.size === 0 && !await this.collectionExists(type)) return [];
+		for (const field of fields) try {
+			validateIdentifier(field, "content filter field");
+		} catch {
+			throw new EmDashValidationError(`Invalid content filter field: ${field}`);
+		}
+		const normalized = fields.map((field) => {
+			const fieldType = metadata.get(field);
+			if (!fieldType || !isIndexableFieldType(fieldType)) throw new EmDashValidationError(`Cannot filter by field "${field}". Custom fields must be indexed before filtering.`);
+			return this.normalizeFieldFilter(field, fieldType, resolvedFilters[field]);
+		});
+		if (normalized.reduce((total, filter) => {
+			if (filter.kind === "null") return total;
+			if (filter.kind === "exact") return total + 1;
+			if (filter.kind === "in") return total + filter.values.length;
+			return total + Object.keys(filter.bounds).length;
+		}, 0) > SQL_BATCH_SIZE) throw new EmDashValidationError(`Indexed field filters have a total operand budget of ${SQL_BATCH_SIZE}`);
+		return normalized;
+	}
+	applyFieldFilters(query, filters) {
+		let next = query;
+		for (const filter of filters) {
+			const column = sql.ref(filter.column);
+			const isPresent = sql`${column} IS NOT NULL`;
+			if (filter.kind === "null") {
+				next = next.where(() => sql`(${isPresent}) = FALSE AND ${column} IS NULL`);
+				continue;
+			}
+			if (filter.kind === "exact") {
+				next = next.where(() => sql`(${isPresent}) = TRUE AND ${column} = ${filter.value}`);
+				continue;
+			}
+			if (filter.kind === "in") {
+				const values = sql.join(filter.values.map((value) => sql`${value}`), sql`, `);
+				next = next.where(() => sql`(${isPresent}) = TRUE AND ${column} IN (${values})`);
+				continue;
+			}
+			next = next.where(() => sql`(${isPresent}) = TRUE`);
+			if (filter.bounds.gt !== void 0) next = next.where(() => sql`${column} > ${filter.bounds.gt}`);
+			if (filter.bounds.gte !== void 0) next = next.where(() => sql`${column} >= ${filter.bounds.gte}`);
+			if (filter.bounds.lt !== void 0) next = next.where(() => sql`${column} < ${filter.bounds.lt}`);
+			if (filter.bounds.lte !== void 0) next = next.where(() => sql`${column} <= ${filter.bounds.lte}`);
+		}
+		return next;
+	}
 	/**
 	* Map order field names to database columns.
 	* Only allows known fields to prevent column enumeration via crafted orderBy values.
 	*/
-	mapOrderField(field) {
-		const mapped = {
-			createdAt: "created_at",
-			updatedAt: "updated_at",
-			publishedAt: "published_at",
-			scheduledAt: "scheduled_at",
-			deletedAt: "deleted_at",
-			title: "title",
-			name: "name",
-			slug: "slug",
-			status: "status",
-			locale: "locale"
-		}[field];
-		if (!mapped) throw new EmDashValidationError(`Invalid order field: ${field}`);
-		return mapped;
+	mapOrderField(field, sortableExtras = []) {
+		const mapped = ORDER_FIELD_COLUMNS[field];
+		if (mapped) return mapped;
+		if (sortableExtras.includes(field)) {
+			validateIdentifier(field, "order field");
+			return field;
+		}
+		throw new EmDashValidationError(`Invalid order field: ${field}`);
+	}
+	async resolveOrderField(type, field, sortableExtras = []) {
+		try {
+			return {
+				column: this.mapOrderField(field, sortableExtras),
+				indexedCustomField: false
+			};
+		} catch (error) {
+			if (!(error instanceof EmDashValidationError)) throw error;
+		}
+		const customField = await this.db.selectFrom("_emdash_collections as collection").leftJoin("_emdash_fields as field", (join) => join.onRef("field.collection_id", "=", "collection.id").on("field.slug", "=", field).on("field.indexed", "=", 1)).where("collection.slug", "=", type).select(["collection.id as collectionId", "field.slug as fieldSlug"]).executeTakeFirst();
+		if (!customField) throw new ContentCollectionNotFoundError(type);
+		if (!customField.fieldSlug) throw new EmDashValidationError(`Invalid order field: ${field}. Custom fields must be indexed before sorting.`);
+		validateIdentifier(customField.fieldSlug, "content order field");
+		return {
+			column: customField.fieldSlug,
+			indexedCustomField: true
+		};
 	}
 };
 
 //#endregion
-export { content_exports as n, RevisionRepository as r, ContentRepository as t };
-//# sourceMappingURL=content-CpfKV9QE.mjs.map
+export { RevisionRepository as i, content_exports as n, isSystemOrderField as r, ContentRepository as t };
+//# sourceMappingURL=content-BNfwh7xX.mjs.map