dineway 0.1.9 → 0.1.12

package/dist/context-DNfcm853.mjs

@@ -0,0 +1,184 @@
+import { a as ContextRepository, i as parseSiteBriefingScope, n as SiteBriefingError } from "./briefing-MVYe_Uyf.mjs";
+import { b as toPublicContextEntry, x as toPublicContextEntryPage, y as toPublicContextDiff } from "./site-context-WBxoD99D.mjs";
+
+//#region src/api/handlers/context.ts
+async function handleContextEntryList(db, input = {}) {
+	try {
+		const scopes = resolveScopes(input.scope, input.includeInherited);
+		const repository = new ContextRepository(db);
+		const query = {
+			scopes,
+			contextTypes: input.contextTypes,
+			tags: input.tags,
+			createdByActorType: input.createdByActorType,
+			createdByActorId: input.createdByActorId,
+			currentOnly: input.currentOnly,
+			limit: input.limit,
+			cursor: input.cursor
+		};
+		return {
+			success: true,
+			data: toPublicContextEntryPage(input.q?.trim() ? await repository.search({
+				...query,
+				query: input.q.trim()
+			}) : await repository.list(query))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_LIST_ERROR", "Failed to list context entries");
+	}
+}
+async function handleContextEntryGet(db, id) {
+	try {
+		const entry = await new ContextRepository(db).findById(id);
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_GET_ERROR", "Failed to get context entry");
+	}
+}
+async function handleContextEntryCreate(db, input, actor) {
+	try {
+		parseSiteBriefingScope(input.scope);
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(await new ContextRepository(db).create({
+				...input,
+				createdByActorType: actor.actorType,
+				createdByActorId: actor.actorId,
+				createdAuthMetadata: actor.authMetadata
+			})) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_CREATE_ERROR", "Failed to create context entry");
+	}
+}
+async function handleContextEntrySupersede(db, id, input, actor) {
+	try {
+		if (input.scope) parseSiteBriefingScope(input.scope);
+		const entry = await new ContextRepository(db).supersede(id, {
+			...input,
+			createdByActorType: actor.actorType,
+			createdByActorId: actor.actorId,
+			createdAuthMetadata: actor.authMetadata
+		});
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_SUPERSEDE_ERROR", "Failed to supersede context entry");
+	}
+}
+async function handleContextEntryReview(db, id, input, actor) {
+	try {
+		const entry = await new ContextRepository(db).review(id, {
+			reviewedByActorType: actor.actorType,
+			reviewedByActorId: actor.actorId,
+			reviewNote: input.reviewNote,
+			validUntil: input.validUntil
+		});
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_REVIEW_ERROR", "Failed to review context entry");
+	}
+}
+async function handleContextEntryStale(db, input = {}) {
+	try {
+		return {
+			success: true,
+			data: toPublicContextEntryPage(await new ContextRepository(db).listStale({
+				scopes: resolveScopes(input.scope, input.includeInherited),
+				contextTypes: input.contextTypes,
+				tags: input.tags,
+				now: input.now,
+				limit: input.limit,
+				cursor: input.cursor
+			}))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_STALE_ERROR", "Failed to list stale context entries");
+	}
+}
+async function handleContextEntryDiff(db, input) {
+	try {
+		return {
+			success: true,
+			data: toPublicContextDiff(await new ContextRepository(db).diff({
+				scopes: resolveScopes(input.scope, input.includeInherited),
+				since: input.since,
+				now: input.now
+			}))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_DIFF_ERROR", "Failed to diff context entries");
+	}
+}
+async function handleContextEntryHistory(db, id) {
+	try {
+		const repository = new ContextRepository(db);
+		if (!await repository.findById(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { items: (await repository.findSupersedeHistory(id)).map(toPublicContextEntry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_HISTORY_ERROR", "Failed to load context history");
+	}
+}
+function resolveScopes(scope, includeInherited) {
+	if (!scope) return void 0;
+	const parsed = parseSiteBriefingScope(scope);
+	return includeInherited ? parsed.ancestors : [parsed.scope];
+}
+function contextError(error, code, fallback) {
+	if (error instanceof SiteBriefingError) return {
+		success: false,
+		error: {
+			code: "VALIDATION_ERROR",
+			message: error.message
+		}
+	};
+	console.error(`[${code}]`, error);
+	return {
+		success: false,
+		error: {
+			code,
+			message: fallback
+		}
+	};
+}
+
+//#endregion
+export { handleContextEntryList as a, handleContextEntrySupersede as c, handleContextEntryHistory as i, handleContextEntryDiff as n, handleContextEntryReview as o, handleContextEntryGet as r, handleContextEntryStale as s, handleContextEntryCreate as t };

package/dist/context-route-helpers-MurhoxWF.mjs

@@ -0,0 +1,45 @@
+import { T as resolveActorIdentity, p as logSiteActivitySafely } from "./activity-events-B4wp7CrU.mjs";
+
+//#region src/api/context-route-helpers.ts
+function resolveContextRouteActor(locals) {
+	const actor = resolveActorIdentity(toActorLocals(locals));
+	return {
+		actorType: actor.actorType,
+		actorId: actor.actorId,
+		authMetadata: actor.authMetadata
+	};
+}
+async function logContextRouteActivity(db, locals, input) {
+	await logSiteActivitySafely(db, toActorLocals(locals), {
+		actionType: input.actionType,
+		subjectType: "context_entry",
+		subjectId: input.entry.id,
+		scope: input.entry.scope,
+		sourceType: "api_route",
+		sourceName: contextRouteSourceName(input.actionType),
+		summary: input.summary,
+		detail: {
+			contextType: input.entry.contextType,
+			policyKey: input.entry.policyKey,
+			tags: input.entry.tags,
+			...input.detail
+		}
+	});
+}
+function contextRouteSourceName(actionType) {
+	switch (actionType) {
+		case "context.added": return "admin.context.add";
+		case "context.superseded": return "admin.context.supersede";
+		case "context.reviewed": return "admin.context.review";
+	}
+}
+function toActorLocals(locals) {
+	return {
+		user: locals.user ? { id: locals.user.id } : null,
+		tokenScopes: locals.tokenScopes,
+		authToken: locals.authToken
+	};
+}
+
+//#endregion
+export { resolveContextRouteActor as n, logContextRouteActivity as t };

package/dist/context-types-C-LwdAxx.mjs

@@ -0,0 +1,23 @@
+//#region src/site-context/context-types.ts
+const SITE_CONTEXT_TYPES = [
+	"brand_voice",
+	"seo_strategy",
+	"audience",
+	"content_guideline",
+	"forbidden_terms",
+	"editorial_policy",
+	"migration_note",
+	"plugin_note",
+	"agent_reasoning",
+	"decision",
+	"risk",
+	"content_gap",
+	"style_exception"
+];
+const SITE_CONTEXT_TYPE_SET = new Set(SITE_CONTEXT_TYPES);
+function isSiteContextType(value) {
+	return SITE_CONTEXT_TYPE_SET.has(value);
+}
+
+//#endregion
+export { isSiteContextType as n, SITE_CONTEXT_TYPES as t };

package/dist/cron-CKxvBrRT.mjs

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

package/dist/dashboard-DqnYU8EU.mjs

@@ -0,0 +1,120 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as ContentRepository } from "./content-CyLkb-qH.mjs";
+import { t as MediaRepository } from "./media-_7Fxdu45.mjs";
+import { t as UserRepository } from "./user-CcXq-zoL.mjs";
+import { t as ReviewRequestRepository } from "./review-requests-C2DIHwlJ.mjs";
+import { sql } from "kysely";
+
+//#region src/api/handlers/dashboard.ts
+/**
+* Dashboard stats handler
+*
+* Returns summary data for the admin dashboard in a single request:
+* collection content counts, media count, user count, and recent
+* content across all collections.
+*/
+/**
+* Fetch dashboard statistics.
+*
+* Queries are intentionally lightweight — counts use indexed columns,
+* and recent items are capped at 10.
+*/
+async function handleDashboardStats(db) {
+	try {
+		const collections = await db.selectFrom("_dineway_collections").select(["slug", "label"]).orderBy("slug", "asc").execute();
+		const contentRepo = new ContentRepository(db);
+		const collectionStats = await Promise.all(collections.map(async (col) => {
+			const stats = await contentRepo.getStats(col.slug);
+			return {
+				slug: col.slug,
+				label: col.label,
+				total: stats.total,
+				published: stats.published,
+				draft: stats.draft
+			};
+		}));
+		const mediaRepo = new MediaRepository(db);
+		const userRepo = new UserRepository(db);
+		const reviewRepo = new ReviewRequestRepository(db);
+		const [mediaCount, userCount, pendingReviewCount] = await Promise.all([
+			mediaRepo.count(),
+			userRepo.count(),
+			reviewRepo.countPending()
+		]);
+		return {
+			success: true,
+			data: {
+				collections: collectionStats,
+				mediaCount,
+				userCount,
+				recentItems: await fetchRecentItems(db, collections),
+				pendingReviewCount
+			}
+		};
+	} catch (error) {
+		console.error("Dashboard stats error:", error);
+		return {
+			success: false,
+			error: {
+				code: "DASHBOARD_STATS_ERROR",
+				message: "Failed to load dashboard statistics"
+			}
+		};
+	}
+}
+/**
+* Fetch the 10 most recently updated items across all collections.
+*
+* Uses UNION ALL over each ec_* table. The query is safe because
+* collection slugs come from the system table and are validated.
+*
+* `title` is not a standard column — it's a user-defined field. We query
+* `_dineway_fields` to discover which collections have one and fall back
+* to `slug` (which is always present) otherwise.
+*/
+async function fetchRecentItems(db, collections) {
+	if (collections.length === 0) return [];
+	const titleFields = await db.selectFrom("_dineway_fields as f").innerJoin("_dineway_collections as c", "c.id", "f.collection_id").select(["c.slug as collection_slug"]).where("f.slug", "=", "title").execute();
+	const collectionsWithTitle = new Set(titleFields.map((r) => r.collection_slug));
+	const subQueries = collections.map((col) => {
+		validateIdentifier(col.slug);
+		const table = `ec_${col.slug}`;
+		const titleExpr = collectionsWithTitle.has(col.slug) ? sql`COALESCE(title, slug, id)` : sql`COALESCE(slug, id)`;
+		return sql`
+			SELECT * FROM (
+				SELECT
+					id,
+					${sql.lit(col.slug)} AS collection,
+					${sql.lit(col.label)} AS collection_label,
+					${titleExpr} AS title,
+					slug,
+					status,
+					updated_at,
+					author_id
+				FROM ${sql.ref(table)}
+				WHERE deleted_at IS NULL
+				ORDER BY updated_at DESC
+				LIMIT 10
+			)
+		`;
+	});
+	let combined = subQueries[0];
+	for (let i = 1; i < subQueries.length; i++) combined = sql`${combined} UNION ALL ${subQueries[i]}`;
+	return (await sql`
+		SELECT * FROM (${combined})
+		ORDER BY updated_at DESC
+		LIMIT 10
+	`.execute(db)).rows.map((row) => ({
+		id: row.id,
+		collection: row.collection,
+		collectionLabel: row.collection_label,
+		title: row.title,
+		slug: row.slug,
+		status: row.status,
+		updatedAt: row.updated_at,
+		authorId: row.author_id
+	}));
+}
+
+//#endregion
+export { handleDashboardStats as t };

package/dist/db/index.d.mts

@@ -1,4 +1,4 @@
-import "../types-DOrVigru.mjs";
-import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-CFI6B6J2.mjs";
-import { a as SqliteConfig, c as sqlite, i as PostgresConfig, n as DatabaseDialectType, o as libsql, r as LibsqlConfig, s as postgres, t as DatabaseDescriptor } from "../adapters-C2ypTrZZ.mjs";
+import "../types-DZPw8Rru.mjs";
+import { a as SqliteConfig, c as sqlite, i as PostgresConfig, n as DatabaseDialectType, o as libsql, r as LibsqlConfig, s as postgres, t as DatabaseDescriptor } from "../adapters-DuLQZhRY.mjs";
+import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-BU6Lo1ZS.mjs";
 export { type DatabaseDescriptor, type DatabaseDialectType, type LibsqlConfig, type MigrationStatus, type PostgresConfig, type SqliteConfig, getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };

package/dist/db/libsql.d.mts

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

package/dist/db/libsql.mjs

@@ -1,5 +1,6 @@
-import { n as __require } from "../chunk-ClPoSABd.mjs";
+import BetterSqlite3 from "better-sqlite3";
 import { SqliteDialect } from "kysely";
+import { LibsqlDialect } from "@libsql/kysely-libsql";
 
 //#region src/db/libsql.ts
 /**
@@ -15,8 +16,7 @@ import { SqliteDialect } from "kysely";
 * Create a libSQL dialect from config
 */
 function createDialect(config) {
-	if (config.url === ":memory:" || config.url.startsWith("file:")) return new SqliteDialect({ database: new (__require("better-sqlite3"))(config.url === ":memory:" ? config.url : config.url.slice(5)) });
-	const { LibsqlDialect } = __require("@libsql/kysely-libsql");
+	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({
 		url: config.url,
 		authToken: config.authToken

package/dist/db/postgres.d.mts

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

package/dist/db/sqlite.d.mts

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