dineway 0.2.40 → 0.2.41

package/dist/{content-CIKsrvU9.mjs → content-BigS8BAv.mjs}

@@ -1,15 +1,179 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { atomicBatch, isD1Database, rowUnchanged } from "./database/batch.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { AtomicWriteConflict, atomicBatch, isD1Database, rowUnchanged } from "./database/batch.mjs";
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
 import { o as isPostgres } from "./dialect-helpers-C6xtO-Ui.mjs";
-import { i as encodeCursor, n as ScheduledNotDueError, r as decodeCursor, t as DinewayValidationError } from "./types-RFzE_V1M.mjs";
-import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
-import { o as invalidateCollectionCache } from "./object-cache-mxCW-Rpt.mjs";
-import { n as slugify } from "./slugify-kD31VIv2.mjs";
-import { t as RevisionRepository } from "./revision-W6FDfDqx.mjs";
+import { n as contentDigest, o as ContentStorageError, t as canonicalContentJson } from "./config-6R0bchVE.mjs";
+import { a as hydrateContentRows, d as contentPartitionWritable, r as getContentStorage } from "./runtime-Ch5G-tnG.mjs";
+import { i as encodeCursor, n as ScheduledNotDueError, r as decodeCursor, t as DinewayValidationError } from "./types-BI3ULB3A.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-Bf5QZboB.mjs";
+import { o as invalidateCollectionCache } from "./object-cache-DyI1SOBK.mjs";
+import { i as storedContentSeo, r as snapshotOwnedContentMetadata, t as contentEventBylines } from "./owned-metadata-BPmUjZqI.mjs";
+import { n as slugify } from "./slugify-DvoaEPtL.mjs";
+import { t as RevisionRepository } from "./revision-B_HYO2AE.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
+import { z } from "zod";
 
