@beignet/cli 0.0.1

package/src/templates.ts

@@ -0,0 +1,2460 @@
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export type PresetName = "minimal" | "standard";
+export type TemplateName = "next";
+export type FeatureName = "client" | "react-query" | "forms" | "openapi";
+export type IntegrationName =
+  | "better-auth"
+  | "drizzle-turso"
+  | "inngest"
+  | "pino"
+  | "resend"
+  | "upstash-rate-limit";
+
+export type TemplateFile = {
+  path: string;
+  content: string;
+};
+
+export type TemplateContext = {
+  name: string;
+  packageManager: PackageManager;
+  beignetVersion: string;
+  preset: PresetName;
+  features: FeatureName[];
+  integrations: IntegrationName[];
+};
+
+const externalVersions = {
+  next: "^16.2.4",
+  react: "^19.2.5",
+  reactDom: "^19.2.5",
+  typescript: "^5.3.0",
+  typesBun: "^1.3.13",
+  typesNode: "^20.10.0",
+  typesReact: "^19.0.0",
+  typesReactDom: "^19.0.0",
+  zod: "^4.0.0",
+  tanstackReactQuery: "^5.100.7",
+  hookformResolvers: "^5.0.0",
+  reactHookForm: "^7.74.0",
+  betterAuth: "^1.3.26",
+  drizzleKit: "^0.30.0",
+  drizzleOrm: "^0.38.0",
+  inngest: "^3.0.0",
+  libsqlClient: "^0.14.0",
+  pino: "^9.7.0",
+  resend: "^4.0.1",
+  upstashRateLimit: "^2.0.0",
+  upstashRedis: "^1.0.0",
+};
+
+function isStandardPreset(ctx: TemplateContext): boolean {
+  return ctx.preset === "standard";
+}
+
+function hasDrizzleTurso(ctx: TemplateContext): boolean {
+  return hasIntegration(ctx, "drizzle-turso");
+}
+
+function packageRunner(ctx: TemplateContext): string {
+  switch (ctx.packageManager) {
+    case "npm":
+      return "npx -p @beignet/cli beignet";
+    case "pnpm":
+      return "pnpm dlx @beignet/cli beignet";
+    case "yarn":
+      return "yarn dlx @beignet/cli beignet";
+    default:
+      return "bunx -p @beignet/cli beignet";
+  }
+}
+
+export const featureChoices = [
+  "client",
+  "react-query",
+  "forms",
+  "openapi",
+] as const satisfies readonly FeatureName[];
+
+export const presetChoices = [
+  "minimal",
+  "standard",
+] as const satisfies readonly PresetName[];
+
+export const integrationChoices = [
+  "better-auth",
+  "drizzle-turso",
+  "inngest",
+  "pino",
+  "resend",
+  "upstash-rate-limit",
+] as const satisfies readonly IntegrationName[];
+
+const integrationDeps: Record<IntegrationName, Record<string, string>> = {
+  "better-auth": {
+    "@beignet/provider-auth-better-auth": "",
+    "better-auth": externalVersions.betterAuth,
+  },
+  "drizzle-turso": {
+    "@beignet/provider-drizzle-turso": "",
+    "@libsql/client": externalVersions.libsqlClient,
+    "drizzle-orm": externalVersions.drizzleOrm,
+  },
+  inngest: {
+    "@beignet/provider-inngest": "",
+    inngest: externalVersions.inngest,
+  },
+  pino: {
+    "@beignet/provider-logger-pino": "",
+    pino: externalVersions.pino,
+  },
+  resend: {
+    "@beignet/provider-mail-resend": "",
+    resend: externalVersions.resend,
+  },
+  "upstash-rate-limit": {
+    "@beignet/provider-rate-limit-upstash": "",
+    "@upstash/ratelimit": externalVersions.upstashRateLimit,
+    "@upstash/redis": externalVersions.upstashRedis,
+  },
+};
+
+const integrationDevDeps: Partial<
+  Record<IntegrationName, Record<string, string>>
+> = {
+  "drizzle-turso": {
+    "drizzle-kit": externalVersions.drizzleKit,
+  },
+};
+
+const featureDeps: Record<FeatureName, Record<string, string>> = {
+  client: {},
+  "react-query": {
+    "@beignet/react-query": "",
+    "@tanstack/react-query": externalVersions.tanstackReactQuery,
+  },
+  forms: {
+    "@beignet/react-hook-form": "",
+    "@hookform/resolvers": externalVersions.hookformResolvers,
+    "react-hook-form": externalVersions.reactHookForm,
+  },
+  openapi: {
+    "@beignet/core": "",
+  },
+};
+
+function hasFeature(ctx: TemplateContext, feature: FeatureName): boolean {
+  return ctx.features.includes(feature);
+}
+
+function hasIntegration(
+  ctx: TemplateContext,
+  integration: IntegrationName,
+): boolean {
+  return ctx.integrations.includes(integration);
+}
+
+function json(value: unknown): string {
+  return `${JSON.stringify(value, null, "\t")}\n`;
+}
+
+function gitignore(ctx: TemplateContext): string {
+  const lines = [files.gitignore.trimEnd()];
+
+  if (isStandardPreset(ctx)) {
+    lines.push("/storage/");
+  }
+
+  if (hasDrizzleTurso(ctx)) {
+    lines.push("local.db", "local.db-*");
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function packageJson(ctx: TemplateContext): string {
+  const dependencies: Record<string, string> = {
+    "@beignet/core": ctx.beignetVersion,
+    "@beignet/next": ctx.beignetVersion,
+    next: externalVersions.next,
+    react: externalVersions.react,
+    "react-dom": externalVersions.reactDom,
+    zod: externalVersions.zod,
+  };
+
+  if (isStandardPreset(ctx)) {
+    dependencies["@beignet/devtools"] = ctx.beignetVersion;
+    dependencies["@beignet/provider-storage-local"] = ctx.beignetVersion;
+  }
+
+  for (const integration of ctx.integrations) {
+    for (const [name, version] of Object.entries(
+      integrationDeps[integration],
+    )) {
+      dependencies[name] = version || ctx.beignetVersion;
+    }
+  }
+
+  for (const feature of ctx.features) {
+    for (const [name, version] of Object.entries(featureDeps[feature])) {
+      dependencies[name] = version || ctx.beignetVersion;
+    }
+  }
+
+  const devDependencies: Record<string, string> = {
+    "@types/bun": externalVersions.typesBun,
+    "@types/node": externalVersions.typesNode,
+    "@types/react": externalVersions.typesReact,
+    "@types/react-dom": externalVersions.typesReactDom,
+    typescript: externalVersions.typescript,
+  };
+
+  for (const integration of ctx.integrations) {
+    for (const [name, version] of Object.entries(
+      integrationDevDeps[integration] ?? {},
+    )) {
+      devDependencies[name] = version;
+    }
+  }
+
+  const scripts: Record<string, string> = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+  };
+
+  if (hasDrizzleTurso(ctx)) {
+    scripts["db:generate"] = "drizzle-kit generate";
+    scripts["db:migrate"] = "drizzle-kit migrate";
+  }
+
+  return json({
+    name: ctx.name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts,
+    dependencies,
+    devDependencies,
+  });
+}
+
+function readme(ctx: TemplateContext): string {
+  if (isStandardPreset(ctx)) {
+    return standardReadme(ctx);
+  }
+
+  const install = `${ctx.packageManager} install`;
+  const run =
+    ctx.packageManager === "npm"
+      ? "npm run dev"
+      : `${ctx.packageManager} run dev`;
+  const featureList =
+    ctx.features.length > 0
+      ? ctx.features.map((feature) => `- \`${feature}\``).join("\n")
+      : "- API routes only";
+  const integrationList =
+    ctx.integrations.length > 0
+      ? ctx.integrations.map((integration) => `- \`${integration}\``).join("\n")
+      : "- None";
+
+  return `# ${ctx.name}
+
+Beignet app scaffolded with \`@beignet/cli\`.
+
+## Getting started
+
+\`\`\`bash
+${install}
+${run}
+\`\`\`
+
+Open http://localhost:3000 and start from the todos workflow.
+
+## Files to know
+
+- \`features/todos/contracts.ts\` defines the API contract.
+- \`features/todos/use-cases.ts\` contains application logic with input and output validation.
+- \`ports/index.ts\` defines the app's external dependencies.
+- \`server/index.ts\` wires contracts to handlers.
+- \`app/api/[[...path]]/route.ts\` exposes contract-backed API routes to Next.js.
+${hasFeature(ctx, "react-query") ? "- `features/todos/components/todo-app.tsx` contains the starter UI.\n" : ""}
+
+## Selected preset
+
+\`${ctx.preset}\`
+
+## Selected features
+
+${featureList}
+
+## Selected integrations
+
+${integrationList}
+${ctx.integrations.length > 0 ? "\nSee `docs/integrations.md` for setup notes.\n" : ""}
+`;
+}
+
+function standardReadme(ctx: TemplateContext): string {
+  const install = `${ctx.packageManager} install`;
+  const run =
+    ctx.packageManager === "npm"
+      ? "npm run dev"
+      : `${ctx.packageManager} run dev`;
+  const typecheck =
+    ctx.packageManager === "npm"
+      ? "npm run typecheck"
+      : `${ctx.packageManager} run typecheck`;
+  const cli = packageRunner(ctx);
+  const beforeDeploy = hasDrizzleTurso(ctx)
+    ? [
+        "- Create a Turso database or keep `TURSO_DB_URL=file:local.db` for local libSQL development.",
+        `- Run \`${ctx.packageManager} run db:generate\` and \`${ctx.packageManager} run db:migrate\` after changing the Drizzle schema.`,
+      ].join("\n")
+    : "- Replace the in-memory todo repository with a durable adapter.";
+
+  return `# ${ctx.name}
+
+Beignet app scaffolded with \`@beignet/cli\`.
+
+## Getting started
+
+\`\`\`bash
+${install}
+cp .env.example .env.local
+${run}
+\`\`\`
+
+Open http://localhost:3000 for the todo workflow, http://localhost:3000/api/health for health checks, and http://localhost:3000/api/devtools while developing.
+
+## First checks
+
+\`\`\`bash
+# in another terminal
+${cli} routes
+${cli} lint
+${cli} doctor
+${typecheck}
+\`\`\`
+
+\`routes\` shows the contracts Beignet can inspect. \`lint\` checks dependency direction. \`doctor\` catches route, OpenAPI, and resource drift.
+
+## App map
+
+- \`features/todos/contracts.ts\` owns the HTTP contract and reuses use case schemas.
+- \`features/todos/use-cases/\` owns application behavior and validation.
+- \`ports/\` defines app-owned dependencies.
+- \`infra/\` implements ports for the selected runtime.
+- \`server/routes.ts\` keeps the central route registry and OpenAPI contract list.
+- \`server/\` wires context, providers, routes, hooks, and error handling.
+- \`features/shared/errors.ts\` keeps application errors and route-owned error schemas together.
+- \`app/storage/[...key]/route.ts\` serves public local storage objects.
+- \`lib/env.ts\` validates deployment configuration at startup.
+- \`lib/auth.ts\` exposes \`requireUser(ctx)\` for protected use cases.
+- \`features/todos/policy.ts\` defines authorization rules registered with \`createGate(...)\`.
+${hasDrizzleTurso(ctx) ? "- `infra/db/schema/` contains the Drizzle schema, `infra/db/repositories.ts` creates app repositories, and `infra/todos/` contains the durable todo repository adapter.\n" : ""}
+
+## Before deploying
+
+${beforeDeploy}
+- Keep \`/api/devtools\` development-only unless you add authentication and stricter redaction.
+- Set \`APP_URL\`, \`LOG_LEVEL\`, and service-specific integration variables in your hosting environment.
+- Replace anonymous auth and add use-case authorization before exposing user-owned data.
+${ctx.integrations.length > 0 ? "\nSee `docs/integrations.md` for setup notes.\n" : ""}
+`;
+}
+
+function integrationsDoc(ctx: TemplateContext): string {
+  const lines = [
+    "# Integrations",
+    "",
+    "The starter app added dependencies for the integrations you selected. Runtime providers are wired in `server/providers.ts` when Beignet can do so safely; integrations that need app-owned setup list their follow-up steps below.",
+    "",
+  ];
+
+  for (const integration of ctx.integrations) {
+    if (integration === "better-auth") {
+      lines.push(
+        "## Better Auth",
+        "",
+        "- Package: `@beignet/provider-auth-better-auth`",
+        "- Peer dependency: `better-auth`",
+        "- The starter uses an anonymous auth adapter. Replace `createAnonymousAuth()` in `infra/app-ports.ts` with an adapter backed by your Better Auth session lookup.",
+        "- Keep auth behind the shared `AuthPort`, then call `requireUser(ctx)` in use cases that need a signed-in user.",
+        "- Put repeated ownership or role rules in policies registered with `createGate(...)`.",
+        "- Add the Better Auth provider only after your app has a database adapter and session setup.",
+        "",
+      );
+    }
+
+    if (integration === "drizzle-turso") {
+      lines.push(
+        "## Drizzle + Turso",
+        "",
+        "- Package: `@beignet/provider-drizzle-turso`",
+        "- Peer dependencies: `@libsql/client` and `drizzle-orm`",
+        "- Dev dependency: `drizzle-kit`",
+        "- Set `TURSO_DB_URL` and optional `TURSO_DB_AUTH_TOKEN`.",
+        "- The scaffold wires a typed Drizzle repository behind the `TodoRepository` port and a transaction-backed Unit of Work.",
+        `- Run \`${ctx.packageManager} run db:generate\` and \`${ctx.packageManager} run db:migrate\` after changing \`infra/db/schema.ts\`.`,
+        "",
+      );
+    }
+
+    if (integration === "inngest") {
+      lines.push(
+        "## Inngest",
+        "",
+        "- Package: `@beignet/core` (`@beignet/core/events`, `@beignet/core/jobs`)",
+        "- Package: `@beignet/provider-inngest`",
+        "- Peer dependency: `inngest`",
+        "- The standard preset wires `inngestProvider` in `server/providers.ts` and adds `jobs: JobDispatcherPort` to `AppPorts`.",
+        "- Define jobs with `createJobHandlers(...).defineJob(...)` and dispatch them through `ctx.ports.jobs.dispatch(...)`.",
+        "- Keep direct Inngest client usage inside infrastructure code unless you intentionally add an app-owned escape-hatch port.",
+        "",
+      );
+    }
+
+    if (integration === "pino") {
+      lines.push(
+        "## Pino logger",
+        "",
+        "- Package: `@beignet/provider-logger-pino`",
+        "- Peer dependency: `pino`",
+        "- Use this provider when you want structured request and handler logging.",
+        "",
+      );
+    }
+
+    if (integration === "resend") {
+      lines.push(
+        "## Resend mail",
+        "",
+        "- Package: `@beignet/provider-mail-resend`",
+        "- Peer dependency: `resend`",
+        "- The standard preset wires `mailResendProvider` in `server/providers.ts` and adds `mailer: MailerPort` to `AppPorts`.",
+        "- Set `RESEND_API_KEY` and `RESEND_FROM` before starting the app.",
+        "",
+      );
+    }
+
+    if (integration === "upstash-rate-limit") {
+      lines.push(
+        "## Upstash rate limit",
+        "",
+        "- Package: `@beignet/provider-rate-limit-upstash`",
+        "- Peer dependencies: `@upstash/ratelimit` and `@upstash/redis`",
+        "- The standard preset wires `upstashRateLimitProvider` in `server/providers.ts` and adds `rateLimit: RateLimitPort` to `AppPorts`.",
+        "- Set `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` before starting the app.",
+        "",
+      );
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function envExample(ctx: TemplateContext): string {
+  const lines = [
+    "# Copy to .env.local and fill in values for your app.",
+    "NODE_ENV=development",
+    "APP_URL=http://localhost:3000",
+    "CRON_SECRET=",
+    "DEVTOOLS_ENABLED=true",
+    "",
+  ];
+
+  if (isStandardPreset(ctx)) {
+    lines.push(
+      "STORAGE_ROOT=storage/app",
+      "# STORAGE_PUBLIC_BASE_URL=/storage",
+      "",
+    );
+  }
+
+  if (hasIntegration(ctx, "pino")) {
+    lines.push(
+      "LOG_LEVEL=info",
+      "LOG_FORMAT=json",
+      `LOG_SERVICE=${ctx.name}`,
+      "",
+    );
+  }
+
+  if (hasIntegration(ctx, "inngest")) {
+    lines.push("INNGEST_APP_NAME=beignet-app", "# INNGEST_EVENT_KEY=", "");
+  }
+
+  if (hasIntegration(ctx, "drizzle-turso")) {
+    lines.push(
+      "# Use file:local.db for local libSQL or libsql://... for Turso cloud.",
+      "TURSO_DB_URL=file:local.db",
+      "# TURSO_DB_AUTH_TOKEN=",
+      "",
+    );
+  }
+
+  if (hasIntegration(ctx, "resend")) {
+    lines.push("RESEND_API_KEY=", "RESEND_FROM=", "");
+  }
+
+  if (hasIntegration(ctx, "upstash-rate-limit")) {
+    lines.push(
+      "UPSTASH_REDIS_REST_URL=",
+      "UPSTASH_REDIS_REST_TOKEN=",
+      "UPSTASH_PREFIX=ck:ratelimit",
+      "",
+    );
+  }
+
+  if (hasIntegration(ctx, "better-auth")) {
+    lines.push(
+      "# Better Auth needs an app-owned database adapter and a shared AuthPort adapter before it can be wired.",
+      "BETTER_AUTH_SECRET=",
+      "BETTER_AUTH_URL=http://localhost:3000",
+      "",
+    );
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function layout(ctx: TemplateContext): string {
+  if (!hasFeature(ctx, "react-query")) {
+    return `import "./globals.css";
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+
+export const metadata: Metadata = {
+	title: "Beignet app",
+	description: "A contract-first Next.js app.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+	return (
+		<html lang="en">
+			<body>{children}</body>
+		</html>
+	);
+}
+`;
+  }
+
+  return `import "./globals.css";
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+import { Providers } from "./providers";
+
+export const metadata: Metadata = {
+	title: "Beignet app",
+	description: "A contract-first Next.js app.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+	return (
+		<html lang="en">
+			<body>
+				<Providers>{children}</Providers>
+			</body>
+		</html>
+	);
+}
+`;
+}
+
+function page(ctx: TemplateContext): string {
+  if (!hasFeature(ctx, "react-query")) {
+    return `export default function HomePage() {
+	return (
+		<main className="page">
+			<div className="shell">
+				<h1>Beignet app</h1>
+				<p className="muted">
+					This app starts with one contract-backed todos API route.
+				</p>
+
+				<section className="panel">
+					<h2>Try the API</h2>
+					<pre className="code">GET /api/todos</pre>
+					<p>
+						<a href="/api/todos">Open todos API</a>
+					</p>
+				</section>
+			</div>
+		</main>
+	);
+}
+`;
+  }
+
+  return `import { TodoApp } from "@/features/todos/components/todo-app";
+
+export default function HomePage() {
+	return (
+		<main className="page">
+			<div className="shell">
+				<header className="hero">
+					<p className="eyebrow">Beignet starter</p>
+					<h1>Type-safe full-stack workflows without codegen.</h1>
+					<p className="muted">
+						Contracts, use cases, ports, server routes, a typed client, React Query,
+						and form validation are wired together so you can start changing product
+						code immediately.
+					</p>
+				</header>
+
+				<TodoApp />
+			</div>
+		</main>
+	);
+}
+`;
+}
+
+function serverProviders(ctx: TemplateContext): string {
+  const imports: string[] = [];
+  const entries: string[] = [];
+
+  if (hasIntegration(ctx, "pino")) {
+    imports.push(
+      'import { loggerPinoProvider } from "@beignet/provider-logger-pino";',
+    );
+    entries.push("loggerPinoProvider");
+  }
+
+  if (hasIntegration(ctx, "inngest")) {
+    imports.push(
+      'import { inngestProvider } from "@beignet/provider-inngest";',
+    );
+    entries.push("inngestProvider");
+  }
+
+  if (hasIntegration(ctx, "resend")) {
+    imports.push(
+      'import { mailResendProvider } from "@beignet/provider-mail-resend";',
+    );
+    entries.push("mailResendProvider");
+  }
+
+  if (hasIntegration(ctx, "upstash-rate-limit")) {
+    imports.push(
+      'import { upstashRateLimitProvider } from "@beignet/provider-rate-limit-upstash";',
+    );
+    entries.push("upstashRateLimitProvider");
+  }
+
+  return `${imports.join("\n")}
+export const providers = [
+	${entries.join(",\n\t")},
+];
+`;
+}
+
+function server(ctx: TemplateContext): string {
+  const hasProviders = ctx.integrations.some((integration) =>
+    ["pino", "inngest", "resend", "upstash-rate-limit"].includes(integration),
+  );
+
+  return `import { createNextServer } from "@beignet/next";
+${hasProviders ? 'import { providers } from "./providers";\n' : ""}import { routes } from "./routes";
+import { appPorts, type AppPorts } from "@/ports";
+
+export type AppContext = {
+	requestId: string;
+	ports: AppPorts;
+};
+
+export const server = await createNextServer<AppContext, AppPorts>({
+	ports: appPorts,
+${hasProviders ? "\tproviders,\n" : ""}	createContext: async ({ ports }) => ({
+		requestId: crypto.randomUUID(),
+		ports,
+	}),
+	routes,
+	mapUnhandledError: ({ err, ctx }) => {
+		const ports = ctx?.ports as
+			| {
+					logger?: {
+						error: (
+							message: string,
+							meta?: Record<string, unknown>,
+						) => void;
+					};
+			  }
+			| undefined;
+
+		if (ports?.logger) {
+			const logger = ports.logger as {
+				error: (message: string, meta?: Record<string, unknown>) => void;
+			};
+			logger.error("Unhandled API error", {
+				error: err,
+				requestId: ctx?.requestId,
+			});
+		} else {
+			console.error("Unhandled API error", {
+				error: err,
+				requestId: ctx?.requestId,
+			});
+		}
+
+		return {
+			status: 500,
+			body: {
+				code: "INTERNAL_SERVER_ERROR",
+				message: "Internal server error",
+				requestId: ctx?.requestId,
+			},
+		};
+	},
+});
+`;
+}
+
+function todoApp(ctx: TemplateContext): string {
+  const listTodosQueryOptions =
+    ctx.preset === "standard" ? "{ query: {} }" : "";
+
+  if (hasFeature(ctx, "forms")) {
+    return `"use client";
+
+import { createReactHookForm } from "@beignet/react-hook-form";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createTodo, listTodos } from "@/features/todos/contracts";
+import { rq } from "@/client/rq";
+
+const rhf = createReactHookForm();
+const createTodoForm = rhf(createTodo);
+
+export function TodoApp() {
+	const queryClient = useQueryClient();
+	const todosQuery = useQuery(rq(listTodos).queryOptions(${listTodosQueryOptions}));
+	const form = createTodoForm.useForm({
+		defaultValues: { title: "" },
+	});
+	const createTodoMutation = useMutation(
+		rq(createTodo).mutationOptions({
+			onSuccess: async () => {
+				form.reset();
+				await queryClient.invalidateQueries({
+					queryKey: rq(listTodos).key(),
+				});
+			},
+		}),
+	);
+
+	const onSubmit = form.handleSubmit((body) => {
+		createTodoMutation.mutate({ body });
+	});
+
+	return (
+		<section className="workspace">
+			<form className="composer" onSubmit={onSubmit}>
+				<label htmlFor="todo-title">New todo</label>
+				<div className="composer-row">
+					<input
+						id="todo-title"
+						placeholder="Ship something type-safe"
+						{...form.register("title")}
+					/>
+					<button type="submit" disabled={createTodoMutation.isPending}>
+						{createTodoMutation.isPending ? "Adding" : "Add"}
+					</button>
+				</div>
+				{form.formState.errors.title ? (
+					<p className="error">{form.formState.errors.title.message}</p>
+				) : null}
+			</form>
+
+			<div className="todos-panel">
+				<div className="panel-heading">
+					<h2>Todos</h2>
+					<span>{todosQuery.data?.total ?? 0} total</span>
+				</div>
+				{todosQuery.isLoading ? <p className="muted">Loading todos...</p> : null}
+				{todosQuery.isError ? (
+					<p className="error">Could not load todos.</p>
+				) : null}
+				<ul className="todo-list">
+					{todosQuery.data?.todos.map((todo) => (
+						<li key={todo.id}>
+							<span>{todo.title}</span>
+							<small>{todo.completed ? "Done" : "Open"}</small>
+						</li>
+					))}
+				</ul>
+			</div>
+		</section>
+	);
+}
+`;
+  }
+
+  return `"use client";
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+import { createTodo, listTodos } from "@/features/todos/contracts";
+import { rq } from "@/client/rq";
+
+export function TodoApp() {
+	const [title, setTitle] = useState("");
+	const queryClient = useQueryClient();
+	const todosQuery = useQuery(rq(listTodos).queryOptions(${listTodosQueryOptions}));
+	const createTodoMutation = useMutation(
+		rq(createTodo).mutationOptions({
+			onSuccess: async () => {
+				setTitle("");
+				await queryClient.invalidateQueries({
+					queryKey: rq(listTodos).key(),
+				});
+			},
+		}),
+	);
+
+	return (
+		<section className="workspace">
+			<form
+				className="composer"
+				onSubmit={(event) => {
+					event.preventDefault();
+					createTodoMutation.mutate({ body: { title } });
+				}}
+			>
+				<label htmlFor="todo-title">New todo</label>
+				<div className="composer-row">
+					<input
+						id="todo-title"
+						value={title}
+						onChange={(event) => setTitle(event.currentTarget.value)}
+						placeholder="Ship something type-safe"
+					/>
+					<button type="submit" disabled={!title || createTodoMutation.isPending}>
+						{createTodoMutation.isPending ? "Adding" : "Add"}
+					</button>
+				</div>
+			</form>
+
+			<div className="todos-panel">
+				<div className="panel-heading">
+					<h2>Todos</h2>
+					<span>{todosQuery.data?.total ?? 0} total</span>
+				</div>
+				<ul className="todo-list">
+					{todosQuery.data?.todos.map((todo) => (
+						<li key={todo.id}>
+							<span>{todo.title}</span>
+							<small>{todo.completed ? "Done" : "Open"}</small>
+						</li>
+					))}
+				</ul>
+			</div>
+		</section>
+	);
+}
+`;
+}
+
+const files = {
+  gitignore: `.next
+node_modules
+dist
+coverage
+.env
+.env.local
+`,
+  nextEnv: `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// This file should not be edited.
+`,
+  nextConfig: `/** @type {import("next").NextConfig} */
+const nextConfig = {};
+
+export default nextConfig;
+`,
+  tsconfig: json({
+    compilerOptions: {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "react-jsx",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: {
+        "@/*": ["./*"],
+      },
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"],
+  }),
+  globals: `:root {
+	color-scheme: light;
+	background: #f8fafc;
+	color: #172033;
+	font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* {
+	box-sizing: border-box;
+}
+
+body {
+	margin: 0;
+}
+
+a {
+	color: #4f46e5;
+}
+
+button,
+input {
+	font: inherit;
+}
+
+.page {
+	min-height: 100vh;
+	padding: 48px 24px 64px;
+}
+
+.shell {
+	max-width: 880px;
+	margin: 0 auto;
+}
+
+.hero {
+	margin-bottom: 28px;
+}
+
+.hero h1 {
+	max-width: 720px;
+	margin: 0 0 12px;
+	font-size: 40px;
+	line-height: 1.05;
+	letter-spacing: 0;
+}
+
+.eyebrow {
+	margin: 0 0 12px;
+	color: #4f46e5;
+	font-size: 13px;
+	font-weight: 700;
+	text-transform: uppercase;
+	letter-spacing: 0.12em;
+}
+
+.muted {
+	color: #475569;
+}
+
+.panel {
+	margin-top: 24px;
+	padding: 20px;
+	border: 1px solid #e2e8f0;
+	border-radius: 8px;
+	background: white;
+}
+
+.code {
+	padding: 16px;
+	overflow-x: auto;
+	border-radius: 8px;
+	background: #111827;
+	color: #f8fafc;
+}
+
+.workspace {
+	display: grid;
+	gap: 18px;
+}
+
+.composer,
+.todos-panel {
+	padding: 18px;
+	border: 1px solid #dbe3ef;
+	border-radius: 8px;
+	background: #ffffff;
+	box-shadow: 0 1px 2px rgb(15 23 42 / 0.05);
+}
+
+.composer label,
+.panel-heading h2 {
+	margin: 0;
+	color: #172033;
+	font-size: 15px;
+	font-weight: 700;
+}
+
+.composer-row {
+	display: flex;
+	gap: 10px;
+	margin-top: 10px;
+}
+
+.composer input {
+	width: 100%;
+	min-width: 0;
+	border: 1px solid #cbd5e1;
+	border-radius: 8px;
+	padding: 10px 12px;
+	color: #172033;
+}
+
+.composer button {
+	border: 0;
+	border-radius: 8px;
+	padding: 10px 14px;
+	background: #4f46e5;
+	color: #ffffff;
+	font-weight: 700;
+	cursor: pointer;
+}
+
+.composer button:disabled {
+	cursor: not-allowed;
+	opacity: 0.6;
+}
+
+.panel-heading {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 16px;
+	margin-bottom: 12px;
+}
+
+.panel-heading span {
+	color: #64748b;
+	font-size: 13px;
+}
+
+.todo-list {
+	display: grid;
+	gap: 8px;
+	margin: 0;
+	padding: 0;
+	list-style: none;
+}
+
+.todo-list li {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 16px;
+	padding: 12px;
+	border: 1px solid #e2e8f0;
+	border-radius: 8px;
+	background: #f8fafc;
+}
+
+.todo-list small {
+	color: #64748b;
+}
+
+.error {
+	margin: 10px 0 0;
+	color: #dc2626;
+	font-size: 14px;
+}
+
+@media (max-width: 640px) {
+	.page {
+		padding: 32px 16px 48px;
+	}
+
+	.hero h1 {
+		font-size: 32px;
+	}
+
+	.composer-row {
+		flex-direction: column;
+	}
+}
+`,
+  appProviders: `"use client";
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { type ReactNode, useState } from "react";
+
+export function Providers({ children }: { children: ReactNode }) {
+	const [queryClient] = useState(() => new QueryClient());
+
+	return (
+		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+	);
+}
+`,
+  apiClient: `import { createNextClient } from "@beignet/next";
+
+export const apiClient = createNextClient({
+	validate: true,
+});
+`,
+  rq: `import { createReactQuery } from "@beignet/react-query";
+import { apiClient } from "./api-client";
+
+export const rq = createReactQuery(apiClient);
+`,
+  contractsTodos: `import { createContractGroup } from "@beignet/core/contracts";
+import { z } from "zod";
+
+const todos = createContractGroup().namespace("todos");
+
+export const TodoSchema = z.object({
+	id: z.string(),
+	title: z.string().min(1),
+	completed: z.boolean(),
+	createdAt: z.string(),
+});
+
+export const CreateTodoSchema = z.object({
+	title: z.string().min(1),
+});
+
+export const listTodos = todos.get("/api/todos").responses({
+	200: z.object({
+		todos: z.array(TodoSchema),
+		total: z.number(),
+	}),
+});
+
+export const createTodo = todos
+	.post("/api/todos")
+	.body(CreateTodoSchema)
+	.responses({
+		201: TodoSchema,
+	});
+`,
+  ports: `import { definePorts } from "@beignet/core/ports";
+import type { z } from "zod";
+import type { CreateTodoSchema, TodoSchema } from "@/features/todos/contracts";
+
+export type Todo = z.infer<typeof TodoSchema>;
+export type CreateTodoInput = z.infer<typeof CreateTodoSchema>;
+
+const todos = new Map<string, Todo>();
+
+function createTodo(input: CreateTodoInput): Todo {
+	const todo = {
+		id: crypto.randomUUID(),
+		title: input.title,
+		completed: false,
+		createdAt: new Date().toISOString(),
+	};
+	todos.set(todo.id, todo);
+	return todo;
+}
+
+createTodo({ title: "Read the generated contract" });
+createTodo({ title: "Add your first use case" });
+
+export const appPorts = definePorts({
+	todos: {
+		list: async () => Array.from(todos.values()),
+		create: async (input: CreateTodoInput) => createTodo(input),
+	},
+});
+
+export type AppPorts = typeof appPorts;
+`,
+  useCasesTodos: `import { createUseCase } from "@beignet/core/application";
+import { z } from "zod";
+import { CreateTodoSchema, TodoSchema } from "@/features/todos/contracts";
+import type { AppPorts } from "@/ports";
+
+type AppContext = {
+	requestId: string;
+	ports: AppPorts;
+};
+
+const useCase = createUseCase<AppContext>();
+
+export const ListTodosOutputSchema = z.object({
+	todos: z.array(TodoSchema),
+	total: z.number(),
+});
+
+export const listTodos = useCase
+	.query("listTodos")
+	.input(z.void())
+	.output(ListTodosOutputSchema)
+	.run(async ({ ctx }) => {
+		const todos = await ctx.ports.todos.list();
+		return { todos, total: todos.length };
+	});
+
+export const createTodo = useCase
+	.command("createTodo")
+	.input(CreateTodoSchema)
+	.output(TodoSchema)
+	.run(async ({ ctx, input }) => ctx.ports.todos.create(input));
+`,
+  todoRoutes: `import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "@/server";
+import { createTodo, listTodos } from "@/features/todos/use-cases";
+import * as contracts from "@/features/todos/contracts";
+
+export const todoRoutes = defineRouteGroup<AppContext>({
+	name: "todos",
+	routes: [
+		{
+			contract: contracts.listTodos,
+			handle: async ({ ctx }) => ({
+				status: 200,
+				body: await listTodos.run({ ctx, input: undefined }),
+			}),
+		},
+		{
+			contract: contracts.createTodo,
+			handle: async ({ ctx, body }) => ({
+				status: 201,
+				body: await createTodo.run({ ctx, input: body }),
+			}),
+		},
+	],
+});
+`,
+  serverRoutes: `import { contractsFromRoutes, defineRoutes } from "@beignet/next";
+import type { AppContext } from "@/server";
+import { todoRoutes } from "@/features/todos/routes";
+
+export const routes = defineRoutes<AppContext>([
+	todoRoutes,
+]);
+export const contracts = contractsFromRoutes(routes);
+`,
+  apiCatchAllRoute: `import { server } from "@/server";
+
+export const GET = server.api;
+export const HEAD = server.api;
+export const OPTIONS = server.api;
+export const PATCH = server.api;
+export const POST = server.api;
+export const PUT = server.api;
+export const DELETE = server.api;
+`,
+  apiOpenApiRoute: `import { createOpenAPIHandler } from "@beignet/next";
+import { server } from "@/server";
+
+export const GET = createOpenAPIHandler(server.contracts, {
+	title: "Beignet starter API",
+	version: "0.1.0",
+});
+`,
+  productionEnv: `import { createEnv } from "@beignet/core/config";
+import { z } from "zod";
+
+const BooleanEnv = z.enum(["true", "false"]).transform((value) => value === "true");
+
+export const env = createEnv({
+	server: {
+		NODE_ENV: z
+			.enum(["development", "test", "production"])
+			.default("development"),
+		APP_URL: z.string().url().default("http://localhost:3000"),
+		CRON_SECRET: z.string().min(1).optional(),
+		DEVTOOLS_ENABLED: BooleanEnv.optional(),
+		LOG_LEVEL: z
+			.enum(["trace", "debug", "info", "warn", "error", "fatal"])
+			.default("info"),
+		LOG_FORMAT: z.enum(["pretty", "json"]).default("json"),
+		LOG_SERVICE: z.string().default("beignet-app"),
+	},
+	runtimeEnv: process.env,
+});
+
+export const isProduction = env.NODE_ENV === "production";
+`,
+  productionAppContext: `import type { DevtoolsPort, DevtoolsTraceContext } from "@beignet/devtools";
+import type { ActivityActor, ActivityTenant, StoragePort } from "@beignet/core/ports";
+import type { AppGate, AppPorts } from "@/ports";
+import type { AuthSession } from "@/ports/auth";
+
+export type AppContext = {
+	requestId: string;
+	actor: ActivityActor;
+	auth: AuthSession | null;
+	gate: AppGate;
+	ports: AppPorts & {
+		devtools: DevtoolsPort;
+		storage: StoragePort;
+	};
+	tenant?: ActivityTenant;
+} & Partial<DevtoolsTraceContext>;
+`,
+  productimapUnhandledErrors: `import { createAppError, defineErrors } from "@beignet/core/errors";
+
+export const errors = defineErrors({
+	Unauthorized: {
+		code: "UNAUTHORIZED",
+		status: 401,
+		message: "Authentication required",
+	},
+	Forbidden: {
+		code: "FORBIDDEN",
+		status: 403,
+		message: "Forbidden",
+	},
+	TodoNotFound: {
+		code: "TODO_NOT_FOUND",
+		status: 404,
+		message: "Todo not found",
+	},
+});
+
+export const appError = createAppError(errors);
+`,
+  productionTodoSchemas: `import { z } from "zod";
+
+export const TodoSchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().min(1),
+	completed: z.boolean(),
+	createdAt: z.string().datetime(),
+});
+
+export const ListTodosInputSchema = z.object({
+	limit: z.coerce.number().int().min(1).max(100).default(20),
+	offset: z.coerce.number().int().min(0).default(0),
+});
+
+export const ListTodosOutputSchema = z.object({
+	todos: z.array(TodoSchema),
+	total: z.number().int().min(0),
+	limit: z.number().int().min(1),
+	offset: z.number().int().min(0),
+});
+
+export const GetTodoInputSchema = z.object({
+	id: z.string().uuid(),
+});
+
+export const CreateTodoInputSchema = z.object({
+	title: z.string().min(1).max(120),
+});
+
+export type Todo = z.infer<typeof TodoSchema>;
+export type CreateTodoInput = z.infer<typeof CreateTodoInputSchema>;
+export type ListTodosInput = z.infer<typeof ListTodosInputSchema>;
+`,
+  productionUseCaseBuilder: `import { createUseCase } from "@beignet/core/application";
+import { createDevtoolsUseCaseObserver } from "@beignet/devtools";
+import type { AppContext } from "@/app-context";
+
+export const useCase = createUseCase<AppContext>({
+	onRun: createDevtoolsUseCaseObserver<AppContext>(),
+});
+`,
+  productionAuthHelpers: `import type { AppContext } from "@/app-context";
+import type { AuthSession, AuthUser } from "@/ports/auth";
+import { appError } from "@/features/shared/errors";
+
+export function requireSession(ctx: AppContext): AuthSession {
+	if (!ctx.auth) {
+		throw appError("Unauthorized");
+	}
+
+	return ctx.auth;
+}
+
+export function requireUser(ctx: AppContext): AuthUser {
+	return requireSession(ctx).user;
+}
+`,
+  productionListTodosUseCase: `import { useCase } from "@/lib/use-case";
+import { ListTodosInputSchema, ListTodosOutputSchema } from "./schemas";
+
+export const listTodosUseCase = useCase
+	.query("todos.list")
+	.input(ListTodosInputSchema)
+	.output(ListTodosOutputSchema)
+	.run(async ({ ctx, input }) => {
+		const result = await ctx.ports.todos.list(input);
+		return {
+			todos: result.todos,
+			total: result.total,
+			limit: input.limit,
+			offset: input.offset,
+		};
+	});
+`,
+  productionGetTodoUseCase: `import { appError } from "@/features/shared/errors";
+import { useCase } from "@/lib/use-case";
+import { GetTodoInputSchema, TodoSchema } from "./schemas";
+
+export const getTodoUseCase = useCase
+	.query("todos.get")
+	.input(GetTodoInputSchema)
+	.output(TodoSchema)
+	.run(async ({ ctx, input }) => {
+		const todo = await ctx.ports.todos.findById(input.id);
+		if (!todo) {
+			throw appError("TodoNotFound", { details: { id: input.id } });
+		}
+
+		return todo;
+	});
+`,
+  productionCreateTodoUseCase: `import { useCase } from "@/lib/use-case";
+import { CreateTodoInputSchema, TodoSchema } from "./schemas";
+
+export const createTodoUseCase = useCase
+	.command("todos.create")
+	.input(CreateTodoInputSchema)
+	.output(TodoSchema)
+	.run(async ({ ctx, input }) => {
+		await ctx.gate.authorize("todos.create");
+		return ctx.ports.uow.transaction((tx) => tx.todos.create(input));
+	});
+`,
+  productionUseCasesIndex: `export { createTodoUseCase } from "./create-todo";
+export { getTodoUseCase } from "./get-todo";
+export { listTodosUseCase } from "./list-todos";
+export {
+	CreateTodoInputSchema,
+	GetTodoInputSchema,
+	ListTodosInputSchema,
+	ListTodosOutputSchema,
+	TodoSchema,
+	type CreateTodoInput,
+	type ListTodosInput,
+	type Todo,
+} from "./schemas";
+`,
+  productionTodoRepositoryPort: `import type {
+	CreateTodoInput,
+	ListTodosInput,
+	Todo,
+} from "@/features/todos/use-cases/schemas";
+
+export type ListTodosResult = {
+	todos: Todo[];
+	total: number;
+};
+
+export interface TodoRepository {
+	list(input: ListTodosInput): Promise<ListTodosResult>;
+	findById(id: string): Promise<Todo | null>;
+	create(input: CreateTodoInput): Promise<Todo>;
+}
+`,
+  productionAuthPort: `import type {
+	AuthPort as BeignetAuthPort,
+	AuthRequestLike,
+	AuthSession as BeignetAuthSession,
+} from "@beignet/core/ports";
+
+export type AuthRequest = AuthRequestLike;
+
+export type AuthUser = {
+	id: string;
+	email?: string;
+	name?: string;
+};
+
+export type AuthSessionMetadata = {
+	id?: string;
+};
+
+export type AuthSession = BeignetAuthSession<
+	AuthUser,
+	AuthSessionMetadata
+>;
+
+export type AuthPort = BeignetAuthPort<
+	AuthUser,
+	AuthSessionMetadata,
+	AuthRequest
+>;
+`,
+  productionLogger: `import type { LoggerPort } from "@beignet/core/ports";
+
+export const fallbackLogger: LoggerPort = {
+	trace: (message, meta) => console.trace(message, meta),
+	debug: (message, meta) => console.debug(message, meta),
+	info: (message, meta) => console.info(message, meta),
+	warn: (message, meta) => console.warn(message, meta),
+	error: (message, meta) => console.error(message, meta),
+	fatal: (message, meta) => console.error(message, meta),
+	child: () => fallbackLogger,
+};
+`,
+  productionAnonymousAuth: `import { createAnonymousAuth as createAnonymousAuthPort } from "@beignet/core/ports";
+import type {
+	AuthPort,
+	AuthRequest,
+	AuthSessionMetadata,
+	AuthUser,
+} from "@/ports/auth";
+
+export function createAnonymousAuth(): AuthPort {
+	return createAnonymousAuthPort<AuthUser, AuthSessionMetadata, AuthRequest>();
+}
+`,
+  productionTodoPolicy: `import { type ActivityActor, definePolicy, deny } from "@beignet/core/ports";
+import type { AuthSession } from "@/ports/auth";
+
+export type AuthorizationContext = {
+	actor: ActivityActor;
+	auth: AuthSession | null;
+};
+
+export const todoPolicy = definePolicy({
+	"todos.create": (ctx: AuthorizationContext) => {
+		if (ctx.actor.type === "user") return true;
+		return deny("You must be signed in to create todos.");
+	},
+});
+`,
+  productionInMemoryTodoRepository: `import type {
+	CreateTodoInput,
+	ListTodosInput,
+	Todo,
+} from "@/features/todos/use-cases/schemas";
+import type { TodoRepository } from "@/features/todos/ports";
+
+export function createInMemoryTodoRepository(
+	seed: Todo[] = [],
+): TodoRepository {
+	const todos = new Map(seed.map((todo) => [todo.id, todo]));
+
+	return {
+		async list(input: ListTodosInput) {
+			const allTodos = Array.from(todos.values()).sort((left, right) =>
+				left.createdAt.localeCompare(right.createdAt),
+			);
+
+			return {
+				todos: allTodos.slice(input.offset, input.offset + input.limit),
+				total: allTodos.length,
+			};
+		},
+		async findById(id: string) {
+			return todos.get(id) ?? null;
+		},
+		async create(input: CreateTodoInput) {
+			const todo: Todo = {
+				id: crypto.randomUUID(),
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			todos.set(todo.id, todo);
+			return todo;
+		},
+	};
+}
+`,
+  productionInfrastructurePorts: `import {
+	createGate,
+	createNoopUnitOfWork,
+	definePorts,
+} from "@beignet/core/ports";
+import { todoPolicy } from "@/features/todos/policy";
+import { appError } from "@/features/shared/errors";
+import { createAnonymousAuth } from "./auth/anonymous-auth";
+import { fallbackLogger } from "./logger";
+import { createInMemoryTodoRepository } from "./todos/in-memory-todo-repository";
+
+const todos = createInMemoryTodoRepository([
+	{
+		id: "00000000-0000-4000-8000-000000000001",
+		title: "Review the starter boundaries",
+		completed: false,
+		createdAt: new Date().toISOString(),
+	},
+	{
+		id: "00000000-0000-4000-8000-000000000002",
+		title: "Replace the repository with durable persistence",
+		completed: false,
+		createdAt: new Date().toISOString(),
+	},
+]);
+
+const gate = createGate({
+	policies: [todoPolicy],
+	onDeny(decision) {
+		return appError("Forbidden", {
+			message: decision.reason ?? "Forbidden",
+			details: decision.details,
+		});
+	},
+});
+
+export const appPorts = definePorts({
+	auth: createAnonymousAuth(),
+	gate,
+	todos,
+	logger: fallbackLogger,
+	uow: createNoopUnitOfWork(() => ({
+		todos,
+	})),
+});
+`,
+  productionInfrastructurePortsWithDrizzleTurso: `import { createGate, definePorts } from "@beignet/core/ports";
+import { todoPolicy } from "@/features/todos/policy";
+import { appError } from "@/features/shared/errors";
+import { createAnonymousAuth } from "./auth/anonymous-auth";
+import { fallbackLogger } from "./logger";
+
+const gate = createGate({
+	policies: [todoPolicy],
+	onDeny(decision) {
+		return appError("Forbidden", {
+			message: decision.reason ?? "Forbidden",
+			details: decision.details,
+		});
+	},
+});
+
+export const appPorts = definePorts({
+	auth: createAnonymousAuth(),
+	gate,
+	logger: fallbackLogger,
+});
+`,
+  productionDrizzleConfig: `export default {
+	schema: "./infra/db/schema/index.ts",
+	out: "./drizzle",
+	dialect: "sqlite",
+	dbCredentials: {
+		url: process.env.TURSO_DB_URL ?? "file:local.db",
+		authToken: process.env.TURSO_DB_AUTH_TOKEN,
+	},
+};
+`,
+  productionDbSchema: `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const todos = sqliteTable("todos", {
+	id: text("id").primaryKey(),
+	title: text("title").notNull(),
+	completed: integer("completed", { mode: "boolean" }).notNull().default(false),
+	createdAt: text("created_at").notNull(),
+});
+`,
+  productionDrizzleTodoRepository: `import { count, desc, eq } from "drizzle-orm";
+import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import type { TodoRepository } from "@/features/todos/ports";
+import type {
+	CreateTodoInput,
+	ListTodosInput,
+	Todo,
+} from "@/features/todos/use-cases/schemas";
+import * as schema from "@/infra/db/schema";
+
+type TodoRow = typeof schema.todos.$inferSelect;
+
+function toTodo(row: TodoRow): Todo {
+	return {
+		id: row.id,
+		title: row.title,
+		completed: row.completed,
+		createdAt: row.createdAt,
+	};
+}
+
+export function createDrizzleTodoRepository(
+	db: DrizzleTursoDatabase<typeof schema>,
+): TodoRepository {
+	return {
+		async list(input: ListTodosInput) {
+			const rows = await db
+				.select()
+				.from(schema.todos)
+				.orderBy(desc(schema.todos.createdAt))
+				.limit(input.limit)
+				.offset(input.offset);
+			const [{ total }] = await db.select({ total: count() }).from(schema.todos);
+
+			return {
+				todos: rows.map(toTodo),
+				total,
+			};
+		},
+		async findById(id: string) {
+			const [row] = await db
+				.select()
+				.from(schema.todos)
+				.where(eq(schema.todos.id, id))
+				.limit(1);
+
+			return row ? toTodo(row) : null;
+		},
+		async create(input: CreateTodoInput) {
+			const todo = {
+				id: crypto.randomUUID(),
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			const [row] = await db.insert(schema.todos).values(todo).returning();
+
+			if (!row) {
+				throw new Error("Failed to create todo");
+			}
+
+			return toTodo(row);
+		},
+	};
+}
+`,
+  productionDbRepositories: `import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
+import type { AppTransactionPorts } from "@/ports";
+import * as schema from "./schema";
+
+export function createRepositories(
+	db: DrizzleTursoDatabase<typeof schema>,
+): Omit<AppTransactionPorts, "events"> {
+	return {
+		todos: createDrizzleTodoRepository(db),
+	};
+}
+`,
+  productionContractsTodos: `import { createContractGroup } from "@beignet/core/contracts";
+import { z } from "zod";
+import { errors } from "@/features/shared/errors";
+import {
+	createTodoUseCase,
+	getTodoUseCase,
+	listTodosUseCase,
+} from "@/features/todos/use-cases";
+
+const ErrorResponseSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	requestId: z.string().optional(),
+});
+
+const todos = createContractGroup()
+	.namespace("todos")
+	.errors({ Unauthorized: errors.Unauthorized })
+	.responses({
+		500: ErrorResponseSchema,
+	});
+
+export const listTodos = todos
+	.get("/api/todos")
+	.query(listTodosUseCase.inputSchema)
+	.responses({
+		200: listTodosUseCase.outputSchema,
+	});
+
+export const createTodo = todos
+	.post("/api/todos")
+	.body(createTodoUseCase.inputSchema)
+	.errors({ Forbidden: errors.Forbidden })
+	.responses({
+		201: createTodoUseCase.outputSchema,
+	});
+
+export const getTodo = todos
+	.get("/api/todos/:id")
+	.pathParams(getTodoUseCase.inputSchema)
+	.errors({ TodoNotFound: errors.TodoNotFound })
+	.responses({
+		200: getTodoUseCase.outputSchema,
+	});
+`,
+  productionTodoRoutes: `import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "@/app-context";
+import { createTodo, getTodo, listTodos } from "@/features/todos/contracts";
+import {
+	createTodoUseCase,
+	getTodoUseCase,
+	listTodosUseCase,
+} from "@/features/todos/use-cases";
+
+export const todoRoutes = defineRouteGroup<AppContext>({
+	name: "todos",
+	routes: [
+		{
+			contract: listTodos,
+			handle: async ({ ctx, query }) => ({
+				status: 200,
+				body: await listTodosUseCase.run({ ctx, input: query }),
+			}),
+		},
+		{
+			contract: createTodo,
+			handle: async ({ ctx, body }) => ({
+				status: 201,
+				body: await createTodoUseCase.run({ ctx, input: body }),
+			}),
+		},
+		{
+			contract: getTodo,
+			handle: async ({ ctx, path }) => ({
+				status: 200,
+				body: await getTodoUseCase.run({ ctx, input: path }),
+			}),
+		},
+	],
+});
+`,
+  productionServerRoutes: `import { contractsFromRoutes, defineRoutes } from "@beignet/next";
+import type { AppContext } from "@/app-context";
+import { todoRoutes } from "@/features/todos/routes";
+
+export const routes = defineRoutes<AppContext>([
+	todoRoutes,
+]);
+export const contracts = contractsFromRoutes(routes);
+`,
+  productionServer: `import { createDevtoolsHooks } from "@beignet/devtools";
+import { createNextServer } from "@beignet/next";
+import {
+	createAnonymousActor,
+	createTenant,
+	createUserActor,
+} from "@beignet/core/ports";
+import type { AppContext } from "@/app-context";
+import { appPorts } from "@/infra/app-ports";
+import { env } from "@/lib/env";
+import { providers } from "./providers";
+import { routes } from "./routes";
+
+export const server = await createNextServer({
+	ports: appPorts,
+	providers,
+	hooks: [
+		createDevtoolsHooks<AppContext>({
+			requestIdHeader: "x-request-id",
+		}),
+	],
+	createContext: async ({ req, ports }) => {
+		const auth = await ports.auth.getSession(req);
+		const tenantId = req.headers.get("x-tenant-id") || undefined;
+		const context = {
+			requestId: req.headers.get("x-request-id") ?? crypto.randomUUID(),
+			actor: auth
+				? createUserActor(auth.user.id, { displayName: auth.user.name })
+				: createAnonymousActor(),
+			auth,
+			ports,
+			tenant: tenantId ? createTenant(tenantId) : undefined,
+		};
+
+		return {
+			...context,
+			gate: ports.gate.bind(context),
+		};
+	},
+	routes,
+	mapUnhandledError: ({ err, ctx }) => {
+		ctx?.ports.logger.error("Unhandled API error", {
+			error: err,
+			requestId: ctx?.requestId,
+			environment: env.NODE_ENV,
+		});
+
+		return {
+			status: 500,
+			body: {
+				code: "INTERNAL_SERVER_ERROR",
+				message: "Internal server error",
+				requestId: ctx?.requestId,
+			},
+		};
+	},
+});
+`,
+  productionServerWithDrizzleTurso: `import { createDevtoolsHooks } from "@beignet/devtools";
+import { createNextServer } from "@beignet/next";
+import {
+	createAnonymousActor,
+	createTenant,
+	createUserActor,
+} from "@beignet/core/ports";
+import { createDrizzleTursoUnitOfWork } from "@beignet/provider-drizzle-turso";
+import type { AppContext } from "@/app-context";
+import { appPorts } from "@/infra/app-ports";
+import * as schema from "@/infra/db/schema";
+import { createRepositories } from "@/infra/db/repositories";
+import { env } from "@/lib/env";
+import type { AppTransactionPorts } from "@/ports";
+import { providers } from "./providers";
+import { routes } from "./routes";
+
+export const server = await createNextServer({
+	ports: appPorts,
+	providers,
+	hooks: [
+		createDevtoolsHooks<AppContext>({
+			requestIdHeader: "x-request-id",
+		}),
+	],
+	createContext: async ({ req, ports }) => {
+		const auth = await ports.auth.getSession(req);
+		const tenantId = req.headers.get("x-tenant-id") || undefined;
+		const repositories = createRepositories(ports.db.db);
+
+		const context = {
+			requestId: req.headers.get("x-request-id") ?? crypto.randomUUID(),
+			actor: auth
+				? createUserActor(auth.user.id, { displayName: auth.user.name })
+				: createAnonymousActor(),
+			auth,
+			ports: {
+				...ports,
+				...repositories,
+				uow: createDrizzleTursoUnitOfWork<typeof schema, AppTransactionPorts>({
+					db: ports.db.db,
+					createTransactionPorts: (tx) => ({
+						...createRepositories(tx),
+					}),
+				}),
+			},
+			tenant: tenantId ? createTenant(tenantId) : undefined,
+		};
+
+		return {
+			...context,
+			gate: ports.gate.bind(context),
+		};
+	},
+	routes,
+	mapUnhandledError: ({ err, ctx }) => {
+		ctx?.ports.logger.error("Unhandled API error", {
+			error: err,
+			requestId: ctx?.requestId,
+			environment: env.NODE_ENV,
+		});
+
+		return {
+			status: 500,
+			body: {
+				code: "INTERNAL_SERVER_ERROR",
+				message: "Internal server error",
+				requestId: ctx?.requestId,
+			},
+		};
+	},
+});
+`,
+  productionApiCatchAllRoute: `import { server } from "@/server";
+
+export const GET = server.api;
+export const HEAD = server.api;
+export const OPTIONS = server.api;
+export const PATCH = server.api;
+export const POST = server.api;
+export const PUT = server.api;
+export const DELETE = server.api;
+`,
+  productionHealthRoute: `import { env } from "@/lib/env";
+
+export function GET() {
+	return Response.json(
+		{
+			status: "ok",
+			environment: env.NODE_ENV,
+			timestamp: new Date().toISOString(),
+		},
+		{
+			headers: {
+				"cache-control": "no-store",
+			},
+		},
+	);
+}
+`,
+  productionDevtoolsRoute: `import { createDevtoolsRoute } from "@beignet/devtools";
+import { server } from "@/server";
+
+export const { GET, POST } = createDevtoolsRoute(server.ports.devtools, {
+	basePath: "/api/devtools",
+});
+`,
+  productionStorageRoute: `import { createStorageRoute } from "@beignet/next";
+import { server } from "@/server";
+
+export const { GET, HEAD } = createStorageRoute(server.ports.storage, {
+	basePath: "/storage",
+});
+`,
+  productionOpenApiRoute: `import { createOpenAPIHandler } from "@beignet/next";
+import { server } from "@/server";
+
+export const GET = createOpenAPIHandler(server.contracts, {
+	title: "Beignet starter API",
+	version: "0.1.0",
+});
+`,
+};
+
+function productionProviderPortImports(ctx: TemplateContext): string[] {
+  const imports: string[] = [];
+  if (hasIntegration(ctx, "inngest")) imports.push("\tJobDispatcherPort,");
+  if (hasIntegration(ctx, "upstash-rate-limit")) {
+    imports.push("\tRateLimitPort,");
+  }
+  return imports;
+}
+
+function productionProviderPortFields(ctx: TemplateContext): string[] {
+  const fields: string[] = [];
+  if (hasIntegration(ctx, "inngest")) fields.push("\tjobs: JobDispatcherPort;");
+  if (hasIntegration(ctx, "resend")) fields.push("\tmailer: MailerPort;");
+  if (hasIntegration(ctx, "upstash-rate-limit")) {
+    fields.push("\trateLimit: RateLimitPort;");
+  }
+  return fields;
+}
+
+function productionPorts(ctx: TemplateContext): string {
+  const mailImport = hasIntegration(ctx, "resend")
+    ? 'import type { MailerPort } from "@beignet/core/mail";\n'
+    : "";
+  const imports = [
+    "\tBoundGate,",
+    "\tGatePort,",
+    "\tLoggerPort,",
+    ...productionProviderPortImports(ctx),
+    "\tUnitOfWorkPort,",
+  ];
+  const providerFields = productionProviderPortFields(ctx);
+
+  return `import type {
+${imports.join("\n")}
+} from "@beignet/core/ports";
+${mailImport}import type { AuthorizationContext, todoPolicy } from "@/features/todos/policy";
+import type { AuthPort } from "./auth";
+import type { TodoRepository } from "@/features/todos/ports";
+
+export type AppTransactionPorts = {
+	todos: TodoRepository;
+};
+
+export type AppGate = BoundGate<[typeof todoPolicy]>;
+
+export type AppPorts = {
+	auth: AuthPort;
+	gate: GatePort<AuthorizationContext, [typeof todoPolicy]>;
+	todos: TodoRepository;
+	logger: LoggerPort;
+${providerFields.length > 0 ? `${providerFields.join("\n")}\n` : ""}	uow: UnitOfWorkPort<AppTransactionPorts>;
+};
+`;
+}
+
+function productionPortsWithDrizzleTurso(ctx: TemplateContext): string {
+  const mailImport = hasIntegration(ctx, "resend")
+    ? 'import type { MailerPort } from "@beignet/core/mail";\n'
+    : "";
+  const imports = [
+    "\tBoundGate,",
+    "\tGatePort,",
+    "\tLoggerPort,",
+    ...productionProviderPortImports(ctx),
+    "\tUnitOfWorkPort,",
+  ];
+  const providerFields = productionProviderPortFields(ctx);
+
+  return `import type {
+${imports.join("\n")}
+} from "@beignet/core/ports";
+${mailImport}import type { DbPort } from "@beignet/provider-drizzle-turso";
+import * as schema from "@/infra/db/schema";
+import type { AuthorizationContext, todoPolicy } from "@/features/todos/policy";
+import type { AuthPort } from "./auth";
+import type { TodoRepository } from "@/features/todos/ports";
+
+export type AppTransactionPorts = {
+	todos: TodoRepository;
+};
+
+export type AppGate = BoundGate<[typeof todoPolicy]>;
+
+export type AppPorts = {
+	auth: AuthPort;
+	db: DbPort<typeof schema>;
+	gate: GatePort<AuthorizationContext, [typeof todoPolicy]>;
+	todos: TodoRepository;
+	logger: LoggerPort;
+${providerFields.length > 0 ? `${providerFields.join("\n")}\n` : ""}	uow: UnitOfWorkPort<AppTransactionPorts>;
+};
+`;
+}
+
+function productionServerProviders(ctx: TemplateContext): string {
+  const imports = [
+    'import { createDevtoolsProvider } from "@beignet/devtools";',
+    hasDrizzleTurso(ctx)
+      ? 'import { createDrizzleTursoProvider } from "@beignet/provider-drizzle-turso";'
+      : undefined,
+    hasIntegration(ctx, "inngest")
+      ? 'import { inngestProvider } from "@beignet/provider-inngest";'
+      : undefined,
+    'import { loggerPinoProvider } from "@beignet/provider-logger-pino";',
+    hasIntegration(ctx, "resend")
+      ? 'import { mailResendProvider } from "@beignet/provider-mail-resend";'
+      : undefined,
+    'import { localStorageProvider } from "@beignet/provider-storage-local";',
+    hasIntegration(ctx, "upstash-rate-limit")
+      ? 'import { upstashRateLimitProvider } from "@beignet/provider-rate-limit-upstash";'
+      : undefined,
+    hasDrizzleTurso(ctx)
+      ? 'import * as schema from "@/infra/db/schema";'
+      : undefined,
+  ].filter((line): line is string => Boolean(line));
+
+  const declarations = hasDrizzleTurso(ctx)
+    ? "\nconst drizzleTursoProvider = createDrizzleTursoProvider({ schema });\n"
+    : "";
+  const entries = [
+    "\tcreateDevtoolsProvider(),",
+    "\tlocalStorageProvider,",
+    "\tloggerPinoProvider,",
+    hasDrizzleTurso(ctx) ? "\tdrizzleTursoProvider," : undefined,
+    hasIntegration(ctx, "inngest") ? "\tinngestProvider," : undefined,
+    hasIntegration(ctx, "resend") ? "\tmailResendProvider," : undefined,
+    hasIntegration(ctx, "upstash-rate-limit")
+      ? "\tupstashRateLimitProvider,"
+      : undefined,
+  ].filter((entry): entry is string => Boolean(entry));
+
+  return `${imports.join("\n")}
+${declarations}
+export const providers = [
+${entries.join("\n")}
+];
+`;
+}
+
+function productionTodosTest(ctx: TemplateContext): string {
+  const portImports = [
+    hasIntegration(ctx, "upstash-rate-limit")
+      ? "createMemoryRateLimiter"
+      : undefined,
+    "createMemoryStorage",
+    "createNoopUnitOfWork",
+    "createUserActor",
+  ].filter((item): item is string => Boolean(item));
+  const extraPorts = [
+    hasDrizzleTurso(ctx)
+      ? "\t\t\tdb: { db: undefined as never, client: undefined as never },"
+      : undefined,
+    hasIntegration(ctx, "inngest")
+      ? "\t\t\tjobs: { dispatch: async () => undefined },"
+      : undefined,
+    hasIntegration(ctx, "resend")
+      ? '\t\t\tmailer: { send: async () => ({ provider: "test" }) },'
+      : undefined,
+    hasIntegration(ctx, "upstash-rate-limit")
+      ? "\t\t\trateLimit: createMemoryRateLimiter(),"
+      : undefined,
+  ].filter((entry): entry is string => Boolean(entry));
+
+  return `import { describe, expect, it } from "bun:test";
+import { createUseCaseTester } from "@beignet/core/application";
+import { createInMemoryDevtools } from "@beignet/devtools";
+import { ${portImports.join(", ")} } from "@beignet/core/ports";
+import type { AppContext } from "@/app-context";
+import { appPorts } from "@/infra/app-ports";
+import {
+	createTodoUseCase,
+	getTodoUseCase,
+	listTodosUseCase,
+	type CreateTodoInput,
+	type ListTodosInput,
+	type Todo,
+} from "../use-cases";
+
+function createTestTodoRepository() {
+	const todos = new Map<string, Todo>();
+
+	return {
+		async list(input: ListTodosInput) {
+			const allTodos = Array.from(todos.values()).sort((left, right) =>
+				left.createdAt.localeCompare(right.createdAt),
+			);
+
+			return {
+				todos: allTodos.slice(input.offset, input.offset + input.limit),
+				total: allTodos.length,
+			};
+		},
+		async findById(id: string) {
+			return todos.get(id) ?? null;
+		},
+		async create(input: CreateTodoInput) {
+			const todo: Todo = {
+				id: crypto.randomUUID(),
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			todos.set(todo.id, todo);
+			return todo;
+		},
+	};
+}
+
+describe("todos resource", () => {
+	it("creates, gets, and lists todos", async () => {
+		const todos = createTestTodoRepository();
+		const auth = {
+			user: {
+				id: "user_test",
+				email: "test@example.com",
+				name: "Test User",
+			},
+			session: { id: "session_test" },
+		};
+		const actor = createUserActor(auth.user.id, {
+			displayName: auth.user.name,
+		});
+		const testPorts = {
+			...appPorts,
+			todos,
+${extraPorts.length > 0 ? `${extraPorts.join("\n")}\n` : ""}			uow: createNoopUnitOfWork(() => ({ todos })) as AppContext["ports"]["uow"],
+			devtools: createInMemoryDevtools(),
+			storage: createMemoryStorage(),
+		};
+		const tester = createUseCaseTester<AppContext>(() => ({
+			requestId: "test-request",
+			actor,
+			auth,
+			gate: testPorts.gate.bind({ actor, auth }),
+			ports: testPorts,
+		}));
+
+		const ctx = await tester.ctx();
+		const created = await tester.run(
+			createTodoUseCase,
+			{ title: "First todo" },
+			{ ctx },
+		);
+		const found = await tester.run(getTodoUseCase, { id: created.id }, { ctx });
+		const result = await tester.run(
+			listTodosUseCase,
+			{ limit: 20, offset: 0 },
+			{ ctx },
+		);
+
+		expect(created.title).toBe("First todo");
+		expect(found.id).toBe(created.id);
+		expect(result.total).toBe(1);
+		expect(result.todos).toEqual([created]);
+	});
+});
+`;
+}
+
+function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
+  const usesDrizzleTurso = hasDrizzleTurso(ctx);
+  const templateFiles: TemplateFile[] = [
+    { path: "package.json", content: packageJson(ctx) },
+    { path: "README.md", content: readme(ctx) },
+    { path: ".gitignore", content: gitignore(ctx) },
+    { path: ".env.example", content: envExample(ctx) },
+    { path: "next-env.d.ts", content: files.nextEnv },
+    { path: "next.config.js", content: files.nextConfig },
+    { path: "tsconfig.json", content: files.tsconfig },
+    { path: "app/globals.css", content: files.globals },
+    { path: "app/layout.tsx", content: layout(ctx) },
+    { path: "app/page.tsx", content: page(ctx) },
+    { path: "app/providers.tsx", content: files.appProviders },
+    { path: "app-context.ts", content: files.productionAppContext },
+    {
+      path: "app/api/[[...path]]/route.ts",
+      content: files.productionApiCatchAllRoute,
+    },
+    { path: "app/api/health/route.ts", content: files.productionHealthRoute },
+    {
+      path: "app/api/devtools/[[...path]]/route.ts",
+      content: files.productionDevtoolsRoute,
+    },
+    {
+      path: "app/storage/[...key]/route.ts",
+      content: files.productionStorageRoute,
+    },
+    {
+      path: "app/api/openapi/route.ts",
+      content: files.productionOpenApiRoute,
+    },
+    { path: "client/api-client.ts", content: files.apiClient },
+    { path: "client/rq.ts", content: files.rq },
+    {
+      path: "features/todos/contracts.ts",
+      content: files.productionContractsTodos,
+    },
+    { path: "features/todos/routes.ts", content: files.productionTodoRoutes },
+    { path: "features/todos/components/todo-app.tsx", content: todoApp(ctx) },
+    { path: "infra/logger.ts", content: files.productionLogger },
+    {
+      path: "infra/app-ports.ts",
+      content: usesDrizzleTurso
+        ? files.productionInfrastructurePortsWithDrizzleTurso
+        : files.productionInfrastructurePorts,
+    },
+    { path: "lib/env.ts", content: files.productionEnv },
+    { path: "lib/auth.ts", content: files.productionAuthHelpers },
+    { path: "features/todos/policy.ts", content: files.productionTodoPolicy },
+    {
+      path: "infra/auth/anonymous-auth.ts",
+      content: files.productionAnonymousAuth,
+    },
+    { path: "ports/auth.ts", content: files.productionAuthPort },
+    {
+      path: "ports/index.ts",
+      content: usesDrizzleTurso
+        ? productionPortsWithDrizzleTurso(ctx)
+        : productionPorts(ctx),
+    },
+    {
+      path: "features/todos/ports.ts",
+      content: files.productionTodoRepositoryPort,
+    },
+    {
+      path: "features/shared/errors.ts",
+      content: files.productimapUnhandledErrors,
+    },
+    {
+      path: "server/index.ts",
+      content: usesDrizzleTurso
+        ? files.productionServerWithDrizzleTurso
+        : files.productionServer,
+    },
+    { path: "server/routes.ts", content: files.productionServerRoutes },
+    {
+      path: "server/providers.ts",
+      content: productionServerProviders(ctx),
+    },
+    { path: "lib/use-case.ts", content: files.productionUseCaseBuilder },
+    {
+      path: "features/todos/use-cases/create-todo.ts",
+      content: files.productionCreateTodoUseCase,
+    },
+    {
+      path: "features/todos/use-cases/get-todo.ts",
+      content: files.productionGetTodoUseCase,
+    },
+    {
+      path: "features/todos/use-cases/list-todos.ts",
+      content: files.productionListTodosUseCase,
+    },
+    {
+      path: "features/todos/use-cases/index.ts",
+      content: files.productionUseCasesIndex,
+    },
+    {
+      path: "features/todos/use-cases/schemas.ts",
+      content: files.productionTodoSchemas,
+    },
+    {
+      path: "features/todos/tests/todos.test.ts",
+      content: productionTodosTest(ctx),
+    },
+    { path: "docs/integrations.md", content: integrationsDoc(ctx) },
+  ];
+
+  if (usesDrizzleTurso) {
+    templateFiles.push(
+      { path: "drizzle.config.ts", content: files.productionDrizzleConfig },
+      {
+        path: "infra/db/schema/index.ts",
+        content: files.productionDbSchema,
+      },
+      {
+        path: "infra/db/repositories.ts",
+        content: files.productionDbRepositories,
+      },
+      {
+        path: "infra/todos/drizzle-todo-repository.ts",
+        content: files.productionDrizzleTodoRepository,
+      },
+    );
+  } else {
+    templateFiles.push({
+      path: "infra/todos/in-memory-todo-repository.ts",
+      content: files.productionInMemoryTodoRepository,
+    });
+  }
+
+  return templateFiles;
+}
+
+export function getTemplateFiles(ctx: TemplateContext): TemplateFile[] {
+  if (isStandardPreset(ctx)) {
+    return getProductionTemplateFiles(ctx);
+  }
+
+  const templateFiles = [
+    { path: "package.json", content: packageJson(ctx) },
+    { path: "README.md", content: readme(ctx) },
+    { path: ".gitignore", content: gitignore(ctx) },
+    { path: "next-env.d.ts", content: files.nextEnv },
+    { path: "next.config.js", content: files.nextConfig },
+    { path: "tsconfig.json", content: files.tsconfig },
+    { path: "app/globals.css", content: files.globals },
+    { path: "app/layout.tsx", content: layout(ctx) },
+    { path: "app/page.tsx", content: page(ctx) },
+    { path: "app/api/[[...path]]/route.ts", content: files.apiCatchAllRoute },
+    { path: "features/todos/contracts.ts", content: files.contractsTodos },
+    { path: "features/todos/routes.ts", content: files.todoRoutes },
+    { path: "ports/index.ts", content: files.ports },
+    { path: "server/index.ts", content: server(ctx) },
+    { path: "server/routes.ts", content: files.serverRoutes },
+    { path: "features/todos/use-cases.ts", content: files.useCasesTodos },
+  ];
+
+  if (hasFeature(ctx, "client")) {
+    templateFiles.push({
+      path: "client/api-client.ts",
+      content: files.apiClient,
+    });
+  }
+
+  if (hasFeature(ctx, "react-query")) {
+    templateFiles.push(
+      { path: "app/providers.tsx", content: files.appProviders },
+      { path: "client/rq.ts", content: files.rq },
+      { path: "features/todos/components/todo-app.tsx", content: todoApp(ctx) },
+    );
+  }
+
+  if (hasFeature(ctx, "openapi")) {
+    templateFiles.push({
+      path: "app/api/openapi/route.ts",
+      content: files.apiOpenApiRoute,
+    });
+  }
+
+  if (
+    ctx.integrations.some((integration) =>
+      ["pino", "inngest", "resend", "upstash-rate-limit"].includes(integration),
+    )
+  ) {
+    templateFiles.push({
+      path: "server/providers.ts",
+      content: serverProviders(ctx),
+    });
+  }
+
+  if (ctx.integrations.length > 0) {
+    templateFiles.push(
+      {
+        path: ".env.example",
+        content: envExample(ctx),
+      },
+      {
+        path: "docs/integrations.md",
+        content: integrationsDoc(ctx),
+      },
+    );
+  }
+
+  return templateFiles;
+}