void 0.27.0 → 1.0.3

package/dist/{requests-C7Oeoh5u.mjs → requests-7W1Pygt2.mjs}

@@ -1,8 +1,8 @@
-import { r as readProjectConfig } from "./project-BAm2aB6Q.mjs";
-import { c as getToken } from "./auth-Dn2vw-SG.mjs";
-import { H as outro, L as log } from "./dist-D3m88sjf.mjs";
-import { i as dim, l as import_picocolors } from "./output-C50ag2r3.mjs";
-import { r as PlatformClient } from "./client-DlDJuY0s.mjs";
+import { r as readProjectConfig } from "./project-rqDnVsJN.mjs";
+import { c as getToken } from "./auth-B6iOCjKI.mjs";
+import { H as outro, L as log } from "./dist-BVdsO7Py.mjs";
+import { f as import_picocolors, i as dim } from "./output-Ba6ZbrzY.mjs";
+import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
 //#region src/cli/requests.ts
 async function runRequestsCommand(root, range, status) {
 	console.log();

package/dist/resolve-project-PnhzMtY6.mjs

@@ -0,0 +1 @@
+export { n as inferDefaultSlug } from "./resolve-project-WpwkCB_c.mjs";

package/dist/resolve-project-WpwkCB_c.mjs

@@ -0,0 +1,48 @@
+import { a as join } from "./dist-ipQi0Q8y.mjs";
+import { r as readProjectConfig } from "./project-rqDnVsJN.mjs";
+import { L as log } from "./dist-BVdsO7Py.mjs";
+import { readFileSync } from "node:fs";
+//#region src/cli/resolve-project.ts
+function getRequestedProjectSlug(options) {
+	const cliSlug = options?.projectSlug?.trim();
+	if (cliSlug) return cliSlug;
+	const envSlug = process.env.VOID_PROJECT?.trim();
+	if (envSlug) return envSlug;
+	return null;
+}
+function resolveProjectBySlug(projects, slug) {
+	const project = projects.find((candidate) => candidate.slug === slug);
+	return project ? {
+		projectId: project.id,
+		slug: project.slug
+	} : null;
+}
+async function requireProjectBySlug(client, slug) {
+	const project = resolveProjectBySlug(await client.listProjects(), slug);
+	if (!project) throw new Error(`project: No project found with slug '${slug}'.`);
+	return project;
+}
+/** Resolves --project, then VOID_PROJECT, then the linked project; exits with an error otherwise. */
+async function resolveCommandProjectId(client, root, projectSlug) {
+	const requestedSlug = projectSlug ?? process.env.VOID_PROJECT?.trim();
+	if (requestedSlug) {
+		const project = resolveProjectBySlug(await client.listProjects(), requestedSlug);
+		if (!project) {
+			log.error(`project: No project found with slug '${requestedSlug}'.`);
+			process.exit(1);
+		}
+		return project.projectId;
+	}
+	const config = readProjectConfig(root);
+	if (!config) {
+		log.error("No linked project. Run `void project link` or pass --project <name>.");
+		process.exit(1);
+	}
+	return config.projectId;
+}
+function inferDefaultSlug(root) {
+	const pkgPath = join(root, "package.json");
+	return (JSON.parse(readFileSync(pkgPath, "utf-8")).name ?? "my-app").replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]/g, "-");
+}
+//#endregion
+export { resolveProjectBySlug as a, resolveCommandProjectId as i, inferDefaultSlug as n, requireProjectBySlug as r, getRequestedProjectSlug as t };

package/dist/{rollback-DVAtrLAl.mjs → rollback-BcASVnwP.mjs}

