emdash 0.34.0 → 0.35.0

package/src/database/index.ts

@@ -2,6 +2,12 @@
 // `connection.ts`, which statically imports `better-sqlite3`. See #947.
 export { EmDashDatabaseError } from "./errors.js";
 export type { DatabaseConfig } from "./connection.js";
-export { runMigrations, getMigrationStatus, rollbackMigration } from "./migrations/runner.js";
-export type { MigrationStatus } from "./migrations/runner.js";
+export {
+	runMigrations,
+	getMigrationStatus,
+	getExactMigrationStatus,
+	rollbackMigration,
+	MIGRATION_NAMES,
+} from "./migrations/runner.js";
+export type { MigrationStatus, ExactMigrationStatus } from "./migrations/runner.js";
 export type * from "./types.js";

package/src/database/migrations/policy.ts

@@ -0,0 +1,70 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../types.js";
+import { getExactMigrationStatus, runMigrations } from "./runner.js";
+
+export type RuntimeMigrationMode = "auto" | "check" | "manual";
+
+export interface RuntimeMigrationConfig {
+	runtime: RuntimeMigrationMode;
+	dev?: RuntimeMigrationMode;
+}
+
+function parseMigrationMode(value: unknown, source: string): RuntimeMigrationMode {
+	if (value === "auto" || value === "check" || value === "manual") {
+		return value;
+	}
+	throw new Error(
+		`Invalid ${source} value ${JSON.stringify(value)}; expected "auto", "check", or "manual"`,
+	);
+}
+
+export function normalizeMigrationConfig(value: unknown): RuntimeMigrationConfig {
+	if (value === undefined) return { runtime: "auto" };
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new Error("Invalid migrations configuration; expected an object");
+	}
+
+	const runtimeValue = Reflect.get(value, "runtime");
+	const devValue = Reflect.get(value, "dev");
+	const runtime = parseMigrationMode(runtimeValue, "migrations.runtime");
+	const dev = devValue === undefined ? undefined : parseMigrationMode(devValue, "migrations.dev");
+	return dev === undefined ? { runtime } : { runtime, dev };
+}
+
+export function resolveRuntimeMigrationMode(
+	config: RuntimeMigrationConfig | undefined,
+	options: { dev: boolean; override?: unknown },
+): RuntimeMigrationMode {
+	if (options.override !== undefined) {
+		return parseMigrationMode(options.override, "EMDASH_MIGRATIONS_MODE");
+	}
+	if (options.dev) return config?.dev ?? "auto";
+	return config?.runtime ?? "auto";
+}
+
+export class PendingMigrationsError extends Error {
+	readonly pending: string[];
+
+	constructor(pending: readonly string[]) {
+		super(`Database has pending EmDash migrations: ${pending.join(", ")}`);
+		this.name = "PendingMigrationsError";
+		this.pending = [...pending];
+	}
+}
+
+export async function enforceRuntimeMigrationPolicy(
+	db: Kysely<Database>,
+	mode: RuntimeMigrationMode,
+): Promise<void> {
+	if (mode === "manual") return;
+	if (mode === "auto") {
+		await runMigrations(db);
+		return;
+	}
+
+	const status = await getExactMigrationStatus(db);
+	if (status.pending.length > 0) {
+		throw new PendingMigrationsError(status.pending);
+	}
+}

package/src/database/migrations/runner.ts

@@ -146,8 +146,11 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"070_collection_routable": m070,
 });
 
+/** Ordered names from the statically registered migration set. */
+export const MIGRATION_NAMES: readonly string[] = Object.freeze(Object.keys(MIGRATIONS));
+
 /** Total number of registered migrations. Exported for use in tests. */
