void 0.27.0 → 0.28.0

package/dist/{requests-C7Oeoh5u.mjs → requests-3CL3BuZh.mjs}

@@ -1,8 +1,8 @@
-import { r as readProjectConfig } from "./project-BAm2aB6Q.mjs";
-import { c as getToken } from "./auth-Dn2vw-SG.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-D3m88sjf.mjs";
-import { i as dim, l as import_picocolors } from "./output-C50ag2r3.mjs";
-import { r as PlatformClient } from "./client-DlDJuY0s.mjs";
+import { f as import_picocolors, i as dim } from "./output-FNHKw5Ac.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-B9Hr0D3n.mjs

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

package/dist/resolve-project-C_Cu7E8a.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-D3m88sjf.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-Ce1d_0J9.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 { 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-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 { c as formatRelativeTime, i as dim, m as printSuccess, o as formatCount, r as createSpinner } from "./output-FNHKw5Ac.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-Ds-lX3Ts.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-IrBuwJ7u.mjs}

@@ -1,8 +1,24 @@
-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";
+import { a as join, s as relative } from "./dist-ipQi0Q8y.mjs";
+import { r as writeFileIfChanged } from "./project-tsconfig-bveqhlYA.mjs";
 //#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";
+const DIALECT_DB_TYPES = {
+	sqlite: {
+		type: "DrizzleD1Database",
+		from: "void/_db",
+		arg: "d1: D1Database"
+	},
+	postgresql: {
+		type: "NodePgDatabase",
+		from: "void/_db-pg",
+		arg: "connectionString: string"
+	},
+	mysql: {
+		type: "MySql2Database",
+		from: "void/_db-mysql",
+		arg: "connectionString: string"
+	}
+};
 /**
 * Generate `.void/db.d.ts` with Drizzle types referencing the user's schema.
 *
@@ -14,62 +30,17 @@ const DRIZZLE_OPERATORS = "sql, eq, ne, gt, gte, lt, lte, and, or, not, desc, as
 * 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\";",
-		""
-	] : [
+	const { type, from, arg } = DIALECT_DB_TYPES[dialect];
+	const schemaType = schema ? "Schema" : "Record<string, never>";
+	const lines = [
 		"// 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>>;",
+		...dialect === "sqlite" ? ["/// <reference types=\"@cloudflare/workers-types\" />"] : [],
+		`import type { ${type} } from "${from}";`,
+		...schema ? ["import type * as schema from \"@schema\";", "type Schema = typeof schema;"] : [],
+		`export declare const db: ${type}<${schemaType}>;`,
+		`export declare function createDb(${arg}): ${type}<${schemaType}>;`,
 		`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\";",
+		`export type { ${type} } from "${from}";`,
 		""
 	];
 	return writeFileIfChanged(join(outDir, "db.d.ts"), lines.join("\n"));
@@ -271,22 +242,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} };`);

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-9wjsSZx-.mjs → runner-B5huK2eC.mjs}

@@ -1,2 +1,2 @@
-import { a as runMigrations, i as openSqliteDatabase, n as getAppliedMigrations, r as getMiniflareDatabasePath, t as getApplicationTables } from "./runner-DMBKSrRk.mjs";
+import { a as runMigrations, i as openSqliteDatabase, n as getAppliedMigrations, r as getMiniflareDatabasePath, t as getApplicationTables } from "./runner-DcVDrzuR.mjs";
 export { getApplicationTables, getAppliedMigrations, getMiniflareDatabasePath, openSqliteDatabase, runMigrations };

package/dist/{runner-DMBKSrRk.mjs → runner-DcVDrzuR.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);

package/dist/{runner-mysql-CEzKtmFb.mjs → runner-mysql-CCtyI0p6.mjs}

@@ -1,4 +1,5 @@
-import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
+import { t as collectMigrations } from "./collect-xjffdCdk.mjs";
+import { n as splitMigrationSql } from "./migration-handler-Cg0Y4EPu.mjs";
 //#region src/migrations/runner-mysql.ts
 async function readMySqlAppliedMigrations(client) {
 	try {
@@ -31,7 +32,7 @@ async function applyMySqlMigrations(client, 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) {
-		await client.query(migration.sql);
+		for (const statement of splitMigrationSql(migration.sql)) await client.query(statement);
 		await client.query("INSERT INTO `_void_migrations` (`name`, `applied_at`) VALUES (?, ?)", [migration.name, (/* @__PURE__ */ new Date()).toISOString()]);
 	}
 	return pending.map((migration) => migration.name);
