dineway 0.2.39 → 0.2.41

package/dist/cron-C7HCJPPl.mjs

@@ -1,271 +0,0 @@
-import { sql } from "kysely";
-import { ulid } from "ulidx";
-import { Cron } from "croner";
-
-//#region src/plugins/cron.ts
-/**
-* Plugin Cron System
-*
-* Provides scheduled task execution for plugins:
-* - CronExecutor: claims overdue tasks, invokes per-plugin cron hook, updates next run.
-* - CronAccessImpl: per-plugin API for schedule/cancel/list.
-*
-*/
-/** Stale lock threshold in minutes */
-const STALE_LOCK_MINUTES = 10;
-const MAX_ONESHOT_RETRIES = 5;
-/**
-* Executes overdue cron tasks.
-*
-* Called by schedulers (NodeCronScheduler, PiggybackScheduler). Stateless —
-* all state lives in the database.
-*/
-var CronExecutor = class {
-	resolveDb;
-	constructor(db, invokeCronHook) {
-		this.invokeCronHook = invokeCronHook;
-		this.resolveDb = typeof db === "function" ? db : () => db;
-	}
-	get db() {
-		return this.resolveDb();
-	}
-	/**
-	* Process all overdue tasks.
-	*
-	* 1. Atomically claim tasks whose next_run_at <= now, status = idle, enabled = 1.
-	* 2. For each claimed task, invoke the plugin's cron hook.
-	* 3. On success: compute next_run_at and reset to idle, or delete one-shots.
-	* 4. On failure: reset to idle (retry on next tick).
-	*/
-	async tick() {
-		let processed = 0;
-		for (let index = 0; index < 10; index++) {
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const lease = ulid();
-			const task = (await sql`
-			UPDATE _dineway_cron_tasks
-			SET status = 'running', locked_at = ${now}, lease_token = ${lease}
-			WHERE status = 'idle' AND enabled = 1 AND next_run_at <= ${now} AND id IN (
-				SELECT id FROM _dineway_cron_tasks
-				WHERE next_run_at <= ${now}
-				  AND status = 'idle'
-				  AND enabled = 1
-				ORDER BY next_run_at ASC
-				LIMIT 1
-			)
-			RETURNING id, plugin_id, task_name, schedule, is_oneshot, data, next_run_at
-		`.execute(this.db)).rows[0];
-			if (!task) break;
-			const ownedOccurrence = sql`id = ${task.id} AND status = 'running' AND enabled = 1 AND lease_token = ${lease}
- AND schedule = ${task.schedule} AND next_run_at = ${task.next_run_at} AND data IS NOT DISTINCT FROM ${task.data}`;
-			let parsedData;
-			if (task.data) try {
-				parsedData = JSON.parse(task.data);
-			} catch {
-				console.error(`[cron] Invalid JSON data for ${task.plugin_id}:${task.task_name}, skipping`);
-				await sql`
-						UPDATE _dineway_cron_tasks
-						SET status = 'failed', enabled = 0, locked_at = NULL, lease_token = NULL
-						WHERE ${ownedOccurrence}
-					`.execute(this.db);
-				continue;
-			}
-			const event = {
-				executionId: `${task.id}:${task.is_oneshot ? task.schedule : task.next_run_at}`,
-				name: task.task_name,
-				data: parsedData,
-				scheduledAt: task.next_run_at
-			};
-			let hookFailed = false;
-			try {
-				await this.invokeCronHook(task.plugin_id, event);
-			} catch (error) {
-				hookFailed = true;
-				console.error(`[cron] Hook failed for ${task.plugin_id}:${task.task_name}:`, error);
-			}
-			if (task.is_oneshot) if (hookFailed) {
-				const retryMeta = parsedData?.__dineway != null && typeof parsedData.__dineway === "object" ? parsedData.__dineway : void 0;
-				const rawRetryCount = retryMeta?.retryCount;
-				const retryCount = typeof rawRetryCount === "number" && Number.isFinite(rawRetryCount) && rawRetryCount > 0 ? Math.floor(rawRetryCount) : 0;
-				if (retryCount >= MAX_ONESHOT_RETRIES) {
-					console.error(`[cron] One-shot task ${task.plugin_id}:${task.task_name} exceeded ${MAX_ONESHOT_RETRIES} retries, retaining failed task`);
-					await sql`
-							UPDATE _dineway_cron_tasks SET status = 'failed', enabled = 0, locked_at = NULL, lease_token = NULL WHERE ${ownedOccurrence}
-						`.execute(this.db);
-				} else {
-					const backoffMs = 6e4 * Math.pow(2, retryCount);
-					await sql`
-						UPDATE _dineway_cron_tasks
-						SET status = 'idle', locked_at = NULL, lease_token = NULL, next_run_at = ${new Date(Date.now() + backoffMs).toISOString()}, data = ${JSON.stringify({
-						...parsedData,
-						__dineway: {
-							...retryMeta,
-							retryCount: retryCount + 1
-						}
-					})}
-						WHERE ${ownedOccurrence}
-					`.execute(this.db);
-				}
-			} else await sql`
-						DELETE FROM _dineway_cron_tasks WHERE ${ownedOccurrence}
-					`.execute(this.db);
-			else await sql`
-					UPDATE _dineway_cron_tasks
-					SET status = 'idle',
-						locked_at = NULL, lease_token = NULL,
-						last_run_at = ${now},
-						next_run_at = ${nextCronTime(task.schedule)}
-					WHERE ${ownedOccurrence}
-				`.execute(this.db);
-			await sql`UPDATE _dineway_cron_tasks SET status = 'idle', locked_at = NULL, lease_token = NULL
- WHERE id = ${task.id} AND status = 'running' AND lease_token = ${lease}`.execute(this.db);
-			processed++;
-		}
-		return processed;
-	}
-	/**
-	* Recover tasks stuck in 'running' for more than STALE_LOCK_MINUTES.
-	* These likely crashed mid-execution.
-	*/
-	async recoverStaleLocks() {
-		const result = await sql`
-			UPDATE _dineway_cron_tasks
-			SET status = 'idle', locked_at = NULL, lease_token = NULL
-			WHERE status = 'running'
-			  AND locked_at < ${(/* @__PURE__ */ new Date(Date.now() - STALE_LOCK_MINUTES * 60 * 1e3)).toISOString()}
-		`.execute(this.db);
-		return Number(result.numAffectedRows ?? 0);
-	}
-	/**
-	* Get the next due time across all enabled tasks.
-	* Returns null if no tasks are scheduled.
-	*/
-	async getNextDueTime() {
-		return (await sql`
-			SELECT MIN(next_run_at) as next
-			FROM _dineway_cron_tasks
-			WHERE status = 'idle' AND enabled = 1
-		`.execute(this.db)).rows[0]?.next ?? null;
-	}
-};
-/**
-* Per-plugin cron API implementation.
-* Scoped to a single plugin ID — plugins cannot see or modify other plugins' tasks.
-*/
-var CronAccessImpl = class {
-	constructor(db, pluginId, reschedule) {
-		this.db = db;
-		this.pluginId = pluginId;
-		this.reschedule = reschedule;
-	}
-	async schedule(name, opts) {
-		validateTaskName(name);
-		validateSchedule(opts.schedule);
-		const oneshot = isOneShot(opts.schedule);
-		const schedule = oneshot ? new Date(opts.schedule).toISOString() : opts.schedule;
-		const nextRun = oneshot ? schedule : nextCronTime(schedule);
-		const dataJson = opts.data ? JSON.stringify(opts.data) : null;
-		await sql`
-			INSERT INTO _dineway_cron_tasks (id, plugin_id, task_name, schedule, is_oneshot, data, next_run_at, status, enabled)
-			VALUES (${ulid()}, ${this.pluginId}, ${name}, ${schedule}, ${oneshot ? 1 : 0}, ${dataJson}, ${nextRun}, 'idle', 1)
-			ON CONFLICT (plugin_id, task_name) DO UPDATE SET
-				schedule = ${schedule},
-				is_oneshot = ${oneshot ? 1 : 0},
-				data = ${dataJson},
-				next_run_at = ${nextRun},
-				status = CASE WHEN _dineway_cron_tasks.status = 'running' THEN 'running' ELSE 'idle' END,
-				locked_at = CASE WHEN _dineway_cron_tasks.status = 'running' THEN _dineway_cron_tasks.locked_at ELSE NULL END,
- lease_token = CASE WHEN _dineway_cron_tasks.status = 'running' THEN _dineway_cron_tasks.lease_token ELSE NULL END,
-				enabled = 1
-		`.execute(this.db);
-		this.reschedule();
-	}
-	async cancel(name) {
-		await sql`
-			DELETE FROM _dineway_cron_tasks
-			WHERE plugin_id = ${this.pluginId} AND task_name = ${name}
-		`.execute(this.db);
-		this.reschedule();
-	}
-	async list() {
-		return (await sql`
-			SELECT task_name, schedule, next_run_at, last_run_at, status
-			FROM _dineway_cron_tasks
-			WHERE plugin_id = ${this.pluginId} AND (enabled = 1 OR status = 'failed')
-			ORDER BY next_run_at ASC
-		`.execute(this.db)).rows.map((row) => ({
-			name: row.task_name,
-			status: row.status,
-			schedule: row.schedule,
-			nextRunAt: row.next_run_at,
-			lastRunAt: row.last_run_at
-		}));
-	}
-};
-/**
-* Enable or disable all cron tasks for a plugin.
-* Called by admin disable/enable endpoints and PluginManager lifecycle.
-* Gracefully handles the cron table not existing yet (pre-migration).
-*/
-async function setCronTasksEnabled(db, pluginId, enabled) {
-	try {
-		await sql`
-			UPDATE _dineway_cron_tasks
-			SET enabled = ${enabled ? 1 : 0}
-			WHERE plugin_id = ${pluginId}
-		`.execute(db);
-	} catch {}
-}
-/**
-* Compute the next fire time for a cron expression.
-* Supports standard cron (5-field), extended (6-field with seconds), and
-* aliases like @daily, @weekly, @hourly, @monthly, @yearly.
-*/
-function nextCronTime(expression) {
-	const next = new Cron(expression).nextRun();
-	if (!next) throw new Error(`Invalid cron expression or no future run: "${expression}"`);
-	return next.toISOString();
-}
-/**
-* Check whether a string is a valid cron expression.
-*/
-function isCronExpression(schedule) {
-	try {
-		new Cron(schedule);
-		return true;
-	} catch {
-		return false;
-	}
-}
-const ISO_DATETIME = /^\d{4}-\d{2}-\d{2}T/;
-/** Croner accepts ISO timestamps too; distinguish those before testing cron patterns. */
-function isOneShot(schedule) {
-	if (ISO_DATETIME.test(schedule)) return !isNaN(Date.parse(schedule));
-	if (schedule.startsWith("@") || isCronExpression(schedule)) return false;
-	return !isNaN(Date.parse(schedule));
-}
-/** Max length for a task name */
-const MAX_TASK_NAME_LENGTH = 128;
-/** Task name pattern: alphanumeric, dashes, underscores */
-const TASK_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-/**
-* Validate a cron task name.
-* Must be non-empty, ≤128 chars, alphanumeric with dashes/underscores.
-*/
-function validateTaskName(name) {
-	if (!name || name.length > MAX_TASK_NAME_LENGTH) throw new Error(`Invalid task name: must be 1-${MAX_TASK_NAME_LENGTH} characters, got ${name.length}`);
-	if (!TASK_NAME_RE.test(name)) throw new Error(`Invalid task name "${name}": must start with a letter and contain only letters, numbers, dashes, or underscores`);
-}
-/**
-* Validate a schedule string at registration time.
-* Must be a valid cron expression or a parseable ISO 8601 datetime.
-*/
-function validateSchedule(schedule) {
-	if (!schedule || schedule.length > 256) throw new Error(`Invalid schedule: must be 1-256 characters, got ${schedule.length}`);
-	if (isCronExpression(schedule)) return;
-	const parsed = Date.parse(schedule);
-	if (isNaN(parsed)) throw new Error(`Invalid schedule "${schedule}": must be a valid cron expression or ISO 8601 datetime`);
-}
-
-//#endregion
-export { CronExecutor as n, setCronTasksEnabled as r, CronAccessImpl as t };

