void 0.1.6 → 0.7.0

package/dist/prepare-BAtWufvm.mjs

@@ -0,0 +1,99 @@
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as cliTitle } from "./output-BwlcIYSR.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-Dayj3gCK.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BIa9HwVX.mjs";
+import { t as scanRoutes } from "./scan-C6HMEIdW.mjs";
+import { n as detectFramework, r as inferProjectBindings, t as FRAMEWORK_SCAN_DIRS } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { i as generateDbDts, n as generateQueueTypes, t as generateRouteTypes } from "./route-types-DReF1gUY.mjs";
+import { n as ensureProjectTsconfig } from "./project-tsconfig-DfkESbDL.mjs";
+import { t as discoverSchema } from "./discover-B7FkXBLB.mjs";
+import { n as generateEnvTypes, t as findEnvFile } from "./env-types-DknSA4SO.mjs";
+import { n as generateVoidAuthDrizzleSchema, t as generateVoidAuthDatabaseModule } from "./drizzle-NnudE_UN.mjs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { loadEnv } from "vite";
+//#region src/codegen/prepare.ts
+function writeGeneratedFile(outDir, fileName, content, written) {
+	mkdirSync(outDir, { recursive: true });
+	writeFileSync(join(outDir, fileName), content);
+	written.push(join(".void", fileName));
+}
+function removeGeneratedFile(outDir, fileName, removed) {
+	const filePath = join(outDir, fileName);
+	if (!existsSync(filePath)) return;
+	rmSync(filePath, { force: true });
+	removed.push(join(".void", fileName));
+}
+async function prepareProject(root) {
+	const config = readConfig(root);
+	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 authEnabled = bindings.needsAuth || authConfigPath !== null || config.auth !== void 0;
+	const dialect = getDatabaseDialect(config);
+	const envFile = findEnvFile(root);
+	if (envFile) {
+		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 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"));
+		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);
+	else removeGeneratedFile(outDir, "queues.d.ts", removed);
+	const schema = discoverSchema(root);
+	const hasDbRuntime = schema != null || authEnabled;
+	if (hasDbRuntime) {
+		generateDbDts(outDir, schema, dialect);
+		written.push(join(".void", "db.d.ts"));
+	} else removeGeneratedFile(outDir, "db.d.ts", removed);
+	if (authEnabled) {
+		const authRuntime = {
+			dialect,
+			providers: config.auth?.providers ?? null,
+			userConfig: await loadVoidAuthConfig(authConfigPath)
+		};
+		const env = loadEnv("development", root, "");
+		const schemaPath = join(outDir, "better-auth-schema.ts");
+		const databasePath = join(outDir, "better-auth-db.ts");
+		const drizzleAdapterPath = fileURLToPath(import.meta.resolve("better-auth/adapters/drizzle"));
+		writeFileSync(schemaPath, generateVoidAuthDrizzleSchema(authRuntime, env));
+		writeFileSync(databasePath, generateVoidAuthDatabaseModule({
+			dialect,
+			schemaImportPath: schemaPath,
+			drizzleAdapterPath
+		}));
+		written.push(join(".void", "better-auth-schema.ts"));
+		written.push(join(".void", "better-auth-db.ts"));
+	} else {
+		removeGeneratedFile(outDir, "better-auth-schema.ts", removed);
+		removeGeneratedFile(outDir, "better-auth-db.ts", removed);
+	}
+	ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null);
+	written.push(join(".void", "tsconfig.json"));
+	return {
+		written,
+		removed
+	};
+}
+//#endregion
+//#region src/cli/prepare.ts
+async function runPrepareCommand(root, _args) {
+	console.log();
+	ge(cliTitle("prepare"));
+	const result = await prepareProject(root);
+	if (result.written.length > 0) Se(result.written.join("\n"), "Wrote");
+	if (result.removed.length > 0) Se(result.removed.join("\n"), "Removed stale files");
+	if (result.written.length === 0 && result.removed.length === 0) R.info("No generated files changed.");
+	ye("Project codegen is ready.");
+}
+//#endregion
+export { runPrepareCommand };

package/dist/preset-D4I73kT4.mjs

