dineway 0.2.33 → 0.2.35

package/dist/{context-MftkHbWx.mjs → context-C5lPtfeh.mjs}

@@ -1,16 +1,18 @@
-import { n as validateJsonFieldName } from "./validate-VPnKoIzW.mjs";
-import { c as jsonExtractExpr } from "./dialect-helpers-fk43GbDb.mjs";
-import { i as encodeCursor, r as decodeCursor } from "./types-BpSTdH1H.mjs";
-import { t as ContentRepository } from "./content-CVCrcuvD.mjs";
-import { t as MediaRepository } from "./media-dvRjj4po.mjs";
-import { t as UserRepository } from "./user-D0NJ7gYf.mjs";
-import { t as OptionsRepository } from "./options-1dBRkoCl.mjs";
-import { t as withTransaction } from "./transaction-BGQgnwUi.mjs";
-import { t as enrichImageMetadata } from "./enrich-KErvJOuI.mjs";
-import { t as SeoRepository } from "./seo-DWHdo5aW.mjs";
-import { a as markContentMediaUsageCollectionStaleSafely } from "./content-refresh-QvBIyb_g.mjs";
-import { a as validateExternalUrl, i as stripCredentialHeaders, t as SsrfError } from "./ssrf-C7tTSD1r.mjs";
-import { t as CronAccessImpl } from "./cron-mGVPQ5e6.mjs";
+import { atomicBatch } from "./database/batch.mjs";
+import { n as validateJsonFieldName } from "./validate-Co3j6T_K.mjs";
+import { c as jsonExtractExpr } from "./dialect-helpers-C6xtO-Ui.mjs";
+import { i as encodeCursor, r as decodeCursor } 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 ContentRepository } from "./content-D9xKUSno.mjs";
+import { t as MediaRepository } from "./media-BZqwtRTZ.mjs";
+import { t as UserRepository } from "./user-1-YV30lf.mjs";
+import { t as OptionsRepository } from "./options-BcqHWpc-.mjs";
+import { t as enrichImageMetadata } from "./enrich-BjF-J4sF.mjs";
+import { t as SeoRepository } from "./seo-DYpc_rQ1.mjs";
+import { o as prepareContentMediaUsageCollectionStale } from "./content-refresh-9M9cc55-.mjs";
+import { a as validateExternalUrl, i as stripCredentialHeaders, t as SsrfError } from "./ssrf-COxLChKv.mjs";
+import { t as CronAccessImpl } from "./cron-BVYo08mi.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -223,26 +225,24 @@ var PluginStorageRepository = class {
 	async putMany(items) {
 		if (items.length === 0) return;
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		await withTransaction(this.db, async (trx) => {
-			for (const item of items) {
-				const jsonData = JSON.stringify(item.data);
-				await trx.insertInto("_plugin_storage").values({
-					plugin_id: this.pluginId,
-					collection: this.collection,
-					id: item.id,
-					data: jsonData,
-					created_at: now,
-					updated_at: now
-				}).onConflict((oc) => oc.columns([
-					"plugin_id",
-					"collection",
-					"id"
-				]).doUpdateSet({
-					data: jsonData,
-					updated_at: now
-				})).execute();
-			}
-		});
+		await atomicBatch(this.db, { statements: items.map((item) => {
+			const jsonData = JSON.stringify(item.data);
+			return this.db.insertInto("_plugin_storage").values({
+				plugin_id: this.pluginId,
+				collection: this.collection,
+				id: item.id,
+				data: jsonData,
+				created_at: now,
+				updated_at: now
+			}).onConflict((oc) => oc.columns([
+				"plugin_id",
+				"collection",
+				"id"
+			]).doUpdateSet({
+				data: jsonData,
+				updated_at: now
+			})).compile();
+		}) });
 	}
 	/**
 	* Delete multiple documents
@@ -330,6 +330,12 @@ var PluginStorageRepository = class {
 //#endregion
 //#region src/plugins/context.ts
 /**
+* Plugin Context v2
+*
+* Creates the unified context object provided to plugins in all hooks and routes.
+*
+*/
+/**
 * Create KV accessor for a plugin
 * All keys are automatically prefixed with the plugin ID
 */
