dineway 0.2.39 → 0.2.41

package/dist/{review-payload-Bap86e75.mjs → content-write-DAZCNKWl.mjs}

@@ -1,23 +1,304 @@
-import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { AtomicWriteConflict, atomicBatch, prepareAtomicChecks, 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-RFzE_V1M.mjs";
-import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
-import { o as invalidateCollectionCache, s as invalidateCommentObjectCache } from "./object-cache-mxCW-Rpt.mjs";
-import { t as RevisionRepository } from "./revision-W6FDfDqx.mjs";
-import { t as ContentRepository } from "./content-CIKsrvU9.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
-import { t as UserRepository } from "./user-Btai9rl3.mjs";
-import { n as stableStringify, t as buildStableHash } from "./stable-hash-B9Tbb2f_.mjs";
-import { t as RedirectRepository } from "./redirect-BQFa1THe.mjs";
-import { r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { t as BylineRepository } from "./byline-TYk2kad6.mjs";
-import { r as parseAllowedMimeTypes, t as matchesMimeAllowlist } from "./mime-BnVhH671.mjs";
-import { i as invalidateRedirectCache } from "./cache-B5NSHhxG.mjs";
-import { t as SeoRepository } from "./seo-Bs_DUxJf.mjs";
+import { i as resolveContentPartition, n as contentDigest, o as ContentStorageError, s as ContentStorageReplay } from "./config-6R0bchVE.mjs";
+import { d as contentPartitionWritable, p as readContentPartitionRoute, r as getContentStorage } from "./runtime-Ch5G-tnG.mjs";
+import { n as readRevisionDataBatch, r as storedRevisionIndex, t as readRevisionData } from "./revisions-CQ7rMP5d.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-qvSs0Gxy.mjs";
+import { n as ScheduledNotDueError, t as DinewayValidationError } from "./types-BI3ULB3A.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-Bf5QZboB.mjs";
+import { a as prepareContentHookEvents, s as contentStorageHookSnapshotSchema, t as ContentRepository } from "./content-BigS8BAv.mjs";
+import { r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { o as invalidateCollectionCache, s as invalidateCommentObjectCache } from "./object-cache-DyI1SOBK.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
+import { t as BylineRepository } from "./byline-3qjp1-oa.mjs";
+import { i as storedContentSeo, r as snapshotOwnedContentMetadata, t as contentEventBylines } from "./owned-metadata-BPmUjZqI.mjs";
+import { t as RevisionRepository } from "./revision-B_HYO2AE.mjs";
+import { t as UserRepository } from "./user-Bl2_8rhJ.mjs";
+import { i as snapshotPartitionTerms, n as prepareContentTerms, r as snapshotContentTermChanges } from "./terms-EskuqbKE.mjs";
+import { t as RedirectRepository } from "./redirect-CJ-FAbNK.mjs";
+import { i as invalidateRedirectCache } from "./cache-DsEbwFVE.mjs";
+import { r as parseAllowedMimeTypes, t as matchesMimeAllowlist } from "./mime-FkfazULS.mjs";
+import { n as extractSearchableFields } from "./text-extraction-CdqMGYQK.mjs";
+import { a as contentVersionSchema } from "./version-store-BXv2D0de.mjs";
+import { r as markContentWriteReplay, t as beginContentWriteIntent } from "./write-intent-DuHVqks9.mjs";
+import { t as SeoRepository } from "./seo-Cv7ud_m2.mjs";
 import { sql } from "kysely";
+import { ulid } from "ulidx";
+import { z } from "zod";
 
+//#region src/content-storage/partition-snapshot.ts
+/** Resolver code sees only declared snapshots; their primary rows are fenced at activation. */
+async function snapshotPartitionDependencies(db, collection, item, rule, changes) {
+	const checks = [];
+	const dependencies = {
+		taxonomies: {},
+		references: {}
+	};
+	if ("field" in rule.partitionBy) return {
+		dependencies,
+		checks
+	};
+	const taxonomies = {};
+	for (const name of rule.partitionBy.taxonomies ?? []) {
+		const snapshot = await snapshotPartitionTerms(db, collection, item.id, name, item.locale ?? "en", changes?.[name]);
+		taxonomies[name] = snapshot.terms;
+		checks.push(...snapshot.checks);
+	}
+	const references = {};
+	for (const [field, definition] of Object.entries(rule.partitionBy.references ?? {})) {
+		const value = item.data[field];
+		if (value == null || value === "") {
+			references[field] = null;
+			continue;
+		}
+		const id = typeof value === "string" ? value : z.object({
+			id: z.string(),
+			collection: z.literal(definition.collection).optional()
+		}).parse(value).id;
+		const snapshot = await new ContentRepository(db).snapshot(definition.collection, id);
+		if (!snapshot) throw new ContentStorageError("INVALID_PARTITION", `Partition reference ${field} does not exist.`);
+		checks.push(snapshot.check);
+		const relatedTerms = {};
+		for (const name of definition.taxonomies ?? []) {
+			const terms = await snapshotPartitionTerms(db, definition.collection, id, name, snapshot.item.locale ?? "en");
+			relatedTerms[name] = terms.terms;
+			checks.push(...terms.checks);
+		}
+		references[field] = {
+			collection: definition.collection,
+			id,
+			data: z.record(z.string(), z.json()).parse(snapshot.item.data),
+			taxonomies: relatedTerms
+		};
+	}
+	dependencies.taxonomies = taxonomies;
+	dependencies.references = references;
+	return {
+		dependencies,
+		checks
+	};
+}
+
+//#endregion
+//#region src/content-storage/projection.ts
+/** A central list/search projection; full bodies are loaded through the directory. */
+function contentProjectionValues(item, fields, full = false) {
+	const values = {
+		id: item.id,
+		slug: item.slug,
+		status: item.status,
+		author_id: item.authorId,
+		primary_byline_id: item.primaryBylineId,
+		created_at: item.createdAt,
+		updated_at: item.updatedAt,
+		published_at: item.publishedAt,
+		scheduled_at: item.scheduledAt,
+		version: item.version,
+		live_revision_id: item.liveRevisionId,
+		draft_revision_id: item.draftRevisionId,
+		locale: item.locale ?? "en",
+		translation_group: item.translationGroup
+	};
+	for (const field of fields) {
+		if (!full && field.type === "portableText" && field.searchable === 1 && field.unique !== 1) {
+			values[field.slug] = extractSearchableFields(item.data, [field.slug])[field.slug] ?? "";
+			continue;
+		}
+		const value = full || field.column_type !== "JSON" || field.unique === 1 || field.searchable === 1 ? item.data[field.slug] : void 0;
+		values[field.slug] = value == null ? field.required ? "null" : null : typeof value === "object" ? JSON.stringify(value) : value;
+	}
+	return values;
+}
+function prepareContentProjection(db, collection, item, fields, create, full = false) {
+	const values = contentProjectionValues(item, fields, full);
+	const columns = Object.keys(values);
+	return create ? sql`INSERT INTO ${sql.table(`ec_${collection}`)} (${sql.join(columns.map((column) => sql.ref(column)))}) VALUES (${sql.join(columns.map((column) => values[column] === null ? sql`NULL` : sql`${values[column]}`))})`.compile(db) : sql`UPDATE ${sql.table(`ec_${collection}`)} SET ${sql.join(columns.filter((column) => column !== "id").map((column) => sql`${sql.ref(column)} = ${values[column] === null ? sql`NULL` : sql`${values[column]}`} `))} WHERE id = ${item.id}`.compile(db);
+}
+
+//#endregion
+//#region src/content-storage/prepare-write.ts
+async function prepareRoutedContentWrite(options) {
+	const { db, collection, item } = options;
+	const storage = getContentStorage(db, collection);
+	if (!storage) return void 0;
+	const location = await storage.coordinator.locate(collection, item.id);
+	const rootVersion = options.rootVersion ?? ulid();
+	const operationId = options.operationId ?? rootVersion;
+	const principalId = getRequestContext()?.writePrincipal?.id ?? "system";
+	const partitionSnapshot = await snapshotPartitionDependencies(db, collection, item, storage.runtime.config.rules[collection], options.terms);
+	const resolved = await resolveContentPartition(storage.runtime.config, {
+		collection,
+		id: item.id,
+		data: contentVersionSchema.shape.data.parse(item.data),
+		dependencies: partitionSnapshot.dependencies
+	}, storage.runtime.resolvers);
+	if (!resolved) throw new Error("Content storage rule is unavailable.");
+	const partition = await readContentPartitionRoute(db, collection, resolved.partition);
+	if (partition.route.state === "frozen") throw new ContentStorageError("FROZEN", "Content in this partition is temporarily read-only during migration. Please retry shortly.");
+	if (partition.route.target_store !== resolved.store) throw new Error("The partition mapping requires an explicit storage migration.");
+	const destination = {
+		partition: resolved.partition,
+		store: partition.route.store
+	};
+	if (partition.route.store === "primary") {
+		const data = contentVersionSchema.shape.data.parse(item.data);
+		const command = {
+			collection,
+			entryId: item.id,
+			store: "primary",
+			partition: destination.partition,
+			partitionEpoch: partition.route.epoch,
+			routingVersion: storage.runtime.config.version,
+			version: rootVersion,
+			digest: await contentDigest(data),
+			operationId,
+			principalId,
+			expectedVersion: location?.version ?? null
+		};
+		const history = location && location.store !== "primary" ? await db.selectFrom("revisions").selectAll().where("collection", "=", collection).where("entry_id", "=", item.id).execute() : [];
+		const snapshots = await readRevisionDataBatch(db, history);
+		const effects = options.effects ? await prepareContentHookEvents(db, command, options.effects.snapshot, options.effects.targets) : { statements: [] };
+		return {
+			checks: [
+				...options.checks,
+				...partitionSnapshot.checks,
+				partition.check,
+				...history.map((row) => rowUnchanged("revisions", row))
+			],
+			statements: [
+				...history.map((row, index) => db.updateTable("revisions").set({ data: JSON.stringify(snapshots[index]) }).where("id", "=", row.id).compile()),
+				...options.primaryStatements,
+				...effects.statements,
+				sql`INSERT INTO _dineway_content_locations (collection, entry_id, store, partition, routing_version, version, digest) VALUES (${collection}, ${item.id}, 'primary', ${destination.partition}, ${storage.runtime.config.version}, ${rootVersion}, ${command.digest}) ON CONFLICT (collection, entry_id) DO UPDATE SET store=excluded.store, partition=excluded.partition, routing_version=excluded.routing_version, version=excluded.version, digest=excluded.digest`.compile(db),
+				sql`INSERT INTO _dineway_content_operations (id, collection, entry_id, command, state, created_at, updated_at) VALUES (${operationId}, ${collection}, ${item.id}, ${JSON.stringify(command)}, 'committed', ${item.updatedAt}, ${item.updatedAt})`.compile(db)
+			]
+		};
+	}
+	const metadata = {
+		slug: item.slug,
+		status: item.status,
+		authorId: item.authorId,
+		primaryBylineId: item.primaryBylineId,
+		createdAt: item.createdAt,
+		updatedAt: item.updatedAt,
+		publishedAt: item.publishedAt,
+		scheduledAt: item.scheduledAt,
+		liveRevisionId: item.liveRevisionId,
+		draftRevisionId: item.draftRevisionId,
+		version: item.version,
+		locale: item.locale,
+		translationGroup: item.translationGroup
+	};
+	const moving = !!location && location.store !== destination.store;
+	const existingRevisions = moving ? await db.selectFrom("revisions").selectAll().where("collection", "=", collection).where("entry_id", "=", item.id).execute() : [];
+	const history = [];
+	const retainedRevisions = existingRevisions.filter((revision) => !options.revisions.some((next) => next.id === revision.id));
+	const retainedData = await readRevisionDataBatch(db, retainedRevisions);
+	for (const [index, revision] of retainedRevisions.entries()) history.push({
+		id: revision.id,
+		data: retainedData[index],
+		authorId: revision.author_id ?? void 0
+	});
+	const historicalIds = new Set(history.map((revision) => revision.id));
+	const revisions = await Promise.all([...history, ...options.revisions].map(async (revision) => {
+		const data = contentVersionSchema.shape.data.parse(revision.data);
+		const version = historicalIds.has(revision.id) || revision.replace ? await contentDigest({
+			rootVersion,
+			revisionId: revision.id
+		}) : revision.id;
+		return {
+			revision,
+			data,
+			reference: {
+				collection,
+				entryId: item.id,
+				store: destination.store,
+				partition: destination.partition,
+				routingVersion: storage.runtime.config.version,
+				version,
+				digest: await contentDigest(data)
+			}
+		};
+	}));
+	const payload = contentVersionSchema.shape.data.parse({
+		...item.data,
+		_dineway: {
+			...metadata,
+			...options.owned ? { owned: options.owned } : {},
+			partitionDependencies: partitionSnapshot.dependencies,
+			revisions: revisions.map((revision) => ({
+				id: revision.revision.id,
+				...revision.reference
+			}))
+		}
+	});
+	const command = {
+		partitionEpoch: partition.route.epoch,
+		collection,
+		entryId: item.id,
+		...destination,
+		routingVersion: storage.runtime.config.version,
+		version: rootVersion,
+		digest: await contentDigest(payload),
+		operationId,
+		principalId,
+		expectedVersion: location?.version ?? null
+	};
+	const projection = prepareContentProjection(db, collection, item, options.fields, options.create);
+	const effects = options.effects ? await prepareContentHookEvents(db, command, options.effects.snapshot, options.effects.targets) : { statements: [] };
+	return storage.coordinator.prepareCommit({
+		command,
+		data: payload
+	}, {
+		authorize: async () => options.create ? [] : contentWriteChecks(collection, item.id, "edit"),
+		prepare: async () => {
+			const statements = [];
+			const store = storage.stores[destination.store];
+			for (const revision of revisions) {
+				await store.prepare({
+					command: {
+						...revision.reference,
+						kind: "revision",
+						operationId: await contentDigest({
+							operationId,
+							revisionId: revision.revision.id
+						}),
+						principalId,
+						expectedVersion: null
+					},
+					data: revision.data
+				});
+				statements.push(historicalIds.has(revision.revision.id) || revision.revision.replace ? db.updateTable("revisions").set({ data: storedRevisionIndex(revision.reference) }).where("id", "=", revision.revision.id).compile() : db.insertInto("revisions").values({
+					id: revision.revision.id,
+					collection,
+					entry_id: item.id,
+					data: storedRevisionIndex(revision.reference),
+					author_id: revision.revision.authorId ?? null,
+					created_at: item.updatedAt
+				}).compile());
+			}
+			statements.push(projection);
+			return {
+				checks: [
+					...options.checks,
+					...partitionSnapshot.checks,
+					...existingRevisions.map((revision) => rowUnchanged("revisions", revision)),
+					...moving ? [sql`(SELECT COUNT(*) FROM revisions WHERE collection = ${collection} AND entry_id = ${item.id}) = ${existingRevisions.length}`] : []
+				],
+				statements: [
+					...statements,
+					...options.globalStatements,
+					...effects.statements
+				]
+			};
+		}
+	});
+}
+
+//#endregion
 //#region src/api/rev.ts
 /**
 * Generate a _rev token from a content item's version and updatedAt.
@@ -135,6 +416,38 @@ async function validateMediaFields(db, collectionSlug, data) {
 
 //#endregion
 //#region src/api/handlers/content.ts
+function contentStorageFailure(error) {
+	if (!(error instanceof ContentStorageError)) return void 0;
+	return {
+		success: false,
+		error: {
+			code: error.code === "INVALID_PARTITION" ? "VALIDATION_ERROR" : error.code === "CONFLICT" || error.code === "ROUTE_CHANGED" ? "CONFLICT" : "CONTENT_STORAGE_UNAVAILABLE",
+			message: {
+				FROZEN: "This content is temporarily read-only. Please retry shortly.",
+				UNAVAILABLE: "Content is temporarily unavailable. Please retry shortly.",
+				INVALID_CONFIG: "Content storage is temporarily unavailable. Please retry shortly.",
+				INVALID_PARTITION: "The fields used to organize this content are missing or inconsistent. Check them and try again.",
+				ROUTE_CHANGED: "Content routing changed. Reload and try again.",
+				CONFLICT: "Content changed during this operation. Reload and try again."
+			}[error.code]
+		}
+	};
+}
+async function commitRoutedContent(db, collection, input, metadata = {}) {
+	try {
+		const prepared = await prepareContentWrite(db, collection, {
+			...input,
+			bylines: metadata.bylines,
+			seo: metadata.hasSeo ? metadata.seo : void 0
+		});
+		await atomicBatch(db, prepared.batch);
+		prepared.afterCommit();
+		return handleContentGet(db, collection, prepared.id);
+	} catch (error) {
+		if (error instanceof ContentStorageReplay) return markContentWriteReplay(await handleContentGet(db, collection, error.location.entryId));
+		throw error;
+	}
+}
 /**
 * Extract a slug source (title or name) from content data.
 * Returns null if no suitable string field is found.
@@ -400,6 +713,8 @@ async function handleContentList(db, collection, params) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content list error:", error);
 		return {
 			success: false,
@@ -427,6 +742,8 @@ async function handleContentAuthors(db, collection) {
 			})).toSorted((a, b) => (a.name ?? a.email).localeCompare(b.name ?? b.email)) }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content authors error:", error);
 		return {
 			success: false,
@@ -460,6 +777,8 @@ async function handleContentGet(db, collection, id, locale) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content get error:", error);
 		return {
 			success: false,
@@ -494,6 +813,8 @@ async function handleContentGetIncludingTrashed(db, collection, id, locale) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content get error:", error);
 		return {
 			success: false,
@@ -527,6 +848,25 @@ async function handleContentCreate(db, collection, body) {
 		if (fieldCheck) return fieldCheck;
 		const mimeCheck = await validateMediaFields(db, collection, body.data);
 		if (!mimeCheck.success) return mimeCheck;
+		if (getContentStorage(db, collection)) {
+			if (body.status && body.status !== "draft" && body.status !== "published") throw new DinewayValidationError("Content must be created as a draft or published item.");
+			return await commitRoutedContent(db, collection, {
+				operationId: body.operationId,
+				data: body.data,
+				terms: body.terms,
+				slug: body.slug,
+				authorId: body.authorId,
+				locale: body.locale,
+				translationOf: body.translationOf,
+				createdAt: body.createdAt,
+				publishedAt: body.publishedAt,
+				publish: body.status === "published"
+			}, {
+				bylines: body.bylines,
+				seo: body.seo,
+				hasSeo
+			});
+		}
 		const repo = new ContentRepository(db);
 		let slug = body.slug;
 		if (!slug) {
@@ -546,6 +886,11 @@ async function handleContentCreate(db, collection, body) {
 		});
 		const checks = [...prepared.batch.checks ?? [], ...configuration.checks];
 		const statements = [...prepared.batch.statements];
+		if (body.terms) {
+			const terms = await prepareContentTerms(db, collection, prepared.id, body.terms, body.locale ?? "en");
+			checks.push(...terms.checks ?? []);
+			statements.push(...terms.statements);
+		}
 		if (usesDraftRevisions && (!body.status || body.status === "draft")) {
 			const draft = await repo.prepareDraftSnapshot(collection, prepared.id, body.authorId);
 			checks.push(...draft.checks ?? []);
@@ -577,6 +922,8 @@ async function handleContentCreate(db, collection, body) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content create error:", error);
 		return {
 			success: false,
@@ -613,6 +960,30 @@ async function handleContentUpdate(db, collection, id, body, options = {}) {
 		}
 		const repo = new ContentRepository(db);
 		const resolvedId = await resolveId(repo, collection, id, body.locale) ?? id;
+		if (getContentStorage(db, collection)) {
+			const existing = await repo.findById(collection, resolvedId);
+			if (!existing) throw new ContentUpdateApiError("NOT_FOUND", `Content item not found: ${id}`);
+			if (body.status && body.status !== "draft" && body.status !== "published") throw new DinewayValidationError("Use the scheduling endpoint to change scheduled content.");
+			return await commitRoutedContent(db, collection, {
+				operationId: body.operationId,
+				id: resolvedId,
+				data: body.data,
+				terms: body.terms,
+				slug: body.slug,
+				authorId: body.authorId,
+				expectedRev: body._rev,
+				publishedAt: body.publishedAt,
+				stageDraft: !!options.stageDraft && !!body.data,
+				reuseDraftRevision: options.skipRevision,
+				publish: body.status === "published",
+				unpublish: existing.status === "published" && body.status === "draft",
+				status: body.status === "draft" ? "draft" : void 0
+			}, {
+				bylines: body.bylines,
+				seo: body.seo,
+				hasSeo
+			});
+		}
 		const snapshot = await repo.snapshot(collection, resolvedId);
 		if (!snapshot) throw new ContentUpdateApiError("NOT_FOUND", `Content item not found: ${id}`);
 		const existing = snapshot.item;
@@ -624,6 +995,11 @@ async function handleContentUpdate(db, collection, id, body, options = {}) {
 			...contentWriteChecks(collection, resolvedId, "edit")
 		];
 		const statements = [];
+		if (body.terms) {
+			const terms = await prepareContentTerms(db, collection, resolvedId, body.terms, existing.locale ?? "en");
+			checks.push(...terms.checks ?? []);
+			statements.push(...terms.statements);
+		}
 		const stageDraft = options.stageDraft && body.data && await collectionSupportsRevisions(db, collection);
 		if (stageDraft) {
 			const revisions = new RevisionRepository(db);
@@ -686,6 +1062,8 @@ async function handleContentUpdate(db, collection, id, body, options = {}) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof AtomicWriteConflict) return {
 			success: false,
 			error: {
@@ -722,6 +1100,43 @@ async function handleContentDuplicate(db, collection, id, authorId) {
 		const hasSeo = configuration.row?.has_seo === 1;
 		const repo = new ContentRepository(db);
 		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		if (getContentStorage(db, collection)) {
+			const snapshot = await repo.snapshot(collection, resolvedId);
+			if (!snapshot) throw new DinewayValidationError("Content item not found");
+			const data = { ...snapshot.item.data };
+			if (typeof data.title === "string") data.title += " (Copy)";
+			else if (typeof data.name === "string") data.name += " (Copy)";
+			const terms = await snapshotContentTermChanges(db, collection, resolvedId);
+			const metadata = await snapshotOwnedContentMetadata(db, collection, resolvedId);
+			const bylines = await new BylineRepository(db).getContentBylines(collection, resolvedId, { locale: snapshot.item.locale ?? void 0 });
+			const seo = hasSeo ? await new SeoRepository(db).get(collection, resolvedId) : void 0;
+			const prepared = await prepareContentWrite(db, collection, {
+				data,
+				terms: terms.changes,
+				bylines: bylines.map((credit) => ({
+					bylineId: credit.byline.id,
+					roleLabel: credit.roleLabel
+				})),
+				seo: seo ? {
+					...seo,
+					canonical: null
+				} : void 0,
+				authorId: authorId ?? snapshot.item.authorId,
+				locale: snapshot.item.locale ?? void 0
+			});
+			await atomicBatch(db, {
+				checks: [
+					...prepared.batch.checks ?? [],
+					...metadata.checks,
+					...terms.checks,
+					snapshot.check,
+					...contentWriteChecks(collection, resolvedId, "edit")
+				],
+				statements: prepared.batch.statements
+			});
+			prepared.afterCommit();
+			return await handleContentGet(db, collection, prepared.id);
+		}
 		const prepared = await repo.prepareDuplicate(collection, resolvedId, authorId);
 		const bylines = await new BylineRepository(db).prepareCopyContentBylines(collection, resolvedId, prepared.id);
 		const checks = [
@@ -750,6 +1165,8 @@ async function handleContentDuplicate(db, collection, id, authorId) {
 			data: { item: duplicate }
 		};
 	} catch (err) {
+		const storageError = contentStorageFailure(err);
+		if (storageError) return storageError;
 		if (err instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -793,6 +1210,8 @@ async function handleContentDelete(db, collection, id) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content delete error:", error);
 		return {
 			success: false,
@@ -826,6 +1245,8 @@ async function handleContentRestore(db, collection, id) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content restore error:", error);
 		return {
 			success: false,
@@ -844,22 +1265,8 @@ 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();
-		}
+		const deleted = await repo.permanentDelete(collection, resolvedId);
+		if (deleted) invalidateCommentObjectCache();
 		if (!deleted) return {
 			success: false,
 			error: {
@@ -875,6 +1282,8 @@ async function handleContentPermanentDelete(db, collection, id) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content permanent delete error:", error);
 		return {
 			success: false,
@@ -913,6 +1322,8 @@ async function handleContentListTrashed(db, collection, options = {}) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content list trashed error:", error);
 		return {
 			success: false,
@@ -933,6 +1344,8 @@ async function handleContentCountTrashed(db, collection) {
 			data: { count: await new ContentRepository(db).countTrashed(collection) }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content count trashed error:", error);
 		return {
 			success: false,
@@ -957,6 +1370,8 @@ async function handleContentSchedule(db, collection, id, scheduledAt) {
 			data: { item }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -988,6 +1403,8 @@ async function handleContentUnschedule(db, collection, id) {
 			data: { item }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -1016,6 +1433,26 @@ 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;
+	if (getContentStorage(db, collection)) {
+		const snapshot = await repo.snapshot(collection, resolvedId);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		if (options.requireScheduledDue && (!snapshot.item.scheduledAt || snapshot.item.scheduledAt > (/* @__PURE__ */ new Date()).toISOString())) throw new ScheduledNotDueError();
+		const prepared = await prepareContentWrite(db, collection, {
+			id: resolvedId,
+			publish: true,
+			publishedAt: options.publishedAt,
+			expectedRev: encodeRev(snapshot.item)
+		});
+		return {
+			resolvedId,
+			previous: snapshot.item,
+			slugChanged: !!snapshot.item.slug && snapshot.item.slug !== prepared.item.slug,
+			batch: {
+				checks: [...prepared.batch.checks ?? [], snapshot.check],
+				statements: [...prepared.batch.statements]
+			}
+		};
+	}
 	const prepared = await repo.preparePublish(collection, resolvedId, options.publishedAt, options.requireScheduledDue);
 	const statements = [...prepared.batch.statements];
 	const existing = prepared.previous;
