@beignet/cli 0.0.3 → 0.0.4

package/dist/templates.js

@@ -1,3 +1,4 @@
+export { featureChoices, integrationChoices, presetChoices, } from "./choices.js";
 const externalVersions = {
     next: "^16.2.4",
     react: "^19.2.5",
@@ -11,9 +12,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",
@@ -30,42 +31,15 @@ function hasDrizzleTurso(ctx) {
 function packageRunner(ctx) {
     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",
-];
-/**
- * Supported scaffold preset choices.
- */
-export const presetChoices = [
-    "minimal",
-    "standard",
-];
-/**
- * Supported scaffold integration choices.
- */
-export const integrationChoices = [
-    "better-auth",
-    "drizzle-turso",
-    "inngest",
-    "pino",
-    "resend",
-    "upstash-rate-limit",
-];
 const integrationDeps = {
     "better-auth": {
         "@beignet/provider-auth-better-auth": "",
@@ -158,6 +132,7 @@ function packageJson(ctx) {
         }
     }
     const devDependencies = {
+        "@beignet/cli": ctx.beignetVersion,
         "@types/bun": externalVersions.typesBun,
         "@types/node": externalVersions.typesNode,
         "@types/react": externalVersions.typesReact,
@@ -170,6 +145,7 @@ function packageJson(ctx) {
         }
     }
     const scripts = {
+        beignet: "beignet",
         dev: "next dev",
         build: "next build",
         start: "next start",
@@ -179,8 +155,12 @@ function packageJson(ctx) {
     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({
         name: ctx.name,
@@ -200,12 +180,28 @@ function readme(ctx) {
     const run = 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")
         : "- API routes only";
     const integrationList = 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}
 
 Beignet app scaffolded with \`@beignet/cli\`.
@@ -214,19 +210,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
 
@@ -247,6 +245,9 @@ function standardReadme(ctx) {
     const run = 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"
         : `${ctx.packageManager} run typecheck`;
@@ -267,10 +268,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
 
@@ -284,15 +299,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.
@@ -309,6 +341,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" : ""}
 `;
@@ -322,13 +356,32 @@ function integrationsDoc(ctx) {
     ];
     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 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.", "");
+            lines.push("## Better Auth", "", "- Package: `@beignet/provider-auth-better-auth`", "- Peer dependency: `better-auth`", "- 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.",
+                ]), "");
         }
         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 \`${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.`, "");
+            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`.", ...(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\`.`, ...(isStandardPreset(ctx)
+                ? [
+                    `- Run \`${packageRunner(ctx)} db seed\` for idempotent starter data and \`${packageRunner(ctx)} db reset\` for destructive local resets.`,
+                ]
+                : []), "");
         }
         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.", "");
+            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 `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.", "");
         }
         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.", "");
@@ -367,7 +420,7 @@ function envExample(ctx) {
         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", "");
+        lines.push("UPSTASH_REDIS_REST_URL=", "UPSTASH_REDIS_REST_TOKEN=", "UPSTASH_PREFIX=beignet:ratelimit", "");
     }
     if (hasIntegration(ctx, "better-auth")) {
         lines.push("BETTER_AUTH_SECRET=local-dev-better-auth-secret-change-me", "BETTER_AUTH_URL=http://localhost:3000", "# BETTER_AUTH_TRUSTED_ORIGINS=http://localhost:3000", "");
@@ -432,6 +485,11 @@ function page(ctx) {
 					<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>
@@ -455,6 +513,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>
@@ -463,47 +529,91 @@ export default function HomePage() {
 `;
 }
 function serverProviders(ctx) {
-    const imports = [];
+    const packageImports = [];
+    const appImports = [];
+    const declarations = [];
     const entries = [];
+    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('import { loggerPinoProvider } from "@beignet/provider-logger-pino";');
+        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('import { inngestProvider } from "@beignet/provider-inngest";');
+        packageImports.push('import { inngestProvider } from "@beignet/provider-inngest";');
         entries.push("inngestProvider");
     }
     if (hasIntegration(ctx, "resend")) {
-        imports.push('import { mailResendProvider } from "@beignet/provider-mail-resend";');
+        packageImports.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";');
+        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) {
+    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) {
-    const hasProviders = ctx.integrations.some((integration) => ["pino", "inngest", "resend", "upstash-rate-limit"].includes(integration));
-    return `import { createNextServer } from "@beignet/next";
+    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 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
@@ -544,17 +654,128 @@ ${hasProviders ? "\tproviders,\n" : ""}	createContext: async ({ ports }) => ({
 });
 `;
 }
