@flaredev/cli 0.4.1 → 0.5.1

package/dist/index.js

@@ -9,8 +9,8 @@ import { FLARE_VERSION as FLARE_VERSION3 } from "@flaredev/core";
 
 // src/commands/create.ts
 import { randomBytes } from "crypto";
-import { appendFileSync, copyFileSync, existsSync as existsSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
+import { appendFileSync, copyFileSync, existsSync as existsSync3, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename, dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2 } from "path";
 import * as prompts from "@clack/prompts";
 import pc from "picocolors";
 import { FLARE_VERSION } from "@flaredev/core";
@@ -186,42 +186,94 @@ var APP_DEV_DEPENDENCIES = {
   vite: "^8.3.0",
   wrangler: "^4.132.0"
 };
+var NEXT_DEPENDENCIES = {
+  next: "16.0.4",
+  "@prisma/client": "7.10.0",
+  "@prisma/adapter-pg": "7.10.0",
+  pg: "^8.16.3",
+  "@upstash/redis": "^1.36.0",
+  "@better-auth/prisma-adapter": "1.7.5",
+  // Signs S3 requests in a few kilobytes, where the AWS SDK is megabytes.
+  aws4fetch: "^1.0.20",
+  dotenv: "^17.2.3"
+};
+var NEXT_DEV_DEPENDENCIES = {
+  prisma: "7.10.0",
+  // Runs seeds: the generated Prisma client is TypeScript a bundler compiles.
+  tsx: "^4.23.13",
+  "@types/node": "^22.20.3",
+  "@types/react": "^19.3.0",
+  "@types/react-dom": "^19.3.0",
+  "@tailwindcss/postcss": "^4.3.3",
+  tailwindcss: "^4.3.3",
+  typescript: "~5.9.3"
+};
+var CLOUDFLARE_ONLY = [
+  "wrangler.jsonc",
+  "vite.config.ts",
+  "worker",
+  "db",
+  "migrations",
+  "drizzle.config.ts",
+  ".dev.vars.example",
+  "worker-configuration.d.ts"
+];
+
+// src/stack.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var STACKS = ["cloudflare", "next"];
+var isStack = (value) => STACKS.includes(value);
+var STACK_LABELS = {
+  cloudflare: "Cloudflare Workers, D1 and Drizzle \u2014 cheapest to run, deploys everywhere",
+  next: "Next.js on Vercel, Neon Postgres and Prisma \u2014 real Postgres, Node runtime"
+};
+function readStack(appRoot) {
+  const file = join(appRoot, "package.json");
+  if (!existsSync(file)) return "cloudflare";
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return isStack(parsed.flare?.stack) ? parsed.flare.stack : "cloudflare";
+  } catch {
+    return "cloudflare";
+  }
+}
 
 // src/utils/fs.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
 var RENAMES = { _gitignore: ".gitignore" };
 function copyTemplate(from, to, tokens) {
   mkdirSync(to, { recursive: true });
   let files = 0;
   for (const entry of readdirSync(from)) {
-    const src = join(from, entry);
-    const dest = join(to, RENAMES[entry] ?? entry);
+    const src = join2(from, entry);
+    const dest = join2(to, RENAMES[entry] ?? entry);
     if (statSync(src).isDirectory()) {
       files += copyTemplate(src, dest, tokens);
       continue;
     }
-    const content = readFileSync(src, "utf8").replace(/__([A-Z_]+)__/g, (match, key) => tokens[key] ?? match);
-    writeFileSync(dest, content);
+    const content = readFileSync2(src, "utf8").replace(/__([A-Z_]+)__/g, (match, key) => tokens[key] ?? match);
+    writeFileSync2(dest, content);
     files++;
   }
   return files;
 }
 function writeJson(path, value) {
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(value, null, 2) + "\n");
+  writeFileSync2(path, JSON.stringify(value, null, 2) + "\n");
 }
 function findUp(file, start) {
   let dir = resolve(start);
   while (true) {
-    if (existsSync(join(dir, file))) return dir;
+    if (existsSync2(join2(dir, file))) return dir;
     const parent = dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
-var templatesDir = join(findUp("templates", dirname(fileURLToPath(import.meta.url))), "templates");
+var templatesDir = join2(findUp("templates", dirname(fileURLToPath(import.meta.url))), "templates");
 
 // src/utils/pm.ts
 import { spawnSync } from "child_process";
@@ -260,7 +312,7 @@ function toAppName(dir) {
 function flarePackageSpec(pkg, appDir, packageManager) {
   const repoPackage = resolve2(templatesDir, "../..", pkg);
   const repoRoot = resolve2(repoPackage, "../..");
-  const fromCheckout = existsSync2(join2(repoPackage, "package.json")) && existsSync2(join2(repoRoot, "pnpm-workspace.yaml")) && !repoPackage.split(/[\\/]/).includes("node_modules");
+  const fromCheckout = existsSync3(join3(repoPackage, "package.json")) && existsSync3(join3(repoRoot, "pnpm-workspace.yaml")) && !repoPackage.split(/[\\/]/).includes("node_modules");
   if (!fromCheckout) return `^${FLARE_VERSION}`;
   const rel = relative(repoRoot, appDir);
   if (rel && !rel.startsWith("..") && !isAbsolute(rel)) return "workspace:*";
@@ -270,32 +322,54 @@ function flarePackageSpec(pkg, appDir, packageManager) {
 function createApp(target, options2 = {}) {
   const dir = resolve2(target);
   const name = toAppName(dir);
-  if (existsSync2(dir) && readdirSync2(dir).length > 0) {
+  if (existsSync3(dir) && readdirSync2(dir).length > 0) {
     throw new Error(`Directory ${dir} already exists and is not empty.`);
   }
   if (options2.pm !== void 0 && !isPackageManager(options2.pm)) {
     throw new Error(`Unknown package manager "${options2.pm}". Use pnpm, npm, yarn, or bun.`);
   }
   const packageManager = options2.pm ?? detectPackageManager();
+  if (options2.stack !== void 0 && !isStack(options2.stack)) {
+    throw new Error(`Unknown stack "${options2.stack}". Use ${STACKS.join(" or ")}.`);
+  }
+  const stack = options2.stack ?? "cloudflare";
   const authProviders = parseAuthProviders(options2.authProviders);
   const authMethods = parseAuthMethods(options2.auth);
   const theme = parseTheme(options2.theme);
   const inWorkspace = findUp("pnpm-workspace.yaml", dirname2(dir)) !== void 0;
   const compatibilityDate = options2.compatibilityDate ?? COMPATIBILITY_DATE;
-  const files = copyTemplate(join2(templatesDir, "app"), dir, {
+  const files = copyTemplate(join3(templatesDir, "app"), dir, {
     APP_NAME: name,
     COMPAT_DATE: compatibilityDate,
     PM: packageManager,
     THEME: theme
   });
-  writeFileSync2(join2(dir, "lib", "auth-config.ts"), renderAuthConfig(authMethods, authProviders));
-  appendFileSync(join2(dir, ".dev.vars.example"), devVarsExampleEntries(authProviders));
-  writeJson(join2(dir, "package.json"), {
+  if (stack === "next") {
+    copyTemplate(join3(templatesDir, "next"), dir, { APP_NAME: name, PM: packageManager, THEME: theme });
+    for (const path of CLOUDFLARE_ONLY) rmSync(join3(dir, path), { recursive: true, force: true });
+  }
+  writeFileSync3(join3(dir, "lib", "auth-config.ts"), renderAuthConfig(authMethods, authProviders));
+  appendFileSync(join3(dir, stack === "next" ? ".env.example" : ".dev.vars.example"), devVarsExampleEntries(authProviders));
+  const shared = { react: APP_DEPENDENCIES.react, "react-dom": APP_DEPENDENCIES["react-dom"] };
+  const uiOnly = Object.fromEntries(
+    Object.entries(APP_DEPENDENCIES).filter(([key]) => !["vinext", "@vinext/cloudflare", "drizzle-orm", "react-server-dom-webpack"].includes(key))
+  );
+  writeJson(join3(dir, "package.json"), {
     name,
     version: "0.1.0",
     private: true,
     type: "module",
-    scripts: {
+    // Which stack this app targets. `flare gen` reads it; don't change it by hand.
+    flare: { stack },
+    scripts: stack === "next" ? {
+      dev: "next dev",
+      build: "prisma generate && next build",
+      start: "next start",
+      deploy: "vercel deploy --prod",
+      "db:generate": "prisma generate",
+      "db:migrate": "prisma migrate dev",
+      "db:studio": "prisma studio"
+    } : {
       dev: "flare dev",
       build: "flare build",
       start: "flare start",
@@ -304,18 +378,25 @@ function createApp(target, options2 = {}) {
       "db:generate": "drizzle-kit generate",
       "db:migrate:local": "wrangler d1 migrations apply DB --local"
     },
-    dependencies: { "@flaredev/core": flarePackageSpec("core", dir, packageManager), ...APP_DEPENDENCIES },
-    devDependencies: { "@flaredev/cli": flarePackageSpec("cli", dir, packageManager), ...APP_DEV_DEPENDENCIES }
+    dependencies: {
+      "@flaredev/core": flarePackageSpec("core", dir, packageManager),
+      ...stack === "next" ? { ...uiOnly, ...shared, ...NEXT_DEPENDENCIES } : APP_DEPENDENCIES
+    },
+    devDependencies: {
+      "@flaredev/cli": flarePackageSpec("cli", dir, packageManager),
+      ...stack === "next" ? NEXT_DEV_DEPENDENCIES : APP_DEV_DEPENDENCIES
+    }
   });
-  writeFileSync2(
-    join2(dir, ".dev.vars"),
+  writeFileSync3(
+    join3(dir, stack === "next" ? ".env" : ".dev.vars"),
     `BETTER_AUTH_SECRET=${randomBytes(32).toString("base64")}
 RESEND_API_KEY=
 MAIL_FROM=
 ${devVarsEntries(authProviders)}`
   );
   if (packageManager === "pnpm" && !inWorkspace) {
-    writeFileSync2(join2(dir, "pnpm-workspace.yaml"), "allowBuilds:\n  esbuild: true\n  workerd: true\n  sharp: false\n");
+    const allowBuilds = stack === "next" ? "allowBuilds:\n  '@prisma/engines': true\n  prisma: true\n  sharp: false\n" : "allowBuilds:\n  esbuild: true\n  workerd: true\n  sharp: false\n";
+    writeFileSync3(join3(dir, "pnpm-workspace.yaml"), allowBuilds);
   }
   const pinned = flarePackageSpec("core", dir, packageManager).startsWith("^");
   if (pinned) copyLockfile(packageManager, dir);
@@ -326,9 +407,9 @@ ${devVarsEntries(authProviders)}`
 function copyLockfile(packageManager, dir) {
   const file = packageManager === "pnpm" ? "pnpm-lock.yaml" : packageManager === "yarn" ? "yarn.lock" : "package-lock.json";
   if (!file) return false;
-  const source = join2(templatesDir, "locks", file);
-  if (!existsSync2(source)) return false;
-  copyFileSync(source, join2(dir, file));
+  const source = join3(templatesDir, "locks", file);
+  if (!existsSync3(source)) return false;
+  copyFileSync(source, join3(dir, file));
   return true;
 }
 function printNextSteps(result, installed) {
@@ -348,8 +429,8 @@ function printNextSteps(result, installed) {
 }
 
 // src/commands/gen-billing.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
 import pc6 from "picocolors";
 
 // src/generator/grammar.ts
@@ -513,7 +594,7 @@ import { defineResource, field as builders, kebabCase, pascalCase } from "@flare
 
 // src/generator/markers.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname3 } from "path";
 var START = "// generated:start";
 var END = "// generated:end";
@@ -563,8 +644,8 @@ ${indentBlock(body, indent)}${indent}${END}
 ${after}`;
 }
 function inspectGenerated(path, content) {
-  if (!existsSync3(path)) return "missing";
-  const parts = splitMarkers(readFileSync2(path, "utf8"));
+  if (!existsSync4(path)) return "missing";
+  const parts = splitMarkers(readFileSync3(path, "utf8"));
   if (!parts) return "unmarked";
   if (parts.hash && hashBlock(parts.block) !== parts.hash) return "drift";
   if (normalize(parts.block) !== normalize(content)) return "outdated";
@@ -580,18 +661,18 @@ var DriftError = class extends Error {
 };
 function writeGenerated(path, content, options2 = {}) {
   const hash = hashBlock(content);
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     mkdirSync2(dirname3(path), { recursive: true });
-    writeFileSync3(path, joinMarkers({ before: options2.header ?? "", block: content, after: "", indent: "", hash }));
+    writeFileSync4(path, joinMarkers({ before: options2.header ?? "", block: content, after: "", indent: "", hash }));
     return "create";
   }
-  const source = readFileSync2(path, "utf8");
+  const source = readFileSync3(path, "utf8");
   const parts = splitMarkers(source);
   if (!parts) throw new Error(`${path} exists but has no generated block; refusing to overwrite hand-written code.`);
   if (parts.hash && hashBlock(parts.block) !== parts.hash && !options2.force) throw new DriftError(path);
   const next = joinMarkers({ ...parts, block: content, hash });
   if (next === source) return "identical";
-  writeFileSync3(path, next);
+  writeFileSync4(path, next);
   return "update";
 }
 
@@ -1346,17 +1427,17 @@ var billingDevVarsExampleEntries = () => [
 ].join("\n");
 
 // src/generator/load.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
-import { join as join3, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
 import { createJiti } from "jiti";
 async function loadResources(root) {
   const appRoot = resolve3(root);
-  const dir = join3(appRoot, "resources");
-  if (!existsSync4(dir)) return [];
-  const jiti = createJiti(join3(appRoot, "package.json"), { alias: { "@": appRoot }, moduleCache: false, fsCache: false });
+  const dir = join4(appRoot, "resources");
+  if (!existsSync5(dir)) return [];
+  const jiti = createJiti(join4(appRoot, "package.json"), { alias: { "@": appRoot }, moduleCache: false, fsCache: false });
   const loaded = [];
   for (const file of readdirSync3(dir).filter((name) => name.endsWith(".resource.ts")).sort()) {
-    const path = join3(dir, file);
+    const path = join4(dir, file);
     const mod = await jiti.import(path);
     const resource = mod.default;
     if (!resource || typeof resource !== "object" || !("fields" in resource) || !("table" in resource)) {
@@ -1374,20 +1455,20 @@ async function loadResources(root) {
 
 // src/generator/migrations.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } from "path";
 
 // src/commands/run.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join7, resolve as resolve4 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname4, join as join8, resolve as resolve4 } from "path";
 import pc4 from "picocolors";
 
 // src/tunnel.ts
 import { spawn, spawnSync as spawnSync2 } from "child_process";
-import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync3, renameSync, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import pc2 from "picocolors";
 var TUNNEL_URL = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
 var LOCAL_URL = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0):\d+/;
@@ -1412,7 +1493,7 @@ function releaseAsset(platform = process.platform, arch = process.arch) {
   throw new Error(`No cloudflared build for ${platform}/${arch}. Install it yourself: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/`);
 }
 var binName = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
-var cacheDir = () => join4(homedir(), ".flare", "bin");
+var cacheDir = () => join5(homedir(), ".flare", "bin");
 function onPath() {
   const probe = spawnSync2(process.platform === "win32" ? "where" : "which", ["cloudflared"], { encoding: "utf8" });
   return probe.status === 0 ? probe.stdout.split(/\r?\n/)[0]?.trim() ?? null : null;
@@ -1421,19 +1502,19 @@ async function download(log2) {
   const asset = releaseAsset();
   const dir = cacheDir();
   mkdirSync3(dir, { recursive: true });
-  const target = join4(dir, binName);
+  const target = join5(dir, binName);
   log2(pc2.dim(`Downloading cloudflared (one time) into ${dir}\u2026`));
   const response = await fetch(`https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`);
   if (!response.ok) throw new Error(`Downloading cloudflared failed: HTTP ${response.status}.`);
   const bytes = Buffer.from(await response.arrayBuffer());
   const partial = `${target}.download`;
   if (asset.endsWith(".tgz")) {
-    writeFileSync4(`${partial}.tgz`, bytes);
+    writeFileSync5(`${partial}.tgz`, bytes);
     const untar = spawnSync2("tar", ["-xzf", `${partial}.tgz`, "-C", dir], { encoding: "utf8" });
-    rmSync(`${partial}.tgz`, { force: true });
+    rmSync2(`${partial}.tgz`, { force: true });
     if (untar.status !== 0) throw new Error(`Unpacking cloudflared failed: ${untar.stderr}`);
   } else {
-    writeFileSync4(partial, bytes);
+    writeFileSync5(partial, bytes);
     renameSync(partial, target);
   }
   if (process.platform !== "win32") chmodSync(target, 493);
@@ -1442,8 +1523,8 @@ async function download(log2) {
 async function ensureCloudflared(log2 = console.log) {
   const found = onPath();
   if (found) return found;
-  const cached = join4(cacheDir(), binName);
-  if (existsSync5(cached)) return cached;
+  const cached = join5(cacheDir(), binName);
+  if (existsSync6(cached)) return cached;
   return download(log2);
 }
 async function openTunnel(localUrl, options2 = {}) {
@@ -1499,16 +1580,16 @@ function tunnelBanner(publicUrl, localUrl) {
 
 // src/commands/deploy.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 import { createZoneClient } from "@flaredev/core/security";
 import { createJiti as createJiti2 } from "jiti";
 import pc3 from "picocolors";
 
 // src/utils/wrangler.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
 import { parse as parseJsonc } from "jsonc-parser";
 function runWrangler(wranglerBin, args, cwd, options2 = {}) {
   return new Promise((resolve6, reject) => {
@@ -1533,9 +1614,9 @@ ${output.trim()}`);
   return JSON.parse(output.slice(start, end + 1));
 }
 function readD1Databases(appRoot) {
-  const path = join5(appRoot, "wrangler.jsonc");
-  if (!existsSync6(path)) return [];
-  const config = parseJsonc(readFileSync3(path, "utf8"));
+  const path = join6(appRoot, "wrangler.jsonc");
+  if (!existsSync7(path)) return [];
+  const config = parseJsonc(readFileSync4(path, "utf8"));
   return (config?.d1_databases ?? []).filter((db) => db.binding && db.database_name);
 }
 
@@ -1575,15 +1656,15 @@ function declaredSecretNames(devVarsExample) {
   return devVarsExample.split(/\r?\n/).map((line) => /^([A-Z][A-Z0-9_]*)=/.exec(line.trim())?.[1]).filter((name) => Boolean(name));
 }
 async function loadSecurityConfig(appRoot) {
-  const path = join6(appRoot, "security.config.ts");
-  if (!existsSync7(path)) return null;
-  const jiti = createJiti2(join6(appRoot, "package.json"), { moduleCache: false, fsCache: false });
+  const path = join7(appRoot, "security.config.ts");
+  if (!existsSync8(path)) return null;
+  const jiti = createJiti2(join7(appRoot, "package.json"), { moduleCache: false, fsCache: false });
   const mod = await jiti.import(path);
   if (!mod.default) throw new Error("security.config.ts must `export default defineSecurity({ ... })`.");
   return mod.default;
 }
 async function provisionZoneSecurity(appRoot, config, credentials, options2) {
-  const app = JSON.parse(readFileSync4(join6(appRoot, "package.json"), "utf8")).name ?? "app";
+  const app = JSON.parse(readFileSync5(join7(appRoot, "package.json"), "utf8")).name ?? "app";
   const zone = createZoneClient({ ...credentials, app, fetch: options2.fetch });
   if (config.zone?.rateLimits) {
     const result = await zone.syncRateLimits(config.zone.rateLimits);
@@ -1603,7 +1684,7 @@ async function runDeploy(args, context3) {
   const envArgs = plan.env ? ["--env", plan.env] : [];
   const step = (message) => log2(`
 ${pc3.bold(pc3.cyan("flare"))} ${message}`);
-  const databases = plan.skipMigrations ? [] : readD1Databases(appRoot).filter((db) => existsSync7(join6(appRoot, db.migrations_dir ?? "migrations")));
+  const databases = plan.skipMigrations ? [] : readD1Databases(appRoot).filter((db) => existsSync8(join7(appRoot, db.migrations_dir ?? "migrations")));
   const migrateAfterDeploy = [];
   const migrate2 = async (db) => {
     step(`Applying migrations to ${db.database_name} (remote)`);
@@ -1662,8 +1743,8 @@ ${put.output.trim()}`);
         existing.add(name);
       }
     }
-    const examplePath = join6(appRoot, ".dev.vars.example");
-    const optional = existsSync7(examplePath) ? declaredSecretNames(readFileSync4(examplePath, "utf8")).filter((name) => !existing.has(name)) : [];
+    const examplePath = join7(appRoot, ".dev.vars.example");
+    const optional = existsSync8(examplePath) ? declaredSecretNames(readFileSync5(examplePath, "utf8")).filter((name) => !existing.has(name)) : [];
     if (optional.length > 0) {
       step("Optional secrets not set in production (features using them stay off):");
       for (const name of optional) log2(`  wrangler secret put ${name}${plan.env ? ` --env ${plan.env}` : ""}`);
@@ -1698,25 +1779,30 @@ function findAppRoot(cwd) {
   while (dir) {
     const root = findUp("package.json", dir);
     if (!root) break;
-    const pkg = JSON.parse(readFileSync5(join7(root, "package.json"), "utf8"));
-    if (pkg.dependencies?.vinext || pkg.devDependencies?.vinext) return root;
+    const pkg = JSON.parse(readFileSync6(join8(root, "package.json"), "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["@flaredev/core"] || deps.vinext) return root;
     const parent = dirname4(root);
     dir = parent === root ? void 0 : parent;
   }
-  throw new Error("Not inside a Flare app (no package.json depending on vinext found). Run this from your app directory.");
+  throw new Error("Not inside a Flare app (no package.json depending on @flaredev/core found). Run this from your app directory.");
 }
 function resolveBin(appRoot, pkgName, binName2) {
-  const pkgDir = findUp(join7("node_modules", pkgName, "package.json"), appRoot);
+  const pkgDir = findUp(join8("node_modules", pkgName, "package.json"), appRoot);
   if (!pkgDir) {
     throw new Error(`Cannot find ${pkgName} in ${appRoot}. Install dependencies first (e.g. pnpm install).`);
   }
-  const manifestPath = join7(pkgDir, "node_modules", pkgName, "package.json");
-  const { bin } = JSON.parse(readFileSync5(manifestPath, "utf8"));
+  const manifestPath = join8(pkgDir, "node_modules", pkgName, "package.json");
+  const { bin } = JSON.parse(readFileSync6(manifestPath, "utf8"));
   const relativeBin = typeof bin === "string" ? bin : bin?.[binName2];
   if (!relativeBin) throw new Error(`${pkgName} does not provide a "${binName2}" executable.`);
-  return join7(dirname4(manifestPath), relativeBin);
+  return join8(dirname4(manifestPath), relativeBin);
 }
 function delegatedArgv(appRoot, command, forwarded) {
+  if (readStack(appRoot) === "next") {
+    const script = { dev: "npm run dev", build: "npm run build", start: "npm start", deploy: "npm run deploy" }[command];
+    throw new Error(`\`flare ${command}\` is for the Cloudflare stack. This app targets Next.js \u2014 run \`${script}\` instead.`);
+  }
   const spec = DELEGATED_COMMANDS[command];
   return [resolveBin(appRoot, spec.pkg, spec.bin), ...spec.args, ...forwarded];
 }
@@ -1775,7 +1861,7 @@ async function runDelegated(command, forwarded, cwd = process.cwd()) {
   const tunnel = (command === "dev" || command === "start") && forwarded.includes("--tunnel");
   if (tunnel) forwarded = forwarded.filter((arg) => arg !== "--tunnel");
   const wantsHelp = forwarded.includes("--help") || forwarded.includes("-h");
-  if (command === "start" && !wantsHelp && !existsSync8(join7(appRoot, "dist/server/wrangler.json"))) {
+  if (command === "start" && !wantsHelp && !existsSync9(join8(appRoot, "dist/server/wrangler.json"))) {
     console.log("No production build found; running `flare build` first.\n");
     const code = await runNode(delegatedArgv(appRoot, "build", []), appRoot);
     if (code !== 0) return code;
@@ -1825,9 +1911,9 @@ function snapshotColumns(snapshot) {
 }
 
 // src/generator/migrations.ts
-var listSql = (dir) => existsSync9(dir) ? readdirSync4(dir).filter((file) => file.endsWith(".sql")) : [];
+var listSql = (dir) => existsSync10(dir) ? readdirSync4(dir).filter((file) => file.endsWith(".sql")) : [];
 async function generateSchemaMigration(appRoot, name, options2 = {}) {
-  const dir = join8(appRoot, "migrations");
+  const dir = join9(appRoot, "migrations");
   const before = new Set(listSql(dir));
   const bin = resolveBin(appRoot, "drizzle-kit", "drizzle-kit");
   const { code, output } = await new Promise((resolve6, reject) => {
@@ -1855,10 +1941,10 @@ If it asked whether a column was renamed, run \`pnpm exec drizzle-kit generate\`
   for (const file of created) {
     const previous = previousSnapshot(dir, file);
     if (!previous) continue;
-    const path = join8(dir, file);
-    const { sql: sql2, changes } = repairRebuildMigration(readFileSync6(path, "utf8"), snapshotColumns(previous));
+    const path = join9(dir, file);
+    const { sql: sql2, changes } = repairRebuildMigration(readFileSync7(path, "utf8"), snapshotColumns(previous));
     if (changes.length) {
-      writeFileSync5(path, sql2);
+      writeFileSync6(path, sql2);
       repairs.push(...changes.map((change) => `${file}: ${change}`));
     }
   }
@@ -1866,32 +1952,32 @@ If it asked whether a column was renamed, run \`pnpm exec drizzle-kit generate\`
 }
 function previousSnapshot(dir, migrationFile) {
   const prefix = /^(\d+)_/.exec(migrationFile)?.[1];
-  const metaDir = join8(dir, "meta");
-  if (!prefix || !existsSync9(metaDir)) return void 0;
+  const metaDir = join9(dir, "meta");
+  if (!prefix || !existsSync10(metaDir)) return void 0;
   const earlier = readdirSync4(metaDir).filter((file) => /^\d+_snapshot\.json$/.test(file) && file < `${prefix}_snapshot.json`).sort().pop();
-  return earlier ? JSON.parse(readFileSync6(join8(metaDir, earlier), "utf8")) : void 0;
+  return earlier ? JSON.parse(readFileSync7(join9(metaDir, earlier), "utf8")) : void 0;
 }
 
 // src/generator/plan.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync6, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync4, readdirSync as readdirSync6, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
 import pc5 from "picocolors";
 
 // src/generator/policy.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5 } from "fs";
-import { join as join9, resolve as resolve5 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync5 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
 import { camelCase as camelCase2, kebabCase as kebabCase2 } from "@flaredev/core";
 import { createJiti as createJiti3 } from "jiti";
 var policyPath = (name) => `policies/${kebabCase2(name)}.policy.ts`;
 var policyLocal = (stem) => `${camelCase2(stem)}Policy`;
 async function loadPolicies(root) {
   const appRoot = resolve5(root);
-  const dir = join9(appRoot, "policies");
-  if (!existsSync10(dir)) return [];
-  const jiti = createJiti3(join9(appRoot, "package.json"), { moduleCache: false, fsCache: false });
+  const dir = join10(appRoot, "policies");
+  if (!existsSync11(dir)) return [];
+  const jiti = createJiti3(join10(appRoot, "package.json"), { moduleCache: false, fsCache: false });
   const loaded = [];
   for (const file of readdirSync5(dir).filter((name) => name.endsWith(".policy.ts")).sort()) {
-    const mod = await jiti.import(join9(dir, file));
+    const mod = await jiti.import(join10(dir, file));
     const policy = mod.default;
     if (!policy || typeof policy !== "object" || !("resource" in policy) || !Array.isArray(policy.read)) {
       throw new Error(`policies/${file} must \`export default definePolicy({ ... })\`.`);
@@ -1936,15 +2022,136 @@ function renderPolicyRegistry(all) {
   ].join("\n");
 }
 
-// src/generator/render.ts
-import { camelCase as camelCase3, columnName, relationGraph, storedFields } from "@flaredev/core";
-var resourceLocal = (stem) => `${camelCase3(stem)}Resource`;
-var tableExport = (resource) => camelCase3(resource.table);
+// src/generator/prisma.ts
+import { camelCase as camelCase3, columnName, pascalCase as pascalCase2, pluralize, storedFields } from "@flaredev/core";
 var q = (value) => JSON.stringify(value);
+var enumTypeName = (resource, key) => `${pascalCase2(resource)}${pascalCase2(key)}`;
+var enumMember = (option) => {
+  const safe = option.replace(/[^A-Za-z0-9_]/g, "_").replace(/^(?=\d)/, "v_");
+  return safe === option ? `  ${safe}` : `  ${safe} @map(${q(option)})`;
+};
+function prismaType(resource, key, def) {
+  switch (def.kind) {
+    case "int":
+      return "Int";
+    case "float":
+      return "Float";
+    case "boolean":
+      return "Boolean";
+    case "date":
+    case "datetime":
+      return "DateTime";
+    case "enum":
+      return enumTypeName(resource.name, key);
+    case "multiselect":
+      return "String[]";
+    default:
+      return "String";
+  }
+}
+function attributes(key, def) {
+  const parts = [];
+  const column = columnName(key);
+  if (column !== key) parts.push(`@map(${q(column)})`);
+  if ("unique" in def && def.unique) parts.push("@unique");
+  if (def.kind === "text") parts.push("@db.Text");
+  if (def.kind === "date") parts.push("@db.Date");
+  if ("default" in def && def.default !== void 0) {
+    const value = def.default;
+    if (def.kind === "enum") parts.push(`@default(${String(value).replace(/[^A-Za-z0-9_]/g, "_")})`);
+    else if (def.kind === "multiselect") parts.push(`@default([${value.map(q).join(", ")}])`);
+    else parts.push(`@default(${typeof value === "string" ? q(value) : String(value)})`);
+  }
+  return parts;
+}
+var onDeleteAction = (onDelete) => onDelete === "set null" ? "SetNull" : onDelete === "cascade" ? "Cascade" : "Restrict";
+function renderPrismaEnums(resource) {
+  return storedFields(resource).filter(([, def]) => def.kind === "enum").map(([key, def]) => {
+    if (def.kind !== "enum") return "";
+    return [`enum ${enumTypeName(resource.name, key)} {`, ...def.options.map(enumMember), "}"].join("\n");
+  }).filter(Boolean);
+}
+function backReferences(target, all) {
+  const found = [];
+  for (const { resource: source } of all) {
+    const pointing = storedFields(source).filter(([, def]) => def.kind === "belongsTo" && def.target === target.name);
+    const ambiguous = pointing.length > 1;
+    for (const [key, def] of pointing) {
+      if (def.kind !== "belongsTo") continue;
+      const declared = Object.entries(target.fields).find(([, other]) => other.kind === "hasMany" && other.target === source.name)?.[0];
+      const base = ambiguous ? camelCase3(`${key.replace(/Id$/, "")} ${pluralize(source.name)}`) : declared ?? camelCase3(pluralize(source.name));
+      found.push({ field: base, from: source.name, relationName: ambiguous ? `${source.name}_${key}` : void 0 });
+    }
+  }
+  return found;
+}
+function renderPrismaModel(entry, all) {
+  const resource = entry.resource;
+  const byName = new Map(all.map((item) => [item.resource.name, item.resource]));
+  const lines = [`model ${resource.name} {`, `  id String @id @default(uuid())`];
+  const indexes = [];
+  for (const [key, def] of Object.entries(resource.fields)) {
+    if (def.kind === "hasMany") {
+      if (!byName.get(def.target)) {
+        throw new Error(`${resource.name}.${key} has many "${def.target}", but there is no ${def.target} resource. Generate it first.`);
+      }
+      continue;
+    }
+    if (def.kind === "belongsTo") {
+      const target = byName.get(def.target);
+      if (!target) throw new Error(`${resource.name}.${key} belongs to "${def.target}", but there is no ${def.target} resource. Generate it first.`);
+      const optional2 = def.required ? "" : "?";
+      const relationField = key.replace(/Id$/, "");
+      const named = backReferences(target, all).find((back) => back.from === resource.name && back.relationName?.endsWith(`_${key}`));
+      const relationArgs = [
+        ...named?.relationName ? [q(named.relationName)] : [],
+        `fields: [${key}]`,
+        "references: [id]",
+        `onDelete: ${onDeleteAction(def.onDelete)}`
+      ];
+      lines.push(`  ${key} String${optional2} @map(${q(columnName(key))})`);
+      lines.push(`  ${relationField} ${target.name}${optional2} @relation(${relationArgs.join(", ")})`);
+      indexes.push(`  @@index([${key}])`);
+      continue;
+    }
+    const optional = def.required || def.kind === "multiselect" ? "" : "?";
+    lines.push(`  ${key} ${prismaType(resource, key, def)}${optional} ${attributes(key, def).join(" ")}`.trimEnd());
+  }
+  for (const back of backReferences(resource, all)) {
+    const args = back.relationName ? `@relation(${q(back.relationName)})` : "";
+    lines.push(`  ${back.field} ${back.from}[] ${args}`.trimEnd());
+  }
+  lines.push(`  createdAt DateTime @default(now()) @map("created_at")`);
+  lines.push(`  updatedAt DateTime @updatedAt @map("updated_at")`);
+  indexes.push(`  @@index([createdAt])`);
+  const sortField = resource.defaultSort.field;
+  if (!["createdAt", "updatedAt"].includes(sortField) && resource.fields[sortField]) indexes.push(`  @@index([${sortField}])`);
+  for (const [key, def] of storedFields(resource)) {
+    if (def.kind === "enum" && def.filterable !== false) indexes.push(`  @@index([${key}])`);
+  }
+  lines.push("", ...[...new Set(indexes)], `  @@map(${q(resource.table)})`, "}");
+  return lines.join("\n");
+}
+function renderPrismaSchema(all) {
+  const ordered = [...all].sort((a, b) => a.resource.name.localeCompare(b.resource.name));
+  const blocks = [];
+  for (const entry of ordered) {
+    blocks.push(...renderPrismaEnums(entry.resource));
+    blocks.push(renderPrismaModel(entry, all));
+  }
+  return `${blocks.join("\n\n")}
+`;
+}
+
+// src/generator/render.ts
+import { camelCase as camelCase4, columnName as columnName2, relationGraph, storedFields as storedFields2 } from "@flaredev/core";
+var resourceLocal = (stem) => `${camelCase4(stem)}Resource`;
+var tableExport = (resource) => camelCase4(resource.table);
+var q2 = (value) => JSON.stringify(value);
 var sqlString = (value) => `'${value.replace(/'/g, "''")}'`;
 var TIMESTAMP_DEFAULT = "sql`(cast(unixepoch('subsecond') * 1000 as integer))`";
 function columnExpression(key, def, resources, selfName) {
-  const col = q(columnName(key));
+  const col = q2(columnName2(key));
   let expr;
   switch (def.kind) {
     case "int":
@@ -1957,10 +2164,10 @@ function columnExpression(key, def, resources, selfName) {
       expr = `integer(${col}, { mode: "boolean" })`;
       break;
     case "enum":
-      expr = `text(${col}, { enum: ${q(def.options)} })`;
+      expr = `text(${col}, { enum: ${q2(def.options)} })`;
       break;
     case "multiselect":
-      expr = `text(${col}, { mode: "json" }).$type<(${def.options.map((option) => q(option)).join(" | ")})[]>()`;
+      expr = `text(${col}, { mode: "json" }).$type<(${def.options.map((option) => q2(option)).join(" | ")})[]>()`;
       break;
     case "belongsTo": {
       const target = resources.get(def.target);
@@ -1968,7 +2175,7 @@ function columnExpression(key, def, resources, selfName) {
         throw new Error(`${selfName}.${key} belongs to "${def.target}", but there is no ${def.target} resource. Generate it first.`);
       }
       const onDelete = def.onDelete ?? "restrict";
-      expr = `text(${col}).references(() => ${tableExport(target)}.id, { onDelete: ${q(onDelete)} })`;
+      expr = `text(${col}).references(() => ${tableExport(target)}.id, { onDelete: ${q2(onDelete)} })`;
       break;
     }
     default:
@@ -1976,13 +2183,13 @@ function columnExpression(key, def, resources, selfName) {
   }
   if (def.required) expr += ".notNull()";
   if ("unique" in def && def.unique) expr += ".unique()";
-  if ("default" in def && def.default !== void 0) expr += `.default(${q(def.default)})`;
+  if ("default" in def && def.default !== void 0) expr += `.default(${q2(def.default)})`;
   return expr;
 }
 function renderTableModule(entry, all) {
   const { resource } = entry;
   const resources = new Map(all.map((item) => [item.resource.name, item.resource]));
-  const fields = storedFields(resource);
+  const fields = storedFields2(resource);
   const name = tableExport(resource);
   const columns = fields.map(([key, def]) => `    ${key}: ${columnExpression(key, def, resources, resource.name)},`);
   const extras = [];
@@ -1990,12 +2197,12 @@ function renderTableModule(entry, all) {
   const addIndex = (key, column) => {
     if (indexed.has(key)) return;
     indexed.add(key);
-    extras.push(`    index(${q(`${resource.table}_${columnName(column)}_idx`)}).on(table.${key}),`);
+    extras.push(`    index(${q2(`${resource.table}_${columnName2(column)}_idx`)}).on(table.${key}),`);
   };
   for (const [key, def] of fields) {
     if (def.kind === "enum") {
       const options2 = def.options.map(sqlString).join(", ");
-      extras.push(`    check(${q(`${resource.table}_${columnName(key)}_check`)}, sql\`\${table.${key}} in (${options2})\`),`);
+      extras.push(`    check(${q2(`${resource.table}_${columnName2(key)}_check`)}, sql\`\${table.${key}} in (${options2})\`),`);
       if (def.filterable !== false) addIndex(key, key);
     }
     if (def.kind === "belongsTo") addIndex(key, key);
@@ -2017,7 +2224,7 @@ function renderTableModule(entry, all) {
     ...targets.map((target) => `import { ${tableExport(target)} } from "./${target.table}";`),
     "",
     `export const ${name} = sqliteTable(`,
-    `  ${q(resource.table)},`,
+    `  ${q2(resource.table)},`,
     "  {",
     `    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),`,
     ...columns.map(
@@ -2057,12 +2264,12 @@ function renderRelations(all) {
         const target = byName.get(relation.target);
         used.add(target);
         const other = tableExport(target);
-        return `  ${relation.name}: one(${other}, { fields: [${self}.${relation.key}], references: [${other}.id], relationName: ${q(relation.relationName)} }),`;
+        return `  ${relation.name}: one(${other}, { fields: [${self}.${relation.key}], references: [${other}.id], relationName: ${q2(relation.relationName)} }),`;
       }),
       ...hasMany.map((relation) => {
         const target = byName.get(relation.target);
         used.add(target);
-        return `  ${relation.key}: many(${tableExport(target)}, { relationName: ${q(relation.relationName)} }),`;
+        return `  ${relation.key}: many(${tableExport(target)}, { relationName: ${q2(relation.relationName)} }),`;
       })
     ];
     const helpers = [belongsTo.length ? "one" : "", hasMany.length ? "many" : ""].filter(Boolean).join(", ");
@@ -2075,32 +2282,40 @@ ${lines.join("\n")}
   const imports = [...used].sort((a, b) => a.table.localeCompare(b.table)).map((resource) => `import { ${tableExport(resource)} } from "./schema/${resource.table}";`);
   return [`import { relations } from "drizzle-orm";`, ...imports, "", blocks.join("\n")].join("\n");
 }
-var handlerImports = (entry) => [
-  `import { createResourceHandlers } from "@flaredev/core/server";`,
-  `import { getDb } from "@/db";`,
-  `import { ${tableExport(entry.resource)} } from "@/db/schema";`,
-  `import { authorize, currentUser } from "@/lib/api";`,
-  `import { revalidateResource } from "@/lib/cache";`,
-  `import ${resourceLocal(entry.stem)} from "@/resources/${entry.stem}.resource";`,
-  "",
-  `const handlers = createResourceHandlers({`,
-  `  resource: ${resourceLocal(entry.stem)},`,
-  `  table: ${tableExport(entry.resource)},`,
-  `  getDb,`,
-  `  authorize,`,
-  `  currentUser,`,
-  `  onChange: revalidateResource,`,
-  `});`,
-  ""
-];
-function renderCollectionRoute(entry) {
-  return [...handlerImports(entry), "export const GET = handlers.collection.GET;", "export const POST = handlers.collection.POST;", ""].join(
+var handlerImports = (entry, stack = "cloudflare") => {
+  const local = resourceLocal(entry.stem);
+  const source = stack === "next" ? {
+    imports: [`import { prismaRows } from "@flaredev/core/server";`, `import { prisma } from "@/lib/db";`],
+    wiring: [`  rows: prismaRows(prisma.${camelCase4(entry.resource.name)}, prisma),`]
+  } : {
+    imports: [`import { getDb } from "@/db";`, `import { ${tableExport(entry.resource)} } from "@/db/schema";`],
+    wiring: [`  table: ${tableExport(entry.resource)},`, `  getDb,`]
+  };
+  return [
+    `import { createResourceHandlers } from "@flaredev/core/server";`,
+    ...source.imports,
+    `import { authorize, currentUser } from "@/lib/api";`,
+    `import { revalidateResource } from "@/lib/cache";`,
+    `import ${local} from "@/resources/${entry.stem}.resource";`,
+    "",
+    `const handlers = createResourceHandlers({`,
+    `  resource: ${local},`,
+    ...source.wiring,
+    `  authorize,`,
+    `  currentUser,`,
+    `  onChange: revalidateResource,`,
+    `});`,
+    ""
+  ];
+};
+function renderCollectionRoute(entry, stack = "cloudflare") {
+  return [...handlerImports(entry, stack), "export const GET = handlers.collection.GET;", "export const POST = handlers.collection.POST;", ""].join(
     "\n"
   );
 }
-function renderItemRoute(entry) {
+function renderItemRoute(entry, stack = "cloudflare") {
   return [
-    ...handlerImports(entry),
+    ...handlerImports(entry, stack),
     "export const GET = handlers.item.GET;",
     "export const PATCH = handlers.item.PATCH;",
     "export const PUT = handlers.item.PUT;",
@@ -2179,7 +2394,7 @@ function renderClient(entry) {
     `import { createResourceClient } from "@flaredev/core/client";`,
     `import type ${local} from "./${stem}.resource";`,
     "",
-    `export const ${camelCase3(stem)}Client = createResourceClient<typeof ${local}>(${q(`/api/${resource.slug}`)});`,
+    `export const ${camelCase4(stem)}Client = createResourceClient<typeof ${local}>(${q2(`/api/${resource.slug}`)});`,
     "",
     `export type ${resource.name} = typeof ${local}.$types.record;`,
     `export type ${resource.name}Create = typeof ${local}.$types.create;`,
@@ -2193,7 +2408,7 @@ function renderValidators(entry) {
     `import { createValidators } from "@flaredev/core";`,
     `import ${local} from "./${entry.stem}.resource";`,
     "",
-    `export const ${camelCase3(entry.stem)}Validators = createValidators(${local});`,
+    `export const ${camelCase4(entry.stem)}Validators = createValidators(${local});`,
     ""
   ].join("\n");
 }
@@ -2223,12 +2438,31 @@ function renderServerRegistry(all) {
     ""
   ].join("\n");
 }
-function resourceFiles(entry, all) {
+function renderPrismaServerRegistry(all) {
+  if (all.length === 0) return "export const resourceTables = {} as const;\n";
+  const sorted = [...all].sort((a, b) => a.resource.name.localeCompare(b.resource.name));
+  return [
+    `import { prisma } from "@/lib/db";`,
+    `import { ${sorted.map(({ stem }) => resourceLocal(stem)).join(", ")} } from "./index";`,
+    "",
+    "export const resourceTables = {",
+    ...sorted.map(
+      ({ resource, stem }) => `  ${resource.name}: { resource: ${resourceLocal(stem)}, delegate: prisma.${camelCase4(resource.name)} },`
+    ),
+    "} as const;",
+    "",
+    "export type ResourceName = keyof typeof resourceTables;",
+    ""
+  ].join("\n");
+}
+function resourceFiles(entry, all, stack = "cloudflare") {
   const { resource, stem } = entry;
   return [
-    { path: `db/schema/${resource.table}.ts`, content: renderTableModule(entry, all) },
-    { path: `app/api/${resource.slug}/route.ts`, content: renderCollectionRoute(entry) },
-    { path: `app/api/${resource.slug}/[id]/route.ts`, content: renderItemRoute(entry) },
+    // The schema is the one file that belongs to a stack. On Next.js every model lives
+    // in one prisma/schema.prisma, written by planFiles rather than per resource.
+    ...stack === "cloudflare" ? [{ path: `db/schema/${resource.table}.ts`, content: renderTableModule(entry, all) }] : [],
+    { path: `app/api/${resource.slug}/route.ts`, content: renderCollectionRoute(entry, stack) },
+    { path: `app/api/${resource.slug}/[id]/route.ts`, content: renderItemRoute(entry, stack) },
     { path: `resources/${stem}.client.ts`, content: renderClient(entry) },
     { path: `resources/${stem}.validators.ts`, content: renderValidators(entry) },
     { path: `app/dashboard/${resource.slug}/page.tsx`, content: renderAdminListPage(entry) },
@@ -2243,21 +2477,42 @@ var resourceHeader = (name) => `// Generated by \`flare gen resource ${name}\`.
 // rewritten on regeneration; add your own code outside it.
 `;
 var HEADER_PATTERN = /^\/\/ Generated by `flare gen resource (\w+)`/;
-function planFiles(all, policies) {
+function planFiles(all, policies, stack = "cloudflare") {
   const files = [];
   for (const entry of all) {
-    for (const file of resourceFiles(entry, all)) files.push({ ...file, header: resourceHeader(entry.resource.name) });
-  }
-  files.push(
-    { path: "db/relations.ts", content: renderRelations(all), header: "// Drizzle relations for every resource (maintained by flare gen).\n" },
-    { path: "resources/index.ts", content: renderRegistry(all), header: "// Registry of every resource descriptor (maintained by flare gen).\n" },
-    {
-      path: "resources/server.ts",
-      content: renderServerRegistry(all),
-      header: "// Server-only: resource name \u2192 descriptor and table (maintained by flare gen).\n"
-    },
-    { path: "db/schema.ts", content: renderSchemaIndex(all) }
-  );
+    for (const file of resourceFiles(entry, all, stack)) files.push({ ...file, header: resourceHeader(entry.resource.name) });
+  }
+  files.push({
+    path: "resources/index.ts",
+    content: renderRegistry(all),
+    header: "// Registry of every resource descriptor (maintained by flare gen).\n"
+  });
+  if (stack === "next") {
+    files.push(
+      // Prisma keeps every model in one schema and writes its own migrations, so there
+      // is no per-table module and no relations file to maintain.
+      {
+        path: "prisma/schema/resources.prisma",
+        content: renderPrismaSchema(all),
+        header: "// Generated from the descriptors in resources/. Edit a descriptor, not this.\n"
+      },
+      {
+        path: "resources/server.ts",
+        content: renderPrismaServerRegistry(all),
+        header: "// Server-only: resource name \u2192 descriptor and Prisma delegate (maintained by flare gen).\n"
+      }
+    );
+  } else {
+    files.push(
+      { path: "db/relations.ts", content: renderRelations(all), header: "// Drizzle relations for every resource (maintained by flare gen).\n" },
+      {
+        path: "resources/server.ts",
+        content: renderServerRegistry(all),
+        header: "// Server-only: resource name \u2192 descriptor and table (maintained by flare gen).\n"
+      },
+      { path: "db/schema.ts", content: renderSchemaIndex(all) }
+    );
+  }
   if (policies) {
     files.push({
       path: "policies/index.ts",
@@ -2269,7 +2524,7 @@ function planFiles(all, policies) {
 }
 function applyPlan(appRoot, plan, options2 = {}) {
   return plan.map(({ path, content, header }) => {
-    const absolute = join10(appRoot, path);
+    const absolute = join11(appRoot, path);
     const status = inspectGenerated(absolute, content);
     if (status === "unmarked") return { path, status, outcome: "skipped-unmarked" };
     if (status === "drift" && !options2.force) return { path, status, outcome: "skipped-drift" };
@@ -2288,30 +2543,30 @@ function applyPlan(appRoot, plan, options2 = {}) {
 function findOrphans(appRoot, all) {
   const planned = new Set(planFiles(all).map((file) => file.path));
   const candidates = [];
-  const list2 = (dir, match) => existsSync11(join10(appRoot, dir)) ? readdirSync6(join10(appRoot, dir)).filter(match).map((name) => `${dir}/${name}`) : [];
+  const list2 = (dir, match) => existsSync12(join11(appRoot, dir)) ? readdirSync6(join11(appRoot, dir)).filter(match).map((name) => `${dir}/${name}`) : [];
   candidates.push(...list2("db/schema", (name) => name.endsWith(".ts")));
   candidates.push(...list2("resources", (name) => /\.(client|validators)\.ts$/.test(name)));
   for (const dir of list2("app/api", () => true)) {
-    for (const file of [`${dir}/route.ts`, `${dir}/[id]/route.ts`]) if (existsSync11(join10(appRoot, file))) candidates.push(file);
+    for (const file of [`${dir}/route.ts`, `${dir}/[id]/route.ts`]) if (existsSync12(join11(appRoot, file))) candidates.push(file);
   }
   for (const dir of list2("app/dashboard", () => true)) {
     for (const file of [`${dir}/page.tsx`, `${dir}/new/page.tsx`, `${dir}/[id]/page.tsx`, `${dir}/[id]/edit/page.tsx`]) {
-      if (existsSync11(join10(appRoot, file))) candidates.push(file);
+      if (existsSync12(join11(appRoot, file))) candidates.push(file);
     }
   }
   const orphans = [];
   for (const path of candidates) {
-    const match = HEADER_PATTERN.exec(readFileSync7(join10(appRoot, path), "utf8"));
+    const match = HEADER_PATTERN.exec(readFileSync8(join11(appRoot, path), "utf8"));
     if (match && !planned.has(path)) orphans.push({ path, resource: match[1] });
   }
   return orphans;
 }
 function ensureSupportFiles(appRoot, log2) {
   for (const path of ["lib/api.ts", "lib/cache.ts"]) {
-    const target = join10(appRoot, path);
-    if (existsSync11(target)) continue;
+    const target = join11(appRoot, path);
+    if (existsSync12(target)) continue;
     mkdirSync4(dirname5(target), { recursive: true });
-    copyFileSync2(join10(templatesDir, "app", path), target);
+    copyFileSync2(join11(templatesDir, "app", path), target);
     log2(`${pc5.green("create".padEnd(9))} ${path}`);
   }
 }
@@ -2339,15 +2594,15 @@ function billingFiles(appName) {
 }
 var RETIRED_FILES = ["app/api/billing/status/route.ts", "components/billing/subscribe-button.tsx"];
 function appendVars(appRoot, target) {
-  const path = join11(appRoot, target);
-  const text = existsSync12(path) ? readFileSync8(path, "utf8") : "";
+  const path = join12(appRoot, target);
+  const text = existsSync13(path) ? readFileSync9(path, "utf8") : "";
   if (/STRIPE_SECRET_KEY/.test(text)) return false;
   appendFileSync2(path, target === ".dev.vars" ? billingDevVarsEntries() : billingDevVarsExampleEntries());
   return true;
 }
 function addStripeDependency(appRoot) {
-  const path = join11(appRoot, "package.json");
-  const pkg = JSON.parse(readFileSync8(path, "utf8"));
+  const path = join12(appRoot, "package.json");
+  const pkg = JSON.parse(readFileSync9(path, "utf8"));
   pkg.dependencies ??= {};
   if (pkg.dependencies.stripe) return false;
   pkg.dependencies.stripe = STRIPE_DEP;
@@ -2356,14 +2611,14 @@ function addStripeDependency(appRoot) {
 }
 function writeBillingResource(appRoot, name, force, log2) {
   const relative2 = descriptorPath(name);
-  const path = join11(appRoot, relative2);
-  if (!existsSync12(path)) {
+  const path = join12(appRoot, relative2);
+  if (!existsSync13(path)) {
     mkdirSync5(dirname6(path), { recursive: true });
-    writeFileSync6(path, renderBillingDescriptor(name));
+    writeFileSync7(path, renderBillingDescriptor(name));
     log2(`${pc6.green("create".padEnd(9))} ${relative2}`);
     return;
   }
-  const parts = splitMarkers(readFileSync8(path, "utf8"));
+  const parts = splitMarkers(readFileSync9(path, "utf8"));
   if (!parts) throw new Error(`${relative2} has no generated fields block, so the billing fields can't be merged. Add them by hand: ${BILLING_RESOURCES[name]}`);
   const merged = mergeBillingFields(name, parts.block);
   if (!merged) {
@@ -2387,26 +2642,26 @@ async function genBilling(options2 = {}) {
   for (const name of ["Plan", "Customer", "Purchase"]) writeBillingResource(appRoot, name, options2.force, log2);
   for (const [name, roles] of Object.entries(BILLING_POLICIES)) {
     const relative2 = policyPath(name);
-    if (existsSync12(join11(appRoot, relative2))) {
+    if (existsSync13(join12(appRoot, relative2))) {
       log2(`${pc6.dim("kept".padEnd(9))} ${relative2} (already exists)`);
       continue;
     }
-    mkdirSync5(join11(appRoot, "policies"), { recursive: true });
-    writeFileSync6(join11(appRoot, relative2), renderPolicy(name, roles));
+    mkdirSync5(join12(appRoot, "policies"), { recursive: true });
+    writeFileSync7(join12(appRoot, relative2), renderPolicy(name, roles));
     log2(`${pc6.green("create".padEnd(9))} ${relative2}`);
   }
   const files = [];
-  const appName = JSON.parse(readFileSync8(join11(appRoot, "package.json"), "utf8")).name ?? "app";
+  const appName = JSON.parse(readFileSync9(join12(appRoot, "package.json"), "utf8")).name ?? "app";
   for (const { path, content } of billingFiles(appName)) {
-    const outcome = writeGenerated(join11(appRoot, path), content, { header: billingHeader(), force: options2.force });
+    const outcome = writeGenerated(join12(appRoot, path), content, { header: billingHeader(), force: options2.force });
     files.push({ path, status: "missing", outcome });
     const label = outcome === "create" ? pc6.green("create") : outcome === "update" ? pc6.yellow("update") : pc6.dim("identical");
     log2(`${label.padEnd(18)} ${path}`);
   }
   for (const path of RETIRED_FILES) {
-    const absolute = join11(appRoot, path);
-    if (!existsSync12(absolute)) continue;
-    const parts = splitMarkers(readFileSync8(absolute, "utf8"));
+    const absolute = join12(appRoot, path);
+    if (!existsSync13(absolute)) continue;
+    const parts = splitMarkers(readFileSync9(absolute, "utf8"));
     const untouched = parts && parts.before.includes("flare gen billing") && !parts.after.trim() && parts.hash !== void 0 && hashBlock(parts.block) === parts.hash;
     if (untouched) {
       unlinkSync(absolute);
@@ -2427,7 +2682,7 @@ async function genBilling(options2 = {}) {
   }
   const all = await loadResources(appRoot);
   ensureSupportFiles(appRoot, log2);
-  logResults(applyPlan(appRoot, planFiles(all, await loadPolicies(appRoot)), { force: options2.force }), log2);
+  logResults(applyPlan(appRoot, planFiles(all, await loadPolicies(appRoot), readStack(appRoot)), { force: options2.force }), log2);
   let migrations = [];
   if (!options2.skipMigration) {
     const result = await generateSchemaMigration(appRoot, "billing");
@@ -2450,8 +2705,8 @@ async function genBilling(options2 = {}) {
 }
 
 // src/commands/gen-security.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname7, join as join12 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname7, join as join13 } from "path";
 import pc7 from "picocolors";
 
 // src/generator/security.ts
@@ -2979,28 +3234,28 @@ function securityFiles(appName) {
 }
 var PASS_THROUGH_HEADER = /^\/\/ Request protection for worker\/index\.ts\.[\s\S]*?\n(?=\/\/ generated:start)/;
 function writeOnce(appRoot, relative2, content, log2) {
-  const path = join12(appRoot, relative2);
-  if (existsSync13(path)) {
+  const path = join13(appRoot, relative2);
+  if (existsSync14(path)) {
     log2(`${pc7.dim("kept".padEnd(9))} ${relative2} (already exists)`);
     return;
   }
   mkdirSync6(dirname7(path), { recursive: true });
-  writeFileSync7(path, content);
+  writeFileSync8(path, content);
   log2(`${pc7.green("create".padEnd(9))} ${relative2}`);
 }
 async function genSecurity(options2 = {}) {
   const log2 = options2.log ?? ((message) => console.log(message));
   const appRoot = findAppRoot(options2.cwd ?? process.cwd());
-  const appName = JSON.parse(readFileSync9(join12(appRoot, "package.json"), "utf8")).name ?? "app";
+  const appName = JSON.parse(readFileSync10(join13(appRoot, "package.json"), "utf8")).name ?? "app";
   writeOnce(appRoot, "security.config.ts", renderSecurityConfig(), log2);
   writeOnce(appRoot, descriptorPath("SecurityEvent"), renderSecurityDescriptor(), log2);
   writeOnce(appRoot, policyPath("SecurityEvent"), renderPolicy("SecurityEvent", SECURITY_EVENT_POLICY), log2);
   const files = [];
   const write = (path, content, header) => {
-    const absolute = join12(appRoot, path);
-    if (path === "lib/security.ts" && existsSync13(absolute)) {
-      const source = readFileSync9(absolute, "utf8");
-      if (PASS_THROUGH_HEADER.test(source)) writeFileSync7(absolute, source.replace(PASS_THROUGH_HEADER, securityHeader()));
+    const absolute = join13(appRoot, path);
+    if (path === "lib/security.ts" && existsSync14(absolute)) {
+      const source = readFileSync10(absolute, "utf8");
+      if (PASS_THROUGH_HEADER.test(source)) writeFileSync8(absolute, source.replace(PASS_THROUGH_HEADER, securityHeader()));
     }
     const outcome = writeGenerated(absolute, content, { header, force: options2.force });
     files.push({ path, status: "missing", outcome });
@@ -3008,16 +3263,16 @@ async function genSecurity(options2 = {}) {
     log2(`${label.padEnd(18)} ${path}`);
   };
   for (const { path, content } of securityFiles(appName)) write(path, content, securityHeader());
-  const navPath = join12(appRoot, "lib/dashboard-nav.ts");
-  if (existsSync13(navPath) && splitMarkers(readFileSync9(navPath, "utf8"))) write("lib/dashboard-nav.ts", renderAdminNavBlock());
+  const navPath = join13(appRoot, "lib/dashboard-nav.ts");
+  if (existsSync14(navPath) && splitMarkers(readFileSync10(navPath, "utf8"))) write("lib/dashboard-nav.ts", renderAdminNavBlock());
   else log2(pc7.yellow(`lib/dashboard-nav.ts not found: link to /dashboard/security from your dashboard sidebar yourself.`));
-  const wranglerPath = join12(appRoot, "wrangler.jsonc");
+  const wranglerPath = join13(appRoot, "wrangler.jsonc");
   let bindings = [];
-  if (existsSync13(wranglerPath)) {
-    const { text, added } = addSecurityBindings(readFileSync9(wranglerPath, "utf8"));
+  if (existsSync14(wranglerPath)) {
+    const { text, added } = addSecurityBindings(readFileSync10(wranglerPath, "utf8"));
     bindings = added;
     if (added.length) {
-      writeFileSync7(wranglerPath, text);
+      writeFileSync8(wranglerPath, text);
       for (const line of added) log2(`${pc7.yellow("update".padEnd(9))} wrangler.jsonc (${line})`);
     }
   } else {
@@ -3025,7 +3280,7 @@ async function genSecurity(options2 = {}) {
   }
   const all = await loadResources(appRoot);
   ensureSupportFiles(appRoot, log2);
-  logResults(applyPlan(appRoot, planFiles(all, await loadPolicies(appRoot)), { force: options2.force }), log2);
+  logResults(applyPlan(appRoot, planFiles(all, await loadPolicies(appRoot), readStack(appRoot)), { force: options2.force }), log2);
   let migrations = [];
   if (!options2.skipMigration) {
     const result = await generateSchemaMigration(appRoot, "security");
@@ -3048,15 +3303,15 @@ async function genSecurity(options2 = {}) {
 }
 
 // src/commands/theme.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14 } from "path";
 import pc8 from "picocolors";
 var THEME_LINE = /theme: "([a-z]+)" as ThemeName,/;
 function setTheme(name, cwd = process.cwd(), log2 = console.log) {
   const appRoot = findAppRoot(cwd);
-  const path = join13(appRoot, "lib/site.ts");
-  if (!existsSync14(path)) throw new Error("lib/site.ts not found: this app was created before themes. Add it from the Flare app template.");
-  const source = readFileSync10(path, "utf8");
+  const path = join14(appRoot, "lib/site.ts");
+  if (!existsSync15(path)) throw new Error("lib/site.ts not found: this app was created before themes. Add it from the Flare app template.");
+  const source = readFileSync11(path, "utf8");
   const current = THEME_LINE.exec(source)?.[1];
   if (!name) {
     for (const [theme2, description] of Object.entries(THEMES)) {
@@ -3067,7 +3322,7 @@ function setTheme(name, cwd = process.cwd(), log2 = console.log) {
   }
   const theme = parseTheme(name);
   if (!current) throw new Error('lib/site.ts has no `theme: "\u2026" as ThemeName,` line to change.');
-  writeFileSync8(path, source.replace(THEME_LINE, `theme: "${theme}" as ThemeName,`));
+  writeFileSync9(path, source.replace(THEME_LINE, `theme: "${theme}" as ThemeName,`));
   log2(`${pc8.green("\u2714")} Theme is now ${pc8.bold(theme)}. Restart \`flare dev\` (or rebuild) to see it.`);
 }
 
@@ -3100,6 +3355,15 @@ function stopIfCancelled(value) {
 async function askCreateQuestions(given, appName) {
   prompts2.intro(`${pc9.bgRed(pc9.white(" Flare "))} ${pc9.dim(`v${FLARE_VERSION2}`)}${appName ? ` ${pc9.dim("\xB7")} ${pc9.bold(appName)}` : ""}`);
   const answers = { ...given };
+  if (given.stack === void 0) {
+    answers.stack = stopIfCancelled(
+      await prompts2.select({
+        message: "Where will it run?",
+        initialValue: "cloudflare",
+        options: STACKS.map((value) => ({ value, label: value === "next" ? "Next.js" : "Cloudflare", hint: STACK_LABELS[value] }))
+      })
+    );
+  }
   if (given.theme === void 0) {
     answers.theme = stopIfCancelled(
       await prompts2.select({
@@ -3139,9 +3403,9 @@ async function askCreateQuestions(given, appName) {
 }
 
 // src/commands/gen.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join14 } from "path";
-import { camelCase as camelCase4, defineResource as defineResource2, relationGraph as relationGraph2 } from "@flaredev/core";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join15 } from "path";
+import { camelCase as camelCase5, defineResource as defineResource2, relationGraph as relationGraph2 } from "@flaredev/core";
 import pc10 from "picocolors";
 function validateFields(name, fields, others, log2) {
   const known = /* @__PURE__ */ new Set([name, ...others.map((resource) => resource.name)]);
@@ -3153,7 +3417,7 @@ function validateFields(name, fields, others, log2) {
   const candidate = defineResource2({ name, fields: Object.fromEntries(fields.map((f) => [f.key, toField(f)])) });
   const graph = relationGraph2([...others, candidate]);
   for (const pending of graph.pending.filter((p) => p.resource === name)) {
-    log2(pc10.dim(`note: ${name}.${pending.key} will link up once ${pending.target} exists (give it a ${camelCase4(name)}Id: belongsTo(${name}) field).`));
+    log2(pc10.dim(`note: ${name}.${pending.key} will link up once ${pending.target} exists (give it a ${camelCase5(name)}Id: belongsTo(${name}) field).`));
   }
 }
 async function genResource(rawName, options2) {
@@ -3161,8 +3425,8 @@ async function genResource(rawName, options2) {
   const appRoot = findAppRoot(options2.cwd ?? process.cwd());
   const name = resourceName(rawName);
   const relativePath = descriptorPath(name);
-  const path = join14(appRoot, relativePath);
-  const exists = existsSync15(path);
+  const path = join15(appRoot, relativePath);
+  const exists = existsSync16(path);
   if (!exists && !options2.fields) {
     throw new Error(`--fields is required, e.g. flare gen resource ${name} --fields "name:string, email:string"`);
   }
@@ -3173,7 +3437,7 @@ async function genResource(rawName, options2) {
     validateFields(name, fields, others, log2);
     if (!exists) {
       mkdirSync7(dirname8(path), { recursive: true });
-      writeFileSync9(path, renderDescriptor(name, fields, { group: options2.group, icon: options2.icon }));
+      writeFileSync10(path, renderDescriptor(name, fields, { group: options2.group, icon: options2.icon }));
       log2(`${pc10.green("create".padEnd(9))} ${relativePath}`);
     } else {
       try {
@@ -3195,7 +3459,7 @@ async function genResource(rawName, options2) {
     const all = await loadResources(appRoot);
     table = all.find(({ resource }) => resource.name === name).resource.table;
     ensureSupportFiles(appRoot, log2);
-    written = applyPlan(appRoot, planFiles(all), { force: options2.force });
+    written = applyPlan(appRoot, planFiles(all, void 0, readStack(appRoot)), { force: options2.force });
     logResults(written, log2);
   } catch (error) {
     const hint = exists ? "" : `
@@ -3209,22 +3473,27 @@ Skipped ${skipped.length} hand-edited file(s); run \`flare sync-types\` for deta
   }
   let migrations = [];
   if (!options2.skipMigration) {
-    const result = await generateSchemaMigration(appRoot, `${exists ? "update" : "create"}_${table}`);
-    migrations = result.files;
-    for (const file of migrations) log2(`${pc10.green("create".padEnd(9))} ${file}`);
-    for (const repair of result.repairs) log2(pc10.dim(`repaired  ${repair}`));
-    if (migrations.length) log2(`
+    if (readStack(appRoot) === "next") {
+      log2(`
+Next: ${pc10.bold("npx prisma migrate dev")} to turn the schema into a migration and apply it.`);
+    } else {
+      const result = await generateSchemaMigration(appRoot, `${exists ? "update" : "create"}_${table}`);
+      migrations = result.files;
+      for (const file of migrations) log2(`${pc10.green("create".padEnd(9))} ${file}`);
+      for (const repair of result.repairs) log2(pc10.dim(`repaired  ${repair}`));
+      if (migrations.length) log2(`
 Next: ${pc10.bold("flare migrate")} to apply it locally.`);
-    else if (exists) log2(pc10.dim("\nNo table changes, so no migration."));
+      else if (exists) log2(pc10.dim("\nNo table changes, so no migration."));
+    }
   }
   const descriptor = { path: relativePath, status: exists ? "outdated" : "missing", outcome: exists ? "update" : "create" };
   return { name, mode: exists ? "update" : "create", written: [descriptor, ...written], migrations };
 }
 
 // src/commands/gen-endpoint.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync10 } from "fs";
-import { join as join15 } from "path";
-import { kebabCase as kebabCase3, pascalCase as pascalCase2 } from "@flaredev/core";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync11 } from "fs";
+import { join as join16 } from "path";
+import { kebabCase as kebabCase3, pascalCase as pascalCase3 } from "@flaredev/core";
 import pc11 from "picocolors";
 var METHODS = ["GET", "POST", "PATCH", "PUT", "DELETE"];
 var ACTIONS = ["read", "create", "update", "delete"];
@@ -3236,7 +3505,7 @@ async function genEndpoint(resourceName2, rawName, options2 = {}) {
   const name = kebabCase3(rawName);
   if (!name) throw new Error(`Invalid endpoint name "${rawName}".`);
   const resources = await loadResources(appRoot);
-  const wanted = pascalCase2(resourceName2);
+  const wanted = pascalCase3(resourceName2);
   const entry = resources.find(({ resource: resource2 }) => resource2.name === wanted);
   if (!entry) {
     throw new Error(`No resource "${resourceName2}". Available: ${resources.map(({ resource: resource2 }) => resource2.name).join(", ") || "none"}.`);
@@ -3245,11 +3514,11 @@ async function genEndpoint(resourceName2, rawName, options2 = {}) {
   if (!ACTIONS.includes(action)) throw new Error(`Unknown action "${action}". Use one of ${ACTIONS.join(", ")}.`);
   const { resource, stem } = entry;
   const relative2 = options2.record ? `app/api/${resource.slug}/[id]/${name}/route.ts` : `app/api/${resource.slug}/${name}/route.ts`;
-  const path = join15(appRoot, relative2);
-  if (existsSync16(path)) throw new Error(`${relative2} already exists.`);
-  mkdirSync8(join15(path, ".."), { recursive: true });
+  const path = join16(appRoot, relative2);
+  if (existsSync17(path)) throw new Error(`${relative2} already exists.`);
+  mkdirSync8(join16(path, ".."), { recursive: true });
   const route = options2.record ? `/api/${resource.slug}/[id]/${name}` : `/api/${resource.slug}/${name}`;
-  writeFileSync10(path, renderEndpoint({ resource: resource.name, stem, method, action, record: Boolean(options2.record), name, route }));
+  writeFileSync11(path, renderEndpoint({ resource: resource.name, stem, method, action, record: Boolean(options2.record), name, route }));
   log2(`${pc11.green("create".padEnd(9))} ${relative2}`);
   log2(`
 It's an ordinary route handler \u2014 edit it freely; regeneration leaves it alone.`);
@@ -3285,8 +3554,8 @@ ${body}
 }
 
 // src/commands/gen-migration.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename2, join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, writeFileSync as writeFileSync12 } from "fs";
+import { basename as basename2, join as join17 } from "path";
 import { snakeCase } from "@flaredev/core";
 import pc12 from "picocolors";
 var DOWN_TEMPLATE = (up) => `-- Rollback for ${up}, run by \`flare migrate:rollback\`.
@@ -3307,12 +3576,12 @@ async function genMigration(rawName, options2 = {}) {
   for (const file of files) log2(`${pc12.green("create".padEnd(9))} ${file}`);
   for (const repair of repairs) log2(pc12.dim(`repaired  ${repair}`));
   if (!options2.fromSchema) {
-    const downDir = join16(appRoot, "migrations", "down");
+    const downDir = join17(appRoot, "migrations", "down");
     mkdirSync9(downDir, { recursive: true });
     for (const file of files) {
-      const down = join16(downDir, basename2(file));
-      if (existsSync17(down)) continue;
-      writeFileSync11(down, DOWN_TEMPLATE(basename2(file)));
+      const down = join17(downDir, basename2(file));
+      if (existsSync18(down)) continue;
+      writeFileSync12(down, DOWN_TEMPLATE(basename2(file)));
       log2(`${pc12.green("create".padEnd(9))} migrations/down/${basename2(file)}`);
     }
     log2(`
@@ -3325,8 +3594,8 @@ Next: ${pc12.bold("flare migrate")}.`);
 }
 
 // src/commands/gen-policy.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname9, join as join17 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname9, join as join18 } from "path";
 import { definePolicy } from "@flaredev/core";
 import pc13 from "picocolors";
 function parseRoles(input, what = "--roles") {
@@ -3344,8 +3613,8 @@ async function genPolicy(rawName, options2) {
     throw new Error(`No resource "${name}". Generate it first. Known resources: ${known}.`);
   }
   const relative2 = policyPath(name);
-  const path = join17(appRoot, relative2);
-  const exists = existsSync18(path);
+  const path = join18(appRoot, relative2);
+  const exists = existsSync19(path);
   let roles;
   let deleteRoles;
   if (options2.roles || !exists) {
@@ -3357,7 +3626,7 @@ async function genPolicy(rawName, options2) {
     const block = renderPolicyBlock({ read: roles, create: roles, update: roles, delete: deleteRoles });
     if (!exists) {
       mkdirSync10(dirname9(path), { recursive: true });
-      writeFileSync12(path, renderPolicy(name, { read: roles, create: roles, update: roles, delete: deleteRoles }));
+      writeFileSync13(path, renderPolicy(name, { read: roles, create: roles, update: roles, delete: deleteRoles }));
       log2(`${pc13.green("create".padEnd(9))} ${relative2}`);
     } else {
       try {
@@ -3372,16 +3641,16 @@ async function genPolicy(rawName, options2) {
     }
   }
   const policies = await loadPolicies(appRoot);
-  logResults(applyPlan(appRoot, planFiles(resources, policies)), log2);
+  logResults(applyPlan(appRoot, planFiles(resources, policies, readStack(appRoot))), log2);
   log2(`
 ${pc13.dim("Roles come from `flare role:add`; the API and the admin both enforce this policy.")}`);
   return { name, path: relative2 };
 }
 
 // src/commands/migrate.ts
-import { existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync11, rmSync as rmSync2, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync12, rmSync as rmSync3, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import pc14 from "picocolors";
 
 // src/generator/down.ts
@@ -3475,7 +3744,17 @@ function context(options2) {
   };
 }
 async function migrate(options2 = {}) {
-  const { appRoot, db, target, wrangler } = context(options2);
+  const appRoot = findAppRoot(options2.cwd ?? process.cwd());
+  const log2 = options2.log ?? ((message) => console.log(message));
+  if (readStack(appRoot) === "next") {
+    if (options2.remote) {
+      log2(pc14.dim("On Next.js, `--remote` is whichever database DATABASE_URL points at."));
+    }
+    const prisma = resolveBin(appRoot, "prisma", "prisma");
+    log2(`${pc14.cyan("prisma")} migrate deploy`);
+    return runNode([prisma, "migrate", "deploy"], appRoot);
+  }
+  const { db, target, wrangler } = context(options2);
   const result = await runWrangler(wrangler, ["d1", "migrations", "apply", db.binding, ...target], appRoot);
   return result.code;
 }
@@ -3499,7 +3778,7 @@ async function rollback(options2 = {}) {
   const steps = options2.steps ?? 1;
   if (!Number.isInteger(steps) || steps < 1) throw new Error("--steps must be a positive integer.");
   const { appRoot, db, target, where, wrangler, log: log2 } = context(options2);
-  const migrationsDir = join18(appRoot, db.migrations_dir ?? "migrations");
+  const migrationsDir = join19(appRoot, db.migrations_dir ?? "migrations");
   const applied = await appliedMigrations(options2, steps);
   if (applied.length === 0) {
     log2("Nothing to roll back.");
@@ -3508,18 +3787,18 @@ async function rollback(options2 = {}) {
   const plan = [];
   for (const { name } of applied) {
     if (!/^[\w.-]+\.sql$/.test(name)) throw new Error(`Unexpected migration name "${name}" in d1_migrations.`);
-    const handWritten = join18(migrationsDir, "down", name);
-    if (existsSync19(handWritten)) {
-      const sql2 = readFileSync11(handWritten, "utf8");
+    const handWritten = join19(migrationsDir, "down", name);
+    if (existsSync20(handWritten)) {
+      const sql2 = readFileSync12(handWritten, "utf8");
       if (splitStatements(sql2).length === 0) {
         throw new Error(`Can't roll back ${name}: migrations/down/${name} has no SQL statements yet. Write the rollback SQL, then run the rollback again. Nothing was changed.`);
       }
       plan.push({ name, sql: sql2, source: `migrations/down/${name}` });
       continue;
     }
-    const upPath = join18(migrationsDir, name);
-    if (!existsSync19(upPath)) throw new Error(`${name} was applied but migrations/${name} is missing, so it can't be reversed.`);
-    const down = deriveDown(readFileSync11(upPath, "utf8"));
+    const upPath = join19(migrationsDir, name);
+    if (!existsSync20(upPath)) throw new Error(`${name} was applied but migrations/${name} is missing, so it can't be reversed.`);
+    const down = deriveDown(readFileSync12(upPath, "utf8"));
     if (!down.reversible) {
       throw new Error(
         `Can't roll back ${name}: ${down.reason}
@@ -3539,15 +3818,15 @@ Write the reverse SQL to migrations/down/${name} and run the rollback again. Not
   }
   const script = plan.map(({ name, sql: sql2 }) => `${sql2.trim()}
 DELETE FROM d1_migrations WHERE name = '${name.replace(/'/g, "''")}';`).join("\n") + "\n";
-  const dir = mkdtempSync(join18(tmpdir(), "flare-rollback-"));
+  const dir = mkdtempSync(join19(tmpdir(), "flare-rollback-"));
   try {
-    const file = join18(dir, "rollback.sql");
-    writeFileSync13(file, script);
+    const file = join19(dir, "rollback.sql");
+    writeFileSync14(file, script);
     const result = await runWrangler(wrangler, ["d1", "execute", db.binding, ...target, "--file", file], appRoot, { capture: true });
     if (result.code !== 0) throw new Error(`Rollback failed:
 ${result.output.trim()}`);
   } finally {
-    rmSync2(dir, { recursive: true, force: true });
+    rmSync3(dir, { recursive: true, force: true });
   }
   log2(pc14.green(`
 Rolled back ${plan.map((step) => step.name).join(", ")}.`));
@@ -3555,8 +3834,8 @@ Rolled back ${plan.map((step) => step.name).join(", ")}.`));
 }
 
 // src/commands/rm.ts
-import { existsSync as existsSync20, readdirSync as readdirSync7, readFileSync as readFileSync12, rmdirSync, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname10, join as join19 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync7, readFileSync as readFileSync13, rmdirSync, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname10, join as join20 } from "path";
 import { relationGraph as relationGraph3 } from "@flaredev/core";
 import pc15 from "picocolors";
 var squash = (text) => text.replace(/\r\n/g, "\n").replace(/\s+/g, " ").trim();
@@ -3575,10 +3854,10 @@ function handWrittenReason(source, header, options2 = {}) {
   return null;
 }
 function removeEmptyDirs(appRoot, start) {
-  let dir = dirname10(join19(appRoot, start));
-  const roots = [join19(appRoot, "app", "api"), join19(appRoot, "app", "dashboard")];
+  let dir = dirname10(join20(appRoot, start));
+  const roots = [join20(appRoot, "app", "api"), join20(appRoot, "app", "dashboard")];
   const inside = () => roots.some((root) => dir.startsWith(root) && dir !== root);
-  while (inside() && existsSync20(dir) && readdirSync7(dir).length === 0) {
+  while (inside() && existsSync21(dir) && readdirSync7(dir).length === 0) {
     rmdirSync(dir);
     dir = dirname10(dir);
   }
@@ -3606,8 +3885,8 @@ async function rmResource(rawName, options2 = {}) {
   const owned = /* @__PURE__ */ new Set();
   if (entry) {
     owned.add(entry.file);
-    for (const file of planFiles(all)) {
-      if (existsSync20(join19(appRoot, file.path)) && file.header === resourceHeader(name)) owned.add(file.path);
+    for (const file of planFiles(all, void 0, readStack(appRoot))) {
+      if (existsSync21(join20(appRoot, file.path)) && file.header === resourceHeader(name)) owned.add(file.path);
     }
   }
   for (const orphan of findOrphans(appRoot, remaining)) if (orphan.resource === name) owned.add(orphan.path);
@@ -3616,7 +3895,7 @@ async function rmResource(rawName, options2 = {}) {
   if (!entry && owned.size === 0) throw new Error(`No resource "${name}" (no ${descriptorPath(name)} and no generated files).`);
   const findings = [];
   for (const path of owned) {
-    const source = readFileSync12(join19(appRoot, path), "utf8");
+    const source = readFileSync13(join20(appRoot, path), "utf8");
     let wrapper;
     if (entry && path === entry.file) {
       const standard = splitMarkers(renderDescriptor(name, [{ key: "placeholder", kind: "string", required: true, unique: false }]));
@@ -3637,15 +3916,15 @@ Move what you want to keep, or pass --force to delete anyway.`);
   }
   const removed = [...owned].sort();
   for (const path of removed) {
-    unlinkSync2(join19(appRoot, path));
+    unlinkSync2(join20(appRoot, path));
     removeEmptyDirs(appRoot, path);
     log2(`${pc15.red("remove".padEnd(9))} ${path}`);
   }
-  logResults(applyPlan(appRoot, planFiles(remaining, policy ? await loadPolicies(appRoot) : void 0)), log2);
+  logResults(applyPlan(appRoot, planFiles(remaining, policy ? await loadPolicies(appRoot) : void 0, readStack(appRoot))), log2);
   const table = entry ? tableExport(entry.resource) : void 0;
-  if (table && existsSync20(join19(appRoot, "seeds"))) {
-    const seeds = readdirSync7(join19(appRoot, "seeds")).filter(
-      (file) => new RegExp(`\\b${table}\\b`).test(readFileSync12(join19(appRoot, "seeds", file), "utf8"))
+  if (table && existsSync21(join20(appRoot, "seeds"))) {
+    const seeds = readdirSync7(join20(appRoot, "seeds")).filter(
+      (file) => new RegExp(`\\b${table}\\b`).test(readFileSync13(join20(appRoot, "seeds", file), "utf8"))
     );
     if (seeds.length) log2(pc15.yellow(`
 These seeds still use ${table}: ${seeds.map((s) => `seeds/${s}`).join(", ")}.`));
@@ -3715,9 +3994,9 @@ ${result.output.trim()}`);
 }
 
 // src/commands/seed.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync11, readdirSync as readdirSync8, writeFileSync as writeFileSync14 } from "fs";
-import { join as join21 } from "path";
-import { createFake, kebabCase as kebabCase4, storedFields as storedFields2 } from "@flaredev/core";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, readdirSync as readdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync15 } from "fs";
+import { join as join22 } from "path";
+import { camelCase as camelCase6, createFake, kebabCase as kebabCase4, storedFields as storedFields3 } from "@flaredev/core";
 import { createJiti as createJiti4 } from "jiti";
 import pc17 from "picocolors";
 
@@ -3814,16 +4093,16 @@ function createInsertMany(sink, drizzle, onProgress) {
 
 // src/seed/local-d1.ts
 import { createRequire } from "module";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { pathToFileURL } from "url";
 var LOCAL_STATE = ".wrangler/state/v3";
 async function openLocalD1(appRoot, binding) {
   process.env.WRANGLER_LOG ??= "error";
-  const appRequire = createRequire(join20(appRoot, "package.json"));
+  const appRequire = createRequire(join21(appRoot, "package.json"));
   const wrangler = await import(pathToFileURL(appRequire.resolve("wrangler")).href);
   const { env, dispose } = await wrangler.getPlatformProxy({
-    configPath: join20(appRoot, "wrangler.jsonc"),
-    persist: { path: join20(appRoot, LOCAL_STATE) }
+    configPath: join21(appRoot, "wrangler.jsonc"),
+    persist: { path: join21(appRoot, LOCAL_STATE) }
   });
   const bindings = env;
   const name = binding ?? "DB";
@@ -3838,8 +4117,8 @@ async function openLocalD1(appRoot, binding) {
 // src/commands/seed.ts
 var SEEDS_DIR = "seeds";
 function seedFiles(appRoot, names) {
-  const dir = join21(appRoot, SEEDS_DIR);
-  const all = existsSync21(dir) ? readdirSync8(dir).filter((file) => file.endsWith(".seed.ts")).sort() : [];
+  const dir = join22(appRoot, SEEDS_DIR);
+  const all = existsSync22(dir) ? readdirSync8(dir).filter((file) => file.endsWith(".seed.ts")).sort() : [];
   if (!names?.length) return all;
   return names.map((name) => {
     const file = `${name.replace(/\.seed\.ts$/, "")}.seed.ts`;
@@ -3857,16 +4136,20 @@ async function runSeeds(options2 = {}) {
     log2(`No seeds found. Create one with ${pc17.bold("flare seed:make <name>")}.`);
     return;
   }
-  const jiti = createJiti4(join21(appRoot, "package.json"), { alias: { "@": appRoot }, moduleCache: false, fsCache: false });
+  if (readStack(appRoot) === "next") {
+    await runPrismaSeeds(appRoot, files, log2);
+    return;
+  }
+  const jiti = createJiti4(join22(appRoot, "package.json"), { alias: { "@": appRoot }, moduleCache: false, fsCache: false });
   const { drizzle } = await jiti.import("drizzle-orm/d1");
   const drizzleHelpers = await jiti.import("drizzle-orm");
-  const schema = await jiti.import(join21(appRoot, "db/schema.ts"));
+  const schema = await jiti.import(join22(appRoot, "db/schema.ts"));
   const local = await openLocalD1(appRoot);
   try {
     const db = drizzle(local.db, { schema });
     const insertMany = createInsertMany(local.db, drizzleHelpers);
     for (const file of files) {
-      const mod = await jiti.import(join21(appRoot, SEEDS_DIR, file));
+      const mod = await jiti.import(join22(appRoot, SEEDS_DIR, file));
       if (typeof mod.default !== "function") throw new Error(`${SEEDS_DIR}/${file} must \`export default defineSeed(async ({ db }) => { ... })\`.`);
       log2(`${pc17.cyan("seed")} ${file}`);
       await mod.default({ db, env: local.env, insertMany, fake: createFake(), log: (message) => log2(`  ${message}`) });
@@ -3916,9 +4199,17 @@ function sampleValue(key, def) {
       return void 0;
   }
 }
-function renderSeed(resource) {
+function renderSeed(resource, stack = "cloudflare") {
   if (!resource) {
-    return `import { defineSeed } from "@flaredev/core";
+    return stack === "next" ? `import { defineSeed } from "@flaredev/core";
+
+export default defineSeed(async ({ db, insertMany, fake, log }) => {
+  // \`db\` is this app's Prisma client, e.g.:
+  // await db.contact.create({ data: { name: "Ada", email: "ada@example.com" } });
+  // Or many at once: await insertMany("contact", [{ name: fake.fullName() }]);
+  log("nothing to seed yet");
+});
+` : `import { defineSeed } from "@flaredev/core";
 
 export default defineSeed(async ({ db, insertMany, fake, log }) => {
   // Insert rows with Drizzle, e.g.:
@@ -3931,11 +4222,30 @@ export default defineSeed(async ({ db, insertMany, fake, log }) => {
   const table = tableExport(resource);
   const lines = [];
   const todos = [];
-  for (const [key, def] of storedFields2(resource)) {
+  for (const [key, def] of storedFields3(resource)) {
     const value = sampleValue(key, def);
     if (value !== void 0) lines.push(`    ${key}: ${value},`);
     else if (def.required) todos.push(`    // ${key}: TODO (${def.kind === "belongsTo" ? `id of an existing ${def.target}` : "R2 object key"}),`);
   }
+  if (stack === "next") {
+    const body = [...lines, ...todos].map((line) => `  ${line}`).join("\n");
+    return `import { defineSeed } from "@flaredev/core";
+
+/** How many to create. createMany sends them in one statement. */
+const COUNT = 50;
+
+export default defineSeed(async ({ insertMany, fake, log }) => {
+  await insertMany(
+    ${JSON.stringify(camelCase6(resource.name))},
+    Array.from({ length: COUNT }, () => ({
+${body}
+      updatedAt: new Date(),
+    })),
+  );
+  log(\`inserted \${COUNT.toLocaleString()} ${resource.pluralLabel.toLowerCase()}\`);
+});
+`;
+  }
   return `import { defineSeed } from "@flaredev/core";
 import { ${table} } from "@/db/schema";
 
@@ -3956,8 +4266,8 @@ async function makeSeed(rawName, options2 = {}) {
   const name = kebabCase4(rawName);
   if (!name) throw new Error(`Invalid seed name "${rawName}".`);
   const relative2 = `${SEEDS_DIR}/${name}.seed.ts`;
-  const path = join21(appRoot, relative2);
-  if (existsSync21(path)) throw new Error(`${relative2} already exists.`);
+  const path = join22(appRoot, relative2);
+  if (existsSync22(path)) throw new Error(`${relative2} already exists.`);
   const resources = (await loadResources(appRoot)).map(({ resource: resource2 }) => resource2);
   let resource;
   if (options2.resource) {
@@ -3966,18 +4276,58 @@ async function makeSeed(rawName, options2 = {}) {
   } else {
     resource = resources.find((r) => [kebabCase4(r.name), r.slug].includes(name));
   }
-  mkdirSync11(join21(appRoot, SEEDS_DIR), { recursive: true });
-  writeFileSync14(path, renderSeed(resource));
+  mkdirSync11(join22(appRoot, SEEDS_DIR), { recursive: true });
+  writeFileSync15(path, renderSeed(resource, readStack(appRoot)));
   log2(`${pc17.green("create".padEnd(9))} ${relative2}`);
   log2(`
 Run it with ${pc17.bold(`flare seed ${name}`)}.`);
   return relative2;
 }
+async function runPrismaSeeds(appRoot, files, log2) {
+  const runner = join22(appRoot, ".flare-seed-runner.mts");
+  const script = [
+    `import "dotenv/config";`,
+    `import { createFake } from "@flaredev/core";`,
+    `import { prisma } from "./lib/db";`,
+    ...files.map((file, index) => `import seed${index} from "./${SEEDS_DIR}/${file.replace(/\.ts$/, "")}";`),
+    "",
+    `const files = ${JSON.stringify(files)};`,
+    `const seeds = [${files.map((_, index) => `seed${index}`).join(", ")}];`,
+    `const client = prisma as unknown as Record<string, { createMany(args: { data: unknown[] }): Promise<unknown> }>;`,
+    "",
+    `for (const [index, seed] of seeds.entries()) {`,
+    `  console.log("seed " + files[index]);`,
+    `  await seed({`,
+    `    db: prisma,`,
+    `    env: process.env,`,
+    `    insertMany: async (model: string, rows: Record<string, unknown>[]) => {`,
+    `      const delegate = client[model];`,
+    `      if (!delegate) throw new Error('No Prisma model "' + model + '". Use the camelCase name, e.g. "orderItem".');`,
+    `      await delegate.createMany({ data: rows });`,
+    `    },`,
+    `    fake: createFake(),`,
+    `    log: (message: string) => console.log("  " + message),`,
+    `  });`,
+    `}`,
+    `await (prisma as unknown as { $disconnect(): Promise<void> }).$disconnect();`,
+    ""
+  ].join("\n");
+  writeFileSync15(runner, script);
+  try {
+    const tsx = resolveBin(appRoot, "tsx", "tsx");
+    const code = await runNode([tsx, runner], appRoot);
+    if (code !== 0) throw new Error("A seed failed; nothing further was run.");
+    log2(pc17.green(`
+Ran ${files.length} seed(s).`));
+  } finally {
+    rmSync4(runner, { force: true });
+  }
+}
 
 // src/commands/db-push.ts
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync3, writeFileSync as writeFileSync15 } from "fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync5, writeFileSync as writeFileSync16 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import pc18 from "picocolors";
 
 // src/terminal.ts
@@ -4042,7 +4392,7 @@ async function dbPush(tables, options2 = {}) {
   const wrangler = resolveBin(appRoot, "wrangler", "wrangler");
   const started = Date.now();
   const local = await openLocalD1(appRoot, options2.database);
-  const dir = mkdtempSync2(join22(tmpdir2(), "flare-push-"));
+  const dir = mkdtempSync2(join23(tmpdir2(), "flare-push-"));
   try {
     const statements = [];
     const counts = [];
@@ -4068,8 +4418,8 @@ async function dbPush(tables, options2 = {}) {
       log2("Nothing to push: those tables are empty locally.");
       return { tables: counts, ms: Date.now() - started };
     }
-    const file = join22(dir, "push.sql");
-    writeFileSync15(file, statements.join("\n"));
+    const file = join23(dir, "push.sql");
+    writeFileSync16(file, statements.join("\n"));
     const target = ["--remote", ...options2.env ? ["--env", options2.env] : []];
     const result = await runWrangler(wrangler, ["d1", "execute", db.binding, ...target, "--yes", "--file", file], appRoot, { capture: true });
     if (result.code !== 0) throw new Error(`Pushing to ${db.database_name} failed:
@@ -4078,19 +4428,19 @@ ${result.output.trim()}`);
     log2(`${pc18.green("\u2714")} Pushed ${pc18.bold(formatCount(total))} rows to ${pc18.bold(db.database_name)} ${pc18.dim(`(${formatDuration(ms)})`)}`);
     return { tables: counts, ms };
   } finally {
-    rmSync3(dir, { recursive: true, force: true });
+    rmSync5(dir, { recursive: true, force: true });
     await local.dispose();
   }
 }
 
 // src/commands/seed-resource.ts
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync4, writeFileSync as writeFileSync16 } from "fs";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync6, writeFileSync as writeFileSync17 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import pc19 from "picocolors";
 
 // src/seed/rows.ts
-import { columnName as columnName2, createFake as createFake2, storedFields as storedFields3 } from "@flaredev/core";
+import { columnName as columnName3, createFake as createFake2, storedFields as storedFields4 } from "@flaredev/core";
 var has = (key, ...words) => words.some((word) => key.includes(word));
 function stringValue(key, def, fake, resource, index) {
   switch (def.format) {
@@ -4195,12 +4545,12 @@ function digitalish(resource) {
   );
 }
 function seedColumns(resource) {
-  return ["id", ...storedFields3(resource).map(([key]) => columnName2(key)), "created_at", "updated_at"];
+  return ["id", ...storedFields4(resource).map(([key]) => columnName3(key)), "created_at", "updated_at"];
 }
 function* seedRows(resource, count, options2 = {}) {
   const fake = createFake2(options2.seed ?? Math.floor(Math.random() * 2 ** 31));
   const parentIds = options2.parentIds ?? /* @__PURE__ */ new Map();
-  const fields = storedFields3(resource);
+  const fields = storedFields4(resource);
   const now = options2.now ?? Date.now();
   const start = options2.startIndex ?? 0;
   for (let i = 0; i < count; i++) {
@@ -4209,7 +4559,7 @@ function* seedRows(resource, count, options2 = {}) {
     for (const [key, def] of fields) {
       let value = fieldValue(key, def, fake, resource, parentIds, number);
       if (typeof value === "string" && "unique" in def && def.unique) value = uniquify(value, number + 1);
-      row[columnName2(key)] = value;
+      row[columnName3(key)] = value;
     }
     const created = now - fake.int(0, 365) * 864e5 - fake.int(0, 86399999);
     row.created_at = created;
@@ -4288,6 +4638,11 @@ async function seedResourceCommand(name, options2 = {}) {
 async function seedResource(name, options2 = {}) {
   const log2 = options2.log ?? ((message) => console.log(message));
   const appRoot = findAppRoot(options2.cwd ?? process.cwd());
+  if (readStack(appRoot) === "next") {
+    throw new Error(
+      "flare seed:resource is Cloudflare-only so far. On this stack, write a seed with `flare seed:make <name> --resource " + name + "` \u2014 it comes with rows already filled in \u2014 and run it with `flare seed`."
+    );
+  }
   const resources = (await loadResources(appRoot)).map(({ resource: resource2 }) => resource2);
   const resource = pickResource(resources, name);
   const total = parseCount(options2.count);
@@ -4320,8 +4675,8 @@ ${result.output.trim()}`);
       const [counted] = await query(`SELECT count(*) AS total FROM "${resource.table}"`);
       startIndex = counted?.total ?? 0;
     }
-    const dir = mkdtempSync3(join23(tmpdir3(), "flare-seed-"));
-    const file = join23(dir, `${resource.table}.sql`);
+    const dir = mkdtempSync3(join24(tmpdir3(), "flare-seed-"));
+    const file = join24(dir, `${resource.table}.sql`);
     try {
       const statements = [];
       if (options2.truncate) statements.push(`DELETE FROM "${resource.table}";`);
@@ -4331,13 +4686,13 @@ ${result.output.trim()}`);
         written += statement.rows;
         options2.onProgress?.(written, total);
       }
-      writeFileSync16(file, statements.join("\n"));
+      writeFileSync17(file, statements.join("\n"));
       log2(`${pc19.cyan("\u25CF")} Uploading ${total.toLocaleString()} rows to ${pc19.bold(db.database_name)}`);
       const result = await runWrangler(wrangler, ["d1", "execute", db.binding, ...target, "--yes", "--file", file], appRoot, { capture: true });
       if (result.code !== 0) throw new Error(`Seeding the remote database failed:
 ${result.output.trim()}`);
     } finally {
-      rmSync4(dir, { recursive: true, force: true });
+      rmSync6(dir, { recursive: true, force: true });
     }
     return { resource, rows: total, ms: Date.now() - started, where };
   }
@@ -4364,17 +4719,17 @@ ${result.output.trim()}`);
 
 // src/commands/billing-sync.ts
 import { createRequire as createRequire2 } from "module";
-import { existsSync as existsSync22, mkdtempSync as mkdtempSync4, readFileSync as readFileSync13, rmSync as rmSync5, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync23, mkdtempSync as mkdtempSync4, readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync18 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { kebabCase as kebabCase5 } from "@flaredev/core";
 import pc20 from "picocolors";
 function stripeKeys(appRoot) {
   const map = {};
-  const path = join24(appRoot, ".dev.vars");
-  if (existsSync22(path)) {
-    for (const line of readFileSync13(path, "utf8").split(/\r?\n/)) {
+  const path = join25(appRoot, ".dev.vars");
+  if (existsSync23(path)) {
+    for (const line of readFileSync14(path, "utf8").split(/\r?\n/)) {
       const match = /^\s*([A-Z][A-Z0-9_]*)=(.*)$/.exec(line);
       if (match) map[match[1]] = match[2].trim();
     }
@@ -4457,10 +4812,10 @@ async function syncPlans(options2 = {}) {
   if (!key) throw new Error("STRIPE_SECRET_KEY is not set in .dev.vars or the environment.");
   const db = readD1Databases(appRoot)[0];
   if (!db) throw new Error("No d1_databases in wrangler.jsonc.");
-  const appRequire = createRequire2(join24(appRoot, "package.json"));
+  const appRequire = createRequire2(join25(appRoot, "package.json"));
   const stripeModule = await import(pathToFileURL2(appRequire.resolve("stripe")).href);
   const stripe = new stripeModule.default(key, { apiVersion: "2026-08-26.dahlia" });
-  const appName = JSON.parse(readFileSync13(join24(appRoot, "package.json"), "utf8")).name ?? "app";
+  const appName = JSON.parse(readFileSync14(join25(appRoot, "package.json"), "utf8")).name ?? "app";
   const everything = await stripe.products.list({ active: true, limit: 100 }).autoPagingToArray({ limit: 1e4 });
   const products = options2.all ? everything : everything.filter((product) => product.metadata?.flare_app === appName);
   if (products.length === 0) {
@@ -4481,15 +4836,15 @@ async function syncPlans(options2 = {}) {
 ${existingResult.output.trim()}`);
   }
   const known = new Set(extractJson(existingResult.output)[0]?.results.map((row) => row.stripe_price_id));
-  const dir = mkdtempSync4(join24(tmpdir4(), "flare-sync-"));
+  const dir = mkdtempSync4(join25(tmpdir4(), "flare-sync-"));
   try {
-    const file = join24(dir, "sync-plans.sql");
-    writeFileSync17(file, renderSyncSql(rows));
+    const file = join25(dir, "sync-plans.sql");
+    writeFileSync18(file, renderSyncSql(rows));
     const result = await runWrangler(wrangler, ["d1", "execute", db.binding, ...target, "--file", file], appRoot, { capture: true });
     if (result.code !== 0) throw new Error(`Could not write plans:
 ${result.output.trim()}`);
   } finally {
-    rmSync5(dir, { recursive: true, force: true });
+    rmSync7(dir, { recursive: true, force: true });
   }
   let created = 0;
   for (const row of rows) {
@@ -4507,16 +4862,16 @@ ${rows.length} plan(s) synced to the ${options2.remote ? "remote" : "local"} dat
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync23 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join26 } from "path";
 import pc21 from "picocolors";
 async function syncTypes(options2 = {}) {
   const log2 = options2.log ?? ((message) => console.log(message));
   const appRoot = findAppRoot(options2.cwd ?? process.cwd());
   const all = await loadResources(appRoot);
   const policies = await loadPolicies(appRoot);
-  const tracksPolicies = policies.length > 0 || existsSync23(join25(appRoot, "policies/index.ts"));
-  const plan = planFiles(all, tracksPolicies ? policies : void 0);
+  const tracksPolicies = policies.length > 0 || existsSync24(join26(appRoot, "policies/index.ts"));
+  const plan = planFiles(all, tracksPolicies ? policies : void 0, readStack(appRoot));
   if (!options2.check) ensureSupportFiles(appRoot, log2);
   const results = applyPlan(appRoot, plan, { force: options2.force, dryRun: options2.check });
   logResults(results, log2);
@@ -4600,22 +4955,22 @@ ${result.output.trim()}`);
 
 // src/utils/install.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync14, readdirSync as readdirSync9 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "fs";
+import { join as join27 } from "path";
 function expectedPackages(dir) {
-  const npmLock = join26(dir, "package-lock.json");
-  if (existsSync24(npmLock)) {
+  const npmLock = join27(dir, "package-lock.json");
+  if (existsSync25(npmLock)) {
     try {
-      const lock = JSON.parse(readFileSync14(npmLock, "utf8"));
+      const lock = JSON.parse(readFileSync15(npmLock, "utf8"));
       return Math.max(0, Object.keys(lock.packages ?? {}).length - 1);
     } catch {
       return 0;
     }
   }
-  const pnpmLock = join26(dir, "pnpm-lock.yaml");
-  if (existsSync24(pnpmLock)) {
+  const pnpmLock = join27(dir, "pnpm-lock.yaml");
+  if (existsSync25(pnpmLock)) {
     try {
-      const text = readFileSync14(pnpmLock, "utf8");
+      const text = readFileSync15(pnpmLock, "utf8");
       const packages = text.slice(text.indexOf("\npackages:"));
       return (packages.match(/\n {2}[^\s:]+:/g) ?? []).length;
     } catch {
@@ -4625,15 +4980,15 @@ function expectedPackages(dir) {
   return 0;
 }
 function installedPackages(dir) {
-  const root = join26(dir, "node_modules");
-  if (!existsSync24(root)) return 0;
+  const root = join27(dir, "node_modules");
+  if (!existsSync25(root)) return 0;
   let total = 0;
   try {
     for (const entry of readdirSync9(root, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name === ".bin") continue;
       if (entry.name.startsWith("@")) {
         try {
-          total += readdirSync9(join26(root, entry.name)).length;
+          total += readdirSync9(join27(root, entry.name)).length;
         } catch {
         }
       } else if (entry.name !== ".pnpm" && entry.name !== ".vite") {
@@ -4677,31 +5032,33 @@ function install(packageManager, dir, onProgress) {
 // src/cli.ts
 function createCli() {
   const cli = cac("flare");
-  cli.command("create <dir>", "Scaffold a new Flare app").option("--pm <manager>", "Package manager: pnpm, npm, yarn, or bun (default: detected)").option("--theme <name>", "Look of the app: default, coral, amber, sky, mono or emerald").option("--auth <list>", "Sign-in methods: magic-link, email-otp, passkeys, 2fa-app, 2fa-email, all or none (default: all)").option("--auth-providers <list>", "Social sign-in, comma-separated: google, github, apple, microsoft").option("-y, --yes", "Don't ask: use the flags given and the defaults for the rest").option("--skip-install", "Write files without installing dependencies").example("flare create shop").example("flare create shop --theme mono --auth passkeys,2fa-app --auth-providers google,github --yes").action(async (dir, options2) => {
-    const wanted = !options2.skipInstall;
-    let answers = { theme: options2.theme, auth: options2.auth, authProviders: options2.authProviders };
-    if (canPrompt(options2.yes)) answers = await askCreateQuestions(answers, toAppName(dir));
-    const result = createApp(dir, { pm: options2.pm, install: false, ...answers, log: (message) => prompts3.log.message(message) });
-    let installed = false;
-    if (wanted) {
-      const spin = prompts3.spinner({ indicator: "timer" });
-      spin.start(`Installing dependencies with ${result.packageManager}`);
-      const outcome = await install(result.packageManager, result.dir, ({ installed: done, expected, percent }) => {
-        spin.message(
-          percent === void 0 ? `Installing dependencies with ${result.packageManager} \xB7 ${formatCount(done)} packages` : `Installing dependencies with ${result.packageManager} \xB7 ${percent}% (${formatCount(done)} of ${formatCount(expected)})`
-        );
-      });
-      installed = outcome.code === 0;
-      if (installed) {
-        spin.stop(`Installed ${formatCount(expectedPackages(result.dir) || 0)} packages with ${result.packageManager} ${pc23.dim(`(${formatDuration(outcome.ms)})`)}`);
-      } else {
-        spin.error(`${result.packageManager} install failed`);
-        process.stderr.write(outcome.output);
-        process.exitCode = 1;
+  cli.command("create <dir>", "Scaffold a new Flare app").option("--pm <manager>", "Package manager: pnpm, npm, yarn, or bun (default: detected)").option("--stack <name>", "Where it runs: cloudflare (default) or next").option("--theme <name>", "Look of the app: default, coral, amber, sky, mono or emerald").option("--auth <list>", "Sign-in methods: magic-link, email-otp, passkeys, 2fa-app, 2fa-email, all or none (default: all)").option("--auth-providers <list>", "Social sign-in, comma-separated: google, github, apple, microsoft").option("-y, --yes", "Don't ask: use the flags given and the defaults for the rest").option("--skip-install", "Write files without installing dependencies").example("flare create shop").example("flare create shop --stack next").example("flare create shop --theme mono --auth passkeys,2fa-app --auth-providers google,github --yes").action(
+    async (dir, options2) => {
+      const wanted = !options2.skipInstall;
+      let answers = { stack: options2.stack, theme: options2.theme, auth: options2.auth, authProviders: options2.authProviders };
+      if (canPrompt(options2.yes)) answers = await askCreateQuestions(answers, toAppName(dir));
+      const result = createApp(dir, { pm: options2.pm, install: false, ...answers, log: (message) => prompts3.log.message(message) });
+      let installed = false;
+      if (wanted) {
+        const spin = prompts3.spinner({ indicator: "timer" });
+        spin.start(`Installing dependencies with ${result.packageManager}`);
+        const outcome = await install(result.packageManager, result.dir, ({ installed: done, expected, percent }) => {
+          spin.message(
+            percent === void 0 ? `Installing dependencies with ${result.packageManager} \xB7 ${formatCount(done)} packages` : `Installing dependencies with ${result.packageManager} \xB7 ${percent}% (${formatCount(done)} of ${formatCount(expected)})`
+          );
+        });
+        installed = outcome.code === 0;
+        if (installed) {
+          spin.stop(`Installed ${formatCount(expectedPackages(result.dir) || 0)} packages with ${result.packageManager} ${pc23.dim(`(${formatDuration(outcome.ms)})`)}`);
+        } else {
+          spin.error(`${result.packageManager} install failed`);
+          process.stderr.write(outcome.output);
+          process.exitCode = 1;
+        }
       }
+      printNextSteps(result, installed);
     }
-    printNextSteps(result, installed);
-  });
+  );
   cli.command("gen <generator> [name] [second]", "Generate code. Generators: resource, endpoint, migration, policy, billing, security").option("--fields <fields>", "resource: fields, e.g. 'name:string, email:string!, status:enum(lead,customer)' (single quotes: bash treats ! in double quotes as history)").option("--group <name>", "resource: sidebar heading to file it under, e.g. Sales").option("--icon <name>", "resource: lucide icon for the sidebar, e.g. users").option("--method <verb>", "endpoint: GET (default), POST, PATCH, PUT or DELETE").option("--action <action>", "endpoint: policy action to require (read, create, update, delete)").option("--record", "endpoint: put it under one record, /api/<resource>/[id]/<name>").option("--force", "resource/policy/billing/security: overwrite hand-edited generated blocks").option("--from-schema", "migration: diff the current tables instead of a blank migration").option("--roles <roles>", "policy: roles allowed to read, create and update, e.g. admin,staff").option("--delete-roles <roles>", "policy: roles allowed to delete (default: the first --roles entry)").option("--provider <provider>", "billing: payment provider (default: stripe)").option("--mode <mode>", "billing: subscriptions (the default; includes one-time checkout)").option("--skip-install", "billing: write files without installing the stripe dependency").option("--skip-migration", "billing/security: skip generating the schema migration").example("flare gen resource Contact --fields 'name:string, email:string!, company:belongsTo(Company)?'").example("flare gen endpoint Order publish --method POST --record").example("flare gen migration backfill_contact_status").example("flare gen migration add_phone_to_contacts --from-schema").example("flare gen policy Invoice --roles admin,staff --delete-roles admin").example("flare gen billing --provider stripe --mode subscriptions").example("flare gen security").action(
     async (generator, name, second, options2) => {
       if (generator === "billing")