void 1.1.0 → 1.1.12

package/dist/{db-7I_gfdVq.mjs → db-BsiOAa0A.mjs}

@@ -1,20 +1,20 @@
 import { a as join, c as resolve, n as dirname, r as extname, s as relative, t as basename } from "./dist-ipQi0Q8y.mjs";
-import { r as detectFramework } from "./plugin-inference-DsARdQKE.mjs";
-import { n as readProjectPaths } from "./project-paths-DMvEeSau.mjs";
-import { d as readConfig, f as resolveBindingNames, s as getDatabaseDialect } from "./config-Bx_1SpnO.mjs";
-import { i as writeJournal, n as readJournal, r as stripSqlExt, t as collectMigrations } from "./collect-xjffdCdk.mjs";
+import { r as detectFramework } from "./plugin-inference-Bekzjuqw.mjs";
+import { n as readProjectPaths } from "./project-paths-DGu_QZ_Q.mjs";
+import { d as readConfig, f as resolveBindingNames, s as getDatabaseDialect } from "./config-D26zcdKy.mjs";
+import { i as writeJournal, n as readJournal, r as stripSqlExt, t as collectMigrations } from "./collect-Dew86qce.mjs";
 import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-rqDnVsJN.mjs";
-import { t as resolveLocalD1Target } from "./local-d1-BxvQYEFi.mjs";
+import { t as resolveLocalD1Target } from "./local-d1-CpaPbd_L.mjs";
 import { t as cfAccessHeaders } from "./cf-access-BM9G0lhO.mjs";
 import { n as ensurePlatformProxyAccess, r as isCloudflareAccessChallenge, t as ensurePlatformAccessToken } from "./cf-access-CWP4avfP.mjs";
 import { c as getToken, o as getProxyUrl } from "./auth-B6iOCjKI.mjs";
 import { A as confirm, H as outro, L as log, X as text, tt as isCancel } from "./dist-BVdsO7Py.mjs";
-import { f as import_picocolors, i as dim, l as formatUrl, m as printSuccess, o as formatCount, u as getErrorMessage } from "./output-Ba6ZbrzY.mjs";
+import { f as import_picocolors, i as dim, l as formatUrl, m as printSuccess, o as formatCount, u as getErrorMessage } from "./output-CKguMgr7.mjs";
 import { o as loadLocalEnv } from "./env-BJjULvL0.mjs";
-import { i as validateMigrations, t as assertJournalCoherence } from "./validate-CheZGRE7.mjs";
-import { n as PlatformApiError, r as PlatformClient } from "./client-DM9Kcf4e.mjs";
+import { i as validateMigrations, t as assertJournalCoherence } from "./validate-CnZPMq4q.mjs";
+import { n as PlatformApiError, r as PlatformClient } from "./client-BdzxubTS.mjs";
 import { n as drizzleKitBin } from "./yarn-pnp-DLbEFMT0.mjs";
