create-taserjs 0.1.12 → 0.2.1

package/dist/cli-CBhdDKHU.cjs

@@ -0,0 +1,1398 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_child_process = require("node:child_process");
+let package_manager_detector = require("package-manager-detector");
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = __toESM(_clack_prompts, 1);
+let picocolors = require("picocolors");
+picocolors = __toESM(picocolors, 1);
+let yargs = require("yargs");
+yargs = __toESM(yargs, 1);
+let yargs_helpers = require("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 (0, package_manager_detector.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 = (0, package_manager_detector.resolveCommand)(agent, "add", packages.dependencies);
+		if (cmd) (0, node_child_process.execSync)(`${cmd.command} ${cmd.args.join(" ")}`, {
+			cwd,
+			stdio: "ignore"
+		});
+	}
+	if (packages.devDependencies.length > 0) {
+		const cmd = (0, package_manager_detector.resolveCommand)(agent, "add", [...agent === "npm" ? ["--save-dev"] : ["-D"], ...packages.devDependencies]);
+		if (cmd) (0, node_child_process.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: [],
+		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 (0, node_fs_promises.mkdir)((0, node_path.dirname)(filePath), { recursive: true });
+	await (0, node_fs_promises.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((0, node_path.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 _clack_prompts.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 (_clack_prompts.isCancel(projectName)) {
+		_clack_prompts.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	const preset = defaults.preset ?? await _clack_prompts.select({
+		message: "Deployment target",
+		options: DEPLOY_TARGETS.map((id) => ({
+			value: id,
+			label: DEPLOY_LABELS[id]
+		})),
+		initialValue: "none"
+	});
+	if (_clack_prompts.isCancel(preset)) {
+		_clack_prompts.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	let runtime;
+	const runtimeOverrides = allowedRuntimeOverrides(preset);
+	if (runtimeOverrides.length > 0) {
+		const runtimeChoice = defaults.runtime ?? await _clack_prompts.select({
+			message: "Runtime override",
+			options: [...runtimeOverrides.map((rt) => ({
+				value: rt,
+				label: rt
+			})), {
+				value: "default",
+				label: "Preset default",
+				hint: "no override"
+			}],
+			initialValue: "default"
+		});
+		if (_clack_prompts.isCancel(runtimeChoice)) {
+			_clack_prompts.cancel("Scaffold cancelled.");
+			process.exit(0);
+		}
+		runtime = runtimeChoice === "default" ? void 0 : runtimeChoice;
+	}
+	const validatorChoice = defaults.validator ?? await _clack_prompts.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 (_clack_prompts.isCancel(validatorChoice)) {
+		_clack_prompts.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	const validator = validatorChoice === "none" ? void 0 : validatorChoice;
+	const dbChoice = defaults.db ?? await _clack_prompts.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 (_clack_prompts.isCancel(dbChoice)) {
+		_clack_prompts.cancel("Scaffold cancelled.");
+		process.exit(0);
+	}
+	let db;
+	let driver;
+	if (dbChoice !== "none") {
+		db = dbChoice;
+		const driverChoice = defaults.driver ?? await _clack_prompts.select({
+			message: "Database driver",
+			options: [
+				{
+					value: "sqlite",
+					label: "SQLite",
+					hint: "default"
+				},
+				{
+					value: "postgres",
+					label: "PostgreSQL"
+				},
+				{
+					value: "mysql",
+					label: "MySQL"
+				}
+			],
+			initialValue: "sqlite"
+		});
+		if (_clack_prompts.isCancel(driverChoice)) {
+			_clack_prompts.cancel("Scaffold cancelled.");
+			process.exit(0);
+		}
+		driver = driverChoice;
+	}
+	const loggerChoice = defaults.logger ?? await _clack_prompts.select({
+		message: "Logger",
+		options: [
+			{
+				value: "none",
+				label: "None",
+				hint: "default"
+			},
+			{
+				value: "pino",
+				label: "Pino"
+			},
+			{
+				value: "winston",
+				label: "Winston"
+			}
+		],
+		initialValue: "none"
+	});
+	if (_clack_prompts.isCancel(loggerChoice)) {
+		_clack_prompts.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 ? node_path.default.resolve(cwd, args.targetDir) : node_path.default.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 = _clack_prompts.spinner();
+		s.start("Scaffolding project");
+		const result = await scaffoldProject(scaffoldOpts);
+		s.stop("Project created");
+		const agent = resolveUserAgent();
+		_clack_prompts.outro(picocolors.default.green("Done!"));
+		console.log(`\nNext steps:`);
+		console.log(`  cd ${node_path.default.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 = (0, yargs_helpers.hideBin)(process.argv)) {
+	await (0, yargs.default)(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
+Object.defineProperty(exports, "ADDONS", {
+	enumerable: true,
+	get: function() {
+		return ADDONS;
+	}
+});
+Object.defineProperty(exports, "DB_DRIVERS", {
+	enumerable: true,
+	get: function() {
+		return DB_DRIVERS;
+	}
+});
+Object.defineProperty(exports, "DB_ODMS", {
+	enumerable: true,
+	get: function() {
+		return DB_ODMS;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_DB_DRIVER", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_DB_DRIVER;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_DEPLOY", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_DEPLOY;
+	}
+});
+Object.defineProperty(exports, "DEPLOY_ENTRIES", {
+	enumerable: true,
+	get: function() {
+		return DEPLOY_ENTRIES;
+	}
+});
+Object.defineProperty(exports, "DEPLOY_TARGETS", {
+	enumerable: true,
+	get: function() {
+		return DEPLOY_TARGETS;
+	}
+});
+Object.defineProperty(exports, "LOGGERS", {
+	enumerable: true,
+	get: function() {
+		return LOGGERS;
+	}
+});
+Object.defineProperty(exports, "RUNTIMES", {
+	enumerable: true,
+	get: function() {
+		return RUNTIMES;
+	}
+});
+Object.defineProperty(exports, "VALIDATORS", {
+	enumerable: true,
+	get: function() {
+		return VALIDATORS;
+	}
+});
+Object.defineProperty(exports, "allowedRuntimeOverrides", {
+	enumerable: true,
+	get: function() {
+		return allowedRuntimeOverrides;
+	}
+});
+Object.defineProperty(exports, "collectBootBindings", {
+	enumerable: true,
+	get: function() {
+		return collectBootBindings;
+	}
+});
+Object.defineProperty(exports, "installPackages", {
+	enumerable: true,
+	get: function() {
+		return installPackages;
+	}
+});
+Object.defineProperty(exports, "isCuratedDeploy", {
+	enumerable: true,
+	get: function() {
+		return isCuratedDeploy;
+	}
+});
+Object.defineProperty(exports, "promptInteractiveOptions", {
+	enumerable: true,
+	get: function() {
+		return promptInteractiveOptions;
+	}
+});
+Object.defineProperty(exports, "resolveAddons", {
+	enumerable: true,
+	get: function() {
+		return resolveAddons;
+	}
+});
+Object.defineProperty(exports, "resolveDeployEntry", {
+	enumerable: true,
+	get: function() {
+		return resolveDeployEntry;
+	}
+});
+Object.defineProperty(exports, "resolveUserAgent", {
+	enumerable: true,
+	get: function() {
+		return resolveUserAgent;
+	}
+});
+Object.defineProperty(exports, "run", {
+	enumerable: true,
+	get: function() {
+		return run;
+	}
+});
+Object.defineProperty(exports, "runCreateCommand", {
+	enumerable: true,
+	get: function() {
+		return runCreateCommand;
+	}
+});
+Object.defineProperty(exports, "runScript", {
+	enumerable: true,
+	get: function() {
+		return runScript;
+	}
+});
+Object.defineProperty(exports, "scaffoldProject", {
+	enumerable: true,
+	get: function() {
+		return scaffoldProject;
+	}
+});
+Object.defineProperty(exports, "validateCombination", {
+	enumerable: true,
+	get: function() {
+		return validateCombination;
+	}
+});