void 0.1.6 → 0.7.0

package/dist/gen-U0Ktr4Zd.mjs

@@ -0,0 +1,761 @@
+import { a as join, n as dirname, o as relative } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as cliTitle } from "./output-BwlcIYSR.mjs";
+import { _ as me, c as R, g as ge, i as Ee, x as q, y as ye } from "./dist-Dayj3gCK.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BIa9HwVX.mjs";
+import { n as ensureProjectTsconfig } from "./project-tsconfig-DfkESbDL.mjs";
+import { n as writeDrizzleConfig } from "./config-BzM9Dy7T.mjs";
+import { r as readJournal, t as collectMigrations } from "./collect-CjeZgz5D.mjs";
+import { n as listDrizzleArtifacts, t as assertJournalCoherence } from "./validate-CaMavMxu.mjs";
+import { t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-BFqMV_bl.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+//#region src/cli/gen.ts
+const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+async function runGenCommand(root, args) {
+	console.log();
+	ge(cliTitle("gen"));
+	if (args.subcommand === "model") await runModel(root, args.name, args.columns);
+	else if (args.subcommand === "migration") runMigration(root, args.name);
+	else if (args.subcommand === "route") runRoute(root, args.path, args.methods);
+	else if (args.subcommand === "middleware") runMiddleware(root, args.name);
+	else if (args.subcommand === "cron") runCron(root, args.name);
+	else if (args.subcommand === "queue") runQueue(root, args.name);
+	else runSsr(root, args.framework);
+}
+function writeIfNotExists(filePath, content) {
+	if (existsSync(filePath)) {
+		R.warn(`Skipped (already exists): ${filePath}`);
+		return false;
+	}
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content);
+	R.success(`Created ${filePath}`);
+	return true;
+}
+function formatTimestamp(date) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return String(date.getUTCFullYear()) + pad(date.getUTCMonth() + 1) + pad(date.getUTCDate()) + pad(date.getUTCHours()) + pad(date.getUTCMinutes()) + pad(date.getUTCSeconds());
+}
+function getMigrationTimestamp(migrationsDir) {
+	const now = /* @__PURE__ */ new Date();
+	let ts = formatTimestamp(now);
+	while (readdirSync(migrationsDir).some((f) => f.startsWith(ts + "_"))) {
+		now.setSeconds(now.getSeconds() + 1);
+		ts = formatTimestamp(now);
+	}
+	return ts;
+}
+function getNextMiddlewareNumber(middlewareDir) {
+	if (!existsSync(middlewareDir)) return "01";
+	const files = readdirSync(middlewareDir);
+	let max = 0;
+	for (const file of files) {
+		const match = file.match(/^(\d+)\./);
+		if (match) max = Math.max(max, Number(match[1]));
+	}
+	return String(max + 1).padStart(2, "0");
+}
+function drizzleColumnDef(col) {
+	const { name, type } = col;
+	switch (type) {
+		case "string":
+		case "text": return `  ${name}: text("${name}").notNull(),`;
+		case "integer": return `  ${name}: integer("${name}").notNull(),`;
+		case "boolean": return `  ${name}: integer("${name}", { mode: "boolean" }).notNull().default(false),`;
+		case "real": return `  ${name}: real("${name}").notNull(),`;
+		default: return `  ${name}: text("${name}"),`;
+	}
+}
+function drizzleImportsForColumns(columns) {
+	const types = new Set(["text", "integer"]);
+	for (const col of columns) switch (col.type) {
+		case "string":
+		case "text":
+			types.add("text");
+			break;
+		case "integer":
+			types.add("integer");
+			break;
+		case "boolean":
+			types.add("integer");
+			break;
+		case "real":
+			types.add("real");
+			break;
+		default: types.add("text");
+	}
+	return [...types].sort();
+}
+function drizzleColumnDefPg(col) {
+	const { name, type } = col;
+	switch (type) {
+		case "string":
+		case "text": return `  ${name}: text("${name}").notNull(),`;
+		case "integer": return `  ${name}: integer("${name}").notNull(),`;
+		case "boolean": return `  ${name}: boolean("${name}").notNull().default(false),`;
+		case "real": return `  ${name}: doublePrecision("${name}").notNull(),`;
+		default: return `  ${name}: text("${name}"),`;
+	}
+}
+function drizzleImportsForColumnsPg(columns) {
+	const types = new Set([
+		"text",
+		"serial",
+		"timestamp"
+	]);
+	for (const col of columns) switch (col.type) {
+		case "string":
+		case "text":
+			types.add("text");
+			break;
+		case "integer":
+			types.add("integer");
+			break;
+		case "boolean":
+			types.add("boolean");
+			break;
+		case "real":
+			types.add("doublePrecision");
+			break;
+		default: types.add("text");
+	}
+	return [...types].sort();
+}
+function detectValidator(root) {
+	const pkgPath = join(root, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	if ("valibot" in allDeps) return "valibot";
+	if ("zod" in allDeps) return "zod";
+	if ("arktype" in allDeps) return "arktype";
+	return null;
+}
+async function resolveValidator(root) {
+	const detected = detectValidator(root);
+	if (detected) {
+		R.info(`Detected validator: ${detected}`);
+		return detected;
+	}
+	const choice = await Ee({
+		message: "No validation library detected. Which would you like to use?",
+		options: [
+			{
+				value: "valibot",
+				label: "Valibot"
+			},
+			{
+				value: "zod",
+				label: "Zod"
+			},
+			{
+				value: "arktype",
+				label: "ArkType"
+			},
+			{
+				value: "none",
+				label: "No validation"
+			}
+		]
+	});
+	if (q(choice)) {
+		me("Cancelled.");
+		process.exit(0);
+	}
+	if (choice !== "none") R.warn(`Remember to install ${choice}: npm install ${choice}`);
+	return choice;
+}
+function validatorTypeFor(validator, col) {
+	if (validator === "valibot") return valibotType(col);
+	if (validator === "zod") return zodType(col);
+	return arktypeType(col);
+}
+function valibotType(col) {
+	let base;
+	switch (col.type) {
+		case "string":
+		case "text":
+		case "datetime":
+			base = "v.string()";
+			break;
+		case "integer":
+		case "real":
+			base = "v.number()";
+			break;
+		case "boolean":
+			base = "v.boolean()";
+			break;
+		case "blob":
+			base = "v.instance(Blob)";
+			break;
+		default: base = "v.string()";
+	}
+	return col.nullable ? `v.optional(${base})` : base;
+}
+function zodType(col) {
+	let base;
+	switch (col.type) {
+		case "string":
+		case "text":
+		case "datetime":
+			base = "z.string()";
+			break;
+		case "integer":
+		case "real":
+			base = "z.number()";
+			break;
+		case "boolean":
+			base = "z.boolean()";
+			break;
+		case "blob":
+			base = "z.instanceof(Blob)";
+			break;
+		default: base = "z.string()";
+	}
+	return col.nullable ? `${base}.optional()` : base;
+}
+function arktypeType(col) {
+	let base;
+	switch (col.type) {
+		case "string":
+		case "text":
+		case "datetime":
+			base = "string";
+			break;
+		case "integer":
+		case "real":
+			base = "number";
+			break;
+		case "boolean":
+			base = "boolean";
+			break;
+		case "blob":
+			base = "instanceof Blob";
+			break;
+		default: base = "string";
+	}
+	return col.nullable ? `${base} | undefined` : base;
+}
+function getImportLine(validator) {
+	switch (validator) {
+		case "valibot": return "import * as v from \"valibot\";";
+		case "zod": return "import { z } from \"zod\";";
+		case "arktype": return "import { type } from \"arktype\";";
+		case "none": return null;
+	}
+}
+function getBodySchema(validator, columns) {
+	if (validator === "arktype") return `type({\n${columns.map((c) => `    ${c.name}: "${arktypeType(c)}",`).join("\n")}\n  })`;
+	const fields = columns.map((c) => `    ${c.name}: ${validatorTypeFor(validator, c)},`).join("\n");
+	return `${validator === "valibot" ? "v" : "z"}.object({\n${fields}\n  })`;
+}
+function getParamsSchema(validator) {
+	switch (validator) {
+		case "valibot": return "v.object({ id: v.string() })";
+		case "zod": return "z.object({ id: z.string() })";
+		case "arktype": return "type({ id: \"string\" })";
+		case "none": return "";
+	}
+}
+function generateIndexRoute(name, columns, validator) {
+	const imports = [
+		getImportLine(validator),
+		"import { defineHandler } from \"void\";",
+		"import { db } from \"void/db\";",
+		`import { ${name} } from "@schema";`
+	].filter(Boolean).join("\n");
+	const insertFields = columns.map((c) => `${c.name}: body.${c.name}`).join(", ");
+	if (columns.length === 0 || validator === "none") {
+		if (columns.length > 0) return `import { defineHandler } from "void";
+import { db } from "void/db";
+import { ${name} } from "@schema";
+
+export const GET = defineHandler(async () => {
+  return db.select().from(${name});
+});
+
+export const POST = defineHandler(async (c) => {
+  const body = await c.req.json();
+  await db.insert(${name}).values({ ${insertFields} });
+  return { created: true };
+});
+`;
+		return `import { defineHandler } from "void";
+import { db } from "void/db";
+import { ${name} } from "@schema";
+
+export const GET = defineHandler(async () => {
+  return db.select().from(${name});
+});
+
+export const POST = defineHandler(async (c) => {
+  const body = await c.req.json();
+  await db.insert(${name}).values(body);
+  return { created: true };
+});
+`;
+	}
+	return `${imports}
+
+export const GET = defineHandler(async () => {
+  return db.select().from(${name});
+});
+
+export const POST = defineHandler.withValidator({
+  body: ${getBodySchema(validator, columns)},
+})(async (c, { body }) => {
+  await db.insert(${name}).values({ ${insertFields} });
+  return { created: true };
+});
+`;
+}
+function generateIdRoute(name, validator) {
+	if (validator === "none") return `import { defineHandler } from "void";
+import { db, eq } from "void/db";
+import { ${name} } from "@schema";
+
+export const GET = defineHandler(async (c) => {
+  const id = c.req.param("id");
+  const [row] = await db.select().from(${name}).where(eq(${name}.id, Number(id)));
+
+  if (!row) {
+    return new Response("Not found", { status: 404 });
+  }
+  return row;
+});
+`;
+	return `${getImportLine(validator)}
+import { defineHandler } from "void";
+import { db, eq } from "void/db";
+import { ${name} } from "@schema";
+
+export const GET = defineHandler.withValidator({
+  params: ${getParamsSchema(validator)},
+})(async (c, { params }) => {
+  const [row] = await db.select().from(${name}).where(eq(${name}.id, Number(params.id)));
+
+  if (!row) {
+    return new Response("Not found", { status: 404 });
+  }
+  return row;
+});
+`;
+}
+async function runModel(root, name, columns) {
+	const validator = await resolveValidator(root);
+	const dialect = getDatabaseDialect(readConfig(root));
+	const schemaDir = join(root, "db", "schema");
+	const barrelPath = join(root, "db", "schema.ts");
+	const modelPath = join(schemaDir, `${name}.ts`);
+	let content;
+	if (dialect === "postgresql") {
+		const colDefs = columns.map((col) => drizzleColumnDefPg(col));
+		const columnImports = drizzleImportsForColumnsPg(columns);
+		const allCols = [
+			`  id: serial("id").primaryKey(),`,
+			...colDefs,
+			`  createdAt: timestamp("created_at").notNull().defaultNow(),`,
+			`  updatedAt: timestamp("updated_at").notNull().defaultNow(),`
+		];
+		content = [
+			`import { pgTable, ${columnImports.join(", ")} } from "void/schema-pg";`,
+			"",
+			`export const ${name} = pgTable("${name}", {`,
+			...allCols,
+			"});",
+			""
+		].join("\n");
+	} else {
+		const colDefs = columns.map((col) => drizzleColumnDef(col));
+		const columnImports = drizzleImportsForColumns(columns);
+		const allCols = [
+			`  id: integer("id").primaryKey({ autoIncrement: true }),`,
+			...colDefs,
+			"  createdAt: text(\"created_at\").notNull().default(sql`(datetime('now'))`),",
+			"  updatedAt: text(\"updated_at\").notNull().default(sql`(datetime('now'))`),"
+		];
+		content = [
+			`import { sqliteTable, ${columnImports.join(", ")} } from "void/schema-d1";`,
+			`import { sql } from "void/db";`,
+			"",
+			`export const ${name} = sqliteTable("${name}", {`,
+			...allCols,
+			"});",
+			""
+		].join("\n");
+	}
+	mkdirSync(schemaDir, { recursive: true });
+	writeIfNotExists(modelPath, content);
+	const exportLine = `export * from "./schema/${name}";`;
+	if (existsSync(barrelPath)) {
+		const existing = readFileSync(barrelPath, "utf-8");
+		if (!existing.includes(exportLine)) writeFileSync(barrelPath, existing.trimEnd() + "\n" + exportLine + "\n");
+	} else writeFileSync(barrelPath, exportLine + "\n");
+	ensureProjectTsconfig(root, void 0, true, true);
+	R.success(`Created ${relative(root, modelPath)}`);
+	R.success(`Updated ${relative(root, barrelPath)}`);
+	writeIfNotExists(join(root, "routes", "api", name, "index.ts"), generateIndexRoute(name, columns, validator));
+	writeIfNotExists(join(root, "routes", "api", name, "[id].ts"), generateIdRoute(name, validator));
+	ye("Model scaffolding complete. Run `void db push` to apply.");
+}
+function runMigration(root, name) {
+	const migrationsDir = join(root, "db", "migrations");
+	mkdirSync(migrationsDir, { recursive: true });
+	const currentMigrations = collectMigrations(migrationsDir);
+	try {
+		assertJournalCoherence(migrationsDir, currentMigrations);
+	} catch (err) {
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	if (existsSync(join(migrationsDir, "migrations.js"))) {
+		R.error("Your project uses Drizzle's bundled migration format (db/migrations/migrations.js).\n`void gen migration` cannot add custom hand-written migrations to a bundled project\nbecause the bundle must be regenerated by drizzle-kit.\n\nEither run `drizzle-kit generate` to regenerate the bundle, or migrate away from\nbundled mode by deleting db/migrations/migrations.js and re-running `void db generate`.");
+		process.exit(1);
+	}
+	const existingJournal = readJournal(migrationsDir);
+	if (existingJournal !== void 0 && existingJournal.entries.length > 0) {
+		const lastEntry = existingJournal.entries[existingJournal.entries.length - 1];
+		const metaDir = join(migrationsDir, "meta");
+		const lastSnapshotPrefix = lastEntry.tag.split("_")[0];
+		if (!existsSync(join(metaDir, `${lastSnapshotPrefix}_snapshot.json`))) {
+			R.error(`db/migrations/meta/_journal.json's last entry is \`${lastEntry.tag}\` but the matching snapshot \`${lastSnapshotPrefix}_snapshot.json\` is missing under meta/.`);
+			R.error("Restore the snapshot from version control, or regenerate migrations with `void db generate` before running `void gen migration`.");
+			process.exit(1);
+		}
+		const journalPath = join(metaDir, "_journal.json");
+		const originalJournalBytes = existsSync(journalPath) ? readFileSync(journalPath) : null;
+		const snapshotsBefore = new Set(readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json")));
+		const sqlFilesBefore = new Set(readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")));
+		let journalDialect;
+		if (existingJournal.dialect === "sqlite") journalDialect = "sqlite";
+		else if (existingJournal.dialect === "postgresql") journalDialect = "postgresql";
+		else {
+			R.error(`db/migrations/meta/_journal.json has an unsupported dialect: \`${existingJournal.dialect}\`.`);
+			R.error("void supports `sqlite` and `postgresql` only. Restore the journal from version control, or drop db/migrations/ and regenerate from scratch.");
+			process.exit(1);
+		}
+		const configDialect = getDatabaseDialect(readConfig(root));
+		if (configDialect !== journalDialect) {
+			R.error(`db/migrations/meta/_journal.json was generated for ${journalDialect}, but void.json is configured for ${configDialect}.`);
+			R.error(`Generating a new custom migration now would append a snapshot in the wrong dialect. Revert void.json's \`database\` field to ${journalDialect}, or drop db/migrations/ and regenerate from scratch.`);
+			process.exit(1);
+		}
+		const configPath = journalDialect === "postgresql" ? writeDrizzleConfig(root, "postgresql://dummy", "postgresql") : writeDrizzleConfig(root, ":memory:");
+		const childEnv = buildDrizzleKitSpawnEnv(root);
+		const result = spawnSync(process.execPath, [
+			drizzleKitBin,
+			"generate",
+			"--config",
+			configPath,
+			"--custom",
+			"--name",
+			name
+		], {
+			cwd: root,
+			stdio: "pipe",
+			encoding: "utf-8",
+			shell: process.platform === "win32",
+			env: childEnv
+		});
+		if (result.error || result.status !== 0) {
+			if (originalJournalBytes !== null) try {
+				writeFileSync(journalPath, originalJournalBytes);
+			} catch {}
+			if (existsSync(metaDir)) {
+				for (const f of readdirSync(metaDir)) if (f.endsWith("_snapshot.json") && !snapshotsBefore.has(f)) try {
+					unlinkSync(join(metaDir, f));
+				} catch {}
+			}
+			for (const f of readdirSync(migrationsDir)) if (f.endsWith(".sql") && !sqlFilesBefore.has(f)) try {
+				unlinkSync(join(migrationsDir, f));
+			} catch {}
+			const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+			R.error([
+				`Failed to run \`drizzle-kit generate --custom --name ${name}\`.`,
+				...detail ? [detail] : [],
+				"",
+				"This is usually a schema-compilation error. Fix any TypeScript errors in db/schema.ts and try again."
+			].join("\n"));
+			process.exit(1);
+		}
+		const newSqlFile = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).find((f) => !sqlFilesBefore.has(f));
+		if (newSqlFile) R.success(`Created db/migrations/${newSqlFile}`);
+		ye("Migration created and journal updated.");
+		return;
+	}
+	if (existingJournal !== void 0 && existingJournal.entries.length === 0) {
+		if (listDrizzleArtifacts(migrationsDir).length > 0) {
+			R.error("db/migrations/meta/_journal.json has empty entries but stale drizzle-kit snapshots are on disk.");
+			R.error("Restore the journal entries from version control (or run `void db generate`), or delete the stale drizzle artifacts and rerun.");
+			process.exit(1);
+		}
+	}
+	writeIfNotExists(join(migrationsDir, `${`${getMigrationTimestamp(migrationsDir)}_${name}`}.sql`), `-- ${name}\n`);
+	ye("Migration created.");
+}
+function runRoute(root, routePath, methods) {
+	writeIfNotExists(join(root, "routes", routePath + ".ts"), `import { defineHandler } from "void";
+
+${methods.map((m) => {
+		const upper = m.toUpperCase();
+		return `export const ${upper} = defineHandler(async () => {
+  return { message: "${upper} ${routePath}" };
+});`;
+	}).join("\n\n")}
+`);
+	ye("Route created.");
+}
+function runMiddleware(root, name) {
+	const middlewareDir = join(root, "middleware");
+	mkdirSync(middlewareDir, { recursive: true });
+	writeIfNotExists(join(middlewareDir, `${getNextMiddlewareNumber(middlewareDir)}.${name}.ts`), `import { defineMiddleware } from "void";
+
+export default defineMiddleware(async (c, next) => {
+  // TODO: implement ${name} middleware
+  await next();
+});
+`);
+	ye("Middleware created.");
+}
+function runCron(root, name) {
+	writeIfNotExists(join(root, "crons", name + ".ts"), `import { defineScheduled } from "void";
+
+export const cron = "* * * * *";
+
+export default defineScheduled(async (controller, env) => {
+  // TODO: implement ${name}
+});
+`);
+	ye("Cron job created.");
+}
+function runQueue(root, name) {
+	writeIfNotExists(join(root, "queues", name + ".ts"), `import { defineQueue } from "void";
+
+interface Message {}
+
+// export const maxBatchSize = 10;
+// export const maxBatchTimeout = 5;
+
+export default defineQueue<Message>(async (batch, env) => {
+  for (const message of batch.messages) {
+    // TODO: process message
+  }
+});
+`);
+	ye("Queue consumer created.");
+}
+function runSsr(root, framework) {
+	if (!framework) framework = detectFramework(root);
+	if (framework === "react") writeReactSsr(root);
+	else if (framework === "vue") writeVueSsr(root);
+	else if (framework === "svelte") writeSvelteSsr(root);
+	else writeSolidSsr(root);
+	ye("SSR scaffolding complete.");
+}
+function detectFramework(root) {
+	const pkgPath = join(root, "package.json");
+	if (!existsSync(pkgPath)) {
+		R.error("No package.json found. Use --react, --vue, --svelte, or --solid to specify a framework.");
+		process.exit(1);
+	}
+	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	if ("react" in allDeps) return "react";
+	if ("vue" in allDeps) return "vue";
+	if ("svelte" in allDeps) return "svelte";
+	if ("solid-js" in allDeps) return "solid";
+	R.error("Could not detect framework from package.json. Use --react, --vue, --svelte, or --solid.");
+	process.exit(1);
+}
+function writeReactSsr(root) {
+	writeIfNotExists(join(root, "src/main.ssr.tsx"), `import { renderToString } from "react-dom/server";
+import { defineRender } from "void";
+import App from "./App";
+
+export default defineRender(async (c, assetTags) => {
+  const appHtml = renderToString(<App />);
+  const html = \`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>App</title>
+    \${assetTags.css}\${assetTags.preloads}
+  </head>
+  <body>
+    <div id="root">\${appHtml}</div>
+    \${assetTags.body}
+  </body>
+</html>\`;
+
+  return new Response(html, {
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+});
+`);
+	writeIfNotExists(join(root, "src/main.client.tsx"), `import { hydrateRoot } from "react-dom/client";
+import App from "./App";
+
+hydrateRoot(document.getElementById("root")!, <App />);
+`);
+	writeIfNotExists(join(root, "src/App.tsx"), `import { useState } from "react";
+
+export default function App() {
+  const [count, setCount] = useState(0);
+
+  return (
+    <main>
+      <h1>Hello Void</h1>
+      <button type="button" onClick={() => setCount((c) => c + 1)}>
+        Count: {count}
+      </button>
+    </main>
+  );
+}
+`);
+}
+function writeVueSsr(root) {
+	writeIfNotExists(join(root, "src/main.ssr.ts"), `import { createSSRApp } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { defineRender } from "void";
+import App from "./App.vue";
+
+export default defineRender(async (c, assetTags) => {
+  const app = createSSRApp(App);
+  const appHtml = await renderToString(app);
+  const html = \`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>App</title>
+    \${assetTags.css}\${assetTags.preloads}
+  </head>
+  <body>
+    <div id="app">\${appHtml}</div>
+    \${assetTags.body}
+  </body>
+</html>\`;
+
+  return new Response(html, {
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+});
+`);
+	writeIfNotExists(join(root, "src/main.client.ts"), `import { createSSRApp } from "vue";
+import App from "./App.vue";
+
+const app = createSSRApp(App);
+app.mount("#app");
+`);
+	writeIfNotExists(join(root, "src/App.vue"), `<script setup lang="ts">
+import { ref } from "vue";
+
+const count = ref(0);
+<\/script>
+
+<template>
+  <main>
+    <h1>Hello Void</h1>
+    <button type="button" @click="count++">Count: {{ count }}</button>
+  </main>
+</template>
+`);
+}
+function writeSvelteSsr(root) {
+	writeIfNotExists(join(root, "src/main.ssr.ts"), `import { render } from "svelte/server";
+import { defineRender } from "void";
+import App from "./App.svelte";
+
+export default defineRender(async (c, assetTags) => {
+  const { html: appHtml } = render(App);
+  const html = \`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>App</title>
+    \${assetTags.css}\${assetTags.preloads}
+  </head>
+  <body>
+    <div id="app">\${appHtml}</div>
+    \${assetTags.body}
+  </body>
+</html>\`;
+
+  return new Response(html, {
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+});
+`);
+	writeIfNotExists(join(root, "src/main.client.ts"), `import { hydrate } from "svelte";
+import App from "./App.svelte";
+
+hydrate(App, { target: document.getElementById("app")! });
+`);
+	writeIfNotExists(join(root, "src/App.svelte"), `<script>
+  let count = $state(0);
+<\/script>
+
+<main>
+  <h1>Hello Void</h1>
+  <button type="button" onclick={() => count++}>Count: {count}</button>
+</main>
+`);
+}
+function writeSolidSsr(root) {
+	writeIfNotExists(join(root, "src/main.ssr.tsx"), `import { renderToString } from "solid-js/web";
+import { defineRender } from "void";
+import App from "./App";
+
+export default defineRender(async (c, assetTags) => {
+  const appHtml = renderToString(() => <App />);
+  const html = \`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>App</title>
+    \${assetTags.css}\${assetTags.preloads}
+  </head>
+  <body>
+    <div id="app">\${appHtml}</div>
+    \${assetTags.body}
+  </body>
+</html>\`;
+
+  return new Response(html, {
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+});
+`);
+	writeIfNotExists(join(root, "src/main.client.tsx"), `import { hydrate } from "solid-js/web";
+import App from "./App";
+
+hydrate(() => <App />, document.getElementById("app")!);
+`);
+	writeIfNotExists(join(root, "src/App.tsx"), `import { createSignal } from "solid-js";
+
+export default function App() {
+  const [count, setCount] = createSignal(0);
+
+  return (
+    <main>
+      <h1>Hello Void</h1>
+      <button type="button" onClick={() => setCount((c) => c + 1)}>
+        Count: {count()}
+      </button>
+    </main>
+  );
+}
+`);
+}
+//#endregion
+export { formatTimestamp, runGenCommand };