create-taserjs 0.1.11 → 0.2.0

package/dist/cli-9fkoNOJg.js

@@ -0,0 +1,1237 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
+import { execSync } from "node:child_process";
+import { getUserAgent, resolveCommand } from "package-manager-detector";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+//#region src/core/types.ts
+const RUNTIMES = [
+	"node",
+	"bun",
+	"deno"
+];
+const DEPLOY_TARGETS = [
+	"none",
+	"node-server",
+	"node-cluster",
+	"bun",
+	"deno-server",
+	"deno-deploy",
+	"cloudflare-module",
+	"vercel",
+	"aws-lambda",
+	"netlify"
+];
+const DB_ODMS = [
+	"drizzle",
+	"prisma",
+	"kysely"
+];
+const DB_DRIVERS = [
+	"postgres",
+	"sqlite",
+	"mysql"
+];
+const DEFAULT_DB_DRIVER = "sqlite";
+const LOGGERS = ["pino", "winston"];
+const VALIDATORS = [
+	"zod",
+	"arktype",
+	"valibot"
+];
+//#endregion
+//#region src/addons/drizzle/index.ts
+function schemaSource$1(driver) {
+	switch (driver) {
+		case "postgres": return `import { pgTable, serial, text } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  email: text("email").notNull(),
+});
+`;
+		case "mysql": return `import { mysqlTable, serial, varchar } from "drizzle-orm/mysql-core";
+
+export const users = mysqlTable("users", {
+  id: serial("id").primaryKey(),
+  email: varchar("email", { length: 255 }).notNull(),
+});
+`;
+		default: return `import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
+
+export const users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  email: text("email").notNull(),
+});
+`;
+	}
+}
+function dbIndexSource$2(driver) {
+	switch (driver) {
+		case "postgres": return `import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import * as schema from "./schema.js";
+
+export function createDb() {
+  const pool = new pg.Pool({
+    connectionString: process.env.DATABASE_URL,
+  });
+  return drizzle(pool, { schema });
+}
+`;
+		case "mysql": return `import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import * as schema from "./schema.js";
+
+export function createDb() {
+  const pool = mysql.createPool(process.env.DATABASE_URL ?? "");
+  return drizzle(pool, { schema, mode: "default" });
+}
+`;
+		default: return `import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
+
+export function createDb() {
+  const filePath = (process.env.DATABASE_URL ?? "file:./local.db").replace(/^file:/, "");
+  const client = new Database(filePath);
+  return drizzle(client, { schema });
+}
+`;
+	}
+}
+function drizzleConfigSource(driver) {
+	return `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/db/schema.ts",
+  out: "./drizzle",
+  dialect: "${driver === "postgres" ? "postgresql" : driver === "mysql" ? "mysql" : "sqlite"}",
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? "",
+  },
+});
+`;
+}
+function envExample$2(driver) {
+	switch (driver) {
+		case "postgres": return "DATABASE_URL=postgresql://user:password@localhost:5432/mydb\n";
+		case "mysql": return "DATABASE_URL=mysql://user:password@localhost:3306/mydb\n";
+		default: return "DATABASE_URL=file:./local.db\n";
+	}
+}
+function driverPackages$2(driver) {
+	switch (driver) {
+		case "postgres": return ["pg"];
+		case "mysql": return ["mysql2"];
+		default: return ["better-sqlite3"];
+	}
+}
+function driverDevPackages$2(driver) {
+	switch (driver) {
+		case "postgres": return ["@types/pg"];
+		case "sqlite": return ["@types/better-sqlite3"];
+		default: return [];
+	}
+}
+const drizzleAddon = {
+	id: "drizzle",
+	category: "database",
+	dependencies(ctx) {
+		return ["drizzle-orm", ...driverPackages$2(ctx.driver ?? "sqlite")];
+	},
+	devDependencies(ctx) {
+		return ["drizzle-kit", ...driverDevPackages$2(ctx.driver ?? "sqlite")];
+	},
+	scripts() {
+		return {
+			"db:generate": "drizzle-kit generate",
+			"db:push": "drizzle-kit push"
+		};
+	},
+	bootBinding() {
+		return {
+			key: "db",
+			importPath: "./db/index.js",
+			factoryName: "createDb"
+		};
+	},
+	async apply(ctx, write) {
+		const driver = ctx.driver ?? "sqlite";
+		await write("src/db/schema.ts", schemaSource$1(driver));
+		await write("src/db/index.ts", dbIndexSource$2(driver));
+		await write("drizzle.config.ts", drizzleConfigSource(driver));
+		await write(".env.example", envExample$2(driver));
+	}
+};
+//#endregion
+//#region src/addons/kysely/index.ts
+function schemaTypesSource() {
+	return `export interface UserTable {
+  id: number;
+  email: string;
+}
+
+export interface DB {
+  users: UserTable;
+}
+`;
+}
+function dbIndexSource$1(driver) {
+	switch (driver) {
+		case "postgres": return `import { Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+import type { DB } from "./schema.js";
+
+export function createDb() {
+  const pool = new pg.Pool({
+    connectionString: process.env.DATABASE_URL,
+  });
+  return new Kysely<DB>({
+    dialect: new PostgresDialect({ pool }),
+  });
+}
+`;
+		case "mysql": return `import { Kysely, MysqlDialect } from "kysely";
+import { createPool } from "mysql2";
+import type { DB } from "./schema.js";
+
+export function createDb() {
+  const pool = createPool(process.env.DATABASE_URL ?? "");
+  return new Kysely<DB>({
+    dialect: new MysqlDialect({ pool }),
+  });
+}
+`;
+		default: return `import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+import type { DB } from "./schema.js";
+
+export function createDb() {
+  const filePath = (process.env.DATABASE_URL ?? "file:./local.db").replace(/^file:/, "");
+  const database = new Database(filePath);
+  return new Kysely<DB>({
+    dialect: new SqliteDialect({ database }),
+  });
+}
+`;
+	}
+}
+function driverPackages$1(driver) {
+	switch (driver) {
+		case "postgres": return ["pg"];
+		case "mysql": return ["mysql2"];
+		default: return ["better-sqlite3"];
+	}
+}
+function driverDevPackages$1(driver) {
+	switch (driver) {
+		case "postgres": return ["@types/pg"];
+		case "sqlite": return ["@types/better-sqlite3"];
+		default: return [];
+	}
+}
+function envExample$1(driver) {
+	switch (driver) {
+		case "postgres": return "DATABASE_URL=postgresql://user:password@localhost:5432/mydb\n";
+		case "mysql": return "DATABASE_URL=mysql://user:password@localhost:3306/mydb\n";
+		default: return "DATABASE_URL=file:./local.db\n";
+	}
+}
+const kyselyAddon = {
+	id: "kysely",
+	category: "database",
+	dependencies(ctx) {
+		return ["kysely", ...driverPackages$1(ctx.driver ?? "sqlite")];
+	},
+	devDependencies(ctx) {
+		return driverDevPackages$1(ctx.driver ?? "sqlite");
+	},
+	bootBinding() {
+		return {
+			key: "db",
+			importPath: "./db/index.js",
+			factoryName: "createDb"
+		};
+	},
+	async apply(ctx, write) {
+		const driver = ctx.driver ?? "sqlite";
+		await write("src/db/schema.ts", schemaTypesSource());
+		await write("src/db/index.ts", dbIndexSource$1(driver));
+		await write(".env.example", envExample$1(driver));
+	}
+};
+//#endregion
+//#region src/addons/pino/index.ts
+const pinoAddon = {
+	id: "pino",
+	category: "logger",
+	dependencies() {
+		return ["pino"];
+	},
+	devDependencies() {
+		return [];
+	},
+	bootBinding() {
+		return {
+			key: "logger",
+			importPath: "./logger.js",
+			factoryName: "createLogger"
+		};
+	},
+	async apply(_ctx, write) {
+		await write("src/logger.ts", `import pino from "pino";
+
+export function createLogger() {
+  return pino({ level: process.env.LOG_LEVEL ?? "info" });
+}
+`);
+	}
+};
+//#endregion
+//#region src/addons/prisma/index.ts
+const PRISMA_VERSION = "^7.10.0";
+function prismaPackage(name) {
+	return `${name}@${PRISMA_VERSION}`;
+}
+function prismaProvider(driver) {
+	switch (driver) {
+		case "postgres": return "postgresql";
+		case "mysql": return "mysql";
+		default: return "sqlite";
+	}
+}
+function envExample(driver) {
+	switch (driver) {
+		case "postgres": return "DATABASE_URL=postgresql://user:password@localhost:5432/mydb\n";
+		case "mysql": return "DATABASE_URL=mysql://user:password@localhost:3306/mydb\n";
+		default: return "DATABASE_URL=file:./local.db\n";
+	}
+}
+function driverPackages(driver) {
+	switch (driver) {
+		case "postgres": return [prismaPackage("@prisma/adapter-pg"), "pg"];
+		case "mysql": return [prismaPackage("@prisma/adapter-mariadb"), "mariadb"];
+		default: return [prismaPackage("@prisma/adapter-better-sqlite3"), "better-sqlite3"];
+	}
+}
+function driverDevPackages(driver) {
+	switch (driver) {
+		case "postgres": return ["@types/pg"];
+		case "sqlite": return ["@types/better-sqlite3"];
+		default: return [];
+	}
+}
+function dbIndexSource(driver) {
+	switch (driver) {
+		case "postgres": return `import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "./prisma/client.js";
+
+export function createDb() {
+  const adapter = new PrismaPg({
+    connectionString: process.env.DATABASE_URL,
+  });
+  return new PrismaClient({ adapter });
+}
+`;
+		case "mysql": return `import { PrismaMariaDb } from "@prisma/adapter-mariadb";
+import { PrismaClient } from "./prisma/client.js";
+
+export function createDb() {
+  const adapter = new PrismaMariaDb(process.env.DATABASE_URL ?? "mariadb://root:@localhost:3306/mydb");
+  return new PrismaClient({ adapter });
+}
+`;
+		default: return `import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
+import { PrismaClient } from "./prisma/client.js";
+
+export function createDb() {
+  const adapter = new PrismaBetterSqlite3({
+    url: process.env.DATABASE_URL ?? "file:./local.db",
+  });
+  return new PrismaClient({ adapter });
+}
+`;
+	}
+}
+function prismaConfigSource() {
+	return `import "dotenv/config";
+import { defineConfig, env } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  datasource: {
+    url: env("DATABASE_URL"),
+  },
+});
+`;
+}
+function schemaSource(driver) {
+	return `generator client {
+  provider = "prisma-client"
+  output   = "../src/db/prisma"
+}
+
+datasource db {
+  provider = "${prismaProvider(driver)}"
+}
+
+model User {
+  id    Int    @id @default(autoincrement())
+  email String
+}
+`;
+}
+const prismaAddon = {
+	id: "prisma",
+	category: "database",
+	dependencies(ctx) {
+		const driver = ctx.driver ?? "sqlite";
+		return [prismaPackage("@prisma/client"), ...driverPackages(driver)];
+	},
+	devDependencies(ctx) {
+		const driver = ctx.driver ?? "sqlite";
+		return [prismaPackage("prisma"), ...driverDevPackages(driver)];
+	},
+	scripts() {
+		return {
+			"db:generate": "prisma generate",
+			"db:push": "prisma db push"
+		};
+	},
+	bootBinding() {
+		return {
+			key: "db",
+			importPath: "./db/index.js",
+			factoryName: "createDb"
+		};
+	},
+	async apply(ctx, write) {
+		const driver = ctx.driver ?? "sqlite";
+		await write("prisma.config.ts", prismaConfigSource());
+		await write("prisma/schema.prisma", schemaSource(driver));
+		await write("src/db/index.ts", dbIndexSource(driver));
+		await write(".env.example", envExample(driver));
+	}
+};
+//#endregion
+//#region src/addons/validators.ts
+const IMPORT_LINES = {
+	zod: `import { z } from "zod";`,
+	arktype: `import { type } from "arktype";`,
+	valibot: `import * as v from "valibot";`
+};
+const QUERY_SCHEMA_EXPR = {
+	zod: `z.object({ name: z.string().default("Taser.js") })`,
+	arktype: `type({ "name?": 'string = "Taser.js"' })`,
+	valibot: `v.object({ name: v.optional(v.string(), "Taser.js") })`
+};
+const ValidatorAddon = (validator) => {
+	return {
+		id: validator,
+		category: "validator",
+		dependencies: () => [validator],
+		devDependencies: () => [],
+		apply: async (_ctx, write) => {
+			await write("src/routes/index.get.ts", `import { t } from "@taserjs/router";
+${IMPORT_LINES[validator]}
+
+export default t
+  .get("/")
+  .query(${QUERY_SCHEMA_EXPR[validator]})
+  .handler(({ req }) => {
+    return Response.json({ message: \`Hello, \${req.query.name}!\` });
+  });
+`);
+		}
+	};
+};
+//#endregion
+//#region src/addons/registry.ts
+const ADDONS = {
+	drizzle: drizzleAddon,
+	prisma: prismaAddon,
+	kysely: kyselyAddon,
+	pino: pinoAddon,
+	winston: {
+		id: "winston",
+		category: "logger",
+		dependencies() {
+			return ["winston"];
+		},
+		devDependencies() {
+			return [];
+		},
+		bootBinding() {
+			return {
+				key: "logger",
+				importPath: "./logger.js",
+				factoryName: "createLogger"
+			};
+		},
+		async apply(_ctx, write) {
+			await write("src/logger.ts", `import winston from "winston";
+
+export function createLogger() {
+  return winston.createLogger({
+    level: process.env.LOG_LEVEL ?? "info",
+    format: winston.format.json(),
+    transports: [new winston.transports.Console()],
+  });
+}
+`);
+		}
+	},
+	zod: ValidatorAddon("zod"),
+	arktype: ValidatorAddon("arktype"),
+	valibot: ValidatorAddon("valibot")
+};
+function resolveAddons(ctx) {
+	const result = [];
+	if (ctx.db && ADDONS[ctx.db]) {
+		const addon = ADDONS[ctx.db];
+		if (addon) result.push(addon);
+	}
+	if (ctx.logger && ADDONS[ctx.logger]) {
+		const addon = ADDONS[ctx.logger];
+		if (addon) result.push(addon);
+	}
+	if (ctx.validator && ADDONS[ctx.validator]) {
+		const addon = ADDONS[ctx.validator];
+		if (addon) result.push(addon);
+	}
+	return result;
+}
+function collectBootBindings(ctx) {
+	const addons = resolveAddons(ctx);
+	const bindings = [];
+	for (const addon of addons) if (addon.bootBinding) {
+		const binding = addon.bootBinding(ctx);
+		if (binding) bindings.push(binding);
+	}
+	return bindings;
+}
+//#endregion
+//#region src/core/package-manager.ts
+function resolveUserAgent() {
+	return getUserAgent() || "pnpm";
+}
+function runScript(agent, script) {
+	switch (agent) {
+		case "npm": return `npm run ${script}`;
+		case "yarn": return `yarn ${script}`;
+		case "bun": return `bun run ${script}`;
+		default: return `pnpm ${script}`;
+	}
+}
+async function installPackages(agent, cwd, packages) {
+	if (packages.dependencies.length > 0) {
+		const cmd = resolveCommand(agent, "add", packages.dependencies);
+		if (cmd) execSync(`${cmd.command} ${cmd.args.join(" ")}`, {
+			cwd,
+			stdio: "ignore"
+		});
+	}
+	if (packages.devDependencies.length > 0) {
+		const cmd = resolveCommand(agent, "add", [...agent === "npm" ? ["--save-dev"] : ["-D"], ...packages.devDependencies]);
+		if (cmd) execSync(`${cmd.command} ${cmd.args.join(" ")}`, {
+			cwd,
+			stdio: "ignore"
+		});
+	}
+}
+//#endregion
+//#region src/core/targets.ts
+const NITRO_NODE_START = "node .output/server/index.mjs";
+const DEPLOY_ENTRIES = {
+	none: {
+		id: "none",
+		impliedRuntime: "node",
+		selfHosted: true,
+		startScript: "node dist/serve.mjs",
+		devDeps: ["srvx"],
+		files: []
+	},
+	"node-server": {
+		id: "node-server",
+		impliedRuntime: "node",
+		selfHosted: true,
+		startScript: NITRO_NODE_START,
+		devDeps: ["nitro"],
+		files: []
+	},
+	"node-cluster": {
+		id: "node-cluster",
+		impliedRuntime: "node",
+		selfHosted: true,
+		startScript: NITRO_NODE_START,
+		devDeps: ["nitro"],
+		files: []
+	},
+	bun: {
+		id: "bun",
+		impliedRuntime: "bun",
+		selfHosted: true,
+		startScript: "bun .output/server/index.mjs",
+		devDeps: ["nitro", "@types/bun"],
+		files: []
+	},
+	"deno-server": {
+		id: "deno-server",
+		impliedRuntime: "deno",
+		selfHosted: true,
+		startScript: "deno run -A .output/server/index.mjs",
+		devDeps: ["nitro"],
+		files: []
+	},
+	"deno-deploy": {
+		id: "deno-deploy",
+		impliedRuntime: "deno",
+		selfHosted: false,
+		startScript: null,
+		devDeps: ["nitro"],
+		files: []
+	},
+	"cloudflare-module": {
+		id: "cloudflare-module",
+		impliedRuntime: "workerd",
+		selfHosted: false,
+		startScript: null,
+		devDeps: [
+			"nitro",
+			"wrangler",
+			"@cloudflare/workers-types"
+		],
+		files: [{
+			name: "wrangler.jsonc",
+			content: ({ projectName }) => `${JSON.stringify({
+				$schema: "node_modules/wrangler/config-schema.json",
+				name: projectName,
+				main: ".output/server/index.mjs",
+				compatibility_date: "2024-11-01"
+			}, null, 2)}\n`
+		}]
+	},
+	vercel: {
+		id: "vercel",
+		impliedRuntime: "node",
+		selfHosted: false,
+		startScript: null,
+		devDeps: ["nitro", "@vercel/node"],
+		files: []
+	},
+	"aws-lambda": {
+		id: "aws-lambda",
+		impliedRuntime: "node",
+		selfHosted: false,
+		startScript: null,
+		devDeps: ["nitro", "@types/aws-lambda"],
+		files: []
+	},
+	netlify: {
+		id: "netlify",
+		impliedRuntime: "node",
+		selfHosted: false,
+		startScript: null,
+		devDeps: ["nitro"],
+		files: []
+	}
+};
+const RUNTIME_OVERRIDES = {
+	none: ["node", "bun"],
+	"node-server": ["node", "bun"],
+	"node-cluster": ["node", "bun"]
+};
+const DEFAULT_DEPLOY = "none";
+function isCuratedDeploy(value) {
+	return DEPLOY_TARGETS.includes(value);
+}
+function resolveDeployEntry(id) {
+	if (isCuratedDeploy(id)) return {
+		entry: DEPLOY_ENTRIES[id],
+		curated: true
+	};
+	return {
+		entry: {
+			id,
+			impliedRuntime: "node",
+			selfHosted: false,
+			startScript: null,
+			devDeps: ["nitro"],
+			files: []
+		},
+		curated: false
+	};
+}
+function allowedRuntimeOverrides(id) {
+	return RUNTIME_OVERRIDES[id] ?? [];
+}
+function validateCombination(runtimeOverride, deploy) {
+	const { entry } = resolveDeployEntry(deploy);
+	if (runtimeOverride !== void 0) {
+		const allowed = entry.selfHosted ? allowedRuntimeOverrides(entry.id) : [];
+		if (!allowed.includes(runtimeOverride)) return {
+			ok: false,
+			reason: `Runtime "${runtimeOverride}" is not valid for deploy target "${entry.id}". ` + (allowed.length > 0 ? `Allowed overrides: ${allowed.join(", ")}.` : `It implies runtime "${String(entry.impliedRuntime)}".`)
+		};
+	}
+	return {
+		ok: true,
+		runtime: runtimeOverride ?? entry.impliedRuntime
+	};
+}
+//#endregion
+//#region src/templates/base.ts
+function packageJsonTemplate(projectName, scripts = {}) {
+	const pkg = {
+		name: projectName,
+		version: "0.0.1",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "vite",
+			build: "vite build",
+			start: "node dist/serve.mjs",
+			...scripts
+		}
+	};
+	return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+function tsconfigTemplate() {
+	return `${JSON.stringify({
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			strict: true,
+			skipLibCheck: true,
+			esModuleInterop: true
+		},
+		include: [
+			"src/**/*",
+			"src/.taserjs/**/*",
+			"taserjs.config.ts",
+			"vite.config.ts",
+			"nitro.config.ts"
+		]
+	}, null, 2)}\n`;
+}
+function gitignoreTemplate() {
+	return `node_modules/
+dist/
+.output/
+.taserjs/
+.env
+.env.*
+!.env.example
+*.log
+local.db
+drizzle/
+`;
+}
+function taserConfigTemplate() {
+	return `import { defineConfig } from "@taserjs/cli";
+
+export default defineConfig({
+  serverDir: "src",
+  routesDir: "routes",
+  outputDir: ".taserjs",
+  app: "taser.ts",
+});
+`;
+}
+function viteConfigTemplate(preset = "none") {
+	if (preset === "none") return `import { defineConfig } from "vite";
+import { taser } from "@taserjs/plugin/vite";
+
+export default defineConfig({
+  plugins: [taser()],
+});
+`;
+	return `import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+import { taser } from "@taserjs/plugin/vite";
+
+export default defineConfig({
+  plugins: [taser(), nitro()],
+});
+`;
+}
+function nitroConfigTemplate(preset) {
+	return `import { defineConfig } from "nitro/config";
+import { taser } from "@taserjs/plugin/nitro";
+
+export default defineConfig({
+  preset: "${preset}",
+  modules: [taser({ standalone: true })],
+});
+`;
+}
+function contextTemplate(bindings) {
+	const imports = bindings.map((b) => `import { ${b.factoryName} } from "${b.importPath}";`);
+	const bootBody = bindings.length > 0 ? bindings.map((b) => `    ${b.key}: ${b.factoryName}(),`).join("\n") : "";
+	const bootBlock = bindings.length > 0 ? `  boot: () => ({\n${bootBody}\n  }),\n` : "";
+	return `${imports.length > 0 ? `${imports.join("\n")}\n\n` : ""}import { createContext } from "@taserjs/router";
+
+export const context = createContext({
+${bootBlock}  request: () => ({
+    requestId: crypto.randomUUID(),
+  }),
+});
+`;
+}
+function taserTsTemplate() {
+	return `import { defineTaser } from "@taserjs/router";
+import { context } from "./context.js";
+
+export default defineTaser().context(context);
+`;
+}
+function rootLayoutTemplate() {
+	return `import { t } from "@taserjs/router";
+
+export default t.layout("/*").use(async (_args, next) => {
+  return await next();
+});
+`;
+}
+function indexRouteTemplate() {
+	return `import { t } from "@taserjs/router";
+
+export default t.get("/").handler(() => {
+  return Response.json({ message: "Welcome to Taser.js!" });
+});
+`;
+}
+function staticRoutesGenTemplate() {
+	return `// @ts-nocheck
+import { createTaserApp } from "@taserjs/runtime";
+import taser from "../taser.js";
+import layout_0 from "../routes/$.js";
+import route_0 from "../routes/index.get.js";
+
+export type LayoutTree = {
+  "/*": typeof layout_0;
+};
+
+export const layoutManifest = {
+  "/*": layout_0,
+} as const;
+
+export const routeManifest = {
+  layouts: layoutManifest,
+  routes: {
+    "/": {
+      GET: {
+        layouts: ["/*"],
+        route: route_0,
+      },
+    },
+  },
+} as const;
+
+export type RouteManifest = typeof routeManifest;
+
+export const app = createTaserApp(routeManifest, taser);
+export default app;
+export const createApp = (overrideTaser?: typeof taser) =>
+  createTaserApp(routeManifest, overrideTaser ?? taser);
+
+export type RoutePath = "/";
+
+export type LayoutHierarchy = {
+  "/*": readonly [];
+};
+
+export type RouteByPathMethod = {
+  "/": {
+    GET: {
+      layouts: readonly ["/*"];
+    };
+  };
+};
+
+export type AppContext = typeof taser.$Infer.Context;
+
+declare module "@taserjs/router" {
+  interface RouterRegister {
+    RoutePath: RoutePath;
+    LayoutTree: LayoutTree;
+    LayoutHierarchy: LayoutHierarchy;
+    RouteByPathMethod: RouteByPathMethod;
+    AppContext: AppContext;
+  }
+}
+`;
+}
+//#endregion
+//#region src/core/scaffold-engine.ts
+async function write(filePath, contents) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, contents.trimStart(), "utf-8");
+}
+async function scaffoldProject(options) {
+	const root = options.targetDir;
+	const preset = options.preset ?? "none";
+	const combination = validateCombination(options.runtime, preset);
+	if (!combination.ok) throw new Error(combination.reason);
+	const writtenFiles = [];
+	const trackedWrite = async (relPath, contents) => {
+		await write(join(root, relPath), contents);
+		writtenFiles.push(relPath);
+	};
+	const addons = resolveAddons(options);
+	const bootBindings = collectBootBindings(options);
+	const { entry: deployEntry } = resolveDeployEntry(preset);
+	const scripts = {};
+	if (deployEntry.startScript) scripts.start = deployEntry.startScript;
+	const dependencies = ["@taserjs/router", "@taserjs/runtime"];
+	const devDependencies = [
+		"@taserjs/cli",
+		"@taserjs/plugin",
+		"typescript",
+		"vite"
+	];
+	for (const dep of deployEntry.devDeps) devDependencies.push(dep);
+	for (const addon of addons) {
+		dependencies.push(...addon.dependencies(options));
+		devDependencies.push(...addon.devDependencies(options));
+		if (addon.scripts) Object.assign(scripts, addon.scripts(options));
+	}
+	const formatDep = (pkg) => {
+		const ver = options.packageVersions?.[pkg];
+		return ver ? `${pkg}@${ver}` : pkg;
+	};
+	const resolvedDeps = [...new Set(dependencies)].map(formatDep);
+	const resolvedDevDeps = [...new Set(devDependencies)].map(formatDep);
+	await trackedWrite("package.json", packageJsonTemplate(options.projectName, scripts));
+	await trackedWrite("tsconfig.json", tsconfigTemplate());
+	await trackedWrite(".gitignore", gitignoreTemplate());
+	await trackedWrite("taserjs.config.ts", taserConfigTemplate());
+	await trackedWrite("vite.config.ts", viteConfigTemplate(preset));
+	if (preset !== "none") await trackedWrite("nitro.config.ts", nitroConfigTemplate(preset));
+	await Promise.all(deployEntry.files.map(async (file) => {
+		const content = typeof file.content === "function" ? file.content({ projectName: options.projectName }) : file.content;
+		await trackedWrite(file.name, content);
+	}));
+	await trackedWrite("src/context.ts", contextTemplate(bootBindings));
+	await trackedWrite("src/taser.ts", taserTsTemplate());
+	await trackedWrite("src/routes/index.get.ts", indexRouteTemplate());
+	await trackedWrite("src/routes/$.ts", rootLayoutTemplate());
+	await Promise.all(addons.map(async (addon) => {
+		await addon.apply(options, async (relPath, contents) => {
+			await trackedWrite(relPath, contents);
+		});
+	}));
+	await trackedWrite("src/.taserjs/routes.gen.ts", staticRoutesGenTemplate());
+	if (!options.skipInstall) await installPackages(options.agent ?? resolveUserAgent(), root, {
+		dependencies: resolvedDeps,
+		devDependencies: resolvedDevDeps
+	});
+	return {
+		...options,
+		files: writtenFiles
+	};
+}
+//#endregion
+//#region src/commands/create.ts
+const DEPLOY_LABELS = {
+	none: "None (Standalone Vite SSR)",
+	"node-server": "Node.js server (Nitro)",
+	"node-cluster": "Node.js cluster (Nitro)",
+	bun: "Bun (Nitro)",
+	"deno-server": "Deno (Nitro)",
+	"deno-deploy": "Deno Deploy (Nitro)",
+	"cloudflare-module": "Cloudflare Workers (Nitro)",
+	vercel: "Vercel (Nitro)",
+	"aws-lambda": "AWS Lambda (Nitro)",
+	netlify: "Netlify (Nitro)"
+};
+async function promptInteractiveOptions(defaults) {
+	const projectName = defaults.projectName ?? await p.text({
+		message: "Project name",
+		placeholder: "my-taser-app",
+		defaultValue: "my-taser-app",
+		validate(value) {
+			if (!value || value.trim().length === 0) return "Project name cannot be empty";
+			if (/[^a-zA-Z0-9_-]/.test(value)) return "Project name contains invalid characters";
+		}
+	});
+	if (p.isCancel(projectName)) {
+		p.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	const preset = defaults.preset ?? await p.select({
+		message: "Deployment target",
+		options: DEPLOY_TARGETS.map((id) => ({
+			value: id,
+			label: DEPLOY_LABELS[id]
+		})),
+		initialValue: "none"
+	});
+	if (p.isCancel(preset)) {
+		p.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	let runtime;
+	const runtimeOverrides = allowedRuntimeOverrides(preset);
+	if (runtimeOverrides.length > 0) {
+		const runtimeChoice = defaults.runtime ?? await p.select({
+			message: "Runtime override",
+			options: [...runtimeOverrides.map((rt) => ({
+				value: rt,
+				label: rt
+			})), {
+				value: "default",
+				label: "Preset default",
+				hint: "no override"
+			}],
+			initialValue: "default"
+		});
+		if (p.isCancel(runtimeChoice)) {
+			p.cancel("Scaffold cancelled.");
+			process.exit(0);
+		}
+		runtime = runtimeChoice === "default" ? void 0 : runtimeChoice;
+	}
+	const validatorChoice = defaults.validator ?? await p.select({
+		message: "Standard Schema Validator",
+		options: [
+			{
+				value: "none",
+				label: "None",
+				hint: "default"
+			},
+			{
+				value: "zod",
+				label: "Zod"
+			},
+			{
+				value: "valibot",
+				label: "Valibot"
+			},
+			{
+				value: "arktype",
+				label: "Arktype"
+			}
+		],
+		initialValue: "none"
+	});
+	if (p.isCancel(validatorChoice)) {
+		p.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	const validator = validatorChoice === "none" ? void 0 : validatorChoice;
+	const dbChoice = defaults.db ?? await p.select({
+		message: "Database ORM / Query Builder",
+		options: [
+			{
+				value: "none",
+				label: "None",
+				hint: "default"
+			},
+			{
+				value: "drizzle",
+				label: "Drizzle"
+			},
+			{
+				value: "prisma",
+				label: "Prisma"
+			},
+			{
+				value: "kysely",
+				label: "Kysely"
+			}
+		],
+		initialValue: "none"
+	});
+	if (p.isCancel(dbChoice)) {
+		p.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	let db;
+	let driver;
+	if (dbChoice !== "none") {
+		db = dbChoice;
+		const driverChoice = defaults.driver ?? await p.select({
+			message: "Database driver",
+			options: [
+				{
+					value: "sqlite",
+					label: "SQLite",
+					hint: "default"
+				},
+				{
+					value: "postgres",
+					label: "PostgreSQL"
+				},
+				{
+					value: "mysql",
+					label: "MySQL"
+				}
+			],
+			initialValue: "sqlite"
+		});
+		if (p.isCancel(driverChoice)) {
+			p.cancel("Scaffold cancelled.");
+			process.exit(0);
+		}
+		driver = driverChoice;
+	}
+	const loggerChoice = defaults.logger ?? await p.select({
+		message: "Logger",
+		options: [
+			{
+				value: "none",
+				label: "None",
+				hint: "default"
+			},
+			{
+				value: "pino",
+				label: "Pino"
+			},
+			{
+				value: "winston",
+				label: "Winston"
+			}
+		],
+		initialValue: "none"
+	});
+	if (p.isCancel(loggerChoice)) {
+		p.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	const logger = loggerChoice === "none" ? void 0 : loggerChoice;
+	return {
+		projectName: String(projectName).trim(),
+		preset,
+		...runtime ? { runtime } : {},
+		...validator ? { validator } : {},
+		...db ? {
+			db,
+			driver
+		} : {},
+		...logger ? { logger } : {},
+		skipInstall: defaults.skipInstall
+	};
+}
+async function runCreateCommand(args = {}) {
+	const isInteractive = args.interactive ?? (Boolean(process.stdout.isTTY) && process.env.NODE_ENV !== "test");
+	const resolved = isInteractive ? await promptInteractiveOptions(args) : {
+		...args,
+		projectName: args.projectName ?? "my-taser-app",
+		preset: args.preset ?? "none"
+	};
+	const cwd = process.cwd();
+	const projectName = resolved.projectName || "my-taser-app";
+	const targetDir = args.targetDir ? path.resolve(cwd, args.targetDir) : path.resolve(cwd, projectName);
+	const scaffoldOpts = {
+		projectName,
+		targetDir,
+		...resolved.preset !== void 0 ? { preset: resolved.preset } : {},
+		...resolved.runtime !== void 0 ? { runtime: resolved.runtime } : {},
+		...resolved.validator !== void 0 ? { validator: resolved.validator } : {},
+		...resolved.db !== void 0 ? { db: resolved.db } : {},
+		...resolved.driver !== void 0 ? { driver: resolved.driver } : {},
+		...resolved.logger !== void 0 ? { logger: resolved.logger } : {},
+		...args.packageVersions !== void 0 ? { packageVersions: args.packageVersions } : {},
+		skipInstall: resolved.skipInstall ?? process.env.NODE_ENV === "test"
+	};
+	if (isInteractive) {
+		const s = p.spinner();
+		s.start("Scaffolding project");
+		const result = await scaffoldProject(scaffoldOpts);
+		s.stop("Project created");
+		const agent = resolveUserAgent();
+		p.outro(pc.green("Done!"));
+		console.log(`\nNext steps:`);
+		console.log(`  cd ${path.relative(cwd, targetDir) || "."}`);
+		if (scaffoldOpts.skipInstall) console.log(`  ${runScript(agent, "install")}`);
+		console.log(`  ${runScript(agent, "dev")}\n`);
+		return result;
+	}
+	return await scaffoldProject(scaffoldOpts);
+}
+//#endregion
+//#region src/cli.ts
+async function run(argv = hideBin(process.argv)) {
+	await yargs(argv).scriptName("create-taserjs").usage("$0 [dir] [options]").command("$0 [dir]", "Scaffold a new Taser.js application", (y) => y.positional("dir", {
+		type: "string",
+		description: "Directory or project name"
+	}).option("preset", {
+		alias: "p",
+		type: "string",
+		description: "Deployment preset"
+	}).option("runtime", {
+		type: "string",
+		description: "Runtime override (node, bun, deno)"
+	}).option("validator", {
+		alias: "v",
+		type: "string",
+		choices: [
+			"zod",
+			"valibot",
+			"arktype",
+			"none"
+		],
+		description: "Standard Schema validator"
+	}).option("db", {
+		type: "string",
+		choices: [
+			"drizzle",
+			"prisma",
+			"kysely",
+			"none"
+		],
+		description: "Database ORM / Query builder"
+	}).option("driver", {
+		type: "string",
+		choices: [
+			"sqlite",
+			"postgres",
+			"mysql"
+		],
+		description: "Database driver"
+	}).option("logger", {
+		alias: "l",
+		type: "string",
+		choices: [
+			"pino",
+			"winston",
+			"none"
+		],
+		description: "Logger addon"
+	}).option("skip-install", {
+		type: "boolean",
+		description: "Skip dependency installation",
+		default: false
+	}).option("yes", {
+		alias: "y",
+		type: "boolean",
+		description: "Skip prompts and use defaults",
+		default: false
+	}), async (args) => {
+		await runCreateCommand({
+			targetDir: args.dir,
+			projectName: args.dir,
+			preset: args.preset,
+			runtime: args.runtime,
+			validator: args.validator === "none" ? void 0 : args.validator,
+			db: args.db === "none" ? void 0 : args.db,
+			driver: args.driver,
+			logger: args.logger === "none" ? void 0 : args.logger,
+			skipInstall: Boolean(args.skipInstall),
+			interactive: !args.yes
+		});
+	}).help().alias("help", "h").version().alias("version", "V").strict().exitProcess(false).parse();
+}
+if (process.argv[1] && process.argv[1].endsWith("cli.js")) run().catch((err) => {
+	console.error(err instanceof Error ? err.message : String(err));
+	process.exit(1);
+});
+//#endregion
+export { VALIDATORS as C, RUNTIMES as S, DB_DRIVERS as _, DEFAULT_DEPLOY as a, DEPLOY_TARGETS as b, isCuratedDeploy as c, installPackages as d, resolveUserAgent as f, resolveAddons as g, collectBootBindings as h, scaffoldProject as i, resolveDeployEntry as l, ADDONS as m, promptInteractiveOptions as n, DEPLOY_ENTRIES as o, runScript as p, runCreateCommand as r, allowedRuntimeOverrides as s, run as t, validateCombination as u, DB_ODMS as v, LOGGERS as x, DEFAULT_DB_DRIVER as y };
+
+//# sourceMappingURL=cli-9fkoNOJg.js.map