-export const MIGRATION_COUNT = Object.keys(MIGRATIONS).length;
+export const MIGRATION_COUNT = MIGRATION_NAMES.length;
 
 /**
  * Migration provider that uses statically imported migrations.
@@ -164,6 +167,12 @@ export interface MigrationStatus {
 	pending: string[];
 }
 
+export interface ExactMigrationStatus {
+	knownApplied: string[];
+	pending: string[];
+	unknownApplied: string[];
+}
+
 /**
  * Thrown when another instance held the migration lock for the whole wait
  * window. This is NOT a migration failure — the holder may simply be slow
@@ -286,8 +295,8 @@ const MIGRATION_RACE_POLL_MS = 100;
  * built from `MIGRATION_TABLE` so a rename cannot drift.
  */
 const MIGRATION_TABLE_MISSING_PATTERN = new RegExp(
-	`(?:no such table:\\s*${escapeRegExp(MIGRATION_TABLE)}\\b` +
-		`|(?:relation|table)\\s+"?${escapeRegExp(MIGRATION_TABLE)}"?\\s+does(?:n't| not) exist\\b)`,
+	`(?:no such table:\\s*(?:[a-z][a-z0-9_]*\\.)?${escapeRegExp(MIGRATION_TABLE)}\\b` +
+		`|(?:relation|table)\\s+"?(?:[a-z][a-z0-9_]*\\.)?${escapeRegExp(MIGRATION_TABLE)}"?\\s+does(?:n't| not) exist\\b)`,
 	"i",
 );
 
@@ -359,6 +368,43 @@ function deepErrorMessage(error: unknown): string {
 	}
 }
 
+/**
+ * Read exact migration status without invoking Kysely's migration
+ * introspection. Registered names retain execution order; unknown database
+ * records are sorted so reports remain stable across dialects.
+ */
+export async function getExactMigrationStatus(
+	db: Kysely<Database>,
+	options?: MigrationOptions,
+): Promise<ExactMigrationStatus> {
+	const table = options?.migrationTableSchema
+		? sql`${sql.ref(options.migrationTableSchema)}.${sql.ref(MIGRATION_TABLE)}`
+		: sql.ref(MIGRATION_TABLE);
+
+	let rows: readonly { name: string }[];
+	try {
+		const result = await sql<{ name: string }>`SELECT name FROM ${table}`.execute(db);
+		rows = result.rows;
+	} catch (error) {
+		if (MIGRATION_TABLE_MISSING_PATTERN.test(deepErrorMessage(error))) {
+			return {
+				knownApplied: [],
+				pending: [...MIGRATION_NAMES],
+				unknownApplied: [],
+			};
+		}
+		throw error;
+	}
+
+	const appliedNames = new Set(rows.map((row) => row.name));
+	const knownApplied = MIGRATION_NAMES.filter((name) => appliedNames.has(name));
+	const pending = MIGRATION_NAMES.filter((name) => !appliedNames.has(name));
+	const knownNames = new Set(MIGRATION_NAMES);
+	const unknownApplied = [...appliedNames].filter((name) => !knownNames.has(name)).toSorted();
+
+	return { knownApplied, pending, unknownApplied };
+}
+
 /**
  * Run all pending migrations.
  *

package/src/db/adapters.ts

@@ -52,6 +52,20 @@ export type ExecuteCollectionDeletionGuard = (
 	input: CollectionDeletionGuardInput,
 ) => Promise<CollectionDeletionGuardResult>;
 
+const ENVIRONMENT_VARIABLE_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function migrationEnvironmentVariable(
+	value: string | undefined,
+	fallback: string,
+	optionName: string,
+): string {
+	const name = value ?? fallback;
+	if (!ENVIRONMENT_VARIABLE_PATTERN.test(name)) {
+		throw new Error(`${optionName} must be a valid environment variable name.`);
+	}
+	return name;
+}
+
 /**
  * Database descriptor - serializable config for virtual modules
  */
