@beignet/cli 0.0.3 → 0.0.4

package/src/templates.ts

@@ -1,29 +1,22 @@
-/**
- * Package managers supported by the app template generator.
- */
-export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
-/**
- * Starter presets supported by the app template generator.
- */
-export type PresetName = "minimal" | "standard";
-/**
- * Application templates supported by the app template generator.
- */
-export type TemplateName = "next";
-/**
- * Optional first-party features that can be scaffolded into a new app.
- */
-export type FeatureName = "client" | "react-query" | "forms" | "openapi";
-/**
- * Optional provider integrations that can be scaffolded into a new app.
- */
-export type IntegrationName =
-  | "better-auth"
-  | "drizzle-turso"
-  | "inngest"
-  | "pino"
-  | "resend"
-  | "upstash-rate-limit";
+import type {
+  FeatureName,
+  IntegrationName,
+  PackageManager,
+  PresetName,
+} from "./choices.js";
+
+export type {
+  FeatureName,
+  IntegrationName,
+  PackageManager,
+  PresetName,
+  TemplateName,
+} from "./choices.js";
+export {
+  featureChoices,
+  integrationChoices,
+  presetChoices,
+} from "./choices.js";
 
 /**
  * One generated file emitted by the template generator.
@@ -58,9 +51,9 @@ const externalVersions = {
   tanstackReactQuery: "^5.100.7",
   hookformResolvers: "^5.0.0",
   reactHookForm: "^7.74.0",
-  betterAuth: "^1.3.26",
-  drizzleKit: "^0.30.0",
-  drizzleOrm: "^0.38.0",
+  betterAuth: "1.6.11",
+  drizzleKit: "^0.31.10",
+  drizzleOrm: "^0.45.2",
   inngest: "^3.0.0",
   libsqlClient: "^0.14.0",
   pino: "^9.7.0",
@@ -80,46 +73,16 @@ function hasDrizzleTurso(ctx: TemplateContext): boolean {
 function packageRunner(ctx: TemplateContext): string {
   switch (ctx.packageManager) {
     case "npm":
-      return "npx -p @beignet/cli beignet";
+      return "npm run beignet --";
     case "pnpm":
-      return "pnpm dlx @beignet/cli beignet";
+      return "pnpm beignet";
     case "yarn":
-      return "yarn dlx @beignet/cli beignet";
+      return "yarn beignet";
     default:
-      return "bunx -p @beignet/cli beignet";
+      return "bun beignet";
   }
 }
 
-/**
- * Supported scaffold feature choices.
- */
-export const featureChoices = [
-  "client",
-  "react-query",
-  "forms",
-  "openapi",
-] as const satisfies readonly FeatureName[];
-
-/**
- * Supported scaffold preset choices.
- */
-export const presetChoices = [
-  "minimal",
-  "standard",
-] as const satisfies readonly PresetName[];
-
-/**
- * Supported scaffold integration choices.
- */
-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": "",
@@ -233,6 +196,7 @@ function packageJson(ctx: TemplateContext): string {
   }
 
   const devDependencies: Record<string, string> = {
+    "@beignet/cli": ctx.beignetVersion,
     "@types/bun": externalVersions.typesBun,
     "@types/node": externalVersions.typesNode,
     "@types/react": externalVersions.typesReact,
@@ -249,6 +213,7 @@ function packageJson(ctx: TemplateContext): string {
   }
 
   const scripts: Record<string, string> = {
+    beignet: "beignet",
     dev: "next dev",
     build: "next build",
     start: "next start",
@@ -259,8 +224,13 @@ function packageJson(ctx: TemplateContext): string {
   if (hasDrizzleTurso(ctx)) {
     scripts["db:generate"] = "drizzle-kit generate";
     scripts["db:migrate"] = "drizzle-kit migrate";
-    scripts["db:seed"] = "bun infra/db/seed.ts";
-    scripts["db:reset"] = "bun infra/db/reset.ts";
+
+    // The minimal preset does not scaffold infra/db/seed.ts or
+    // infra/db/reset.ts, so only the standard preset gets their scripts.
+    if (isStandardPreset(ctx)) {
+      scripts["db:seed"] = "bun infra/db/seed.ts";
+      scripts["db:reset"] = "bun infra/db/reset.ts";
+    }
   }
 
   return json({
@@ -284,6 +254,9 @@ function readme(ctx: TemplateContext): string {
     ctx.packageManager === "npm"
       ? "npm run dev"
       : `${ctx.packageManager} run dev`;
+  const cli = packageRunner(ctx);
+  const envSetup =
+    ctx.integrations.length > 0 ? "cp .env.example .env.local\n" : "";
   const featureList =
     ctx.features.length > 0
       ? ctx.features.map((feature) => `- \`${feature}\``).join("\n")
@@ -292,6 +265,20 @@ function readme(ctx: TemplateContext): string {
     ctx.integrations.length > 0
       ? ctx.integrations.map((integration) => `- \`${integration}\``).join("\n")
       : "- None";
+  const databaseSection = hasDrizzleTurso(ctx)
+    ? `
+## Database
+
+The drizzle-turso integration persists todos with Drizzle on libSQL/Turso. The server creates and seeds the starter \`todos\` table at startup using \`TURSO_DB_URL\` (defaults to \`file:local.db\`).
+
+Regenerate and apply migrations after changing \`infra/db/schema/index.ts\`:
+
+\`\`\`bash
+${cli} db generate
+${cli} db migrate
+\`\`\`
+`
+    : "";
 
   return `# ${ctx.name}
 
@@ -301,19 +288,21 @@ Beignet app scaffolded with \`@beignet/cli\`.
 
 \`\`\`bash
 ${install}
-${run}
+${envSetup}${run}
 \`\`\`
 
-Open http://localhost:3000 and start from the todos workflow.
-
+Open http://localhost:3000 and start from the todos workflow. The homepage links to the health check, OpenAPI document, and Beignet docs.
+${databaseSection}
 ## Files to know
 
 - \`features/todos/contracts.ts\` defines the API contract.
-- \`features/todos/use-cases.ts\` contains application logic with input and output validation.
+- \`features/todos/use-cases/\` contains application logic with input and output validation.
 - \`ports/index.ts\` defines the app's external dependencies.
-- \`server/index.ts\` wires contracts to handlers.
+- \`features/todos/routes.ts\` binds contracts to use cases.
+- \`server/context.ts\` declares the context blueprint shared by the server and tests.
+- \`server/index.ts\` composes the server from ports, context, and routes.
 - \`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" : ""}
+${hasDrizzleTurso(ctx) ? "- `infra/db/schema/index.ts` owns the Drizzle schema and `infra/db/provider.ts` wires the Drizzle todo repository into the `todos` port.\n" : ""}${hasIntegration(ctx, "better-auth") ? "- `lib/better-auth.ts` owns the Better Auth instance served at `/api/auth/*`.\n" : ""}${hasFeature(ctx, "react-query") ? "- `features/todos/components/todo-app.tsx` contains the starter UI.\n" : ""}
 
 ## Selected preset
 
@@ -336,6 +325,10 @@ function standardReadme(ctx: TemplateContext): string {
     ctx.packageManager === "npm"
       ? "npm run dev"
       : `${ctx.packageManager} run dev`;
+  const test =
+    ctx.packageManager === "npm"
+      ? "npm run test"
+      : `${ctx.packageManager} run test`;
   const typecheck =
     ctx.packageManager === "npm"
       ? "npm run typecheck"
@@ -358,10 +351,24 @@ Beignet app scaffolded with \`@beignet/cli\`.
 \`\`\`bash
 ${install}
 cp .env.example .env.local
+\`\`\`
+
+## Prepare the database
+
+\`\`\`bash
+${cli} db generate
+${cli} db migrate
+\`\`\`
+
+\`db generate\` creates Drizzle migrations from \`infra/db/schema/\`. \`db migrate\` applies them to the local SQLite database configured in \`.env.local\`.
+
+## Start the app
+
+\`\`\`bash
 ${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.
+Open http://localhost:3000 for the todo workflow. The homepage links to the health check, OpenAPI document, devtools, and Beignet docs.
 
 ## First checks
 
@@ -375,15 +382,32 @@ ${typecheck}
 
 \`routes\` shows the contracts Beignet can inspect. \`lint\` checks dependency direction. \`doctor\` catches route, OpenAPI, and resource drift.
 
+## Generate a feature
+
+\`\`\`bash
+${cli} make feature projects
+${cli} db generate
+${cli} db migrate
+${test}
+${typecheck}
+${cli} lint
+${cli} doctor
+\`\`\`
+
+\`make feature\` creates a contract-to-test vertical slice. In the standard starter it also adds Drizzle schema and repository files, so regenerate and migrate the database before running the app against the new feature.
+
 ## App map
 
-- \`features/todos/contracts.ts\` owns the HTTP contract and reuses use case schemas.
+- \`features/todos/contracts.ts\` owns the HTTP contract and reuses shared feature schemas.
+- \`features/todos/schemas.ts\` owns shared DTO and validation schemas used by contracts, use cases, ports, tests, and clients.
 - \`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/context.ts\` declares the context blueprint shared by the server and route tests.
 - \`server/\` wires context, providers, routes, hooks, and error handling.
-- \`server/outbox.ts\` registers durable events and jobs for the outbox drain route.
+- \`server/outbox.ts\` registers durable events and jobs for the outbox drain route and CLI drain runner.
+- \`server/schedules.ts\` registers schedules for cron routes and the CLI schedule runner.
 - \`features/shared/errors.ts\` keeps application errors and route-owned error schemas together.
 - \`features/todos/domain/events/\`, \`jobs/\`, \`listeners/\`, \`notifications/\`, \`schedules/\`, and \`uploads/\` show the feature-owned background workflow shape.
 - \`app/storage/[...key]/route.ts\` serves public local storage objects.
@@ -400,6 +424,8 @@ ${beforeDeploy}
 - Keep \`/api/devtools\` development-only unless you add authentication and stricter redaction.
 - Set \`APP_URL\`, \`BETTER_AUTH_SECRET\`, \`CRON_SECRET\`, \`LOG_LEVEL\`, and service-specific integration variables in your hosting environment.
 - Configure a scheduled request to \`/api/cron/outbox/drain\` with \`Authorization: Bearer <CRON_SECRET>\`.
+- Use \`${cli} outbox drain\` for bounded local, CI, or worker-hosted drain runs.
+- Use \`${cli} schedule run todos.log-daily-summary\` for bounded local, CI, or worker-hosted schedule runs.
 - Review the starter authorization policy before exposing user-owned data.
 ${ctx.integrations.length > 0 ? "\nSee `docs/integrations.md` for setup notes.\n" : ""}
 `;
@@ -420,10 +446,17 @@ function integrationsDoc(ctx: TemplateContext): string {
         "",
         "- Package: `@beignet/provider-auth-better-auth`",
         "- Peer dependency: `better-auth`",
-        "- The standard starter wires `lib/better-auth.ts`, `app/api/auth/[...all]/route.ts`, and `createAuthBetterAuthProvider(...)`.",
-        "- 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(...)`.",
-        "- The generated SQLite schema includes the Better Auth `user`, `session`, `account`, and `verification` tables for local development.",
+        "- The starter wires `lib/better-auth.ts`, `app/api/auth/[...all]/route.ts`, and `createAuthBetterAuthProvider(...)`.",
+        ...(isStandardPreset(ctx)
+          ? [
+              "- 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(...)`.",
+              "- The generated SQLite schema includes the Better Auth `user`, `session`, `account`, and `verification` tables for local development.",
+            ]
+          : [
+              "- Keep auth behind the shared `AuthPort`, then read `ctx.auth` in use cases that need a signed-in user.",
+              "- The minimal starter uses Better Auth's in-memory adapter, so users and sessions reset on restart. Switch to a database adapter such as `better-auth/adapters/drizzle` before production.",
+            ]),
         "",
       );
     }
@@ -436,9 +469,19 @@ function integrationsDoc(ctx: TemplateContext): string {
         "- 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.",
+        ...(isStandardPreset(ctx)
+          ? [
+              "- The scaffold wires a typed Drizzle repository behind the `TodoRepository` port and a transaction-backed Unit of Work.",
+            ]
+          : [
+              "- The scaffold wires a typed Drizzle repository behind the `todos` port through `infra/db/provider.ts`, which also creates and seeds the starter table at startup.",
+            ]),
         `- Run \`${packageRunner(ctx)} db generate\` and \`${packageRunner(ctx)} db migrate\` after changing \`infra/db/schema/index.ts\`.`,
-        `- Run \`${packageRunner(ctx)} db seed\` for idempotent starter data and \`${packageRunner(ctx)} db reset\` for destructive local resets.`,
+        ...(isStandardPreset(ctx)
+          ? [
+              `- Run \`${packageRunner(ctx)} db seed\` for idempotent starter data and \`${packageRunner(ctx)} db reset\` for destructive local resets.`,
+            ]
+          : []),
         "",
       );
     }
@@ -451,7 +494,7 @@ function integrationsDoc(ctx: TemplateContext): string {
         "- 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(...)`.",
+        "- Define jobs with `defineJob(...)` from `lib/jobs.ts` 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.",
         "",
       );
@@ -544,7 +587,7 @@ function envExample(ctx: TemplateContext): string {
     lines.push(
       "UPSTASH_REDIS_REST_URL=",
       "UPSTASH_REDIS_REST_TOKEN=",
-      "UPSTASH_PREFIX=ck:ratelimit",
+      "UPSTASH_PREFIX=beignet:ratelimit",
       "",
     );
   }
@@ -621,6 +664,11 @@ function page(ctx: TemplateContext): string {
 					<p>
 						<a href="/api/todos">Open todos API</a>
 					</p>
+					<nav className="starter-links" aria-label="Starter links">
+						<a href="/api/health">Health</a>
+						<a href="/api/openapi">OpenAPI</a>
+						<a href="https://beignetjs.com">Docs</a>
+					</nav>
 				</section>
 			</div>
 		</main>
@@ -645,6 +693,14 @@ export default function HomePage() {
 					</p>
 				</header>
 
+				<nav className="starter-links" aria-label="Starter links">
+					<a href="#todos">Todo feature</a>
+					<a href="/api/health">Health</a>
+					<a href="/api/openapi">OpenAPI</a>
+					<a href="/api/devtools">Devtools</a>
+					<a href="https://beignetjs.com">Docs</a>
+				</nav>
+
 				<TodoApp />
 			</div>
 		</main>
@@ -654,64 +710,126 @@ export default function HomePage() {
 }
 
 function serverProviders(ctx: TemplateContext): string {
-  const imports: string[] = [];
+  const packageImports: string[] = [];
+  const appImports: string[] = [];
+  const declarations: string[] = [];
   const entries: string[] = [];
 
+  if (hasIntegration(ctx, "better-auth")) {
+    packageImports.push(
+      'import { createAuthBetterAuthProvider } from "@beignet/provider-auth-better-auth";',
+    );
+    appImports.push(
+      'import { auth } from "@/lib/better-auth";',
+      'import type { AuthSessionMetadata, AuthUser } from "@/ports";',
+    );
+    entries.push(
+      "createAuthBetterAuthProvider<AuthUser, AuthSessionMetadata>(auth)",
+    );
+  }
+
   if (hasIntegration(ctx, "pino")) {
-    imports.push(
+    packageImports.push(
       'import { loggerPinoProvider } from "@beignet/provider-logger-pino";',
     );
     entries.push("loggerPinoProvider");
   }
 
+  if (hasDrizzleTurso(ctx)) {
+    packageImports.push(
+      'import { createDrizzleTursoProvider } from "@beignet/provider-drizzle-turso";',
+    );
+    appImports.unshift(
+      'import { starterDatabaseProvider } from "@/infra/db/provider";',
+      'import * as schema from "@/infra/db/schema";',
+    );
+    declarations.push(
+      "const drizzleTursoProvider = createDrizzleTursoProvider({ schema });",
+    );
+    entries.push("drizzleTursoProvider", "starterDatabaseProvider");
+  }
+
   if (hasIntegration(ctx, "inngest")) {
-    imports.push(
+    packageImports.push(
       'import { inngestProvider } from "@beignet/provider-inngest";',
     );
     entries.push("inngestProvider");
   }
 
   if (hasIntegration(ctx, "resend")) {
-    imports.push(
+    packageImports.push(
       'import { mailResendProvider } from "@beignet/provider-mail-resend";',
     );
     entries.push("mailResendProvider");
   }
 
   if (hasIntegration(ctx, "upstash-rate-limit")) {
-    imports.push(
+    packageImports.push(
       'import { upstashRateLimitProvider } from "@beignet/provider-rate-limit-upstash";',
     );
     entries.push("upstashRateLimitProvider");
   }
 
-  return `${imports.join("\n")}
+  const importBlock = [...packageImports.sort(), ...appImports].join("\n");
+  const declarationBlock =
+    declarations.length > 0 ? `\n${declarations.join("\n")}\n` : "";
+
+  return `${importBlock}
+${declarationBlock}
 export const providers = [
 	${entries.join(",\n\t")},
 ];
 `;
 }
 
+function serverContext(ctx: TemplateContext): string {
+  const blueprint = hasIntegration(ctx, "better-auth")
+    ? `	async ({ req, ports }) => ({
+		requestId: crypto.randomUUID(),
+		auth: await ports.auth.getSession(req),
+		ports,
+	}),`
+    : `	async ({ ports }) => ({
+		requestId: crypto.randomUUID(),
+		ports,
+	}),`;
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { defineServerContext } from "@beignet/core/server";
+import type { AppContext } from "@/app-context";
+import type { AppPorts } from "@/ports";
+
+/**
+ * Context blueprint shared by the runtime server and route tests.
+ */
+export const appContext = defineServerContext<AppContext, AppPorts>()(
+${blueprint}
+);
+`;
+}
+
 function server(ctx: TemplateContext): string {
-  const hasProviders = ctx.integrations.some((integration) =>
-    ["pino", "inngest", "resend", "upstash-rate-limit"].includes(integration),
-  );
+  const hasProviders = ctx.integrations.length > 0;
+  const providerConfigBlock = hasDrizzleTurso(ctx)
+    ? `	providerConfig: {
+		"drizzle-turso": {
+			DB_URL: process.env.TURSO_DB_URL ?? "file:local.db",
+			DB_AUTH_TOKEN: process.env.TURSO_DB_AUTH_TOKEN,
+		},
+	},
+`
+    : "";
 
-  return `import { createNextServer } from "@beignet/next";
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createNextServer } from "@beignet/next";
+import { appContext } from "./context";
 ${hasProviders ? 'import { providers } from "./providers";\n' : ""}import { routes } from "./routes";
+import type { AppContext } from "@/app-context";
 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,
-	}),
+${hasProviders ? "\tproviders,\n" : ""}${providerConfigBlock}	context: appContext,
 	routes,
 	mapUnhandledError: ({ err, ctx }) => {
 		const ports = ctx?.ports as
@@ -753,6 +871,127 @@ ${hasProviders ? "\tproviders,\n" : ""}	createContext: async ({ ports }) => ({
 `;
 }
 
+function minimalPorts(ctx: TemplateContext): string {
+  const usesDrizzleTurso = hasDrizzleTurso(ctx);
+  const usesBetterAuth = hasIntegration(ctx, "better-auth");
+
+  if (!usesDrizzleTurso && !usesBetterAuth) {
+    return files.ports;
+  }
+
+  const imports = [
+    'import { definePorts } from "@beignet/core/ports";',
+    ...(usesBetterAuth
+      ? [
+          `import type {
+	AuthPort as BeignetAuthPort,
+	AuthSession as BeignetAuthSession,
+} from "@beignet/core/ports";`,
+        ]
+      : []),
+    'import type { z } from "zod";',
+    'import type { CreateTodoSchema, TodoSchema } from "@/features/todos/contracts";',
+  ].join("\n");
+
+  const authTypes = usesBetterAuth
+    ? `
+
+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>;`
+    : "";
+
+  const appPortsType = [
+    "export type AppPorts = {",
+    ...(usesBetterAuth ? ["\tauth: AuthPort;"] : []),
+    "\ttodos: TodoRepository;",
+    "};",
+  ].join("\n");
+
+  const inMemoryTodos = usesDrizzleTurso
+    ? ""
+    : `
+
+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" });`;
+
+  const bound = usesDrizzleTurso
+    ? "\tbound: {},"
+    : `	bound: {
+		todos: {
+			list: async () => Array.from(todos.values()),
+			create: async (input: CreateTodoInput) => createTodo(input),
+		},
+	},`;
+  const deferred = [
+    ...(usesBetterAuth ? ['"auth"'] : []),
+    ...(usesDrizzleTurso ? ['"todos"'] : []),
+  ].join(", ");
+
+  return `${imports}
+
+export type Todo = z.infer<typeof TodoSchema>;
+export type CreateTodoInput = z.infer<typeof CreateTodoSchema>;
+
+export interface TodoRepository {
+	list(): Promise<Todo[]>;
+	create(input: CreateTodoInput): Promise<Todo>;
+}${authTypes}
+
+${appPortsType}${inMemoryTodos}
+
+/**
+ * App ports the server boots with.
+ *
+ * Bound ports are app-owned. Every deferred key is contributed by a provider
+ * in server/providers.ts during startup; createNextServer(...) fails boot if
+ * any of them is still unbound after providers have started.
+ */
+export const appPorts = definePorts<AppPorts>()({
+${bound}
+	deferred: [${deferred}],
+});
+`;
+}
+
+function minimalAppContext(ctx: TemplateContext): string {
+  if (!hasIntegration(ctx, "better-auth")) {
+    return files.appContext;
+  }
+
+  return `import type { AppPorts, AuthSession } from "@/ports";
+
+export type AppContext = {
+	requestId: string;
+	auth: AuthSession | null;
+	ports: AppPorts;
+};
+`;
+}
+
 function todoApp(ctx: TemplateContext): string {
   const listTodosQueryOptions =
     ctx.preset === "standard" ? "{ query: {} }" : "";
@@ -760,12 +999,12 @@ function todoApp(ctx: TemplateContext): string {
   if (hasFeature(ctx, "forms")) {
     return `"use client";
 
-import { createReactHookForm } from "@beignet/react-hook-form";
+import { rootFormError } from "@beignet/react-hook-form";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { rq } from "@/client";
+import { rhf } from "@/client/forms";
 import { createTodo, listTodos } from "@/features/todos/contracts";
-import { rq } from "@/client/rq";
 
-const rhf = createReactHookForm();
 const createTodoForm = rhf(createTodo);
 
 export function TodoApp() {
@@ -778,19 +1017,21 @@ export function TodoApp() {
 		rq(createTodo).mutationOptions({
 			onSuccess: async () => {
 				form.reset();
-				await queryClient.invalidateQueries({
-					queryKey: rq(listTodos).key(),
-				});
+				await rq(listTodos).invalidate(queryClient);
+			},
+			onError: (error) => {
+				form.setError("root", rootFormError(error, "Could not create the todo."));
 			},
 		}),
 	);
 
 	const onSubmit = form.handleSubmit((body) => {
+		form.clearErrors("root");
 		createTodoMutation.mutate({ body });
 	});
 
 	return (
-		<section className="workspace">
+		<section id="todos" className="workspace">
 			<form className="composer" onSubmit={onSubmit}>
 				<label htmlFor="todo-title">New todo</label>
 				<div className="composer-row">
@@ -806,6 +1047,9 @@ export function TodoApp() {
 				{form.formState.errors.title ? (
 					<p className="error">{form.formState.errors.title.message}</p>
 				) : null}
+				{form.formState.errors.root ? (
+					<p className="error">{form.formState.errors.root.message}</p>
+				) : null}
 			</form>
 
 			<div className="todos-panel">
@@ -836,8 +1080,8 @@ export function TodoApp() {
 
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
+import { rq } from "@/client";
 import { createTodo, listTodos } from "@/features/todos/contracts";
-import { rq } from "@/client/rq";
 
 export function TodoApp() {
 	const [title, setTitle] = useState("");
@@ -847,15 +1091,13 @@ export function TodoApp() {
 		rq(createTodo).mutationOptions({
 			onSuccess: async () => {
 				setTitle("");
-				await queryClient.invalidateQueries({
-					queryKey: rq(listTodos).key(),
-				});
+				await rq(listTodos).invalidate(queryClient);
 			},
 		}),
 	);
 
 	return (
-		<section className="workspace">
+		<section id="todos" className="workspace">
 			<form
 				className="composer"
 				onSubmit={(event) => {
@@ -897,6 +1139,58 @@ export function TodoApp() {
 `;
 }
 
+function clientIndex(ctx: TemplateContext): string {
+  const imports = [
+    'import { createClient } from "@beignet/core/client";',
+    ...(hasFeature(ctx, "react-query")
+      ? [
+          'import { createReactQuery } from "@beignet/react-query";',
+          'import { QueryClient } from "@tanstack/react-query";',
+        ]
+      : []),
+    ...(isStandardPreset(ctx)
+      ? [
+          'import { createUploadClient } from "@beignet/core/uploads/client";',
+          'import type { todoUploads } from "@/features/todos/uploads";',
+        ]
+      : []),
+  ].join("\n");
+
+  const exports = [
+    `export const apiClient = createClient({
+\tvalidateInput: true,
+});`,
+    ...(hasFeature(ctx, "react-query")
+      ? ["export const rq = createReactQuery(apiClient);"]
+      : []),
+    ...(isStandardPreset(ctx)
+      ? [
+          `export const uploads = createUploadClient<typeof todoUploads>({
+\tbaseUrl: "/api/uploads",
+});`,
+        ]
+      : []),
+    ...(hasFeature(ctx, "react-query")
+      ? [
+          `export function makeQueryClient() {
+\treturn new QueryClient({
+\t\tdefaultOptions: {
+\t\t\tqueries: {
+\t\t\t\tstaleTime: 60 * 1000,
+\t\t\t},
+\t\t},
+\t});
+}`,
+        ]
+      : []),
+  ].join("\n\n");
+
+  return `${imports}
+
+${exports}
+`;
+}
+
 const files = {
   gitignore: `.next
 node_modules
@@ -997,6 +1291,29 @@ input {
 	color: #475569;
 }
 
+.starter-links {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 10px;
+	margin: 22px 0;
+}
+
+.starter-links a {
+	border: 1px solid #cbd5e1;
+	border-radius: 8px;
+	padding: 8px 10px;
+	background: #ffffff;
+	color: #172033;
+	font-size: 14px;
+	font-weight: 700;
+	text-decoration: none;
+}
+
+.starter-links a:hover {
+	border-color: #4f46e5;
+	color: #4f46e5;
+}
+
 .panel {
 	margin-top: 24px;
 	padding: 20px;
@@ -1123,32 +1440,26 @@ input {
 `,
   appProviders: `"use client";
 
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { QueryClientProvider } from "@tanstack/react-query";
 import { type ReactNode, useState } from "react";
+import { makeQueryClient } from "@/client";
 
 export function Providers({ children }: { children: ReactNode }) {
-	const [queryClient] = useState(() => new QueryClient());
+	const [queryClient] = useState(() => makeQueryClient());
 
 	return (
 		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
 	);
 }
 `,
-  apiClient: `import { createNextClient } from "@beignet/next";
+  formsClient: `import { createReactHookForm } from "@beignet/react-hook-form";
 
-export const apiClient = createNextClient({
-	validate: true,
-});
+export const rhf = createReactHookForm();
 `,
-  rq: `import { createReactQuery } from "@beignet/react-query";
-import { apiClient } from "./api-client";
-
-export const rq = createReactQuery(apiClient);
-`,
-  contractsTodos: `import { createContractGroup } from "@beignet/core/contracts";
+  contractsTodos: `import { defineContractGroup } from "@beignet/core/contracts";
 import { z } from "zod";
 
-const todos = createContractGroup().namespace("todos");
+const todos = defineContractGroup().namespace("todos");
 
 export const TodoSchema = z.object({
 	id: z.string(),
@@ -1213,15 +1524,145 @@ export const appPorts = definePorts({
 
 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";
+  appContext: `import type { AppPorts } from "@/ports";
 
-type AppContext = {
+export type AppContext = {
 	requestId: string;
 	ports: AppPorts;
 };
+`,
+  minimalBetterAuth: `import { betterAuth } from "better-auth";
+import { memoryAdapter, type MemoryDB } from "better-auth/adapters/memory";
+
+// The minimal starter keeps auth storage in memory, matching its in-memory
+// ports. Users and sessions reset on restart; switch to a database adapter
+// such as better-auth/adapters/drizzle before production.
+const database: MemoryDB = {
+	account: [],
+	session: [],
+	user: [],
+	verification: [],
+};
+
+export const auth = betterAuth({
+	baseURL: process.env.BETTER_AUTH_URL ?? "http://localhost:3000",
+	secret:
+		process.env.BETTER_AUTH_SECRET ?? "local-dev-better-auth-secret-change-me",
+	database: memoryAdapter(database),
+	emailAndPassword: {
+		enabled: true,
+	},
+});
+`,
+  minimalDbSchema: `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(),
+});
+`,
+  minimalDrizzleTodoRepository: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import { asc } from "drizzle-orm";
+import * as schema from "@/infra/db/schema";
+import type { CreateTodoInput, TodoRepository } from "@/ports";
+
+export function createDrizzleTodoRepository(
+	db: DrizzleTursoDatabase<typeof schema>,
+): TodoRepository {
+	return {
+		async list() {
+			return db
+				.select()
+				.from(schema.todos)
+				.orderBy(asc(schema.todos.createdAt));
+		},
+		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 row;
+		},
+	};
+}
+`,
+  minimalDbProvider: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createProvider } from "@beignet/core/providers";
+import type { DbPort } from "@beignet/provider-drizzle-turso";
+import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
+import type { AppPorts } from "@/ports";
+import * as schema from "./schema";
+
+const setupStatements = [
+	\`CREATE TABLE IF NOT EXISTS todos (
+		id text PRIMARY KEY NOT NULL,
+		title text NOT NULL,
+		completed integer DEFAULT false NOT NULL,
+		created_at text NOT NULL
+	)\`,
+];
+
+const seedTitles = [
+	"Read the generated contract",
+	"Add your first use case",
+] as const;
+
+export const starterDatabaseProvider = createProvider<{
+	db: DbPort<typeof schema>;
+}>()({
+	name: "starter-database",
+
+	async setup({ ports }) {
+		const dbPort = ports.db;
+		if (!dbPort) {
+			throw new Error(
+				"starterDatabaseProvider requires a db port. Register createDrizzleTursoProvider({ schema }) before it.",
+			);
+		}
+
+		const providedPorts: Pick<AppPorts, "todos"> = {
+			todos: createDrizzleTodoRepository(dbPort.db),
+		};
+
+		return {
+			ports: providedPorts,
+			async start() {
+				for (const statement of setupStatements) {
+					await dbPort.client.execute(statement);
+				}
+
+				const result = await dbPort.client.execute(
+					"SELECT count(*) as total FROM todos",
+				);
+				const total = Number(result.rows[0]?.total ?? 0);
+				if (total > 0) return;
+
+				for (const title of seedTitles) {
+					await dbPort.client.execute({
+						sql: "INSERT INTO todos (id, title, completed, created_at) VALUES (?, ?, ?, ?)",
+						args: [crypto.randomUUID(), title, 0, new Date().toISOString()],
+					});
+				}
+			},
+		};
+	},
+});
+`,
+  useCasesTodos: `import { createUseCase } from "@beignet/core/application";
+import { z } from "zod";
+import { CreateTodoSchema, TodoSchema } from "@/features/todos/contracts";
+import type { AppContext } from "@/app-context";
 
 const useCase = createUseCase<AppContext>();
 
@@ -1238,7 +1679,7 @@ export const ListTodosOutputSchema = z.object({
 
 export const listTodos = useCase
 	.query("listTodos")
-	.input(z.void())
+	.input(z.object({}))
 	.output(ListTodosOutputSchema)
 	.run(async ({ ctx }) => {
 		const todos = await ctx.ports.todos.list();
@@ -1260,33 +1701,23 @@ export const createTodo = useCase
 	.output(TodoSchema)
 	.run(async ({ ctx, input }) => ctx.ports.todos.create(input));
 `,
-  todoRoutes: `import { defineRouteGroup } from "@beignet/next";
-import type { AppContext } from "@/server";
+  todoRoutes: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "@/app-context";
 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 }),
-			}),
-		},
+		{ contract: contracts.listTodos, useCase: listTodos },
+		{ contract: contracts.createTodo, useCase: createTodo },
 	],
 });
 `,
-  serverRoutes: `import { contractsFromRoutes, defineRoutes } from "@beignet/next";
-import type { AppContext } from "@/server";
+  serverRoutes: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { contractsFromRoutes, defineRoutes } from "@beignet/next";
+import type { AppContext } from "@/app-context";
 import { todoRoutes } from "@/features/todos/routes";
 
 export const routes = defineRoutes<AppContext>([
@@ -1344,24 +1775,28 @@ export const env = createEnv({
 
 export const isProduction = env.NODE_ENV === "production";
 `,
-  productionAppContext: `import type { DevtoolsPort, DevtoolsTraceContext } from "@beignet/devtools";
-import type { ActivityActor, ActivityTenant, StoragePort } from "@beignet/core/ports";
+  productionAppContext: `import type { ActivityActor, ActivityTenant } from "@beignet/core/ports";
+import type { InferProviderPorts } from "@beignet/core/providers";
+import type { TraceContext } from "@beignet/core/tracing";
 import type { AppGate, AppPorts } from "@/ports";
 import type { AuthSession } from "@/ports/auth";
+import type { providers } from "@/server/providers";
+
+/**
+ * App ports plus the ports contributed by the server's providers at startup.
+ */
+export type AppRuntimePorts = AppPorts & InferProviderPorts<typeof providers>;
 
 export type AppContext = {
 	requestId: string;
 	actor: ActivityActor;
 	auth: AuthSession | null;
 	gate: AppGate;
-	ports: AppPorts & {
-		devtools: DevtoolsPort;
-		storage: StoragePort;
-	};
+	ports: AppRuntimePorts;
 	tenant?: ActivityTenant;
-} & Partial<DevtoolsTraceContext>;
+} & Partial<TraceContext>;
 `,
-  productimapUnhandledErrors: `import { createAppError, defineErrors } from "@beignet/core/errors";
+  productionSharedErrors: `import { createAppError, defineErrors } from "@beignet/core/errors";
 
 export const errors = defineErrors({
 	Unauthorized: {
@@ -1420,13 +1855,36 @@ 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";
+  productionUseCaseBuilder: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createUseCase } from "@beignet/core/application";
 import type { AppContext } from "@/app-context";
 
-export const useCase = createUseCase<AppContext>({
-	onRun: createDevtoolsUseCaseObserver<AppContext>(),
-});
+export const useCase = createUseCase<AppContext>();
+`,
+  productionListenersBuilder: `import { createListeners } from "@beignet/core/events";
+import type { AppContext } from "@/app-context";
+
+export const { defineListener } = createListeners<AppContext>();
+`,
+  productionJobsBuilder: `import { createJobs } from "@beignet/core/jobs";
+import type { AppContext } from "@/app-context";
+
+export const { defineJob } = createJobs<AppContext>();
+`,
+  productionSchedulesBuilder: `import { createSchedules } from "@beignet/core/schedules";
+import type { AppContext } from "@/app-context";
+
+export const { defineSchedule } = createSchedules<AppContext>();
+`,
+  productionNotificationsBuilder: `import { createNotifications } from "@beignet/core/notifications";
+import type { AppContext } from "@/app-context";
+
+export const { defineNotification } = createNotifications<AppContext>();
+`,
+  productionTasksBuilder: `import { createTasks } from "@beignet/core/tasks";
+import type { AppContext } from "@/app-context";
+
+export const { defineTask } = createTasks<AppContext>();
 `,
   productionAuthHelpers: `import type { AppContext } from "@/app-context";
 import type { AuthSession, AuthUser } from "@/ports/auth";
@@ -1444,9 +1902,10 @@ export function requireUser(ctx: AppContext): AuthUser {
 	return requireSession(ctx).user;
 }
 `,
-  productionListTodosUseCase: `import { normalizeOffsetPage } from "@beignet/core/pagination";
+  productionListTodosUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { normalizeOffsetPage } from "@beignet/core/pagination";
 import { useCase } from "@/lib/use-case";
-import { ListTodosInputSchema, ListTodosOutputSchema } from "./schemas";
+import { ListTodosInputSchema, ListTodosOutputSchema } from "../schemas";
 
 export const listTodosUseCase = useCase
 	.query("todos.list")
@@ -1461,9 +1920,10 @@ export const listTodosUseCase = useCase
 		return ctx.ports.todos.list(page);
 	});
 `,
-  productionGetTodoUseCase: `import { appError } from "@/features/shared/errors";
+  productionGetTodoUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { appError } from "@/features/shared/errors";
 import { useCase } from "@/lib/use-case";
-import { GetTodoInputSchema, TodoSchema } from "./schemas";
+import { GetTodoInputSchema, TodoSchema } from "../schemas";
 
 export const getTodoUseCase = useCase
 	.query("todos.get")
@@ -1478,10 +1938,11 @@ export const getTodoUseCase = useCase
 		return todo;
 	});
 `,
-  productionCreateTodoUseCase: `import { TodoCreated } from "@/features/todos/domain/events";
+  productionCreateTodoUseCase: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { TodoCreated } from "@/features/todos/domain/events";
 import { auditEntry } from "@/lib/audit";
 import { useCase } from "@/lib/use-case";
-import { CreateTodoInputSchema, TodoSchema } from "./schemas";
+import { CreateTodoInputSchema, TodoSchema } from "../schemas";
 
 export const createTodoUseCase = useCase
 	.command("todos.create")
@@ -1521,7 +1982,7 @@ export {
 	type CreateTodoInput,
 	type ListTodosInput,
 	type Todo,
-} from "./schemas";
+} from "../schemas";
 `,
   productionTodoRepositoryPort: `import type {
 	OffsetPage,
@@ -1531,7 +1992,7 @@ export {
 import type {
 	CreateTodoInput,
 	Todo,
-} from "@/features/todos/use-cases/schemas";
+} from "@/features/todos/schemas";
 
 export type ListTodosResult = PageResult<Todo, OffsetPageInfo>;
 
@@ -1624,11 +2085,12 @@ export const todoPolicy = definePolicy({
 	},
 });
 `,
-  productionInMemoryTodoRepository: `import { offsetPageResult } from "@beignet/core/pagination";
+  productionInMemoryTodoRepository: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { offsetPageResult } from "@beignet/core/pagination";
 import type {
 	CreateTodoInput,
 	Todo,
-} from "@/features/todos/use-cases/schemas";
+} from "@/features/todos/schemas";
 import type {
 	TodoAttachmentRepository,
 	TodoRepository,
@@ -1712,26 +2174,6 @@ export const appPorts = definePorts({
 		todos,
 	})),
 });
-`,
-  productionInfrastructurePortsWithDrizzleTurso: `import { createGate, definePorts } from "@beignet/core/ports";
-import { todoPolicy } from "@/features/todos/policy";
-import { appError } from "@/features/shared/errors";
-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({
-	gate,
-	logger: fallbackLogger,
-});
 `,
   productionDrizzleConfig: `export default {
 	schema: "./infra/db/schema/index.ts",
@@ -1902,8 +2344,34 @@ export const outboxMessages = sqliteTable(
 		),
 	}),
 );
+
+export const idempotencyRecords = sqliteTable(
+	"idempotency_records",
+	{
+		storageKey: text("storage_key").primaryKey(),
+		namespace: text("namespace").notNull(),
+		idempotencyKey: text("idempotency_key").notNull(),
+		scopeKey: text("scope_key").notNull(),
+		fingerprint: text("fingerprint").notNull(),
+		status: text("status", { enum: ["in-progress", "completed"] }).notNull(),
+		resultJson: text("result_json"),
+		reservedAt: text("reserved_at").notNull(),
+		completedAt: text("completed_at"),
+		expiresAt: text("expires_at"),
+		updatedAt: text("updated_at").notNull(),
+	},
+	(table) => ({
+		lookupIdx: index("idempotency_records_lookup_idx").on(
+			table.namespace,
+			table.scopeKey,
+			table.idempotencyKey,
+		),
+		expiresIdx: index("idempotency_records_expires_idx").on(table.expiresAt),
+	}),
+);
 `,
-  productionDrizzleTodoRepository: `import { offsetPageResult } from "@beignet/core/pagination";
+  productionDrizzleTodoRepository: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { offsetPageResult } from "@beignet/core/pagination";
 import { count, desc, eq } from "drizzle-orm";
 import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
 import type {
@@ -1913,7 +2381,7 @@ import type {
 import type {
 	CreateTodoInput,
 	Todo,
-} from "@/features/todos/use-cases/schemas";
+} from "@/features/todos/schemas";
 import * as schema from "@/infra/db/schema";
 
 type TodoRow = typeof schema.todos.$inferSelect;
@@ -2027,7 +2495,10 @@ import * as schema from "./schema";
 
 export function createRepositories(
 	db: DrizzleTursoDatabase<typeof schema>,
-): Omit<AppTransactionPorts, "audit" | "events" | "jobs" | "outbox"> {
+): Omit<
+	AppTransactionPorts,
+	"audit" | "events" | "idempotency" | "jobs" | "outbox"
+> {
 	return {
 		todoAttachments: createDrizzleTodoAttachmentRepository(db),
 		todos: createDrizzleTodoRepository(db),
@@ -2080,7 +2551,7 @@ export function createDrizzleAuditLog(
 	};
 }
 `,
-  productionDbBootstrap: `import { createDrizzleTursoOutboxSetupStatements } from "@beignet/provider-drizzle-turso";
+  productionDbBootstrap: `import { createDrizzleTursoIdempotencySetupStatements, createDrizzleTursoOutboxSetupStatements } from "@beignet/provider-drizzle-turso";
 import type { Client } from "@libsql/client";
 
 type BootstrapOptions = {
@@ -2174,6 +2645,7 @@ const setupStatements = [
 	"CREATE INDEX IF NOT EXISTS audit_log_request_idx ON audit_log (request_id)",
 	"CREATE INDEX IF NOT EXISTS audit_log_resource_idx ON audit_log (resource_type, resource_id)",
 	"CREATE INDEX IF NOT EXISTS audit_log_tenant_idx ON audit_log (tenant_id)",
+	...createDrizzleTursoIdempotencySetupStatements(),
 	...createDrizzleTursoOutboxSetupStatements(),
 ];
 
@@ -2200,6 +2672,7 @@ const resetTables = [
 	"todo_attachments",
 	"todos",
 	"audit_log",
+	"idempotency_records",
 	"outbox_messages",
 ] as const;
 
@@ -2238,7 +2711,6 @@ export async function resetStarterDatabase(client: Client): Promise<void> {
 }
 `,
   productionDbProvider: `import { registerListeners } from "@beignet/core/events";
-import { createMemoryIdempotencyStore } from "@beignet/core/idempotency";
 import { createInlineJobDispatcher } from "@beignet/core/jobs";
 import { createMemoryMailer } from "@beignet/core/mail";
 import { createInlineNotificationDispatcher } from "@beignet/core/notifications";
@@ -2247,19 +2719,15 @@ import {
 	createOutboxJobDispatcher,
 } from "@beignet/core/outbox";
 import {
+	createInstrumentedAuditLog,
 	createSystemActor,
-	createTenant,
 } from "@beignet/core/ports";
 import {
 	createProvider,
 	createProviderInstrumentation,
 } from "@beignet/core/providers";
 import {
-	createDevtoolsAuditLog,
-	createDevtoolsTraceContext,
-	type DevtoolsPort,
-} from "@beignet/devtools";
-import {
+	createDrizzleTursoIdempotencyPort,
 	createDrizzleTursoOutboxPort,
 	createDrizzleTursoUnitOfWork,
 	type DbPort,
@@ -2269,42 +2737,30 @@ import type { AppContext } from "@/app-context";
 import { todoListeners } from "@/features/todos/listeners";
 import { createDrizzleAuditLog } from "@/infra/audit/drizzle-audit-log";
 import type { AppPorts } from "@/ports";
+import type { AppServiceContextInput } from "@/server/context";
 import { ensureStarterDatabase } from "./bootstrap";
 import { createRepositories } from "./repositories";
 import type * as schema from "./schema";
 
-export const starterDatabaseProvider = createProvider({
+export const starterDatabaseProvider = createProvider<
+	{ db: DbPort<typeof schema> },
+	AppContext,
+	AppServiceContextInput
+>()({
 	name: "starter-database",
 
-	async setup({ ports }) {
-		const dbPort = (ports as { db: DbPort<typeof schema> }).db;
-		const devtools = (ports as { devtools?: DevtoolsPort }).devtools;
+	async setup({ ports, createServiceContext }) {
+		const dbPort = ports.db;
 		if (!dbPort) {
 			throw new Error(
 				"starterDatabaseProvider requires a db port. Register createDrizzleTursoProvider({ schema }) before it.",
 			);
 		}
 
-		let currentPorts: AppContext["ports"] | undefined;
-		const createBackgroundContext = (): AppContext => {
-			if (!currentPorts) {
-				throw new Error("Starter background context is not ready.");
-			}
-
-			const actor = createSystemActor("starter-background");
-			const tenant = createTenant("tenant_default");
-			const traceContext = createDevtoolsTraceContext();
-
-			return {
-				actor,
-				auth: null,
-				gate: currentPorts.gate.bind({ actor, auth: null }),
-				requestId: crypto.randomUUID(),
-				...traceContext,
-				ports: currentPorts,
-				tenant,
-			};
-		};
+		const createBackgroundContext = () =>
+			createServiceContext({
+				actor: createSystemActor("starter-background"),
+			});
 
 		const mailInstrumentation = createProviderInstrumentation(ports, {
 			providerName: "memory-mailer",
@@ -2338,12 +2794,12 @@ export const starterDatabaseProvider = createProvider({
 				});
 			},
 		});
-		const audit = createDevtoolsAuditLog({
+		const audit = createInstrumentedAuditLog({
 			audit: createDrizzleAuditLog(dbPort.db),
-			devtools,
+			instrumentation: ports,
 		});
 		const repositories = createRepositories(dbPort.db);
-		const idempotency = createMemoryIdempotencyStore();
+		const idempotency = createDrizzleTursoIdempotencyPort(dbPort.db);
 		const outbox = createDrizzleTursoOutboxPort(dbPort.db);
 		const unregisterListeners = registerListeners(eventBus, todoListeners, {
 			ctx: createBackgroundContext,
@@ -2355,34 +2811,52 @@ export const starterDatabaseProvider = createProvider({
 			},
 		});
 
-		return {
-			ports: {
-				audit,
-				...repositories,
-				eventBus,
-				idempotency,
-				jobs,
-				mailer,
-				notifications,
-				outbox,
-				uow: createDrizzleTursoUnitOfWork({
-					db: dbPort.db,
-					createTransactionPorts: (tx) => {
-						const txOutbox = createDrizzleTursoOutboxPort(tx);
-
-						return {
+		const providedPorts: Pick<
+			AppPorts,
+			| "audit"
+			| "eventBus"
+			| "idempotency"
+			| "jobs"
+			| "mailer"
+			| "notifications"
+			| "outbox"
+			| "todoAttachments"
+			| "todos"
+			| "uow"
+		> = {
+			audit,
+			...repositories,
+			eventBus,
+			idempotency,
+			jobs,
+			mailer,
+			notifications,
+			outbox,
+			uow: createDrizzleTursoUnitOfWork({
+				db: dbPort.db,
+				createTransactionPorts: (tx) => {
+					const txIdempotency = createDrizzleTursoIdempotencyPort(tx);
+					const txOutbox = createDrizzleTursoOutboxPort(tx);
+
+					return {
+						audit: createInstrumentedAuditLog({
 							audit: createDrizzleAuditLog(tx),
-							...createRepositories(tx),
-							events: createOutboxEventRecorder(txOutbox),
-							jobs: createOutboxJobDispatcher(txOutbox),
-							outbox: txOutbox,
-						};
-					},
-				}),
-			} satisfies Partial<AppPorts>,
-			async start(ctx) {
+							instrumentation: ports,
+						}),
+						...createRepositories(tx),
+						events: createOutboxEventRecorder(txOutbox),
+						idempotency: txIdempotency,
+						jobs: createOutboxJobDispatcher(txOutbox),
+						outbox: txOutbox,
+					};
+				},
+			}),
+		};
+
+		return {
+			ports: providedPorts,
+			async start() {
 				await ensureStarterDatabase(dbPort.client);
-				currentPorts = ctx.ports as AppContext["ports"];
 			},
 			stop() {
 				unregisterListeners();
@@ -2391,14 +2865,16 @@ export const starterDatabaseProvider = createProvider({
 	},
 });
 `,
-  productionContractsTodos: `import { createContractGroup } from "@beignet/core/contracts";
+  productionContractsTodos: `import { defineContractGroup } from "@beignet/core/contracts";
 import { z } from "zod";
 import { errors } from "@/features/shared/errors";
 import {
-	createTodoUseCase,
-	getTodoUseCase,
-	listTodosUseCase,
-} from "@/features/todos/use-cases";
+	CreateTodoInputSchema,
+	GetTodoInputSchema,
+	ListTodosInputSchema,
+	ListTodosOutputSchema,
+	TodoSchema,
+} from "@/features/todos/schemas";
 
 const ErrorResponseSchema = z.object({
 	code: z.string(),
@@ -2406,7 +2882,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const todos = createContractGroup()
+const todos = defineContractGroup()
 	.namespace("todos")
 	.errors({ Unauthorized: errors.Unauthorized })
 	.responses({
@@ -2415,28 +2891,29 @@ const todos = createContractGroup()
 
 export const listTodos = todos
 	.get("/api/todos")
-	.query(listTodosUseCase.inputSchema)
+	.query(ListTodosInputSchema)
 	.responses({
-		200: listTodosUseCase.outputSchema,
+		200: ListTodosOutputSchema,
 	});
 
 export const createTodo = todos
 	.post("/api/todos")
-	.body(createTodoUseCase.inputSchema)
+	.body(CreateTodoInputSchema)
 	.errors({ Forbidden: errors.Forbidden })
 	.responses({
-		201: createTodoUseCase.outputSchema,
+		201: TodoSchema,
 	});
 
 export const getTodo = todos
 	.get("/api/todos/:id")
-	.pathParams(getTodoUseCase.inputSchema)
+	.pathParams(GetTodoInputSchema)
 	.errors({ TodoNotFound: errors.TodoNotFound })
 	.responses({
-		200: getTodoUseCase.outputSchema,
+		200: TodoSchema,
 	});
 `,
-  productionTodoRoutes: `import { defineRouteGroup } from "@beignet/next";
+  productionTodoRoutes: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { defineRouteGroup } from "@beignet/next";
 import type { AppContext } from "@/app-context";
 import { createTodo, getTodo, listTodos } from "@/features/todos/contracts";
 import {
@@ -2448,31 +2925,14 @@ import {
 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 }),
-			}),
-		},
+		{ contract: listTodos, useCase: listTodosUseCase },
+		{ contract: createTodo, useCase: createTodoUseCase },
+		{ contract: getTodo, useCase: getTodoUseCase },
 	],
 });
 `,
-  productionServerRoutes: `import { contractsFromRoutes, defineRoutes } from "@beignet/next";
+  productionServerRoutes: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { contractsFromRoutes, defineRoutes } from "@beignet/next";
 import type { AppContext } from "@/app-context";
 import { todoRoutes } from "@/features/todos/routes";
 
@@ -2481,16 +2941,72 @@ export const routes = defineRoutes<AppContext>([
 ]);
 export const contracts = contractsFromRoutes(routes);
 `,
-  productionServer: `import { createDevtoolsHooks } from "@beignet/devtools";
-import { createNextServer } from "@beignet/next";
+  productionServerContext: `import type { beignetServerOnly } from "@beignet/core/server-only";
 import {
+	type ActivityActor,
 	createAnonymousActor,
+	createServiceActor,
 	createTenant,
 	createUserActor,
 } from "@beignet/core/ports";
+import { defineServerContext } from "@beignet/core/server";
+import type { TraceContext } from "@beignet/core/tracing";
+import type { AppContext, AppRuntimePorts } from "@/app-context";
+
+export type AppServiceContextInput =
+	| {
+			actor?: ActivityActor;
+			tenantId?: string;
+	  }
+	| undefined;
+
+/**
+ * Context blueprint shared by the runtime server and route tests.
+ */
+export const appContext = defineServerContext<AppContext, AppRuntimePorts>()({
+	gate: (ports) => ports.gate,
+	request: async ({ req, ports, requestId, trace }) => {
+		const auth = await ports.auth.getSession(req);
+		const tenantId = req.headers.get("x-tenant-id") || undefined;
+
+		return {
+			requestId,
+			actor: auth
+				? createUserActor(auth.user.id, { displayName: auth.user.name })
+				: createAnonymousActor(),
+			auth,
+			...trace,
+			ports,
+			tenant: tenantId ? createTenant(tenantId) : undefined,
+		};
+	},
+	service: ({
+		ports,
+		input,
+		requestId,
+		trace,
+	}: {
+		ports: AppRuntimePorts;
+		input: AppServiceContextInput;
+		requestId: string;
+		trace: TraceContext;
+	}) => ({
+		requestId,
+		actor: input?.actor ?? createServiceActor("beignet-service"),
+		auth: null,
+		...trace,
+		ports,
+		tenant: createTenant(input?.tenantId ?? "tenant_default"),
+	}),
+});
+`,
+  productionServer: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createNextServer } from "@beignet/next";
+import { createIdempotencyHooks } from "@beignet/core/server";
 import type { AppContext } from "@/app-context";
 import { appPorts } from "@/infra/app-ports";
 import { env } from "@/lib/env";
+import { appContext } from "./context";
 import { providers } from "./providers";
 import { routes } from "./routes";
 
@@ -2503,29 +3019,8 @@ export const server = await createNextServer({
 			DB_AUTH_TOKEN: env.TURSO_DB_AUTH_TOKEN,
 		},
 	},
-	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),
-		};
-	},
+	hooks: [createIdempotencyHooks<AppContext>()],
+	context: appContext,
 	routes,
 	mapUnhandledError: ({ err, ctx }) => {
 		ctx?.ports.logger.error("Unhandled API error", {
@@ -2545,16 +3040,13 @@ export const server = await createNextServer({
 	},
 });
 `,
-  productionServerWithDrizzleTurso: `import { createDevtoolsHooks } from "@beignet/devtools";
+  productionServerWithDrizzleTurso: `import type { beignetServerOnly } from "@beignet/core/server-only";
 import { createNextServer } from "@beignet/next";
-import {
-	createAnonymousActor,
-	createTenant,
-	createUserActor,
-} from "@beignet/core/ports";
+import { createIdempotencyHooks } from "@beignet/core/server";
 import type { AppContext } from "@/app-context";
 import { appPorts } from "@/infra/app-ports";
 import { env } from "@/lib/env";
+import { appContext } from "./context";
 import { providers } from "./providers";
 import { routes } from "./routes";
 
@@ -2567,30 +3059,8 @@ export const server = await createNextServer({
 			DB_AUTH_TOKEN: env.TURSO_DB_AUTH_TOKEN,
 		},
 	},
-	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),
-		};
-	},
+	hooks: [createIdempotencyHooks<AppContext>()],
+	context: appContext,
 	routes,
 	mapUnhandledError: ({ err, ctx }) => {
 		ctx?.ports.logger.error("Unhandled API error", {
@@ -2739,6 +3209,55 @@ try {
 } finally {
 	client.close();
 }
+`,
+  productionDbTestDatabase: `import { existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { OutboxPort } from "@beignet/core/outbox";
+import { createDrizzleTursoOutboxPort } from "@beignet/provider-drizzle-turso";
+import { type Client, createClient } from "@libsql/client";
+import { drizzle, type LibSQLDatabase } from "drizzle-orm/libsql";
+import { createDrizzleAuditLog } from "@/infra/audit/drizzle-audit-log";
+import { ensureStarterDatabase, resetStarterDatabase } from "./bootstrap";
+import { createRepositories } from "./repositories";
+import * as schema from "./schema";
+
+export type TestDatabase = {
+\tclient: Client;
+\tdb: LibSQLDatabase<typeof schema>;
+\taudit: ReturnType<typeof createDrizzleAuditLog>;
+\toutbox: OutboxPort;
+\trepositories: ReturnType<typeof createRepositories>;
+\tpath: string;
+\treset(): Promise<void>;
+\tclose(): Promise<void>;
+};
+
+export async function createTestDatabase(): Promise<TestDatabase> {
+\tconst path = join(tmpdir(), "beignet-test-" + crypto.randomUUID() + ".db");
+\tconst client = createClient({ url: "file:" + path });
+\tawait ensureStarterDatabase(client, { seed: false });
+
+\tconst db = drizzle(client, { schema });
+
+\treturn {
+\t\tclient,
+\t\tdb,
+\t\taudit: createDrizzleAuditLog(db),
+\t\toutbox: createDrizzleTursoOutboxPort(db),
+\t\trepositories: createRepositories(db),
+\t\tpath,
+\t\treset: async () => {
+\t\t\tawait resetStarterDatabase(client);
+\t\t},
+\t\tclose: async () => {
+\t\t\tclient.close();
+\t\t\tif (existsSync(path)) {
+\t\t\t\tunlinkSync(path);
+\t\t\t}
+\t\t},
+\t};
+}
 `,
   productionAuditHelper: `import type { AuditLogEntryInput } from "@beignet/core/ports";
 import type { AppContext } from "@/app-context";
@@ -2771,14 +3290,12 @@ export const TodoCreated = defineEvent("todos.created", {
 
 export const todoEvents = [TodoCreated] as const;
 `,
-  productionTodoJobs: `import { createJobHandlers, retry } from "@beignet/core/jobs";
+  productionTodoJobs: `import { retry } from "@beignet/core/jobs";
 import { z } from "zod";
-import type { AppContext } from "@/app-context";
 import { auditEntry } from "@/lib/audit";
+import { defineJob } from "@/lib/jobs";
 
-const jobs = createJobHandlers<AppContext>();
-
-export const LogTodoCreatedJob = jobs.defineJob("todos.log-created", {
+export const LogTodoCreatedJob = defineJob("todos.log-created", {
 	payload: z.object({
 		todoId: z.string().uuid(),
 		title: z.string(),
@@ -2804,16 +3321,11 @@ export const LogTodoCreatedJob = jobs.defineJob("todos.log-created", {
 
 export const todoJobs = [LogTodoCreatedJob] as const;
 `,
-  productionTodoNotifications: `import {
-	createNotificationHandlers,
-	defineMailNotificationChannel,
-} from "@beignet/core/notifications";
+  productionTodoNotifications: `import { defineMailNotificationChannel } from "@beignet/core/notifications";
 import { z } from "zod";
-import type { AppContext } from "@/app-context";
+import { defineNotification } from "@/lib/notifications";
 
-const notifications = createNotificationHandlers<AppContext>();
-
-export const TodoCreatedNotification = notifications.defineNotification(
+export const TodoCreatedNotification = defineNotification(
 	"todos.created",
 	{
 		payload: z.object({
@@ -2830,16 +3342,13 @@ export const TodoCreatedNotification = notifications.defineNotification(
 	},
 );
 `,
-  productionTodoListeners: `import { createEventHandlers } from "@beignet/core/events";
-import type { AppContext } from "@/app-context";
-import { TodoCreated } from "@/features/todos/domain/events";
+  productionTodoListeners: `import { TodoCreated } from "@/features/todos/domain/events";
 import { LogTodoCreatedJob } from "@/features/todos/jobs";
 import { TodoCreatedNotification } from "@/features/todos/notifications";
 import { auditEntry } from "@/lib/audit";
+import { defineListener } from "@/lib/listeners";
 
-const listeners = createEventHandlers<AppContext>();
-
-export const enqueueTodoCreatedWork = listeners.defineListener(TodoCreated, {
+export const enqueueTodoCreatedWork = defineListener(TodoCreated, {
 	name: "todos.enqueue-created-work",
 	async handle({ ctx, payload }) {
 		await ctx.ports.jobs.dispatch(LogTodoCreatedJob, payload);
@@ -2861,14 +3370,11 @@ export const enqueueTodoCreatedWork = listeners.defineListener(TodoCreated, {
 export const todoListeners = [enqueueTodoCreatedWork] as const;
 `,
   productionTodoSchedules: `import { normalizeOffsetPage } from "@beignet/core/pagination";
-import { createScheduleHandlers } from "@beignet/core/schedules";
 import { z } from "zod";
-import type { AppContext } from "@/app-context";
 import { auditEntry } from "@/lib/audit";
+import { defineSchedule } from "@/lib/schedules";
 
-const schedules = createScheduleHandlers<AppContext>();
-
-export const LogDailyTodoSummarySchedule = schedules.defineSchedule(
+export const LogDailyTodoSummarySchedule = defineSchedule(
 	"todos.log-daily-summary",
 	{
 		cron: "0 9 * * *",
@@ -2912,6 +3418,23 @@ export const LogDailyTodoSummarySchedule = schedules.defineSchedule(
 );
 
 export const todoSchedules = [LogDailyTodoSummarySchedule] as const;
+`,
+  productionSchedules: `import { createServiceActor } from "@beignet/core/ports";
+import type { AppContext } from "@/app-context";
+import { todoSchedules } from "@/features/todos/schedules";
+import { server } from "./index.js";
+
+export const schedules = [...todoSchedules] as const;
+
+export async function createScheduleContext(): Promise<AppContext> {
+	return server.createServiceContext({
+		actor: createServiceActor("beignet-schedule"),
+	});
+}
+
+export async function stopScheduleContext(): Promise<void> {
+	await server.stop();
+}
 `,
   productionTodoUploads: `import { defineUpload, defineUploads } from "@beignet/core/uploads";
 import { z } from "zod";
@@ -2993,13 +3516,26 @@ export const todoUploads = defineUploads({
 });
 `,
   productionOutbox: `import { defineOutboxRegistry } from "@beignet/core/outbox";
+import { createServiceActor } from "@beignet/core/ports";
+import type { AppContext } from "@/app-context";
 import { todoEvents } from "@/features/todos/domain/events";
 import { todoJobs } from "@/features/todos/jobs";
+import { server } from "./index.js";
 
 export const outboxRegistry = defineOutboxRegistry({
 	events: todoEvents,
 	jobs: todoJobs,
 });
+
+export async function createOutboxDrainContext(): Promise<AppContext> {
+	return server.createServiceContext({
+		actor: createServiceActor("beignet-outbox"),
+	});
+}
+
+export async function stopOutboxDrainContext(): Promise<void> {
+	await server.stop();
+}
 `,
   productionOutboxDrainRoute: `import { createOutboxDrainRoute } from "@beignet/next";
 import { env } from "@/lib/env";
@@ -3014,111 +3550,23 @@ export const { GET, POST } = createOutboxDrainRoute({
 	secret: env.CRON_SECRET,
 });
 `,
-  productionScheduleRoute: `import { createInlineScheduleRunner } from "@beignet/core/schedules";
-import type { AppContext } from "@/app-context";
-import { LogDailyTodoSummarySchedule } from "@/features/todos/schedules";
+  productionScheduleRoute: `import { createScheduleRoute } from "@beignet/next";
 import { env } from "@/lib/env";
 import { server } from "@/server";
+import { schedules } from "@/server/schedules";
 
-async function runDailyTodoSummary(request: Request) {
-	if (!env.CRON_SECRET) {
-		return Response.json(
-			{
-				ok: false,
-				error: "CRON_SECRET is not configured.",
-				scheduleName: LogDailyTodoSummarySchedule.name,
-			},
-			{ status: 500 },
-		);
-	}
-
-	if (request.headers.get("authorization") !== \`Bearer \${env.CRON_SECRET}\`) {
-		return Response.json({ error: "Unauthorized" }, { status: 401 });
-	}
-
-	const ctx = await server.createContextFromNext();
-	const runner = createInlineScheduleRunner<AppContext>({
-		ctx,
-		onStart({ run, schedule }) {
-			ctx.ports.devtools.record({
-				type: "schedule",
-				watcher: "schedules",
-				requestId: ctx.requestId,
-				traceId: ctx.traceId,
-				scheduleName: schedule.name,
-				status: "started",
-				cron: schedule.cron,
-				timezone: schedule.timezone,
-				details: {
-					source: run.source,
-					scheduledAt: run.scheduledAt?.toISOString(),
-				},
-			});
-		},
-		onSuccess({ run, schedule }) {
-			ctx.ports.devtools.record({
-				type: "schedule",
-				watcher: "schedules",
-				requestId: ctx.requestId,
-				traceId: ctx.traceId,
-				scheduleName: schedule.name,
-				status: "completed",
-				cron: schedule.cron,
-				timezone: schedule.timezone,
-				details: {
-					source: run.source,
-					scheduledAt: run.scheduledAt?.toISOString(),
-				},
-			});
-		},
-		onError({ error, run, schedule }) {
-			ctx.ports.devtools.record({
-				type: "schedule",
-				watcher: "schedules",
-				requestId: ctx.requestId,
-				traceId: ctx.traceId,
-				scheduleName: schedule.name,
-				status: "failed",
-				cron: schedule.cron,
-				timezone: schedule.timezone,
-				details: {
-					error,
-					source: run.source,
-					scheduledAt: run.scheduledAt?.toISOString(),
-				},
-			});
-			ctx.ports.logger.error("Daily todo summary schedule failed", {
-				error,
-				scheduleName: schedule.name,
-			});
-		},
-	});
-
-	try {
-		await runner.run(LogDailyTodoSummarySchedule, {
-			source: "starter-cron-route",
-		});
-	} catch {
-		return Response.json(
-			{
-				ok: false,
-				error: "Schedule failed",
-				scheduleName: LogDailyTodoSummarySchedule.name,
-			},
-			{ status: 500 },
-		);
-	}
-
-	return Response.json({
-		ok: true,
-		scheduleName: LogDailyTodoSummarySchedule.name,
-	});
-}
+export const runtime = "nodejs";
 
-export const GET = runDailyTodoSummary;
-export const POST = runDailyTodoSummary;
+export const { GET, POST } = createScheduleRoute({
+	server,
+	schedules,
+	schedule: "todos.log-daily-summary",
+	secret: env.CRON_SECRET,
+	source: "starter-cron-route",
+});
 `,
-  productionUploadsRoute: `import { createUploadRouter, uploadsFromRegistry } from "@beignet/core/uploads";
+  productionUploadsRoute: `import { resolveProviderInstrumentationPort } from "@beignet/core/providers";
+import { createUploadRouter, uploadsFromRegistry } from "@beignet/core/uploads";
 import { createUploadRoute } from "@beignet/next";
 import type { AppContext } from "@/app-context";
 import { todoUploads } from "@/features/todos/uploads";
@@ -3128,17 +3576,10 @@ const uploadRouter = createUploadRouter<AppContext>({
 	uploads: uploadsFromRegistry(todoUploads),
 	ctx: () => server.createContextFromNext(),
 	storage: server.ports.storage,
-	instrumentation: server.ports.devtools,
+	instrumentation: resolveProviderInstrumentationPort(server.ports),
 });
 
 export const { POST } = createUploadRoute(uploadRouter);
-`,
-  productionUploadClient: `import { createUploadClient } from "@beignet/core/uploads/client";
-import type { todoUploads } from "@/features/todos/uploads";
-
-export const uploads = createUploadClient<typeof todoUploads>({
-	baseUrl: "/api/uploads",
-});
 `,
 };
 
@@ -3158,6 +3599,73 @@ function productionProviderPortFields(ctx: TemplateContext): string[] {
   return fields;
 }
 
+function productionInfrastructurePortsWithDrizzleTurso(
+  ctx: TemplateContext,
+): string {
+  const deferred = [
+    '\t\t"audit",',
+    hasIntegration(ctx, "better-auth") ? '\t\t"auth",' : undefined,
+    '\t\t"eventBus",',
+    '\t\t"idempotency",',
+    '\t\t"jobs",',
+    '\t\t"logger",',
+    '\t\t"mailer",',
+    '\t\t"notifications",',
+    '\t\t"outbox",',
+    hasIntegration(ctx, "upstash-rate-limit") ? '\t\t"rateLimit",' : undefined,
+    '\t\t"storage",',
+    '\t\t"todoAttachments",',
+    '\t\t"todos",',
+    '\t\t"uow",',
+  ]
+    .filter((entry): entry is string => Boolean(entry))
+    .sort();
+  const bound = [
+    hasIntegration(ctx, "better-auth")
+      ? undefined
+      : "\t\tauth: createAnonymousAuth(),",
+    "\t\tgate,",
+  ].filter((entry): entry is string => Boolean(entry));
+  const imports = [
+    'import { createGate, definePorts } from "@beignet/core/ports";',
+    'import { todoPolicy } from "@/features/todos/policy";',
+    'import { appError } from "@/features/shared/errors";',
+    'import type { AppPorts } from "@/ports";',
+    hasIntegration(ctx, "better-auth")
+      ? undefined
+      : 'import { createAnonymousAuth } from "./auth/anonymous-auth";',
+  ].filter((entry): entry is string => Boolean(entry));
+
+  return `${imports.join("\n")}
+
+const gate = createGate({
+	policies: [todoPolicy],
+	onDeny(decision) {
+		return appError("Forbidden", {
+			message: decision.reason ?? "Forbidden",
+			details: decision.details,
+		});
+	},
+});
+
+/**
+ * App ports the server boots with.
+ *
+ * Bound ports are app-owned. Every deferred key is contributed by a provider
+ * in server/providers.ts during startup; createServer(...) fails boot if any
+ * of them is still unbound after providers have started.
+ */
+export const appPorts = definePorts<AppPorts>()({
+	bound: {
+${bound.join("\n")}
+	},
+	deferred: [
+${deferred.join("\n")}
+	],
+});
+`;
+}
+
 function productionPorts(ctx: TemplateContext): string {
   const mailImport = 'import type { MailerPort } from "@beignet/core/mail";\n';
   const imports = [
@@ -3186,6 +3694,7 @@ import type { TodoAttachmentRepository, TodoRepository } from "@/features/todos/
 export type AppTransactionPorts = {
 	audit: AuditLogPort;
 	events: import("@beignet/core/ports").BufferedDomainEventRecorder;
+	idempotency: IdempotencyPort;
 	jobs: JobDispatcherPort;
 	outbox: OutboxPort;
 	todoAttachments: TodoAttachmentRepository;
@@ -3238,14 +3747,10 @@ import type { AuthorizationContext, todoPolicy } from "@/features/todos/policy";
 import type { AuthPort } from "./auth";
 import type { TodoAttachmentRepository, TodoRepository } from "@/features/todos/ports";
 
-export type AppDatabasePort = {
-	db: unknown;
-	client: unknown;
-};
-
 export type AppTransactionPorts = {
 	audit: AuditLogPort;
 	events: import("@beignet/core/ports").BufferedDomainEventRecorder;
+	idempotency: IdempotencyPort;
 	jobs: JobDispatcherPort;
 	outbox: OutboxPort;
 	todoAttachments: TodoAttachmentRepository;
@@ -3257,7 +3762,6 @@ export type AppGate = BoundGate<[typeof todoPolicy]>;
 export type AppPorts = {
 	audit: AuditLogPort;
 	auth: AuthPort;
-	db: AppDatabasePort;
 	eventBus: EventBusPort;
 	gate: GatePort<AuthorizationContext, [typeof todoPolicy]>;
 	idempotency: IdempotencyPort;
@@ -3276,6 +3780,7 @@ ${providerFields.length > 0 ? `${providerFields.join("\n")}\n` : ""}	uow: UnitOf
 
 function productionServerProviders(ctx: TemplateContext): string {
   const imports = [
+    'import type { beignetServerOnly } from "@beignet/core/server-only";',
     'import { createDevtoolsProvider } from "@beignet/devtools";',
     hasIntegration(ctx, "better-auth")
       ? 'import { createAuthBetterAuthProvider } from "@beignet/provider-auth-better-auth";'
@@ -3329,40 +3834,21 @@ function productionServerProviders(ctx: TemplateContext): string {
 ${declarations}
 export const providers = [
 ${entries.join("\n")}
-];
+] as const;
 `;
 }
 
-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, "upstash-rate-limit")
-      ? "\t\t\trateLimit: createMemoryRateLimiter(),"
-      : undefined,
-  ].filter((entry): entry is string => Boolean(entry));
-
+function productionTodosTest(_ctx: TemplateContext): string {
   return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
-import { createMemoryIdempotencyStore } from "@beignet/core/idempotency";
-import { createMemoryMailer } from "@beignet/core/mail";
-import { createMemoryNotificationPort } from "@beignet/core/notifications";
-import { createMemoryOutbox } from "@beignet/core/outbox";
 import { offsetPageResult, type OffsetPage } from "@beignet/core/pagination";
 import { createInMemoryDevtools } from "@beignet/devtools";
-import { createInMemoryEventBus } from "@beignet/provider-event-bus-memory";
-import { ${["createDomainEventRecorder", "createMemoryAuditLog", ...portImports].join(", ")} } from "@beignet/core/ports";
+import { createDomainEventRecorder } from "@beignet/core/ports";
+import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
+import { createTestUserActor } from "@beignet/core/ports/testing";
 import type { AppContext } from "@/app-context";
 import { appPorts } from "@/infra/app-ports";
+import type { AppTransactionPorts } from "@/ports";
 import {
 	createTodoUseCase,
 	getTodoUseCase,
@@ -3427,14 +3913,6 @@ describe("todos resource", () => {
 	it("creates, gets, and lists todos", async () => {
 		const todos = createTestTodoRepository();
 		const todoAttachments = createTestTodoAttachmentRepository();
-		const audit = createMemoryAuditLog();
-		const eventBus = createInMemoryEventBus();
-		const jobs = { dispatch: async () => undefined };
-		const mailer = createMemoryMailer({
-			defaultFrom: "Test <test@example.local>",
-		});
-		const notifications = createMemoryNotificationPort();
-		const outbox = createMemoryOutbox();
 		const auth = {
 			user: {
 				id: "user_test",
@@ -3443,38 +3921,31 @@ describe("todos resource", () => {
 			},
 			session: { id: "session_test" },
 		};
-		const actor = createUserActor(auth.user.id, {
-			displayName: auth.user.name,
-		});
-		const testPorts = {
-			...appPorts,
-			audit,
-			eventBus,
-			idempotency: createMemoryIdempotencyStore(),
-			jobs,
-			mailer,
-			notifications,
-			outbox,
-			todoAttachments,
-			todos,
-${extraPorts.length > 0 ? `${extraPorts.join("\n")}\n` : ""}			uow: createNoopUnitOfWork(() => ({
-				audit,
-				events: createDomainEventRecorder(),
-				jobs,
-				outbox,
+		const testFixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
+			base: appPorts,
+			overrides: {
+				gate: appPorts.gate,
 				todoAttachments,
 				todos,
-			})) as unknown as AppContext["ports"]["uow"],
-			devtools: createInMemoryDevtools(),
-			storage: createMemoryStorage(),
-		} as unknown as AppContext["ports"];
-		const tester = createUseCaseTester<AppContext>(() => ({
-			requestId: "test-request",
-			actor,
+				devtools: createInMemoryDevtools(),
+			},
+			transaction: {
+				ports: (ports) => ({
+					...ports,
+					events: createDomainEventRecorder(),
+					todoAttachments,
+					todos,
+				}),
+			},
+		});
+		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
+			ports: testFixture.ports,
+			actor: createTestUserActor(auth.user.id, {
+				displayName: auth.user.name,
+			}),
 			auth,
-			gate: testPorts.gate.bind({ actor, auth }),
-			ports: testPorts,
-		}));
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const ctx = await tester.ctx();
 		const created = await tester.run(
@@ -3546,9 +4017,8 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
       path: "app/api/uploads/[uploadName]/[action]/route.ts",
       content: files.productionUploadsRoute,
     },
-    { path: "client/api-client.ts", content: files.apiClient },
-    { path: "client/rq.ts", content: files.rq },
-    { path: "client/uploads.ts", content: files.productionUploadClient },
+    { path: "client/index.ts", content: clientIndex(ctx) },
+    { path: "client/forms.ts", content: files.formsClient },
     {
       path: "features/todos/contracts.ts",
       content: files.productionContractsTodos,
@@ -3559,7 +4029,7 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     {
       path: "infra/app-ports.ts",
       content: usesDrizzleTurso
-        ? files.productionInfrastructurePortsWithDrizzleTurso
+        ? productionInfrastructurePortsWithDrizzleTurso(ctx)
         : files.productionInfrastructurePorts,
     },
     { path: "lib/env.ts", content: files.productionEnv },
@@ -3609,7 +4079,7 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     },
     {
       path: "features/shared/errors.ts",
-      content: files.productimapUnhandledErrors,
+      content: files.productionSharedErrors,
     },
     {
       path: "server/index.ts",
@@ -3617,13 +4087,22 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
         ? files.productionServerWithDrizzleTurso
         : files.productionServer,
     },
+    { path: "server/context.ts", content: files.productionServerContext },
     { path: "server/routes.ts", content: files.productionServerRoutes },
     { path: "server/outbox.ts", content: files.productionOutbox },
+    { path: "server/schedules.ts", content: files.productionSchedules },
     {
       path: "server/providers.ts",
       content: productionServerProviders(ctx),
     },
     { path: "lib/use-case.ts", content: files.productionUseCaseBuilder },
+    { path: "lib/listeners.ts", content: files.productionListenersBuilder },
+    { path: "lib/jobs.ts", content: files.productionJobsBuilder },
+    { path: "lib/schedules.ts", content: files.productionSchedulesBuilder },
+    {
+      path: "lib/notifications.ts",
+      content: files.productionNotificationsBuilder,
+    },
     {
       path: "features/todos/use-cases/create-todo.ts",
       content: files.productionCreateTodoUseCase,
@@ -3641,7 +4120,7 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
       content: files.productionUseCasesIndex,
     },
     {
-      path: "features/todos/use-cases/schemas.ts",
+      path: "features/todos/schemas.ts",
       content: files.productionTodoSchemas,
     },
     {
@@ -3670,6 +4149,10 @@ function getProductionTemplateFiles(ctx: TemplateContext): TemplateFile[] {
         path: "infra/db/reset.ts",
         content: files.productionDbReset,
       },
+      {
+        path: "infra/db/test-database.ts",
+        content: files.productionDbTestDatabase,
+      },
       {
         path: "infra/db/provider.ts",
         content: files.productionDbProvider,
@@ -3716,29 +4199,37 @@ export function getTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     { path: "app/layout.tsx", content: layout(ctx) },
     { path: "app/page.tsx", content: page(ctx) },
     { path: "app/api/[[...path]]/route.ts", content: files.apiCatchAllRoute },
+    { path: "app-context.ts", content: minimalAppContext(ctx) },
     { path: "features/todos/contracts.ts", content: files.contractsTodos },
     { path: "features/todos/routes.ts", content: files.todoRoutes },
-    { path: "ports/index.ts", content: files.ports },
+    { path: "ports/index.ts", content: minimalPorts(ctx) },
     { path: "server/index.ts", content: server(ctx) },
+    { path: "server/context.ts", content: serverContext(ctx) },
     { path: "server/routes.ts", content: files.serverRoutes },
-    { path: "features/todos/use-cases.ts", content: files.useCasesTodos },
+    { path: "features/todos/use-cases/index.ts", content: files.useCasesTodos },
   ];
 
   if (hasFeature(ctx, "client")) {
     templateFiles.push({
-      path: "client/api-client.ts",
-      content: files.apiClient,
+      path: "client/index.ts",
+      content: clientIndex(ctx),
     });
   }
 
   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, "forms")) {
+    templateFiles.push({
+      path: "client/forms.ts",
+      content: files.formsClient,
+    });
+  }
+
   if (hasFeature(ctx, "openapi")) {
     templateFiles.push({
       path: "app/api/openapi/route.ts",
@@ -3746,19 +4237,34 @@ export function getTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     });
   }
 
-  if (
-    ctx.integrations.some((integration) =>
-      ["pino", "inngest", "resend", "upstash-rate-limit"].includes(integration),
-    )
-  ) {
-    templateFiles.push({
-      path: "server/providers.ts",
-      content: serverProviders(ctx),
-    });
+  if (hasIntegration(ctx, "better-auth")) {
+    templateFiles.push(
+      { path: "lib/better-auth.ts", content: files.minimalBetterAuth },
+      {
+        path: "app/api/auth/[...all]/route.ts",
+        content: files.productionAuthRoute,
+      },
+    );
+  }
+
+  if (hasDrizzleTurso(ctx)) {
+    templateFiles.push(
+      { path: "drizzle.config.ts", content: files.productionDrizzleConfig },
+      { path: "infra/db/provider.ts", content: files.minimalDbProvider },
+      { path: "infra/db/schema/index.ts", content: files.minimalDbSchema },
+      {
+        path: "infra/todos/drizzle-todo-repository.ts",
+        content: files.minimalDrizzleTodoRepository,
+      },
+    );
   }
 
   if (ctx.integrations.length > 0) {
     templateFiles.push(
+      {
+        path: "server/providers.ts",
+        content: serverProviders(ctx),
+      },
       {
         path: ".env.example",
         content: envExample(ctx),