-import { n as formatTimestamp } from "./gen-CufHEf42.mjs";
+import { n as formatTimestamp } from "./gen-CYN3wiov.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -156,7 +156,7 @@ function runDrizzleKit(root, args) {
 * already printed its own error.
 */
 async function runDrizzleKitWithDatabaseUrl(root, url, dialect, command) {
-	const { withPrivateDrizzleConfig } = await import("./config-QrJWu0IX.mjs");
+	const { withPrivateDrizzleConfig } = await import("./config-DYJV8aEH.mjs");
 	if (!withPrivateDrizzleConfig(root, url, dialect, (configPath) => {
 		try {
 			runDrizzleKit(root, [
@@ -186,12 +186,18 @@ async function withPgClient(root, fn) {
 		await client.end();
 	}
 }
-async function withMySqlClient(root, fn) {
-	const { toMySqlClient } = await import("./runner-mysql-DWwE8jKi.mjs");
+async function withMySqlClient(root, fn, options = {}) {
+	const { toMySqlClient } = await import("./runner-mysql-BcHnLUuM.mjs");
 	const { createConnection } = await import("mysql2/promise");
 	const connection = await createConnection({
 		uri: getLocalDatabaseUrl(root, "mysql"),
-		multipleStatements: true
+		multipleStatements: true,
+		...options.textValues ? {
+			dateStrings: true,
+			jsonStrings: true,
+			supportBigNumbers: true,
+			bigNumberStrings: true
+		} : {}
 	});
 	try {
 		return await fn(toMySqlClient(connection));
@@ -217,6 +223,7 @@ async function runDbCommand(root, args) {
 	else if (args.action === "studio") await runStudio(root, dialect, args.remote);
 	else if (args.action === "set-url") await runSetUrl(root, dialect);
 	else if (args.action === "connect") await runConnect(root, dialect, args);
+	else if (args.action === "restore") await runRestore(root, dialect, args);
 	else if (args.action === "rename-migrations") await runRenameMigrations(root, dialect);
 	else await runExport(root, args, dialect);
 }
@@ -245,7 +252,7 @@ function assertDatabaseProvider(value, source) {
 }
 async function loadDatabaseProvider(root, provider) {
 	if (provider === "neon") {
-		const { createNeonDatabaseProvider } = await import("./neon-n74ta1Pr.mjs");
+		const { createNeonDatabaseProvider } = await import("./neon-DTZr7Bu7.mjs");
 		return createNeonDatabaseProvider();
 	}
 	const requireFromProject = createRequire(join(root, "package.json"));
@@ -305,7 +312,7 @@ async function runPush(root, dialect) {
 		printSuccess("Database schema pushed.");
 		return;
 	}
-	const { writeDrizzleConfig } = await import("./config-QrJWu0IX.mjs");
+	const { writeDrizzleConfig } = await import("./config-DYJV8aEH.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	mkdirSync(dirname(dbPath), { recursive: true });
 	const configPath = writeDrizzleConfig(root, dbPath);
@@ -321,15 +328,15 @@ async function runPush(root, dialect) {
 	printSuccess("Database schema pushed.");
 }
 async function runGenerate(root, dialect) {
-	const { prepareProject } = await import("./prepare-CYT6tAzD.mjs");
-	const { PLACEHOLDER_DB_URL, writeDrizzleConfig } = await import("./config-QrJWu0IX.mjs");
+	const { prepareProject } = await import("./prepare-EVEbQ9n2.mjs");
+	const { PLACEHOLDER_DB_URL, writeDrizzleConfig } = await import("./config-DYJV8aEH.mjs");
 	await prepareProject(root);
 	const authSchemaPath = join(root, ".void", "better-auth-schema.ts");
 	const additionalSchemas = existsSync(authSchemaPath) ? [authSchemaPath] : void 0;
 	const configPath = writeDrizzleConfig(root, PLACEHOLDER_DB_URL[dialect], dialect, { additionalSchemas });
 	try {
 		if (dialect === "sqlite") {
-			const { generateValidatedSqliteMigrations } = await import("./generate-ClI89brV.mjs");
+			const { generateValidatedSqliteMigrations } = await import("./generate-DkEb9rL-.mjs");
 			await generateValidatedSqliteMigrations(readProjectPaths(root).migrationsDir, () => {
 				runDrizzleKit(root, [
 					"generate",
@@ -353,7 +360,7 @@ async function runStatus(root, dialect) {
 	const migrationsDir = paths.migrationsDir;
 	const allMigrations = collectMigrations(migrationsDir);
 	try {
-		assertJournalCoherence(migrationsDir, allMigrations);
+		assertJournalCoherence(migrationsDir, allMigrations, paths.sourceRelative);
 	} catch (err) {
 		log.error(getErrorMessage(err));
 		process.exit(1);
@@ -363,35 +370,36 @@ async function runStatus(root, dialect) {
 		return;
 	}
 	let localApplied;
+	let localError;
 	if (dialect === "postgresql") try {
-		const { readPgAppliedMigrations } = await import("./runner-pg-_Xncr3H5.mjs");
+		const { readPgAppliedMigrations } = await import("./runner-pg-Cgp-cr_p.mjs");
 		localApplied = await withPgClient(root, readPgAppliedMigrations);
-	} catch {
-		localApplied = [];
+	} catch (error) {
+		localError = error;
 	}
 	else if (dialect === "mysql") try {
-		const { readMySqlAppliedMigrations } = await import("./runner-mysql-DWwE8jKi.mjs");
+		const { readMySqlAppliedMigrations } = await import("./runner-mysql-BcHnLUuM.mjs");
 		localApplied = await withMySqlClient(root, readMySqlAppliedMigrations);
-	} catch {
-		localApplied = [];
+	} catch (error) {
+		localError = error;
 	}
 	else {
-		const { getAppliedMigrations } = await import("./runner-So9mYfcm.mjs");
+		const { getAppliedMigrations } = await import("./runner-WCdfeI0q.mjs");
 		const { databasePath: dbPath } = getLocalD1Target(root);
 		localApplied = (await getAppliedMigrations(dbPath)).map((m) => m.name);
 	}
-	const localSet = new Set(localApplied);
+	const localSet = localApplied ? new Set(localApplied) : null;
 	let remoteApplied = null;
 	if (readDeploymentPlatform(root) === "cloudflare") try {
 		if (dialect !== "sqlite") {
 			const databaseUrl = process.env.DATABASE_URL;
 			if (!databaseUrl) throw new Error("DATABASE_URL is not available.");
-			remoteApplied = (dialect === "postgresql" ? await (await import("./runner-pg-_Xncr3H5.mjs")).getPgAppliedMigrations(databaseUrl) : await (await import("./runner-mysql-DWwE8jKi.mjs")).getMySqlAppliedMigrations(databaseUrl)).map((name) => ({
+			remoteApplied = (dialect === "postgresql" ? await (await import("./runner-pg-Cgp-cr_p.mjs")).getPgAppliedMigrations(databaseUrl) : await (await import("./runner-mysql-BcHnLUuM.mjs")).getMySqlAppliedMigrations(databaseUrl)).map((name) => ({
 				name,
 				applied_at: ""
 			}));
 		} else {
-			const { readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-CrSUFRzJ.mjs");
+			const { readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-BFLCpUCV.mjs");
 			remoteApplied = (await readCloudflareD1Migrations(resolveCloudflareD1Context(root, configuredD1Binding(root)))).map((name) => ({
 				name,
 				applied_at: ""
@@ -406,19 +414,29 @@ async function runStatus(root, dialect) {
 		} catch {}
 	}
 	const remoteSet = remoteApplied ? new Set(remoteApplied.map((m) => m.name)) : null;
+	if (localSet === null) {
+		const message = `Local migration status is unavailable: ${getErrorMessage(localError)}`;
+		if (remoteSet === null) {
+			log.error(message);
+			process.exit(1);
+		}
+		log.warn(message);
+	}
 	const lines = [];
 	for (const migration of allMigrations) {
-		const localStatus = localSet.has(migration.name) ? import_picocolors.default.green("applied") : import_picocolors.default.yellow("pending");
+		const localStatus = localSet === null ? dim("unknown") : localSet.has(migration.name) ? import_picocolors.default.green("applied") : import_picocolors.default.yellow("pending");
 		let remotePart = "";
 		if (remoteSet !== null) remotePart = `  remote: ${remoteSet.has(migration.name) ? import_picocolors.default.green("applied") : import_picocolors.default.yellow("pending")}`;
 		lines.push(`  ${migration.name}  ${dim("local:")} ${localStatus}${remotePart}`);
 	}
 	log.info(lines.join("\n"));
-	const localPending = allMigrations.length - localSet.size;
 	const parts = [formatCount(allMigrations.length, "migration")];
-	if (localPending > 0) parts.push(`${localPending} pending locally`);
+	if (localSet !== null) {
+		const localPending = allMigrations.filter((m) => !localSet.has(m.name)).length;
+		if (localPending > 0) parts.push(`${localPending} pending locally`);
+	}
 	if (remoteSet !== null) {
-		const remotePending = allMigrations.length - remoteSet.size;
+		const remotePending = allMigrations.filter((m) => !remoteSet.has(m.name)).length;
 		if (remotePending > 0) parts.push(`${remotePending} pending remotely`);
 	}
 	outro(parts.join(", "));
@@ -431,6 +449,69 @@ const LOCAL_DATABASE_HOSTS = /* @__PURE__ */ new Set([
 	"[::1]"
 ]);
 /**
+* Objects that `void db reset` drops in `public` before it applies every migration again:
+* tables and views first, then standalone sequences, then enum, domain, range and composite
+* types. drizzle-kit creates them without `IF NOT EXISTS`, so any one that stays makes the
+* migration fail. Extension members stay, and so do sequences that a column owns: the table
+* drop removes them, and their names change when a table is renamed.
+*/
+const PG_RESET_OBJECTS = `SELECT kind, name FROM (
+  SELECT CASE rel.relkind WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'MATERIALIZED VIEW'
+           WHEN 'S' THEN 'SEQUENCE' ELSE 'TABLE' END AS kind,
+         rel.relname AS name, CASE rel.relkind WHEN 'S' THEN 1 ELSE 0 END AS step
+  FROM pg_class rel JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+  WHERE ns.nspname = 'public' AND rel.relkind IN ('r', 'p', 'v', 'm', 'S')
+    AND NOT EXISTS (
+      SELECT 1 FROM pg_depend dep WHERE dep.classid = 'pg_class'::regclass AND dep.objid = rel.oid
+        AND (dep.deptype = 'e' OR (rel.relkind = 'S' AND dep.deptype IN ('a', 'i')))
+    )
+  UNION ALL
+  SELECT 'TYPE', typ.typname, 2
+  FROM pg_type typ JOIN pg_namespace ns ON ns.oid = typ.typnamespace
+  WHERE ns.nspname = 'public'
+    AND (typ.typtype IN ('e', 'd', 'r')
+      OR (typ.typtype = 'c' AND (SELECT relkind FROM pg_class WHERE oid = typ.typrelid) = 'c'))
+    AND NOT EXISTS (
+      SELECT 1 FROM pg_depend dep WHERE dep.classid = 'pg_type'::regclass AND dep.objid = typ.oid
+        AND dep.deptype = 'e'
+    )
+) objects ORDER BY step, name`;
+/**
+* Objects in other schemas that `CASCADE` would also drop with the types ($1) and the views,
+* materialized views and sequences ($2) that reset drops in `public`: a column of that type or
+* its array type, a view, a function, a column default and so on, also through a type or
+* function in `public` that goes with them. Reset must not remove these, so it stops when there
+* are any. The TOAST table of a materialized view is part of it, so it does not count. The table
+* drops still remove what depends on a `public` table in another schema (a view, a foreign key,
+* an inheriting table); a view that also uses one of these objects is listed here too.
+*/
+const PG_RESET_OUTSIDE_DEPENDENTS = `WITH RECURSIVE dropped(classid, objid) AS (
+  SELECT 'pg_type'::regclass::oid, typ.oid FROM pg_type typ
+  WHERE typ.typnamespace = 'public'::regnamespace AND typ.typname = ANY($1::text[])
+  UNION ALL
+  SELECT 'pg_class'::regclass::oid, rel.oid FROM pg_class rel
+  WHERE rel.relnamespace = 'public'::regnamespace AND rel.relname = ANY($2::text[])
+  UNION
+  SELECT dep.classid, dep.objid FROM dropped
+  JOIN pg_depend dep ON dep.refclassid = dropped.classid AND dep.refobjid = dropped.objid
+  WHERE dep.classid IN ('pg_type'::regclass, 'pg_proc'::regclass)
+    AND (pg_identify_object(dep.classid, dep.objid, 0)).schema = 'public'
+)
+SELECT DISTINCT pg_describe_object(dep.classid, dep.objid, dep.objsubid) || ' uses '
+  || pg_describe_object(dep.refclassid, dep.refobjid, 0) AS object
+FROM dropped
+JOIN pg_depend dep ON dep.refclassid = dropped.classid AND dep.refobjid = dropped.objid
+WHERE NOT (dep.classid = 'pg_class'::regclass AND dep.deptype = 'i')
+  AND COALESCE((pg_identify_object(dep.classid, dep.objid, dep.objsubid)).schema, (
+  SELECT ns.nspname FROM pg_class rel JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+  WHERE rel.oid = CASE dep.classid
+    WHEN 'pg_attrdef'::regclass THEN (SELECT adrelid FROM pg_attrdef WHERE oid = dep.objid)
+    WHEN 'pg_rewrite'::regclass THEN (SELECT ev_class FROM pg_rewrite WHERE oid = dep.objid)
+    WHEN 'pg_trigger'::regclass THEN (SELECT tgrelid FROM pg_trigger WHERE oid = dep.objid)
+    WHEN 'pg_policy'::regclass THEN (SELECT polrelid FROM pg_policy WHERE oid = dep.objid)
+  END)) <> 'public'
+ORDER BY object`;
+/**
 * `.env` may hold the deployed database URL (`void db connect` writes it there), so ask before
 * dropping every table on any other host. Without a TTY, require `--yes`.
 */
@@ -446,39 +527,56 @@ async function confirmDropAllTables(host, target, yes) {
 		process.exit(0);
 	}
 }
+async function confirmReset(root, dialect, yes) {
+	if (dialect === "postgresql") {
+		const { Client } = await import("pg");
+		const { host, port, database } = new Client({ connectionString: getLocalDatabaseUrl(root, dialect) });
+		await confirmDropAllTables(host, `database "${database}" on ${host}:${port}`, yes);
+	} else if (dialect === "mysql") {
+		const { hostname, host, pathname } = new URL(getLocalDatabaseUrl(root, dialect));
+		await confirmDropAllTables(hostname, `database "${decodeURIComponent(pathname.slice(1))}" on ${host}`, yes);
+	}
+}
 async function resetDatabase(root, dialect, yes) {
-	const migrationsDir = readProjectPaths(root).migrationsDir;
+	const paths = readProjectPaths(root);
+	const migrationsDir = paths.migrationsDir;
 	const migrations = collectMigrations(migrationsDir);
 	try {
-		assertJournalCoherence(migrationsDir, migrations);
+		assertJournalCoherence(migrationsDir, migrations, paths.sourceRelative);
 	} catch (err) {
 		log.error(getErrorMessage(err));
 		process.exit(1);
 	}
+	await confirmReset(root, dialect, yes);
 	if (dialect === "postgresql") {
-		const { Client } = await import("pg");
-		const { host, port, database } = new Client({ connectionString: getLocalDatabaseUrl(root, dialect) });
-		await confirmDropAllTables(host, `database "${database}" on ${host}:${port}`, yes);
-		const { applyPgMigrations } = await import("./runner-pg-_Xncr3H5.mjs");
+		const { applyPgMigrations } = await import("./runner-pg-Cgp-cr_p.mjs");
 		await withPgClient(root, async (client) => {
-			const tables = await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
-			for (const row of tables.rows) await client.query(`DROP TABLE IF EXISTS "${row.tablename}" CASCADE`);
+			const objects = await client.query(PG_RESET_OBJECTS);
+			const names = (kind) => objects.rows.filter((row) => row.kind === kind).map((row) => row.name);
+			const types = names("TYPE");
+			const relations = [
+				...names("VIEW"),
+				...names("MATERIALIZED VIEW"),
+				...names("SEQUENCE")
+			];
+			const outside = types.length > 0 || relations.length > 0 ? await client.query(PG_RESET_OUTSIDE_DEPENDENTS, [types, relations]) : { rows: [] };
+			if (outside.rows.length > 0) throw new Error("db: Reset stopped before dropping anything. Dropping the views, sequences and types in the public schema would also remove these objects in other schemas:\n" + outside.rows.map((row) => `  - ${row.object}\n`).join("") + "Change or drop these objects, or move the views, sequences and types they use out of the public schema, then run the command again.");
+			for (const { kind, name } of objects.rows) await client.query(`DROP ${kind} IF EXISTS public.${quoteSqlIdentifier(name)} CASCADE`);
 			await applyPgMigrations(client, migrations);
 		});
 		return migrations.length;
 	}
 	if (dialect === "mysql") {
-		const { hostname, host, pathname } = new URL(getLocalDatabaseUrl(root, dialect));
-		await confirmDropAllTables(hostname, `database "${decodeURIComponent(pathname.slice(1))}" on ${host}`, yes);
-		const { applyPendingMySqlMigrations, withMySqlMigrationLock } = await import("./runner-mysql-DWwE8jKi.mjs");
+		const { applyPendingMySqlMigrations, withMySqlMigrationLock } = await import("./runner-mysql-BcHnLUuM.mjs");
 		await withMySqlClient(root, (client) => withMySqlMigrationLock(client, async () => {
-			const tables = await client.query("SELECT table_name AS table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'");
+			const tables = await client.query("SELECT table_name AS table_name, table_type AS table_type FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type IN ('BASE TABLE', 'VIEW')");
 			await client.query("SET FOREIGN_KEY_CHECKS = 0");
 			try {
 				for (const row of tables) {
 					if (row.table_name === "_void_migration_lock") continue;
+					const kind = row.table_type === "VIEW" ? "VIEW" : "TABLE";
 					const table = String(row.table_name).replaceAll("`", "``");
-					await client.query(`DROP TABLE IF EXISTS \`${table}\``);
+					await client.query(`DROP ${kind} IF EXISTS \`${table}\``);
 				}
 			} finally {
 				await client.query("SET FOREIGN_KEY_CHECKS = 1");
@@ -487,7 +585,7 @@ async function resetDatabase(root, dialect, yes) {
 		}));
 		return migrations.length;
 	}
-	const { runMigrations } = await import("./runner-So9mYfcm.mjs");
+	const { runMigrations } = await import("./runner-WCdfeI0q.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	rmSync(dbPath, { force: true });
 	rmSync(dbPath + "-wal", { force: true });
@@ -500,11 +598,13 @@ async function runReset(root, dialect, yes) {
 	printSuccess(`Database reset. Applied ${formatCount(count, "migration")}.`);
 }
 async function runSeed(root, file, dialect, yes) {
-	const migrationCount = await resetDatabase(root, dialect, yes);
-	log.step(`Reset database. Applied ${formatCount(migrationCount, "migration")}.`);
 	const seed = resolveSeedTarget(root, file);
-	if (seed.kind === "sql") {
-		const sql = readFileSync(seed.path, "utf-8");
+	const sql = seed.kind === "sql" ? readFileSync(seed.path, "utf-8") : void 0;
+	await confirmReset(root, dialect, yes);
+	const seedFn = sql === void 0 ? await loadSeedFunction(seed.path) : void 0;
+	const migrationCount = await resetDatabase(root, dialect, true);
+	log.step(`Reset database. Applied ${formatCount(migrationCount, "migration")}.`);
+	if (sql !== void 0) {
 		if (dialect === "postgresql") {
 			await withPgClient(root, async (client) => {
 				await client.query(sql);
@@ -519,7 +619,7 @@ async function runSeed(root, file, dialect, yes) {
 			printSuccess(`Seeded from ${seed.displayPath}.`);
 			return;
 		}
-		const { openSqliteDatabase } = await import("./runner-So9mYfcm.mjs");
+		const { openSqliteDatabase } = await import("./runner-WCdfeI0q.mjs");
 		const { databasePath: dbPath } = getLocalD1Target(root);
 		const db = await openSqliteDatabase(dbPath);
 		try {
@@ -527,7 +627,7 @@ async function runSeed(root, file, dialect, yes) {
 		} finally {
 			db.close();
 		}
-	} else await runSeedModule(root, seed.path, dialect);
+	} else await runSeedModule(root, seedFn, dialect);
 	log.info(dim("Restart your dev server if it's running."));
 	printSuccess(`Seeded from ${seed.displayPath}.`);
 }
@@ -604,18 +704,14 @@ async function confirmDestructiveRemote(sql) {
 async function runExecute(root, command, file, dialect, remote) {
 	if (remote) {
 		const directCloudflare = readDeploymentPlatform(root) === "cloudflare";
-		if (dialect === "sqlite" && file && !directCloudflare) {
-			log.error("--file is not yet supported with --remote D1; pipe statements through stdin or run them one at a time.");
-			process.exit(1);
-		}
-		const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+		const sql = file ? readFileSync(resolve(root, file), "utf-8") : command;
 		if (directCloudflare) {
 			if (!await confirmDestructiveRemote(sql)) {
 				log.info("Cancelled.");
 				process.exit(0);
 			}
 			if (dialect === "sqlite") {
-				const { executeCloudflareD1Sql, resolveCloudflareD1Context } = await import("./cloudflare-operations-CrSUFRzJ.mjs");
+				const { executeCloudflareD1Sql, resolveCloudflareD1Context } = await import("./cloudflare-operations-BFLCpUCV.mjs");
 				const rows = await executeCloudflareD1Sql(resolveCloudflareD1Context(root, configuredD1Binding(root)), sql);
 				if (rows.length > 0) printTable(rows);
 			} else {
@@ -649,10 +745,11 @@ async function runExecute(root, command, file, dialect, remote) {
 			return;
 		}
 		const platformClient = new PlatformClient(token, { root });
-		let binding = configuredD1Binding(root);
+		const configuredBinding = configuredD1Binding(root);
+		let binding = configuredBinding;
 		try {
-			const d1Resource = (await platformClient.getResources(projectConfig.projectId)).find((r) => r.type === "d1");
-			if (d1Resource) binding = d1Resource.binding_name;
+			const d1Bindings = (await platformClient.getResources(projectConfig.projectId)).filter((r) => r.type === "d1").map((r) => r.binding_name);
+			if (!d1Bindings.includes(configuredBinding) && d1Bindings.length === 1) binding = d1Bindings[0];
 		} catch {}
 		const proxyUrl = getProxyUrl(root);
 		ensurePlatformProxyAccess(platformClient.apiUrl, proxyUrl);
@@ -698,7 +795,7 @@ async function runExecute(root, command, file, dialect, remote) {
 		return;
 	}
 	if (dialect === "postgresql") {
-		const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+		const sql = file ? readFileSync(resolve(root, file), "utf-8") : command;
 		await withPgClient(root, async (client) => {
 			const result = await client.query(sql);
 			if (result.rows && result.rows.length > 0) printTable(result.rows);
@@ -707,7 +804,7 @@ async function runExecute(root, command, file, dialect, remote) {
 		return;
 	}
 	if (dialect === "mysql") {
-		const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+		const sql = file ? readFileSync(resolve(root, file), "utf-8") : command;
 		await withMySqlClient(root, async (client) => {
 			const rows = await client.query(sql);
 			if (rows.length > 0) printTable(rows);
@@ -715,13 +812,13 @@ async function runExecute(root, command, file, dialect, remote) {
 		printSuccess("SQL executed successfully.");
 		return;
 	}
-	const { openSqliteDatabase } = await import("./runner-So9mYfcm.mjs");
+	const { openSqliteDatabase } = await import("./runner-WCdfeI0q.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
-		log.error("No local database found. Run `void dev` first.");
+		log.error("No local database found. Start the dev server first.");
 		process.exit(1);
 	}
-	const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+	const sql = file ? readFileSync(resolve(root, file), "utf-8") : command;
 	const db = await openSqliteDatabase(dbPath);
 	try {
 		const trimmed = sql.trimStart();
@@ -754,7 +851,7 @@ async function runMigrate(root, dialect, remote) {
 	const migrationsDir = paths.migrationsDir;
 	const rawMigrations = collectMigrations(migrationsDir);
 	try {
-		assertJournalCoherence(migrationsDir, rawMigrations);
+		assertJournalCoherence(migrationsDir, rawMigrations, paths.sourceRelative);
 	} catch (err) {
 		log.error(getErrorMessage(err));
 		process.exit(1);
@@ -779,11 +876,11 @@ async function runMigrate(root, dialect, remote) {
 				let appliedNames;
 				let applyMigrations;
 				if (dialect === "postgresql") {
-					const { getPgAppliedMigrations, runPgMigrations } = await import("./runner-pg-_Xncr3H5.mjs");
+					const { getPgAppliedMigrations, runPgMigrations } = await import("./runner-pg-Cgp-cr_p.mjs");
 					appliedNames = await getPgAppliedMigrations(databaseUrl);
 					applyMigrations = () => runPgMigrations(migrationsDir, databaseUrl);
 				} else {
-					const { getMySqlAppliedMigrations, runMySqlMigrations } = await import("./runner-mysql-DWwE8jKi.mjs");
+					const { getMySqlAppliedMigrations, runMySqlMigrations } = await import("./runner-mysql-BcHnLUuM.mjs");
 					appliedNames = await getMySqlAppliedMigrations(databaseUrl);
 					applyMigrations = () => runMySqlMigrations(migrationsDir, databaseUrl);
 				}
@@ -808,7 +905,7 @@ async function runMigrate(root, dialect, remote) {
 				log.info(`No migration files found in ${paths.sourceRelative("db/migrations")}/`);
 				return;
 			}
-			const { applyCloudflareD1Migrations, readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-CrSUFRzJ.mjs");
+			const { applyCloudflareD1Migrations, readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-BFLCpUCV.mjs");
 			const binding = configuredD1Binding(root);
 			const context = resolveCloudflareD1Context(root, binding);
 			const remoteBefore = new Set(await readCloudflareD1Migrations(context));
@@ -823,8 +920,13 @@ async function runMigrate(root, dialect, remote) {
 				log.error(getErrorMessage(error));
 				process.exit(1);
 			}
-			const { checkWranglerMigrationApplySet, parseRootWranglerConfig } = await import("./deploy-9lgfhrXS.mjs");
-			const applySet = await checkWranglerMigrationApplySet(context.operation.configPath, parseRootWranglerConfig(context.operation.configPath), binding, context.migrationsDir, rawMigrations);
+			if (!context.migrationsDir) {
+				const dir = paths.sourceRelative("db/migrations");
+				log.error(`db: D1 binding ${binding} has no "migrations_dir", so Cloudflare would apply ./migrations instead of ${dir}/. Add "migrations_dir": "./${dir}" to that D1 binding in your Cloudflare config, then run the command again.`);
+				process.exit(1);
+			}
+			const { checkWranglerMigrationApplySet, parseRootWranglerConfig } = await import("./deploy-Dc0XsCQj.mjs");
+			const applySet = await checkWranglerMigrationApplySet(context.operation.configPath, parseRootWranglerConfig(context.operation.configPath), binding, context.migrationsDir, rawMigrations, paths.sourceRelative("db/migrations"));
 			if (!applySet.ok) {
 				log.error(applySet.reason);
 				process.exit(1);
@@ -885,7 +987,7 @@ async function runMigrate(root, dialect, remote) {
 		return;
 	}
 	if (dialect === "postgresql") {
-		const { applyPgMigrations, readPgAppliedMigrations } = await import("./runner-pg-_Xncr3H5.mjs");
+		const { applyPgMigrations, readPgAppliedMigrations } = await import("./runner-pg-Cgp-cr_p.mjs");
 		const applied = await withPgClient(root, async (client) => {
 			const appliedNames = await readPgAppliedMigrations(client).catch(() => []);
 			try {
@@ -904,7 +1006,7 @@ async function runMigrate(root, dialect, remote) {
 		return;
 	}
 	if (dialect === "mysql") {
-		const { applyMySqlMigrations, readMySqlAppliedMigrations } = await import("./runner-mysql-DWwE8jKi.mjs");
+		const { applyMySqlMigrations, readMySqlAppliedMigrations } = await import("./runner-mysql-BcHnLUuM.mjs");
 		const applied = await withMySqlClient(root, async (client) => {
 			const appliedNames = await readMySqlAppliedMigrations(client).catch(() => []);
 			try {
@@ -922,7 +1024,7 @@ async function runMigrate(root, dialect, remote) {
 		}
 		return;
 	}
-	const { getAppliedMigrations, runMigrations } = await import("./runner-So9mYfcm.mjs");
+	const { getAppliedMigrations, runMigrations } = await import("./runner-WCdfeI0q.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	try {
 		const existingRows = await getAppliedMigrations(dbPath);
@@ -931,7 +1033,7 @@ async function runMigrate(root, dialect, remote) {
 		log.error(getErrorMessage(err));
 		process.exit(1);
 	}
-	const applied = await runMigrations(migrationsDir, dbPath);
+	const applied = await runMigrations(migrationsDir, dbPath, paths.sourceRelative);
 	if (applied.length === 0) log.info("All migrations are up to date.");
 	else {
 		for (const name of applied) log.step(name);
@@ -939,10 +1041,59 @@ async function runMigrate(root, dialect, remote) {
 		printSuccess(`Applied ${formatCount(applied.length, "migration")}.`);
 	}
 }
+async function runRestore(root, dialect, { target, platform: explicitPlatform, yes }) {
+	const platform = readDeploymentPlatform(root);
+	const directCloudflare = explicitPlatform === "cloudflare" || platform === "cloudflare" || platform === null && !readProjectConfig(root) && await hasDeployedCloudflareDatabase(root);
+	if (dialect !== "sqlite") {
+		log.error("db: `void db restore` restores D1 databases only.");
+		process.exit(1);
+	}
+	if (!directCloudflare) {
+		log.error("db: `void db restore` restores the D1 database of a direct Cloudflare deploy. After a one-off `void deploy --platform cloudflare`, run it with `--platform cloudflare`.");
+		process.exit(1);
+	}
+	const { readCloudflareD1Migrations, resolveCloudflareD1Context, restoreCloudflareD1Database } = await import("./cloudflare-operations-BFLCpUCV.mjs");
+	const binding = configuredD1Binding(root);
+	const context = resolveCloudflareD1Context(root, binding);
+	const database = `D1 database ${context.migrateToken} (${binding})`;
+	const point = "bookmark" in target ? `bookmark ${target.bookmark}` : target.timestamp;
+	if (!yes) {
+		if (!process.stdin.isTTY) {
+			log.error(`db: Refusing to restore ${database} without confirmation. Re-run with --yes.`);
+			process.exit(1);
+		}
+		const ok = await confirm({
+			message: `This restores ${database} to ${point} and discards every write made after it. Continue?`,
+			initialValue: false
+		});
+		if (isCancel(ok) || !ok) {
+			log.info("Cancelled.");
+			process.exit(0);
+		}
+	}
+	let previousBookmark;
+	try {
+		previousBookmark = await restoreCloudflareD1Database(context, target);
+	} catch (error) {
+		log.error(`db: Could not restore ${database} to ${point}: ${getErrorMessage(error)}\nRestore points expire after 7 days on Workers Free and 30 days on Workers Paid. To undo an older migration, write a new migration that reverses it.`);
+		process.exit(1);
+	}
+	const platformFlag = platform === "cloudflare" ? "" : " --platform cloudflare";
+	if (previousBookmark) log.info(`To undo this restore, run \`void db restore${platformFlag} --bookmark=${previousBookmark}\`.`);
+	const paths = readProjectPaths(root);
+	try {
+		const applied = new Set(await readCloudflareD1Migrations(context));
+		const unapplied = collectMigrations(paths.migrationsDir).filter((migration) => !applied.has(migration.name));
+		if (unapplied.length > 0) log.warn(`The remote database does not have these migrations applied: ${unapplied.map((migration) => migration.name).join(", ")}. The next \`void deploy${platformFlag}\` applies them. Fix or remove a migration that caused the problem before you deploy.`);
+	} catch (error) {
+		log.warn(`Could not read the applied migrations after the restore: ${getErrorMessage(error)}. ` + (platformFlag ? `The next \`void deploy${platformFlag}\` applies any migration the restore rewound.` : "Run `void db status` to check them."));
+	}
+	printSuccess(`Restored ${database} to ${point}.`);
+}
 async function runStudio(root, dialect, remote) {
 	if (remote) {
 		if (dialect === "sqlite") {
-			log.error("Remote D1 studio is not yet supported. Use `void db execute --remote` for ad-hoc queries against your deployed D1 database.");
+			log.error("Remote Studio supports PostgreSQL and MySQL databases. For D1, use `void db execute --remote` to query the deployed database.");
 			process.exit(1);
 		}
 		let dbUrl;
@@ -975,10 +1126,10 @@ async function runStudio(root, dialect, remote) {
 		await runDrizzleKitWithDatabaseUrl(root, url, dialect, "studio");
 		return;
 	}
-	const { writeDrizzleConfig } = await import("./config-QrJWu0IX.mjs");
+	const { writeDrizzleConfig } = await import("./config-DYJV8aEH.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
-		log.error("No local database found. Run `void dev` first.");
+		log.error("No local database found. Start the dev server first.");
 		process.exit(1);
 	}
 	const configPath = writeDrizzleConfig(root, dbPath);
@@ -993,21 +1144,37 @@ async function runStudio(root, dialect, remote) {
 		process.exit(1);
 	}
 }
+/** A direct Cloudflare deploy records its D1 or Hyperdrive id in the checked-in Cloudflare config. */
+async function hasDeployedCloudflareDatabase(root) {
+	const { readRootWranglerConfig } = await import("./wrangler-DAdxHEzh.mjs");
+	const { isRealD1Id, isRealHyperdriveId } = await import("./provision-BgXFDv0d.mjs");
+	const config = readRootWranglerConfig(root)?.config;
+	const entries = (key) => {
+		const value = config?.[key];
+		return Array.isArray(value) ? value.filter((entry) => !!entry && typeof entry === "object") : [];
+	};
+	return entries("d1_databases").some((entry) => isRealD1Id(entry.database_id)) || entries("hyperdrive").some((entry) => isRealHyperdriveId(entry.id));
+}
 async function runRenameMigrations(root, dialect) {
-	const migrationsDir = readProjectPaths(root).migrationsDir;
+	const paths = readProjectPaths(root);
+	const migrationsDir = paths.migrationsDir;
+	const dir = paths.sourceRelative("db/migrations");
 	if (!existsSync(migrationsDir)) {
 		log.info("No migrations directory found.");
 		return;
 	}
 	const currentMigrations = collectMigrations(migrationsDir);
 	try {
-		assertJournalCoherence(migrationsDir, currentMigrations);
+		assertJournalCoherence(migrationsDir, currentMigrations, paths.sourceRelative);
 	} catch (err) {
 		log.error(getErrorMessage(err));
 		process.exit(1);
 	}
 	if (existsSync(join(migrationsDir, "migrations.js"))) {
-		log.error("This project uses Drizzle's bundled migration format (db/migrations/migrations.js).\n`void db rename-migrations` cannot rename migrations in bundled mode because\n`migrations.js` contains static imports of the SQL files by filename.\n\nDelete db/migrations/migrations.js and re-run `void db generate` to migrate away\nfrom bundled mode, then retry `void db rename-migrations`.");
+		log.error(`This project uses Drizzle's bundled migration format (${dir}/migrations.js).\n\`void db rename-migrations\` cannot rename migrations in bundled mode because
+\`migrations.js\` contains static imports of the SQL files by filename.
+
+Delete ${dir}/migrations.js and re-run \`void db generate\` to migrate away\nfrom bundled mode, then retry \`void db rename-migrations\`.`);
 		process.exit(1);
 	}
 	const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql") && f !== "seed.sql").sort();
@@ -1016,6 +1183,16 @@ async function runRenameMigrations(root, dialect) {
 		log.info("No migrations with numeric prefixes found. Nothing to rename.");
 		return;
 	}
+	const platform = readDeploymentPlatform(root);
+	const config = readProjectConfig(root);
+	if (platform === "cloudflare" || !config && platform !== "void" && await hasDeployedCloudflareDatabase(root)) {
+		log.error("`void db rename-migrations` does not support direct Cloudflare deploys.\nVoid cannot rename the migration records in your deployed database, so the next deploy would run the renamed migrations again.\nKeep the current file names. New migrations use timestamps and run after them.");
+		process.exit(1);
+	}
+	if (platform === "void" && !config) {
+		log.error("This project deploys to Void but is not linked, so Void cannot rename the migration records in its deployed database.\nRun `void project link`, then run `void db rename-migrations` again.");
+		process.exit(1);
+	}
 	const timestampFiles = files.filter((f) => /^\d{14}_/.test(f));
 	let baseTime;
 	if (timestampFiles.length > 0) {
@@ -1042,7 +1219,7 @@ async function runRenameMigrations(root, dialect) {
 	const metaDir = join(migrationsDir, "meta");
 	const journalPath = join(metaDir, "_journal.json");
 	const originalJournalBytes = existsSync(journalPath) ? readFileSync(journalPath) : null;
-	const journal = readJournal(migrationsDir);
+	const journal = readJournal(migrationsDir, paths.sourceRelative);
 	const snapshotPrefix = (tag) => tag.split("_")[0];
 	const snapshotPathFor = (tag) => join(metaDir, `${snapshotPrefix(tag)}_snapshot.json`);
 	if (journal && journal.entries.length > 0) {
@@ -1054,13 +1231,12 @@ async function runRenameMigrations(root, dialect) {
 		}
 		if (missingSnapshots.length > 0) {
 			log.error("db: Cannot rename migrations because one or more Drizzle snapshot files are missing:");
-			for (const p of missingSnapshots) log.error(`  - db/migrations/${p}`);
+			for (const p of missingSnapshots) log.error(`  - ${dir}/${p}`);
 			log.error("\nRestore the missing snapshot(s) from version control, or reset the migration directory with `void db generate`, then retry.");
 			process.exit(1);
 		}
 	}
 	const token = getToken(root);
-	const config = readProjectConfig(root);
 	let remoteRenamed = false;
 	if (config && !token) {
 		log.error("Project is linked but you are not logged in.\nRun `void account login` first so remote migration records can be updated.");
@@ -1091,7 +1267,8 @@ async function runRenameMigrations(root, dialect) {
 		if (journalRewritten && originalJournalBytes !== null) try {
 			writeFileSync(journalPath, originalJournalBytes);
 		} catch (error) {
-			log.warn("Could not restore db/migrations/meta/_journal.json after rollback. The journal may be in a partial state.\nRegenerate it with `void db generate`, or restore it from version control.");
+			log.warn(`Could not restore ${dir}/meta/_journal.json after rollback. The journal may be in a partial state.
+Regenerate it with \`void db generate\`, or restore it from version control.`);
 			log.warn(String(error));
 		}
 		if (remoteRenamed && token && config) try {
@@ -1130,8 +1307,8 @@ async function runRenameMigrations(root, dialect) {
 		await rollback("db: Failed to rename migration files. All changes have been reverted.", err);
 	}
 	if (journal) try {
-		const current = readJournal(migrationsDir);
-		if (!current) throw new Error("db: db/migrations/meta/_journal.json disappeared mid-run. File renames will be reverted.");
+		const current = readJournal(migrationsDir, paths.sourceRelative);
+		if (!current) throw new Error(`db: ${dir}/meta/_journal.json disappeared mid-run. File renames will be reverted.`);
 		const renameMap = /* @__PURE__ */ new Map();
 		for (const { from, to } of renames) renameMap.set(stripSqlExt(from), stripSqlExt(to));
 		const updatedEntries = current.entries.map((entry) => {
@@ -1148,7 +1325,7 @@ async function runRenameMigrations(root, dialect) {
 			entries: updatedEntries
 		});
 	} catch (err) {
-		await rollback("db: Failed to update db/migrations/meta/_journal.json. File renames have been reverted.", err);
+		await rollback(`db: Failed to update ${dir}/meta/_journal.json. File renames have been reverted.`, err);
 	}
 	if (dialect === "postgresql") try {
 		await withPgClient(root, async (client) => {
@@ -1168,13 +1345,20 @@ async function runRenameMigrations(root, dialect) {
 	else if (dialect === "mysql") try {
 		await withMySqlClient(root, async (client) => {
 			if ((await client.query("SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = '_void_migrations' LIMIT 1")).length === 0) return;
-			for (const { from, to } of renames) await client.query("UPDATE `_void_migrations` SET `name` = ? WHERE `name` = ?", [to, from]);
+			await client.query("START TRANSACTION");
+			try {
+				for (const { from, to } of renames) await client.query("UPDATE `_void_migrations` SET `name` = ? WHERE `name` = ?", [to, from]);
+				await client.query("COMMIT");
+			} catch (err) {
+				await client.query("ROLLBACK").catch(() => {});
+				throw err;
+			}
 		});
 	} catch (err) {
 		await rollback("db: Failed to update MySQL tracking table. File renames have been reverted.\nFix the database connection and run `void db rename-migrations` again.", err);
 	}
 	else {
-		const { openSqliteDatabase } = await import("./runner-So9mYfcm.mjs");
+		const { openSqliteDatabase } = await import("./runner-WCdfeI0q.mjs");
 		const { databasePath: dbPath } = getLocalD1Target(root);
 		if (existsSync(dbPath)) try {
 			const db = await openSqliteDatabase(dbPath);
@@ -1197,12 +1381,23 @@ async function runRenameMigrations(root, dialect) {
 	}
 	printSuccess(`Renamed ${formatCount(renames.length, "migration")} to timestamp format.`);
 }
+const INTERNAL_TABLES = /* @__PURE__ */ new Set([
+	"_void_migrations",
+	"_void_migration_attempts",
+	"_void_migration_lock",
+	"_void_migration_fences",
+	"__drizzle_migrations"
+]);
+function isInternalTable(name, dialect) {
+	if (INTERNAL_TABLES.has(name)) return true;
+	return dialect === "sqlite" && (name === "_migrations" || name.startsWith("_cf_") || name.startsWith("sqlite_"));
+}
 function formatMySqlExportValue(value) {
 	if (value === null || value === void 0) return "NULL";
 	if (typeof value === "number" || typeof value === "bigint") return String(value);
 	if (typeof value === "boolean") return value ? "1" : "0";
 	if (value instanceof Uint8Array) return `X'${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}'`;
-	return `'${(value instanceof Date ? value.toISOString() : String(value)).replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
+	return `'${String(value).replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
 }
 function formatSqliteExportValue(value) {
 	if (value === null) return "NULL";
@@ -1222,7 +1417,7 @@ async function runExport(root, args, dialect) {
 					process.exit(1);
 				}
 				tables = [args.table];
-			} else tables = (await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename NOT LIKE '\\_%' ORDER BY tablename")).rows.map((row) => String(row.tablename));
+			} else tables = (await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename")).rows.map((row) => String(row.tablename)).filter((name) => !isInternalTable(name, dialect));
 			if (!args.noSchema) await assertPgExportableSchema(client, tables, !args.table);
 			const sequences = await exportPgSequences(client, tables, args);
 			parts.push(...sequences.before);
@@ -1274,14 +1469,14 @@ async function runExport(root, args, dialect) {
 		});
 		const output = parts.join("\n");
 		if (args.output) {
-			writeFileSync(join(root, args.output), output);
+			writeFileSync(resolve(root, args.output), output);
 			printSuccess(`Exported to ${args.output}`);
 		} else process.stdout.write(output);
 		return;
 	}
 	if (dialect === "mysql") {
 		const parts = [];
-		await withMySqlClient(root, async (client) => {
+		const exportTables = async (client) => {
 			let tables;
 			if (args.table) {
 				if ((await client.query("SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ?", [args.table])).length === 0) {
@@ -1289,8 +1484,9 @@ async function runExport(root, args, dialect) {
 					process.exit(1);
 				}
 				tables = [args.table];
-			} else tables = (await client.query("SELECT table_name AS table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE' AND table_name NOT LIKE '\\_%' ORDER BY table_name")).map((row) => String(row.table_name));
-			parts.push("SET FOREIGN_KEY_CHECKS = 0;");
+			} else tables = (await client.query("SELECT table_name AS table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE' ORDER BY table_name")).map((row) => String(row.table_name)).filter((name) => !isInternalTable(name, dialect));
+			await client.query("SET time_zone = '+00:00'");
+			parts.push("SET FOREIGN_KEY_CHECKS = 0;", "SET time_zone = '+00:00';");
 			for (const table of tables) {
 				const escapedTable = table.replaceAll("`", "``");
 				if (!args.noSchema) {
@@ -1309,18 +1505,19 @@ async function runExport(root, args, dialect) {
 				parts.push("");
 			}
 			parts.push("SET FOREIGN_KEY_CHECKS = 1;", "");
-		});
+		};
+		await withMySqlClient(root, exportTables, { textValues: true });
 		const output = parts.join("\n");
 		if (args.output) {
-			writeFileSync(join(root, args.output), output);
+			writeFileSync(resolve(root, args.output), output);
 			printSuccess(`Exported to ${args.output}`);
 		} else process.stdout.write(output);
 		return;
 	}
-	const { openSqliteDatabase } = await import("./runner-So9mYfcm.mjs");
+	const { openSqliteDatabase } = await import("./runner-WCdfeI0q.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
-		log.error("No local database found. Run `void dev` first.", errOut);
+		log.error("No local database found. Start the dev server first.", errOut);
 		process.exit(1);
 	}
 	const db = await openSqliteDatabase(dbPath, { readonly: true });
@@ -1332,7 +1529,7 @@ async function runExport(root, args, dialect) {
 				process.exit(1);
 			}
 			tables = [args.table];
-		} else tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '\\_%' ESCAPE '\\' ORDER BY name").all().map((row) => String(row.name)).filter((name) => !name.startsWith("sqlite_"));
+		} else tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all().map((row) => String(row.name)).filter((name) => !isInternalTable(name, dialect));
 		const parts = [];
 		for (const table of tables) {
 			if (!args.noSchema) {
@@ -1367,14 +1564,14 @@ async function runExport(root, args, dialect) {
 			]) for (const object of schemaObjects) {
 				if (object.type !== type) continue;
 				if (type === "view") {
-					if (args.table || object.name.startsWith("_")) continue;
+					if (args.table || isInternalTable(object.name, dialect)) continue;
 				} else if (!tables.includes(object.tbl_name)) continue;
 				parts.push(object.sql.trim().replace(/;?$/, ";"));
 			}
 		}
 		const output = parts.join("\n");
 		if (args.output) {
-			writeFileSync(join(root, args.output), output);
+			writeFileSync(resolve(root, args.output), output);
 			printSuccess(`Exported to ${args.output}`);
 		} else process.stdout.write(output);
 	} finally {
@@ -1444,18 +1641,16 @@ function toSeedTarget(root, seedPath, displayPath) {
 	log.error(`db: Unsupported seed file '${normalizedDisplay}'. Use .sql, .ts, .mts, .js, or .mjs.`);
 	process.exit(1);
 }
-async function runSeedModule(root, seedPath, dialect) {
-	const seed = await loadSeedFunction(seedPath);
+async function runSeedModule(root, seed, dialect) {
 	const schema = await loadSeedSchema(root);
 	if (dialect === "postgresql") {
 		const { drizzle } = await import("drizzle-orm/node-postgres");
 		await withPgClient(root, async (client) => {
 			const options = getDrizzleSchemaOptions(schema);
 			const drizzleClient = client;
-			const db = options ? drizzle(drizzleClient, options) : drizzle(drizzleClient);
 			await seed({
 				dialect,
-				db,
+				db: options ? drizzle(drizzleClient, options) : drizzle(drizzleClient),
 				schema
 			});
 		});
@@ -1481,7 +1676,7 @@ async function runSeedModule(root, seedPath, dialect) {
 		return;
 	}
 	const { drizzle } = await import("drizzle-orm/better-sqlite3");
-	const { openSqliteDatabase } = await import("./runner-So9mYfcm.mjs");
+	const { openSqliteDatabase } = await import("./runner-WCdfeI0q.mjs");
 	const { databasePath: dbPath } = getLocalD1Target(root);
 	const sqlite = await openSqliteDatabase(dbPath);
 	try {
@@ -1502,7 +1697,7 @@ async function loadSeedFunction(seedPath) {
 	return seed;
 }
 async function loadSeedSchema(root) {
-	const { discoverSchema } = await import("./discover-ClzFSwns.mjs");
+	const { discoverSchema } = await import("./discover-D4TPKo57.mjs");
 	const location = discoverSchema(root, readProjectPaths(root));
 	if (!location) return {};
 	if (location.type === "file") {