@@ -59,6 +73,11 @@ export interface DatabaseDescriptor {
 	entrypoint: string;
 	config: unknown;
 	type: DatabaseDialectType;
+	/** Deployment migration capability with configuration safe for a build artifact. */
+	migrations?: {
+		entrypoint: string;
+		manifestConfig: unknown;
+	};
 	/**
 	 * When true, the adapter's runtime entrypoint MUST export a named
 	 * `createRequestScopedDb` function matching the signature declared in
@@ -111,6 +130,7 @@ export interface LibsqlConfig {
 	 * Auth token for remote libSQL
 	 */
 	authToken?: string;
+	migrationAuthTokenEnv?: string;
 }
 
 /**
@@ -128,6 +148,10 @@ export function sqlite(config: SqliteConfig): DatabaseDescriptor {
 		entrypoint: "emdash/db/sqlite",
 		config,
 		type: "sqlite",
+		migrations: {
+			entrypoint: "emdash/db/sqlite-migrations",
+			manifestConfig: { url: config.url },
+		},
 	};
 }
 
@@ -145,10 +169,22 @@ export function sqlite(config: SqliteConfig): DatabaseDescriptor {
  * ```
  */
 export function libsql(config: LibsqlConfig): DatabaseDescriptor {
+	const { migrationAuthTokenEnv, ...runtimeConfig } = config;
 	return {
 		entrypoint: "emdash/db/libsql",
-		config,
+		config: runtimeConfig,
 		type: "sqlite",
+		migrations: {
+			entrypoint: "emdash/db/libsql-migrations",
+			manifestConfig: {
+				url: config.url,
+				authTokenEnv: migrationEnvironmentVariable(
+					migrationAuthTokenEnv,
+					"TURSO_AUTH_TOKEN",
+					"migrationAuthTokenEnv",
+				),
+			},
+		},
 	};
 }
 
@@ -164,6 +200,7 @@ export interface PostgresConfig {
 	password?: string;
 	ssl?: boolean;
 	pool?: { min?: number; max?: number };
+	migrationConnectionStringEnv?: string;
 }
 
 /**
@@ -177,9 +214,20 @@ export interface PostgresConfig {
  * ```
  */
 export function postgres(config: PostgresConfig): DatabaseDescriptor {
+	const { migrationConnectionStringEnv, ...runtimeConfig } = config;
 	return {
 		entrypoint: "emdash/db/postgres",
-		config,
+		config: runtimeConfig,
 		type: "postgres",
+		migrations: {
+			entrypoint: "emdash/db/postgres-migrations",
+			manifestConfig: {
+				connectionStringEnv: migrationEnvironmentVariable(
+					migrationConnectionStringEnv,
+					"DATABASE_URL",
+					"migrationConnectionStringEnv",
+				),
+			},
+		},
 	};
 }

package/src/db/index.ts

@@ -35,6 +35,8 @@ export type {
 export {
 	runMigrations,
 	getMigrationStatus,
+	getExactMigrationStatus,
 	rollbackMigration,
+	MIGRATION_NAMES,
 } from "../database/migrations/runner.js";
-export type { MigrationStatus } from "../database/migrations/runner.js";
+export type { MigrationStatus, ExactMigrationStatus } from "../database/migrations/runner.js";

package/src/db/libsql-migrations.ts

@@ -0,0 +1,72 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { createDirectMigrationExecutor } from "../migrations/direct-executor.js";
+import type { MigrationExecutor, MigrationExecutorFactoryContext } from "../migrations/protocol.js";
+import { createMigrationTarget, requireMigrationEnvironment } from "../migrations/target.js";
+import { createDialect } from "./libsql.js";
+
+export interface LibsqlMigrationManifestConfig {
+	url: string;
+	authTokenEnv: string;
+}
+
+interface ResolvedLibsqlUrl {
+	connectionUrl: string;
+	label: string;
+	identity: string[];
+	requiresAuthToken: boolean;
+}
+
+function resolveLibsqlUrl(url: unknown, projectRoot: string): ResolvedLibsqlUrl {
+	if (typeof url !== "string" || url.length === 0) {
+		throw new Error("libSQL migration URL is missing.");
+	}
+	if (url.startsWith("file:")) {
+		const configuredPath = url.slice(5);
+		if (configuredPath.length === 0) throw new Error("libSQL migration URL is invalid.");
+		const fileUrl = pathToFileURL(resolve(projectRoot, configuredPath));
+		return {
+			connectionUrl: fileUrl.href,
+			label: fileUrl.href,
+			identity: [fileUrl.protocol, fileUrl.pathname],
+			requiresAuthToken: false,
+		};
+	}
+
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error("libSQL migration URL is invalid.");
+	}
+	if (parsed.username || parsed.password) {
+		throw new Error("libSQL migration URL must not contain credentials.");
+	}
+	const label = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+	return {
+		connectionUrl: url,
+		label,
+		identity: [parsed.protocol, parsed.host, parsed.pathname],
+		requiresAuthToken: true,
+	};
+}
+
+export async function createMigrationExecutor(
+	manifestConfig: LibsqlMigrationManifestConfig,
+	context: MigrationExecutorFactoryContext,
+): Promise<MigrationExecutor> {
+	const resolvedUrl = resolveLibsqlUrl(manifestConfig.url, context.projectRoot);
+	const authToken = resolvedUrl.requiresAuthToken
+		? requireMigrationEnvironment(manifestConfig.authTokenEnv, context.env)
+		: undefined;
+	const target = await createMigrationTarget("libsql", resolvedUrl.label, resolvedUrl.identity);
+	return createDirectMigrationExecutor({
+		target,
+		createDialect: () =>
+			createDialect({
+				url: resolvedUrl.connectionUrl,
+				authToken,
+			}),
+	});
+}

