void 0.7.12 → 0.8.0

package/dist/plan-aD3wRDqF.mjs

@@ -0,0 +1,271 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+import { t as canonicalJson } from "./canonical-json-CEyQaVDa.mjs";
+import { createHash } from "node:crypto";
+//#region src/migrations/tokenize.ts
+function* tokenizeSql(sql) {
+	const sqlLength = sql.length;
+	let index = 0;
+	let runStart = 0;
+	const flushRun = (upTo) => {
+		if (upTo > runStart) return {
+			kind: "sql",
+			start: runStart,
+			end: upTo
+		};
+	};
+	while (index < sqlLength) {
+		const character = sql[index];
+		const next = index + 1 < sqlLength ? sql[index + 1] : "";
+		if (character === "-" && next === "-") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 2;
+			while (scanIndex < sqlLength && sql[scanIndex] !== "\n") scanIndex++;
+			yield {
+				kind: "line-comment",
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		if (character === "/" && next === "*") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 2;
+			while (scanIndex < sqlLength - 1 && !(sql[scanIndex] === "*" && sql[scanIndex + 1] === "/")) scanIndex++;
+			const end = Math.min(scanIndex + 2, sqlLength);
+			yield {
+				kind: "block-comment",
+				start: index,
+				end
+			};
+			index = end;
+			runStart = index;
+			continue;
+		}
+		if (character === "'") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 1;
+			while (scanIndex < sqlLength) {
+				if (sql[scanIndex] === "'" && sql[scanIndex + 1] === "'") {
+					scanIndex += 2;
+					continue;
+				}
+				if (sql[scanIndex] === "'") {
+					scanIndex++;
+					break;
+				}
+				scanIndex++;
+			}
+			yield {
+				kind: "string",
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		if (character === "\"" || character === "`" || character === "[") {
+			const run = flushRun(index);
+			if (run) yield run;
+			const close = character === "[" ? "]" : character;
+			let scanIndex = index + 1;
+			while (scanIndex < sqlLength) {
+				if (close !== "]" && sql[scanIndex] === close && sql[scanIndex + 1] === close) {
+					scanIndex += 2;
+					continue;
+				}
+				if (sql[scanIndex] === close) {
+					scanIndex++;
+					break;
+				}
+				scanIndex++;
+			}
+			yield {
+				kind: "ident-quote",
+				open: character,
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		index++;
+	}
+	const tail = flushRun(sqlLength);
+	if (tail) yield tail;
+}
+//#endregion
+//#region src/migrations/plan.ts
+var plan_exports = /* @__PURE__ */ __exportAll({
+	DESTRUCTIVE_PRAGMA: () => DESTRUCTIVE_PRAGMA,
+	MIGRATION_CLASSIFIER_VERSION: () => 1,
+	UNSPLIT_MULTI_STATEMENT_PRAGMA: () => UNSPLIT_MULTI_STATEMENT_PRAGMA,
+	buildMigrationPlanBundle: () => buildMigrationPlanBundle,
+	canonicalSql: () => canonicalSql,
+	classifyMigration: () => classifyMigration,
+	computeMigrationListHash: () => computeMigrationListHash,
+	hasStandalonePragma: () => hasStandalonePragma,
+	isSingleStatement: () => isSingleStatement,
+	sha256Hex: () => sha256Hex
+});
+const UNSPLIT_MULTI_STATEMENT_PRAGMA = "-- void:allow-unsplit-multi-statement";
+const DESTRUCTIVE_PRAGMA = "-- void:allow-destructive";
+function canonicalSql(sql) {
+	return (sql.charCodeAt(0) === 65279 ? sql.slice(1) : sql).replace(/\r\n?/g, "\n");
+}
+function sha256Hex(value) {
+	return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function getPlanHashInput(plan) {
+	const base = {
+		classifierVersion: plan.classifierVersion,
+		dialect: plan.dialect,
+		kind: plan.kind,
+		name: plan.name,
+		sqlHash: plan.sqlHash,
+		stability: plan.stability
+	};
+	if (plan.kind === "breakpoint-framed") base.statements = plan.statements;
+	return base;
+}
+function hashPlan(plan) {
+	return sha256Hex(canonicalJson(getPlanHashInput(plan)));
+}
+function computeMigrationListHash(plans) {
+	return sha256Hex(canonicalJson(plans.map((plan) => [
+		plan.name,
+		plan.sqlHash,
+		plan.planHash
+	])));
+}
+function isStandalonePragmaLine(line, pragma) {
+	return line.trim() === pragma;
+}
+function hasStandalonePragma(sql, pragma) {
+	return canonicalSql(sql).split("\n").some((line) => isStandalonePragmaLine(line, pragma));
+}
+function isBreakpointComment(text) {
+	return text.trim() === "--> statement-breakpoint";
+}
+function splitBreakpointFramedSql(sql) {
+	const normalized = canonicalSql(sql);
+	const statements = [];
+	let cursor = 0;
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind !== "line-comment") continue;
+		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) {
+			const statement = normalized.slice(cursor, segment.start).trim();
+			if (statement) statements.push(statement);
+			cursor = segment.end;
+		}
+	}
+	const statement = normalized.slice(cursor).trim();
+	if (statement) statements.push(statement);
+	return statements;
+}
+function getExecutableSql(sql) {
+	let out = "";
+	for (const segment of tokenizeSql(sql)) if (segment.kind === "sql") out += sql.slice(segment.start, segment.end);
+	else out += " ".repeat(segment.end - segment.start);
+	return out;
+}
+function hasStatementBreakpointOutsideLiterals(sql) {
+	const normalized = canonicalSql(sql);
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind !== "line-comment") continue;
+		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) return true;
+	}
+	return false;
+}
+function isSingleStatement(sql) {
+	const normalized = canonicalSql(sql);
+	let statements = 0;
+	let inStatement = false;
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind === "line-comment" || segment.kind === "block-comment") continue;
+		if (segment.kind === "string" || segment.kind === "ident-quote") {
+			inStatement = true;
+			continue;
+		}
+		for (let index = segment.start; index < segment.end; index++) {
+			const character = normalized[index];
+			if (character === ";") {
+				if (inStatement) {
+					statements++;
+					inStatement = false;
+				}
+				continue;
+			}
+			if (character !== " " && character !== "	" && character !== "\n" && character !== "\r") inStatement = true;
+		}
+	}
+	if (inStatement) statements++;
+	return statements === 1;
+}
+function includesTransactionControl(sql) {
+	return getExecutableSql(sql).match(/(?:^|;)\s*(BEGIN(?:\s+(?:DEFERRED|IMMEDIATE|EXCLUSIVE|TRANSACTION))?|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)\b/i)?.[1]?.toUpperCase() ?? null;
+}
+function classifyMigration(migration) {
+	const sql = canonicalSql(migration.sql);
+	const sqlHash = sha256Hex(sql);
+	const transactionControl = includesTransactionControl(sql);
+	if (transactionControl) throw new Error(`Migration ${migration.name} contains ${transactionControl}; Void owns the stable D1 transaction boundary.`);
+	let base;
+	const warnings = [];
+	if (hasStatementBreakpointOutsideLiterals(sql)) {
+		const statements = splitBreakpointFramedSql(sql);
+		if (statements.length === 0) throw new Error(`Migration ${migration.name} has statement breakpoints but no SQL statements.`);
+		base = {
+			classifierVersion: 1,
+			dialect: "sqlite",
+			kind: "breakpoint-framed",
+			name: migration.name,
+			sqlHash,
+			stability: "stable",
+			statements
+		};
+	} else if (isSingleStatement(sql)) base = {
+		classifierVersion: 1,
+		dialect: "sqlite",
+		kind: "single-statement",
+		name: migration.name,
+		sqlHash,
+		stability: "stable"
+	};
+	else {
+		const allowLegacy = hasStandalonePragma(sql, UNSPLIT_MULTI_STATEMENT_PRAGMA);
+		warnings.push(`Migration ${migration.name} contains multiple statements without Drizzle statement breakpoints; it will run through the legacy D1 path.`);
+		base = {
+			allowLegacy,
+			classifierVersion: 1,
+			dialect: "sqlite",
+			kind: "legacy-unsplit-multi-statement",
+			name: migration.name,
+			sqlHash,
+			stability: "legacy"
+		};
+	}
+	return {
+		...base,
+		planHash: hashPlan(base),
+		...warnings.length > 0 ? { warnings } : {}
+	};
+}
+function buildMigrationPlanBundle(migrations) {
+	const plans = migrations.map((migration) => classifyMigration(migration));
+	return {
+		classifierVersion: 1,
+		destructiveValidation: "passed",
+		migrationListHash: computeMigrationListHash(plans),
+		plans,
+		protocolVersion: 2
+	};
+}
+//#endregion
+export { tokenizeSql as a, plan_exports as i, buildMigrationPlanBundle as n, classifyMigration as r, DESTRUCTIVE_PRAGMA as t };