@@ -1,8 +1,8 @@
-import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-BAm2aB6Q.mjs";
-import { c as getToken } from "./auth-Dn2vw-SG.mjs";
-import { A as confirm, H as outro, K as select, L as log, O as cancel, tt as isCancel } from "./dist-D3m88sjf.mjs";
-import { a as ensureUtc, d as printSuccess, i as dim, r as createSpinner, s as formatCount } from "./output-C50ag2r3.mjs";
-import { r as PlatformClient } from "./client-DlDJuY0s.mjs";
+import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-rqDnVsJN.mjs";
+import { c as getToken } from "./auth-B6iOCjKI.mjs";
+import { A as confirm, H as outro, K as select, L as log, O as cancel, tt as isCancel } from "./dist-BVdsO7Py.mjs";
+import { c as formatRelativeTime, i as dim, m as printSuccess, o as formatCount, r as createSpinner } from "./output-Ba6ZbrzY.mjs";
+import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
 //#region src/cli/rollback.ts
 async function runRollbackCommand(root, deployId) {
 	console.log();
@@ -39,7 +39,7 @@ async function runRollbackCommand(root, deployId) {
 			message: "Select a deployment to roll back to:",
 			options: candidates.map((d) => ({
 				value: d.id,
-				label: `${d.id} ${dim(formatAge(d.deployed_at))}`,
+				label: `${d.id} ${dim(d.deployed_at ? formatRelativeTime(d.deployed_at) : "")}`,
 				hint: d.source ? `via ${d.source}` : void 0
 			}))
 		});
@@ -74,7 +74,7 @@ async function runRollbackCommand(root, deployId) {
 	}
 }
 async function runCloudflareRollback(root, deployId) {
-	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BlYLlowZ.mjs");
+	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-CrSUFRzJ.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	const status = await readCloudflareWorkerStatus(context);
 	const deployedVersionIds = new Set(status.deployedVersionIds);
@@ -99,7 +99,7 @@ async function runCloudflareRollback(root, deployId) {
 			message: "Select a version to roll back to:",
 			options: candidates.map((version) => ({
 				value: version.id,
-				label: `${version.id} ${dim(formatAge(version.createdAt))}`,
+				label: `${version.id} ${dim(version.createdAt ? formatRelativeTime(version.createdAt) : "")}`,
 				hint: version.metadata ? formatCount(version.metadata.migrations.length, "migration") : "migration state unknown"
 			}))
 		});
@@ -146,15 +146,5 @@ async function confirmUnrevertedMigrations(migrationDiff, noun) {
 	log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
 	await confirmRollbackOrExit();
 }
-function formatAge(deployedAt) {
-	if (!deployedAt) return "";
-	const diffMs = Date.now() - new Date(ensureUtc(deployedAt)).getTime();
-	if (diffMs < 6e4) return "just now";
-	const minutes = Math.floor(diffMs / 6e4);
-	if (minutes < 60) return `${minutes}m ago`;
-	const hours = Math.floor(minutes / 60);
-	if (hours < 24) return `${hours}h ago`;
-	return `${Math.floor(hours / 24)}d ago`;
-}
 //#endregion
 export { runRollbackCommand };

package/dist/{route-types-CbtsIeFn.mjs → route-types-BZi26DVS.mjs}