package/src/db/postgres-migrations.ts

@@ -0,0 +1,59 @@
+import { createDirectMigrationExecutor } from "../migrations/direct-executor.js";
+import type { MigrationExecutor, MigrationExecutorFactoryContext } from "../migrations/protocol.js";
+import { createMigrationTarget, requireMigrationEnvironment } from "../migrations/target.js";
+import { createDialect } from "./postgres.js";
+
+export interface PostgresMigrationManifestConfig {
+	connectionStringEnv: string;
+}
+
+interface PostgresTargetIdentity {
+	host: string;
+	port: string;
+	database: string;
+}
+
+function parseTargetIdentity(connectionString: string): PostgresTargetIdentity {
+	let parsed: URL;
+	try {
+		parsed = new URL(connectionString);
+	} catch {
+		throw new Error("PostgreSQL migration connection string is invalid.");
+	}
+	if (parsed.protocol !== "postgres:" && parsed.protocol !== "postgresql:") {
+		throw new Error("PostgreSQL migration connection string is invalid.");
+	}
+	const database = parsed.pathname.slice(1);
+	if (!parsed.hostname || !database) {
+		throw new Error("PostgreSQL migration connection string must identify a host and database.");
+	}
+	return {
+		host: parsed.hostname,
+		port: parsed.port || "5432",
+		database,
+	};
+}
+
+export async function createMigrationExecutor(
+	manifestConfig: PostgresMigrationManifestConfig,
+	context: MigrationExecutorFactoryContext,
+): Promise<MigrationExecutor> {
+	const connectionStringEnv =
+		context.overrides?.databaseUrlEnv ?? manifestConfig.connectionStringEnv;
+	const connectionString = requireMigrationEnvironment(connectionStringEnv, context.env);
+	const identity = parseTargetIdentity(connectionString);
+	const label = `${identity.host}:${identity.port}/${identity.database}`;
+	const target = await createMigrationTarget("postgres", label, [
+		identity.host,
+		identity.port,
+		identity.database,
+	]);
+	return createDirectMigrationExecutor({
+		target,
+		createDialect: () =>
+			createDialect({
+				connectionString,
+				pool: { min: 0, max: 1 },
+			}),
+	});
+}

package/src/db/sqlite-migrations.ts

@@ -0,0 +1,37 @@
+import { isAbsolute, resolve } from "node:path";
+
+import { createDirectMigrationExecutor } from "../migrations/direct-executor.js";
+import type { MigrationExecutor, MigrationExecutorFactoryContext } from "../migrations/protocol.js";
+import { createMigrationTarget } from "../migrations/target.js";
+import { createDialect } from "./sqlite.js";
+
+export interface SqliteMigrationManifestConfig {
+	url: string;
+}
+
+function resolveDatabasePath(
+	manifestConfig: SqliteMigrationManifestConfig,
+	context: MigrationExecutorFactoryContext,
+): string {
+	const configuredUrl = context.overrides?.database ?? manifestConfig.url;
+	if (typeof configuredUrl !== "string" || configuredUrl.length === 0) {
+		throw new Error("SQLite migration database path is missing.");
+	}
+	const path = configuredUrl.startsWith("file:") ? configuredUrl.slice(5) : configuredUrl;
+	if (path.length === 0) {
+		throw new Error("SQLite migration database path is missing.");
+	}
+	return isAbsolute(path) ? resolve(path) : resolve(context.projectRoot, path);
+}
+
+export async function createMigrationExecutor(
+	manifestConfig: SqliteMigrationManifestConfig,
+	context: MigrationExecutorFactoryContext,
+): Promise<MigrationExecutor> {
+	const databasePath = resolveDatabasePath(manifestConfig, context);
+	const target = await createMigrationTarget("sqlite", databasePath, [databasePath]);
+	return createDirectMigrationExecutor({
+		target,
+		createDialect: () => createDialect({ url: databasePath }),
+	});
+}