@@ -0,0 +1,221 @@
+import { a as join, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { o as hasSsrEntry } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/cli/preset.ts
+/**
+* Known output conventions for SSGs.
+* Keyed by the SSG name — detection iterates in insertion order.
+*/
+const SSG_PRESETS = {
+	vitepress: {
+		dep: "vitepress",
+		buildCommand: "vitepress build",
+		outputDir: ".vitepress/dist",
+		appType: "static",
+		resolve(root) {
+			if (existsSync(join(root, "docs/.vitepress"))) return {
+				buildCommand: "vitepress build docs",
+				outputDir: "docs/.vitepress/dist"
+			};
+		}
+	},
+	docusaurus: {
+		dep: "@docusaurus/core",
+		buildCommand: "docusaurus build",
+		outputDir: "build",
+		appType: "static"
+	}
+};
+/**
+* Known output conventions for meta-frameworks.
+* Keyed by the framework name from `detectFramework()`.
+*
+* Class A frameworks (tanstack-start, react-router, vinext) use the project's
+* Vite-compatible build command (`vite build` or `vp build`) and have their
+* output structure determined by the framework's Vite plugin.
+*
+* Class B/C frameworks (sveltekit, nuxt, analog, astro) use their own build CLI
+* and have framework-specific output conventions.
+*/
+const FRAMEWORK_PRESETS = {
+	"tanstack-start": {
+		buildCommand: "vite build",
+		workerDir: "dist/server",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	"react-router": {
+		buildCommand: "vite build",
+		workerDir: "build/server",
+		workerMain: "index.js",
+		assetsDir: "build/client"
+	},
+	"vinext-app": {
+		buildCommand: "vite build",
+		workerDir: "dist/rsc",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	"vinext-pages": {
+		buildCommand: "vite build",
+		workerDir: "dist/ssr",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	sveltekit: {
+		buildCommand: "vite build",
+		workerDir: ".svelte-kit/cloudflare",
+		workerMain: "_worker.js",
+		assetsDir: ".svelte-kit/cloudflare",
+		hashedAssetsPrefix: "_app/immutable",
+		bundle: true
+	},
+	nuxt: {
+		buildCommand: "nuxt build",
+		workerDir: ".output/server",
+		workerMain: "index.mjs",
+		assetsDir: ".output/public",
+		hashedAssetsPrefix: "_nuxt"
+	},
+	analog: {
+		buildCommand: "vite build",
+		workerDir: "dist/analog/server",
+		workerMain: "index.mjs",
+		assetsDir: "dist/analog/public",
+		hashedAssetsPrefix: "assets"
+	},
+	astro: {
+		buildCommand: "astro build",
+		workerDir: "dist/server",
+		workerMain: "entry.mjs",
+		assetsDir: "dist/client",
+		hashedAssetsPrefix: "_astro"
+	}
+};
+/**
+* Resolve a project-local command, rewriting `vite` to `vp` when the project
+* depends on Vite+ and preferring node_modules/.bin when available.
+*/
+function resolveProjectCommand(root, command) {
+	const [bin, ...args] = command.trim().split(/\s+/);
+	const resolvedBin = localBin(root, resolveCommandBin(root, bin));
+	return args.length > 0 ? `${resolvedBin} ${args.join(" ")}` : resolvedBin;
+}
+/**
+* Format a user-facing command string, rewriting `vite` to `vp` when the
+* project depends on Vite+ without expanding to an absolute local bin path.
+*/
+function formatProjectCommand(root, command) {
+	const [bin, ...args] = command.trim().split(/\s+/);
+	const formattedBin = resolveCommandBin(root, bin);
+	return args.length > 0 ? `${formattedBin} ${args.join(" ")}` : formattedBin;
+}
+/**
+* Detect a static deploy preset based on the project root.
+* Returns null when the project requires a full worker deploy.
+*/
+function detectPreset(root, options) {
+	if (options?.dir) return {
+		buildCommand: null,
+		outputDir: resolve(root, options.dir),
+		appType: options.spa ? "spa" : "static"
+	};
+	const pkg = readPackageJson(root);
+	if (pkg) {
+		const allDeps = getAllDeps(pkg);
+		for (const preset of Object.values(SSG_PRESETS)) if (preset.dep in allDeps) {
+			const overrides = preset.resolve?.(root);
+			const cmd = overrides?.buildCommand ?? preset.buildCommand;
+			const out = overrides?.outputDir ?? preset.outputDir;
+			return {
+				buildCommand: resolveProjectCommand(root, cmd),
+				outputDir: resolve(root, out),
+				appType: preset.appType
+			};
+		}
+	}
+	if (hasBackendFiles(root)) return null;
+	if (pkg && hasViteLike(pkg)) return {
+		buildCommand: resolveProjectScriptCommand(root, "build") ?? resolveProjectCommand(root, "vite build"),
+		outputDir: resolve(root, "dist"),
+		appType: "spa"
+	};
+	if (existsSync(join(root, "dist/index.html"))) return {
+		buildCommand: null,
+		outputDir: resolve(root, "dist"),
+		appType: options?.spa ? "spa" : "static"
+	};
+	if (existsSync(join(root, "index.html"))) return {
+		buildCommand: null,
+		outputDir: root,
+		appType: options?.spa ? "spa" : "static"
+	};
+	return null;
+}
+/**
+* Resolve a local node_modules/.bin executable path.
+* Falls back to bare command name if the bin doesn't exist locally.
+*/
+function localBin(root, name) {
+	const bin = join(root, "node_modules", ".bin", name);
+	return existsSync(bin) ? bin : name;
+}
+function resolveCommandBin(root, name) {
+	if (name === "vite") return detectViteBinary(root);
+	return name;
+}
+function readPackageJson(root) {
+	try {
+		return JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function getAllDeps(pkg) {
+	return {
+		...pkg.dependencies ?? {},
+		...pkg.devDependencies ?? {}
+	};
+}
+function detectPackageManager(root) {
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) return "bun";
+	return "npm";
+}
+function resolveProjectScriptCommand(root, scriptName) {
+	const script = readPackageJson(root)?.scripts;
+	if (!script || typeof script !== "object" || Array.isArray(script)) return null;
+	if (typeof script[scriptName] !== "string") return null;
+	switch (detectPackageManager(root)) {
+		case "pnpm": return `pnpm ${scriptName}`;
+		case "yarn": return `yarn ${scriptName}`;
+		case "bun": return `bun run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+function hasViteLike(pkg) {
+	const deps = getAllDeps(pkg);
+	return "vite" in deps || "vite-plus" in deps;
+}
+function detectViteBinary(root) {
+	const pkg = readPackageJson(root);
+	if (pkg) {
+		if ("vite-plus" in getAllDeps(pkg)) return "vp";
+	}
+	return "vite";
+}
+/**
+* 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;
+	return false;
+}
+//#endregion
+export { resolveProjectCommand as i, detectPreset as n, formatProjectCommand as r, FRAMEWORK_PRESETS as t };

package/dist/project-TqORyHn8.mjs

@@ -0,0 +1,72 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+//#region src/cli/project.ts
+var project_exports = /* @__PURE__ */ __exportAll({
+	isVoidInternalStaging: () => isVoidInternalStaging,
+	readProjectConfig: () => readProjectConfig,
+	removeProjectConfig: () => removeProjectConfig,
+	writeProjectConfig: () => writeProjectConfig
+});
+const PROJECT_FILE = ".void/project.json";
+function readProjectConfigFile(root) {
+	const filePath = join(root, PROJECT_FILE);
+	try {
+		const raw = readFileSync(filePath, "utf-8");
+		const config = JSON.parse(raw);
+		if (typeof config !== "object" || config === null || Array.isArray(config)) return null;
+		return config;
+	} catch {
+		return null;
+	}
+}
+/**
+* Read the project config from the project root.
+* Returns null if no project.json exists.
+* A file containing only internal metadata is not treated as a linked project.
+*/
+function readProjectConfig(root) {
+	const config = readProjectConfigFile(root);
+	if (!config || typeof config.projectId !== "string" || typeof config.slug !== "string") return null;
+	const result = {
+		projectId: config.projectId,
+		slug: config.slug
+	};
+	if (config.voidInternalStaging === true) result.voidInternalStaging = true;
+	return result;
+}
+/**
+* Internal-only platform developers' staging switch.
+* This intentionally lives with the project link state, not public void.json.
+*/
+function isVoidInternalStaging(root) {
+	return readProjectConfigFile(root)?.voidInternalStaging === true;
+}
+/**
+* Write the project config to the project root.
+*/
+function writeProjectConfig(root, config) {
+	const filePath = join(root, PROJECT_FILE);
+	const existing = readProjectConfigFile(root);
+	const next = {
+		projectId: config.projectId,
+		slug: config.slug
+	};
+	if (config.voidInternalStaging === true || existing?.voidInternalStaging === true) next.voidInternalStaging = true;
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+}
+/**
+* Remove the project config file. Returns true if removed, false if it didn't exist.
+*/
+function removeProjectConfig(root) {
+	const filePath = join(root, PROJECT_FILE);
+	try {
+		rmSync(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { writeProjectConfig as a, removeProjectConfig as i, project_exports as n, readProjectConfig as r, isVoidInternalStaging as t };

package/dist/project-cmd-B7lQp3F3.mjs

@@ -0,0 +1,67 @@
+import { i as dim, l as tablePrefix, n as cliTitle, s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { c as R, g as ge, y as ye } from "./dist-Dayj3gCK.mjs";
+import { n as PlatformClient, o as getSiteDomain, s as getToken } from "./client-snXOjrp1.mjs";
+//#region src/cli/projects.ts
+async function runProjectsCommand(root) {
+	console.log();
+	ge(cliTitle("project list"));
+	const token = getToken(root);
+	if (!token) {
+		R.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const projects = await new PlatformClient(token, { root }).listProjects();
+	if (projects.length === 0) {
+		ye("No projects found.");
+		return;
+	}
+	const rows = projects.map((p) => ({
+		slug: p.slug,
+		appType: p.type ?? "worker",
+		url: p.custom_domain ? `https://${p.custom_domain}` : `https://${p.slug}.${getSiteDomain(root)}`
+	}));
+	const slugWidth = Math.max(4, ...rows.map((r) => r.slug.length));
+	const typeWidth = Math.max(4, ...rows.map((r) => r.appType.length));
+	const prefix = tablePrefix();
+	const header = `${prefix}${dim(`${"slug".padEnd(slugWidth)}  ${"type".padEnd(typeWidth)}  url`)}`;
+	const lines = rows.map((row) => `${prefix}${import_picocolors.default.green(row.slug)}${"".padEnd(slugWidth - row.slug.length)}  ${row.appType.padEnd(typeWidth)}  ${row.url}`);
+	console.log(prefix);
+	console.log(header);
+	for (const line of lines) console.log(line);
+	ye(`${projects.length} project(s)`);
+}
+//#endregion
+//#region src/cli/project-cmd.ts
+async function runProjectCommand(root, args) {
+	if (args.subcommand === "status") {
+		const { runListCommand } = await import("./list-Bfel-QLc.mjs");
+		return runListCommand(root, args.name || void 0);
+	}
+	if (args.subcommand === "link") {
+		const { runLink } = await import("./link-p2R6NbgN.mjs");
+		return runLink(root, args.name || void 0);
+	}
+	if (args.subcommand === "list") return runProjectsCommand(root);
+	if (args.subcommand === "logs") {
+		const { runLogsCommand } = await import("./logs-DmkrRvx6.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-gyC59l7U.mjs");
+		return runRollbackCommand(root, args.deployId || void 0);
+	}
+	if (args.subcommand === "cancel") {
+		const { runCancelDeployCommand } = await import("./cancel-deploy-BOBTqqh0.mjs");
+		return runCancelDeployCommand(root, args.deployId || void 0);
+	}
+	if (args.subcommand === "delete") {
+		const { runDeleteCommand } = await import("./delete-DAP6yDc7.mjs");
+		return runDeleteCommand(root, args.name || void 0, { force: args.force });
+	}
+	if (args.subcommand === "purge-cache") {
+		const { runPurgeCacheCommand } = await import("./cache-W82I8ihI.mjs");
+		return runPurgeCacheCommand(root, args.projectSlug || void 0);
+	}
+}
+//#endregion
+export { runProjectCommand };

package/dist/project-slug-CKam8lF9.mjs

@@ -0,0 +1,11 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+//#region src/cli/project-slug.ts
+var project_slug_exports = /* @__PURE__ */ __exportAll({ validateProjectSlug: () => validateProjectSlug });
+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 };

package/dist/project-tsconfig-DfkESbDL.mjs

@@ -0,0 +1,63 @@
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+//#region src/codegen/project-tsconfig.ts
+/**
+* Build the generated .void/tsconfig.json contents. Lists the generated
+* declaration files so TypeScript discovers them via the `files` field
+* (which is inherited by `extends`, unlike `include`).
+*
+* @param hasRouteTypes - When true, include routes.d.ts. When omitted,
+*   auto-detect by checking for a routes/ directory.
+* @param hasDrizzle - When true, configure `@schema` paths for the user's
+*   Drizzle schema.
+*/
+function createProjectTsconfig(root, hasRouteTypes, hasDb, hasSchema, options = {}) {
+	const outDir = join(root, ".void");
+	const includeRoutes = hasRouteTypes ?? existsSync(join(root, "routes"));
+	const includeQueues = existsSync(join(root, "queues"));
+	const includeMd = existsSync(join(outDir, "md.d.ts"));
+	const includeEnv = existsSync(join(outDir, "env.d.ts"));
+	const tsconfig = { files: [
+		...includeRoutes ? ["routes.d.ts"] : [],
+		...hasDb ? ["db.d.ts"] : [],
+		...includeQueues ? ["queues.d.ts"] : [],
+		...includeMd ? ["md.d.ts"] : [],
+		...includeEnv ? ["env.d.ts"] : []
+	] };
+	if (hasDb) {
+		const paths = {};
+		if (options.redirectDbModule !== false) paths["void/db"] = ["./db.d.ts"];
+		if (hasSchema) {
+			paths["@schema"] = [existsSync(join(root, "db", "schema")) && !existsSync(join(root, "db", "schema.ts")) ? "../db/schema/index.ts" : "../db/schema.ts"];
+			paths["@schema/*"] = ["../db/schema/*"];
+		}
+		tsconfig.compilerOptions = { paths };
+	}
+	if (includeRoutes) {
+		const compilerOptions = tsconfig.compilerOptions ??= {};
+		const paths = compilerOptions.paths ??= {};
+		paths["void/routes"] = ["./routes.d.ts"];
+	}
+	if (includeQueues) {
+		const compilerOptions = tsconfig.compilerOptions ??= {};
+		const paths = compilerOptions.paths ??= {};
+		paths["void/queues"] = ["./queues.d.ts"];
+	}
+	if (includeMd) {
+		const compilerOptions = tsconfig.compilerOptions ??= {};
+		const paths = compilerOptions.paths ??= {};
+		paths["@void/md/pages"] = ["./md.d.ts"];
+	}
+	return tsconfig;
+}
+/**
+* Ensure .void/tsconfig.json exists so the user's root tsconfig can extend it.
+*/
+function ensureProjectTsconfig(root, hasRouteTypes, hasDb, hasSchema, options = {}) {
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	const tsconfig = createProjectTsconfig(root, hasRouteTypes, hasDb, hasSchema, options);
+	writeFileSync(join(outDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+}
+//#endregion
+export { ensureProjectTsconfig as n, createProjectTsconfig as t };

package/dist/protocol-BWzXs2A2.d.mts

@@ -0,0 +1,34 @@
+import { n as HeadDescriptor, t as HeadConfig } from "./head-P-egrtFE.mjs";
+import { n as CloudContext, t as CloudBindings } from "./handler-B0ds0OHJ.mjs";
+
+//#region src/pages/protocol.d.ts
+/** Escape characters that are unsafe inside inline <script> tags to prevent XSS. */
+declare function safeJsonStringify(value: unknown): string;
+interface PageObject {
+  component: string;
+  props: Record<string, unknown>;
+  shared: Record<string, unknown>;
+  url: string;
+  errors: Record<string, string> | null;
+  head?: HeadDescriptor;
+  deferred?: Array<string>;
+  deferredKeys?: Record<string, string>;
+}
+type PageRenderResult = string | ReadableStream<Uint8Array>;
+type PageHandler = ((c: CloudContext) => unknown | Promise<unknown>) | undefined;
+type PageHeadHandler = ((c: CloudContext, props: Record<string, unknown>) => HeadDescriptor | undefined) | undefined;
+type AssetTags = {
+  css: string;
+  preloads: string;
+  body: string;
+};
+type RenderPage = (pageObj: PageObject, assetTags: AssetTags) => Promise<PageRenderResult>;
+type GetAssetTags = (req: Request, env: CloudBindings, componentId: string) => Promise<AssetTags>;
+/** Flatten withValidator's { issues: [{ slot, issues: [{ message, path }] }] } into { field: message } */
+declare function flattenValidationErrors(body: unknown): Record<string, string>;
+/** Handle GET page request — run handler, return page object or SSR HTML */
+declare function handlePageGet(handler: PageHandler, headFn: PageHeadHandler, c: CloudContext, componentId: string, renderFn: RenderPage, getAssetTags: GetAssetTags, configHead?: HeadConfig, island?: boolean): Promise<Response>;
+/** Handle POST/PUT/DELETE page request — run mutation, then re-run GET or redirect */
+declare function handlePageMutation(mutationHandler: PageHandler, getHandler: PageHandler, headFn: PageHeadHandler, c: CloudContext, componentId: string, renderFn: RenderPage, getAssetTags: GetAssetTags, configHead?: HeadConfig, island?: boolean): Promise<Response>;
+//#endregion
+export { handlePageMutation as a, handlePageGet as i, PageRenderResult as n, safeJsonStringify as o, flattenValidationErrors as r, PageObject as t };

package/dist/providers-B3aMxWzP.mjs

@@ -0,0 +1,67 @@
+//#region src/auth/providers.ts
+const VOID_SOCIAL_AUTH_PROVIDERS = [
+	"apple",
+	"atlassian",
+	"cognito",
+	"discord",
+	"dropbox",
+	"facebook",
+	"figma",
+	"github",
+	"gitlab",
+	"google",
+	"huggingface",
+	"kakao",
+	"kick",
+	"line",
+	"linear",
+	"linkedin",
+	"microsoft",
+	"naver",
+	"notion",
+	"paybin",
+	"paypal",
+	"polar",
+	"railway",
+	"reddit",
+	"roblox",
+	"salesforce",
+	"slack",
+	"spotify",
+	"tiktok",
+	"twitch",
+	"twitter",
+	"vercel",
+	"vk",
+	"zoom"
+];
+const VOID_EMAIL_AUTH_PROVIDER = "email";
+const VOID_AUTH_PROVIDERS = [VOID_EMAIL_AUTH_PROVIDER, ...VOID_SOCIAL_AUTH_PROVIDERS];
+const VOID_SOCIAL_AUTH_PROVIDER_SET = new Set(VOID_SOCIAL_AUTH_PROVIDERS);
+const VOID_AUTH_PROVIDER_SET = new Set(VOID_AUTH_PROVIDERS);
+function isVoidSocialAuthProvider(value) {
+	return VOID_SOCIAL_AUTH_PROVIDER_SET.has(value);
+}
+function isVoidAuthProvider(value) {
+	return VOID_AUTH_PROVIDER_SET.has(value);
+}
+function getVoidAuthProviderEnvNames(provider) {
+	const normalized = provider.toUpperCase().replaceAll("-", "_");
+	const envNames = {
+		clientId: `AUTH_${normalized}_CLIENT_ID`,
+		clientSecret: `AUTH_${normalized}_CLIENT_SECRET`
+	};
+	if (provider === "github") return {
+		...envNames,
+		legacyClientId: "GITHUB_OAUTH_ID",
+		legacyClientSecret: "GITHUB_OAUTH_SECRET"
+	};
+	if (provider === "google") return {
+		...envNames,
+		legacyClientId: "GOOGLE_OAUTH_ID",
+		legacyClientSecret: "GOOGLE_OAUTH_SECRET"
+	};
+	return envNames;
+}
+//#endregion
+export { isVoidSocialAuthProvider as a, isVoidAuthProvider as i, VOID_EMAIL_AUTH_PROVIDER as n, getVoidAuthProviderEnvNames as r, VOID_AUTH_PROVIDERS as t };

package/dist/resolve-project-Br5BR03U.mjs

@@ -0,0 +1,29 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { readFileSync } from "node:fs";
+//#region src/cli/resolve-project.ts
+var resolve_project_exports = /* @__PURE__ */ __exportAll({
+	getRequestedProjectSlug: () => getRequestedProjectSlug,
+	inferDefaultSlug: () => inferDefaultSlug,
+	resolveProjectBySlug: () => resolveProjectBySlug
+});
+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;
+}
+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 { resolve_project_exports as i, inferDefaultSlug as n, resolveProjectBySlug as r, getRequestedProjectSlug as t };