dineway 0.2.32 → 0.2.34

package/dist/{context-JjKucxBm.mjs → context-B0SG9Xkc.mjs}

@@ -1,5 +1,5 @@
-import { _ as toPublicContextDiff, v as toPublicContextEntry, y as toPublicContextEntryPage } from "./site-context-CA7rbxux.mjs";
-import { i as parseSiteBriefingScope, n as SiteBriefingError, o as ContextRepository } from "./briefing-BgQTljQt.mjs";
+import { _ as toPublicContextDiff, v as toPublicContextEntry, y as toPublicContextEntryPage } from "./site-context-vCiDRr4H.mjs";
+import { d as ContextRepository, i as parseSiteBriefingScope, n as SiteBriefingError } from "./briefing-CkCi6S-W.mjs";
 
 //#region src/api/handlers/context.ts
 async function handleContextEntryList(db, input = {}) {

package/dist/{context-route-helpers-e1APrqSm.mjs → context-route-helpers-C8s26uDT.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-D-yGV7cW.mjs";
 
 //#region src/api/context-route-helpers.ts
 function resolveContextRouteActor(locals) {

package/dist/{cron-mGVPQ5e6.mjs → cron-D7zB6m8i.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-B1b8cmxX.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-B-OybCMw.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-NobcQti0.mjs";
+import { t as MediaRepository } from "./media-3fK0u-bo.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,20 @@
+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[];
+}
+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, rowUnchanged };

package/dist/database/batch.mjs

@@ -0,0 +1,69 @@
+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
+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 = [];
+			for (const statement of batch.statements) results.push(await transaction.executeQuery(statement));
+			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, rowUnchanged };

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

@@ -0,0 +1,18 @@
+import { At as ResolvedPlugin, ac as compileD1Schema, ec as D1Migration, ic as D1SchemaObject, nc as assertD1Migrations, rc as migrateD1, tc as D1MigrationOptions } from "../../types-QjOcidFc.mjs";
+import "../../types-7Th6Mwz3.mjs";
+import "../../runner-JnJSGXEB.mjs";
+import "../../index-CSUSBfdD.mjs";
+import "../../types-DkXuBo8k.mjs";
+import "../../public-url-BV-YQ_LF.mjs";
+import "../../validate-A27peRc4.mjs";
+import "../../byline-fields-BmkhEDFF.mjs";
+import "../../types-DTjrkhKU.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-CMdxWKx-.mjs";
+import "../../state-jyNZ6-7L.mjs";
+import { n as compileD1Schema, t as migrateD1Release } from "../../release-BR08Slqf.mjs";
+
+export { assertD1Migrations, compileD1Schema, migrateD1, migrateD1Release };

package/dist/db/d1.d.mts

@@ -0,0 +1,7 @@
+import { t as D1Config } from "../adapters-BQ8CQbBm.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-B1b8cmxX.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-7Th6Mwz3.mjs";
+import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-JnJSGXEB.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-BQ8CQbBm.mjs";
+export { type D1Config, type DatabaseDescriptor, type DatabaseDialectType, type LibsqlConfig, type MigrationStatus, type PostgresConfig, type SqliteConfig, d1, getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };

package/dist/db/index.mjs

@@ -1,5 +1,6 @@
-import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration } from "../runner-DJiRFyLI.mjs";
-import "../dialect-helpers-fk43GbDb.mjs";
+import { a as runMigrations, i as rollbackMigration, r as getMigrationStatus } from "../runner-CVeq0266.mjs";
+import "../d1-binding-D6HZa3ks.mjs";
+import "../dialect-helpers-C6xtO-Ui.mjs";
 
 //#region src/db/adapters.ts
 /**
@@ -40,11 +41,13 @@ function libsql(config) {
 		type: "sqlite"
 	};
 }
-/** Remote libSQL over HTTP, suitable for Cloudflare Workers and ChatGPT Sites. */
-function libsqlHttp(config = {}) {
+const BINDING_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Cloudflare D1 binding. Schema migrations run explicitly before deployment. */
+function d1(config = { binding: "DB" }) {
+	if (!BINDING_NAME.test(config.binding)) throw new Error("D1 binding must be a valid identifier.");
 	return {
-		entrypoint: "dineway/db/libsql-http",
-		config,
+		entrypoint: "dineway/db/d1",
+		config: { binding: config.binding },
 		type: "sqlite"
 	};
 }
@@ -67,4 +70,4 @@ function postgres(config) {
 }
 
 //#endregion
-export { getMigrationStatus, libsql, libsqlHttp, postgres, rollbackMigration, runMigrations, sqlite };
+export { d1, getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };

package/dist/db/libsql.d.mts

@@ -1,4 +1,4 @@
-import { r as LibsqlConfig } from "../adapters-DHt3f2lu.mjs";
+import { i as LibsqlConfig } from "../adapters-BQ8CQbBm.mjs";
 import { Dialect } from "kysely";
 
 //#region src/db/libsql.d.ts

package/dist/db/libsql.mjs

@@ -1,7 +1,50 @@
-import { t as LibsqlDialect } from "../libsql-dialect-CANq6UNI.mjs";
-import { SqliteDialect } from "kysely";
+import { SqliteAdapter, SqliteDialect } from "kysely";
 import BetterSqlite3 from "better-sqlite3";
+import { LibsqlDialect } from "@libsql/kysely-libsql";
 
+//#region src/db/libsql-dialect.ts
+const MIGRATION_LOCK_LEASE_MS = 5 * 6e4;
+const MIGRATION_LOCK_WAIT_MS = 3e4;
+const MIGRATION_LOCK_POLL_MS = 50;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var LibsqlMigrationLockAdapter = class extends SqliteAdapter {
+	#claims = /* @__PURE__ */ new Map();
+	async acquireMigrationLock(db, options) {
+		const queryDb = options.lockTableSchema ? db.withSchema(options.lockTableSchema) : db;
+		const claimKey = `${options.lockTableSchema ?? ""}.${options.lockTable}:${options.lockRowId}`;
+		const waitDeadline = Date.now() + MIGRATION_LOCK_WAIT_MS;
+		for (;;) {
+			const now = Date.now();
+			const claim = now + MIGRATION_LOCK_LEASE_MS;
+			if ((await queryDb.updateTable(options.lockTable).set({ is_locked: claim }).where("id", "=", options.lockRowId).where((expression) => expression.or([expression("is_locked", "=", 0), expression("is_locked", "<=", now)])).executeTakeFirst()).numUpdatedRows === 1n) {
+				this.#claims.set(claimKey, claim);
+				return;
+			}
+			if (now >= waitDeadline) throw new Error("Timed out waiting for the libSQL migration lock");
+			await sleep(MIGRATION_LOCK_POLL_MS);
+		}
+	}
+	async releaseMigrationLock(db, options) {
+		const claimKey = `${options.lockTableSchema ?? ""}.${options.lockTable}:${options.lockRowId}`;
+		const claim = this.#claims.get(claimKey);
+		if (claim === void 0) return;
+		const queryDb = options.lockTableSchema ? db.withSchema(options.lockTableSchema) : db;
+		try {
+			await queryDb.updateTable(options.lockTable).set({ is_locked: 0 }).where("id", "=", options.lockRowId).where("is_locked", "=", claim).execute();
+		} finally {
+			this.#claims.delete(claimKey);
+		}
+	}
+};
+var LibsqlDialect$1 = class extends LibsqlDialect {
+	createAdapter() {
+		return new LibsqlMigrationLockAdapter();
+	}
+};
+
+//#endregion
 //#region src/db/libsql.ts
 /**
 * libSQL runtime adapter
@@ -17,7 +60,7 @@ import BetterSqlite3 from "better-sqlite3";
 */
 function createDialect(config) {
 	if (config.url === ":memory:" || config.url.startsWith("file:")) return new SqliteDialect({ database: new BetterSqlite3(config.url === ":memory:" ? config.url : config.url.slice(5)) });
-	return new LibsqlDialect({
+	return new LibsqlDialect$1({
 		url: config.url,
 		authToken: config.authToken
 	});

package/dist/db/postgres.d.mts

@@ -1,4 +1,4 @@
-import { a as PostgresConfig } from "../adapters-DHt3f2lu.mjs";
+import { a as PostgresConfig } from "../adapters-BQ8CQbBm.mjs";
 import { PostgresDialect } from "kysely";
 
 //#region src/db/postgres.d.ts

package/dist/db/sqlite.d.mts

@@ -1,4 +1,4 @@
-import { o as SqliteConfig } from "../adapters-DHt3f2lu.mjs";
+import { o as SqliteConfig } from "../adapters-BQ8CQbBm.mjs";
 import { Dialect } from "kysely";
 
 //#region src/db/sqlite.d.ts