package/src/emdash-runtime.ts

@@ -26,10 +26,14 @@ import { getTrustedProxyHeaders } from "./auth/trusted-proxy.js";
 import type { ContentFieldFilters } from "./content-list-query.js";
 import { isSqlite } from "./database/dialect-helpers.js";
 import { kyselyLogOption } from "./database/instrumentation.js";
+import {
+	enforceRuntimeMigrationPolicy,
+	PendingMigrationsError,
+	type RuntimeMigrationMode,
+} from "./database/migrations/policy.js";
 import {
 	ConcurrentMigrationTimeoutError,
 	MIGRATION_RACE_WAIT_MS,
-	runMigrations,
 } from "./database/migrations/runner.js";
 import { AuditRepository } from "./database/repositories/audit.js";
 import { ContentRepository } from "./database/repositories/content.js";
@@ -87,6 +91,7 @@ import type {
 } from "./plugins/types.js";
 import { recordSchedulerHeartbeatSafely } from "./scheduler-health.js";
 import { MAX_COLLECTION_LIST_COLUMNS, type FieldType } from "./schema/types.js";
+import { isMissingTableError } from "./utils/db-errors.js";
 import { hashString } from "./utils/hash.js";
 import { createInitLock, type InitLock, initWithLock } from "./utils/init-lock.js";
 import { createSingleFlightCache, singleFlightCached } from "./utils/single-flight-cache.js";
@@ -347,6 +352,8 @@ export type CreateSchedulerFn = (executor: CronExecutor) => CronScheduler;
  */
 export interface RuntimeDependencies {
 	config: EmDashConfig;
+	/** Effective migration mode, resolved once by the runtime entrypoint. */
+	migrationMode?: RuntimeMigrationMode;
 	plugins: ResolvedPlugin[];
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	createDialect: (config: any) => Dialect;
@@ -1247,8 +1254,10 @@ export class EmDashRuntime {
 			}
 		};
 
-		// Initialize database (connects, runs migrations if needed)
-		const db = await phase("rt.db", "DB init + migrations", () => EmDashRuntime.getDatabase(deps));
+		// Initialize the database and enforce its configured migration policy.
+		const db = await phase("rt.db", "DB init + migration policy", () =>
+			EmDashRuntime.getDatabase(deps),
+		);
 
 		// Resolver for the live connection, mirroring the `get db()` getter
 		// below (which can't be used here — the runtime instance doesn't exist
@@ -1311,6 +1320,16 @@ export class EmDashRuntime {
 		// fall back to the singleton, where serialization costs nothing.
 		let readDb = db;
 		let readDbDisposable: Kysely<Database> | undefined;
+		const disposeReadDb = async () => {
+			const disposable = readDbDisposable;
+			readDbDisposable = undefined;
+			if (!disposable) return;
+			try {
+				await disposable.destroy();
+			} catch {
+				// Non-fatal — the underlying binding is shared and needs no teardown.
+			}
+		};
 		if (ownsConfiguredDb && deps.createCoalescingDialect && deps.config.database) {
 			try {
 				const dialect = deps.createCoalescingDialect(deps.config.database.config);
@@ -1323,6 +1342,12 @@ export class EmDashRuntime {
 			}
 		}
 		const optionsRepo = new OptionsRepository(readDb);
+		let missingManualSchemaError: unknown;
+		const captureMissingManualSchema = (error: unknown) => {
+			if ((deps.migrationMode ?? "auto") === "manual" && isMissingTableError(error)) {
+				missingManualSchemaError ??= error;
+			}
+		};
 
 		const readSiteInfo = async () => {
 			const siteOpts = await optionsRepo.getMany<string>([
@@ -1351,14 +1376,16 @@ export class EmDashRuntime {
 						.select(["plugin_id", "status"])
 						.execute();
 					pluginStates = new Map(states.map((s) => [s.plugin_id, s.status]));
-				} catch {
+				} catch (error) {
+					captureMissingManualSchema(error);
 					// _plugin_state may not exist yet on a pre-migration db.
 				}
 			}),
 			phase("rt.site", "Site info options", async () => {
 				try {
 					siteInfo = await readSiteInfo();
-				} catch {
+				} catch (error) {
+					captureMissingManualSchema(error);
 					// options may not exist yet on a pre-migration db.
 				}
 			}),
@@ -1387,7 +1414,8 @@ export class EmDashRuntime {
 							}
 						})();
 						seedGate = { collectionCount: collectionCount.count, setupDone };
-					} catch {
+					} catch (error) {
+						captureMissingManualSchema(error);
 						// Leave the "already set up" default so a read failure never
 						// triggers a seed onto a half-built db.
 					}