+//#region src/content-storage/hook-events.ts
+const contentStorageHookSchema = z.enum([
+	"content:afterSave",
+	"content:afterPublish",
+	"content:afterUnpublish",
+	"content:afterDelete",
+	"content:afterRestore",
+	"content:afterSchedule",
+	"content:afterUnschedule"
+]);
+const contentStorageHookSnapshotSchema = z.object({
+	collection: z.string(),
+	id: z.string(),
+	isNew: z.boolean(),
+	permanent: z.boolean(),
+	content: z.record(z.string(), z.json()),
+	previousContent: z.record(z.string(), z.json()).optional()
+}).strict();
+
+//#endregion
+//#region src/content-storage/outbox.ts
+const eventIdentitySchema = z.object({
+	operationId: z.string().min(1).max(128),
+	routingVersion: z.string().min(1).max(128),
+	collection: z.string().regex(/^[a-z][a-z0-9_]{0,62}$/),
+	entryId: z.string().min(1).max(128)
+});
+const hookTargetSchema = z.object({
+	hook: contentStorageHookSchema,
+	pluginId: z.string().min(1).max(128),
+	timeoutMs: z.number().int().min(1).max(12e4)
+});
+/** Pending snapshots are temporary outbox data, removed only after every subscriber acknowledges. */
+async function prepareContentHookEvents(db, command, snapshot, targets) {
+	if (!targets.length) return { statements: [] };
+	eventIdentitySchema.parse(command);
+	contentStorageHookSnapshotSchema.parse(snapshot);
+	if (snapshot.collection !== command.collection || snapshot.id !== command.entryId) throw new ContentStorageError("CONFLICT", "The content event snapshot does not match its commit.");
+	const subscribers = targets.map((target) => hookTargetSchema.parse(target));
+	if (new Set(subscribers.map((target) => `${target.hook}:${target.pluginId}`)).size !== targets.length) throw new ContentStorageError("INVALID_CONFIG", "Each content hook subscriber must be unique.");
+	const payload = canonicalContentJson(snapshot);
+	if (new TextEncoder().encode(payload).length > 8e6) throw new ContentStorageError("CONFLICT", "The content event exceeds the durable delivery limit; no snapshot was truncated.");
+	const parts = [];
+	for (let offset = 0; offset < payload.length;) {
+		let end = Math.min(payload.length, offset + 1e5);
+		const last = payload.charCodeAt(end - 1);
+		if (end < payload.length && last >= 55296 && last <= 56319) end--;
+		parts.push(payload.slice(offset, end));
+		offset = end;
+	}
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const statements = [sql`INSERT INTO _dineway_content_commit_events (operation_id,collection,entry_id,command,created_at,payload_digest,part_count) VALUES (${command.operationId},${command.collection},${command.entryId},${canonicalContentJson(command)},${now},${await contentDigest(payload)},${parts.length})`.compile(db)];
+	for (const [part, data] of parts.entries()) statements.push(sql`INSERT INTO _dineway_content_event_payloads (operation_id,part,data) VALUES (${command.operationId},${part},${data})`.compile(db));
+	for (const [ordinal, target] of subscribers.entries()) {
+		const id = await contentDigest({
+			operationId: command.operationId,
+			hook: target.hook,
+			pluginId: target.pluginId
+		});
+		statements.push(sql`INSERT INTO _dineway_content_hook_deliveries (id,operation_id,hook,plugin_id,ordinal,timeout_ms,attempts,next_attempt_at,created_at) VALUES (${id},${command.operationId},${target.hook},${target.pluginId},${ordinal},${target.timeoutMs},0,${now},${now})`.compile(db));
+	}
+	return { statements };
+}
+/** Claims are per subscriber; receivers must use the stable key for idempotent side effects. */
+async function drainContentHookEvents(db, deliver, options = {}) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const limit = z.number().int().min(1).max(20).parse(options.limit ?? 5);
+	let completed = 0;
+	let failed = 0;
+	for (let index = 0; index < limit; index++) {
+		const at = now().toISOString();
+		const row = (await sql`SELECT d.* FROM _dineway_content_hook_deliveries d JOIN _dineway_content_commit_events event ON event.operation_id=d.operation_id WHERE d.delivered_at IS NULL AND d.next_attempt_at<=${at} AND (d.lease_until IS NULL OR d.lease_until<${at}) AND NOT EXISTS (SELECT 1 FROM _dineway_content_hook_deliveries prior WHERE prior.operation_id=d.operation_id AND prior.ordinal<d.ordinal AND prior.delivered_at IS NULL) AND NOT EXISTS (SELECT 1 FROM _dineway_content_commit_events earlier WHERE earlier.collection=event.collection AND earlier.entry_id=event.entry_id AND earlier.sequence<event.sequence AND earlier.part_count>0 AND earlier.delivered_at IS NULL) ORDER BY d.next_attempt_at,event.sequence,d.ordinal LIMIT 1`.execute(db)).rows[0];
+		if (!row) break;
+		const owner = ulid();
+		try {
+			await atomicBatch(db, {
+				checks: [rowUnchanged("_dineway_content_hook_deliveries", { ...row })],
+				statements: [sql`UPDATE _dineway_content_hook_deliveries SET lease_owner=${owner},lease_until=${new Date(now().getTime() + Math.max(3e4, row.timeout_ms) + 15e3).toISOString()},attempts=attempts+1 WHERE id=${row.id}`.compile(db)]
+			});
+		} catch (error) {
+			if (error instanceof AtomicWriteConflict) continue;
+			throw error;
+		}
+		try {
+			const header = (await sql`SELECT command,payload_digest,part_count FROM _dineway_content_commit_events WHERE operation_id=${row.operation_id}`.execute(db)).rows[0];
+			if (!header) throw new ContentStorageError("CONFLICT", "The durable content event is missing.");
+			const command = eventIdentitySchema.parse(JSON.parse(header.command));
+			const installed = (await sql`SELECT version FROM _dineway_content_storage_config WHERE id='active'`.execute(db)).rows[0];
+			if (command.routingVersion !== installed?.version) throw new ContentStorageError("ROUTE_CHANGED", "A pending content event targets a different routing version.");
+			const parts = (await sql`SELECT part,data FROM _dineway_content_event_payloads WHERE operation_id=${row.operation_id} ORDER BY part`.execute(db)).rows;
+			const payload = parts.map((part) => part.data).join("");
+			if (parts.length !== header.part_count || parts.some((part, ordinal) => part.part !== ordinal) || await contentDigest(payload) !== header.payload_digest) throw new ContentStorageError("UNAVAILABLE", "The durable content event snapshot could not be verified.");
+			const snapshot = contentStorageHookSnapshotSchema.parse(JSON.parse(payload));
+			if (command.operationId !== row.operation_id || snapshot.id !== command.entryId || snapshot.collection !== command.collection) throw new ContentStorageError("CONFLICT", "The content event snapshot does not match its commit.");
+			await deliver({
+				hook: contentStorageHookSchema.parse(row.hook),
+				pluginId: row.plugin_id,
+				timeoutMs: row.timeout_ms
+			}, {
+				...snapshot,
+				idempotencyKey: row.id
+			});
+			await atomicBatch(db, {
+				checks: [sql`EXISTS (SELECT 1 FROM _dineway_content_hook_deliveries WHERE id=${row.id} AND lease_owner=${owner})`],
+				statements: [
+					sql`UPDATE _dineway_content_hook_deliveries SET delivered_at=${now().toISOString()},lease_owner=NULL,lease_until=NULL,last_error=NULL WHERE id=${row.id}`.compile(db),
+					sql`UPDATE _dineway_content_commit_events SET delivered_at=${now().toISOString()} WHERE operation_id=${row.operation_id} AND NOT EXISTS (SELECT 1 FROM _dineway_content_hook_deliveries WHERE operation_id=${row.operation_id} AND delivered_at IS NULL)`.compile(db),
+					sql`DELETE FROM _dineway_content_event_payloads WHERE operation_id=${row.operation_id} AND EXISTS (SELECT 1 FROM _dineway_content_commit_events WHERE operation_id=${row.operation_id} AND delivered_at IS NOT NULL)`.compile(db)
+				]
+			});
+			completed++;
+		} catch (error) {
+			await sql`UPDATE _dineway_content_hook_deliveries SET lease_owner=NULL,lease_until=NULL,next_attempt_at=${new Date(now().getTime() + Math.min(36e5, 1e3 * 2 ** Math.min(row.attempts, 12))).toISOString()},last_error=${error instanceof ContentStorageError ? error.code : "DELIVERY_FAILED"} WHERE id=${row.id} AND lease_owner=${owner}`.execute(db);
+			failed++;
+		}
+	}
+	return {
+		completed,
+		failed
+	};
+}
+
+//#endregion
+//#region src/content-storage/lifecycle-events.ts
+/** Visibility-only changes stay on primary and commit their exact event snapshot atomically. */
+async function prepareContentLifecycleEvents(db, previous, hook, current, permanent = false) {
+	const storage = getContentStorage(db, previous.type);
+	if (!storage) return { statements: [] };
+	const targets = storage.runtime.hookTargets?.([hook]) ?? [];
+	const metadata = targets.length ? await snapshotOwnedContentMetadata(db, previous.type, previous.id) : void 0;
+	const enrich = async (item) => ({
+		...item,
+		...metadata ? {
+			seo: storedContentSeo(metadata.owned.seo),
+			...await contentEventBylines(db, item, metadata.owned.bylines)
+		} : {}
+	});
+	return {
+		...await prepareContentHookEvents(db, {
+			operationId: ulid(),
+			routingVersion: storage.runtime.config.version,
+			collection: previous.type,
+			entryId: previous.id
+		}, contentStorageHookSnapshotSchema.parse(JSON.parse(JSON.stringify({
+			collection: previous.type,
+			id: previous.id,
+			isNew: false,
+			permanent,
+			content: current ? await enrich(current) : {},
+			previousContent: await enrich(previous)
+		}))), targets),
+		checks: [
+			...metadata?.checks ?? [],
+			contentPartitionWritable(previous.type, previous.id),
+			sql`EXISTS (SELECT 1 FROM _dineway_content_storage_config WHERE id='active' AND version=${storage.runtime.config.version})`
+		]
+	};
+}
+
+//#endregion
 //#region src/database/repositories/content.ts
 var content_exports = /* @__PURE__ */ __exportAll({ ContentRepository: () => ContentRepository });
 const ULID_PATTERN = /^[0-9A-Z]{26}$/;
