dineway 0.2.34 → 0.2.35

package/dist/seo/index.mjs

@@ -2,13 +2,13 @@ import "../d1-binding-D6HZa3ks.mjs";
 import "../dialect-helpers-C6xtO-Ui.mjs";
 import "../base64-Cz-aU0X1.mjs";
 import "../types-BqxIv8Il.mjs";
-import "../content-refresh-l4mPoGeX.mjs";
-import "../fts-manager-BeWtB7ZD.mjs";
-import { i as satisfiesPublicDiscoveryRules } from "../public-discovery-BAbOvKiR.mjs";
-import "../registry-RD9qTnYL.mjs";
-import { n as resolveCanonicalUrl, t as listPublicContent } from "../discovery-CqXbN0WZ.mjs";
-import { t as resolveContentUrl } from "../public-url-C7pbmS_7.mjs";
-import { t as buildSeoImageUrl } from "../media-url-B4YtTY6c.mjs";
+import "../content-refresh-9M9cc55-.mjs";
+import "../fts-manager-DA74x_uP.mjs";
+import { i as satisfiesPublicDiscoveryRules } from "../public-discovery-CTql6jdZ.mjs";
+import "../registry-DcV93OL_.mjs";
+import { n as resolveCanonicalUrl, t as listPublicContent } from "../discovery-CYcZJ1o3.mjs";
+import { t as resolveContentUrl } from "../public-url-DNt9A1yS.mjs";
+import { t as buildSeoImageUrl } from "../media-url-D-elxQjL.mjs";
 
 //#region src/seo/index.ts
 /**

package/dist/{seo-B_tBFyud.mjs → seo-Bypxm1iD.mjs}

@@ -1,4 +1,4 @@
-import { t as listPublicContent } from "./discovery-CqXbN0WZ.mjs";
+import { t as listPublicContent } from "./discovery-CYcZJ1o3.mjs";
 
 //#region src/api/handlers/seo.ts
 /** Internal XML batch, not an unbounded public JSON list endpoint. */

package/dist/{service-DilVsWGD.mjs → service-DOFqfUVv.mjs}

@@ -1,6 +1,8 @@
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
-import { t as CommentRepository } from "./comment-Bi7cJ9SS.mjs";
-import { t as escapeHtml } from "./escape-BWC4s5bV.mjs";
+import { s as invalidateCommentObjectCache } from "./object-cache-BGjIlY9s.mjs";
+import { t as CommentRepository } from "./comment-kgLTdtQD.mjs";
+import { t as escapeHtml } from "./escape-B1GM0yJU.mjs";
+import { sql } from "kysely";
 
 //#region src/comments/notifications.ts
 const NOTIFICATION_SOURCE = "dineway-comments";