@@ -1396,6 +1424,10 @@ export class EmDashRuntime {
 		}
 
 		await Promise.all(coldStartReads);
+		if (missingManualSchemaError) {
+			await disposeReadDb();
+			throw missingManualSchemaError;
+		}
 
 		if (
 			localeCasingRepairVersion &&
@@ -1452,13 +1484,7 @@ export class EmDashRuntime {
 		}
 
 		// The read connection is single-use; everything below uses the singleton.
-		if (readDbDisposable) {
-			try {
-				await readDbDisposable.destroy();
-			} catch {
-				// Non-fatal — the underlying binding is shared and needs no teardown.
-			}
-		}
+		await disposeReadDb();
 
 		const enabledPlugins = new Set<string>();
 		for (const plugin of deps.plugins) {
@@ -1911,13 +1937,16 @@ export class EmDashRuntime {
 				const db = new Kysely<Database>({ dialect, log: kyselyLogOption() });
 
 				try {
-					await runMigrations(db);
+					await enforceRuntimeMigrationPolicy(db, deps.migrationMode ?? "auto");
 				} catch (error) {
 					// Timing out behind another instance's in-flight migrations
 					// is not a failure of OUR migration — the holder may just be
 					// slow. Don't back off for it: the next request waits again
 					// and init recovers the moment the holder finishes.
-					if (!(error instanceof ConcurrentMigrationTimeoutError)) {
+					if (
+						!(error instanceof ConcurrentMigrationTimeoutError) &&
+						!(error instanceof PendingMigrationsError)
+					) {
 						holder.failures.set(cacheKey, {
 							at: Date.now(),
 							message: error instanceof Error ? error.message : String(error),

package/src/i18n/normalize.ts

@@ -0,0 +1,31 @@
+import type { I18nConfig } from "./config.js";
+
+export interface AstroLocaleObject {
+	path: string;
+	codes: readonly string[];
+}
+
+export interface AstroI18nInput {
+	defaultLocale: string;
+	locales: readonly (string | AstroLocaleObject)[];
+	fallback?: Readonly<Record<string, string | undefined>>;
+	routing?: string | { prefixDefaultLocale?: boolean };
+}
+
+export function normalizeAstroI18n(config: AstroI18nInput | null | undefined): I18nConfig | null {
+	if (!config) return null;
+
+	return {
+		defaultLocale: config.defaultLocale,
+		locales: config.locales.map((locale) => (typeof locale === "string" ? locale : locale.path)),
+		fallback: config.fallback
+			? Object.fromEntries(
+					Object.entries(config.fallback).filter(
+						(entry): entry is [string, string] => entry[1] !== undefined,
+					),
+				)
+			: undefined,
+		prefixDefaultLocale:
+			typeof config.routing === "object" ? (config.routing.prefixDefaultLocale ?? false) : false,
+	};
+}

package/src/index.ts

@@ -1,8 +1,14 @@
 // Database (only types and utilities - internal functions not exported)
-export { EmDashDatabaseError, getMigrationStatus } from "./database/index.js";
+export {
+	EmDashDatabaseError,
+	getMigrationStatus,
+	getExactMigrationStatus,
+	MIGRATION_NAMES,
+} from "./database/index.js";
 export type {
 	DatabaseConfig,
 	MigrationStatus,
+	ExactMigrationStatus,
 	Database,
 	UserTable,
 	MediaTable,