dineway 0.2.33 → 0.2.35

package/dist/review-payload-LLIi1sxO.mjs

@@ -0,0 +1,1386 @@
+import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
+import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
+import { n as ScheduledNotDueError, t as DinewayValidationError } from "./types-BqxIv8Il.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
+import { o as invalidateCollectionCache, s as invalidateCommentObjectCache } from "./object-cache-BGjIlY9s.mjs";
+import { t as RevisionRepository } from "./revision-090sZyGc.mjs";
+import { t as ContentRepository } from "./content-D9xKUSno.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-BnG3LPMN.mjs";
+import { t as UserRepository } from "./user-1-YV30lf.mjs";
+import { n as stableStringify, t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
+import { t as RedirectRepository } from "./redirect-HLI3wT5Y.mjs";
+import { r as requestCached } from "./request-cache-DPmV5nk4.mjs";
+import { t as BylineRepository } from "./byline-DEZKlzD9.mjs";
+import { r as parseAllowedMimeTypes, t as matchesMimeAllowlist } from "./mime-D_ae-u_U.mjs";
+import { i as invalidateRedirectCache } from "./cache-DZDOBJv3.mjs";
+import { t as SeoRepository } from "./seo-DYpc_rQ1.mjs";
+import { sql } from "kysely";
+
+//#region src/api/rev.ts
+/**
+* Generate a _rev token from a content item's version and updatedAt.
+*/
+function encodeRev(item) {
+	return encodeBase64(`${item.version}:${item.updatedAt}`);
+}
+/**
+* Decode a _rev token into its components.
+* Returns null if the token is malformed.
+*/
+function decodeRev(rev) {
+	try {
+		const decoded = decodeBase64(rev);
+		const colonIdx = decoded.indexOf(":");
+		if (colonIdx === -1) return null;
+		const version = parseInt(decoded.slice(0, colonIdx), 10);
+		const updatedAt = decoded.slice(colonIdx + 1);
+		if (isNaN(version) || !updatedAt) return null;
+		return {
+			version,
+			updatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Validate a _rev token against a content item.
+* Returns null if valid (or if no _rev provided), or an error message if invalid.
+*/
+function validateRev(rev, item) {
+	if (!rev) return { valid: true };
+	const decoded = decodeRev(rev);
+	if (!decoded) return {
+		valid: false,
+		message: "Malformed _rev token"
+	};
+	if (decoded.version !== item.version || decoded.updatedAt !== item.updatedAt) return {
+		valid: false,
+		message: "Content has been modified since last read (version conflict)"
+	};
+	return { valid: true };
+}
+
+//#endregion
+//#region src/api/handlers/validate-media-fields.ts
+function asMediaRef(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function fail(message) {
+	return {
+		success: false,
+		error: {
+			code: "INVALID_MIME_FOR_FIELD",
+			message
+		}
+	};
+}
+async function loadMediaFieldsForCollection(db, collectionSlug) {
+	const rows = await db.selectFrom("_dineway_fields").innerJoin("_dineway_collections", "_dineway_collections.id", "_dineway_fields.collection_id").select(["_dineway_fields.slug", "_dineway_fields.validation"]).where("_dineway_collections.slug", "=", collectionSlug).where("_dineway_fields.type", "in", ["file", "image"]).execute();
+	const out = [];
+	for (const row of rows) {
+		const list = parseAllowedMimeTypes(row.validation);
+		if (!list) continue;
+		out.push({
+			slug: row.slug,
+			allowedMimeTypes: list
+		});
+	}
+	return out;
+}
+async function validateMediaFields(db, collectionSlug, data) {
+	const fields = await requestCached(`mediaFields:${collectionSlug}`, () => loadMediaFieldsForCollection(db, collectionSlug));
+	if (fields.length === 0) return {
+		success: true,
+		data: true
+	};
+	const localIds = /* @__PURE__ */ new Set();
+	for (const field of fields) {
+		const ref = asMediaRef(data[field.slug]);
+		if (!ref) continue;
+		if ((typeof ref.provider === "string" ? ref.provider : "local") === "local" && typeof ref.id === "string") localIds.add(ref.id);
+	}
+	const mimeById = /* @__PURE__ */ new Map();
+	const idList = [...localIds];
+	if (idList.length > 0) for (const batch of chunks(idList, SQL_BATCH_SIZE)) {
+		const rows = await db.selectFrom("media").select(["id", "mime_type"]).where("id", "in", batch).execute();
+		for (const row of rows) mimeById.set(row.id, row.mime_type);
+	}
+	for (const field of fields) {
+		const value = data[field.slug];
+		if (value === null || value === void 0) continue;
+		const ref = asMediaRef(value);
+		if (!ref) continue;
+		const provider = typeof ref.provider === "string" ? ref.provider : "local";
+		let mime;
+		if (provider === "local") {
+			if (typeof ref.id !== "string") return fail(`Field '${field.slug}' references media with an invalid id`);
+			mime = mimeById.get(ref.id);
+			if (!mime) return fail(`Field '${field.slug}' references media with unknown MIME type`);
+		} else {
+			if (typeof ref.mimeType !== "string") return fail(`Field '${field.slug}' requires a mimeType declaration for non-local media`);
+			mime = ref.mimeType;
+		}
+		if (!matchesMimeAllowlist(mime, field.allowedMimeTypes)) return fail(`Field '${field.slug}' does not accept ${mime}`);
+	}
+	return {
+		success: true,
+		data: true
+	};
+}
+
+//#endregion
+//#region src/api/handlers/content.ts
+/**
+* Extract a slug source (title or name) from content data.
+* Returns null if no suitable string field is found.
+*/
+function getSlugSource(data) {
+	if (typeof data.title === "string" && data.title.length > 0) return data.title;
+	if (typeof data.name === "string" && data.name.length > 0) return data.name;
+	return null;
+}
+/** Default SEO values for content without an explicit SEO row */
+const SEO_DEFAULTS = {
+	title: null,
+	description: null,
+	image: null,
+	canonical: null,
+	noIndex: false
+};
+var ContentUpdateApiError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ContentUpdateApiError";
+	}
+};
+async function contentWriteConfiguration(db, collection) {
+	const row = await db.selectFrom("_dineway_collections").selectAll().where("slug", "=", collection).executeTakeFirst();
+	const fields = row ? await db.selectFrom("_dineway_fields").selectAll().where("collection_id", "=", row.id).execute() : [];
+	return {
+		row,
+		fields,
+		checks: row ? [
+			rowUnchanged("_dineway_collections", row),
+			sql`(SELECT COUNT(*) FROM _dineway_fields WHERE collection_id = ${row.id}) = ${fields.length}`,
+			...fields.map((field) => rowUnchanged("_dineway_fields", field))
+		] : [sql`NOT EXISTS (SELECT 1 FROM _dineway_collections WHERE slug = ${collection})`]
+	};
+}
+/**
+* Check if a collection has SEO enabled.
+*/
+async function collectionHasSeo(db, collection) {
+	return (await db.selectFrom("_dineway_collections").select("has_seo").where("slug", "=", collection).executeTakeFirst())?.has_seo === 1;
+}
+async function collectionSupportsRevisions(db, collection) {
+	const row = await db.selectFrom("_dineway_collections").select("supports").where("slug", "=", collection).executeTakeFirst();
+	if (!row?.supports) return false;
+	try {
+		const supports = JSON.parse(row.supports);
+		return Array.isArray(supports) && supports.includes("revisions");
+	} catch {
+		return false;
+	}
+}
+async function getCollectionFieldSlugs(db, collection) {
+	const collectionRow = await db.selectFrom("_dineway_collections").select("id").where("slug", "=", collection).executeTakeFirst();
+	if (!collectionRow) return null;
+	return (await db.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collectionRow.id).orderBy("sort_order", "asc").orderBy("created_at", "asc").execute()).map((row) => row.slug);
+}
+async function validateContentDataFields(db, collection, data) {
+	const allowedSlugs = await getCollectionFieldSlugs(db, collection);
+	if (!allowedSlugs) return null;
+	const allowed = new Set(allowedSlugs);
+	const unknownFields = Object.keys(data).filter((field) => !allowed.has(field));
+	if (unknownFields.length === 0) return null;
+	return {
+		success: false,
+		error: {
+			code: "VALIDATION_ERROR",
+			message: `Unknown ${unknownFields.length === 1 ? "field" : "fields"} ${unknownFields.map((field) => `"${field}"`).join(", ")} for collection "${collection}". Allowed fields: ${allowedSlugs.join(", ")}.`
+		}
+	};
+}
+/**
+* Hydrate SEO data on a single content item if the collection has SEO enabled.
+*/
+async function hydrateSeo(db, collection, item, hasSeo) {
+	if (!hasSeo) return;
+	item.seo = await new SeoRepository(db).get(collection, item.id);
+}
+/**
+* Hydrate SEO data on multiple content items using a single batch query.
+*/
+async function hydrateSeoMany(db, collection, items, hasSeo) {
+	if (!hasSeo || items.length === 0) return;
+	const seoMap = await new SeoRepository(db).getMany(collection, items.map((i) => i.id));
+	for (const item of items) item.seo = seoMap.get(item.id) ?? { ...SEO_DEFAULTS };
+}
+async function hydrateBylines(db, collection, item) {
+	const bylineRepo = new BylineRepository(db);
+	const localeOpt = item.locale ? { locale: item.locale } : void 0;
+	const bylines = await bylineRepo.getContentBylines(collection, item.id, localeOpt);
+	if (bylines.length > 0) {
+		item.bylines = bylines.map((c) => ({
+			...c,
+			source: "explicit"
+		}));
+		item.byline = bylines[0]?.byline ?? null;
+		return;
+	}
+	if (item.primaryBylineId) {
+		item.bylines = [];
+		item.byline = null;
+		return;
+	}
+	if (item.authorId) {
+		const fallback = await bylineRepo.findByUserId(item.authorId, localeOpt);
+		if (fallback) {
+			item.bylines = [{
+				byline: fallback,
+				sortOrder: 0,
+				roleLabel: null,
+				source: "inferred"
+			}];
+			item.byline = fallback;
+			return;
+		}
+	}
+	item.bylines = [];
+	item.byline = null;
+}
+/**
+* Batch-hydrate bylines for multiple items using two bulk queries instead of N+1.
+*/
+async function hydrateBylinesMany(db, collection, items) {
+	if (items.length === 0) return;
+	const bylineRepo = new BylineRepository(db);
+	const localeBuckets = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = item.locale ?? null;
+		const bucket = localeBuckets.get(key);
+		if (bucket) bucket.push(item);
+		else localeBuckets.set(key, [item]);
+	}
+	const bylinesMap = /* @__PURE__ */ new Map();
+	const itemsNeedingAuthorCheck = [];
+	for (const [locale, bucket] of localeBuckets) {
+		const localeOpt = locale ? { locale } : void 0;
+		const credits = await bylineRepo.getContentBylinesMany(collection, bucket.map((item) => item.id), localeOpt);
+		for (const [id, list] of credits) bylinesMap.set(id, list);
+		for (const item of bucket) {
+			const explicit = credits.get(item.id);
+			if (explicit && explicit.length > 0) continue;
+			if (item.authorId && !item.primaryBylineId) itemsNeedingAuthorCheck.push(item);
+		}
+	}
+	const fallbackByItem = /* @__PURE__ */ new Map();
+	const authorBuckets = /* @__PURE__ */ new Map();
+	for (const item of itemsNeedingAuthorCheck) {
+		const key = item.locale ?? null;
+		const bucket = authorBuckets.get(key);
+		if (bucket) bucket.push(item);
+		else authorBuckets.set(key, [item]);
+	}
+	for (const [locale, bucket] of authorBuckets) {
+		const authorIds = bucket.map((item) => item.authorId).filter((id) => id !== null);
+		const uniqueAuthorIds = [...new Set(authorIds)];
+		if (uniqueAuthorIds.length === 0) continue;
+		const localeOpt = locale ? { locale } : void 0;
+		const authorBylineMap = await bylineRepo.findByUserIds(uniqueAuthorIds, localeOpt);
+		for (const item of bucket) {
+			if (!item.authorId) continue;
+			const fallback = authorBylineMap.get(item.authorId);
+			if (fallback) fallbackByItem.set(item.id, fallback);
+		}
+	}
+	for (const item of items) {
+		const explicit = bylinesMap.get(item.id);
+		if (explicit && explicit.length > 0) {
+			item.bylines = explicit.map((c) => ({
+				...c,
+				source: "explicit"
+			}));
+			item.byline = explicit[0]?.byline ?? null;
+			continue;
+		}
+		if (item.primaryBylineId) {
+			item.bylines = [];
+			item.byline = null;
+			continue;
+		}
+		const fallback = fallbackByItem.get(item.id);
+		if (fallback) {
+			item.bylines = [{
+				byline: fallback,
+				sortOrder: 0,
+				roleLabel: null,
+				source: "inferred"
+			}];
+			item.byline = fallback;
+			continue;
+		}
+		item.bylines = [];
+		item.byline = null;
+	}
+}
+/**
+* Resolve an identifier (ID or slug) to a real content ID.
+* Returns the ID if found, null if not found.
+* When locale is provided, slug lookups are scoped to that locale.
+*/
+async function resolveId(repo, collection, identifier, locale) {
+	return (await repo.findByIdOrSlug(collection, identifier, locale))?.id ?? null;
+}
+/**
+* Resolve an identifier (ID or slug) to a real content ID,
+* including trashed (soft-deleted) items.
+*/
+async function resolveIdIncludingTrashed(repo, collection, identifier, locale) {
+	return (await repo.findByIdOrSlugIncludingTrashed(collection, identifier, locale))?.id ?? null;
+}
+async function resolveSearchColumns(db, collection) {
+	const columns = ["slug"];
+	const fieldSlugs = await getCollectionFieldSlugs(db, collection);
+	if (!fieldSlugs) return columns;
+	const fields = new Set(fieldSlugs);
+	for (const candidate of ["title", "name"]) if (fields.has(candidate)) columns.push(candidate);
+	return columns;
+}
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function normalizeDateBound(value, edge) {
+	if (!value) return void 0;
+	if (!DATE_ONLY_RE.test(value)) return value;
+	return edge === "start" ? `${value}T00:00:00.000Z` : `${value}T23:59:59.999Z`;
+}
+/**
+* Create content list handler
+*/
+async function handleContentList(db, collection, params) {
+	try {
+		const repo = new ContentRepository(db);
+		const where = {};
+		if (params.status) where.status = params.status;
+		if (params.locale) where.locale = params.locale;
+		if (params.authorId) where.authorId = params.authorId;
+		if (params.dateField && (params.dateFrom || params.dateTo)) where.dateFilter = {
+			field: params.dateField,
+			from: normalizeDateBound(params.dateFrom, "start"),
+			to: normalizeDateBound(params.dateTo, "end")
+		};
+		const q = params.q?.trim();
+		if (q) {
+			where.q = q;
+			where.searchColumns = await resolveSearchColumns(db, collection);
+		}
+		const result = await repo.findMany(collection, {
+			cursor: params.cursor,
+			limit: params.limit || 50,
+			where: Object.keys(where).length > 0 ? where : void 0,
+			orderBy: params.orderBy ? {
+				field: params.orderBy,
+				direction: params.order || "desc"
+			} : void 0
+		});
+		const hasSeo = await collectionHasSeo(db, collection);
+		await hydrateSeoMany(db, collection, result.items, hasSeo);
+		await hydrateBylinesMany(db, collection, result.items);
+		return {
+			success: true,
+			data: {
+				items: result.items,
+				nextCursor: result.nextCursor,
+				total: result.total
+			}
+		};
+	} catch (error) {
+		console.error("Content list error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_LIST_ERROR",
+				message: "Failed to list content"
+			}
+		};
+	}
+}
+async function handleContentAuthors(db, collection) {
+	try {
+		const authorIds = await new ContentRepository(db).findDistinctAuthorIds(collection);
+		if (authorIds.length === 0) return {
+			success: true,
+			data: { items: [] }
+		};
+		return {
+			success: true,
+			data: { items: (await new UserRepository(db).findByIds(authorIds)).map((user) => ({
+				id: user.id,
+				name: user.name,
+				email: user.email,
+				avatarUrl: user.avatarUrl
+			})).toSorted((a, b) => (a.name ?? a.email).localeCompare(b.name ?? b.email)) }
+		};
+	} catch (error) {
+		console.error("Content authors error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_AUTHORS_ERROR",
+				message: "Failed to list content authors"
+			}
+		};
+	}
+}
+/**
+* Get single content item
+*/
+async function handleContentGet(db, collection, id, locale) {
+	try {
+		const item = await new ContentRepository(db).findByIdOrSlug(collection, id, locale);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		await hydrateBylines(db, collection, item);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_GET_ERROR",
+				message: "Failed to get content"
+			}
+		};
+	}
+}
+/**
+* Get a content item by id, including trashed items.
+* Used by restore endpoint for ownership checks on soft-deleted items.
+*/
+async function handleContentGetIncludingTrashed(db, collection, id, locale) {
+	try {
+		const item = await new ContentRepository(db).findByIdOrSlugIncludingTrashed(collection, id, locale);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		await hydrateBylines(db, collection, item);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_GET_ERROR",
+				message: "Failed to get content"
+			}
+		};
+	}
+}
+/**
+* Create content item.
+*
+* Content + SEO writes are wrapped in a transaction so either both succeed
+* or neither does. If `body.seo` is provided for a non-SEO collection, the
+* API returns a validation error rather than silently dropping it.
+*/
+async function handleContentCreate(db, collection, body) {
+	try {
+		const configuration = await contentWriteConfiguration(db, collection);
+		const hasSeo = await collectionHasSeo(db, collection);
+		const usesDraftRevisions = await collectionSupportsRevisions(db, collection);
+		if (body.seo && !hasSeo) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: `Collection "${collection}" does not have SEO enabled. Remove the seo field or enable SEO on this collection.`
+			}
+		};
+		const fieldCheck = await validateContentDataFields(db, collection, body.data);
+		if (fieldCheck) return fieldCheck;
+		const mimeCheck = await validateMediaFields(db, collection, body.data);
+		if (!mimeCheck.success) return mimeCheck;
+		const repo = new ContentRepository(db);
+		let slug = body.slug;
+		if (!slug) {
+			const source = getSlugSource(body.data);
+			if (source) slug = await repo.generateUniqueSlug(collection, source, body.locale);
+		}
+		const prepared = await repo.prepareCreate({
+			type: collection,
+			slug,
+			data: body.data,
+			status: body.status || "draft",
+			authorId: body.authorId,
+			locale: body.locale,
+			translationOf: body.translationOf,
+			createdAt: body.createdAt,
+			publishedAt: body.publishedAt
+		});
+		const checks = [...prepared.batch.checks ?? [], ...configuration.checks];
+		const statements = [...prepared.batch.statements];
+		if (usesDraftRevisions && (!body.status || body.status === "draft")) {
+			const draft = await repo.prepareDraftSnapshot(collection, prepared.id, body.authorId);
+			checks.push(...draft.checks ?? []);
+			statements.push(...draft.statements);
+		}
+		if (body.bylines !== void 0) {
+			const bylines = await new BylineRepository(db).prepareContentBylines(collection, prepared.id, body.bylines);
+			checks.push(...bylines.checks ?? []);
+			statements.push(...bylines.statements);
+		}
+		if (body.seo && hasSeo) {
+			const seo = new SeoRepository(db).prepareUpsert(collection, prepared.id, body.seo);
+			if (seo) statements.push(seo);
+		}
+		await atomicBatch(db, {
+			checks,
+			statements
+		});
+		invalidateCollectionCache(collection);
+		const item = await repo.findById(collection, prepared.id);
+		if (!item) throw new Error("Failed to reload content");
+		await hydrateBylines(db, collection, item);
+		await hydrateSeo(db, collection, item, hasSeo);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content create error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_CREATE_ERROR",
+				message: "Failed to create content"
+			}
+		};
+	}
+}
+/**
+* Update content item.
+* If `_rev` is provided, validates it against the current version before writing.
+* No `_rev` = blind write (backwards-compatible for admin UI).
+*
+* Content + SEO writes are wrapped in a transaction for atomicity.
+*/
+async function handleContentUpdate(db, collection, id, body, options = {}) {
+	try {
+		const configuration = await contentWriteConfiguration(db, collection);
+		const hasSeo = await collectionHasSeo(db, collection);
+		if (body.seo && !hasSeo) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: `Collection "${collection}" does not have SEO enabled. Remove the seo field or enable SEO on this collection.`
+			}
+		};
+		if (body.data) {
+			const fieldCheck = await validateContentDataFields(db, collection, body.data);
+			if (fieldCheck) return fieldCheck;
+			const mimeCheck = await validateMediaFields(db, collection, body.data);
+			if (!mimeCheck.success) return mimeCheck;
+		}
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id, body.locale) ?? id;
+		const snapshot = await repo.snapshot(collection, resolvedId);
+		if (!snapshot) throw new ContentUpdateApiError("NOT_FOUND", `Content item not found: ${id}`);
+		const existing = snapshot.item;
+		const revCheck = validateRev(body._rev, existing);
+		if (!revCheck.valid) throw new ContentUpdateApiError("CONFLICT", revCheck.message);
+		const checks = [
+			...configuration.checks,
+			snapshot.check,
+			...contentWriteChecks(collection, resolvedId, "edit")
+		];
+		const statements = [];
+		const stageDraft = options.stageDraft && body.data && await collectionSupportsRevisions(db, collection);
+		if (stageDraft) {
+			const revisions = new RevisionRepository(db);
+			const draft = existing.draftRevisionId ? await db.selectFrom("revisions").selectAll().where("id", "=", existing.draftRevisionId).executeTakeFirst() : null;
+			if (existing.draftRevisionId && (!draft || draft.collection !== collection || draft.entry_id !== resolvedId)) throw new ContentUpdateApiError("CONFLICT", "The draft revision is missing or belongs to another entry");
+			if (draft) checks.push(rowUnchanged("revisions", draft));
+			const data = {
+				...draft ? JSON.parse(draft.data) : existing.data,
+				...body.data,
+				...body.slug !== void 0 ? { _slug: body.slug } : {}
+			};
+			if (options.skipRevision && draft && draft.id !== existing.liveRevisionId) statements.push(db.updateTable("revisions").set({ data: JSON.stringify(data) }).where("id", "=", draft.id).compile());
+			else {
+				const revision = revisions.prepareCreateSnapshot({
+					collection,
+					entryId: resolvedId,
+					data: sql`${JSON.stringify(data)}`,
+					authorId: body.authorId ?? void 0
+				});
+				statements.push(revision.statement, sql`UPDATE ${sql.table(`ec_${collection}`)} SET draft_revision_id = ${revision.id} WHERE id = ${resolvedId}`.compile(db));
+			}
+		}
+		statements.push(repo.prepareUpdate(collection, resolvedId, {
+			data: stageDraft ? void 0 : body.data,
+			slug: stageDraft ? void 0 : body.slug,
+			status: body.status,
+			authorId: body.authorId,
+			publishedAt: body.publishedAt
+		}));
+		if (body.bylines !== void 0) {
+			const bylines = await new BylineRepository(db).prepareContentBylines(collection, resolvedId, body.bylines);
+			checks.push(...bylines.checks ?? []);
+			statements.push(...bylines.statements);
+		}
+		const slugChanged = !stageDraft && body.slug && existing.slug && existing.slug !== body.slug;
+		if (slugChanged) statements.push(...new RedirectRepository(db).prepareAutoRedirect(collection, existing.slug, body.slug, resolvedId, configuration.row?.url_pattern ?? null).statements);
+		if (!stageDraft && isI18nEnabled() && body.data && existing.translationGroup) {
+			const sync = prepareNonTranslatableFields(db, collection, resolvedId, existing.translationGroup, body.data, configuration.fields.filter((field) => field.translatable === 0).map((field) => field.slug));
+			if (sync) statements.push(sync);
+		}
+		if (body.seo && hasSeo) {
+			const seo = new SeoRepository(db).prepareUpsert(collection, resolvedId, body.seo);
+			if (seo) statements.push(seo);
+		}
+		await atomicBatch(db, {
+			checks,
+			statements
+		});
+		invalidateCollectionCache(collection);
+		if (slugChanged) invalidateRedirectCache();
+		const item = await repo.findById(collection, resolvedId);
+		if (!item) throw new Error("Failed to reload content");
+		await hydrateSeo(db, collection, item, hasSeo);
+		await hydrateBylines(db, collection, item);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		if (error instanceof AtomicWriteConflict) return {
+			success: false,
+			error: {
+				code: "CONFLICT",
+				message: "Content or its configuration changed during the save. Reload and try again."
+			}
+		};
+		if (error instanceof ContentUpdateApiError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message
+			}
+		};
+		console.error("Content update error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UPDATE_ERROR",
+				message: "Failed to update content"
+			}
+		};
+	}
+}
+/**
+* Duplicate content item.
+*
+* Only copies SEO data if the collection has SEO enabled.
+* Always returns consistent `seo` shape for SEO-enabled collections.
+*/
+async function handleContentDuplicate(db, collection, id, authorId) {
+	try {
+		const configuration = await contentWriteConfiguration(db, collection);
+		const hasSeo = configuration.row?.has_seo === 1;
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const prepared = await repo.prepareDuplicate(collection, resolvedId, authorId);
+		const bylines = await new BylineRepository(db).prepareCopyContentBylines(collection, resolvedId, prepared.id);
+		const checks = [
+			...configuration.checks,
+			...prepared.batch.checks ?? [],
+			...bylines.checks ?? []
+		];
+		const statements = [...prepared.batch.statements, ...bylines.statements];
+		if (await collectionSupportsRevisions(db, collection)) {
+			const draft = await repo.prepareDraftSnapshot(collection, prepared.id, authorId);
+			checks.push(...draft.checks ?? []);
+			statements.push(...draft.statements);
+		}
+		if (hasSeo) statements.push(new SeoRepository(db).prepareCopyForDuplicate(collection, resolvedId, prepared.id));
+		await atomicBatch(db, {
+			checks,
+			statements
+		});
+		invalidateCollectionCache(collection);
+		const duplicate = await repo.findById(collection, prepared.id);
+		if (!duplicate) throw new Error("Failed to reload duplicate");
+		await hydrateBylines(db, collection, duplicate);
+		await hydrateSeo(db, collection, duplicate, hasSeo);
+		return {
+			success: true,
+			data: { item: duplicate }
+		};
+	} catch (err) {
+		if (err instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: err.message
+			}
+		};
+		console.error("Content duplicate error:", err);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DUPLICATE_ERROR",
+				message: "Failed to duplicate content"
+			}
+		};
+	}
+}
+/**
+* Delete content item (soft delete - moves to trash)
+*/
+async function handleContentDelete(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const result = {
+			id: resolvedId,
+			deleted: await repo.delete(collection, resolvedId)
+		};
+		if (!result.deleted) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: {
+				deleted: true,
+				id: result.id
+			}
+		};
+	} catch (error) {
+		console.error("Content delete error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DELETE_ERROR",
+				message: "Failed to delete content"
+			}
+		};
+	}
+}
+/**
+* Restore content item from trash
+*/
+async function handleContentRestore(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveIdIncludingTrashed(repo, collection, id) ?? id;
+		const item = await repo.restore(collection, resolvedId);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Trashed content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: {
+				restored: true,
+				item
+			}
+		};
+	} catch (error) {
+		console.error("Content restore error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_RESTORE_ERROR",
+				message: "Failed to restore content"
+			}
+		};
+	}
+}
+/**
+* Permanently delete content item (cannot be undone).
+* Also cleans up associated SEO data.
+*/
+async function handleContentPermanentDelete(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveIdIncludingTrashed(repo, collection, id) ?? id;
+		const snapshot = await repo.snapshot(collection, resolvedId, true);
+		const deleted = !!snapshot?.deleted;
+		if (snapshot && deleted) {
+			await atomicBatch(db, {
+				checks: [snapshot.check, ...contentWriteChecks(collection, resolvedId, "permanent")],
+				statements: [
+					sql`DELETE FROM ${sql.table(`ec_${collection}`)} WHERE id = ${resolvedId} AND deleted_at IS NOT NULL`.compile(db),
+					db.deleteFrom("_dineway_seo").where("collection", "=", collection).where("content_id", "=", resolvedId).compile(),
+					db.deleteFrom("_dineway_comments").where("collection", "=", collection).where("content_id", "=", resolvedId).compile(),
+					db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", resolvedId).compile(),
+					db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", collection).where("content_id", "=", resolvedId).compile()
+				]
+			});
+			invalidateCollectionCache(collection);
+			invalidateCommentObjectCache();
+		}
+		if (!deleted) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: {
+				deleted: true,
+				id: resolvedId
+			}
+		};
+	} catch (error) {
+		console.error("Content permanent delete error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DELETE_ERROR",
+				message: "Failed to permanently delete content"
+			}
+		};
+	}
+}
+/**
+* List trashed content items
+*/
+async function handleContentListTrashed(db, collection, options = {}) {
+	try {
+		const result = await new ContentRepository(db).findTrashed(collection, {
+			limit: options.limit,
+			cursor: options.cursor
+		});
+		return {
+			success: true,
+			data: {
+				items: result.items.map((item) => ({
+					id: item.id,
+					type: item.type,
+					slug: item.slug,
+					status: item.status,
+					data: item.data,
+					authorId: item.authorId,
+					createdAt: item.createdAt,
+					updatedAt: item.updatedAt,
+					publishedAt: item.publishedAt,
+					deletedAt: item.deletedAt
+				})),
+				nextCursor: result.nextCursor
+			}
+		};
+	} catch (error) {
+		console.error("Content list trashed error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_LIST_ERROR",
+				message: "Failed to list trashed content"
+			}
+		};
+	}
+}
+/**
+* Count trashed content items
+*/
+async function handleContentCountTrashed(db, collection) {
+	try {
+		return {
+			success: true,
+			data: { count: await new ContentRepository(db).countTrashed(collection) }
+		};
+	} catch (error) {
+		console.error("Content count trashed error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COUNT_ERROR",
+				message: "Failed to count trashed content"
+			}
+		};
+	}
+}
+/**
+* Schedule content for future publishing
+*/
+async function handleContentSchedule(db, collection, id, scheduledAt) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const item = await repo.schedule(collection, resolvedId, scheduledAt);
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content schedule error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_SCHEDULE_ERROR",
+				message: "Failed to schedule content"
+			}
+		};
+	}
+}
+/**
+* Unschedule content (revert to draft)
+*/
+async function handleContentUnschedule(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const item = await repo.unschedule(collection, resolvedId);
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content unschedule error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UNSCHEDULE_ERROR",
+				message: "Failed to unschedule content"
+			}
+		};
+	}
+}
+/**
+* Publish content immediately.
+*
+* Wrapped in a transaction because publish performs multiple writes
+* (syncDataColumns, slug sync, status/revision update) that must
+* be atomic to prevent FTS shadow table corruption on crash.
+*/
+async function prepareContentPublication(db, collection, id, options = {}) {
+	const configuration = await contentWriteConfiguration(db, collection);
+	const repo = new ContentRepository(db);
+	const resolvedId = await resolveId(repo, collection, id) ?? id;
+	const prepared = await repo.preparePublish(collection, resolvedId, options.publishedAt, options.requireScheduledDue);
+	const statements = [...prepared.batch.statements];
+	const existing = prepared.previous;
+	const slugChanged = existing.status === "published" && existing.slug && prepared.slug && existing.slug !== prepared.slug;
+	if (slugChanged) statements.push(...new RedirectRepository(db).prepareAutoRedirect(collection, existing.slug, prepared.slug, resolvedId, configuration.row?.url_pattern ?? null).statements);
+	return {
+		resolvedId,
+		previous: existing,
+		slugChanged,
+		batch: {
+			checks: [...configuration.checks, ...prepared.batch.checks],
+			statements
+		}
+	};
+}
+async function handleContentPublish(db, collection, id, options = {}) {
+	try {
+		const prepared = await prepareContentPublication(db, collection, id, options);
+		await atomicBatch(db, prepared.batch);
+		const { resolvedId, slugChanged } = prepared;
+		const repo = new ContentRepository(db);
+		invalidateCollectionCache(collection);
+		if (slugChanged) invalidateRedirectCache();
+		const item = await repo.findById(collection, resolvedId);
+		if (!item) throw new Error("Content not found");
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		if (error instanceof ScheduledNotDueError) return {
+			success: false,
+			error: {
+				code: "NOT_DUE",
+				message: error.message
+			}
+		};
+		console.error("Content publish error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_PUBLISH_ERROR",
+				message: "Failed to publish content"
+			}
+		};
+	}
+}
+/**
+* Unpublish content (revert to draft).
+*
+* Wrapped in a transaction — unpublish may create a draft revision
+* from the live version then update the status, which is multi-step.
+*/
+async function handleContentUnpublish(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const item = await repo.unpublish(collection, resolvedId);
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content unpublish error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UNPUBLISH_ERROR",
+				message: "Failed to unpublish content"
+			}
+		};
+	}
+}
+/**
+* Count scheduled content items
+*/
+async function handleContentCountScheduled(db, collection) {
+	try {
+		return {
+			success: true,
+			data: { count: await new ContentRepository(db).countScheduled(collection) }
+		};
+	} catch (error) {
+		console.error("Content count scheduled error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COUNT_ERROR",
+				message: "Failed to count scheduled content"
+			}
+		};
+	}
+}
+/**
+* Discard draft changes (revert to live version)
+*/
+async function handleContentDiscardDraft(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		const item = await repo.discardDraft(collection, resolvedId);
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: error.message
+			}
+		};
+		console.error("Content discard draft error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DISCARD_DRAFT_ERROR",
+				message: "Failed to discard draft"
+			}
+		};
+	}
+}
+/**
+* Compare live and draft revisions
+*/
+async function handleContentCompare(db, collection, id) {
+	try {
+		const entry = await new ContentRepository(db).findByIdOrSlug(collection, id);
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		const revisionRepo = new RevisionRepository(db);
+		const live = entry.liveRevisionId ? await revisionRepo.findById(entry.liveRevisionId) : null;
+		const draft = entry.draftRevisionId ? await revisionRepo.findById(entry.draftRevisionId) : null;
+		return {
+			success: true,
+			data: {
+				hasChanges: entry.draftRevisionId !== null && entry.draftRevisionId !== entry.liveRevisionId,
+				live: live?.data ?? null,
+				draft: draft?.data ?? null
+			}
+		};
+	} catch (error) {
+		console.error("Content compare error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COMPARE_ERROR",
+				message: "Failed to compare revisions"
+			}
+		};
+	}
+}
+/**
+* Get all translations for a content item.
+* Returns the item's translation group members with locale and status info.
+*/
+async function handleContentTranslations(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const item = await repo.findByIdOrSlug(collection, id);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		if (!item.translationGroup) return {
+			success: true,
+			data: {
+				translationGroup: item.id,
+				translations: [{
+					id: item.id,
+					locale: item.locale,
+					slug: item.slug,
+					status: item.status,
+					updatedAt: item.updatedAt
+				}]
+			}
+		};
+		const translations = await repo.findTranslations(collection, item.translationGroup);
+		return {
+			success: true,
+			data: {
+				translationGroup: item.translationGroup,
+				translations: translations.map((t) => ({
+					id: t.id,
+					locale: t.locale,
+					slug: t.slug,
+					status: t.status,
+					updatedAt: t.updatedAt
+				}))
+			}
+		};
+	} catch (error) {
+		if (error instanceof Error) console.error("Content translations error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_TRANSLATIONS_ERROR",
+				message: "Failed to get translations"
+			}
+		};
+	}
+}
+/**
+* Sync non-translatable fields to sibling locales.
+*
+* When a content item is updated and it belongs to a translation group,
+* any non-translatable fields in the update data are written to all other
+* rows in the same translation group within the same transaction.
+*
+* Non-translatable fields are **copied, not linked** — each row owns its
+* own data. This keeps queries simple and avoids cross-row joins.
+*/
+function prepareNonTranslatableFields(db, collectionSlug, updatedItemId, translationGroup, data, nonTranslatableSlugs) {
+	const syncData = {};
+	for (const slug of nonTranslatableSlugs) if (slug in data) syncData[slug] = data[slug];
+	if (Object.keys(syncData).length === 0) return null;
+	validateIdentifier(collectionSlug, "collection slug");
+	const tableName = `ec_${collectionSlug}`;
+	const setClauses = Object.entries(syncData).map(([key, value]) => {
+		validateIdentifier(key, "field slug");
+		const serialized = typeof value === "object" && value !== null ? JSON.stringify(value) : typeof value === "boolean" ? Number(value) : value;
+		return sql`${sql.ref(key)} = ${serialized}`;
+	});
+	return sql`
+		UPDATE ${sql.ref(tableName)}
+		SET ${sql.join(setClauses, sql`, `)}
+		WHERE translation_group = ${translationGroup}
+		AND id != ${updatedItemId}
+	`.compile(db);
+}
+
+//#endregion
+//#region src/site-context/action-hash.ts
+async function buildStableActionHash(value) {
+	return buildStableHash(value);
+}
+
+//#endregion
+//#region src/site-context/review-payload.ts
+var ReviewPayloadBuilder = class {
+	constructor(handlers) {
+		this.handlers = handlers;
+	}
+	async buildContentReviewPayload(input) {
+		const actionType = input.actionType ?? "content.publish";
+		const content = await this.loadContent(input.collection, input.id);
+		const compare = await this.loadCompare(input.collection, content.entryId);
+		const live = asRecord(compare.live);
+		const draft = asRecord(compare.draft) ?? content.data;
+		const displayTitle = stringOrNull(draft.title) ?? content.displayTitle;
+		const hasChanges = typeof compare.hasChanges === "boolean" ? compare.hasChanges : stableStringify(live) !== stableStringify(draft);
+		const actionHash = await buildStableActionHash({
+			actionType,
+			collection: input.collection,
+			entryId: content.entryId,
+			liveRevisionId: content.liveRevisionId,
+			draftRevisionId: content.draftRevisionId,
+			reviewedRev: content.reviewedRev,
+			live,
+			draft
+		});
+		const scope = `content:${input.collection}:${content.entryId}`;
+		const summary = input.summary ?? `Review ${actionType} for ${input.collection}/${displayTitle ?? content.entryId}`;
+		return {
+			collection: input.collection,
+			entryId: content.entryId,
+			scope,
+			liveRevisionId: content.liveRevisionId,
+			draftRevisionId: content.draftRevisionId,
+			reviewedRev: content.reviewedRev,
+			actionType,
+			actionHash,
+			reviewPayload: {
+				kind: "content_review",
+				actionType,
+				summary,
+				target: {
+					collection: input.collection,
+					entryId: content.entryId,
+					scope,
+					liveRevisionId: content.liveRevisionId,
+					draftRevisionId: content.draftRevisionId,
+					reviewedRev: content.reviewedRev,
+					actionHash
+				},
+				content: {
+					id: content.entryId,
+					slug: content.slug,
+					status: content.status,
+					title: displayTitle,
+					updatedAt: content.updatedAt
+				},
+				diff: {
+					hasChanges,
+					live,
+					draft
+				}
+			}
+		};
+	}
+	async loadContent(collection, id) {
+		const result = await this.handlers.handleContentGet(collection, id);
+		if (!result.success) throw new Error(result.error?.message ?? `Content item not found: ${collection}/${id}`);
+		const payload = asRecord(result.data);
+		const item = asRecord(payload?.item);
+		if (!payload || !item) throw new Error("Content get response did not include an item");
+		const entryId = stringOrNull(item.id);
+		const reviewedRev = stringOrNull(payload._rev);
+		if (!entryId) throw new Error("Content item is missing id");
+		if (!reviewedRev) throw new Error("Content item is missing _rev for review binding");
+		const data = asRecord(item.data) ?? {};
+		const title = stringOrNull(data.title) ?? stringOrNull(item.title) ?? stringOrNull(item.slug);
+		return {
+			entryId,
+			reviewedRev,
+			liveRevisionId: stringOrNull(item.liveRevisionId),
+			draftRevisionId: stringOrNull(item.draftRevisionId),
+			slug: stringOrNull(item.slug),
+			status: stringOrNull(item.status),
+			updatedAt: stringOrNull(item.updatedAt),
+			displayTitle: title,
+			data
+		};
+	}
+	async loadCompare(collection, id) {
+		const result = await this.handlers.handleContentCompare(collection, id);
+		if (!result.success) throw new Error(result.error?.message ?? `Failed to compare content: ${collection}/${id}`);
+		return asRecord(result.data) ?? {};
+	}
+};
+function asRecord(value) {
+	return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+//#endregion
+export { validateRev as A, handleContentUpdate as C, validateMediaFields as D, validateContentDataFields as E, decodeRev as O, handleContentUnschedule as S, prepareNonTranslatableFields as T, handleContentPublish as _, handleContentCompare as a, handleContentTranslations as b, handleContentCreate as c, handleContentDuplicate as d, handleContentGet as f, handleContentPermanentDelete as g, handleContentListTrashed as h, handleContentAuthors as i, encodeRev as k, handleContentDelete as l, handleContentList as m, buildStableActionHash as n, handleContentCountScheduled as o, handleContentGetIncludingTrashed as p, contentWriteConfiguration as r, handleContentCountTrashed as s, ReviewPayloadBuilder as t, handleContentDiscardDraft as u, handleContentRestore as v, prepareContentPublication as w, handleContentUnpublish as x, handleContentSchedule as y };