@@ -1047,6 +1484,8 @@ async function handleContentPublish(db, collection, id, options = {}) {
 			data: { item }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -1081,6 +1520,10 @@ async function handleContentUnpublish(db, collection, id) {
 	try {
 		const repo = new ContentRepository(db);
 		const resolvedId = await resolveId(repo, collection, id) ?? id;
+		if (getContentStorage(db, collection)) return await commitRoutedContent(db, collection, {
+			id: resolvedId,
+			unpublish: true
+		});
 		const item = await repo.unpublish(collection, resolvedId);
 		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
 		return {
@@ -1088,6 +1531,8 @@ async function handleContentUnpublish(db, collection, id) {
 			data: { item }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -1115,6 +1560,8 @@ async function handleContentCountScheduled(db, collection) {
 			data: { count: await new ContentRepository(db).countScheduled(collection) }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content count scheduled error:", error);
 		return {
 			success: false,
@@ -1139,6 +1586,8 @@ async function handleContentDiscardDraft(db, collection, id) {
 			data: { item }
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof DinewayValidationError) return {
 			success: false,
 			error: {
@@ -1181,6 +1630,8 @@ async function handleContentCompare(db, collection, id) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		console.error("Content compare error:", error);
 		return {
 			success: false,
@@ -1234,6 +1685,8 @@ async function handleContentTranslations(db, collection, id) {
 			}
 		};
 	} catch (error) {
+		const storageError = contentStorageFailure(error);
+		if (storageError) return storageError;
 		if (error instanceof Error) console.error("Content translations error:", error);
 		return {
 			success: false,
@@ -1274,113 +1727,367 @@ function prepareNonTranslatableFields(db, collectionSlug, updatedItemId, transla
 }
 
 //#endregion
-//#region src/site-context/action-hash.ts
-async function buildStableActionHash(value) {
-	return buildStableHash(value);
+//#region src/api/handlers/content-write.ts
+var content_write_exports = /* @__PURE__ */ __exportAll({
+	prepareContentWrite: () => prepareContentWrite,
+	preparedContentReview: () => preparedContentReview
+});
+const fieldData = (data) => Object.fromEntries(Object.entries(data).filter(([key]) => !key.startsWith("_")));
+const reviews = /* @__PURE__ */ new WeakMap();
+function preparedContentReview(write) {
+	const stored = reviews.get(write);
+	if (!stored) throw new DinewayValidationError("Review requires an unmodified prepared content write.");
+	return structuredClone(stored);
 }
-
-//#endregion
-//#region src/site-context/review-payload.ts
-var ReviewPayloadBuilder = class {
-	constructor(handlers) {
-		this.handlers = handlers;
+/** Prepare a draft or direct backing-row edit without committing site-owned writes separately. */
+async function prepareContentWrite(db, collection, input) {
+	return prepareContentWriteInternal(db, collection, input, true);
+}
+async function prepareContentWriteInternal(db, collection, input, syncTranslations) {
+	const configuration = await contentWriteConfiguration(db, collection);
+	const supports = JSON.parse(configuration.row?.supports ?? "[]");
+	const usesRevisions = Array.isArray(supports) && supports.includes("revisions");
+	if (input.seo && configuration.row?.has_seo !== 1) throw new DinewayValidationError("SEO is not enabled for this content type.");
+	if (input.status !== void 0 && input.status !== "draft") throw new DinewayValidationError("Prepared status changes must use publish or unpublish.");
+	if (input.publish && input.unpublish) throw new DinewayValidationError("Publish and unpublish cannot be combined.");
+	const validateData = async (data) => {
+		const fields = await validateContentDataFields(db, collection, fieldData(data));
+		if (fields && !fields.success) throw new DinewayValidationError(fields.error.message);
+		const media = await validateMediaFields(db, collection, fieldData(data));
+		if (!media.success) throw new DinewayValidationError(media.error.message);
+	};
+	if (input.data) await validateData(input.data);
+	const intent = getContentStorage(db, collection) ? await beginContentWriteIntent(db, collection, input, JSON.parse(JSON.stringify(input))) : void 0;
+	const revisionIdentity = intent ? {
+		id: intent.revisionId,
+		createdAt: intent.now
+	} : void 0;
+	const repo = new ContentRepository(db, { prepareIndexWrites: true });
+	const checks = [...configuration.checks];
+	const statements = [];
+	const globalStatements = [];
+	const storageRevisions = [];
+	const translatedWrites = [];
+	let termChanges = input.terms;
+	if (!input.id && input.translationOf && getContentStorage(db, collection)) {
+		const sourceTerms = await snapshotContentTermChanges(db, collection, input.translationOf);
+		checks.push(...sourceTerms.checks);
+		termChanges = {
+			...sourceTerms.changes,
+			...termChanges
+		};
 	}
-	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 appendGlobal = (...items) => {
+		statements.push(...items);
+		globalStatements.push(...items);
+	};
+	let item;
+	let previousItem;
+	let previousSlug = null;
+	let wasPublished = false;
+	let live = null;
+	let draft = null;
+	let now = intent?.now ?? (/* @__PURE__ */ new Date()).toISOString();
+	if (input.id) {
+		const snapshot = await repo.snapshot(collection, input.id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found.");
+		previousItem = snapshot.item;
+		if (input.expectedRev !== void 0 && encodeRev(snapshot.item) !== input.expectedRev) throw new AtomicWriteConflict();
+		previousSlug = snapshot.item.slug;
+		wasPublished = snapshot.item.status === "published";
+		item = {
+			...snapshot.item,
+			updatedAt: now,
+			version: snapshot.item.version + 1,
+			publishedAt: input.publishedAt === void 0 ? snapshot.item.publishedAt : input.publishedAt
+		};
+		checks.push(snapshot.check, ...contentWriteChecks(collection, item.id, "edit"));
+		if (getContentStorage(db, collection)) checks.push(contentPartitionWritable(collection, item.id));
+		for (const [kind, id] of [["live", item.liveRevisionId], ["draft", item.draftRevisionId]]) {
+			if (!id) continue;
+			const revision = await db.selectFrom("revisions").selectAll().where("id", "=", id).executeTakeFirst();
+			if (!revision || revision.collection !== collection || revision.entry_id !== item.id) throw new DinewayValidationError("Content revision is missing or belongs to another entry.");
+			checks.push(rowUnchanged("revisions", revision));
+			if (kind === "live") live = await readRevisionData(db, revision);
+			else draft = await readRevisionData(db, revision);
+		}
+		const stage = input.stageDraft !== false && usesRevisions;
+		const changedDraft = stage && (Object.keys(input.data ?? {}).length > 0 || input.slug !== void 0);
+		if (changedDraft) draft = {
+			...draft ?? item.data,
+			...input.data,
+			...input.slug === void 0 ? {} : { _slug: input.slug }
+		};
+		if (input.draftData) {
+			const previous = draft ?? live ?? item.data;
+			await validateData(Object.fromEntries(Object.entries(input.draftData).filter(([key, value]) => JSON.stringify(previous[key]) !== JSON.stringify(value))));
+			draft = structuredClone(input.draftData);
+		}
+		if (!stage) {
+			item.data = {
+				...item.data,
+				...await repo.normalizePreparedData(collection, fieldData(input.data ?? {}))
+			};
+			for (const [key, value] of Object.entries(item.data)) if (typeof value === "boolean") item.data[key] = Number(value);
+			for (const [key, value] of Object.entries(item.data)) if (value === null || value === void 0) delete item.data[key];
+			if (input.slug !== void 0) item.slug = input.slug;
+		}
+		if (!stage && input.slug && previousSlug && input.slug !== previousSlug) appendGlobal(...new RedirectRepository(db).prepareAutoRedirect(collection, previousSlug, input.slug, item.id, configuration.row?.url_pattern ?? null).statements);
+		if (syncTranslations && !stage && isI18nEnabled() && input.data && item.translationGroup) {
+			const sync = prepareNonTranslatableFields(db, collection, item.id, item.translationGroup, fieldData(input.data), configuration.fields.filter((field) => field.translatable === 0).map((field) => field.slug));
+			if (sync) if (getContentStorage(db, collection)) {
+				const sharedSlugs = new Set(configuration.fields.filter((field) => field.translatable === 0).map((field) => field.slug));
+				const shared = Object.fromEntries(Object.entries(fieldData(input.data)).filter(([field]) => sharedSlugs.has(field)));
+				const siblings = await sql`SELECT id FROM ${sql.table(`ec_${collection}`)} WHERE translation_group = ${item.translationGroup} AND id <> ${item.id} ORDER BY id`.execute(db);
+				checks.push(sql`(SELECT COUNT(*) FROM ${sql.table(`ec_${collection}`)} WHERE translation_group = ${item.translationGroup} AND id <> ${item.id}) = ${siblings.rows.length}`);
+				for (const sibling of siblings.rows) translatedWrites.push(await prepareContentWriteInternal(db, collection, {
+					id: sibling.id,
+					data: shared,
+					stageDraft: false,
+					operationId: intent ? `${intent.operationId}:${sibling.id}` : void 0
+				}, false));
+			} else appendGlobal(sync);
+		}
+		if (input.status !== void 0) item.status = input.status;
+		if (input.authorId !== void 0) item.authorId = input.authorId;
+		statements.push(repo.prepareUpdate(collection, item.id, {
+			data: stage ? void 0 : input.data && fieldData(input.data),
+			slug: stage ? void 0 : input.slug,
+			status: input.status,
+			authorId: input.authorId,
+			publishedAt: input.publishedAt
+		}, now));
+		if (changedDraft || input.draftData || input.unpublish && !draft && live) {
+			draft ??= live;
+			if (draft) {
+				const replace = !!input.reuseDraftRevision && !!item.draftRevisionId && item.draftRevisionId !== item.liveRevisionId;
+				const revision = replace ? {
+					id: item.draftRevisionId,
+					statement: db.updateTable("revisions").set({ data: JSON.stringify(draft) }).where("id", "=", item.draftRevisionId).compile()
+				} : new RevisionRepository(db, { prepareIndexWrites: true }).prepareCreateSnapshot({
+					collection,
+					entryId: item.id,
+					data: sql`${JSON.stringify(draft)}`,
+					authorId: input.authorId ?? void 0
+				}, revisionIdentity);
+				storageRevisions.push({
+					id: revision.id,
+					data: draft,
+					authorId: input.authorId ?? void 0,
+					replace
+				});
+				item.draftRevisionId = revision.id;
+				statements.push(revision.statement, sql`UPDATE ${sql.table(`ec_${collection}`)} SET draft_revision_id=${revision.id} WHERE id=${item.id}`.compile(db));
+			}
+		}
+	} else {
+		if (input.expectedRev !== void 0 || input.unpublish) throw new DinewayValidationError("A new draft cannot reference an existing revision.");
+		const data = fieldData(input.data ?? {});
+		if (input.draftData) await validateData(input.draftData);
+		const slugSource = [data.title, data.name].find((value) => typeof value === "string" && value.length > 0);
+		const slug = input.slug ?? (slugSource ? await repo.generateUniqueSlug(collection, slugSource, input.locale) : void 0);
+		if (slug) checks.push(sql`NOT EXISTS(SELECT 1 FROM ${sql.table(`ec_${collection}`)} WHERE slug=${slug} ${input.locale ? sql`AND locale=${input.locale}` : sql``})`);
+		const created = await repo.prepareCreate({
+			type: collection,
+			data,
+			slug,
+			status: "draft",
+			authorId: input.authorId ?? void 0,
+			locale: input.locale,
+			translationOf: input.translationOf,
+			createdAt: input.createdAt,
+			publishedAt: input.publishedAt
+		}, {
+			captureDefaults: true,
+			id: intent?.entryId,
+			now: intent?.now
 		});
-		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
-				}
+		item = created.item;
+		now = item.updatedAt;
+		checks.push(...created.batch.checks ?? []);
+		statements.push(...created.batch.statements);
+		if (usesRevisions || input.draftData) {
+			draft = structuredClone(input.draftData ?? {
+				...item.data,
+				...Object.fromEntries(Object.entries(input.data ?? {}).filter(([key]) => key.startsWith("_")))
+			});
+			const revision = new RevisionRepository(db, { prepareIndexWrites: true }).prepareCreateSnapshot({
+				collection,
+				entryId: item.id,
+				data: sql`${JSON.stringify(draft)}`,
+				authorId: input.authorId ?? void 0
+			}, revisionIdentity);
+			storageRevisions.push({
+				id: revision.id,
+				data: draft,
+				authorId: input.authorId ?? void 0
+			});
+			item.draftRevisionId = revision.id;
+			statements.push(revision.statement, sql`UPDATE ${sql.table(`ec_${collection}`)} SET draft_revision_id=${revision.id} WHERE id=${item.id}`.compile(db));
+		}
+	}
+	if (input.publish) {
+		const authority = contentWriteChecks(collection, item.id, "publish");
+		if (input.id) checks.push(...authority);
+		else appendGlobal(...prepareAtomicChecks(db, authority));
+		const data = draft ?? live ?? item.data;
+		let revisionId = item.draftRevisionId ?? item.liveRevisionId;
+		if (!revisionId) {
+			const revision = new RevisionRepository(db, { prepareIndexWrites: true }).prepareCreateSnapshot({
+				collection,
+				entryId: item.id,
+				data: sql`${JSON.stringify(data)}`,
+				authorId: input.authorId ?? void 0
+			}, revisionIdentity);
+			revisionId = revision.id;
+			storageRevisions.push({
+				id: revision.id,
+				data,
+				authorId: input.authorId ?? void 0
+			});
+			statements.push(revision.statement);
+		}
+		const sync = repo.prepareSyncDataColumns(collection, item.id, data);
+		if (sync) statements.push(sync);
+		const slug = typeof data._slug === "string" ? data._slug : item.slug;
+		if (wasPublished && previousSlug && slug && previousSlug !== slug) appendGlobal(...new RedirectRepository(db).prepareAutoRedirect(collection, previousSlug, slug, item.id, configuration.row?.url_pattern ?? null).statements);
+		item = {
+			...item,
+			slug,
+			status: "published",
+			liveRevisionId: revisionId,
+			draftRevisionId: null,
+			scheduledAt: null,
+			publishedAt: item.publishedAt ?? now,
+			updatedAt: now,
+			data: {
+				...item.data,
+				...await repo.normalizePreparedData(collection, fieldData(data))
 			}
 		};
+		for (const [key, value] of Object.entries(item.data)) {
+			if (typeof value === "boolean") item.data[key] = Number(value);
+			if (value === null || value === void 0) delete item.data[key];
+		}
+		statements.push(sql`UPDATE ${sql.table(`ec_${collection}`)} SET slug=${slug},status='published',live_revision_id=${revisionId},draft_revision_id=NULL,scheduled_at=NULL,published_at=${item.publishedAt},updated_at=${now} WHERE id=${item.id}`.compile(db));
+		live = data;
+		draft = null;
 	}
-	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
-		};
+	if (input.unpublish) {
+		checks.push(...contentWriteChecks(collection, item.id, "publish"));
+		item.liveRevisionId = null;
+		item.status = "draft";
+		live = null;
+		statements.push(sql`UPDATE ${sql.table(`ec_${collection}`)} SET live_revision_id=NULL,status='draft' WHERE id=${item.id}`.compile(db));
 	}
-	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) ?? {};
+	const metadata = getContentStorage(db, collection) ? await snapshotOwnedContentMetadata(db, collection, item.id) : void 0;
+	if (metadata) checks.push(...metadata.checks);
+	const previousBylines = metadata?.owned.bylines;
+	const previousSeo = metadata && configuration.row?.has_seo === 1 ? storedContentSeo(metadata.owned.seo) : void 0;
+	if (termChanges) {
+		const terms = await prepareContentTerms(db, collection, item.id, termChanges, item.locale ?? "en");
+		checks.push(...terms.checks ?? []);
+		appendGlobal(...terms.statements);
+		if (metadata) metadata.owned.terms = [...metadata.owned.terms.filter((row) => !terms.replaced.includes(row.taxonomy_id)), ...terms.assignments.map((taxonomy_id) => ({
+			collection,
+			entry_id: item.id,
+			taxonomy_id
+		}))].toSorted((a, b) => a.taxonomy_id.localeCompare(b.taxonomy_id));
 	}
-};
-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;
+	if (input.bylines !== void 0) {
+		const bylines = await new BylineRepository(db).prepareContentBylines(collection, item.id, input.bylines, {
+			prefix: intent?.rootVersion,
+			now,
+			primaryIndex: true
+		});
+		checks.push(...bylines.checks ?? []);
+		appendGlobal(...bylines.statements);
+		item.primaryBylineId = bylines.rows[0]?.byline_id ?? null;
+		if (metadata) metadata.owned.bylines = bylines.rows;
+	}
+	if (input.seo) {
+		const seo = new SeoRepository(db, { prepareIndexWrites: true }).prepareUpsert(collection, item.id, input.seo, now);
+		if (seo) {
+			appendGlobal(seo);
+			if (metadata) {
+				const previous = metadata.owned.seo[0];
+				metadata.owned.seo = [{
+					collection,
+					content_id: item.id,
+					seo_title: input.seo.title === void 0 ? previous?.seo_title ?? null : input.seo.title,
+					seo_description: input.seo.description === void 0 ? previous?.seo_description ?? null : input.seo.description,
+					seo_image: input.seo.image === void 0 ? previous?.seo_image ?? null : input.seo.image,
+					seo_canonical: input.seo.canonical === void 0 ? previous?.seo_canonical ?? null : input.seo.canonical,
+					seo_no_index: input.seo.noIndex === void 0 ? previous?.seo_no_index ?? 0 : Number(input.seo.noIndex),
+					created_at: previous?.created_at ?? now,
+					updated_at: now
+				}];
+			}
+		}
+	}
+	const effectContext = syncTranslations ? getRequestContext()?.contentWriteEffects : void 0;
+	const effectTargets = syncTranslations ? effectContext?.targets ?? getContentStorage(db, collection)?.runtime.hookTargets?.([input.publish ? "content:afterPublish" : input.unpublish ? "content:afterUnpublish" : "content:afterSave"]) : void 0;
+	const eventContent = {
+		...item,
+		...effectTargets?.length && metadata ? await contentEventBylines(db, item, metadata.owned.bylines) : {},
+		...metadata && configuration.row?.has_seo === 1 ? { seo: storedContentSeo(metadata.owned.seo) } : {}
+	};
+	const priorEventContent = effectContext?.previousContent ?? (previousItem ? {
+		...previousItem,
+		...effectTargets?.length && previousBylines ? await contentEventBylines(db, previousItem, previousBylines) : {},
+		...previousSeo ? { seo: previousSeo } : {}
+	} : void 0);
+	const ownBatch = await prepareRoutedContentWrite({
+		db,
+		collection,
+		item,
+		create: !input.id,
+		operationId: intent?.operationId,
+		rootVersion: intent?.rootVersion,
+		owned: metadata?.owned,
+		effects: effectTargets?.length ? {
+			targets: effectTargets,
+			snapshot: contentStorageHookSnapshotSchema.parse(JSON.parse(JSON.stringify({
+				collection,
+				id: item.id,
+				isNew: !input.id,
+				permanent: false,
+				content: eventContent,
+				previousContent: priorEventContent
+			})))
+		} : void 0,
+		terms: termChanges,
+		checks,
+		globalStatements,
+		primaryStatements: statements,
+		revisions: storageRevisions,
+		fields: configuration.fields
+	}) ?? {
+		checks,
+		statements
+	};
+	const prepared = {
+		id: item.id,
+		item,
+		rev: encodeRev(item),
+		draftData: draft,
+		batch: {
+			checks: [...ownBatch.checks ?? [], ...translatedWrites.flatMap((write) => write.batch.checks ?? [])],
+			statements: [...ownBatch.statements, ...translatedWrites.flatMap((write) => write.batch.statements)]
+		},
+		afterCommit: () => {
+			invalidateCollectionCache(collection);
+			if (previousSlug !== item.slug) invalidateRedirectCache();
+			for (const write of translatedWrites) write.afterCommit();
+		}
+	};
+	reviews.set(prepared, structuredClone({
+		item,
+		live,
+		draft
+	}));
+	return prepared;
 }
 
 //#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 };
+export { prepareContentProjection as A, handleContentUnschedule as C, encodeRev as D, decodeRev as E, validateRev as O, handleContentUnpublish as S, prepareContentPublication as T, handleContentPermanentDelete as _, handleContentAuthors as a, handleContentSchedule as b, handleContentCountTrashed as c, handleContentDiscardDraft as d, handleContentDuplicate as f, handleContentListTrashed as g, handleContentList as h, contentWriteConfiguration as i, snapshotPartitionDependencies as j, contentProjectionValues as k, handleContentCreate as l, handleContentGetIncludingTrashed as m, prepareContentWrite as n, handleContentCompare as o, handleContentGet as p, preparedContentReview as r, handleContentCountScheduled as s, content_write_exports as t, handleContentDelete as u, handleContentPublish as v, handleContentUpdate as w, handleContentTranslations as x, handleContentRestore as y };