dineway 0.2.33 → 0.2.34

package/dist/{bundle-S6zx-V4D.mjs → bundle-Cgak1zGE.mjs}

@@ -1,13 +1,13 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { t as capabilitiesToDeclaredAccess } from "./types-BbkkkAb6.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { t as capabilitiesToDeclaredAccess } from "./types-D17dJRht.mjs";
 import { createHash } from "node:crypto";
 import { imageSize } from "image-size";
 import { createWriteStream } from "node:fs";
 import { basename, extname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { access, copyFile, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { defineCommand } from "citty";
 import consola from "consola";
-import { access, copyFile, mkdir, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 import { packTar } from "modern-tar/fs";
 

package/dist/{byline-Ctil4rij.mjs → byline-DEZKlzD9.mjs}

@@ -1,12 +1,12 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { l as listTablesLike } from "./dialect-helpers-fk43GbDb.mjs";
-import { i as encodeCursor, r as decodeCursor, t as DinewayValidationError } from "./types-BpSTdH1H.mjs";
-import { a as invalidateBylineObjectCache, o as invalidateCollectionCache } from "./object-cache-D51qOseS.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-CnuL55JE.mjs";
-import { t as withTransaction } from "./transaction-BGQgnwUi.mjs";
-import { i as setRequestCacheEntry, n as peekRequestCache, t as clearRequestCacheEntry } from "./request-cache-BruBnFAR.mjs";
-import { n as getBylineFieldDefs } from "./field-defs-cache-CwrIyZFT.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
+import { l as listTablesLike } from "./dialect-helpers-C6xtO-Ui.mjs";
+import { i as encodeCursor, r as decodeCursor, t as DinewayValidationError } from "./types-BqxIv8Il.mjs";
+import { a as invalidateBylineObjectCache, o as invalidateCollectionCache } from "./object-cache-BGjIlY9s.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-BnG3LPMN.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, t as clearRequestCacheEntry } from "./request-cache-DPmV5nk4.mjs";
+import { n as getBylineFieldDefs } from "./field-defs-cache-BKKFFf_V.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -214,45 +214,29 @@ var BylineRepository = class {
 		}
 		return writes;
 	}
-	async writeCustomFields(trx, bylineId, translationGroup, writes, now) {
-		let touchedGroupShared = false;
+	prepareCustomFields(bylineId, translationGroup, writes, now) {
+		const checks = [];
+		const statements = [];
 		for (const { field, value } of writes) {
-			if (!field.translatable) touchedGroupShared = true;
-			if (field.translatable) {
-				if (value === null) {
-					await trx.deleteFrom("_dineway_byline_field_values").where("byline_id", "=", bylineId).where("field_id", "=", field.id).execute();
-					continue;
-				}
-				const encoded = JSON.stringify(value);
-				await trx.insertInto("_dineway_byline_field_values").values({
-					byline_id: bylineId,
-					field_id: field.id,
-					value: encoded,
-					created_at: now,
-					updated_at: now
-				}).onConflict((oc) => oc.columns(["byline_id", "field_id"]).doUpdateSet({
-					value: encoded,
-					updated_at: now
-				})).execute();
-				continue;
-			}
-			if (value === null) {
-				await trx.deleteFrom("_dineway_byline_field_group_values").where("translation_group", "=", translationGroup).where("field_id", "=", field.id).execute();
-				continue;
-			}
-			const encoded = JSON.stringify(value);
-			await trx.insertInto("_dineway_byline_field_group_values").values({
-				translation_group: translationGroup,
-				field_id: field.id,
-				value: encoded,
-				created_at: now,
-				updated_at: now
-			}).onConflict((oc) => oc.columns(["translation_group", "field_id"]).doUpdateSet({
-				value: encoded,
-				updated_at: now
-			})).execute();
+			checks.push(rowUnchanged("_dineway_byline_fields", {
+				id: field.id,
+				type: field.type,
+				required: field.required ? 1 : 0,
+				translatable: field.translatable ? 1 : 0,
+				validation: field.validation ? JSON.stringify(field.validation) : null
+			}));
+			const table = field.translatable ? "_dineway_byline_field_values" : "_dineway_byline_field_group_values";
+			const owner = field.translatable ? "byline_id" : "translation_group";
+			const ownerId = field.translatable ? bylineId : translationGroup;
+			if (value === null) statements.push(sql`DELETE FROM ${sql.table(table)} WHERE ${sql.ref(owner)} = ${ownerId} AND field_id = ${field.id}`.compile(this.db));
+			else statements.push(sql`INSERT INTO ${sql.table(table)} (${sql.ref(owner)}, field_id, value, created_at, updated_at)
+ VALUES (${ownerId}, ${field.id}, ${JSON.stringify(value)}, ${now}, ${now})
+ ON CONFLICT (${sql.ref(owner)}, field_id) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`.compile(this.db));
 		}
-		return touchedGroupShared;
+		return {
+			checks,
+			statements
+		};
 	}
 	async findById(id) {
 		const row = await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", id).executeTakeFirst();
@@ -310,15 +294,13 @@ var BylineRepository = class {
 		const id = ulid();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const customFieldWrites = await this.resolveCustomFieldWrites(input.customFields);
-		let translationGroup = id;
-		if (input.translationOf) {
-			const source = await this.findById(input.translationOf);
-			if (!source) throw new Error("Source byline for translation not found");
-			translationGroup = source.translationGroup ?? source.id;
-		}
-		let touchedGroupShared = false;
-		await withTransaction(this.db, async (trx) => {
-			await trx.insertInto("_dineway_bylines").values({
+		const source = input.translationOf ? await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", input.translationOf).executeTakeFirst() : null;
+		if (input.translationOf && !source) throw new Error("Source byline for translation not found");
+		const translationGroup = source?.translation_group ?? source?.id ?? id;
+		const fields = this.prepareCustomFields(id, translationGroup, customFieldWrites, now);
+		await atomicBatch(this.db, {
+			checks: [...source ? [rowUnchanged("_dineway_bylines", source)] : [], ...fields.checks ?? []],
+			statements: [this.db.insertInto("_dineway_bylines").values({
 				id,
 				slug: input.slug,
 				display_name: input.displayName,
@@ -331,17 +313,16 @@ var BylineRepository = class {
 				updated_at: now,
 				...input.locale !== void 0 ? { locale: input.locale } : {},
 				translation_group: translationGroup
-			}).execute();
-			touchedGroupShared = await this.writeCustomFields(trx, id, translationGroup, customFieldWrites, now);
+			}).compile(), ...fields.statements]
 		});
-		if (touchedGroupShared) clearRequestCacheEntry(`byline-field-group-values:${translationGroup}`);
+		if (customFieldWrites.some(({ field }) => !field.translatable)) clearRequestCacheEntry(`byline-field-group-values:${translationGroup}`);
 		invalidateBylineObjectCache();
 		const byline = await this.findById(id);
 		if (!byline) throw new Error("Failed to create byline");
 		return byline;
 	}
 	async update(id, input) {
-		const existing = await this.findById(id);
+		const existing = await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", id).executeTakeFirst();
 		if (!existing) return null;
 		const customFieldWrites = await this.resolveCustomFieldWrites(input.customFields);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -353,39 +334,39 @@ var BylineRepository = class {
 		if (input.websiteUrl !== void 0) updates.website_url = input.websiteUrl;
 		if (input.userId !== void 0) updates.user_id = input.userId;
 		if (input.isGuest !== void 0) updates.is_guest = input.isGuest ? 1 : 0;
-		const group = existing.translationGroup ?? existing.id;
-		let touchedGroupShared = false;
-		await withTransaction(this.db, async (trx) => {
-			await trx.updateTable("_dineway_bylines").set(updates).where("id", "=", id).execute();
-			touchedGroupShared = await this.writeCustomFields(trx, id, group, customFieldWrites, now);
+		const group = existing.translation_group ?? existing.id;
+		const fields = this.prepareCustomFields(id, group, customFieldWrites, now);
+		await atomicBatch(this.db, {
+			checks: [rowUnchanged("_dineway_bylines", existing), ...fields.checks ?? []],
+			statements: [this.db.updateTable("_dineway_bylines").set(updates).where("id", "=", id).compile(), ...fields.statements]
 		});
-		if (touchedGroupShared) clearRequestCacheEntry(`byline-field-group-values:${group}`);
+		if (customFieldWrites.some(({ field }) => !field.translatable)) clearRequestCacheEntry(`byline-field-group-values:${group}`);
 		invalidateBylineObjectCache();
 		return await this.findById(id);
 	}
 	async delete(id) {
-		const existing = await this.findById(id);
+		const existing = await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", id).executeTakeFirst();
 		if (!existing) return false;
-		const group = existing.translationGroup ?? existing.id;
-		await withTransaction(this.db, async (trx) => {
-			await trx.deleteFrom("_dineway_byline_field_values").where("byline_id", "=", id).execute();
-			await trx.deleteFrom("_dineway_bylines").where("id", "=", id).execute();
-			const remaining = await trx.selectFrom("_dineway_bylines").select(({ fn }) => [fn.count("id").as("count")]).where("translation_group", "=", group).executeTakeFirst();
-			if (Number(remaining?.count ?? 0) > 0) return;
-			await trx.deleteFrom("_dineway_content_bylines").where("byline_id", "=", group).execute();
-			await trx.deleteFrom("_dineway_byline_field_group_values").where("translation_group", "=", group).execute();
-			const tableNames = await listTablesLike(trx, "ec_%");
-			for (const tableName of tableNames) {
-				validateIdentifier(tableName, "content table");
-				await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET primary_byline_id = NULL
-					WHERE primary_byline_id = ${group}
-				`.execute(trx);
-			}
+		const group = existing.translation_group ?? existing.id;
+		const noTranslation = sql`NOT EXISTS (SELECT 1 FROM _dineway_bylines WHERE translation_group = ${group})`;
+		const statements = [
+			this.db.deleteFrom("_dineway_byline_field_values").where("byline_id", "=", id).compile(),
+			this.db.deleteFrom("_dineway_bylines").where("id", "=", id).compile(),
+			this.db.deleteFrom("_dineway_content_bylines").where("byline_id", "=", group).where(noTranslation).compile(),
+			this.db.deleteFrom("_dineway_byline_field_group_values").where("translation_group", "=", group).where(noTranslation).compile()
+		];
+		const tableNames = await listTablesLike(this.db, "ec_%");
+		for (const tableName of tableNames) {
+			validateIdentifier(tableName, "content table");
+			statements.push(sql`UPDATE ${sql.table(tableName)} SET primary_byline_id = NULL WHERE primary_byline_id = ${group} AND ${noTranslation}`.compile(this.db));
+		}
+		await atomicBatch(this.db, {
+			checks: [rowUnchanged("_dineway_bylines", existing)],
+			statements
 		});
 		clearRequestCacheEntry(`byline-field-group-values:${group}`);
 		invalidateBylineObjectCache();
+		for (const tableName of tableNames) invalidateCollectionCache(tableName.slice(3));
 		return true;
 	}
 	async getContentBylines(collectionSlug, contentId, options) {
@@ -517,44 +498,50 @@ var BylineRepository = class {
 		}
 		return result;
 	}
-	async copyContentBylines(collectionSlug, sourceContentId, targetContentId) {
+	async prepareCopyContentBylines(collectionSlug, sourceContentId, targetContentId) {
 		validateIdentifier(collectionSlug, "collection slug");
-		const tableName = `ec_${collectionSlug}`;
-		validateIdentifier(tableName, "content table");
-		if (await this.db.selectFrom("_dineway_content_bylines").select("id").where("collection_slug", "=", collectionSlug).where("content_id", "=", targetContentId).executeTakeFirst()) return;
-		const sourceRows = await this.db.selectFrom("_dineway_content_bylines").select([
-			"byline_id",
-			"sort_order",
-			"role_label"
-		]).where("collection_slug", "=", collectionSlug).where("content_id", "=", sourceContentId).orderBy("sort_order", "asc").execute();
-		if (sourceRows.length === 0) return;
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		await this.db.insertInto("_dineway_content_bylines").values(sourceRows.map((row) => ({
+		const source = await this.db.selectFrom("_dineway_content_bylines").selectAll().where("collection_slug", "=", collectionSlug).where("content_id", "=", sourceContentId).orderBy("sort_order", "asc").execute();
+		const checks = [
+			sql`NOT EXISTS (SELECT 1 FROM _dineway_content_bylines WHERE collection_slug = ${collectionSlug} AND content_id = ${targetContentId})`,
+			sql`(SELECT COUNT(*) FROM _dineway_content_bylines WHERE collection_slug = ${collectionSlug} AND content_id = ${sourceContentId}) = ${source.length}`,
+			...source.map((row) => rowUnchanged("_dineway_content_bylines", row))
+		];
+		const statements = source.map((row) => this.db.insertInto("_dineway_content_bylines").values({
+			...row,
 			id: ulid(),
-			collection_slug: collectionSlug,
 			content_id: targetContentId,
-			byline_id: row.byline_id,
-			sort_order: row.sort_order,
-			role_label: row.role_label,
-			created_at: now
-		}))).execute();
-		await sql`
-				UPDATE ${sql.ref(tableName)}
-				SET primary_byline_id = ${sourceRows[0]?.byline_id ?? null}
-				WHERE id = ${targetContentId}
-			`.execute(this.db);
+			created_at: (/* @__PURE__ */ new Date()).toISOString()
+		}).compile());
+		if (source.length) statements.push(sql`UPDATE ${sql.table(`ec_${collectionSlug}`)} SET primary_byline_id = ${source[0].byline_id} WHERE id = ${targetContentId}`.compile(this.db));
+		return {
+			checks,
+			statements
+		};
+	}
+	async copyContentBylines(collectionSlug, sourceContentId, targetContentId) {
+		if (await this.db.selectFrom("_dineway_content_bylines").select("id").where("collection_slug", "=", collectionSlug).where("content_id", "=", targetContentId).executeTakeFirst()) return;
+		const prepared = await this.prepareCopyContentBylines(collectionSlug, sourceContentId, targetContentId);
+		await atomicBatch(this.db, {
+			...prepared,
+			checks: [...prepared.checks ?? [], sql`EXISTS (SELECT 1 FROM ${sql.table(`ec_${collectionSlug}`)} WHERE id = ${targetContentId} AND deleted_at IS NULL)`]
+		});
 		invalidateCollectionCache(collectionSlug);
 	}
-	async setContentBylines(collectionSlug, contentId, inputBylines) {
+	async prepareContentBylines(collectionSlug, contentId, inputBylines) {
 		validateIdentifier(collectionSlug, "collection slug");
 		const tableName = `ec_${collectionSlug}`;
 		validateIdentifier(tableName, "content table");
+		const checks = [];
+		const statements = [];
 		const idToGroup = /* @__PURE__ */ new Map();
 		if (inputBylines.length > 0) {
 			const ids = [...new Set(inputBylines.map((item) => item.bylineId))];
 			const rows = await this.db.selectFrom("_dineway_bylines").select(["id", "translation_group"]).where("id", "in", ids).execute();
 			if (rows.length !== ids.length) throw new Error("One or more byline IDs do not exist");
-			for (const row of rows) idToGroup.set(row.id, row.translation_group ?? row.id);
+			for (const row of rows) {
+				idToGroup.set(row.id, row.translation_group ?? row.id);
+				checks.push(rowUnchanged("_dineway_bylines", row));
+			}
 		}
 		const seenGroups = /* @__PURE__ */ new Set();
 		const bylines = [];
@@ -568,11 +555,11 @@ var BylineRepository = class {
 				group
 			});
 		}
-		await this.db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).execute();
+		statements.push(this.db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).compile());
 		for (let i = 0; i < bylines.length; i++) {
 			const item = bylines[i];
 			if (!item) continue;
-			await this.db.insertInto("_dineway_content_bylines").values({
+			statements.push(this.db.insertInto("_dineway_content_bylines").values({
 				id: ulid(),
 				collection_slug: collectionSlug,
 				content_id: contentId,
@@ -580,13 +567,20 @@ var BylineRepository = class {
 				sort_order: i,
 				role_label: item.roleLabel ?? null,
 				created_at: (/* @__PURE__ */ new Date()).toISOString()
-			}).execute();
+			}).compile());
 		}
-		await sql`
+		statements.push(sql`
 				UPDATE ${sql.ref(tableName)}
 				SET primary_byline_id = ${bylines[0]?.group ?? null}
 				WHERE id = ${contentId}
-			`.execute(this.db);
+			`.compile(this.db));
+		return {
+			checks,
+			statements
+		};
+	}
+	async setContentBylines(collectionSlug, contentId, inputBylines) {
+		await atomicBatch(this.db, await this.prepareContentBylines(collectionSlug, contentId, inputBylines));
 		invalidateCollectionCache(collectionSlug);
 		return await this.getContentBylines(collectionSlug, contentId);
 	}

package/dist/{byline-fields-QpmruT5r.mjs → byline-fields-BGEIA9dZ.mjs}

@@ -1,6 +1,6 @@
-import { i as RESERVED_BYLINE_FIELD_SLUGS } from "./types-C0DPvhR5.mjs";
-import { n as isSiteContextType, t as SITE_CONTEXT_TYPES } from "./context-types-CPWAJRs5.mjs";
-import { Ln as roleLevel, Nn as httpUrl } from "./redirects-N8gmWhVM.mjs";
+import { i as RESERVED_BYLINE_FIELD_SLUGS } from "./types-CyBH89BS.mjs";
+import { n as isSiteContextType, t as SITE_CONTEXT_TYPES } from "./context-types-DqTo6C79.mjs";
+import { Ln as roleLevel, Nn as httpUrl } from "./redirects-UCXyL0lP.mjs";
 import { z } from "zod";
 
 //#region src/api/schemas/context.ts

package/dist/{byline-fields-51ja6JDa.d.mts → byline-fields-BmkhEDFF.d.mts}

@@ -807,8 +807,8 @@ declare const createCollectionBody: z.ZodObject<{
   icon: z.ZodOptional<z.ZodString>;
   supports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
     search: "search";
-    drafts: "drafts";
     revisions: "revisions";
+    drafts: "drafts";
     preview: "preview";
     scheduling: "scheduling";
   }>>>;
@@ -828,8 +828,8 @@ declare const updateCollectionBody: z.ZodObject<{
   icon: z.ZodOptional<z.ZodString>;
   supports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
     search: "search";
-    drafts: "drafts";
     revisions: "revisions";
+    drafts: "drafts";
     preview: "preview";
     scheduling: "scheduling";
   }>>>;
@@ -856,9 +856,9 @@ declare const createFieldBody: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     json: "json";
     url: "url";
-    file: "file";
     slug: "slug";
     image: "image";
     datetime: "datetime";
@@ -914,9 +914,9 @@ declare const updateFieldBody: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     json: "json";
     url: "url";
-    file: "file";
     slug: "slug";
     image: "image";
     datetime: "datetime";
@@ -1008,9 +1008,9 @@ declare const fieldSchema: z.ZodObject<{
     string: "string";
     number: "number";
     boolean: "boolean";
+    file: "file";
     json: "json";
     url: "url";
-    file: "file";
     slug: "slug";
     image: "image";
     datetime: "datetime";
@@ -1083,9 +1083,9 @@ declare const collectionWithFieldsResponseSchema: z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
+        file: "file";
         json: "json";
         url: "url";
-        file: "file";
         slug: "slug";
         image: "image";
         datetime: "datetime";
@@ -1142,9 +1142,9 @@ declare const fieldResponseSchema: z.ZodObject<{
       string: "string";
       number: "number";
       boolean: "boolean";
+      file: "file";
       json: "json";
       url: "url";
-      file: "file";
       slug: "slug";
       image: "image";
       datetime: "datetime";
@@ -1179,9 +1179,9 @@ declare const fieldListResponseSchema: z.ZodObject<{
       string: "string";
       number: "number";
       boolean: "boolean";
+      file: "file";
       json: "json";
       url: "url";
-      file: "file";
       slug: "slug";
       image: "image";
       datetime: "datetime";
@@ -1637,9 +1637,9 @@ declare const authMeActionBody: z.ZodObject<{
  * from `referenceCollection` + `referenceId` (a translation_group id).
  */
 declare const menuItemTypeEnum: z.ZodEnum<{
+  custom: "custom";
   collection: "collection";
   taxonomy: "taxonomy";
-  custom: "custom";
   page: "page";
   post: "post";
 }>;
@@ -1654,9 +1654,9 @@ declare const updateMenuBody: z.ZodObject<{
 }, z.core.$strict>;
 declare const createMenuItemBody: z.ZodObject<{
   type: z.ZodEnum<{
+    custom: "custom";
     collection: "collection";
     taxonomy: "taxonomy";
-    custom: "custom";
     page: "page";
     post: "post";
   }>;

package/dist/{byline-fields-DiCyW6eQ.mjs → byline-fields-Qg8TesxL.mjs}

@@ -1,4 +1,4 @@
-import { n as BylineSchemaRegistry, r as mapBylineSchemaError, t as BylineSchemaError } from "./byline-registry-rkr73qSE.mjs";
+import { n as BylineSchemaRegistry, r as mapBylineSchemaError, t as BylineSchemaError } from "./byline-registry-CkuVVeJJ.mjs";
 
 //#region src/api/handlers/byline-fields.ts
 function bylineSchemaErrorResult(error) {

package/dist/{byline-registry-rkr73qSE.mjs → byline-registry-CkuVVeJJ.mjs}

@@ -1,6 +1,6 @@
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { t as withTransaction } from "./transaction-BGQgnwUi.mjs";
-import { i as RESERVED_BYLINE_FIELD_SLUGS, t as BYLINE_FIELD_TYPES } from "./types-C0DPvhR5.mjs";
+import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
+import { i as RESERVED_BYLINE_FIELD_SLUGS, t as BYLINE_FIELD_TYPES } from "./types-CyBH89BS.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -63,36 +63,27 @@ var BylineSchemaRegistry = class {
 		this.validateLabel(input.label);
 		this.validateType(input.type);
 		const validation = this.normaliseValidation(input.type, input.validation ?? null);
-		if (await this.getField(input.slug)) {
-			await this.markVersionClean();
-			throw new BylineSchemaError(`Byline field "${input.slug}" already exists`, "FIELD_EXISTS", { slug: input.slug });
-		}
+		if (await this.getField(input.slug)) throw new BylineSchemaError(`Byline field "${input.slug}" already exists`, "FIELD_EXISTS", { slug: input.slug });
 		const id = ulid();
-		const sortOrder = input.sortOrder ?? await this.nextSortOrder();
-		await this.markVersionDirty();
-		await withTransaction(this.db, async (trx) => {
-			await trx.insertInto("_dineway_byline_fields").values({
-				id,
-				slug: input.slug,
-				label: input.label,
-				type: input.type,
-				required: input.required ? 1 : 0,
-				translatable: input.translatable === false ? 0 : 1,
-				validation: validation ? JSON.stringify(validation) : null,
-				sort_order: sortOrder
-			}).execute();
-		});
-		await this.markVersionClean();
+		const sortOrder = input.sortOrder ?? sql`(SELECT COALESCE(MAX(sort_order), -1) + 1 FROM _dineway_byline_fields)`;
+		await atomicBatch(this.db, { statements: [this.db.insertInto("_dineway_byline_fields").values({
+			id,
+			slug: input.slug,
+			label: input.label,
+			type: input.type,
+			required: input.required ? 1 : 0,
+			translatable: input.translatable === false ? 0 : 1,
+			validation: validation ? JSON.stringify(validation) : null,
+			sort_order: sortOrder
+		}).compile(), this.prepareVersionClean()] });
 		const created = await this.getFieldById(id);
 		if (!created) throw new BylineSchemaError("Failed to load created byline field", "FIELD_NOT_FOUND", { id });
 		return created;
 	}
 	async updateField(slug, input) {
-		const field = await this.getField(slug);
-		if (!field) {
-			await this.markVersionClean();
-			throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
-		}
+		const row = await this.db.selectFrom("_dineway_byline_fields").selectAll().where("slug", "=", slug).executeTakeFirst();
+		const field = row ? mapFieldRow(row) : null;
+		if (!row || !field) throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
 		const updates = {};
 		if (input.label !== void 0) {
 			this.validateLabel(input.label);
@@ -112,55 +103,49 @@ var BylineSchemaRegistry = class {
 			updates.translatable = input.translatable ? 1 : 0;
 		}
 		if (input.sortOrder !== void 0) updates.sort_order = input.sortOrder;
-		if (Object.keys(updates).length === 0) {
-			await this.markVersionClean();
-			return field;
-		}
+		if (Object.keys(updates).length === 0) return field;
 		updates.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-		await this.markVersionDirty();
-		await withTransaction(this.db, async (trx) => {
-			await trx.updateTable("_dineway_byline_fields").set(updates).where("id", "=", field.id).execute();
+		const checks = [rowUnchanged("_dineway_byline_fields", row)];
+		if (updates.translatable !== void 0) checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_byline_field_values WHERE field_id = ${field.id}) AND NOT EXISTS (SELECT 1 FROM _dineway_byline_field_group_values WHERE field_id = ${field.id})`);
+		await atomicBatch(this.db, {
+			checks,
+			statements: [this.db.updateTable("_dineway_byline_fields").set(updates).where("id", "=", field.id).compile(), this.prepareVersionClean()]
 		});
-		await this.markVersionClean();
 		const updated = await this.getFieldById(field.id);
 		if (!updated) throw new BylineSchemaError("Failed to load updated byline field", "FIELD_NOT_FOUND", { slug });
 		return updated;
 	}
 	async deleteField(slug) {
-		const field = await this.getField(slug);
-		if (!field) {
-			await this.markVersionClean();
-			throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
-		}
-		await this.markVersionDirty();
-		await withTransaction(this.db, async (trx) => {
-			await trx.deleteFrom("_dineway_byline_field_values").where("field_id", "=", field.id).execute();
-			await trx.deleteFrom("_dineway_byline_field_group_values").where("field_id", "=", field.id).execute();
-			await trx.deleteFrom("_dineway_byline_fields").where("id", "=", field.id).execute();
+		const row = await this.db.selectFrom("_dineway_byline_fields").selectAll().where("slug", "=", slug).executeTakeFirst();
+		const field = row ? mapFieldRow(row) : null;
+		if (!row || !field) throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
+		await atomicBatch(this.db, {
+			checks: [rowUnchanged("_dineway_byline_fields", row)],
+			statements: [
+				this.db.deleteFrom("_dineway_byline_field_values").where("field_id", "=", field.id).compile(),
+				this.db.deleteFrom("_dineway_byline_field_group_values").where("field_id", "=", field.id).compile(),
+				this.db.deleteFrom("_dineway_byline_fields").where("id", "=", field.id).compile(),
+				this.prepareVersionClean()
+			]
 		});
-		await this.markVersionClean();
 	}
 	async reorderFields(slugs) {
 		if (new Set(slugs).size !== slugs.length) throw new BylineSchemaError("Reorder input contains duplicate slugs", "REORDER_MISMATCH", { slugs });
-		const registeredSlugs = (await this.listFields()).map((field) => field.slug).toSorted();
+		const rows = await this.db.selectFrom("_dineway_byline_fields").selectAll().execute();
+		const registeredSlugs = rows.map(mapFieldRow).map((field) => field.slug).toSorted();
 		const inputSlugs = slugs.toSorted();
 		if (registeredSlugs.length !== inputSlugs.length || registeredSlugs.some((slug, index) => slug !== inputSlugs[index])) throw new BylineSchemaError("Reorder input does not match the registered byline field set", "REORDER_MISMATCH", {
 			registered: registeredSlugs,
 			input: inputSlugs
 		});
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		await this.markVersionDirty();
-		await withTransaction(this.db, async (trx) => {
-			for (let index = 0; index < slugs.length; index++) {
-				const slug = slugs[index];
-				if (slug === void 0) continue;
-				await trx.updateTable("_dineway_byline_fields").set({
-					sort_order: index,
-					updated_at: now
-				}).where("slug", "=", slug).execute();
-			}
+		await atomicBatch(this.db, {
+			checks: [sql`(SELECT COUNT(*) FROM _dineway_byline_fields) = ${rows.length}`, ...rows.map((row) => rowUnchanged("_dineway_byline_fields", row))],
+			statements: [...slugs.map((slug, index) => this.db.updateTable("_dineway_byline_fields").set({
+				sort_order: index,
+				updated_at: now
+			}).where("slug", "=", slug).compile()), this.prepareVersionClean()]
 		});
-		await this.markVersionClean();
 	}
 	async getFieldUsage(slug) {
 		const field = await this.getField(slug);
@@ -181,19 +166,8 @@ var BylineSchemaRegistry = class {
 		const parsed = Number.parseInt(row.value, 10);
 		return Number.isFinite(parsed) ? parsed : 0;
 	}
-	async markVersionDirty() {
-		await sql`
-			INSERT INTO options (name, value)
-			VALUES (${VERSION_KEY}, '1')
-			ON CONFLICT(name) DO UPDATE SET value = CASE
-				WHEN CAST(options.value AS INTEGER) % 2 = 0
-					THEN CAST(CAST(options.value AS INTEGER) + 1 AS TEXT)
-				ELSE options.value
-			END
-		`.execute(this.db);
-	}
-	async markVersionClean() {
-		await sql`
+	prepareVersionClean() {
+		return sql`
 			INSERT INTO options (name, value)
 			VALUES (${VERSION_KEY}, '2')
 			ON CONFLICT(name) DO UPDATE SET value = CASE
@@ -201,11 +175,7 @@ var BylineSchemaRegistry = class {
 					THEN CAST(CAST(options.value AS INTEGER) + 2 AS TEXT)
 				ELSE CAST(CAST(options.value AS INTEGER) + 1 AS TEXT)
 			END
-		`.execute(this.db);
-	}
-	async nextSortOrder() {
-		const row = await this.db.selectFrom("_dineway_byline_fields").select(({ fn }) => [fn.max("sort_order").as("max")]).executeTakeFirst();
-		return row?.max == null ? 0 : row.max + 1;
+		`.compile(this.db);
 	}
 	async countFieldValues(fieldId) {
 		const translatable = await this.db.selectFrom("_dineway_byline_field_values").select(({ fn }) => [fn.count("field_id").as("count")]).where("field_id", "=", fieldId).executeTakeFirst();