+function minimalPorts(ctx) {
+    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) {
+    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) {
     const listTodosQueryOptions = ctx.preset === "standard" ? "{ query: {} }" : "";
     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() {
@@ -567,19 +788,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">
@@ -595,6 +818,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">
@@ -624,8 +850,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("");
@@ -635,15 +861,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) => {
@@ -684,6 +908,55 @@ export function TodoApp() {
 }
 `;
 }
+function clientIndex(ctx) {
+    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
@@ -784,6 +1057,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;
@@ -910,32 +1206,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(),
@@ -1000,15 +1290,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>();
 
@@ -1025,7 +1445,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();
@@ -1047,33 +1467,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>([
@@ -1131,24 +1541,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: {
@@ -1207,13 +1621,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";
@@ -1231,9 +1668,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")
@@ -1248,9 +1686,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")
@@ -1265,10 +1704,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")
@@ -1308,7 +1748,7 @@ export {
 	type CreateTodoInput,
 	type ListTodosInput,
 	type Todo,
-} from "./schemas";
+} from "../schemas";
 `,
     productionTodoRepositoryPort: `import type {
 	OffsetPage,
@@ -1318,7 +1758,7 @@ export {
 import type {
 	CreateTodoInput,
 	Todo,
-} from "@/features/todos/use-cases/schemas";
+} from "@/features/todos/schemas";
 
 export type ListTodosResult = PageResult<Todo, OffsetPageInfo>;
 
@@ -1411,11 +1851,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,
@@ -1497,27 +1938,7 @@ export const appPorts = definePorts({
 	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 { 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 {
@@ -1689,8 +2110,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 {
@@ -1700,7 +2147,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;
@@ -1814,7 +2261,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),
@@ -1867,7 +2317,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 = {
@@ -1961,6 +2411,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(),
 ];
 
@@ -1987,6 +2438,7 @@ const resetTables = [
 	"todo_attachments",
 	"todos",
 	"audit_log",
+	"idempotency_records",
 	"outbox_messages",
 ] as const;
 
@@ -2025,7 +2477,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";
@@ -2034,19 +2485,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,
@@ -2056,42 +2503,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",
@@ -2125,12 +2560,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,
@@ -2142,34 +2577,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();
@@ -2178,14 +2631,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(),
@@ -2193,7 +2648,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const todos = createContractGroup()
+const todos = defineContractGroup()
 	.namespace("todos")
 	.errors({ Unauthorized: errors.Unauthorized })
 	.responses({
@@ -2202,28 +2657,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 {
@@ -2235,31 +2691,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";
 
@@ -2268,16 +2707,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";
 
@@ -2290,29 +2785,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", {
@@ -2332,16 +2806,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";
 
@@ -2354,30 +2825,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", {
@@ -2526,6 +2975,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";
@@ -2558,14 +3056,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(),
@@ -2591,16 +3087,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({
@@ -2617,16 +3108,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);
@@ -2648,14 +3136,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 * * *",
@@ -2699,6 +3184,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";
@@ -2780,13 +3282,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";
@@ -2801,111 +3316,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";
@@ -2915,17 +3342,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",
-});
 `,
 };
 function productionProviderPortImports(ctx) {
@@ -2942,6 +3362,69 @@ function productionProviderPortFields(ctx) {
     }
     return fields;
 }
+function productionInfrastructurePortsWithDrizzleTurso(ctx) {
+    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) => Boolean(entry))
+        .sort();
+    const bound = [
+        hasIntegration(ctx, "better-auth")
+            ? undefined
+            : "\t\tauth: createAnonymousAuth(),",
+        "\t\tgate,",
+    ].filter((entry) => 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) => 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) {
     const mailImport = 'import type { MailerPort } from "@beignet/core/mail";\n';
     const imports = [
@@ -2969,6 +3452,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;
@@ -3019,14 +3503,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;
@@ -3038,7 +3518,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;
@@ -3056,6 +3535,7 @@ ${providerFields.length > 0 ? `${providerFields.join("\n")}\n` : ""}	uow: UnitOf
 }
 function productionServerProviders(ctx) {
     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";'
@@ -3107,38 +3587,20 @@ function productionServerProviders(ctx) {
 ${declarations}
 export const providers = [
 ${entries.join("\n")}
-];
+] as const;
 `;
 }
-function productionTodosTest(ctx) {
-    const portImports = [
-        hasIntegration(ctx, "upstash-rate-limit")
-            ? "createMemoryRateLimiter"
-            : undefined,
-        "createMemoryStorage",
-        "createNoopUnitOfWork",
-        "createUserActor",
-    ].filter((item) => 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) => Boolean(entry));
+function productionTodosTest(_ctx) {
     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,
@@ -3203,14 +3665,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",
@@ -3219,38 +3673,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(
@@ -3321,9 +3768,8 @@ function getProductionTemplateFiles(ctx) {
             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,
@@ -3334,7 +3780,7 @@ function getProductionTemplateFiles(ctx) {
         {
             path: "infra/app-ports.ts",
             content: usesDrizzleTurso
-                ? files.productionInfrastructurePortsWithDrizzleTurso
+                ? productionInfrastructurePortsWithDrizzleTurso(ctx)
                 : files.productionInfrastructurePorts,
         },
         { path: "lib/env.ts", content: files.productionEnv },
@@ -3384,7 +3830,7 @@ function getProductionTemplateFiles(ctx) {
         },
         {
             path: "features/shared/errors.ts",
-            content: files.productimapUnhandledErrors,
+            content: files.productionSharedErrors,
         },
         {
             path: "server/index.ts",
@@ -3392,13 +3838,22 @@ function getProductionTemplateFiles(ctx) {
                 ? 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,
@@ -3416,7 +3871,7 @@ function getProductionTemplateFiles(ctx) {
             content: files.productionUseCasesIndex,
         },
         {
-            path: "features/todos/use-cases/schemas.ts",
+            path: "features/todos/schemas.ts",
             content: files.productionTodoSchemas,
         },
         {
@@ -3438,6 +3893,9 @@ function getProductionTemplateFiles(ctx) {
         }, {
             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,
@@ -3478,21 +3936,29 @@ export function getTemplateFiles(ctx) {
         { 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) });
+        templateFiles.push({ path: "app/providers.tsx", content: files.appProviders }, { 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({
@@ -3500,14 +3966,23 @@ export function getTemplateFiles(ctx) {
             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 (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),
         }, {