package/dist/schema-CosVhHJt.mjs

@@ -1,8 +0,0 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { n as SchemaRegistry } from "./registry-Dclv9iHv.mjs";
-
-//#region src/schema/index.ts
-var schema_exports = /* @__PURE__ */ __exportAll({ SchemaRegistry: () => SchemaRegistry });
-
-//#endregion
-export { schema_exports as t };

package/dist/submission-DJmRejGR.mjs

@@ -1,411 +0,0 @@
-import { AtomicWriteConflict, atomicBatch, prepareAtomicChecks, rowUnchanged } from "./database/batch.mjs";
-import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
-import { 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 { t as RevisionRepository } from "./revision-W6FDfDqx.mjs";
-import { t as ContentRepository } from "./content-CIKsrvU9.mjs";
-import { t as buildStableHash } from "./stable-hash-B9Tbb2f_.mjs";
-import { i as isSupersededReview, r as ReviewRequestRepository, t as REVIEW_SUPERSESSION_ACTOR } from "./review-requests-CUVn0RBl.mjs";
-import { t as RedirectRepository } from "./redirect-BQFa1THe.mjs";
-import { i as invalidateRedirectCache } from "./cache-B5NSHhxG.mjs";
-import { D as validateMediaFields, E as validateContentDataFields, T as prepareNonTranslatableFields, k as encodeRev, r as contentWriteConfiguration, t as ReviewPayloadBuilder } from "./review-payload-Bap86e75.mjs";
-import { i as reviewDraft } from "./evidence-Vnp_fQbC.mjs";
-import { sql } from "kysely";
-import { z } from "zod";
-
-//#region src/api/handlers/content-write.ts
-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);
-}
-/** Prepare a draft or direct backing-row edit without committing site-owned writes separately. */
-async function prepareContentWrite(db, collection, input) {
-	const configuration = await contentWriteConfiguration(db, collection);
-	const supports = JSON.parse(configuration.row?.supports ?? "[]");
-	const usesRevisions = Array.isArray(supports) && supports.includes("revisions");
-	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 repo = new ContentRepository(db);
-	const checks = [...configuration.checks];
-	const statements = [];
-	let item;
-	let previousSlug = null;
-	let wasPublished = false;
-	let live = null;
-	let draft = null;
-	let 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.");
-		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
-		};
-		checks.push(snapshot.check, ...contentWriteChecks(collection, item.id, "edit"));
-		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 = JSON.parse(revision.data);
-			else draft = JSON.parse(revision.data);
-		}
-		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) statements.push(...new RedirectRepository(db).prepareAutoRedirect(collection, previousSlug, input.slug, item.id, configuration.row?.url_pattern ?? null).statements);
-		if (!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) statements.push(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
-		}, now));
-		if (changedDraft || input.draftData || input.unpublish && !draft && live) {
-			draft ??= live;
-			if (draft) {
-				const revision = new RevisionRepository(db).prepareCreateSnapshot({
-					collection,
-					entryId: item.id,
-					data: sql`${JSON.stringify(draft)}`,
-					authorId: input.authorId
-				});
-				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,
-			locale: input.locale
-		}, { captureDefaults: true });
-		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).prepareCreateSnapshot({
-				collection,
-				entryId: item.id,
-				data: sql`${JSON.stringify(draft)}`,
-				authorId: input.authorId
-			});
-			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 statements.push(...prepareAtomicChecks(db, authority));
-		const data = draft ?? live ?? item.data;
-		let revisionId = item.draftRevisionId ?? item.liveRevisionId;
-		if (!revisionId) {
-			const revision = new RevisionRepository(db).prepareCreateSnapshot({
-				collection,
-				entryId: item.id,
-				data: sql`${JSON.stringify(data)}`,
-				authorId: input.authorId
-			});
-			revisionId = revision.id;
-			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) statements.push(...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;
-	}
-	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));
-	}
-	const prepared = {
-		id: item.id,
-		item,
-		rev: encodeRev(item),
-		draftData: draft,
-		batch: {
-			checks,
-			statements
-		},
-		afterCommit: () => {
-			invalidateCollectionCache(collection);
-			if (previousSlug !== item.slug) invalidateRedirectCache();
-		}
-	};
-	reviews.set(prepared, structuredClone({
-		item,
-		live,
-		draft
-	}));
-	return prepared;
-}
-
-//#endregion
-//#region src/review-automation/submission.ts
-var ReviewSubmissionError = class extends Error {
-	constructor(message, code = "REVIEW_SUBMISSION_INVALID") {
-		super(message);
-		this.code = code;
-	}
-};
-async function prepareAutomatedReview(db, handlers, input, options = {}) {
-	const projected = options.draft ? preparedContentReview(options.draft) : null;
-	if (projected && (projected.item.id !== input.id || projected.item.type !== input.collection)) throw new ReviewSubmissionError("Prepared draft does not match the review target.");
-	const contentRepo = new ContentRepository(db);
-	const entry = projected ? projected.item : await contentRepo.findByIdOrSlug(input.collection, input.id);
-	const snapshot = projected ? {
-		item: projected.item,
-		check: sql`true`
-	} : entry ? await contentRepo.snapshot(input.collection, entry.id) : null;
-	if (!snapshot) throw new ReviewSubmissionError("The submitted content could not be read.");
-	const revisionIds = projected ? [] : [snapshot.item.liveRevisionId, snapshot.item.draftRevisionId].filter((id) => id !== null);
-	const revisions = revisionIds.length ? await db.selectFrom("revisions").selectAll().where("id", "in", revisionIds).execute() : [];
-	const built = await new ReviewPayloadBuilder(projected ? {
-		handleContentGet: async () => ({
-			success: true,
-			data: {
-				item: projected.item,
-				_rev: encodeRev(projected.item)
-			}
-		}),
-		handleContentCompare: async () => ({
-			success: true,
-			data: {
-				live: projected.live,
-				draft: projected.draft,
-				hasChanges: projected.item.draftRevisionId !== null && projected.item.draftRevisionId !== projected.item.liveRevisionId
-			}
-		})
-	} : handlers).buildContentReviewPayload(input);
-	if (input.expectedRev !== void 0 && input.expectedRev !== built.reviewedRev) throw new ReviewSubmissionError("Reload the latest draft before submitting it.", "REVIEW_REVISION_CHANGED");
-	const contentHash = await buildStableHash(reviewDraft(built));
-	const targetKey = await buildStableHash({
-		collection: built.collection,
-		id: built.entryId,
-		actionHash: built.actionHash
-	});
-	if (built.reviewedRev !== encodeRev(snapshot.item) || built.draftRevisionId !== snapshot.item.draftRevisionId || built.liveRevisionId !== snapshot.item.liveRevisionId) throw new ReviewSubmissionError("The submitted content changed. Review the latest draft.");
-	const scheduledAt = snapshot.item.scheduledAt;
-	const checks = [...options.draft?.batch.checks ?? [snapshot.check], ...revisions.map((revision) => rowUnchanged("revisions", revision))];
-	const projectedGuard = [];
-	if (projected) {
-		const future = sql`${rowUnchanged(`ec_${input.collection}`, {
-			id: projected.item.id,
-			version: projected.item.version,
-			updated_at: projected.item.updatedAt,
-			live_revision_id: projected.item.liveRevisionId,
-			draft_revision_id: projected.item.draftRevisionId,
-			status: projected.item.status,
-			scheduled_at: projected.item.scheduledAt
-		})} AND ${projected.item.draftRevisionId && projected.draft ? sql`EXISTS(SELECT 1 FROM revisions WHERE id=${projected.item.draftRevisionId} AND collection=${input.collection} AND entry_id=${input.id} AND json(data)=json(${JSON.stringify(projected.draft)}))` : sql`true`}`;
-		projectedGuard.push(...prepareAtomicChecks(db, [future]));
-	}
-	const reviews = new ReviewRequestRepository(db);
-	const prepareSupersession = async () => {
-		const statements = [];
-		if (!input.supersedePending) return {
-			checks: [],
-			statements
-		};
-		const query = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("requested_by_actor_type", "=", input.actor.actorType).where("requested_by_actor_id", "=", input.actor.actorId).where("status", "=", "pending").where("revoked_at", "is", null).where((eb) => eb.or([eb("reviewed_rev", "!=", built.reviewedRev), eb("action_hash", "!=", built.actionHash)]));
-		const previous = await query.select("id").execute();
-		const supersessionChecks = [sql`${query.select((eb) => eb.fn.countAll().as("count"))} = ${previous.length}`];
-		for (const prior of previous) {
-			const batch = await reviews.prepareResolve(prior.id, {
-				decision: "rejected",
-				resolvedByActorType: "system",
-				resolvedByActorId: REVIEW_SUPERSESSION_ACTOR,
-				reviewNote: "Superseded by a newer submission. This is not an editorial rejection."
-			});
-			if (!batch) throw new AtomicWriteConflict();
-			supersessionChecks.push(...batch.checks ?? []);
-			statements.push(...batch.statements);
-		}
-		return {
-			checks: supersessionChecks,
-			statements
-		};
-	};
-	const reuseReview = async (item) => {
-		const batch = await prepareSupersession();
-		return {
-			id: item.id,
-			targetKey,
-			created: false,
-			batch: {
-				checks: [
-					...checks,
-					rowUnchanged("_dineway_review_requests", {
-						id: item.id,
-						status: item.status,
-						revoked_at: item.revokedAt ?? null
-					}),
-					...batch.checks
-				],
-				statements: [...projectedGuard, ...batch.statements]
-			}
-		};
-	};
-	const findExisting = async () => {
-		const existing = await db.selectFrom("_dineway_review_jobs").select("review_id").where("target_key", "=", targetKey).executeTakeFirst();
-		if (existing) {
-			const item = await reviews.findById(existing.review_id);
-			if (!item || item.status === "rejected" || item.revokedAt) throw new ReviewSubmissionError("Edit the content before submitting a rejected or revoked target again.");
-			return item;
-		}
-		return null;
-	};
-	const existingReview = await findExisting();
-	if (existingReview) return reuseReview(existingReview);
-	const rejected = await db.selectFrom("_dineway_review_requests").select([
-		"id",
-		"status",
-		"review_payload",
-		"resolved_by_actor_type",
-		"resolved_by_actor_id"
-	]).where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("status", "=", "rejected").execute();
-	checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_review_jobs WHERE target_key = ${targetKey})`, sql`(SELECT COUNT(*) FROM _dineway_review_requests WHERE collection = ${built.collection} AND entry_id = ${built.entryId} AND status = 'rejected') = ${rejected.length}`, ...rejected.map((row) => rowUnchanged("_dineway_review_requests", row)));
-	for (const row of rejected) {
-		if (isSupersededReview(row)) continue;
-		if (await buildStableHash(z.object({ diff: z.object({ draft: z.unknown().optional() }).optional() }).parse(JSON.parse(row.review_payload)).diff?.draft) === contentHash) throw new ReviewSubmissionError("This content was rejected. Change it before submitting a new review.");
-	}
-	const approved = await reviews.findApprovedForTarget(built);
-	if (approved) return reuseReview(approved);
-	const pendingQuery = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("reviewed_rev", "=", built.reviewedRev).where("action_hash", "=", built.actionHash).where("status", "=", "pending").where("revoked_at", "is", null);
-	const pending = await pendingQuery.selectAll().orderBy("created_at").orderBy("id").executeTakeFirst();
-	checks.push(pending ? rowUnchanged("_dineway_review_requests", pending) : sql`NOT EXISTS ${pendingQuery.select("id")}`);
-	const prepared = pending ? null : reviews.prepareCreate({
-		...built,
-		riskReason: input.riskReason,
-		requestedByActorType: input.actor.actorType,
-		requestedByActorId: input.actor.actorId,
-		requestedAuthMetadata: input.actor.authMetadata
-	});
-	const reviewId = pending?.id ?? prepared.id;
-	const supersession = await prepareSupersession();
-	checks.push(...supersession.checks);
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const job = db.insertInto("_dineway_review_jobs").values({
-		review_id: reviewId,
-		target_key: targetKey,
-		content_hash: contentHash,
-		state: "queued",
-		release_state: "none",
-		evidence_json: null,
-		reason: "Automated review in progress",
-		release_reason: null,
-		scheduled_at: scheduledAt,
-		created_at: now,
-		updated_at: now
-	}).compile();
-	return {
-		id: reviewId,
-		targetKey,
-		created: !pending,
-		batch: {
-			checks,
-			statements: [
-				...projectedGuard,
-				...supersession.statements,
-				...prepared ? [prepared.statement] : [],
-				job
-			]
-		}
-	};
-}
-async function submitAutomatedReview(db, handlers, input) {
-	let prepared = await prepareAutomatedReview(db, handlers, input);
-	try {
-		await atomicBatch(db, prepared.batch);
-	} catch (error) {
-		if (!(error instanceof AtomicWriteConflict)) throw error;
-		const existing = await prepareAutomatedReview(db, handlers, input);
-		if (existing.created || existing.targetKey !== prepared.targetKey) throw error;
-		await atomicBatch(db, existing.batch);
-		prepared = existing;
-	}
-	return {
-		item: await new ReviewRequestRepository(db).findById(prepared.id),
-		created: prepared.created
-	};
-}
-
-//#endregion
-export { prepareContentWrite as i, prepareAutomatedReview as n, submitAutomatedReview as r, ReviewSubmissionError as t };