@@ -51,4 +52,4 @@ async function runMySqlMigrations(migrationsDir, url) {
 	}
 }
 //#endregion
-export { runMySqlMigrations as i, getMySqlAppliedMigrations as n, readMySqlAppliedMigrations as r, applyMySqlMigrations as t };
+export { toMySqlClient as a, runMySqlMigrations as i, getMySqlAppliedMigrations as n, readMySqlAppliedMigrations as r, applyMySqlMigrations as t };

package/dist/runner-mysql-CaJq-hd6.mjs

@@ -0,0 +1,2 @@
+import { a as toMySqlClient, i as runMySqlMigrations, n as getMySqlAppliedMigrations, r as readMySqlAppliedMigrations, t as applyMySqlMigrations } from "./runner-mysql-CCtyI0p6.mjs";
+export { applyMySqlMigrations, getMySqlAppliedMigrations, readMySqlAppliedMigrations, runMySqlMigrations, toMySqlClient };

package/dist/runner-pg-BJhFZZG4.mjs

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

package/dist/{runner-pg-DV8p_zjA.mjs → runner-pg-CPd-CB_F.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 {

package/dist/runtime/ai.mjs

@@ -1,5 +1,6 @@
-import { t as cfAccessHeaders } from "../cf-access-TWNzXltp.mjs";
-import { a as getRawRuntimeEnv } from "../env-raw-jZpP5n47.mjs";
+import { n as bytesToBase64 } from "../base64-DVrOndmI.mjs";
+import { t as cfAccessHeaders } from "../cf-access-BM9G0lhO.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cklzcde3.mjs";
 import { r as limitFromResponse, t as UsageLimit } from "../limits-D0vD1M9A.mjs";
 //#region src/runtime/ai-types.ts
 /** Maps provider prefix to expected env var name for the API key */
@@ -95,12 +96,6 @@ function copyBinaryView(value) {
 	copy.set(bytes);
 	return copy.buffer;
 }
-function bytesToBase64(bytes) {
-	let binary = "";
-	const chunkSize = 32768;
-	for (let i = 0; i < bytes.length; i += chunkSize) binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
-	return btoa(binary);
-}
 function arrayBufferToBase64(buffer) {
 	return bytesToBase64(new Uint8Array(buffer));
 }
@@ -214,16 +209,10 @@ async function responseFromResult(result) {
 	if (isBinaryView(result)) return new Response(copyBinaryView(result), { headers: { "content-type": "application/octet-stream" } });
 	return Response.json(result);
 }
-function splitImageOptions(options) {
-	if (typeof options !== "object" || options === null) return {
-		endpoint: "images/generations",
-		runOptions: void 0
-	};
-	const { endpoint, ...runOptions } = options;
-	return {
-		endpoint: typeof endpoint === "string" ? endpoint : "images/generations",
-		runOptions: Object.keys(runOptions).length > 0 ? runOptions : void 0
-	};
+function imageRunOptions(options) {
+	if (typeof options !== "object" || options === null) return;
+	const { endpoint: _endpoint, ...runOptions } = options;
+	return Object.keys(runOptions).length > 0 ? runOptions : void 0;
 }
 function resolveProviderKey(provider, runtimeEnv, options) {
 	const envVar = options?.apiKeyEnv ?? PROVIDER_KEY_MAP[provider];
@@ -324,11 +313,10 @@ function makeProxyBackend(send, runtimeEnv) {
 			return readProxyResult(res);
 		},
 		async image(model, inputs, options) {
-			const { runOptions } = splitImageOptions(options);
 			return proxyFetch("run", {
 				model,
 				inputs,
-				options: runOptions
+				options: imageRunOptions(options)
 			});
 		},
 		async providerFetch(provider, path, init, options) {
@@ -392,8 +380,7 @@ function makeDirectBackend(directAi, runtimeEnv, gatewayId) {
 	return {
 		run,
 		async image(model, inputs, options) {
-			const { runOptions } = splitImageOptions(options);
-			return responseFromResult(await run(model, inputs, runOptions));
+			return responseFromResult(await run(model, inputs, imageRunOptions(options)));
 		},
 		async providerFetch(provider, path, init, options) {
 			if (!gatewayId) return Response.json({ error: "ai: ai.provider().fetch() needs an AI Gateway when self-hosting. Set \"ai\": { \"gateway\": \"<id>\" } in void.json." }, { status: 501 });

package/dist/runtime/better-auth-mysql.d.mts

@@ -1,10 +1,7 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-CPvWD3nG.mjs";
+import { n as VoidAuthRuntimeApi } from "../better-auth-shared-B74NJIus.mjs";
 //#region src/runtime/better-auth-mysql.d.ts
-export declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
-export declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
 export declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
 export declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
 export declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
 export declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
-//#endregion
-export type { VoidAuthDialect, VoidAuthEnv, VoidAuthRuntimeOptions };
+//#endregion

package/dist/runtime/better-auth-mysql.mjs

@@ -1,44 +1,19 @@
-import { t as applyMySqlAuthMigrations } from "../auth-migrations-BwHgeEsD.mjs";
-import { n as createVoidAuthRuntime, r as resolveConnectionString } from "../better-auth-shared-DPpj8zxc.mjs";
+import { i as mysqlMigrationRunner, t as applyMySqlAuthMigrations } from "../auth-migrations-Cgs0k6lS.mjs";
+import { n as resolveConnectionString, t as createVoidAuthRuntime } from "../better-auth-shared-CMXlZG7W.mjs";
 //#region src/runtime/better-auth-mysql.ts
-async function resolveDatabase(env) {
-	const { createPool } = await import("mysql2/promise");
-	const pool = createPool({
-		uri: resolveConnectionString(env, "MySQL"),
-		connectionLimit: 1
-	});
-	return {
-		database: pool,
-		async dispose() {
-			await pool.end();
-		}
-	};
-}
-async function runMySqlAuthMigrations(_request, env, runtime, migrationSchema) {
-	if (!migrationSchema) throw new Error("auth: Migration schema is unavailable.");
-	if (runtime.dialect !== "mysql" || migrationSchema.dialect !== "mysql") throw new Error("auth: Runtime mismatch. Expected mysql.");
+async function applyMigrations(env, migrationSchema) {
 	const { createConnection } = await import("mysql2/promise");
 	const connection = await createConnection(resolveConnectionString(env, "MySQL"));
 	try {
-		await applyMySqlAuthMigrations({
-			async all(sql, params) {
-				const [rows] = await connection.query(sql, params);
-				return rows;
-			},
-			async run(sql, params) {
-				await connection.query(sql, params);
-			}
-		}, migrationSchema);
+		await applyMySqlAuthMigrations(mysqlMigrationRunner(connection), migrationSchema);
 	} finally {
 		await connection.end();
 	}
 }
-const runtime = createVoidAuthRuntime("mysql", resolveDatabase, runMySqlAuthMigrations);
-const resolveVoidAuthOptions = runtime.resolveVoidAuthOptions;
-const createVoidAuth = runtime.createVoidAuth;
+const runtime = createVoidAuthRuntime("mysql", applyMigrations);
 const resolveVoidAuthState = runtime.resolveVoidAuthState;
 const runVoidAuthMiddleware = runtime.runVoidAuthMiddleware;
 const handleVoidAuthRequest = runtime.handleVoidAuthRequest;
 const runVoidAuthMigrations = runtime.runVoidAuthMigrations;
 //#endregion
-export { createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };
+export { handleVoidAuthRequest, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };

package/dist/runtime/better-auth-pg.d.mts

@@ -1,10 +1,7 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-CPvWD3nG.mjs";
+import { n as VoidAuthRuntimeApi } from "../better-auth-shared-B74NJIus.mjs";
 //#region src/runtime/better-auth-pg.d.ts
-export declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
-export declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
 export declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
 export declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
 export declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
 export declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
-//#endregion
-export type { VoidAuthDialect, VoidAuthEnv, VoidAuthRuntimeOptions };
+//#endregion