package/dist/{plugin-inference-BexV6LL3.mjs → plugin-inference-Ba1uGdIy.mjs}

@@ -1,5 +1,6 @@
-import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
-import { n as globSync } from "./dist-q8b2Mjgb.mjs";
+import { a as join, s as relative } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
+import { n as readProjectPaths } from "./project-paths-CCMrHYQm.mjs";
+import { n as globSync } from "./dist-DR9sIMbM.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { parseSync } from "vite";
 import { parse } from "es-module-lexer/js";
@@ -242,7 +243,7 @@ function inferBindingsFromSource(code, filename) {
 				case "void/auth":
 					result.needsAuth = true;
 					break;
-				case "void/queue":
+				case "void/queues":
 					result.needsQueues = true;
 					break;
 				case "void/ai":
@@ -352,10 +353,10 @@ function mergeBindings(bindings) {
 //#region src/ssr/entry.ts
 const SSR_SERVER_ENTRY_RELATIVE_PATHS = ["src/main.ssr.ts", "src/main.ssr.tsx"];
 const SSR_CLIENT_ENTRY_RELATIVE_PATHS = ["src/main.client.ts", "src/main.client.tsx"];
-function resolveSingleEntry(root, entries, label) {
-	const matches = entries.map((relativePath) => ({
-		relativePath,
-		absolutePath: join(root, relativePath)
+function resolveSingleEntry(root, entries, label, paths = readProjectPaths(root)) {
+	const matches = entries.map((entryName) => ({
+		relativePath: relative(root, join(paths.ssrDir, entryName)).replace(/\\/g, "/"),
+		absolutePath: join(paths.ssrDir, entryName)
 	})).filter((entry) => existsSync(entry.absolutePath));
 	if (matches.length === 0) return null;
 	if (matches.length > 1) {
@@ -364,11 +365,13 @@ function resolveSingleEntry(root, entries, label) {
 	}
 	return matches[0];
 }
-function getSsrServerEntryPath(root) {
-	return resolveSingleEntry(root, SSR_SERVER_ENTRY_RELATIVE_PATHS, "SSR")?.absolutePath ?? null;
+const SSR_SERVER_ENTRY_NAMES = ["main.ssr.ts", "main.ssr.tsx"];
+const SSR_CLIENT_ENTRY_NAMES = ["main.client.ts", "main.client.tsx"];
+function getSsrServerEntryPath(root, paths = readProjectPaths(root)) {
+	return resolveSingleEntry(root, SSR_SERVER_ENTRY_NAMES, "SSR", paths)?.absolutePath ?? null;
 }
-function hasSsrEntry(root) {
-	return getSsrServerEntryPath(root) !== null;
+function hasSsrEntry(root, paths = readProjectPaths(root)) {
+	return getSsrServerEntryPath(root, paths) !== null;
 }
 function validateServerRenderExport(entry) {
 	const { absolutePath, relativePath } = entry;
@@ -407,9 +410,9 @@ function validateServerRenderExport(entry) {
 * Validate SSR mode entry conventions.
 * Returns null when SSR mode is not used.
 */
-function validateSsrEntries(root) {
-	const server = resolveSingleEntry(root, SSR_SERVER_ENTRY_RELATIVE_PATHS, "SSR");
-	const client = resolveSingleEntry(root, SSR_CLIENT_ENTRY_RELATIVE_PATHS, "SSR client");
+function validateSsrEntries(root, paths = readProjectPaths(root)) {
+	const server = resolveSingleEntry(root, SSR_SERVER_ENTRY_NAMES, "SSR", paths);
+	const client = resolveSingleEntry(root, SSR_CLIENT_ENTRY_NAMES, "SSR client", paths);
 	if (!server && !client) return null;
 	if (server && !client) throw new Error(`ssr: Missing client entry. Add one of: ${SSR_CLIENT_ENTRY_RELATIVE_PATHS.join(", ")}.`);
 	if (!server && client) throw new Error(`ssr: Missing server entry. Add one of: ${SSR_SERVER_ENTRY_RELATIVE_PATHS.join(", ")}.`);
@@ -419,8 +422,8 @@ function validateSsrEntries(root) {
 		client
 	};
 }
-function validateSsrEntry(root) {
-	return validateSsrEntries(root)?.server.absolutePath ?? null;
+function validateSsrEntry(root, paths = readProjectPaths(root)) {
+	return validateSsrEntries(root, paths)?.server.absolutePath ?? null;
 }
 //#endregion
 //#region src/plugin-inference.ts
@@ -531,7 +534,8 @@ function inferProjectBindings(root, options, scanDirs) {
 		needsSandbox: false,
 		needsLive: false
 	};
-	const dirs = scanDirs ?? DEFAULT_SCAN_DIRS;
+	const paths = options?.paths ?? readProjectPaths(root);
+	const dirs = scanDirs ?? (paths.sourceDir ? [paths.sourceDir] : DEFAULT_SCAN_DIRS);
 	const allBindings = [];
 	for (const dir of dirs) {
 		const dirPath = join(root, dir);
@@ -549,14 +553,16 @@ function inferProjectBindings(root, options, scanDirs) {
 			allBindings.push(inferBindingsFromFile(file, code));
 		}
 	}
-	const ssrEntry = getSsrServerEntryPath(root);
+	const ssrEntry = getSsrServerEntryPath(root, paths);
 	if (ssrEntry) {
 		const code = readFileSync(ssrEntry, "utf-8");
 		const filename = ssrEntry.split("/").pop() ?? "main.ssr.ts";
 		allBindings.push(inferBindingsFromSource(code, filename));
 	}
-	if (!new Set(dirs).has("src")) {
-		const srcPath = join(root, "src");
+	const dirsSet = new Set(dirs);
+	const srcRel = paths.sourceDir ? paths.sourceDir : "src";
+	if (!dirsSet.has(srcRel)) {
+		const srcPath = paths.sourceDir ? paths.sourceRoot : join(root, "src");
 		let srcFiles;
 		try {
 			srcFiles = globSync(SOURCE_GLOB, {

package/dist/{prepare-BEkH89oX.mjs → prepare-BrAISonG.mjs}

@@ -1,15 +1,16 @@
-import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
-import { n as cliTitle } from "./output-D3g5otMC.mjs";
-import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-CvHtTM0q.mjs";
-import { c as R, g as ge, u as Se, y as ye } from "./dist-D2L3_KTK.mjs";
-import { c as getDatabaseDialect, f as readConfig } from "./config-CeRQg3Lz.mjs";
-import { t as scanRoutes } from "./scan-CkK1Hzpa.mjs";
-import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-BexV6LL3.mjs";
-import { i as generateDbDts, n as generateQueueTypes, t as generateRouteTypes } from "./route-types-qVL-v-CB.mjs";
-import { n as ensureProjectTsconfig } from "./project-tsconfig-Bfy55qvs.mjs";
-import { t as discoverSchema } from "./discover-CKGQpis8.mjs";
-import { n as generateEnvTypes, t as findEnvFile } from "./env-types-BSQghXbx.mjs";
-import { n as generateVoidAuthDrizzleSchema, t as generateVoidAuthDatabaseModule } from "./drizzle-Cx7cVwrE.mjs";
+import { a as join } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
+import { n as cliTitle } from "./output-DeiS4oEX.mjs";
+import { i as resolveProjectPaths } from "./project-paths-CCMrHYQm.mjs";
+import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-hhMYPVRT.mjs";
+import { c as R, g as ge, u as Se, y as ye } from "./dist-abzUneor.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BVEC0lti.mjs";
+import { r as scanRoutes } from "./scan-DzzHqtiT.mjs";
+import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-Ba1uGdIy.mjs";
+import { i as generateDbDts, n as generateQueueTypes, t as generateRouteTypes } from "./route-types-jxRfWuCb.mjs";
+import { n as ensureProjectTsconfig } from "./project-tsconfig-HAGjfY6w.mjs";
+import { t as discoverSchema } from "./discover-C8N1I4tK.mjs";
+import { r as generateEnvTypes, t as findEnvFile } from "./env-types-D6qI1ThV.mjs";
+import { n as generateVoidAuthDrizzleSchema, t as generateVoidAuthDatabaseModule } from "./drizzle-DmaANP4-.mjs";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { loadEnv } from "vite";
@@ -27,13 +28,19 @@ function removeGeneratedFile(outDir, fileName, removed) {
 }
 async function prepareProject(root) {
 	const config = readConfig(root);
+	const paths = resolveProjectPaths(root, config);
 	const outDir = join(root, ".void");
 	const written = [];
 	const removed = [];
 	mkdirSync(outDir, { recursive: true });
 	const detectedFramework = detectFramework(root);
-	const bindings = inferProjectBindings(root, config.inference?.bindings ? { bindings: config.inference.bindings } : void 0, config.inference?.scanDirs ?? (detectedFramework ? FRAMEWORK_SCAN_DIRS : void 0));
-	const authConfigPath = findVoidAuthConfig(root);
+	const inferenceOptions = config.inference?.bindings ? { bindings: config.inference.bindings } : void 0;
+	const scanDirs = config.inference?.scanDirs ?? (detectedFramework ? FRAMEWORK_SCAN_DIRS : void 0);
+	const bindings = inferProjectBindings(root, {
+		...inferenceOptions,
+		paths
+	}, scanDirs);
+	const authConfigPath = findVoidAuthConfig(root, paths);
 	const authEnabled = bindings.needsAuth || authConfigPath !== null || config.auth !== void 0;
 	const dialect = getDatabaseDialect(config);
 	const envFile = findEnvFile(root);
@@ -41,15 +48,18 @@ async function prepareProject(root) {
 		const { dts } = generateEnvTypes(envFile, outDir);
 		writeGeneratedFile(outDir, "env.d.ts", dts, written);
 	} else removeGeneratedFile(outDir, "env.d.ts", removed);
-	const scan = await scanRoutes(root, { output: config.output });
+	const scan = await scanRoutes(root, {
+		output: config.output,
+		paths
+	});
 	const hasRouteTypes = scan.routes.length > 0 || (scan.websockets?.length ?? 0) > 0 || scan.pages.pages.length > 0;
 	if (hasRouteTypes) {
-		const { dts } = generateRouteTypes(scan, join(root, "routes"), outDir, join(root, "pages"));
+		const { dts } = generateRouteTypes(scan, paths.routesDir, outDir, paths.pagesDir);
 		writeGeneratedFile(outDir, "routes.d.ts", dts, written);
 	} else removeGeneratedFile(outDir, "routes.d.ts", removed);
-	if (scan.queues.length > 0) writeGeneratedFile(outDir, "queues.d.ts", generateQueueTypes(scan.queues, join(root, "queues"), outDir), written);
+	if (scan.queues.length > 0) writeGeneratedFile(outDir, "queues.d.ts", generateQueueTypes(scan.queues, paths.queuesDir, outDir), written);
 	else removeGeneratedFile(outDir, "queues.d.ts", removed);
-	const schema = discoverSchema(root);
+	const schema = discoverSchema(root, paths);
 	const hasDbRuntime = schema != null || authEnabled;
 	if (hasDbRuntime) {
 		generateDbDts(outDir, schema, dialect);
@@ -77,7 +87,7 @@ async function prepareProject(root) {
 		removeGeneratedFile(outDir, "better-auth-schema.ts", removed);
 		removeGeneratedFile(outDir, "better-auth-db.ts", removed);
 	}
-	ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null);
+	ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null, { paths });
 	written.push(join(".void", "tsconfig.json"));
 	return {
 		written,

package/dist/{preset-CYQh93UF.mjs → preset-BRsCi8ZB.mjs}

@@ -1,5 +1,6 @@
-import { a as join, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
-import { s as hasSsrEntry } from "./plugin-inference-BexV6LL3.mjs";
+import { a as join, c as resolve } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
+import { n as readProjectPaths } from "./project-paths-CCMrHYQm.mjs";
+import { s as hasSsrEntry } from "./plugin-inference-Ba1uGdIy.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/cli/preset.ts
 /**
@@ -209,12 +210,13 @@ function detectViteBinary(root) {
 * Check whether the project has backend files that require a full worker deploy.
 */
 function hasBackendFiles(root) {
-	if (existsSync(join(root, "routes"))) return true;
-	if (existsSync(join(root, "pages"))) return true;
-	if (existsSync(join(root, "middleware"))) return true;
-	if (existsSync(join(root, "crons"))) return true;
-	if (existsSync(join(root, "queues"))) return true;
-	if (hasSsrEntry(root)) return true;
+	const paths = readProjectPaths(root);
+	if (existsSync(paths.routesDir)) return true;
+	if (existsSync(paths.pagesDir)) return true;
+	if (existsSync(paths.middlewareDir)) return true;
+	if (existsSync(paths.cronsDir)) return true;
+	if (existsSync(paths.queuesDir)) return true;
+	if (hasSsrEntry(root, paths)) return true;
 	return false;
 }
 //#endregion

package/dist/{project-DhB4A8_g.mjs → project-CH9pdo16.mjs}

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
-import { a as join, n as dirname } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 //#region src/cli/project.ts
 var project_exports = /* @__PURE__ */ __exportAll({

package/dist/{project-cmd-CeXO06hG.mjs → project-cmd-JQUzv3qF.mjs}

@@ -1,6 +1,6 @@
-import { i as dim, l as tablePrefix, n as cliTitle, s as import_picocolors } from "./output-D3g5otMC.mjs";
-import { c as getToken, n as PlatformClient, s as getSiteDomain } from "./client-C_DYiXeu.mjs";
-import { c as R, g as ge, y as ye } from "./dist-D2L3_KTK.mjs";
+import { i as dim, l as tablePrefix, n as cliTitle, s as import_picocolors } from "./output-DeiS4oEX.mjs";
+import { c as getToken, n as PlatformClient, s as getSiteDomain } from "./client-C-nH6yz3.mjs";
+import { c as R, g as ge, y as ye } from "./dist-abzUneor.mjs";
 //#region src/cli/projects.ts
 async function runProjectsCommand(root) {
 	console.log();
@@ -34,32 +34,32 @@ async function runProjectsCommand(root) {
 //#region src/cli/project-cmd.ts
 async function runProjectCommand(root, args) {
 	if (args.subcommand === "status") {
-		const { runListCommand } = await import("./list-9Bxa5Odn.mjs");
+		const { runListCommand } = await import("./list-ezL7hqDV.mjs");
 		return runListCommand(root, args.name || void 0);
 	}
 	if (args.subcommand === "link") {
-		const { runLink } = await import("./link-DdXqlUiJ.mjs");
+		const { runLink } = await import("./link-C5x1E-XZ.mjs");
 		return runLink(root, args.name || void 0);
 	}
 	if (args.subcommand === "list") return runProjectsCommand(root);
 	if (args.subcommand === "logs") {
-		const { runLogsCommand } = await import("./logs-DjqCpEER.mjs");
+		const { runLogsCommand } = await import("./logs-MnGILmLz.mjs");
 		return runLogsCommand(root, args.filter, args.range, args.deployment || void 0, args.level || void 0);
 	}
 	if (args.subcommand === "rollback") {
-		const { runRollbackCommand } = await import("./rollback-C8OSMxmq.mjs");
+		const { runRollbackCommand } = await import("./rollback-CoAAvC18.mjs");
 		return runRollbackCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "cancel") {
-		const { runCancelDeployCommand } = await import("./cancel-deploy-DOuSbPwX.mjs");
+		const { runCancelDeployCommand } = await import("./cancel-deploy-B4j31z7d.mjs");
 		return runCancelDeployCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "delete") {
-		const { runDeleteCommand } = await import("./delete-XyM_VD9o.mjs");
+		const { runDeleteCommand } = await import("./delete-eMGTHHB9.mjs");
 		return runDeleteCommand(root, args.name || void 0, { force: args.force });
 	}
 	if (args.subcommand === "purge-cache") {
-		const { runPurgeCacheCommand } = await import("./cache-DUDCNty6.mjs");
+		const { runPurgeCacheCommand } = await import("./cache-CGYC-2LW.mjs");
 		return runPurgeCacheCommand(root, args.projectSlug || void 0);
 	}
 }

package/dist/project-paths-CCMrHYQm.mjs

@@ -0,0 +1,100 @@
+import { a as join, i as isAbsolute, o as normalize, s as relative } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/project-paths.ts
+const SOURCE_CONVENTION_DIRECTORIES = [
+	"routes",
+	"pages",
+	"middleware",
+	"crons",
+	"queues",
+	"db"
+];
+const AUTH_CONFIG_FILES = [
+	"auth.ts",
+	"auth.mts",
+	"auth.js",
+	"auth.mjs",
+	"auth.cts",
+	"auth.cjs"
+];
+const ENV_CONFIG_FILES = [
+	"env.ts",
+	"env.mts",
+	"env.js",
+	"env.mjs"
+];
+const SOURCE_CONVENTIONS = new Set([
+	...SOURCE_CONVENTION_DIRECTORIES,
+	...AUTH_CONFIG_FILES,
+	...ENV_CONFIG_FILES
+]);
+function validateSourceDir(value, label = "sourceDir") {
+	if (value.trim() !== value || value.length === 0) throw new Error(`config: "${label}" in void.json must be a non-empty relative directory.`);
+	if (value === "." || value === ".." || value.startsWith("../") || value.includes("/../") || value.endsWith("/..") || isAbsolute(value)) throw new Error(`config: "${label}" path '${value}' in void.json must be a relative directory.`);
+	const normalized = normalize(value).replace(/\/+$/, "");
+	if (normalized === "" || normalized === ".") throw new Error(`config: "${label}" path '${value}' in void.json must be a relative directory.`);
+	return normalized;
+}
+function getSourceDir(config) {
+	return config?.sourceDir ? validateSourceDir(config.sourceDir) : "";
+}
+function resolveCandidate(root, sourceDir, candidate) {
+	return sourceDir ? join(root, sourceDir, candidate) : join(root, candidate);
+}
+function resolveProjectPaths(root, config) {
+	const sourceDir = getSourceDir(config);
+	const sourceRoot = sourceDir ? join(root, sourceDir) : root;
+	const sourceRelative = (path) => sourceDir ? `${sourceDir}/${path}` : path;
+	const envFileCandidates = sourceDir ? ENV_CONFIG_FILES.map((file) => join(sourceRoot, file)) : [...ENV_CONFIG_FILES.map((file) => join(root, file)), ...ENV_CONFIG_FILES.map((file) => join(root, "src", file))];
+	return {
+		root,
+		sourceDir,
+		sourceRoot,
+		routesDir: join(sourceRoot, "routes"),
+		middlewareDir: join(sourceRoot, "middleware"),
+		cronsDir: join(sourceRoot, "crons"),
+		queuesDir: join(sourceRoot, "queues"),
+		pagesDir: join(sourceRoot, "pages"),
+		dbDir: join(sourceRoot, "db"),
+		migrationsDir: join(sourceRoot, "db", "migrations"),
+		schemaFile: join(sourceRoot, "db", "schema.ts"),
+		schemaDir: join(sourceRoot, "db", "schema"),
+		srcDir: join(sourceRoot, "src"),
+		ssrDir: sourceDir ? sourceRoot : join(root, "src"),
+		sourceRelative,
+		authConfigCandidates: AUTH_CONFIG_FILES.map((file) => resolveCandidate(root, sourceDir, file)),
+		envFileCandidates
+	};
+}
+function readProjectPaths(root) {
+	return resolveProjectPaths(root, readSourceDirConfig(root));
+}
+function readSourceDirConfig(root) {
+	let raw;
+	try {
+		raw = readFileSync(join(root, "void.json"), "utf-8");
+	} catch {
+		return {};
+	}
+	let config;
+	try {
+		config = JSON.parse(raw);
+	} catch {
+		return {};
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return {};
+	const sourceDir = config.sourceDir;
+	return typeof sourceDir === "string" ? { sourceDir } : {};
+}
+function resolvePagesDir(root = process.cwd()) {
+	return readProjectPaths(root).pagesDir;
+}
+function assertNoRootSourceConventionConflicts(paths) {
+	if (!paths.sourceDir) return;
+	const conflicts = Array.from(SOURCE_CONVENTIONS).filter((convention) => existsSync(join(paths.root, convention)) && existsSync(join(paths.sourceRoot, convention)));
+	if (conflicts.length === 0) return;
+	const relSource = relative(paths.root, paths.sourceRoot);
+	throw new Error(`sourceDir: void.json sets "sourceDir": "${paths.sourceDir}", but convention path(s) also exist at the project root: ${conflicts.join(", ")}. Move them under "${relSource}" or remove the root copy.`);
+}
+//#endregion
+export { validateSourceDir as a, resolveProjectPaths as i, readProjectPaths as n, resolvePagesDir as r, assertNoRootSourceConventionConflicts as t };

package/dist/{project-slug-KRvHQEQI.mjs → project-slug-De4UjtD9.mjs}

@@ -5,7 +5,6 @@ function validateProjectSlug(value) {
 	const slug = (value ?? "").trim();
 	if (slug.length === 0) return "Project slug is required.";
 	if (!(slug.length === 1 ? /^[a-z0-9]$/.test(slug) : /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(slug))) return "Slug must be lowercase alphanumeric with dashes.";
-	if (slug.length <= 5) return "Slugs of 5 characters or fewer require a paid plan. Use at least 6 characters.";
 }
 //#endregion
 export { validateProjectSlug as n, project_slug_exports as t };