void 0.10.12 → 0.20.0

package/dist/rollback-CtlPXEBi.mjs

@@ -0,0 +1,166 @@
+import { C as cancel, D as log, E as intro, F as isCancel, a as dim, c as import_picocolors, i as createSpinner, j as select, k as outro, o as ensureUtc, r as cliTitle, w as confirm } from "./output-tFQLLj26.mjs";
+import { b as readDeploymentPlatform, c as getToken, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
+import { n as PlatformClient } from "./client-CyCHWSO_.mjs";
+//#region src/cli/rollback.ts
+async function runRollbackCommand(root, deployId) {
+	console.log();
+	intro(cliTitle("project rollback"));
+	const platform = readDeploymentPlatform(root);
+	if (platform === "cloudflare") return runCloudflareRollback(root, deployId);
+	if (platform === "none") throw new Error("rollback: Deployment is disabled. Run `void init` to choose a platform.");
+	const token = getToken(root);
+	if (!token) {
+		log.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const linked = readProjectConfig(root);
+	if (!linked) {
+		log.error("No linked project. Run `void project link` first.");
+		process.exit(1);
+	}
+	const client = new PlatformClient(token, { root });
+	const { deployments, activeDeploymentId } = await client.listDeployments(linked.projectId);
+	const candidates = deployments.filter((d) => d.retained && d.status === "live" && d.id !== activeDeploymentId);
+	if (candidates.length === 0) {
+		log.warn("No retained deployments available for rollback.");
+		outro(dim("Deploy more versions to enable rollback."));
+		return;
+	}
+	let targetId;
+	if (deployId) {
+		if (!candidates.find((d) => d.id === deployId)) {
+			log.error(`Deployment ${deployId} is not available for rollback (not retained or not found).`);
+			process.exit(1);
+		}
+		targetId = deployId;
+	} else {
+		const result = await select({
+			message: "Select a deployment to roll back to:",
+			options: candidates.map((d) => ({
+				value: d.id,
+				label: `${d.id} ${dim(formatAge(d.deployed_at))}`,
+				hint: d.source ? `via ${d.source}` : void 0
+			}))
+		});
+		if (isCancel(result)) {
+			cancel("Rollback cancelled.");
+			process.exit(0);
+		}
+		targetId = result;
+	}
+	const active = deployments.find((d) => d.id === activeDeploymentId);
+	const target = candidates.find((d) => d.id === targetId);
+	const currentMigrations = active?.applied_migrations ? JSON.parse(active.applied_migrations) : [];
+	const targetMigrations = target.applied_migrations ? JSON.parse(target.applied_migrations) : [];
+	const migrationDiff = currentMigrations.filter((m) => !targetMigrations.includes(m));
+	if (migrationDiff.length > 0) {
+		log.warn(`The current database has ${migrationDiff.length} migration(s) applied after this deployment:`);
+		for (const m of migrationDiff) log.message(`  ${dim("•")} ${m}`);
+		log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
+		const proceed = await confirm({ message: "Proceed with rollback?" });
+		if (isCancel(proceed) || !proceed) {
+			cancel("Rollback cancelled.");
+			process.exit(0);
+		}
+	}
+	const s = createSpinner();
+	s.start("Rolling back...");
+	try {
+		const result = await client.rollback(linked.projectId, targetId, { allowDestructive: migrationDiff.length > 0 ? migrationDiff : void 0 });
+		s.stop("Rollback complete.");
+		if (result.ok) log.success(`Rolled back to ${import_picocolors.default.bold(targetId)}`);
+		else {
+			log.error(result.error ?? "Rollback failed.");
+			process.exit(1);
+		}
+	} catch (err) {
+		s.stop("Rollback failed.");
+		log.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	outro(dim("Traffic is now serving the rolled-back deployment."));
+}
+async function runCloudflareRollback(root, deployId) {
+	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+	const context = resolveCloudflareOperationContext(root);
+	const status = await readCloudflareWorkerStatus(context);
+	const deployedVersionIds = new Set(status.deployedVersionIds);
+	const candidates = [...status.versions].reverse().filter((version) => version.id !== status.activeVersionId && deployedVersionIds.has(version.id));
+	if (candidates.length === 0) {
+		log.warn("No previous Cloudflare Worker Versions are available for rollback.");
+		outro(dim("Deploy more versions to enable rollback."));
+		return;
+	}
+	const requestedMatches = deployId ? candidates.filter((version) => version.id === deployId || version.id.startsWith(deployId)) : [];
+	if (requestedMatches.length > 1) {
+		log.error(`Version prefix ${deployId} is ambiguous; pass the complete version id.`);
+		process.exit(1);
+	}
+	let target = requestedMatches[0];
+	if (deployId && !target) {
+		log.error(`Version ${deployId} is not available for rollback.`);
+		process.exit(1);
+	}
+	if (!target) {
+		const result = await select({
+			message: "Select a version to roll back to:",
+			options: candidates.map((version) => ({
+				value: version.id,
+				label: `${version.id} ${dim(formatAge(version.createdAt))}`,
+				hint: version.metadata ? `${version.metadata.migrations.length} migration(s)` : "migration state unknown"
+			}))
+		});
+		if (isCancel(result)) {
+			cancel("Rollback cancelled.");
+			process.exit(0);
+		}
+		target = candidates.find((version) => version.id === result);
+	}
+	const current = status.versions.find((version) => version.id === status.activeVersionId);
+	if (target.metadata?.schema !== 2 || current?.metadata?.schema !== 2 || target.metadata.triggerConfig.preserve || current.metadata.triggerConfig.preserve) log.info("This rollback keeps the current domains, routes, and schedules. The selected version has no complete trigger snapshot.");
+	if (!current?.metadata || !target.metadata) {
+		log.warn("Void migration metadata is unavailable for one of these versions. Database migrations are forward-only and will not be reverted.");
+		const proceed = await confirm({ message: "Proceed with rollback?" });
+		if (isCancel(proceed) || !proceed) {
+			cancel("Rollback cancelled.");
+			process.exit(0);
+		}
+	} else {
+		const targetSet = new Set(target.metadata.migrations);
+		const migrationDiff = current.metadata.migrations.filter((migration) => !targetSet.has(migration));
+		if (migrationDiff.length > 0) {
+			log.warn(`The current database has ${migrationDiff.length} migration(s) applied after this version:`);
+			for (const migration of migrationDiff) log.message(`  ${dim("•")} ${migration}`);
+			log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
+			const proceed = await confirm({ message: "Proceed with rollback?" });
+			if (isCancel(proceed) || !proceed) {
+				cancel("Rollback cancelled.");
+				process.exit(0);
+			}
+		}
+	}
+	const spinner = createSpinner();
+	spinner.start("Rolling back...");
+	try {
+		await activateCloudflareExistingVersion(context, target, current);
+		spinner.stop("Rollback complete.");
+	} catch (error) {
+		spinner.stop("Rollback failed.");
+		log.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+	log.success(`Rolled back to ${import_picocolors.default.bold(target.id)}`);
+	outro(dim("Traffic is now serving the selected Cloudflare Worker Version."));
+}
+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/{rolldown-runtime-DJK8HYOj.mjs → rolldown-runtime-rQ84J-ij.mjs}

@@ -26,7 +26,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));

package/dist/{route-types-COI2DsZv.mjs → route-types-Da-DpyUp.mjs}

@@ -1,6 +1,6 @@
-import { a as join, s as relative } from "./dist-DaKKDf8D.mjs";
-import { r as writeFileIfChanged } from "./project-tsconfig-B-QtXjLQ.mjs";
+import { c as relative, o as join } from "./dist-BrsS7cai.mjs";
 import { a as isVoidSocialAuthProvider } from "./providers-CJlNS3kT.mjs";
+import { r as writeFileIfChanged } from "./project-tsconfig-Ql2XsSQp.mjs";
 import { mkdirSync } from "node:fs";
 import { getAuthTables, getSchema } from "better-auth/db";
 //#region src/codegen/db-types.ts
@@ -17,7 +17,25 @@ const DRIZZLE_OPERATORS = "sql, eq, ne, gt, gte, lt, lte, and, or, not, desc, as
 */
 function generateDbDts(outDir, schema, dialect) {
 	mkdirSync(outDir, { recursive: true });
-	const lines = dialect === "postgresql" ? schema ? [
+	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\";",
@@ -123,13 +141,32 @@ function renderEnumValues(values) {
 function resolveFieldName(defaultFieldName, field) {
 	return field.fieldName ?? defaultFieldName;
 }
+const UNBOUNDED_MYSQL_AUTH_FIELDS = /* @__PURE__ */ new Set([
+	"account.accessToken",
+	"account.refreshToken",
+	"account.idToken"
+]);
+function usesUnboundedMySqlText(defaultModelName, defaultFieldName, field) {
+	return field.type === "string" && !field.unique && !field.index && !field.references && !field.sortable && UNBOUNDED_MYSQL_AUTH_FIELDS.has(`${defaultModelName}.${defaultFieldName}`);
+}
 function resolveReferenceFieldName(schema, model, field) {
 	if (field === "id") return "id";
 	const referencedField = schema[model]?.fields[field];
 	return referencedField ? resolveFieldName(field, referencedField) : field;
 }
-function createColumnBuilder(dialect, idStrategy, fieldName, field) {
+function createColumnBuilder(dialect, idStrategy, defaultModelName, defaultFieldName, fieldName, field) {
 	const useIdType = fieldName === "id" || field.references?.field === "id";
+	if (dialect === "mysql") {
+		if (useIdType) return idStrategy === "serial" ? `int(${JSON.stringify(fieldName)})` : `varchar(${JSON.stringify(fieldName)}, { length: ${idStrategy === "uuid" ? 36 : 255} })`;
+		if (Array.isArray(field.type)) return `varchar(${JSON.stringify(fieldName)}, { length: 255, enum: ${renderEnumValues(field.type)} })`;
+		if (isJsonField(field)) return `json(${JSON.stringify(fieldName)})`;
+		switch (field.type) {
+			case "boolean": return `boolean(${JSON.stringify(fieldName)})`;
+			case "date": return `timestamp(${JSON.stringify(fieldName)}, { mode: "date", fsp: 3 })`;
+			case "number": return field.bigint ? `bigint(${JSON.stringify(fieldName)}, { mode: "number" })` : `int(${JSON.stringify(fieldName)})`;
+			default: return usesUnboundedMySqlText(defaultModelName, defaultFieldName, field) ? `text(${JSON.stringify(fieldName)})` : `varchar(${JSON.stringify(fieldName)}, { length: 255 })`;
+		}
+	}
 	if (dialect === "postgresql") {
 		if (useIdType) {
 			if (idStrategy === "serial") return `integer(${JSON.stringify(fieldName)})`;
@@ -160,10 +197,13 @@ function createColumnBuilder(dialect, idStrategy, fieldName, field) {
 		default: return `text(${JSON.stringify(fieldName)})`;
 	}
 }
-function createColumnDefinition(dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field) {
+function createColumnDefinition(dialect, schema, idStrategy, defaultToVariable, defaultModelName, defaultFieldName, field) {
 	const actualFieldName = resolveFieldName(defaultFieldName, field);
-	const parts = [createColumnBuilder(dialect, idStrategy, actualFieldName, field)];
-	if (actualFieldName === "id") parts.push(".primaryKey()");
+	const parts = [createColumnBuilder(dialect, idStrategy, defaultModelName, defaultFieldName, actualFieldName, field)];
+	if (actualFieldName === "id") {
+		parts.push(".primaryKey()");
+		if (dialect === "mysql" && idStrategy === "serial") parts.push(".autoincrement()");
+	}
 	if (field.required !== false || actualFieldName === "id") parts.push(".notNull()");
 	if (field.references) {
 		const referenceModel = Object.entries(schema).find(([_, value]) => value.modelName === field.references?.model)?.[0] ?? field.references.model;
@@ -177,10 +217,10 @@ function createColumnDefinition(dialect, schema, idStrategy, defaultToVariable,
 	return parts.join("");
 }
 function collectCoreImports(dialect, schema, idStrategy) {
-	const imports = /* @__PURE__ */ new Set([dialect === "postgresql" ? "pgTable" : "sqliteTable", "text"]);
-	if (idStrategy === "serial") imports.add("integer");
+	const imports = /* @__PURE__ */ new Set([dialect === "postgresql" ? "pgTable" : dialect === "mysql" ? "mysqlTable" : "sqliteTable", dialect === "mysql" ? "varchar" : "text"]);
+	if (idStrategy === "serial") imports.add(dialect === "mysql" ? "int" : "integer");
 	if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
-	for (const [, table] of Object.entries(schema)) for (const [defaultFieldName, field] of Object.entries(table.fields)) {
+	for (const [defaultModelName, table] of Object.entries(schema)) for (const [defaultFieldName, field] of Object.entries(table.fields)) {
 		if (resolveFieldName(defaultFieldName, field) === "id" || field.references?.field === "id") {
 			if (idStrategy === "serial") imports.add("integer");
 			if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
@@ -188,24 +228,24 @@ function collectCoreImports(dialect, schema, idStrategy) {
 		}
 		if (field.index) imports.add("index");
 		if (Array.isArray(field.type) || field.type === "string") {
-			imports.add("text");
+			imports.add(dialect === "mysql" && !usesUnboundedMySqlText(defaultModelName, defaultFieldName, field) ? "varchar" : "text");
 			continue;
 		}
 		if (isJsonField(field)) {
-			imports.add(dialect === "postgresql" ? "jsonb" : "text");
+			imports.add(dialect === "postgresql" ? "jsonb" : dialect === "mysql" ? "json" : "text");
 			continue;
 		}
 		if (field.type === "boolean") {
-			imports.add(dialect === "postgresql" ? "boolean" : "integer");
+			imports.add(dialect === "postgresql" ? "boolean" : dialect === "mysql" ? "boolean" : "integer");
 			continue;
 		}
 		if (field.type === "date") {
-			imports.add(dialect === "postgresql" ? "timestamp" : "integer");
+			imports.add(dialect === "postgresql" ? "timestamp" : dialect === "mysql" ? "timestamp" : "integer");
 			continue;
 		}
 		if (field.type === "number") {
-			imports.add("integer");
-			if (field.bigint && dialect === "postgresql") imports.add("bigint");
+			imports.add(dialect === "mysql" ? "int" : "integer");
+			if (field.bigint && dialect !== "sqlite") imports.add("bigint");
 		}
 	}
 	return [...imports].sort();
@@ -218,8 +258,8 @@ function generateVoidAuthDrizzleSchema(runtime, env = {}) {
 	const defaultToVariable = /* @__PURE__ */ new Map();
 	const entries = Object.entries(schema).sort(([, left], [, right]) => (left.order ?? DEFAULT_TABLE_ORDER) - (right.order ?? DEFAULT_TABLE_ORDER));
 	for (const [defaultModelName] of entries) defaultToVariable.set(defaultModelName, `${sanitizeIdentifier(defaultModelName)}Table`);
-	const tableFactory = runtime.dialect === "postgresql" ? "pgTable" : "sqliteTable";
-	const importPath = runtime.dialect === "postgresql" ? "void/schema-pg" : "void/schema-d1";
+	const tableFactory = runtime.dialect === "postgresql" ? "pgTable" : runtime.dialect === "mysql" ? "mysqlTable" : "sqliteTable";
+	const importPath = runtime.dialect === "postgresql" ? "void/schema-pg" : runtime.dialect === "mysql" ? "void/schema-mysql" : "void/schema-d1";
 	const lines = [
 		"// Auto-generated by void — do not edit",
 		`import { ${collectCoreImports(runtime.dialect, schema, idStrategy).join(", ")} } from ${JSON.stringify(importPath)};`,
@@ -228,12 +268,12 @@ function generateVoidAuthDrizzleSchema(runtime, env = {}) {
 	for (const [defaultModelName, table] of entries) {
 		const variableName = defaultToVariable.get(defaultModelName);
 		const fieldEntries = Object.entries(table.fields);
-		const renderedFields = [`  "id": ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, "id", {
+		const renderedFields = [`  "id": ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, defaultModelName, "id", {
 			type: idStrategy === "serial" ? "number" : "string",
 			required: true
 		})},`, ...fieldEntries.map(([defaultFieldName, field]) => {
 			const actualFieldName = resolveFieldName(defaultFieldName, field);
-			return `  ${JSON.stringify(actualFieldName)}: ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field)},`;
+			return `  ${JSON.stringify(actualFieldName)}: ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, defaultModelName, defaultFieldName, field)},`;
 		})];
 		const indexedFields = fieldEntries.filter(([, field]) => field.index && !field.unique);
 		if (indexedFields.length > 0) lines.push(`export const ${variableName} = ${tableFactory}(${JSON.stringify(table.modelName)}, {`, ...renderedFields, `}, (table) => [`, ...indexedFields.map(([defaultFieldName, field]) => {
@@ -252,7 +292,12 @@ function generateVoidAuthDrizzleSchema(runtime, env = {}) {
 }
 function resolveVoidAuthMigrationSchema(runtime, env = {}) {
 	const options = resolveSchemaOptions(runtime, env);
+	const logicalSchema = getAuthTables(options);
 	const schema = getSchema(options);
+	const unboundedMySqlFields = /* @__PURE__ */ new Set();
+	if (runtime.dialect === "mysql") {
+		for (const [defaultModelName, table] of Object.entries(logicalSchema)) for (const [defaultFieldName, field] of Object.entries(table.fields)) if (usesUnboundedMySqlText(defaultModelName, defaultFieldName, field)) unboundedMySqlFields.add(`${table.modelName}\0${resolveFieldName(defaultFieldName, field)}`);
+	}
 	return {
 		dialect: runtime.dialect,
 		idStrategy: resolveIdStrategy(options),
@@ -265,6 +310,7 @@ function resolveVoidAuthMigrationSchema(runtime, env = {}) {
 				unique: field.unique === true,
 				index: field.index === true,
 				bigint: field.bigint === true,
+				...unboundedMySqlFields.has(`${name}\0${fieldName}`) ? { unbounded: true } : {},
 				...field.references ? { references: {
 					table: field.references.model,
 					field: field.references.field,
@@ -276,14 +322,21 @@ function resolveVoidAuthMigrationSchema(runtime, env = {}) {
 }
 function generateVoidAuthDatabaseModule(options) {
 	const schemaImport = JSON.stringify(options.schemaImportPath);
-	const provider = options.dialect === "postgresql" ? "pg" : "sqlite";
+	const provider = options.dialect === "postgresql" ? "pg" : options.dialect === "mysql" ? "mysql" : "sqlite";
 	return [
 		"// Auto-generated by void — do not edit",
 		`import { drizzleAdapter } from ${JSON.stringify(options.drizzleAdapterPath)};`,
 		`import { db as __voidDb } from "void/db";`,
 		`import { schema as __voidAuthSchema } from ${schemaImport};`,
 		"",
-		`export const __voidAuthDatabase = drizzleAdapter(__voidDb, { provider: ${JSON.stringify(provider)}, schema: __voidAuthSchema });`,
+		"// Better Auth reads Drizzle metadata while creating the adapter.",
+		"// Defer that work until request handling, when runtime bindings are available.",
+		"let __voidAuthDatabaseInstance: ReturnType<typeof drizzleAdapter> | undefined;",
+		"",
+		"export const __voidAuthDatabase: ReturnType<typeof drizzleAdapter> = (options) => {",
+		`  __voidAuthDatabaseInstance ??= drizzleAdapter(__voidDb, { provider: ${JSON.stringify(provider)}, schema: __voidAuthSchema });`,
+		"  return __voidAuthDatabaseInstance(options);",
+		"};",
 		""
 	].join("\n");
 }
@@ -301,7 +354,8 @@ function generateQueueTypes(queues, queuesDir, outDir) {
 	lines.push("// Auto-generated by void — do not edit");
 	lines.push("export interface QueueMap {");
 	for (const q of queues) {
-		const importPath = relative(outDir, `${queuesDir}/${q.filePath}`);
+		const absPath = `${queuesDir}/${q.filePath}`;
+		const importPath = relative(outDir, absPath);
 		lines.push(`  ${JSON.stringify(q.name)}: Queue<(typeof import(${JSON.stringify(importPath)}))["default"]["__payload"]>;`);
 	}
 	lines.push("}");
@@ -428,7 +482,8 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 	lines.push("  interface RouteMap {");
 	for (const route of scan.routes) {
 		if (route.methods.length === 0) continue;
-		const importPath = relative(outDir, `${routesDir}/${route.filePath}`);
+		const absRoutePath = `${routesDir}/${route.filePath}`;
+		const importPath = relative(outDir, absRoutePath);
 		lines.push(`    ${JSON.stringify(route.pattern)}: {`);
 		for (const method of route.methods) {
 			lines.push(`      ${method}: {`);
@@ -442,7 +497,8 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 	lines.push("");
 	lines.push("  interface WebSocketRouteMap {");
 	for (const route of scan.websockets ?? []) {
-		const importPath = relative(outDir, `${routesDir}/${route.filePath}`);
+		const absRoutePath = `${routesDir}/${route.filePath}`;
+		const importPath = relative(outDir, absRoutePath);
 		lines.push(`    ${JSON.stringify(route.pattern)}: {`);
 		lines.push(`      params: RouteParams<${JSON.stringify(route.params)}>;`);
 		lines.push(`      client: ExtractInput<(typeof import(${JSON.stringify(importPath)}))["default"]["messages"]["client"]>;`);
@@ -459,7 +515,10 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 			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) importPath = relative(outDir, `${pagesDir}/${page.serverPath}`);
+			if (page.serverPath) {
+				const absPath = `${pagesDir}/${page.serverPath}`;
+				importPath = relative(outDir, absPath);
+			}
 			if (hasActions) {
 				if (importPath) {
 					const actionsImport = `(typeof import(${JSON.stringify(importPath)}))["actions"]`;

package/dist/routes-stub.d.mts

@@ -1,24 +1,24 @@
 //#region src/routes-stub.d.ts
 /** Stub interface augmented by the generated .void/routes.d.ts */
-interface RouteMap {}
+export interface RouteMap {}
 /** Stub interface augmented by the generated .void/routes.d.ts */
-interface WebSocketRouteMap {}
+export interface WebSocketRouteMap {}
 /** Union of known route patterns (keys of the generated RouteMap). */
-type RouteName = keyof RouteMap;
+export type RouteName = keyof RouteMap;
 /**
-* Destination type for rewrites / fallbacks / c.rewrite().
-*
-* The `string & {}` branch keeps IDE autocomplete of known routes while
-* still accepting arbitrary strings (needed for dynamic paths like
-* `/users/${id}`). When no routes are generated yet, `RouteName` is
-* `never` and this degenerates to `string & {}`, which is assignable
-* from any string.
-*/
-type RewriteDestination = RouteName | (string & {});
+ * Destination type for rewrites / fallbacks / c.rewrite().
+ *
+ * The `string & {}` branch keeps IDE autocomplete of known routes while
+ * still accepting arbitrary strings (needed for dynamic paths like
+ * `/users/${id}`). When no routes are generated yet, `RouteName` is
+ * `never` and this degenerates to `string & {}`, which is assignable
+ * from any string.
+ */
+export type RewriteDestination = RouteName | (string & {});
 /** Stub interface for page action types — augmented by generated routes.d.ts */
-interface PageActionMap {}
+export interface PageActionMap {}
 /** Parse "/path?action" into base path and action name */
-type ParseActionUrl<U extends string> = U extends `${infer Base}?${infer Action}` ? {
+export type ParseActionUrl<U extends string> = U extends `${infer Base}?${infer Action}` ? {
   base: Base;
   action: Action;
 } : {
@@ -26,7 +26,7 @@ type ParseActionUrl<U extends string> = U extends `${infer Base}?${infer Action}
   action: never;
 };
 /** Resolve body type for a useForm URL (single action or named action) */
-type ResolveActionBody<U extends string> = ParseActionUrl<U>["base"] extends keyof PageActionMap ? ParseActionUrl<U>["action"] extends never ? PageActionMap[ParseActionUrl<U>["base"]] extends {
+export type ResolveActionBody<U extends string> = ParseActionUrl<U>["base"] extends keyof PageActionMap ? ParseActionUrl<U>["action"] extends never ? PageActionMap[ParseActionUrl<U>["base"]] extends {
   body: infer B;
 } ? B : Record<string, unknown> : PageActionMap[ParseActionUrl<U>["base"]] extends {
   actions: infer A;
@@ -34,22 +34,21 @@ type ResolveActionBody<U extends string> = ParseActionUrl<U>["base"] extends key
   body: infer B;
 } ? B : Record<string, unknown> : never : never : Record<string, unknown>;
 /** Resolve params type */
-type ResolveActionParams<U extends string> = ParseActionUrl<U>["base"] extends keyof PageActionMap ? PageActionMap[ParseActionUrl<U>["base"]] extends {
+export type ResolveActionParams<U extends string> = ParseActionUrl<U>["base"] extends keyof PageActionMap ? PageActionMap[ParseActionUrl<U>["base"]] extends {
   params: infer P;
 } ? P : never : never;
 /** Has params check */
-type HasActionParams<U extends string> = ResolveActionParams<U> extends Record<string, string> ? true : false;
+export type HasActionParams<U extends string> = ResolveActionParams<U> extends Record<string, string> ? true : false;
 /** Form options type (requires params for dynamic routes) */
-type ActionFormOptions<U extends string> = HasActionParams<U> extends true ? {
+export type ActionFormOptions<U extends string> = HasActionParams<U> extends true ? {
   params: ResolveActionParams<U>;
 } : {
   params?: never;
 };
 /** Valid useForm URLs — single-action pages + "page?name" combos + default actions */
-type ActionUrl = { [K in keyof PageActionMap]: PageActionMap[K] extends {
+export type ActionUrl = { [K in keyof PageActionMap]: PageActionMap[K] extends {
   body: unknown;
-} ? K : never }[keyof PageActionMap] | { [K in keyof PageActionMap]: PageActionMap[K] extends {
+} ? K : never; }[keyof PageActionMap] | { [K in keyof PageActionMap]: PageActionMap[K] extends {
   actions: infer A;
-} ? `${K & string}?${keyof A & string}` : never }[keyof PageActionMap];
-//#endregion
-export { ActionFormOptions, ActionUrl, HasActionParams, PageActionMap, ParseActionUrl, ResolveActionBody, ResolveActionParams, RewriteDestination, RouteMap, RouteName, WebSocketRouteMap };
+} ? `${K & string}?${keyof A & string}` : never; }[keyof PageActionMap];
+//#endregion

package/dist/runner-mysql-CgRFl3s6.mjs

@@ -0,0 +1,61 @@
+import { n as __exportAll } from "./rolldown-runtime-rQ84J-ij.mjs";
+import { c as collectMigrations } from "./validate-Bihr8WBi.mjs";
+//#region src/migrations/runner-mysql.ts
+var runner_mysql_exports = /* @__PURE__ */ __exportAll({
+	applyMySqlMigrations: () => applyMySqlMigrations,
+	getMySqlAppliedMigrations: () => getMySqlAppliedMigrations,
+	readMySqlAppliedMigrations: () => readMySqlAppliedMigrations,
+	runMySqlMigrations: () => runMySqlMigrations
+});
+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;
+	}
+}
+async function getMySqlAppliedMigrations(url) {
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection(url);
+	try {
+		return await readMySqlAppliedMigrations({ async query(sql, params) {
+			const [rows] = await connection.query(sql, params);
+			return Array.isArray(rows) ? rows : [];
+		} });
+	} finally {
+		await connection.end();
+	}
+}
+async function applyMySqlMigrations(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) {
+		await client.query(migration.sql);
+		await client.query("INSERT INTO `_void_migrations` (`name`, `applied_at`) VALUES (?, ?)", [migration.name, (/* @__PURE__ */ new Date()).toISOString()]);
+	}
+	return pending.map((migration) => migration.name);
+}
+async function runMySqlMigrations(migrationsDir, url) {
+	const migrations = collectMigrations(migrationsDir);
+	if (migrations.length === 0) return [];
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection({
+		uri: url,
+		multipleStatements: true
+	});
+	try {
+		return await applyMySqlMigrations({ async query(sql, params) {
+			const [rows] = await connection.query(sql, params);
+			return Array.isArray(rows) ? rows : [];
+		} }, migrations);
+	} finally {
+		await connection.end();
+	}
+}
+//#endregion
+export { runner_mysql_exports as n, runMySqlMigrations as t };

package/dist/{runner-pg-CHM76xuC.mjs → runner-pg-DCkWPsWS.mjs}

@@ -1,5 +1,20 @@
-import { c as collectMigrations } from "./validate-Cw_RLeTj.mjs";
+import { n as __exportAll } from "./rolldown-runtime-rQ84J-ij.mjs";
+import { c as collectMigrations } from "./validate-Bihr8WBi.mjs";
 //#region src/migrations/runner-pg.ts
+var runner_pg_exports = /* @__PURE__ */ __exportAll({
+	applyPgMigrations: () => applyPgMigrations,
+	getPgAppliedMigrations: () => getPgAppliedMigrations,
+	readPgAppliedMigrations: () => readPgAppliedMigrations,
+	runPgMigrations: () => runPgMigrations
+});
+async function readPgAppliedMigrations(client) {
+	try {
+		return (await client.query("SELECT name FROM _void_migrations")).rows.map((row) => String(row.name));
+	} catch (error) {
+		if (typeof error === "object" && error !== null && error.code === "42P01") return [];
+		throw error;
+	}
+}
 /**
 * Apply unapplied SQL migrations via a connected PostgreSQL client.
 * Each migration runs in its own transaction (BEGIN/COMMIT).
@@ -9,10 +24,7 @@ async function getPgAppliedMigrations(url) {
 	const client = new Client({ connectionString: url });
 	await client.connect();
 	try {
-		await client.query(`CREATE TABLE IF NOT EXISTS _void_migrations (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)`);
-		return (await client.query("SELECT name FROM _void_migrations")).rows.map((row) => String(row.name));
-	} catch {
-		return [];
+		return await readPgAppliedMigrations(client);
 	} finally {
 		await client.end();
 	}
@@ -54,4 +66,4 @@ async function runPgMigrations(migrationsDir, url) {
 	}
 }
 //#endregion
-export { applyPgMigrations, getPgAppliedMigrations, runPgMigrations };
+export { runner_pg_exports as n, runPgMigrations as t };

package/dist/runtime/ai.d.mts

@@ -19,22 +19,29 @@ type AiProviderFetchInit = {
 //#endregion
 //#region src/runtime/ai.d.ts
 /**
-* Extended AI type with a convenience `stream()` method.
-*
-* `stream()` calls `ai.run()` with `stream: true` and wraps the result
-* in a `Response` with SSE headers — ready to return from a route handler.
-*/
-type VoidAi = Omit<Ai, "run"> & {
-  /** Workers AI inference (existing) */run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>; /** Cloudflare AI Gateway model inference. Accepts Cloudflare model IDs unchanged. */
-  run(model: string, inputs: unknown, options?: AiOptions): Promise<unknown>; /** Image generation. Returns the proxy response so callers can return or parse it. */
-  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<Response>; /** Cloudflare AI Gateway model inference returned as a Response. */
-  image(model: string, inputs: unknown, options?: AiOptions): Promise<Response>; /** Provider-native AI Gateway requests using a project secret for the provider API key. */
+ * Extended AI type with a convenience `stream()` method.
+ *
+ * `stream()` calls `ai.run()` with `stream: true` and wraps the result
+ * in a `Response` with SSE headers — ready to return from a route handler.
+ */
+export type VoidAi = Omit<Ai, "run"> & {
+  /** Workers AI inference (existing) */
+  run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>;
+  /** Cloudflare AI Gateway model inference. Accepts Cloudflare model IDs unchanged. */
+  run(model: string, inputs: unknown, options?: AiOptions): Promise<unknown>;
+  /** Image generation. Returns the proxy response so callers can return or parse it. */
+  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<Response>;
+  /** Cloudflare AI Gateway model inference returned as a Response. */
+  image(model: string, inputs: unknown, options?: AiOptions): Promise<Response>;
+  /** Provider-native AI Gateway requests using a project secret for the provider API key. */
   provider(provider: AiProvider, options?: AiProviderOptions): {
     fetch(path: string, init?: AiProviderFetchInit): Promise<Response>;
-  }; /** Stream Workers AI response as SSE */
-  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>; /** Stream any Cloudflare AI Gateway model response as SSE */
+  };
+  /** Stream Workers AI response as SSE */
+  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>;
+  /** Stream any Cloudflare AI Gateway model response as SSE */
   stream(model: string, inputs: Record<string, unknown>, options?: AiOptions): Promise<Response>;
 };
-declare const ai: VoidAi;
+export declare const ai: VoidAi;
 //#endregion
-export { type AiProvider, type AiProviderFetchInit, type AiProviderName, type AiProviderOptions, type ImageFileInput, VoidAi, ai };
+export type { AiProvider, AiProviderFetchInit, AiProviderName, AiProviderOptions, ImageFileInput };