@@ -488,58 +494,70 @@ function createContentAccessWithWrite(db) {
 		...createContentAccess(db),
 		async create(collection, data) {
 			const { fields, seo } = splitSeoFromInput(data);
-			let contentMutated = false;
-			try {
-				const created = await withTransaction(db, async (trx) => {
-					const trxContentRepo = new ContentRepository(trx);
-					const trxSeoRepo = new SeoRepository(trx);
-					const hasSeo = await assertSeoEnabled(trxSeoRepo, collection, seo);
-					const item = await trxContentRepo.create({
-						type: collection,
-						data: fields
-					});
-					contentMutated = true;
-					const result = toPluginContentItem(item);
-					if (hasSeo) result.seo = seo !== void 0 ? await trxSeoRepo.upsert(collection, item.id, seo) : await trxSeoRepo.get(collection, item.id);
-					return result;
-				});
-				await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
-				return created;
-			} catch (error) {
-				if (contentMutated) await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
-				throw error;
+			const repo = new ContentRepository(db);
+			const seoRepo = new SeoRepository(db);
+			const hasSeo = await assertSeoEnabled(seoRepo, collection, seo);
+			const prepared = await repo.prepareCreate({
+				type: collection,
+				data: fields
+			});
+			const statements = [...prepared.batch.statements];
+			if (hasSeo && seo !== void 0) {
+				const write = seoRepo.prepareUpsert(collection, prepared.id, seo);
+				if (write) statements.push(write);
 			}
+			statements.push(prepareContentMediaUsageCollectionStale(db, collection, "CONTENT_USAGE_STALE"));
+			await atomicBatch(db, {
+				checks: [...prepared.batch.checks ?? [], sql`COALESCE((SELECT has_seo FROM _dineway_collections WHERE slug = ${collection}), 0) = ${hasSeo ? 1 : 0}`],
+				statements
+			});
+			invalidateCollectionCache(collection);
+			const item = await repo.findById(collection, prepared.id);
+			if (!item) throw new Error("Content not found");
+			const result = toPluginContentItem(item);
+			if (hasSeo) result.seo = await seoRepo.get(collection, item.id);
+			return result;
 		},
 		async update(collection, id, data) {
 			const { fields, seo } = splitSeoFromInput(data);
 			const hasFieldUpdates = Object.keys(fields).length > 0;
-			let contentMutated = false;
-			try {
-				const updated = await withTransaction(db, async (trx) => {
-					const trxContentRepo = new ContentRepository(trx);
-					const trxSeoRepo = new SeoRepository(trx);
-					const hasSeo = await assertSeoEnabled(trxSeoRepo, collection, seo);
-					const item = hasFieldUpdates ? await trxContentRepo.update(collection, id, { data: fields }) : await (async () => {
-						const existing = await trxContentRepo.findById(collection, id);
-						if (!existing) throw new Error("Content not found");
-						return existing;
-					})();
-					if (hasFieldUpdates) contentMutated = true;
-					const result = toPluginContentItem(item);
-					if (hasSeo) result.seo = seo !== void 0 ? await trxSeoRepo.upsert(collection, item.id, seo) : await trxSeoRepo.get(collection, item.id);
-					return result;
-				});
-				if (hasFieldUpdates) await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
-				return updated;
-			} catch (error) {
-				if (contentMutated) await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
-				throw error;
+			const repo = new ContentRepository(db);
+			const seoRepo = new SeoRepository(db);
+			const hasSeo = await assertSeoEnabled(seoRepo, collection, seo);
+			const snapshot = await repo.snapshot(collection, id);
+			if (!snapshot) throw new Error("Content not found");
+			const statements = hasFieldUpdates ? [repo.prepareUpdate(collection, id, { data: fields })] : [];
+			if (hasSeo && seo !== void 0) {
+				const write = seoRepo.prepareUpsert(collection, id, seo);
+				if (write) statements.push(write);
 			}
+			if (hasFieldUpdates) statements.push(prepareContentMediaUsageCollectionStale(db, collection, "CONTENT_USAGE_STALE"));
+			await atomicBatch(db, {
+				checks: [
+					snapshot.check,
+					...contentWriteChecks(collection, id, "edit"),
+					sql`COALESCE((SELECT has_seo FROM _dineway_collections WHERE slug = ${collection}), 0) = ${hasSeo ? 1 : 0}`
+				],
+				statements
+			});
+			invalidateCollectionCache(collection);
+			const item = await repo.findById(collection, id);
+			if (!item) throw new Error("Content not found");
+			const result = toPluginContentItem(item);
+			if (hasSeo) result.seo = await seoRepo.get(collection, id);
+			return result;
 		},
 		async delete(collection, id) {
-			const deleted = await new ContentRepository(db).delete(collection, id);
-			if (deleted) await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
-			return deleted;
+			const repo = new ContentRepository(db);
+			const snapshot = await repo.snapshot(collection, id);
+			if (!snapshot) return false;
+			const prepared = repo.prepareDelete(collection, id);
+			const [result] = await atomicBatch(db, {
+				checks: [snapshot.check, ...prepared.checks ?? []],
+				statements: [...prepared.statements, prepareContentMediaUsageCollectionStale(db, collection, "CONTENT_USAGE_STALE")]
+			});
+			invalidateCollectionCache(collection);
+			return (result?.numAffectedRows ?? 0n) > 0n;
 		}
 	};
 }

package/dist/{context-route-helpers-e1APrqSm.mjs → context-route-helpers-CWAHJFl3.mjs}

@@ -1,5 +1,5 @@
-import { n as resolveActorIdentity } from "./actor-DrJJsvy6.mjs";
-import { p as logSiteActivitySafely } from "./activity-events-BVo9rMUz.mjs";
+import { i as resolveActorIdentity } from "./actor-DxUAJgQX.mjs";
+import { p as logSiteActivitySafely } from "./activity-events-CiFN61xq.mjs";
 
 //#region src/api/context-route-helpers.ts
 function resolveContextRouteActor(locals) {

package/dist/{cron-mGVPQ5e6.mjs → cron-BVYo08mi.mjs}

@@ -38,22 +38,26 @@ var CronExecutor = class {
 	* 4. On failure: reset to idle (retry on next tick).
 	*/
 	async tick() {
-		const now = (/* @__PURE__ */ new Date()).toISOString();
 		let processed = 0;
-		const claimed = await sql`
+		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}
-			WHERE id IN (
+			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 10
+				LIMIT 1
 			)
 			RETURNING id, plugin_id, task_name, schedule, is_oneshot, data, next_run_at
-		`.execute(this.db);
-		for (const task of claimed.rows) {
+		`.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);
@@ -61,12 +65,13 @@ var CronExecutor = class {
 				console.error(`[cron] Invalid JSON data for ${task.plugin_id}:${task.task_name}, skipping`);
 				await sql`
 						UPDATE _dineway_cron_tasks
-						SET status = 'idle', locked_at = NULL
-						WHERE id = ${task.id}
+						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
@@ -83,35 +88,37 @@ var CronExecutor = class {
 				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, removing`);
+					console.error(`[cron] One-shot task ${task.plugin_id}:${task.task_name} exceeded ${MAX_ONESHOT_RETRIES} retries, retaining failed task`);
 					await sql`
-							DELETE FROM _dineway_cron_tasks WHERE id = ${task.id}
+							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, next_run_at = ${new Date(Date.now() + backoffMs).toISOString()}, data = ${JSON.stringify({
+						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 id = ${task.id}
+						WHERE ${ownedOccurrence}
 					`.execute(this.db);
 				}
 			} else await sql`
-						DELETE FROM _dineway_cron_tasks WHERE id = ${task.id}
+						DELETE FROM _dineway_cron_tasks WHERE ${ownedOccurrence}
 					`.execute(this.db);
 			else await sql`
 					UPDATE _dineway_cron_tasks
 					SET status = 'idle',
-						locked_at = NULL,
+						locked_at = NULL, lease_token = NULL,
 						last_run_at = ${now},
 						next_run_at = ${nextCronTime(task.schedule)}
-					WHERE id = ${task.id}
+					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;
@@ -123,7 +130,7 @@ var CronExecutor = class {
 	async recoverStaleLocks() {
 		const result = await sql`
 			UPDATE _dineway_cron_tasks
-			SET status = 'idle', locked_at = NULL
+			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);
@@ -155,18 +162,20 @@ var CronAccessImpl = class {
 		validateTaskName(name);
 		validateSchedule(opts.schedule);
 		const oneshot = isOneShot(opts.schedule);
-		const nextRun = oneshot ? opts.schedule : nextCronTime(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}, ${opts.schedule}, ${oneshot ? 1 : 0}, ${dataJson}, ${nextRun}, 'idle', 1)
+			VALUES (${ulid()}, ${this.pluginId}, ${name}, ${schedule}, ${oneshot ? 1 : 0}, ${dataJson}, ${nextRun}, 'idle', 1)
 			ON CONFLICT (plugin_id, task_name) DO UPDATE SET
-				schedule = ${opts.schedule},
+				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();
@@ -180,12 +189,13 @@ var CronAccessImpl = class {
 	}
 	async list() {
 		return (await sql`
-			SELECT task_name, schedule, next_run_at, last_run_at
+			SELECT task_name, schedule, next_run_at, last_run_at, status
 			FROM _dineway_cron_tasks
-			WHERE plugin_id = ${this.pluginId} AND enabled = 1
+			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
@@ -227,17 +237,11 @@ function isCronExpression(schedule) {
 		return false;
 	}
 }
-/**
-* Check if a schedule string is a one-shot (ISO 8601 datetime) rather than
-* a recurring cron expression.
-*
-* Tries to parse as a cron expression first. Only if that fails does it
-* attempt Date.parse. This avoids misclassifying cron range expressions
-* like "1-5 * * * *" which Date.parse accepts as valid dates.
-*/
+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 (schedule.startsWith("@")) return false;
-	if (isCronExpression(schedule)) return false;
+	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 */

package/dist/d1-binding-D6HZa3ks.mjs

@@ -0,0 +1,8 @@
+//#region src/db/d1-binding.ts
+const D1_BINDING = Symbol.for("dineway:database:d1");
+function d1Database(db) {
+	return Reflect.get(db.getExecutor().adapter, D1_BINDING);
+}
+
+//#endregion
+export { d1Database as n, D1_BINDING as t };

package/dist/d1-dialect-BBxPg6Om.mjs

@@ -0,0 +1,48 @@
+import { t as D1_BINDING } from "./d1-binding-D6HZa3ks.mjs";
+import { OperationNodeTransformer, SqliteAdapter, SqliteIntrospector, TableNode, WhereNode, sql } from "kysely";
+import { D1Dialect } from "kysely-d1";
+
+//#region src/db/d1-dialect.ts
+var DinewayD1Adapter = class extends SqliteAdapter {
+	[D1_BINDING];
+	constructor(database) {
+		super();
+		this[D1_BINDING] = database;
+	}
+	async acquireMigrationLock() {
+		throw new Error("D1 schema changes require the explicit Dineway migration runner.");
+	}
+};
+var DinewayD1Dialect = class extends D1Dialect {
+	constructor(binding) {
+		super({ database: binding });
+		this.binding = binding;
+	}
+	createAdapter() {
+		return new DinewayD1Adapter(this.binding);
+	}
+	createIntrospector(db) {
+		const transformer = new D1IntrospectionFilter();
+		return new SqliteIntrospector(db.withPlugin({
+			transformQuery: ({ node }) => transformer.transformNode(node),
+			transformResult: async ({ result }) => result
+		}));
+	}
+};
+var D1IntrospectionFilter = class extends OperationNodeTransformer {
+	transformSelectQuery(node) {
+		const select = super.transformSelectQuery(node);
+		if (!select.from?.froms.some((from) => TableNode.is(from) && from.table.identifier.name === "sqlite_master")) return select;
+		const filter = sql`name NOT GLOB '_cf_*'`.toOperationNode();
+		return {
+			...select,
+			where: select.where ? WhereNode.cloneWithOperation(select.where, "And", filter) : WhereNode.create(filter)
+		};
+	}
+};
+function createD1Dialect(database) {
+	return new DinewayD1Dialect(database);
+}
+
+//#endregion
+export { createD1Dialect as t };

package/dist/{dashboard-ZJ7sMcBI.mjs → dashboard-BnD5krLg.mjs}

@@ -1,8 +1,8 @@
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { t as ContentRepository } from "./content-CVCrcuvD.mjs";
-import { t as MediaRepository } from "./media-dvRjj4po.mjs";
-import { t as UserRepository } from "./user-D0NJ7gYf.mjs";
-import { n as ReviewRequestRepository } from "./review-requests-DICrYH2-.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
+import { t as ContentRepository } from "./content-D9xKUSno.mjs";
+import { t as MediaRepository } from "./media-BZqwtRTZ.mjs";
+import { t as UserRepository } from "./user-1-YV30lf.mjs";
+import { r as ReviewRequestRepository } from "./review-requests-BF2eEKr8.mjs";
 import { sql } from "kysely";
 
 //#region src/api/handlers/dashboard.ts

package/dist/database/batch.d.mts

@@ -0,0 +1,22 @@
+import { CompiledQuery, Kysely, QueryResult, RawBuilder } from "kysely";
+
+//#region src/database/batch.d.ts
+interface AtomicBatch {
+  /** Conditions evaluated inside the same transaction as all writes. */
+  checks?: readonly RawBuilder<boolean>[];
+  statements: readonly CompiledQuery[];
+}
+/** Place checks between composed writes while retaining native Node transactions. */
+declare function prepareAtomicChecks<DB>(db: Kysely<DB>, checks: readonly RawBuilder<boolean>[]): CompiledQuery[];
+declare class AtomicWriteConflict extends Error {
+  constructor();
+}
+declare function isD1Database<DB>(db: Kysely<DB>): boolean;
+/** Guard a read used to prepare writes; pass the original database row, including its key. */
+declare function rowUnchanged(table: string, row: Record<string, unknown>): RawBuilder<boolean>;
+/** Called during explicit schema installation, never during a user write. */
+declare function ensureAtomicBatchSchema<DB>(db: Kysely<DB>): Promise<void>;
+/** Executes precompiled writes once; conflicts and unknown commit outcomes are never replayed. */
+declare function atomicBatch<DB>(db: Kysely<DB>, batch: AtomicBatch): Promise<QueryResult<unknown>[]>;
+//#endregion
+export { AtomicBatch, AtomicWriteConflict, atomicBatch, ensureAtomicBatchSchema, isD1Database, prepareAtomicChecks, rowUnchanged };

package/dist/database/batch.mjs

@@ -0,0 +1,92 @@
+import { n as d1Database } from "../d1-binding-D6HZa3ks.mjs";
+import { getRequestContext } from "../request-context.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/database/batch.ts
+const inlineChecks = /* @__PURE__ */ new WeakMap();
+/** Place checks between composed writes while retaining native Node transactions. */
+function prepareAtomicChecks(db, checks) {
+	return checks.flatMap((check) => {
+		const id = ulid();
+		const assertion = sql`INSERT INTO _dineway_atomic_guards(id,ok) VALUES(${id},CASE WHEN ${check} THEN 1 ELSE 0 END)`.compile(db);
+		const cleanup = sql`DELETE FROM _dineway_atomic_guards WHERE id=${id}`.compile(db);
+		inlineChecks.set(assertion, check);
+		inlineChecks.set(cleanup, null);
+		return [assertion, cleanup];
+	});
+}
+var AtomicWriteConflict = class extends Error {
+	constructor() {
+		super("Atomic write precondition failed");
+		this.name = "AtomicWriteConflict";
+	}
+};
+function isD1Database(db) {
+	return d1Database(db) !== void 0;
+}
+/** Guard a read used to prepare writes; pass the original database row, including its key. */
+function rowUnchanged(table, row) {
+	const entries = Object.entries(row);
+	if (!entries.length) throw new Error("An atomic row check requires a nonempty database row.");
+	return sql`EXISTS (SELECT 1 FROM ${sql.table(table)} WHERE ${sql.join(entries.map(([column, value]) => sql`${sql.ref(column)} IS NOT DISTINCT FROM ${value}`), sql` AND `)})`;
+}
+/** Called during explicit schema installation, never during a user write. */
+async function ensureAtomicBatchSchema(db) {
+	await sql`CREATE TABLE IF NOT EXISTS _dineway_atomic_guards (
+		id TEXT PRIMARY KEY,
+		ok INTEGER NOT NULL CONSTRAINT dineway_atomic_precondition CHECK (ok = 1)
+	)`.execute(db);
+}
+function assertQueryLimits(query) {
+	if (query.parameters.length > 100) throw new Error("D1 statements support at most 100 bound parameters.");
+	if (new TextEncoder().encode(query.sql).length > 1e5) throw new Error("D1 statements must not exceed 100 KB.");
+}
+/** Executes precompiled writes once; conflicts and unknown commit outcomes are never replayed. */
+async function atomicBatch(db, batch) {
+	if (!batch.statements.length && !batch.checks?.length) return [];
+	const checks = [...await getRequestContext()?.prepareWriteChecks?.(db) ?? [], ...batch.checks ?? []];
+	const binding = d1Database(db);
+	if (!binding) {
+		const execute = async (transaction) => {
+			for (const check of checks) if ((await sql`SELECT CASE WHEN ${check} THEN 1 ELSE 0 END AS ok`.execute(transaction)).rows[0]?.ok !== 1) throw new AtomicWriteConflict();
+			const results = [];
+			try {
+				for (const statement of batch.statements) if (inlineChecks.has(statement)) {
+					const check = inlineChecks.get(statement);
+					if (check) {
+						if ((await sql`SELECT CASE WHEN ${check} THEN 1 ELSE 0 END AS ok`.execute(transaction)).rows[0]?.ok !== 1) throw new AtomicWriteConflict();
+					}
+					results.push({ rows: [] });
+				} else results.push(await transaction.executeQuery(statement));
+			} catch (error) {
+				if (error instanceof Error && `${error.message} ${String(error.cause)}`.includes("dineway_atomic_precondition")) throw new AtomicWriteConflict();
+				throw error;
+			}
+			return results;
+		};
+		return db.isTransaction ? execute(db) : db.transaction().execute(execute);
+	}
+	const id = ulid();
+	const statements = checks.length ? [
+		...checks.map((check, index) => sql`INSERT INTO _dineway_atomic_guards (id, ok) VALUES (${sql.lit(`${id}:${index}`)}, CASE WHEN ${check} THEN 1 ELSE 0 END)`.compile(db)),
+		...batch.statements,
+		sql`DELETE FROM _dineway_atomic_guards WHERE id GLOB ${`${id}:*`}`.compile(db)
+	] : [...batch.statements];
+	if (!statements.length) return [];
+	for (const statement of statements) assertQueryLimits(statement);
+	try {
+		const results = await binding.batch(statements.map((statement) => binding.prepare(statement.sql).bind(...statement.parameters)));
+		return (checks.length ? results.slice(checks.length, -1) : results).map((result) => ({
+			rows: result.results,
+			numAffectedRows: BigInt(result.meta.changes),
+			insertId: BigInt(result.meta.last_row_id)
+		}));
+	} catch (error) {
+		if (error instanceof Error && `${error.message} ${String(error.cause)}`.includes("dineway_atomic_precondition")) throw new AtomicWriteConflict();
+		throw error;
+	}
+}
+
+//#endregion
+export { AtomicWriteConflict, atomicBatch, ensureAtomicBatchSchema, isD1Database, prepareAtomicChecks, rowUnchanged };

package/dist/database/d1/index.d.mts

@@ -0,0 +1,18 @@
+import { At as ResolvedPlugin, ac as D1Migration, cc as migrateD1, lc as D1SchemaObject, oc as D1MigrationOptions, sc as assertD1Migrations, uc as compileD1Schema } from "../../types-Tt_IGMno.mjs";
+import "../../types-CVRNRAA5.mjs";
+import "../../runner-Cxl-vyk2.mjs";
+import "../../index-mlJSqFkG.mjs";
+import "../../types-SddyDti7.mjs";
+import "../../public-url-zoO-QbN6.mjs";
+import "../../validate-CCOsvPg2.mjs";
+import "../../byline-fields-BO96fXLv.mjs";
+import "../../types-CAD4OvmF.mjs";
+import { Kysely } from "kysely";
+
+//#region src/database/d1/release.d.ts
+/** Explicit maintenance entry point. A failed release stays unavailable until a successful retry. */
+declare function migrateD1Release<DB>(db: Kysely<DB>, plugins: readonly ResolvedPlugin[], options?: {
+  adopt?: boolean;
+}): Promise<Record<string, string[]>>;
+//#endregion
+export { type D1Migration, type D1MigrationOptions, type D1SchemaObject, assertD1Migrations, compileD1Schema, migrateD1, migrateD1Release };

package/dist/database/d1/index.mjs

@@ -0,0 +1,8 @@
+import { o as assertD1Migrations, s as migrateD1 } from "../../runner-CVeq0266.mjs";
+import "../../d1-binding-D6HZa3ks.mjs";
+import "../../dialect-helpers-C6xtO-Ui.mjs";
+import "../../migrations-C7YXse7V.mjs";
+import "../../state-D8AogXCV.mjs";
+import { n as compileD1Schema, t as migrateD1Release } from "../../release-CZfAeyXm.mjs";
+
+export { assertD1Migrations, compileD1Schema, migrateD1, migrateD1Release };

package/dist/db/d1.d.mts

@@ -0,0 +1,7 @@
+import { t as D1Config } from "../adapters-Rol-inz6.mjs";
+import { Dialect } from "kysely";
+
+//#region src/db/d1.d.ts
+declare function createDialect(config: D1Config): Dialect;
+//#endregion
+export { createDialect };

package/dist/db/d1.mjs

@@ -0,0 +1,13 @@
+import "../d1-binding-D6HZa3ks.mjs";
+import { t as createD1Dialect } from "../d1-dialect-BBxPg6Om.mjs";
+import { env } from "cloudflare:workers";
+
+//#region src/db/d1.ts
+function createDialect(config) {
+	const binding = Reflect.get(env, config.binding);
+	if (!binding || typeof binding !== "object" || !("prepare" in binding) || !("batch" in binding)) throw new Error(`Missing D1 database binding: ${config.binding}`);
+	return createD1Dialect(binding);
+}
+
+//#endregion
+export { createDialect };

package/dist/db/index.d.mts

@@ -1,4 +1,4 @@
-import "../types-BRCUO8NR.mjs";
-import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-Dye73myO.mjs";
-import { a as PostgresConfig, c as libsqlHttp, i as LibsqlHttpConfig, l as postgres, n as DatabaseDialectType, o as SqliteConfig, r as LibsqlConfig, s as libsql, t as DatabaseDescriptor, u as sqlite } from "../adapters-DHt3f2lu.mjs";
-export { type DatabaseDescriptor, type DatabaseDialectType, type LibsqlConfig, type LibsqlHttpConfig, type MigrationStatus, type PostgresConfig, type SqliteConfig, getMigrationStatus, libsql, libsqlHttp, postgres, rollbackMigration, runMigrations, sqlite };
+import "../types-CVRNRAA5.mjs";
+import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-Cxl-vyk2.mjs";
+import { a as PostgresConfig, c as libsql, i as LibsqlConfig, l as postgres, n as DatabaseDescriptor, o as SqliteConfig, r as DatabaseDialectType, s as d1, t as D1Config, u as sqlite } from "../adapters-Rol-inz6.mjs";
+export { type D1Config, type DatabaseDescriptor, type DatabaseDialectType, type LibsqlConfig, type MigrationStatus, type PostgresConfig, type SqliteConfig, d1, getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };