void 0.10.12 → 0.20.0

package/dist/{db-DOiJMRt2.mjs → db-BxoUWL0F.mjs}

@@ -1,16 +1,80 @@
-import { a as join, c as resolve, r as extname, s as relative } from "./dist-DaKKDf8D.mjs";
-import { D as outro, S as confirm, T as log, a as cliTitle, j as isCancel, s as dim, u as import_picocolors, w as intro } from "./agents-CtgBYqld.mjs";
-import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
-import { t as cfAccessHeaders } from "./cf-access-Bqw81xAf.mjs";
-import { b as readProjectConfig, f as getToken, m as isStagingMode, n as PlatformClient, t as PlatformApiError } from "./client-Gb71-XkG.mjs";
-import { c as getDatabaseDialect, f as readConfig, p as resolveBindingNames } from "./config-BkTvs43g.mjs";
-import { r as detectFramework } from "./plugin-inference-DMeavIJ6.mjs";
-import { c as collectMigrations, d as stripSqlExt, f as writeJournal, n as listDrizzleArtifacts, r as validateMigrations, t as assertJournalCoherence, u as readJournal } from "./validate-Cw_RLeTj.mjs";
-import { n as STAGING_PROXY_URL, t as DEFAULT_PROXY_URL } from "./proxy-D-3_D-Gl.mjs";
-import { formatTimestamp } from "./gen-o_w-8yI8.mjs";
+import { c as relative, i as extname, l as resolve, o as join, t as basename } from "./dist-BrsS7cai.mjs";
+import { D as log, E as intro, F as isCancel, a as dim, c as import_picocolors, k as outro, r as cliTitle, w as confirm } from "./output-tFQLLj26.mjs";
+import { n as readProjectPaths } from "./project-paths-SK8nMHPp.mjs";
+import { t as cfAccessHeaders } from "./cf-access-AJ1ehiFR.mjs";
+import { b as readDeploymentPlatform, c as getToken, o as getProxyUrl, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
+import { c as getDatabaseDialect, f as readConfig, p as resolveBindingNames } from "./config-BQFq7QvD.mjs";
+import { r as detectFramework } from "./plugin-inference-BDRfZngg.mjs";
+import { c as collectMigrations, d as stripSqlExt, f as writeJournal, n as listDrizzleArtifacts, r as validateMigrations, t as assertJournalCoherence, u as readJournal } from "./validate-Bihr8WBi.mjs";
+import { t as resolveLocalD1Target } from "./local-d1-BE8KBbMy.mjs";
+import { a as loadLocalEnv } from "./env-D4Emu-M_.mjs";
+import { n as PlatformClient, t as PlatformApiError } from "./client-CyCHWSO_.mjs";
+import { formatTimestamp } from "./gen-BKw6qHIg.mjs";
+import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { execFileSync } from "node:child_process";
+//#region src/cli/db-export-sequences.ts
+function quoteSqlIdentifier(value) {
+	return `"${value.replaceAll("\"", "\"\"")}"`;
+}
+function quoteSqlString(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+/** Restore SERIAL dependencies before tables, ownership/state after their data. */
+async function exportPgSequences(client, tables, options) {
+	const result = await client.query(`SELECT ns.nspname AS schema_name, seq.relname AS sequence_name,
+      tbl.relname AS table_name, col.attname AS column_name,
+      format_type(s.seqtypid, NULL) AS data_type,
+      s.seqstart::text AS start_value, s.seqincrement::text AS increment_by,
+      s.seqmin::text AS min_value, s.seqmax::text AS max_value,
+      s.seqcache::text AS cache_size, s.seqcycle AS cycle
+    FROM pg_sequence s
+    JOIN pg_class seq ON seq.oid = s.seqrelid
+    JOIN pg_namespace ns ON ns.oid = seq.relnamespace
+    JOIN pg_depend dep ON dep.objid = seq.oid AND dep.classid = 'pg_class'::regclass AND dep.deptype = 'a'
+    JOIN pg_class tbl ON tbl.oid = dep.refobjid
+    JOIN pg_namespace tblns ON tblns.oid = tbl.relnamespace
+    JOIN pg_attribute col ON col.attrelid = tbl.oid AND col.attnum = dep.refobjsubid
+    WHERE tblns.nspname = 'public' AND tbl.relname = ANY($1::text[])
+    ORDER BY ns.nspname, seq.relname`, [tables]);
+	const before = [];
+	const after = [];
+	for (const seq of result.rows) {
+		const name = `${quoteSqlIdentifier(seq.schema_name)}.${quoteSqlIdentifier(seq.sequence_name)}`;
+		if (!options.noSchema) {
+			before.push(`CREATE SEQUENCE ${name} AS ${seq.data_type} INCREMENT BY ${seq.increment_by} MINVALUE ${seq.min_value} MAXVALUE ${seq.max_value} START WITH ${seq.start_value} CACHE ${seq.cache_size} ${seq.cycle ? "CYCLE" : "NO CYCLE"};`);
+			after.push(`ALTER SEQUENCE ${name} OWNED BY "public".${quoteSqlIdentifier(seq.table_name)}.${quoteSqlIdentifier(seq.column_name)};`);
+		}
+		if (!options.noData) {
+			const value = (await client.query(`SELECT last_value::text, is_called FROM ${name}`)).rows[0];
+			after.push(`SELECT pg_catalog.setval(${quoteSqlString(name)}, ${value.last_value}, ${value.is_called});`);
+		}
+	}
+	return {
+		before,
+		after
+	};
+}
+/** Add constraints after all tables/data so cross-table references can resolve. */
+async function exportPgConstraints(client, tables) {
+	const constraints = await client.query(`
+    SELECT tbl.relname AS table_name, con.conname AS name, pg_get_constraintdef(con.oid) AS definition
+    FROM pg_constraint con JOIN pg_class tbl ON tbl.oid = con.conrelid
+    JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+    WHERE ns.nspname = 'public' AND tbl.relname = ANY($1::text[])
+      AND con.contype IN ('p', 'u', 'f', 'c', 'x')
+    ORDER BY CASE WHEN con.contype = 'f' THEN 1 ELSE 0 END, tbl.relname, con.conname`, [tables]);
+	const indexes = await client.query(`
+    SELECT pg_get_indexdef(idx.indexrelid) AS definition
+    FROM pg_index idx JOIN pg_class tbl ON tbl.oid = idx.indrelid
+    JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+    WHERE ns.nspname = 'public' AND tbl.relname = ANY($1::text[])
+      AND NOT EXISTS (SELECT 1 FROM pg_constraint con WHERE con.conindid = idx.indexrelid)
+    ORDER BY idx.indexrelid`, [tables]);
+	return [...constraints.rows.map((row) => `ALTER TABLE "public".${quoteSqlIdentifier(row.table_name)} ADD CONSTRAINT ${quoteSqlIdentifier(row.name)} ${row.definition};`), ...indexes.rows.map((row) => row.definition + ";")];
+}
+//#endregion
 //#region src/cli/db.ts
 const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
 const DEFAULT_SEED_FILES = [
@@ -26,9 +90,15 @@ const MODULE_SEED_EXTENSIONS = /* @__PURE__ */ new Set([
 	".js",
 	".mjs"
 ]);
-function getLocalD1PersistRoot(root) {
+function getLocalD1Target(root) {
 	const detected = detectFramework(root);
-	return detected && (detected.class === "b" || detected.class === "c") ? join(root, ".wrangler", "state") : join(root, ".void");
+	const defaultPersistRoot = detected && (detected.class === "b" || detected.class === "c") ? join(root, ".wrangler", "state") : join(root, ".void");
+	const bindingName = resolveBindingNames(readConfig(root).inference?.bindings)?.d1 ?? "DB";
+	return resolveLocalD1Target(root, {
+		bindingName,
+		defaultPersistRoot,
+		readPersistState: true
+	});
 }
 function runDrizzleKit(root, args) {
 	execFileSync(process.execPath, [drizzleKitBin, ...args], {
@@ -39,26 +109,14 @@ function runDrizzleKit(root, args) {
 function getErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-function readEnvLocal(root) {
-	const envPath = join(root, ".env.local");
-	if (!existsSync(envPath)) return {};
-	const content = readFileSync(envPath, "utf-8");
-	const vars = {};
-	for (const line of content.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const eqIndex = trimmed.indexOf("=");
-		if (eqIndex === -1) continue;
-		const key = trimmed.slice(0, eqIndex).trim();
-		let value = trimmed.slice(eqIndex + 1).trim();
-		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
-		vars[key] = value;
-	}
-	return vars;
-}
 function getPgUrl(root) {
-	const url = readEnvLocal(root).DATABASE_URL;
-	if (!url) throw new Error("DATABASE_URL not found in .env.local. Add it to connect to your PostgreSQL database.");
+	const url = loadLocalEnv(root).DATABASE_URL;
+	if (!url) throw new Error("DATABASE_URL not found in .env. Add it to connect to your local PostgreSQL database.");
+	return url;
+}
+function getMySqlUrl(root) {
+	const url = loadLocalEnv(root).DATABASE_URL;
+	if (!url) throw new Error("DATABASE_URL not found in .env. Add it to connect to your local MySQL database.");
 	return url;
 }
 async function withPgClient(root, fn) {
@@ -72,6 +130,27 @@ async function withPgClient(root, fn) {
 		await client.end();
 	}
 }
+async function withMySqlClient(root, fn) {
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection({
+		uri: getMySqlUrl(root),
+		multipleStatements: true
+	});
+	const client = {
+		async query(sql, params) {
+			const [rows] = await connection.query(sql, params);
+			return Array.isArray(rows) ? rows : [];
+		},
+		async end() {
+			await connection.end();
+		}
+	};
+	try {
+		return await fn(client);
+	} finally {
+		await client.end();
+	}
+}
 function validatePendingMigrations(migrations, appliedNames) {
 	const pending = migrations.filter((migration) => !appliedNames.has(migration.name));
 	if (pending.length === 0) return;
@@ -92,18 +171,98 @@ async function runDbCommand(root, args) {
 	else if (args.action === "migrate") await runMigrate(root, dialect, args.remote);
 	else if (args.action === "studio") await runStudio(root, dialect, args.remote);
 	else if (args.action === "set-url") await runSetUrl(root);
+	else if (args.action === "connect") await runConnect(root, dialect, args);
 	else if (args.action === "rename-migrations") await runRenameMigrations(root, dialect);
 	else await runExport(root, args, dialect);
 }
+function writeLocalDatabaseUrl(root, connectionString) {
+	const envPath = join(root, ".env");
+	const original = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+	const lines = original ? original.replace(/\r\n/g, "\n").split("\n") : [];
+	const assignment = `DATABASE_URL=${JSON.stringify(connectionString)}`;
+	const index = lines.findIndex((line) => /^\s*(?:export\s+)?DATABASE_URL\s*=/.test(line));
+	if (index === -1) {
+		while (lines.at(-1) === "") lines.pop();
+		if (lines.length > 0) lines.push("");
+		lines.push(assignment);
+	} else {
+		lines[index] = assignment;
+		for (let i = lines.length - 1; i > index; i--) if (/^\s*(?:export\s+)?DATABASE_URL\s*=/.test(lines[i])) lines.splice(i, 1);
+	}
+	while (lines.at(-1) === "") lines.pop();
+	writeFileSync(envPath, `${lines.join("\n")}\n`);
+}
+function assertDatabaseProvider(value, source) {
+	if (!value || typeof value !== "object") throw new Error(`Database provider '${source}' did not export an adapter object.`);
+	const adapter = value;
+	if (typeof adapter.id !== "string" || typeof adapter.label !== "string" || !Array.isArray(adapter.dialects) || typeof adapter.provision !== "function") throw new Error(`Database provider '${source}' does not implement DatabaseProviderAdapter.`);
+	return adapter;
+}
+async function loadDatabaseProvider(root, provider) {
+	if (provider === "neon") {
+		const { createNeonDatabaseProvider } = await import("./neon-DHwd2zvC.mjs");
+		return createNeonDatabaseProvider();
+	}
+	const requireFromProject = createRequire(join(root, "package.json"));
+	let resolved;
+	try {
+		resolved = provider.startsWith(".") || provider.startsWith("/") ? resolve(root, provider) : requireFromProject.resolve(provider);
+	} catch {
+		throw new Error(`Could not resolve database provider adapter '${provider}' from this project. Install it first or pass a file path.`);
+	}
+	const mod = await import(pathToFileURL(resolved).href);
+	return assertDatabaseProvider(mod.default ?? mod.databaseProvider, provider);
+}
+async function runConnect(root, dialect, args) {
+	if (dialect === "sqlite") {
+		log.error("db: `void db connect` requires an external database. Set \"database\" to \"pg\" or \"mysql\" in void.json first.");
+		process.exit(1);
+	}
+	let connectionString = args.url;
+	if (args.provider) {
+		const adapter = await loadDatabaseProvider(root, args.provider);
+		if (!adapter.dialects.includes(dialect)) throw new Error(`${adapter.label} does not support the configured ${dialect} dialect.`);
+		log.info(`Provisioning ${adapter.label} database...`);
+		const result = await adapter.provision({
+			name: args.name ?? basename(root),
+			dialect,
+			region: args.region
+		});
+		connectionString = result.connectionString;
+		log.success(`Provisioned ${adapter.label} database.`);
+		if (result.dashboardUrl) log.info(`Dashboard: ${result.dashboardUrl}`);
+	}
+	if (!connectionString) {
+		const { text: promptText, isCancel: isCancelCheck } = await import("./output-tFQLLj26.mjs").then((n) => n.T);
+		const answer = await promptText({
+			message: `Enter your ${dialect === "mysql" ? "MySQL" : "PostgreSQL"} connection string:`,
+			placeholder: dialect === "mysql" ? "mysql://user:pass@host:3306/database" : "postgresql://user:pass@host:5432/database"
+		});
+		if (isCancelCheck(answer)) process.exit(0);
+		connectionString = answer;
+	}
+	const parsed = new URL(connectionString);
+	if (!(dialect === "mysql" ? ["mysql:"] : ["postgres:", "postgresql:"]).includes(parsed.protocol)) throw new Error(`Connection string protocol '${parsed.protocol}' does not match the configured ${dialect} dialect.`);
+	writeLocalDatabaseUrl(root, connectionString);
+	log.success("Saved DATABASE_URL to .env.");
+	if (!args.localOnly) {
+		const token = getToken(root);
+		const projectConfig = readProjectConfig(root);
+		if (token && projectConfig) {
+			await new PlatformClient(token, { root }).setDatabaseUrl(projectConfig.projectId, connectionString);
+			log.success("Updated the linked Void project database URL.");
+		} else log.info("No authenticated Void project is linked, so only local configuration was updated.");
+	}
+	outro("Database connected.");
+}
 async function runPush(root, dialect) {
-	const { writeDrizzleConfig } = await import("./config-CutEMNGJ.mjs").then((n) => n.t);
+	const { writeDrizzleConfig } = await import("./config-NOG_U1aK.mjs").then((n) => n.t);
 	let configPath;
-	if (dialect === "postgresql") configPath = writeDrizzleConfig(root, getPgUrl(root), "postgresql");
+	if (dialect !== "sqlite") configPath = writeDrizzleConfig(root, dialect === "mysql" ? getMySqlUrl(root) : getPgUrl(root), dialect);
 	else {
 		const { mkdirSync } = await import("node:fs");
-		const { dirname } = await import("node:path");
-		const { getMiniflareDatabasePath } = await import("./runner-kapo9aPs.mjs");
-		const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+		const { dirname } = await import("./dist-BrsS7cai.mjs").then((n) => n.r);
+		const { databasePath: dbPath } = getLocalD1Target(root);
 		mkdirSync(dirname(dbPath), { recursive: true });
 		configPath = writeDrizzleConfig(root, dbPath);
 	}
@@ -119,8 +278,12 @@ async function runPush(root, dialect) {
 	outro("Done.");
 }
 async function runGenerate(root, dialect) {
-	const { writeDrizzleConfig } = await import("./config-CutEMNGJ.mjs").then((n) => n.t);
-	const configPath = dialect === "postgresql" ? writeDrizzleConfig(root, "postgresql://dummy", "postgresql") : writeDrizzleConfig(root, ":memory:");
+	const { prepareProject } = await import("./prepare-CBetXvsN.mjs");
+	const { writeDrizzleConfig } = await import("./config-NOG_U1aK.mjs").then((n) => n.t);
+	await prepareProject(root);
+	const authSchemaPath = join(root, ".void", "better-auth-schema.ts");
+	const additionalSchemas = existsSync(authSchemaPath) ? [authSchemaPath] : void 0;
+	const configPath = writeDrizzleConfig(root, dialect === "postgresql" ? "postgresql://dummy" : dialect === "mysql" ? "mysql://dummy" : ":memory:", dialect, { additionalSchemas });
 	try {
 		runDrizzleKit(root, [
 			"generate",
@@ -159,17 +322,47 @@ async function runStatus(root, dialect) {
 	} catch {
 		localApplied = [];
 	}
+	else if (dialect === "mysql") try {
+		localApplied = await withMySqlClient(root, async (client) => {
+			try {
+				return await client.query("SELECT `name` FROM `_void_migrations` ORDER BY `name`");
+			} catch {
+				return [];
+			}
+		});
+	} catch {
+		localApplied = [];
+	}
 	else {
-		const { getMiniflareDatabasePath, getAppliedMigrations } = await import("./runner-kapo9aPs.mjs");
-		localApplied = await getAppliedMigrations(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+		const { getAppliedMigrations } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+		const { databasePath: dbPath } = getLocalD1Target(root);
+		localApplied = await getAppliedMigrations(dbPath);
 	}
 	const localSet = new Set(localApplied.map((m) => m.name));
 	let remoteApplied = null;
-	const token = getToken(root);
-	const config = readProjectConfig(root);
-	if (token && config) try {
-		remoteApplied = (await new PlatformClient(token, { root }).getMigrationStatus(config.projectId, dialect)).applied;
+	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-DCkWPsWS.mjs").then((n) => n.n)).getPgAppliedMigrations(databaseUrl) : await (await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n)).getMySqlAppliedMigrations(databaseUrl)).map((name) => ({
+				name,
+				applied_at: ""
+			}));
+		} else {
+			const { readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+			remoteApplied = (await readCloudflareD1Migrations(resolveCloudflareD1Context(root, resolveBindingNames(readConfig(root).inference?.bindings)?.d1 ?? "DB"))).map((name) => ({
+				name,
+				applied_at: ""
+			}));
+		}
 	} catch {}
+	else {
+		const token = getToken(root);
+		const config = readProjectConfig(root);
+		if (token && config) try {
+			remoteApplied = (await new PlatformClient(token, { root }).getMigrationStatus(config.projectId, dialect)).applied;
+		} catch {}
+	}
 	const remoteSet = remoteApplied ? new Set(remoteApplied.map((m) => m.name)) : null;
 	const lines = [];
 	for (const migration of allMigrations) {
@@ -218,8 +411,27 @@ async function resetDatabase(root, dialect) {
 		});
 		return migrations.length;
 	}
-	const { getMiniflareDatabasePath, runMigrations } = await import("./runner-kapo9aPs.mjs");
-	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (dialect === "mysql") {
+		await withMySqlClient(root, async (client) => {
+			const tables = await client.query("SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'");
+			await client.query("SET FOREIGN_KEY_CHECKS = 0");
+			try {
+				for (const row of tables) {
+					const table = String(row.table_name).replaceAll("`", "``");
+					await client.query(`DROP TABLE IF EXISTS \`${table}\``);
+				}
+			} finally {
+				await client.query("SET FOREIGN_KEY_CHECKS = 1");
+			}
+		});
+		if (migrations.length > 0) {
+			const { applyMySqlMigrations } = await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n);
+			await withMySqlClient(root, (client) => applyMySqlMigrations(client, migrations));
+		}
+		return migrations.length;
+	}
+	const { runMigrations } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+	const { databasePath: dbPath } = getLocalD1Target(root);
 	rmSync(dbPath, { force: true });
 	rmSync(dbPath + "-wal", { force: true });
 	rmSync(dbPath + "-shm", { force: true });
@@ -228,7 +440,7 @@ async function resetDatabase(root, dialect) {
 async function runReset(root, dialect) {
 	const count = await resetDatabase(root, dialect);
 	log.success(`Database reset. Applied ${count} migration(s).`);
-	if (dialect !== "postgresql") log.info(dim("Restart your dev server if it's running."));
+	if (dialect === "sqlite") log.info(dim("Restart your dev server if it's running."));
 	outro("Done.");
 }
 async function runSeed(root, file, dialect) {
@@ -245,8 +457,17 @@ async function runSeed(root, file, dialect) {
 			outro("Done.");
 			return;
 		}
-		const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-kapo9aPs.mjs");
-		const db = await openSqliteDatabase(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+		if (dialect === "mysql") {
+			await withMySqlClient(root, async (client) => {
+				await client.query(sql);
+			});
+			log.success(`Seeded from ${seed.displayPath}.`);
+			outro("Done.");
+			return;
+		}
+		const { openSqliteDatabase } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+		const { databasePath: dbPath } = getLocalD1Target(root);
+		const db = await openSqliteDatabase(dbPath);
 		try {
 			db.exec(sql);
 		} finally {
@@ -318,6 +539,33 @@ async function fetchRemoteDatabaseUrl(client, projectId) {
 		throw err;
 	}
 }
+async function executeExternalRemoteSql(dialect, dbUrl, sql) {
+	if (dialect === "postgresql") {
+		const { Client } = await import("pg");
+		const pgClient = new Client({ connectionString: dbUrl });
+		await pgClient.connect();
+		try {
+			const result = await pgClient.query(sql);
+			if (result.rows && result.rows.length > 0) printTable(result.rows);
+			else log.success("Executed successfully.");
+		} finally {
+			await pgClient.end();
+		}
+		return;
+	}
+	const { createConnection } = await import("mysql2/promise");
+	const mySqlClient = await createConnection({
+		uri: dbUrl,
+		multipleStatements: true
+	});
+	try {
+		const [rows] = await mySqlClient.query(sql);
+		if (Array.isArray(rows) && rows.length > 0) printTable(rows);
+		else log.success("Executed successfully.");
+	} finally {
+		await mySqlClient.end();
+	}
+}
 /**
 * Prompt the user to confirm a destructive remote query when running in a TTY.
 * Returns true if execution should proceed, false if it was cancelled.
@@ -331,11 +579,33 @@ async function confirmDestructiveRemote(sql) {
 }
 async function runExecute(root, command, file, dialect, remote) {
 	if (remote) {
-		if (dialect !== "postgresql" && file) {
+		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;
+		if (directCloudflare) {
+			if (!await confirmDestructiveRemote(sql)) {
+				log.info("Cancelled.");
+				process.exit(0);
+			}
+			if (dialect === "sqlite") {
+				const { executeCloudflareD1Sql, resolveCloudflareD1Context } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+				const rows = await executeCloudflareD1Sql(resolveCloudflareD1Context(root, resolveBindingNames(readConfig(root).inference?.bindings)?.d1 ?? "DB"), sql);
+				if (rows.length > 0) printTable(rows);
+				else log.success("Executed successfully.");
+			} else {
+				const dbUrl = process.env.DATABASE_URL;
+				if (!dbUrl) {
+					log.error("DATABASE_URL is required in the shell for a direct Cloudflare remote database command.");
+					process.exit(1);
+				}
+				await executeExternalRemoteSql(dialect, dbUrl, sql);
+			}
+			outro("Done.");
+			return;
+		}
 		const token = getToken(root);
 		if (!token) {
 			log.error("Not logged in. Run `void auth login` first.");
@@ -350,34 +620,25 @@ async function runExecute(root, command, file, dialect, remote) {
 			log.info("Cancelled.");
 			process.exit(0);
 		}
-		if (dialect === "postgresql") {
-			const dbUrl = await fetchRemoteDatabaseUrl(new PlatformClient(token, { root }), projectConfig.projectId);
-			const { Client } = await import("pg");
-			const pgClient = new Client({ connectionString: dbUrl });
-			await pgClient.connect();
-			try {
-				const result = await pgClient.query(sql);
-				if (result.rows && result.rows.length > 0) printTable(result.rows);
-				else log.success("Executed successfully.");
-			} finally {
-				await pgClient.end();
-			}
+		if (dialect !== "sqlite") {
+			await executeExternalRemoteSql(dialect, await fetchRemoteDatabaseUrl(new PlatformClient(token, { root }), projectConfig.projectId), sql);
 			outro("Done.");
 			return;
 		}
 		const platformClient = new PlatformClient(token, { root });
-		let binding = resolveBindingNames(readConfig(root).inference?.bindings)?.d1 ?? "DB";
+		const voidConfig = readConfig(root);
+		let binding = resolveBindingNames(voidConfig.inference?.bindings)?.d1 ?? "DB";
 		try {
 			const d1Resource = (await platformClient.getResources(projectConfig.projectId)).find((r) => r.type === "d1");
 			if (d1Resource) binding = d1Resource.binding_name;
 		} catch {}
-		const proxyUrl = isStagingMode(root) ? STAGING_PROXY_URL : DEFAULT_PROXY_URL;
+		const proxyUrl = getProxyUrl(root);
 		const res = await fetch(`${proxyUrl}/d1/query`, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${token}`,
 				"Content-Type": "application/json",
-				...cfAccessHeaders(process.env)
+				...cfAccessHeaders(process.env, proxyUrl)
 			},
 			body: JSON.stringify({
 				projectId: projectConfig.projectId,
@@ -408,8 +669,18 @@ async function runExecute(root, command, file, dialect, remote) {
 		outro("Done.");
 		return;
 	}
-	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-kapo9aPs.mjs");
-	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (dialect === "mysql") {
+		const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+		await withMySqlClient(root, async (client) => {
+			const rows = await client.query(sql);
+			if (rows.length > 0) printTable(rows);
+			else log.success("Executed successfully.");
+		});
+		outro("Done.");
+		return;
+	}
+	const { openSqliteDatabase } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
 		log.error("No local database found. Run `void dev` first.");
 		process.exit(1);
@@ -456,9 +727,91 @@ async function runMigrate(root, dialect, remote) {
 		process.exit(1);
 	}
 	if (remote) {
-		if (dialect === "postgresql") {
-			log.error("db: `void db migrate --remote` is only supported for D1 projects. PostgreSQL remote migrations run during `void deploy` through the project Hyperdrive binding.");
-			process.exit(1);
+		const deploymentPlatform = readDeploymentPlatform(root);
+		if (dialect !== "sqlite") {
+			if (deploymentPlatform !== "cloudflare") {
+				log.error(`db: \`void db migrate --remote\` is only supported for D1 projects. ${dialect === "mysql" ? "MySQL" : "PostgreSQL"} remote migrations run during \`void deploy\` through the project Hyperdrive binding.`);
+				process.exit(1);
+			}
+			if (rawMigrations.length === 0) {
+				log.info(`No migration files found in ${paths.sourceRelative("db/migrations")}/`);
+				outro("Done.");
+				return;
+			}
+			const databaseUrl = process.env.DATABASE_URL;
+			if (!databaseUrl) {
+				log.error("DATABASE_URL is required in the shell for a direct Cloudflare remote database command.");
+				process.exit(1);
+			}
+			try {
+				let appliedNames;
+				let applyMigrations;
+				if (dialect === "postgresql") {
+					const { getPgAppliedMigrations, runPgMigrations } = await import("./runner-pg-DCkWPsWS.mjs").then((n) => n.n);
+					appliedNames = await getPgAppliedMigrations(databaseUrl);
+					applyMigrations = () => runPgMigrations(migrationsDir, databaseUrl);
+				} else {
+					const { getMySqlAppliedMigrations, runMySqlMigrations } = await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n);
+					appliedNames = await getMySqlAppliedMigrations(databaseUrl);
+					applyMigrations = () => runMySqlMigrations(migrationsDir, databaseUrl);
+				}
+				const appliedSet = new Set(appliedNames);
+				const pending = rawMigrations.filter((migration) => !appliedSet.has(migration.name));
+				if (pending.length === 0) {
+					log.info("Remote database is up to date.");
+					outro("Done.");
+					return;
+				}
+				validateMigrations(pending);
+				const applied = await applyMigrations();
+				for (const migration of applied) log.step(migration);
+				log.success(`Applied ${applied.length} migration(s) to remote database.`);
+				outro("Done.");
+				return;
+			} catch (error) {
+				log.error(`db: Remote ${dialect} migrations failed — ${getErrorMessage(error)}`);
+				process.exit(1);
+			}
+		}
+		if (deploymentPlatform === "cloudflare") {
+			if (rawMigrations.length === 0) {
+				log.info(`No migration files found in ${paths.sourceRelative("db/migrations")}/`);
+				outro("Done.");
+				return;
+			}
+			const { applyCloudflareD1Migrations, readCloudflareD1Migrations, resolveCloudflareD1Context } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+			const binding = resolveBindingNames(readConfig(root).inference?.bindings)?.d1 ?? "DB";
+			const context = resolveCloudflareD1Context(root, binding);
+			const remoteBefore = new Set(await readCloudflareD1Migrations(context));
+			const pending = rawMigrations.filter((migration) => !remoteBefore.has(migration.name));
+			if (pending.length === 0) {
+				log.info("Remote database is up to date.");
+				outro("Done.");
+				return;
+			}
+			try {
+				validateMigrations(pending);
+			} catch (error) {
+				log.error(getErrorMessage(error));
+				process.exit(1);
+			}
+			const { checkWranglerMigrationApplySet, parseRootWranglerConfig } = await import("./deploy-CcDoeBIf.mjs").then((n) => n.n);
+			const applySet = await checkWranglerMigrationApplySet(context.operation.configPath, parseRootWranglerConfig(context.operation.configPath), binding, context.migrationsDir, rawMigrations);
+			if (!applySet.ok) {
+				log.error(applySet.reason);
+				process.exit(1);
+			}
+			await applyCloudflareD1Migrations(context);
+			const remoteAfter = new Set(await readCloudflareD1Migrations(context));
+			const unapplied = rawMigrations.filter((migration) => !remoteAfter.has(migration.name));
+			if (unapplied.length > 0) {
+				log.error(`db: Remote D1 still has unapplied migrations: ${unapplied.map((migration) => migration.name).join(", ")}.`);
+				process.exit(1);
+			}
+			for (const migration of pending) log.step(migration.name);
+			log.success(`Applied ${pending.length} migration(s) to remote database.`);
+			outro("Done.");
+			return;
 		}
 		const token = getToken(root);
 		if (!token) {
@@ -511,7 +864,7 @@ async function runMigrate(root, dialect, remote) {
 		return;
 	}
 	if (dialect === "postgresql") {
-		const { applyPgMigrations } = await import("./runner-pg-CHM76xuC.mjs");
+		const { applyPgMigrations } = await import("./runner-pg-DCkWPsWS.mjs").then((n) => n.n);
 		const applied = await withPgClient(root, async (client) => {
 			let existingRows = [];
 			try {
@@ -535,8 +888,33 @@ async function runMigrate(root, dialect, remote) {
 		outro("Done.");
 		return;
 	}
-	const { getMiniflareDatabasePath, getAppliedMigrations, runMigrations } = await import("./runner-kapo9aPs.mjs");
-	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (dialect === "mysql") {
+		const { applyMySqlMigrations } = await import("./runner-mysql-CgRFl3s6.mjs").then((n) => n.n);
+		const applied = await withMySqlClient(root, async (client) => {
+			let existingRows = [];
+			try {
+				existingRows = await client.query("SELECT `name` FROM `_void_migrations`");
+			} catch {
+				existingRows = [];
+			}
+			try {
+				validatePendingMigrations(rawMigrations, new Set(existingRows.map((row) => row.name)));
+			} catch (err) {
+				log.error(getErrorMessage(err));
+				process.exit(1);
+			}
+			return applyMySqlMigrations(client, rawMigrations);
+		});
+		if (applied.length === 0) log.info("All migrations are up to date.");
+		else {
+			for (const name of applied) log.step(name);
+			log.success(`Applied ${applied.length} migration(s).`);
+		}
+		outro("Done.");
+		return;
+	}
+	const { getAppliedMigrations, runMigrations } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+	const { databasePath: dbPath } = getLocalD1Target(root);
 	try {
 		const existingRows = await getAppliedMigrations(dbPath);
 		validatePendingMigrations(rawMigrations, new Set(existingRows.map((row) => row.name)));
@@ -555,23 +933,32 @@ async function runMigrate(root, dialect, remote) {
 }
 async function runStudio(root, dialect, remote) {
 	if (remote) {
-		if (dialect !== "postgresql") {
+		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.");
 			process.exit(1);
 		}
-		const token = getToken(root);
-		if (!token) {
-			log.error("Not logged in. Run `void auth login` first.");
-			process.exit(1);
-		}
-		const projectConfig = readProjectConfig(root);
-		if (!projectConfig) {
-			log.error("No project linked. Run `void deploy` first or link a project.");
-			process.exit(1);
+		let dbUrl;
+		if (readDeploymentPlatform(root) === "cloudflare") {
+			dbUrl = process.env.DATABASE_URL ?? "";
+			if (!dbUrl) {
+				log.error("DATABASE_URL is required in the shell for direct Cloudflare remote Studio.");
+				process.exit(1);
+			}
+		} else {
+			const token = getToken(root);
+			if (!token) {
+				log.error("Not logged in. Run `void auth login` first.");
+				process.exit(1);
+			}
+			const projectConfig = readProjectConfig(root);
+			if (!projectConfig) {
+				log.error("No project linked. Run `void deploy` first or link a project.");
+				process.exit(1);
+			}
+			dbUrl = await fetchRemoteDatabaseUrl(new PlatformClient(token, { root }), projectConfig.projectId);
 		}
-		const dbUrl = await fetchRemoteDatabaseUrl(new PlatformClient(token, { root }), projectConfig.projectId);
-		const { writeDrizzleConfig } = await import("./config-CutEMNGJ.mjs").then((n) => n.t);
-		const configPath = writeDrizzleConfig(root, dbUrl, "postgresql");
+		const { writeDrizzleConfig } = await import("./config-NOG_U1aK.mjs").then((n) => n.t);
+		const configPath = writeDrizzleConfig(root, dbUrl, dialect);
 		log.info("Opening Drizzle Studio (remote)...");
 		try {
 			runDrizzleKit(root, [
@@ -584,9 +971,9 @@ async function runStudio(root, dialect, remote) {
 		}
 		return;
 	}
-	if (dialect === "postgresql") {
-		const { writeDrizzleConfig } = await import("./config-CutEMNGJ.mjs").then((n) => n.t);
-		const configPath = writeDrizzleConfig(root, getPgUrl(root), "postgresql");
+	if (dialect !== "sqlite") {
+		const { writeDrizzleConfig } = await import("./config-NOG_U1aK.mjs").then((n) => n.t);
+		const configPath = writeDrizzleConfig(root, dialect === "mysql" ? getMySqlUrl(root) : getPgUrl(root), dialect);
 		log.info("Opening Drizzle Studio...");
 		try {
 			runDrizzleKit(root, [
@@ -599,9 +986,8 @@ async function runStudio(root, dialect, remote) {
 		}
 		return;
 	}
-	const { writeDrizzleConfig } = await import("./config-CutEMNGJ.mjs").then((n) => n.t);
-	const { getMiniflareDatabasePath } = await import("./runner-kapo9aPs.mjs");
-	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	const { writeDrizzleConfig } = await import("./config-NOG_U1aK.mjs").then((n) => n.t);
+	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
 		log.error("No local database found. Run `void dev` first.");
 		process.exit(1);
@@ -678,7 +1064,8 @@ async function runRenameMigrations(root, dialect) {
 		const missingSnapshots = [];
 		for (const { from } of renames) {
 			const fromTag = stripSqlExt(from);
-			if (!existsSync(snapshotPathFor(fromTag))) missingSnapshots.push(`meta/${snapshotPrefix(fromTag)}_snapshot.json`);
+			const snapshotFrom = snapshotPathFor(fromTag);
+			if (!existsSync(snapshotFrom)) missingSnapshots.push(`meta/${snapshotPrefix(fromTag)}_snapshot.json`);
 		}
 		if (missingSnapshots.length > 0) {
 			log.error("db: Cannot rename migrations because one or more Drizzle snapshot files are missing:");
@@ -819,9 +1206,25 @@ async function runRenameMigrations(root, dialect) {
 		log.error(String(err));
 		process.exit(1);
 	}
+	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]);
+		});
+	} catch (err) {
+		reverseSnapshotRenames();
+		for (const { from, to } of renames) try {
+			renameSync(join(migrationsDir, to), join(migrationsDir, from));
+		} catch {}
+		restoreJournal();
+		await reverseRemote();
+		log.error("db: Failed to update MySQL tracking table. File renames have been reverted.\nFix the database connection and run `void db rename-migrations` again.");
+		log.error(String(err));
+		process.exit(1);
+	}
 	else {
-		const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-kapo9aPs.mjs");
-		const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+		const { openSqliteDatabase } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+		const { databasePath: dbPath } = getLocalD1Target(root);
 		if (existsSync(dbPath)) try {
 			const db = await openSqliteDatabase(dbPath);
 			try {
@@ -852,6 +1255,13 @@ async function runRenameMigrations(root, dialect) {
 	log.success(`Renamed ${renames.length} migration(s) to timestamp format.`);
 	outro("Done.");
 }
+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("'", "''")}'`;
+}
 async function runExport(root, args, dialect) {
 	const errOut = { output: process.stderr };
 	if (dialect === "postgresql") {
@@ -865,18 +1275,23 @@ async function runExport(root, args, dialect) {
 				}
 				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));
+			const sequences = await exportPgSequences(client, tables, args);
+			parts.push(...sequences.before);
 			for (const table of tables) {
+				const cols = await client.query(`SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public' ORDER BY ordinal_position`, [table]);
+				const names = cols.rows.map((column) => quoteSqlIdentifier(String(column.column_name)));
+				const tableName = `"public".${quoteSqlIdentifier(table)}`;
 				if (!args.noSchema) {
-					const colDefs = (await client.query(`SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public' ORDER BY ordinal_position`, [table])).rows.map((column) => {
-						let def = `  "${String(column.column_name)}" ${String(column.data_type)}`;
+					const colDefs = cols.rows.map((column) => {
+						let def = `  ${quoteSqlIdentifier(String(column.column_name))} ${String(column.data_type)}`;
 						if (column.is_nullable === "NO") def += " NOT NULL";
 						if (column.column_default) def += ` DEFAULT ${String(column.column_default)}`;
 						return def;
 					});
-					parts.push(`CREATE TABLE "${table}" (\n${colDefs.join(",\n")}\n);`);
+					parts.push(`CREATE TABLE ${tableName} (\n${colDefs.join(",\n")}\n);`);
 				}
 				if (!args.noData) {
-					const rows = await client.query(`SELECT * FROM "${table}"`);
+					const rows = await client.query(`SELECT ${names.map((name) => `${name}::text AS ${name}`).join(", ")} FROM ${tableName}`);
 					for (const row of rows.rows) {
 						const cols = Object.keys(row);
 						const vals = cols.map((column) => {
@@ -885,7 +1300,46 @@ async function runExport(root, args, dialect) {
 							if (typeof value === "number") return String(value);
 							return `'${String(value).replace(/'/g, "''")}'`;
 						});
-						parts.push(`INSERT INTO "${table}" (${cols.join(", ")}) VALUES (${vals.join(", ")});`);
+						parts.push(`INSERT INTO ${tableName} (${cols.map(quoteSqlIdentifier).join(", ")}) VALUES (${vals.join(", ")});`);
+					}
+				}
+				parts.push("");
+			}
+			parts.push(...sequences.after);
+			if (!args.noSchema) parts.push(...await exportPgConstraints(client, tables));
+		});
+		const output = parts.join("\n");
+		if (args.output) {
+			writeFileSync(join(root, args.output), output);
+			log.success(`Exported to ${args.output}`);
+			outro("Done.");
+		} else process.stdout.write(output);
+		return;
+	}
+	if (dialect === "mysql") {
+		const parts = [];
+		await withMySqlClient(root, 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) {
+					log.error(`db: Table '${args.table}' not found.`, errOut);
+					process.exit(1);
+				}
+				tables = [args.table];
+			} else tables = (await client.query("SELECT 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));
+			for (const table of tables) {
+				const escapedTable = table.replaceAll("`", "``");
+				if (!args.noSchema) {
+					const createSql = (await client.query(`SHOW CREATE TABLE \`${escapedTable}\``))[0]?.["Create Table"];
+					if (createSql) parts.push(`${String(createSql)};`);
+				}
+				if (!args.noData) {
+					const rows = await client.query(`SELECT * FROM \`${escapedTable}\``);
+					for (const row of rows) {
+						const columns = Object.keys(row);
+						const values = columns.map((column) => formatMySqlExportValue(row[column]));
+						const names = columns.map((column) => `\`${column.replaceAll("`", "``")}\``);
+						parts.push(`INSERT INTO \`${escapedTable}\` (${names.join(", ")}) VALUES (${values.join(", ")});`);
 					}
 				}
 				parts.push("");
@@ -899,8 +1353,8 @@ async function runExport(root, args, dialect) {
 		} else process.stdout.write(output);
 		return;
 	}
-	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-kapo9aPs.mjs");
-	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	const { openSqliteDatabase } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+	const { databasePath: dbPath } = getLocalD1Target(root);
 	if (!existsSync(dbPath)) {
 		log.error("No local database found. Run `void dev` first.", errOut);
 		process.exit(1);
@@ -914,7 +1368,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));
+		} 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_"));
 		const parts = [];
 		for (const table of tables) {
 			if (!args.noSchema) {
@@ -922,7 +1376,7 @@ async function runExport(root, args, dialect) {
 				parts.push(row.sql + ";");
 			}
 			if (!args.noData) {
-				const rows = db.prepare(`SELECT * FROM "${table}"`).all();
+				const rows = db.prepare(`SELECT * FROM ${quoteSqlIdentifier(table)}`).all();
 				for (const row of rows) {
 					const cols = Object.keys(row);
 					const vals = cols.map((column) => {
@@ -931,11 +1385,19 @@ async function runExport(root, args, dialect) {
 						if (typeof value === "number") return String(value);
 						return `'${String(value).replace(/'/g, "''")}'`;
 					});
-					parts.push(`INSERT INTO "${table}" (${cols.join(", ")}) VALUES (${vals.join(", ")});`);
+					parts.push(`INSERT INTO ${quoteSqlIdentifier(table)} (${cols.map(quoteSqlIdentifier).join(", ")}) VALUES (${vals.join(", ")});`);
 				}
 			}
 			parts.push("");
 		}
+		if (!args.noData && db.prepare("SELECT name FROM sqlite_master WHERE name='sqlite_sequence'").get()) {
+			const sequences = db.prepare("SELECT name, seq FROM sqlite_sequence").all();
+			for (const sequence of sequences) if (tables.includes(sequence.name)) {
+				const name = quoteSqlString(sequence.name);
+				parts.push(`DELETE FROM sqlite_sequence WHERE name = ${name};`);
+				parts.push(`INSERT INTO sqlite_sequence (name, seq) VALUES (${name}, ${sequence.seq});`);
+			}
+		}
 		const output = parts.join("\n");
 		if (args.output) {
 			writeFileSync(join(root, args.output), output);
@@ -947,9 +1409,10 @@ async function runExport(root, args, dialect) {
 	}
 }
 async function runSetUrl(root) {
-	const { readConfig: readVoidConfig, getDatabaseDialect: getDialect } = await import("./config-BkTvs43g.mjs").then((n) => n.n);
-	if (getDialect(readVoidConfig(root)) !== "postgresql") {
-		log.error("db: This command is only for PostgreSQL projects. Set \"database\": \"pg\" in void.json.");
+	const { readConfig: readVoidConfig, getDatabaseDialect: getDialect } = await import("./config-BQFq7QvD.mjs").then((n) => n.n);
+	const dialect = getDialect(readVoidConfig(root));
+	if (dialect === "sqlite") {
+		log.error("db: This command is only for PostgreSQL and MySQL projects. Set \"database\" to \"pg\" or \"mysql\" in void.json.");
 		process.exit(1);
 	}
 	const token = getToken(root);
@@ -962,12 +1425,14 @@ async function runSetUrl(root) {
 		log.error("No project linked. Run `void deploy` first or link a project.");
 		process.exit(1);
 	}
-	const { text: promptText, isCancel: isCancelCheck } = await import("./agents-CtgBYqld.mjs").then((n) => n.C);
+	const { text: promptText, isCancel: isCancelCheck } = await import("./output-tFQLLj26.mjs").then((n) => n.T);
 	const connectionString = await promptText({
-		message: "Enter your PostgreSQL connection string:",
-		placeholder: "postgresql://user:pass@host:5432/dbname",
+		message: `Enter your ${dialect === "mysql" ? "MySQL" : "PostgreSQL"} connection string:`,
+		placeholder: dialect === "mysql" ? "mysql://user:pass@host:3306/dbname" : "postgresql://user:pass@host:5432/dbname",
 		validate(value = "") {
-			if (!value.startsWith("postgres://") && !value.startsWith("postgresql://")) return "Connection string must start with \"postgres://\" or \"postgresql://\"";
+			if (dialect === "mysql") {
+				if (!value.startsWith("mysql://")) return "Connection string must start with \"mysql://\"";
+			} else if (!value.startsWith("postgres://") && !value.startsWith("postgresql://")) return "Connection string must start with \"postgres://\" or \"postgresql://\"";
 		}
 	});
 	if (isCancelCheck(connectionString)) process.exit(0);
@@ -1027,9 +1492,29 @@ async function runSeedModule(root, seedPath, dialect) {
 		});
 		return;
 	}
+	if (dialect === "mysql") {
+		const { drizzle } = await import("drizzle-orm/mysql2");
+		const { createConnection } = await import("mysql2/promise");
+		const connection = await createConnection(getMySqlUrl(root));
+		try {
+			const options = getDrizzleSchemaOptions(schema);
+			await seed({
+				dialect,
+				db: options ? drizzle(connection, {
+					...options,
+					mode: "default"
+				}) : drizzle(connection),
+				schema
+			});
+		} finally {
+			await connection.end();
+		}
+		return;
+	}
 	const { drizzle } = await import("drizzle-orm/better-sqlite3");
-	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-kapo9aPs.mjs");
-	const sqlite = await openSqliteDatabase(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+	const { openSqliteDatabase } = await import("./local-d1-BE8KBbMy.mjs").then((n) => n.i);
+	const { databasePath: dbPath } = getLocalD1Target(root);
+	const sqlite = await openSqliteDatabase(dbPath);
 	try {
 		const options = getDrizzleSchemaOptions(schema);
 		await seed({
@@ -1048,7 +1533,7 @@ async function loadSeedFunction(seedPath) {
 	return seed;
 }
 async function loadSeedSchema(root) {
-	const { discoverSchema } = await import("./discover-CJHyvYfR.mjs").then((n) => n.n);
+	const { discoverSchema } = await import("./discover-xvfrgJeo.mjs").then((n) => n.n);
 	const location = discoverSchema(root, readProjectPaths(root));
 	if (!location) return {};
 	if (location.type === "file") {