void 0.1.6 → 0.7.0

package/dist/rollback-gyC59l7U.mjs

@@ -0,0 +1,92 @@
+import { a as ensureUtc, i as dim, n as cliTitle, r as createSpinner, s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { _ as me, c as R, g as ge, i as Ee, v as ue, x as q, y as ye } from "./dist-Dayj3gCK.mjs";
+import { r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+//#region src/cli/rollback.ts
+async function runRollbackCommand(root, deployId) {
+	console.log();
+	ge(cliTitle("project rollback"));
+	const token = getToken(root);
+	if (!token) {
+		R.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const linked = readProjectConfig(root);
+	if (!linked) {
+		R.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) {
+		R.warn("No retained deployments available for rollback.");
+		ye(dim("Deploy more versions to enable rollback."));
+		return;
+	}
+	let targetId;
+	if (deployId) {
+		if (!candidates.find((d) => d.id === deployId)) {
+			R.error(`Deployment ${deployId} is not available for rollback (not retained or not found).`);
+			process.exit(1);
+		}
+		targetId = deployId;
+	} else {
+		const result = await Ee({
+			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 (q(result)) {
+			me("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) {
+		R.warn(`The current database has ${migrationDiff.length} migration(s) applied after this deployment:`);
+		for (const m of migrationDiff) R.message(`  ${dim("•")} ${m}`);
+		R.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
+		const proceed = await ue({ message: "Proceed with rollback?" });
+		if (q(proceed) || !proceed) {
+			me("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) R.success(`Rolled back to ${import_picocolors.default.bold(targetId)}`);
+		else {
+			R.error(result.error ?? "Rollback failed.");
+			process.exit(1);
+		}
+	} catch (err) {
+		s.stop("Rollback failed.");
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	ye(dim("Traffic is now serving the rolled-back deployment."));
+}
+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-DReF1gUY.mjs

@@ -0,0 +1,255 @@
+import { a as join, o as relative } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { mkdirSync, writeFileSync } 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 === "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\";",
+		""
+	];
+	writeFileSync(join(outDir, "db.d.ts"), lines.join("\n"));
+}
+//#endregion
+//#region src/codegen/queue-types.ts
+/**
+* Generate .void/queues.d.ts content.
+*
+* Augments `void/queues` with a typed `QueueMap` interface
+* so `queues.emails.send(body)` is fully typed from the consumer's
+* `defineQueue<T>` phantom type.
+*/
+function generateQueueTypes(queues, queuesDir, outDir) {
+	const lines = [];
+	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}`);
+		lines.push(`  ${JSON.stringify(q.name)}: Queue<(typeof import(${JSON.stringify(importPath)}))["default"]["__payload"]>;`);
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push("export declare const queues: QueueMap;");
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/codegen/route-types.ts
+/**
+* Generate .void/routes.d.ts content.
+*
+* Uses `typeof import(...)` so TypeScript resolves all types.
+* The codegen generates scaffolding only — never analyzes types itself.
+*/
+function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
+	const lines = [];
+	lines.push("// Auto-generated by void — do not edit");
+	lines.push("export {}");
+	lines.push("interface StandardSchemaV1<Input = unknown, Output = Input> {");
+	lines.push("  readonly \"~standard\": {");
+	lines.push("    readonly version: 1;");
+	lines.push("    readonly vendor: string;");
+	lines.push("    readonly validate: (value: unknown) => unknown;");
+	lines.push("    readonly types?: { readonly input: Input; readonly output: Output } | undefined;");
+	lines.push("  };");
+	lines.push("}");
+	lines.push("declare namespace StandardSchemaV1 {");
+	lines.push("  type InferInput<Schema extends StandardSchemaV1> = NonNullable<");
+	lines.push("    Schema[\"~standard\"][\"types\"]");
+	lines.push("  >[\"input\"];");
+	lines.push("  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<");
+	lines.push("    Schema[\"~standard\"][\"types\"]");
+	lines.push("  >[\"output\"];");
+	lines.push("}");
+	lines.push("");
+	lines.push("type Serialize<T> =");
+	lines.push("  T extends Response ? never :");
+	lines.push("  T extends Date ? string :");
+	lines.push("  T extends bigint ? never :");
+	lines.push("  T extends Function ? never :");
+	lines.push("  T extends undefined ? never :");
+	lines.push("  T extends Array<infer U> ? Array<Serialize<U>> :");
+	lines.push("  T extends object ? { [K in keyof T as T[K] extends Function ? never : K]: Serialize<T[K]> } :");
+	lines.push("  T;");
+	lines.push("");
+	lines.push("type ExtractInput<V> = {");
+	lines.push("  [K in keyof V as V[K] extends StandardSchemaV1 ? K : never]:");
+	lines.push("    V[K] extends StandardSchemaV1 ? StandardSchemaV1.InferInput<V[K]> : never;");
+	lines.push("};");
+	lines.push("");
+	lines.push("type ExtractOutput<S> =");
+	lines.push("  S extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<S> : never;");
+	lines.push("");
+	lines.push("type RouteParams<P extends readonly string[]> =");
+	lines.push("  P extends readonly [] ? Record<string, never> : { [K in P[number]]: string };");
+	lines.push("");
+	lines.push("declare module \"void/routes\" {");
+	lines.push("  export interface RouteMap {}");
+	lines.push("  export interface WebSocketRouteMap {}");
+	lines.push("  export interface PageActionMap {}");
+	lines.push("");
+	lines.push("  /** Union of known route patterns (keys of the generated RouteMap). */");
+	lines.push("  export type RouteName = keyof RouteMap;");
+	lines.push("");
+	lines.push("  /**");
+	lines.push("   * Destination type for rewrites / fallbacks / c.rewrite().");
+	lines.push("   *");
+	lines.push("   * The `string & {}` branch keeps IDE autocomplete of known routes while");
+	lines.push("   * still accepting arbitrary strings (needed for dynamic paths like");
+	lines.push("   * `/users/${id}`). When no routes are generated yet, `RouteName` is");
+	lines.push("   * `never` and this degenerates to `string & {}`, which is assignable");
+	lines.push("   * from any string.");
+	lines.push("   */");
+	lines.push("  export type RewriteDestination = RouteName | (string & {});");
+	lines.push("");
+	lines.push("  export type ParseActionUrl<U extends string> = U extends `${infer Base}?${infer Action}` ? {");
+	lines.push("    base: Base;");
+	lines.push("    action: Action;");
+	lines.push("  } : {");
+	lines.push("    base: U;");
+	lines.push("    action: never;");
+	lines.push("  };");
+	lines.push("");
+	lines.push("  export type ResolveActionBody<U extends string> =");
+	lines.push("    ParseActionUrl<U>[\"base\"] extends keyof PageActionMap");
+	lines.push("      ? ParseActionUrl<U>[\"action\"] extends never");
+	lines.push("        ? PageActionMap[ParseActionUrl<U>[\"base\"]] extends { body: infer B }");
+	lines.push("          ? B");
+	lines.push("          : Record<string, unknown>");
+	lines.push("        : PageActionMap[ParseActionUrl<U>[\"base\"]] extends { actions: infer A }");
+	lines.push("          ? ParseActionUrl<U>[\"action\"] extends keyof A");
+	lines.push("            ? A[ParseActionUrl<U>[\"action\"]] extends { body: infer B }");
+	lines.push("              ? B");
+	lines.push("              : Record<string, unknown>");
+	lines.push("            : never");
+	lines.push("          : never");
+	lines.push("      : Record<string, unknown>;");
+	lines.push("");
+	lines.push("  export type ResolveActionParams<U extends string> =");
+	lines.push("    ParseActionUrl<U>[\"base\"] extends keyof PageActionMap");
+	lines.push("      ? PageActionMap[ParseActionUrl<U>[\"base\"]] extends { params: infer P }");
+	lines.push("        ? P");
+	lines.push("        : never");
+	lines.push("      : never;");
+	lines.push("");
+	lines.push("  export type HasActionParams<U extends string> =");
+	lines.push("    ResolveActionParams<U> extends Record<string, string> ? true : false;");
+	lines.push("");
+	lines.push("  export type ActionFormOptions<U extends string> =");
+	lines.push("    HasActionParams<U> extends true ? { params: ResolveActionParams<U> } : { params?: never };");
+	lines.push("");
+	lines.push("  export type ActionUrl =");
+	lines.push("    | {");
+	lines.push("        [K in keyof PageActionMap]: PageActionMap[K] extends { body: any } ? K : never;");
+	lines.push("      }[keyof PageActionMap]");
+	lines.push("    | {");
+	lines.push("        [K in keyof PageActionMap]: PageActionMap[K] extends { actions: infer A }");
+	lines.push("          ? `${K & string}?${keyof A & string}`");
+	lines.push("          : never;");
+	lines.push("      }[keyof PageActionMap]");
+	lines.push("");
+	lines.push("  interface RouteMap {");
+	for (const route of scan.routes) {
+		if (route.methods.length === 0) continue;
+		const importPath = relative(outDir, `${routesDir}/${route.filePath}`);
+		lines.push(`    ${JSON.stringify(route.pattern)}: {`);
+		for (const method of route.methods) {
+			lines.push(`      ${method}: {`);
+			lines.push(`        input: ExtractInput<(typeof import(${JSON.stringify(importPath)}))["${method}"]["__validators"]>;`);
+			lines.push(`        output: Serialize<Awaited<(typeof import(${JSON.stringify(importPath)}))["${method}"]["__output"]>>;`);
+			lines.push("      };");
+		}
+		lines.push("    };");
+	}
+	lines.push("  }");
+	lines.push("");
+	lines.push("  interface WebSocketRouteMap {");
+	for (const route of scan.websockets ?? []) {
+		const importPath = relative(outDir, `${routesDir}/${route.filePath}`);
+		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"]>;`);
+		lines.push(`      server: ExtractOutput<(typeof import(${JSON.stringify(importPath)}))["default"]["messages"]["server"]>;`);
+		lines.push("    };");
+	}
+	lines.push("  }");
+	const actionPages = scan.pages.pages.filter((p) => p.methods.includes("action") || p.methods.includes("actions"));
+	if (actionPages.length > 0 && pagesDir) {
+		lines.push("  interface PageActionMap {");
+		for (const page of actionPages) {
+			const hasAction = page.methods.includes("action");
+			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) 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 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} };`);
+			}
+			lines.push("    };");
+		}
+		lines.push("  }");
+	}
+	lines.push("}");
+	lines.push("");
+	return { dts: lines.join("\n") };
+}
+//#endregion
+export { generateDbDts as i, generateQueueTypes as n, DRIZZLE_OPERATORS as r, generateRouteTypes as t };

package/dist/routes-stub.d.mts

@@ -0,0 +1,55 @@
+//#region src/routes-stub.d.ts
+/** Stub interface augmented by the generated .void/routes.d.ts */
+interface RouteMap {}
+/** Stub interface augmented by the generated .void/routes.d.ts */
+interface WebSocketRouteMap {}
+/** Union of known route patterns (keys of the generated RouteMap). */
+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 & {});
+/** Stub interface for page action types — augmented by generated routes.d.ts */
+interface PageActionMap {}
+/** Parse "/path?action" into base path and action name */
+type ParseActionUrl<U extends string> = U extends `${infer Base}?${infer Action}` ? {
+  base: Base;
+  action: Action;
+} : {
+  base: U;
+  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 {
+  body: infer B;
+} ? B : Record<string, unknown> : PageActionMap[ParseActionUrl<U>["base"]] extends {
+  actions: infer A;
+} ? ParseActionUrl<U>["action"] extends keyof A ? A[ParseActionUrl<U>["action"]] extends {
+  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 {
+  params: infer P;
+} ? P : never : never;
+/** Has params check */
+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 ? {
+  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 {
+  body: unknown;
+} ? 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 };

package/dist/routes-stub.mjs

@@ -0,0 +1 @@
+export {};

package/dist/runner-6Ep3fNQu.mjs

@@ -0,0 +1,123 @@
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { t as collectMigrations } from "./collect-CjeZgz5D.mjs";
+import { existsSync, mkdirSync } from "node:fs";
+import { createHash, createHmac } from "node:crypto";
+//#region src/migrations/runner.ts
+function toBetterSqlite3Error(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (!message.includes("Could not locate the bindings file")) return error instanceof Error ? error : new Error(message);
+	return /* @__PURE__ */ new Error("db: better-sqlite3 is installed but its native binding was not built. Add it to your 'onlyBuiltDependencies' and run `pnpm rebuild better-sqlite3`. See https://pnpm.io/settings#onlybuiltdependencies");
+}
+async function openSqliteDatabase(dbPath, options) {
+	try {
+		const Database = (await import("better-sqlite3")).default;
+		return new Database(dbPath, options);
+	} catch (error) {
+		throw toBetterSqlite3Error(error);
+	}
+}
+/**
+* Read the list of applied migrations from the local SQLite database.
+* Returns [] if the DB file or tracking table doesn't exist.
+*/
+async function getAppliedMigrations(dbPath) {
+	if (!existsSync(dbPath)) return [];
+	const db = await openSqliteDatabase(dbPath, { readonly: true });
+	try {
+		let tableName = null;
+		for (const candidate of ["_void_migrations", "_migrations"]) if (db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='${candidate}'`).get()) {
+			tableName = candidate;
+			break;
+		}
+		if (!tableName) return [];
+		return db.prepare(`SELECT name, applied_at FROM ${tableName} ORDER BY name`).all();
+	} finally {
+		db.close();
+	}
+}
+/**
+* Compute the miniflare D1 SQLite database path.
+* Miniflare uses a deterministic hash based on the database_id
+* to store local D1 data.
+*/
+function getMiniflareDatabasePath(persistRoot, databaseId) {
+	const uniqueKey = "miniflare-D1DatabaseObject";
+	const key = createHash("sha256").update(uniqueKey).digest();
+	const nameHmac = createHmac("sha256", key).update(databaseId).digest().subarray(0, 16);
+	const hmac = createHmac("sha256", key).update(nameHmac).digest().subarray(0, 16);
+	return join(persistRoot, "v3", "d1", uniqueKey, `${Buffer.concat([nameHmac, hmac]).toString("hex")}.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.
+*/
+function upgradeTrackingTable(db) {
+	db.transaction(() => {
+		if (!db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_migrations'").get()) return;
+		db.exec(`
+      CREATE TABLE IF NOT EXISTS _void_migrations (
+        name TEXT PRIMARY KEY,
+        applied_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+		db.exec(`INSERT OR IGNORE INTO _void_migrations (name, applied_at) SELECT name, applied_at FROM _migrations`);
+		db.exec(`DROP TABLE IF EXISTS _migrations`);
+	}).immediate();
+}
+/**
+* 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.
+*/
+async function runMigrations(migrationsDir, dbPath) {
+	const allMigrations = collectMigrations(migrationsDir);
+	if (allMigrations.length === 0) return [];
+	mkdirSync(dirname(dbPath), { recursive: true });
+	const db = await openSqliteDatabase(dbPath);
+	try {
+		upgradeTrackingTable(db);
+		db.exec(`
+      CREATE TABLE IF NOT EXISTS _void_migrations (
+        name TEXT PRIMARY KEY,
+        applied_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+		const appliedSet = new Set(db.prepare("SELECT name FROM _void_migrations").all().map((r) => r.name));
+		const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+		if (pending.length === 0) return [];
+		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);
+		return appliedNames;
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+export { getAppliedMigrations, getMiniflareDatabasePath, openSqliteDatabase, runMigrations };

package/dist/runner-pg-D0wWHYnr.mjs

@@ -0,0 +1,57 @@
+import { t as collectMigrations } from "./collect-CjeZgz5D.mjs";
+//#region src/migrations/runner-pg.ts
+/**
+* Apply unapplied SQL migrations via a connected PostgreSQL client.
+* Each migration runs in its own transaction (BEGIN/COMMIT).
+*/
+async function getPgAppliedMigrations(url) {
+	const { Client } = await import("pg");
+	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 [];
+	} finally {
+		await client.end();
+	}
+}
+async function applyPgMigrations(client, migrations) {
+	if (migrations.length === 0) return [];
+	await client.query(`CREATE TABLE IF NOT EXISTS _void_migrations (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)`);
+	const existing = await client.query("SELECT name FROM _void_migrations");
+	const appliedSet = new Set(existing.rows.map((row) => String(row.name)));
+	const pending = migrations.filter((m) => !appliedSet.has(m.name));
+	if (pending.length === 0) return [];
+	for (const m of pending) {
+		await client.query("BEGIN");
+		try {
+			await client.query(m.sql);
+			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;
+		}
+	}
+	return pending.map((m) => m.name);
+}
+/**
+* Apply unapplied SQL migrations to a PostgreSQL database.
+* Each migration runs in its own transaction (BEGIN/COMMIT).
+*/
+async function runPgMigrations(migrationsDir, url) {
+	const allMigrations = collectMigrations(migrationsDir);
+	if (allMigrations.length === 0) return [];
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString: url });
+	await client.connect();
+	try {
+		return await applyPgMigrations(client, allMigrations);
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { applyPgMigrations, getPgAppliedMigrations, runPgMigrations };