@@ -1,80 +1,4 @@
-import { a as join, l as relative } from "./dist-BVqXeR_h.mjs";
-import { r as writeFileIfChanged } from "./project-tsconfig-CVJhNMxs.mjs";
-import { mkdirSync } from "node:fs";
-//#region src/codegen/db-types.ts
-const DRIZZLE_OPERATORS = "sql, eq, ne, gt, gte, lt, lte, and, or, not, desc, asc, like, ilike, notLike, inArray, notInArray, isNull, isNotNull, between, notBetween, exists, notExists, count, sum, avg, min, max";
-/**
-* Generate `.void/db.d.ts` with Drizzle types referencing the user's schema.
-*
-* This is a proper module file (not `declare module`) whose types override
-* the base `void/db` package via a tsconfig `paths` redirect:
-*   "void/db": ["./.void/db.d.ts"]
-*
-* Imports reference `void/_db` (internal subpath pointing at the same
-* base module) to avoid circular resolution through the paths redirect.
-*/
-function generateDbDts(outDir, schema, dialect) {
-	mkdirSync(outDir, { recursive: true });
-	const lines = dialect === "mysql" ? schema ? [
-		"// Auto-generated by void — do not edit",
-		"import type { MySql2Database } from \"void/_db-mysql\";",
-		"import type * as schema from \"@schema\";",
-		"type Schema = typeof schema;",
-		"export declare const db: MySql2Database<Schema>;",
-		"export declare function createDb(connectionString: string): MySql2Database<Schema>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { MySql2Database } from \"void/_db-mysql\";",
-		""
-	] : [
-		"// Auto-generated by void — do not edit",
-		"import type { MySql2Database } from \"void/_db-mysql\";",
-		"export declare const db: MySql2Database<Record<string, never>>;",
-		"export declare function createDb(connectionString: string): MySql2Database<Record<string, never>>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { MySql2Database } from \"void/_db-mysql\";",
-		""
-	] : dialect === "postgresql" ? schema ? [
-		"// Auto-generated by void — do not edit",
-		"import type { NodePgDatabase } from \"void/_db-pg\";",
-		"import type * as schema from \"@schema\";",
-		"type Schema = typeof schema;",
-		"export declare const db: NodePgDatabase<Schema>;",
-		"export declare function createDb(connectionString: string): NodePgDatabase<Schema>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { NodePgDatabase } from \"void/_db-pg\";",
-		""
-	] : [
-		"// Auto-generated by void — do not edit",
-		"import type { NodePgDatabase } from \"void/_db-pg\";",
-		"export declare const db: NodePgDatabase<Record<string, never>>;",
-		"export declare function createDb(connectionString: string): NodePgDatabase<Record<string, never>>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { NodePgDatabase } from \"void/_db-pg\";",
-		""
-	] : schema ? [
-		"// Auto-generated by void — do not edit",
-		"/// <reference types=\"@cloudflare/workers-types\" />",
-		"import type { DrizzleD1Database } from \"void/_db\";",
-		"import type * as schema from \"@schema\";",
-		"type Schema = typeof schema;",
-		"export declare const db: DrizzleD1Database<Schema>;",
-		"export declare function createDb(d1: D1Database): DrizzleD1Database<Schema>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { DrizzleD1Database } from \"void/_db\";",
-		""
-	] : [
-		"// Auto-generated by void — do not edit",
-		"/// <reference types=\"@cloudflare/workers-types\" />",
-		"import type { DrizzleD1Database } from \"void/_db\";",
-		"export declare const db: DrizzleD1Database<Record<string, never>>;",
-		"export declare function createDb(d1: D1Database): DrizzleD1Database<Record<string, never>>;",
-		`export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-		"export type { DrizzleD1Database } from \"void/_db\";",
-		""
-	];
-	return writeFileIfChanged(join(outDir, "db.d.ts"), lines.join("\n"));
-}
-//#endregion
+import { s as relative } from "./dist-ipQi0Q8y.mjs";
 //#region src/codegen/queue-types.ts
 /**
 * Generate .void/queues.d.ts content.
@@ -271,22 +195,16 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 			const hasActions = page.methods.includes("actions");
 			if (hasAction && hasActions) throw new Error(`pages: Page '${page.pattern}' exports both "action" and "actions". Use one or the other.`);
 			lines.push(`    ${JSON.stringify(page.pattern)}: {`);
-			let importPath = null;
-			if (page.serverPath) {
-				const absPath = `${pagesDir}/${page.serverPath}`;
-				importPath = relative(outDir, absPath);
-			}
+			const importPath = relative(outDir, `${pagesDir}/${page.serverPath}`);
 			if (hasActions) {
-				if (importPath) {
-					const actionsImport = `(typeof import(${JSON.stringify(importPath)}))["actions"]`;
-					lines.push(`      actions: { [K in keyof ${actionsImport}]: {`);
-					lines.push(`        body: ExtractInput<${actionsImport}[K]["__validators"]> extends { body: infer B } ? B : Record<string, unknown>;`);
-					lines.push("      } };");
-				}
-			} else if (importPath) {
+				const actionsImport = `(typeof import(${JSON.stringify(importPath)}))["actions"]`;
+				lines.push(`      actions: { [K in keyof ${actionsImport}]: {`);
+				lines.push(`        body: ExtractInput<${actionsImport}[K]["__validators"]> extends { body: infer B } ? B : Record<string, unknown>;`);
+				lines.push("      } };");
+			} else {
 				const importExpr = `(typeof import(${JSON.stringify(importPath)}))["action"]`;
 				lines.push(`      body: ExtractInput<${importExpr}["__validators"]> extends { body: infer B } ? B : Record<string, unknown>;`);
-			} else lines.push("      body: Record<string, unknown>;");
+			}
 			if (page.params.length > 0) {
 				const paramsType = page.params.map((p) => `${p}: string`).join("; ");
 				lines.push(`      params: { ${paramsType} };`);
@@ -300,4 +218,4 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 	return { dts: lines.join("\n") };
 }
 //#endregion
-export { generateDbDts as i, generateQueueTypes as n, DRIZZLE_OPERATORS as r, generateRouteTypes as t };
+export { generateQueueTypes as n, generateRouteTypes as t };

package/dist/routing-assets-VkrKIbxE.mjs

@@ -0,0 +1,139 @@
+//#region src/runtime/routing-assets.ts
+const ASSET_EXTENSIONS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"avif",
+	"svg",
+	"ico",
+	"css",
+	"js",
+	"mjs",
+	"cjs",
+	"woff",
+	"woff2",
+	"ttf",
+	"otf",
+	"eot",
+	"mp4",
+	"webm",
+	"mp3",
+	"wav",
+	"pdf",
+	"txt",
+	"xml",
+	"json",
+	"wasm",
+	"map"
+];
+function createManifestLoader() {
+	let cached = null;
+	return async (request, env) => {
+		if (cached) return cached;
+		const injected = globalThis.__VITE_MANIFEST__;
+		if (typeof injected === "object" && injected) {
+			cached = injected;
+			return cached;
+		}
+		const assets = env?.ASSETS;
+		if (!assets || typeof assets.fetch !== "function") return null;
+		const response = await assets.fetch(new Request(new URL("/.vite/manifest.json", request.url).toString()));
+		if (!response.ok) return null;
+		cached = await response.json();
+		return cached;
+	};
+}
+const BINDING_HINT_SCRIPT = "<script type=\"module\" src=\"/@id/virtual:void/binding-hint\"><\/script>";
+const REACT_REFRESH_SCRIPT = `<script type="module">
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+<\/script>`;
+const escapeAttribute = (value) => String(value).replace(/"/g, "&quot;");
+const script = (url) => `<script type="module" src="${escapeAttribute(url)}"><\/script>`;
+function collectManifestFiles(manifest, entryId, depthFirst) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [entryId];
+	for (let index = 0; depthFirst ? pending.length > 0 : index < pending.length;) {
+		const id = depthFirst ? pending.pop() : pending[index++];
+		if (seen.has(id)) continue;
+		seen.add(id);
+		const imports = manifest[id]?.imports;
+		if (Array.isArray(imports)) pending.push(...imports);
+	}
+	return [...seen];
+}
+function collectRouteCss(manifest, roots) {
+	const css = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (visited.has(id)) return;
+		visited.add(id);
+		const chunk = manifest[id];
+		if (!chunk) return;
+		if (Array.isArray(chunk.css)) for (const file of chunk.css) css.add(file);
+		if (Array.isArray(chunk.imports)) for (const imported of chunk.imports) visit(imported);
+	};
+	for (const root of roots) visit(root);
+	return css;
+}
+/** Frameworks supply only client entry IDs and active layout/page roots. */
+function createClientAssetTags(options, loadManifest = createManifestLoader()) {
+	return async (request, env, componentId = "") => {
+		const empty = {
+			css: "",
+			preloads: "",
+			body: ""
+		};
+		const manifest = await loadManifest(request, env);
+		if (!manifest || typeof manifest !== "object") {
+			if (!options.dev) return empty;
+			const preloads = [script("/@vite/client"), BINDING_HINT_SCRIPT];
+			if (options.kind === "ssr" && options.reactRefresh) preloads.push(REACT_REFRESH_SCRIPT);
+			let body = script(options.entryUrl);
+			if (options.extraEntryUrl) body += "\n" + script(options.extraEntryUrl);
+			const tags = {
+				css: "",
+				preloads: preloads.join("\n"),
+				body
+			};
+			if (options.devCss && options.kind !== "ssr") {
+				const css = await options.devCss(request, env, {
+					kind: options.kind,
+					componentId,
+					rootPhases: options.devRootPhases?.[componentId] || [[options.entryUrl]]
+				});
+				tags.devCss = Array.isArray(css) ? css : [];
+			}
+			return tags;
+		}
+		const entry = manifest[options.entryId];
+		if (!entry || typeof entry !== "object" || typeof entry.file !== "string") return empty;
+		const ids = collectManifestFiles(manifest, options.entryId, options.kind === "ssr");
+		const extraEntry = options.extraEntryId ? manifest[options.extraEntryId] : void 0;
+		const hasExtra = extraEntry && typeof extraEntry.file === "string";
+		if (hasExtra) ids.push(...collectManifestFiles(manifest, options.extraEntryId, false));
+		const css = options.kind === "ssr" ? /* @__PURE__ */ new Set() : collectRouteCss(manifest, [options.entryId, ...options.pageCssKeys?.[componentId] ?? []]);
+		if (hasExtra) for (const file of collectRouteCss(manifest, [options.extraEntryId])) css.add(file);
+		const preloads = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			const chunk = manifest[id];
+			if (!chunk || typeof chunk !== "object") continue;
+			if (options.kind === "ssr" && Array.isArray(chunk.css)) for (const file of chunk.css) css.add(file);
+			if (id !== options.entryId && id !== options.extraEntryId && typeof chunk.file === "string") preloads.add(chunk.file);
+		}
+		let body = script("/" + entry.file);
+		if (hasExtra) body += "\n" + script("/" + extraEntry.file);
+		return {
+			css: [...css].map((file) => `<link rel="stylesheet" href="/${escapeAttribute(file)}">`).join("\n"),
+			preloads: [...preloads].map((file) => `<link rel="modulepreload" href="/${escapeAttribute(file)}">`).join("\n"),
+			body
+		};
+	};
+}
+//#endregion
+export { createClientAssetTags as n, createManifestLoader as r, ASSET_EXTENSIONS as t };

package/dist/{runner-DMBKSrRk.mjs → runner-CabsQ-iM.mjs}

@@ -1,6 +1,6 @@
-import { a as join, n as dirname } from "./dist-BVqXeR_h.mjs";
-import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
-import { n as hasPackageDependency, r as readNearestPackageJson } from "./package-json-DXfiT1jV.mjs";
+import { a as join, n as dirname } from "./dist-ipQi0Q8y.mjs";
+import { t as collectMigrations } from "./collect-xjffdCdk.mjs";
+import { n as hasPackageDependency, r as readNearestPackageJson } from "./package-json-BjYqR-So.mjs";
 import { r as classifyMigration } from "./plan-BhLO2p4w.mjs";
 import { existsSync, mkdirSync } from "node:fs";
 import { createHash, createHmac } from "node:crypto";
@@ -64,14 +64,8 @@ function getMiniflareDatabasePath(persistRoot, databaseId) {
 	return join(persistRoot, "v3", "d1", uniqueKey, `${hash}.sqlite`);
 }
 /**
-* One-time migration: rename legacy `_migrations` table to `_void_migrations`.
-* Copies all rows from the old table to the new one, then drops the old table.
-*
-* Wrapped in an IMMEDIATE transaction + re-checked inside, so two concurrent
-* local runners (e.g. two `vite dev` processes against the same DB file)
-* don't race each other. Without the lock, both could observe `_migrations`
-* exists, both enter the body, and the loser crashes on `SELECT … FROM
-* _migrations` after the winner already dropped it.
+* Move the legacy `_migrations` rows into `_void_migrations`. The check runs inside an
+* IMMEDIATE transaction so two local runners cannot both copy and drop the old table.
 */
 function upgradeTrackingTable(db) {
 	db.transaction(() => {
@@ -120,23 +114,8 @@ function assertLocalMigrationState(migrations, appliedNames, applicationTables)
 	].join("\n"));
 }
 /**
-* Apply unapplied SQL migrations from the migrations directory.
-* Tracks applied migrations in the `_void_migrations` table.
-*
-* Each .sql file is executed as a single `db.exec()` call — better-sqlite3's
-* `exec` natively handles multi-statement SQL and lets SQLite do the parsing,
-* so semicolons inside string literals, comments, or trigger bodies don't
-* fracture the migration. A naive `split(';')` pre-processor would misparse
-* a statement like `CREATE TABLE t (msg TEXT DEFAULT 'a;b')` into garbage
-* fragments.
-*
-* Concurrent-runner safety: two local `void` processes can race against the
-* same SQLite file. Both can snapshot the applied-set before either writes,
-* and if both decide a migration is pending, the loser would crash on a
-* `table already exists` error. Each per-migration apply therefore runs
-* inside an IMMEDIATE transaction that re-checks the tracking row under the
-* SQLite write lock — the loser sees the winner's insert and skips, instead
-* of re-running the DDL.
+* Apply pending SQL migrations and record them in `_void_migrations`.
+* Each file runs through one `exec` so SQLite parses multi-statement SQL itself.
 */
 async function runMigrations(migrationsDir, dbPath) {
 	const allMigrations = collectMigrations(migrationsDir);
@@ -159,12 +138,21 @@ async function runMigrations(migrationsDir, dbPath) {
 		const insertStmt = db.prepare("INSERT INTO _void_migrations (name) VALUES (?)");
 		const checkStmt = db.prepare("SELECT 1 FROM _void_migrations WHERE name = ?");
 		const appliedNames = [];
-		for (const migration of pending) if (db.transaction(() => {
-			if (checkStmt.get(migration.name)) return false;
-			db.exec(migration.sql);
-			insertStmt.run(migration.name);
-			return true;
-		}).immediate()) appliedNames.push(migration.name);
+		for (const migration of pending) {
+			const tx = db.transaction(() => {
+				if (checkStmt.get(migration.name)) return false;
+				db.exec(migration.sql);
+				insertStmt.run(migration.name);
+				return true;
+			});
+			let applied;
+			try {
+				applied = tx.immediate();
+			} catch (err) {
+				throw new Error(`migration ${migration.name} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+			}
+			if (applied) appliedNames.push(migration.name);
+		}
 		return appliedNames;
 	} finally {
 		db.close();

package/dist/runner-So9mYfcm.mjs

@@ -0,0 +1 @@
+export { t as getApplicationTables, n as getAppliedMigrations, r as getMiniflareDatabasePath, i as openSqliteDatabase, a as runMigrations } from "./runner-CabsQ-iM.mjs";

package/dist/runner-mysql-BhRaONkO.mjs

@@ -0,0 +1,146 @@
+import { t as collectMigrations } from "./collect-xjffdCdk.mjs";
+import { a as mySqlMigrationLockError, o as mySqlMigrationLockName, s as readMySqlMigrationLease, t as splitMySqlMigrationSql } from "./mysql-migration-sql-BIS5vbNk.mjs";
+//#region src/migrations/runner-mysql.ts
+async function readMySqlAppliedMigrations(client) {
+	try {
+		return (await client.query("SELECT `name` FROM `_void_migrations`")).map((row) => String(row.name));
+	} catch (error) {
+		const value = typeof error === "object" && error !== null ? error : void 0;
+		if (value?.code === "ER_NO_SUCH_TABLE" || value?.errno === 1146) return [];
+		throw error;
+	}
+}
+function toMySqlClient(connection) {
+	return { async query(sql, params) {
+		const [rows] = await connection.query(sql, params);
+		return Array.isArray(rows) ? rows : [];
+	} };
+}
+async function getMySqlAppliedMigrations(url) {
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection(url);
+	try {
+		return await readMySqlAppliedMigrations(toMySqlClient(connection));
+	} finally {
+		await connection.end();
+	}
+}
+const MIGRATION_LOCK_TIMEOUT_SECONDS = 10;
+/**
+* Take a named lock so two runs on one database cannot both apply a pending file. The lock
+* survives the commits MySQL makes for DDL and ends with the session. A deploy cannot hold a
+* session lock and writes a lease row instead, so this also waits for that lease.
+*/
+async function acquireMySqlMigrationLock(client) {
+	const [row] = await client.query("SELECT DATABASE() AS db");
+	const database = row?.db ?? "";
+	const name = mySqlMigrationLockName(database);
+	const [lock] = await client.query("SELECT GET_LOCK(?, ?) AS acquired", [name, MIGRATION_LOCK_TIMEOUT_SECONDS]);
+	if (Number(Object.values(lock ?? {})[0]) !== 1) throw mySqlMigrationLockError(database, "run the command again");
+	const readLease = () => readMySqlMigrationLease((sql, params) => client.query(sql, params));
+	const deadline = Date.now() + MIGRATION_LOCK_TIMEOUT_SECONDS * 1e3;
+	let remaining = await readLease();
+	while (remaining !== void 0 && Date.now() < deadline) {
+		await new Promise((resolve) => setTimeout(resolve, 1e3));
+		remaining = await readLease();
+	}
+	if (remaining !== void 0) {
+		await client.query("SELECT RELEASE_LOCK(?)", [name]).catch(() => {});
+		throw new Error(`A deploy is applying migrations to MySQL database "${database}". Wait for it to finish, then run the command again. If that deploy stopped, its lock expires in ${remaining} seconds.`);
+	}
+	return name;
+}
+/**
+* A DDL statement makes MySQL commit and close the open transaction. A savepoint can only be
+* rolled back to inside a transaction, so this tells whether the file's changes can still be undone.
+*/
+async function isTransactionOpen(client) {
+	try {
+		await client.query("SAVEPOINT `void_migration`");
+		await client.query("ROLLBACK TO SAVEPOINT `void_migration`");
+		return true;
+	} catch {
+		return false;
+	}
+}
+const ROLLED_BACK_BY_SERVER_ERRNOS = /* @__PURE__ */ new Set([1213, 3101]);
+function isRolledBackByServer(error) {
+	const errno = typeof error === "object" && error !== null ? error.errno : void 0;
+	return typeof errno === "number" && ROLLED_BACK_BY_SERVER_ERRNOS.has(errno);
+}
+function mySqlMigrationError(name, error, committed) {
+	const lines = [`migration ${name} failed: ${error instanceof Error ? error.message : String(error)}`];
+	if (committed) lines.push(`MySQL commits schema changes immediately, so earlier statements in ${name} may already be applied. Undo them, fix the file, then run the command again.`, "See https://void.cloud/guide/database/mysql#failed-migrations");
+	return new Error(lines.join("\n"), { cause: error });
+}
+/**
+* Runs `work` while this session holds the database's migration lock, so no other migration run,
+* deploy or reset changes the schema meanwhile.
+*/
+async function withMySqlMigrationLock(client, work) {
+	const lock = await acquireMySqlMigrationLock(client);
+	try {
+		return await work();
+	} finally {
+		await client.query("SELECT RELEASE_LOCK(?)", [lock]).catch(() => {});
+	}
+}
+async function applyMySqlMigrations(client, migrations) {
+	if (migrations.length === 0) return [];
+	return withMySqlMigrationLock(client, () => applyPendingMySqlMigrations(client, migrations));
+}
+/** Applies the files not yet recorded. The caller holds the migration lock. */
+async function applyPendingMySqlMigrations(client, migrations) {
+	if (migrations.length === 0) return [];
+	await client.query("CREATE TABLE IF NOT EXISTS `_void_migrations` (`name` VARCHAR(255) PRIMARY KEY, `applied_at` VARCHAR(64) NOT NULL)");
+	const existing = await client.query("SELECT `name` FROM `_void_migrations`");
+	const appliedSet = new Set(existing.map((row) => String(row.name)));
+	const pending = migrations.filter((migration) => !appliedSet.has(migration.name));
+	for (const migration of pending) {
+		let ran = 0;
+		await client.query("BEGIN");
+		try {
+			for (const statement of splitMySqlMigrationSql(migration.sql)) {
+				await client.query(statement);
+				ran++;
+			}
+			await client.query("INSERT INTO `_void_migrations` (`name`, `applied_at`) VALUES (?, ?)", [migration.name, (/* @__PURE__ */ new Date()).toISOString()]);
+			await client.query("COMMIT");
+		} catch (error) {
+			const committed = ran > 0 && !isRolledBackByServer(error) && !await isTransactionOpen(client);
+			await client.query("ROLLBACK").catch(() => {});
+			throw mySqlMigrationError(migration.name, error, committed);
+		}
+	}
+	return pending.map((migration) => migration.name);
+}
+/** Connects to `url` and runs `work` while holding that database's migration lock. */
+async function withMySqlMigrationLockAt(url, work) {
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection({
+		uri: url,
+		multipleStatements: true
+	});
+	try {
+		const client = toMySqlClient(connection);
+		return await withMySqlMigrationLock(client, () => work(client));
+	} finally {
+		await connection.end();
+	}
+}
+/**
+* Applies the pending files in `migrationsDir`. `afterApply` gets the applied names and runs before
+* the lock is released, so the schema changes it makes (Better Auth's tables) do not overlap
+* another run either.
+*/
+async function runMySqlMigrations(migrationsDir, url, afterApply) {
+	const migrations = collectMigrations(migrationsDir);
+	if (migrations.length === 0 && !afterApply) return [];
+	return withMySqlMigrationLockAt(url, async (client) => {
+		const applied = await applyPendingMySqlMigrations(client, migrations);
+		await afterApply?.(applied);
+		return applied;
+	});
+}
+//#endregion
+export { runMySqlMigrations as a, withMySqlMigrationLockAt as c, readMySqlAppliedMigrations as i, applyPendingMySqlMigrations as n, toMySqlClient as o, getMySqlAppliedMigrations as r, withMySqlMigrationLock as s, applyMySqlMigrations as t };

package/dist/runner-mysql-DWwE8jKi.mjs

@@ -0,0 +1 @@
+export { t as applyMySqlMigrations, n as applyPendingMySqlMigrations, r as getMySqlAppliedMigrations, i as readMySqlAppliedMigrations, a as runMySqlMigrations, o as toMySqlClient, s as withMySqlMigrationLock, c as withMySqlMigrationLockAt } from "./runner-mysql-BhRaONkO.mjs";

package/dist/{runner-pg-DV8p_zjA.mjs → runner-pg-BRemq_GX.mjs}

@@ -1,4 +1,4 @@
-import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
+import { t as collectMigrations } from "./collect-xjffdCdk.mjs";
 //#region src/migrations/runner-pg.ts
 async function readPgAppliedMigrations(client) {
 	try {
@@ -36,8 +36,8 @@ async function applyPgMigrations(client, migrations) {
 			await client.query("INSERT INTO _void_migrations (name, applied_at) VALUES ($1, $2)", [m.name, (/* @__PURE__ */ new Date()).toISOString()]);
 			await client.query("COMMIT");
 		} catch (err) {
-			await client.query("ROLLBACK");
-			throw err;
+			await client.query("ROLLBACK").catch(() => {});
+			throw new Error(`migration ${m.name} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
 		}
 	}
 	return pending.map((m) => m.name);

package/dist/runner-pg-_Xncr3H5.mjs

@@ -0,0 +1 @@
+export { t as applyPgMigrations, n as getPgAppliedMigrations, r as readPgAppliedMigrations, i as runPgMigrations } from "./runner-pg-BRemq_GX.mjs";