@@ -99,9 +263,16 @@ function escapeRegExp(s) {
 * Content is stored in per-collection tables (ec_posts, ec_pages, etc.)
 * Each field becomes a real column in the table.
 */
-var ContentRepository = class {
-	constructor(db) {
+var ContentRepository = class ContentRepository {
+	constructor(db, options = {}) {
 		this.db = db;
+		this.options = options;
+	}
+	assertIndexWrite(type) {
+		if (!this.options.prepareIndexWrites && getContentStorage(this.db, type)) throw new DinewayValidationError("Use Dineway content commands or prepareContentWrite for partitioned content writes.");
+	}
+	writeChecks(type, id, action) {
+		return [...contentWriteChecks(type, id, action), ...getContentStorage(this.db, type) ? [contentPartitionWritable(type, id)] : []];
 	}
 	async normalizePreparedData(type, data) {
 		if (isPostgres(this.db)) return data;
@@ -115,8 +286,9 @@ var ContentRepository = class {
 	* Create a new content item
 	*/
 	async prepareCreate(input, options = {}) {
-		const id = ulid();
-		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.assertIndexWrite(input.type);
+		const id = options.id ?? ulid();
+		const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
 		const { type, slug, data, status = "draft", authorId, primaryBylineId, locale, translationOf, publishedAt, createdAt } = input;
 		if (!type) throw new DinewayValidationError("Content type is required");
 		const tableName = getTableName(type);
@@ -203,6 +375,7 @@ var ContentRepository = class {
 	}
 	/** Capture database defaults and JSON values from the saved row inside the write batch. */
 	async prepareDraftSnapshot(type, id, authorId) {
+		this.assertIndexWrite(type);
 		const tableName = getTableName(type);
 		const checks = [];
 		let snapshot;
@@ -291,6 +464,7 @@ var ContentRepository = class {
 	* A slug is auto-generated from the new title by the handler layer.
 	*/
 	async prepareDuplicate(type, id, authorId) {
+		this.assertIndexWrite(type);
 		const snapshot = await this.snapshot(type, id);
 		if (!snapshot) throw new DinewayValidationError("Content item not found");
 		const original = snapshot.item;
@@ -312,7 +486,7 @@ var ContentRepository = class {
 			batch: {
 				checks: [
 					snapshot.check,
-					...contentWriteChecks(type, id, "edit"),
+					...this.writeChecks(type, id, "edit"),
 					...prepared.batch.checks ?? []
 				],
 				statements: prepared.batch.statements
@@ -338,6 +512,7 @@ var ContentRepository = class {
 			AND deleted_at IS NULL
 		`.execute(this.db)).rows[0];
 		if (!row) return null;
+		await hydrateContentRows(this.db, type, [row]);
 		return this.mapRow(type, row);
 	}
 	/**
@@ -351,6 +526,7 @@ var ContentRepository = class {
 			WHERE id = ${id}
 		`.execute(this.db)).rows[0];
 		if (!row) return null;
+		await hydrateContentRows(this.db, type, [row]);
 		return this.mapRow(type, row);
 	}
 	/**
@@ -398,6 +574,7 @@ var ContentRepository = class {
 					LIMIT 1
 				`.execute(this.db)).rows[0];
 		if (!row) return null;
+		await hydrateContentRows(this.db, type, [row]);
 		return this.mapRow(type, row);
 	}
 	/**
@@ -417,6 +594,7 @@ var ContentRepository = class {
 					LIMIT 1
 				`.execute(this.db)).rows[0];
 		if (!row) return null;
+		await hydrateContentRows(this.db, type, [row]);
 		return this.mapRow(type, row);
 	}
 	/**
@@ -447,6 +625,7 @@ var ContentRepository = class {
 		const [rows, total] = await Promise.all([query.execute(), this.count(type, options.where)]);
 		const hasMore = rows.length > limit;
 		const items = rows.slice(0, limit);
+		await hydrateContentRows(this.db, type, items);
 		const mappedResult = {
 			items: items.map((row) => this.mapRow(type, row)),
 			total
@@ -462,6 +641,7 @@ var ContentRepository = class {
 	* Update content
 	*/
 	prepareUpdate(type, id, input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+		this.assertIndexWrite(type);
 		const tableName = getTableName(type);
 		const updates = {
 			updated_at: now,
@@ -483,15 +663,18 @@ var ContentRepository = class {
 	}
 	async snapshot(type, id, includeTrashed = false) {
 		const row = (await sql`SELECT * FROM ${sql.table(getTableName(type))} WHERE id = ${id} AND ${includeTrashed ? sql`true` : sql`deleted_at IS NULL`}`.execute(this.db)).rows[0];
-		return row ? {
+		if (!row) return null;
+		const check = rowUnchanged(getTableName(type), row);
+		await hydrateContentRows(this.db, type, [row]);
+		return {
 			item: this.mapRow(type, row),
 			deleted: row.deleted_at !== null,
-			check: rowUnchanged(getTableName(type), row)
-		} : null;
+			check
+		};
 	}
 	async update(type, id, input) {
 		await atomicBatch(this.db, {
-			checks: contentWriteChecks(type, id, "edit"),
+			checks: this.writeChecks(type, id, "edit"),
 			statements: [this.prepareUpdate(type, id, input)]
 		});
 		invalidateCollectionCache(type);
@@ -503,10 +686,11 @@ var ContentRepository = class {
 	* Delete content (soft delete - moves to trash)
 	*/
 	prepareDelete(type, id) {
+		this.assertIndexWrite(type);
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		return {
-			checks: contentWriteChecks(type, id, "delete"),
+			checks: this.writeChecks(type, id, "delete"),
 			statements: [sql`
 			UPDATE ${sql.ref(tableName)}
 			SET deleted_at = ${now}
@@ -516,47 +700,90 @@ var ContentRepository = class {
 		};
 	}
 	async delete(type, id) {
-		const [result] = await atomicBatch(this.db, this.prepareDelete(type, id));
+		const [result] = await atomicBatch(this.db, await this.prepareSoftDelete(type, id));
 		const changed = (result?.numAffectedRows ?? 0n) > 0n;
 		if (changed) invalidateCollectionCache(type);
 		return changed;
 	}
+	/** Compose a routed soft delete with primary business writes without dropping its event. */
+	async prepareSoftDelete(type, id) {
+		if (!getContentStorage(this.db, type)) return this.prepareDelete(type, id);
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) return { statements: [] };
+		const effects = await prepareContentLifecycleEvents(this.db, snapshot.item, "content:afterDelete", null);
+		const write = new ContentRepository(this.db, { prepareIndexWrites: true }).prepareDelete(type, id);
+		return {
+			checks: [
+				snapshot.check,
+				...write.checks ?? [],
+				...effects.checks ?? []
+			],
+			statements: [...write.statements, ...effects.statements]
+		};
+	}
 	/**
 	* Restore content from trash
 	*/
 	async restore(type, id) {
 		const tableName = getTableName(type);
+		const snapshot = getContentStorage(this.db, type) ? await this.snapshot(type, id, true) : null;
+		if (getContentStorage(this.db, type) && !snapshot?.deleted) return null;
+		const effects = snapshot ? await prepareContentLifecycleEvents(this.db, snapshot.item, "content:afterRestore", snapshot.item) : {
+			checks: [],
+			statements: []
+		};
 		const [result] = await atomicBatch(this.db, {
-			checks: contentWriteChecks(type, id, "edit"),
+			checks: [
+				...this.writeChecks(type, id, "edit"),
+				...effects.checks ?? [],
+				...snapshot ? [snapshot.check] : []
+			],
 			statements: [sql`
 			UPDATE ${sql.ref(tableName)}
 			SET deleted_at = NULL
 			WHERE id = ${id}
 			AND deleted_at IS NOT NULL
 			RETURNING *
-		`.compile(this.db)]
+		`.compile(this.db), ...effects.statements]
 		});
 		const restored = result?.rows[0];
 		if (!restored) return null;
 		invalidateCollectionCache(type);
+		await hydrateContentRows(this.db, type, [restored]);
 		return this.mapRow(type, restored);
 	}
 	/**
 	* Permanently delete a soft-deleted content row.
 	*/
 	async permanentDelete(type, id) {
+		const batch = await this.preparePermanentDelete(type, id);
+		if (!batch) return false;
+		await atomicBatch(this.db, batch);
+		invalidateCollectionCache(type);
+		return true;
+	}
+	async preparePermanentDelete(type, id) {
 		const tableName = getTableName(type);
-		const [result] = await atomicBatch(this.db, {
-			checks: contentWriteChecks(type, id, "permanent"),
-			statements: [sql`
-			DELETE FROM ${sql.ref(tableName)}
-			WHERE id = ${id}
-			AND deleted_at IS NOT NULL
-		`.compile(this.db)]
-		});
-		const changed = (result?.numAffectedRows ?? 0n) > 0n;
-		if (changed) invalidateCollectionCache(type);
-		return changed;
+		const snapshot = await this.snapshot(type, id, true);
+		if (!snapshot?.deleted) return null;
+		const effects = await prepareContentLifecycleEvents(this.db, snapshot.item, "content:afterDelete", null, true);
+		return {
+			checks: [
+				...this.writeChecks(type, id, "permanent"),
+				snapshot.check,
+				...effects.checks ?? []
+			],
+			statements: [
+				sql`DELETE FROM ${sql.table(tableName)} WHERE id=${id} AND deleted_at IS NOT NULL`.compile(this.db),
+				this.db.deleteFrom("_dineway_seo").where("collection", "=", type).where("content_id", "=", id).compile(),
+				this.db.deleteFrom("content_taxonomies").where("collection", "=", type).where("entry_id", "=", id).compile(),
+				this.db.deleteFrom("_dineway_comments").where("collection", "=", type).where("content_id", "=", id).compile(),
+				this.db.deleteFrom("revisions").where("collection", "=", type).where("entry_id", "=", id).compile(),
+				this.db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", type).where("content_id", "=", id).compile(),
+				...getContentStorage(this.db, type) ? [sql`DELETE FROM _dineway_content_locations WHERE collection=${type} AND entry_id=${id}`.compile(this.db)] : [],
+				...effects.statements
+			]
+		};
 	}
 	/**
 	* Find trashed content items
@@ -581,6 +808,7 @@ var ContentRepository = class {
 		const rows = await query.execute();
 		const hasMore = rows.length > limit;
 		const items = rows.slice(0, limit);
+		await hydrateContentRows(this.db, type, items);
 		const mappedResult = { items: items.map((row) => {
 			const record = row;
 			return {
@@ -677,9 +905,20 @@ var ContentRepository = class {
 		if (scheduledDate <= /* @__PURE__ */ new Date()) throw new DinewayValidationError("Scheduled date must be in the future");
 		const snapshot = await this.snapshot(type, id);
 		if (!snapshot) throw new DinewayValidationError("Content item not found");
-		const newStatus = snapshot.item.status === "published" ? "published" : "scheduled";
+		const existing = snapshot.item;
+		const newStatus = existing.status === "published" ? "published" : "scheduled";
+		const effects = await prepareContentLifecycleEvents(this.db, existing, "content:afterSchedule", {
+			...existing,
+			status: newStatus,
+			scheduledAt,
+			updatedAt: now
+		});
 		await atomicBatch(this.db, {
-			checks: [snapshot.check, ...contentWriteChecks(type, id, "publish")],
+			checks: [
+				snapshot.check,
+				...this.writeChecks(type, id, "publish"),
+				...effects.checks ?? []
+			],
 			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET status = ${newStatus},
@@ -687,7 +926,7 @@ var ContentRepository = class {
 				updated_at = ${now}
 			WHERE id = ${id}
 				AND deleted_at IS NULL
-			`.compile(this.db)]
+			`.compile(this.db), ...effects.statements]
 		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
@@ -705,9 +944,21 @@ var ContentRepository = class {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const snapshot = await this.snapshot(type, id);
 		if (!snapshot) throw new DinewayValidationError("Content item not found");
-		const newStatus = snapshot.item.status === "published" ? "published" : "draft";
+		const existing = snapshot.item;
+		const newStatus = existing.status === "published" ? "published" : "draft";
+		if (getContentStorage(this.db, type) && existing.scheduledAt === null) return existing;
+		const effects = await prepareContentLifecycleEvents(this.db, existing, "content:afterUnschedule", {
+			...existing,
+			status: newStatus,
+			scheduledAt: null,
+			updatedAt: now
+		});
 		await atomicBatch(this.db, {
-			checks: [snapshot.check, ...contentWriteChecks(type, id, "publish")],
+			checks: [
+				snapshot.check,
+				...this.writeChecks(type, id, "publish"),
+				...effects.checks ?? []
+			],
 			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET status = ${newStatus},
@@ -716,7 +967,7 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND scheduled_at IS NOT NULL
 				AND deleted_at IS NULL
-			`.compile(this.db)]
+			`.compile(this.db), ...effects.statements]
 		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
@@ -734,26 +985,30 @@ var ContentRepository = class {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const limitClause = typeof limit === "number" && Number.isInteger(limit) && limit > 0 ? sql`LIMIT ${limit}` : sql``;
-		return (await sql`
+		const result = await sql`
 			SELECT * FROM ${sql.ref(tableName)}
 			WHERE scheduled_at IS NOT NULL
 			AND scheduled_at <= ${now}
 			AND deleted_at IS NULL
 			ORDER BY scheduled_at ASC
 			${limitClause}
-		`.execute(this.db)).rows.map((row) => this.mapRow(type, row));
+		`.execute(this.db);
+		await hydrateContentRows(this.db, type, result.rows);
+		return result.rows.map((row) => this.mapRow(type, row));
 	}
 	/**
 	* Find all translations in a translation group
 	*/
 	async findTranslations(type, translationGroup) {
 		const tableName = getTableName(type);
-		return (await sql`
+		const result = await sql`
 			SELECT * FROM ${sql.ref(tableName)}
 			WHERE translation_group = ${translationGroup}
 			AND deleted_at IS NULL
 			ORDER BY locale ASC
-		`.execute(this.db)).rows.map((row) => this.mapRow(type, row));
+		`.execute(this.db);
+		await hydrateContentRows(this.db, type, result.rows);
+		return result.rows.map((row) => this.mapRow(type, row));
 	}
 	/**
 	* Publish the current draft
@@ -767,6 +1022,7 @@ var ContentRepository = class {
 	* `published_at` is preserved and first publish falls back to the current time.
 	*/
 	async preparePublish(type, id, publishedAt, requireScheduledDue = false) {
+		this.assertIndexWrite(type);
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const snapshot = await this.snapshot(type, id);
@@ -833,7 +1089,7 @@ var ContentRepository = class {
 			checks: [
 				snapshot.check,
 				rowUnchanged("revisions", revision),
-				...contentWriteChecks(type, id, "edit")
+				...this.writeChecks(type, id, "edit")
 			],
 			statements: [sql`UPDATE ${sql.table(tableName)} SET draft_revision_id = ${revisionId}, updated_at = ${(/* @__PURE__ */ new Date()).toISOString()} WHERE id = ${id} AND deleted_at IS NULL`.compile(this.db)]
 		});
@@ -850,7 +1106,7 @@ var ContentRepository = class {
 		const snapshot = await this.snapshot(type, id);
 		if (!snapshot) throw new DinewayValidationError("Content item not found");
 		const existing = snapshot.item;
-		const checks = [snapshot.check, ...contentWriteChecks(type, id, "publish")];
+		const checks = [snapshot.check, ...this.writeChecks(type, id, "publish")];
 		const statements = [];
 		let draftId = existing.draftRevisionId;
 		if (!draftId && existing.liveRevisionId) {
@@ -891,7 +1147,7 @@ var ContentRepository = class {
 		const existing = snapshot.item;
 		if (!existing.draftRevisionId) return existing;
 		await atomicBatch(this.db, {
-			checks: [snapshot.check, ...contentWriteChecks(type, id, "edit")],
+			checks: [snapshot.check, ...this.writeChecks(type, id, "edit")],
 			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET draft_revision_id = NULL,
@@ -911,6 +1167,7 @@ var ContentRepository = class {
 	* Keys starting with _ are revision metadata (e.g. _slug) and are skipped.
 	*/
 	prepareSyncDataColumns(type, id, data) {
+		this.assertIndexWrite(type);
 		const tableName = getTableName(type);
 		const updates = {};
 		for (const [key, value] of Object.entries(data)) {
@@ -986,4 +1243,4 @@ var ContentRepository = class {
 };
 
 //#endregion
-export { content_exports as n, ContentRepository as t };
+export { prepareContentHookEvents as a, drainContentHookEvents as i, content_exports as n, contentStorageHookSchema as o, prepareContentLifecycleEvents as r, contentStorageHookSnapshotSchema as s, ContentRepository as t };