@@ -90,11 +92,23 @@ async function lookupContentAuthor(db, collection, contentId) {
 //#endregion
 //#region src/comments/service.ts
 /**
+* Comment Service
+*
+* Orchestrates comment creation through the hook pipeline:
+*   1. Run comment:beforeCreate pipeline (transform/reject)
+*   2. Query priorApprovedCount for first-time moderation
+*   3. Invoke comment:moderate exclusive hook (or built-in fallback)
+*   4. Save comment with determined status
+*   5. Fire comment:afterCreate (fire-and-forget)
+*
+* Also handles admin moderation (status changes) with afterModerate hooks.
+*/
+/**
 * Create a comment through the full hook pipeline.
 *
 * Returns null if the comment was rejected by a beforeCreate handler.
 */
-async function createComment(db, input, collectionSettings, hooks, contentInfo) {
+async function prepareComment(db, input, collectionSettings, hooks, contentInfo) {
 	const repo = new CommentRepository(db);
 	const beforeCreateEvent = {
 		comment: {
@@ -121,7 +135,7 @@ async function createComment(db, input, collectionSettings, hooks, contentInfo)
 		priorApprovedCount
 	};
 	const decision = await hooks.runModerate(moderateEvent);
-	const comment = await repo.create({
+	const prepared = repo.prepareCreate({
 		collection: event.comment.collection,
 		contentId: event.comment.contentId,
 		parentId: event.comment.parentId,
@@ -134,23 +148,34 @@ async function createComment(db, input, collectionSettings, hooks, contentInfo)
 		userAgent: event.comment.userAgent,
 		moderationMetadata: Object.keys(event.metadata).length > 0 ? event.metadata : null
 	});
-	if (contentInfo) {
-		const afterEvent = {
-			comment: commentToStored(comment),
-			metadata: event.metadata,
-			content: {
-				id: contentInfo.id,
-				collection: contentInfo.collection,
-				slug: contentInfo.slug,
-				title: contentInfo.title
-			},
-			contentAuthor: contentInfo.author
-		};
-		hooks.fireAfterCreate(afterEvent);
-	}
+	const comment = prepared.comment;
+	let completed;
+	const afterCommit = () => completed ??= (async () => {
+		if (!await repo.findById(comment.id)) throw new Error("The comment has not been committed.");
+		invalidateCommentObjectCache();
+		if (contentInfo) {
+			const afterEvent = {
+				comment: commentToStored(comment),
+				metadata: event.metadata,
+				content: {
+					id: contentInfo.id,
+					collection: contentInfo.collection,
+					slug: contentInfo.slug,
+					title: contentInfo.title
+				},
+				contentAuthor: contentInfo.author
+			};
+			await hooks.fireAfterCreate(afterEvent);
+		}
+	})();
 	return {
 		comment,
-		decision
+		decision,
+		afterCommit,
+		batch: {
+			checks: [sql`(SELECT COUNT(*) FROM _dineway_comments WHERE author_email = ${event.comment.authorEmail} AND status = 'approved') = ${priorApprovedCount}`],
+			statements: [prepared.statement]
+		}
 	};
 }
 /**
@@ -191,4 +216,4 @@ function commentToStored(comment) {
 }
 
 //#endregion
-export { sendCommentNotification as i, moderateComment as n, lookupContentAuthor as r, createComment as t };
+export { sendCommentNotification as i, prepareComment as n, lookupContentAuthor as r, moderateComment as t };

package/dist/{service--bQht6oN.mjs → service-mJBl4ZP4.mjs}

@@ -1,5 +1,5 @@
-import { n as DinewayToolsService, r as integrationResponse } from "./service-wYQ_ePZ4.mjs";
-import { r as getSiteIntegrationCatalog, t as SiteIntegrationRuns } from "./runs-B5BExdKO.mjs";
+import { n as DinewayToolsService, r as integrationResponse } from "./service-CeEi6nax.mjs";
+import { r as getSiteIntegrationCatalog, t as SiteIntegrationRuns } from "./runs-B8kCirJ6.mjs";
 
 //#region src/integrations/service.ts
 function createSiteIntegrationService(options, actorId) {

package/dist/{settings-Deqx3Upy.mjs → settings-2p7TuNWG.mjs}

@@ -1,5 +1,5 @@
 import { c as __exportAll } from "./runner-CVeq0266.mjs";
-import { a as getSiteSettingsWithDb, s as setSiteSettings } from "./settings-DFzevIrU.mjs";
+import { a as getSiteSettingsWithDb, s as setSiteSettings } from "./settings-DRFy8JQx.mjs";
 
 //#region src/api/handlers/settings.ts
 var settings_exports = /* @__PURE__ */ __exportAll({

package/dist/{settings-DFzevIrU.mjs → settings-DRFy8JQx.mjs}

@@ -2,11 +2,11 @@ import { getRequestContext } from "./request-context.mjs";
 import { r as getDb } from "./loader-Cgsx23wU.mjs";
 import { t as after } from "./after-BVaUn7bK.mjs";
 import { l as invalidateObjectCache, n as cachedQuery, t as CacheNamespace } from "./object-cache-BGjIlY9s.mjs";
-import { t as MediaRepository } from "./media-3fK0u-bo.mjs";
+import { t as MediaRepository } from "./media-BZqwtRTZ.mjs";
 import { t as OptionsRepository } from "./options-BcqHWpc-.mjs";
 import { n as peekRequestCache, r as requestCached } from "./request-cache-DPmV5nk4.mjs";
 import { n as invalidateProcessCache, r as processCachedAsync, t as createProcessCache } from "./process-cache-MHM4Sqzs.mjs";
-import { i as resolvePublicMediaUrl } from "./url-D375-6LM.mjs";
+import { i as resolvePublicMediaUrl } from "./url-Ce0qtSdB.mjs";
 
 //#region src/settings/index.ts
 /** Prefix for site settings in the options table */

package/dist/{site-context-vCiDRr4H.mjs → site-context-D9oETfxF.mjs}

@@ -1,20 +1,20 @@
 import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
 import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
 import { i as encodeCursor, r as decodeCursor } from "./types-BqxIv8Il.mjs";
-import { t as ContentRepository } from "./content-NobcQti0.mjs";
+import { t as ContentRepository } from "./content-D9xKUSno.mjs";
 import { t as SiteActivityRepository } from "./site-activity-BrN2NviL.mjs";
 import { r as ReviewRequestRepository } from "./review-requests-BF2eEKr8.mjs";
-import { o as HitlRequestRepository } from "./publication-authorization-BrEZ2TsE.mjs";
+import { o as HitlRequestRepository } from "./publication-authorization-Dq_20SZR.mjs";
 import { r as isPattern } from "./patterns-CZ7D4y_R.mjs";
-import { n as buildStableActionHash, t as ReviewPayloadBuilder } from "./review-payload-DEylbssM.mjs";
-import { d as ContextRepository, i as parseSiteBriefingScope, l as handlePluginList } from "./briefing-CkCi6S-W.mjs";
-import { t as FTSManager } from "./fts-manager-BeWtB7ZD.mjs";
-import { n as SchemaRegistry } from "./registry-RD9qTnYL.mjs";
-import { a as getSiteSettingsWithDb } from "./settings-DFzevIrU.mjs";
-import { n as assertExperimentalSiteContextWorkflowsEnabled } from "./experimental-workflows-M5D3RTFo.mjs";
-import { m as normalizeUrl } from "./utils-Cglcqpm2.mjs";
-import { t as sanitizeWordPressImportSlug } from "./wordpress-slugs-vOx7R1dM.mjs";
-import { s as searchCollection } from "./search-CRzWNfxX.mjs";
+import { n as buildStableActionHash, t as ReviewPayloadBuilder } from "./review-payload-LLIi1sxO.mjs";
+import { d as ContextRepository, i as parseSiteBriefingScope, l as handlePluginList } from "./briefing-5zf0YZbR.mjs";
+import { t as FTSManager } from "./fts-manager-DA74x_uP.mjs";
+import { n as SchemaRegistry } from "./registry-DcV93OL_.mjs";
+import { a as getSiteSettingsWithDb } from "./settings-DRFy8JQx.mjs";
+import { n as assertExperimentalSiteContextWorkflowsEnabled } from "./experimental-workflows-fzJHB3ZI.mjs";
+import { m as normalizeUrl } from "./utils-BoWkoty8.mjs";
+import { t as sanitizeWordPressImportSlug } from "./wordpress-slugs-pQlLXbKn.mjs";
+import { s as searchCollection } from "./search-C9qOBgvo.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 import { Role } from "@dineway-ai/auth";

package/dist/storage/local.d.mts

@@ -1,4 +1,4 @@
-import { a as ListOptions, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, s as LocalStorageConfig, u as SignedUploadUrl } from "../types-CwkJp6zr.mjs";
+import { a as ListOptions, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, s as LocalStorageConfig, u as SignedUploadUrl } from "../types-BWsEjujW.mjs";
 
 //#region src/storage/local.d.ts
 /**

package/dist/storage/local.mjs

@@ -1,4 +1,4 @@
-import { t as DinewayStorageError } from "../types-BDq9t5lG.mjs";
+import { t as DinewayStorageError } from "../types-BKsk4nnM.mjs";
 import { createReadStream, existsSync } from "node:fs";
 import * as path from "node:path";
 import mime from "mime/lite";

package/dist/storage/s3.d.mts

@@ -1,4 +1,4 @@
-import { a as ListOptions, c as S3StorageConfig, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, u as SignedUploadUrl } from "../types-CwkJp6zr.mjs";
+import { a as ListOptions, c as S3StorageConfig, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, u as SignedUploadUrl } from "../types-BWsEjujW.mjs";
 
 //#region src/storage/s3.d.ts
 /**

package/dist/storage/s3.mjs

@@ -1,5 +1,5 @@
-import { t as readRuntimeEnv } from "../runtime-env-CQVAWHzH.mjs";
-import { t as DinewayStorageError } from "../types-BDq9t5lG.mjs";
+import { t as readRuntimeEnv } from "../runtime-env-v-1UXPAH.mjs";
+import { t as DinewayStorageError } from "../types-BKsk4nnM.mjs";
 import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 

package/dist/{store-C1yDxxfv.mjs → store-CjmmGlVw.mjs}

@@ -1,7 +1,7 @@
 import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
 import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
-import { t as readRuntimeEnv } from "./runtime-env-CQVAWHzH.mjs";
-import { i as parseEncryptionKeys, t as DinewaySecretsError } from "./secrets-Cg0D2gQW.mjs";
+import { t as readRuntimeEnv } from "./runtime-env-v-1UXPAH.mjs";
+import { i as parseEncryptionKeys, t as DinewaySecretsError } from "./secrets-BP2YTPWn.mjs";
 
 //#region src/database/repositories/integration-credentials.ts
 var IntegrationCredentialRepository = class {

package/dist/submission-BLvkvewK.mjs

@@ -0,0 +1,411 @@
+import { AtomicWriteConflict, atomicBatch, prepareAtomicChecks, rowUnchanged } from "./database/batch.mjs";
+import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
+import { t as DinewayValidationError } from "./types-BqxIv8Il.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
+import { o as invalidateCollectionCache } from "./object-cache-BGjIlY9s.mjs";
+import { t as RevisionRepository } from "./revision-090sZyGc.mjs";
+import { t as ContentRepository } from "./content-D9xKUSno.mjs";
+import { t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
+import { i as isSupersededReview, r as ReviewRequestRepository, t as REVIEW_SUPERSESSION_ACTOR } from "./review-requests-BF2eEKr8.mjs";
+import { t as RedirectRepository } from "./redirect-HLI3wT5Y.mjs";
+import { i as invalidateRedirectCache } from "./cache-DZDOBJv3.mjs";
+import { D as validateMediaFields, E as validateContentDataFields, T as prepareNonTranslatableFields, k as encodeRev, r as contentWriteConfiguration, t as ReviewPayloadBuilder } from "./review-payload-LLIi1sxO.mjs";
+import { i as reviewDraft } from "./evidence-krrA3uiG.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 };

package/dist/{taxonomies-4cnTcbD6.mjs → taxonomies-C5ayPp3T.mjs}

@@ -1,6 +1,6 @@
 import { c as __exportAll } from "./runner-CVeq0266.mjs";
 import { t as TaxonomyRepository } from "./taxonomy-DWxxLpp5.mjs";
-import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-CllxqaH0.mjs";
+import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-DW6Fps-w.mjs";
 import { ulid } from "ulidx";
 
 //#region src/api/handlers/taxonomies.ts