betterstart-cli 0.0.90 → 0.0.92

package/dist/cli.js

@@ -22,10 +22,9 @@ import {
 
 // cli.ts
 import { readFileSync } from "fs";
-import * as p30 from "@clack/prompts";
+import * as p31 from "@clack/prompts";
 
-// core-engine/commands/require-init.ts
-import path2 from "path";
+// core-engine/commands/default-action.ts
 import * as p from "@clack/prompts";
 
 // core-engine/config/resolver.ts
@@ -49,22 +48,9 @@ async function loadConfigFile(configPath) {
   return mod.default || mod;
 }
 
-// core-engine/commands/require-init.ts
-var INIT_COMMAND = "init";
-function resolveCommandCwd(command) {
-  const options = command.opts();
-  return typeof options.cwd === "string" ? path2.resolve(options.cwd) : process.cwd();
-}
-function requireInitializedProject(command) {
-  if (command.name() === INIT_COMMAND) {
-    return;
-  }
-  const cwd = resolveCommandCwd(command);
-  if (findConfigFile(cwd)) {
-    return;
-  }
-  p.log.error("Couldn't find betterstart project. Please run `betterstart init` first.");
-  process.exit(1);
+// core-engine/utils/interactive.ts
+function isInteractiveSession() {
+  return Boolean(process.stdin.isTTY) && process.env.CI !== "true";
 }
 
 // core-engine/commands/runtime.ts
@@ -196,9 +182,142 @@ function createUpdateStylesCommand(runtime) {
   return new Command("update-styles").description("Replace admin-globals.css with the latest version from the CLI").option("--cwd <path>", "Project root path").action((options) => runtime.runUpdateStyles(options));
 }
 
+// core-engine/commands/default-action.ts
+var ADD_COMMAND = "add";
+var CREATE_COMMAND = "create";
+var INIT_COMMAND = "init";
+var REMOVE_COMMAND = "remove";
+var REMOVE_SCHEMA_COMMAND = "remove-schema";
+var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+function cancelled(value) {
+  return value === CANCELLED;
+}
+async function runDefaultAction(program2, runtime) {
+  if (!isInteractiveSession()) {
+    program2.outputHelp();
+    return;
+  }
+  const cwd = process.cwd();
+  if (!findConfigFile(cwd)) {
+    await program2.parseAsync([INIT_COMMAND], { from: "user" });
+    return;
+  }
+  const argv = await promptInvocation(program2, runtime, cwd);
+  if (cancelled(argv)) {
+    p.cancel("No command selected.");
+    return;
+  }
+  await program2.parseAsync(argv, { from: "user" });
+}
+async function promptInvocation(program2, runtime, cwd) {
+  const name = await p.select({
+    message: "What do you want to do?",
+    options: program2.commands.map((command) => ({
+      value: command.name(),
+      label: command.name(),
+      hint: command.description()
+    }))
+  });
+  if (p.isCancel(name)) {
+    return CANCELLED;
+  }
+  const args = await promptRequiredArguments(name, runtime, cwd);
+  if (cancelled(args)) {
+    return CANCELLED;
+  }
+  return [name, ...args];
+}
+async function promptRequiredArguments(name, runtime, cwd) {
+  if (name === CREATE_COMMAND) {
+    const kind = await p.select({
+      message: "Schema kind",
+      options: CREATE_SCHEMA_KINDS.map((value) => ({ value, label: value }))
+    });
+    return p.isCancel(kind) ? CANCELLED : [kind];
+  }
+  if (name === ADD_COMMAND || name === REMOVE_COMMAND) {
+    return promptInstallables(name, runtime, cwd);
+  }
+  if (name === REMOVE_SCHEMA_COMMAND) {
+    const schemas = await runtime.listSchemaChoices(cwd);
+    if (schemas.length === 0) {
+      p.log.warn("No schemas to remove.");
+      return CANCELLED;
+    }
+    const schema = await p.select({
+      message: "Schema to remove",
+      options: schemas.map((value) => ({ value, label: value }))
+    });
+    return p.isCancel(schema) ? CANCELLED : [schema];
+  }
+  return [];
+}
+async function promptInstallables(name, runtime, cwd) {
+  const removing = name === REMOVE_COMMAND;
+  const choices = await runtime.listInstallableChoices(cwd);
+  const presets = choices.presets.filter((choice) => choice.installed === removing);
+  const integrations = choices.integrations.filter((choice) => choice.installed === removing);
+  if (presets.length === 0 && integrations.length === 0) {
+    p.log.warn(removing ? "Nothing installed to remove." : "Everything available is installed.");
+    return CANCELLED;
+  }
+  const family = await promptInstallableFamily(presets, integrations);
+  if (cancelled(family)) {
+    return CANCELLED;
+  }
+  const items = await p.multiselect({
+    message: removing ? "Items to remove" : "Items to install",
+    options: (family === "integration" ? integrations : presets).map((choice) => ({
+      value: choice.id,
+      label: choice.id,
+      hint: choice.description
+    }))
+  });
+  if (p.isCancel(items)) {
+    return CANCELLED;
+  }
+  return family === "integration" ? ["--integration", ...items] : items;
+}
+async function promptInstallableFamily(presets, integrations) {
+  if (integrations.length === 0) {
+    return "preset";
+  }
+  if (presets.length === 0) {
+    return "integration";
+  }
+  const family = await p.select({
+    message: "Presets or integrations?",
+    options: [
+      { value: "preset", label: "Presets", hint: "content presets (e.g. blog)" },
+      { value: "integration", label: "Integrations", hint: "services (e.g. r2, resend)" }
+    ]
+  });
+  return p.isCancel(family) ? CANCELLED : family;
+}
+
+// core-engine/commands/require-init.ts
+import path2 from "path";
+import * as p2 from "@clack/prompts";
+var INIT_COMMAND2 = "init";
+function resolveCommandCwd(command) {
+  const options = command.opts();
+  return typeof options.cwd === "string" ? path2.resolve(options.cwd) : process.cwd();
+}
+function requireInitializedProject(command) {
+  if (command.name() === INIT_COMMAND2) {
+    return;
+  }
+  const cwd = resolveCommandCwd(command);
+  if (findConfigFile(cwd)) {
+    return;
+  }
+  p2.log.error("Couldn't find betterstart project. Please run `betterstart init` first.");
+  process.exit(1);
+}
+
 // adapters/next/commands/add.ts
 import path27 from "path";
-import * as p7 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 
 // core-engine/config/serialize.ts
 import fs3 from "fs";
@@ -747,10 +866,93 @@ async function resolveConfigOrExit(cwd) {
 }
 
 // adapters/next/generators/post-generate.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFile } from "child_process";
 import fs8 from "fs";
 import path10 from "path";
-import * as p4 from "@clack/prompts";
+import { promisify } from "util";
+import * as p6 from "@clack/prompts";
+
+// core-engine/utils/spinner.ts
+import { stripVTControlCharacters } from "util";
+import * as p3 from "@clack/prompts";
+var RENDER_OVERHEAD = 7;
+var MIN_MESSAGE_WIDTH = 8;
+function fitSpinnerMessage(message) {
+  const normalized = message.replace(/\t/g, " ");
+  const columns = process.stdout.columns ?? 80;
+  const max = Math.max(columns - RENDER_OVERHEAD, MIN_MESSAGE_WIDTH);
+  const visible = stripVTControlCharacters(normalized);
+  if (visible.length <= max) return normalized;
+  return `${visible.slice(0, max - 1)}\u2026`;
+}
+var CLACK_LINE_ROWS = 2;
+var LOG_PREFIX_WIDTH = 3;
+function clackPromptRows(message, value) {
+  const columns = process.stdout.columns ?? 80;
+  const rows = (text7) => Math.max(1, Math.ceil((stripVTControlCharacters(text7).length + LOG_PREFIX_WIDTH) / columns));
+  return 1 + rows(message) + rows(value);
+}
+function clackLogRows(message) {
+  const columns = process.stdout.columns ?? 80;
+  const width = stripVTControlCharacters(message).length + LOG_PREFIX_WIDTH;
+  return 1 + Math.max(1, Math.ceil(width / columns));
+}
+function eraseRows(rows) {
+  if (rows <= 0 || !process.stdout.isTTY || process.env.CI === "true") return;
+  process.stdout.write(`\x1B[${rows}A\x1B[${rows}M`);
+}
+function eraseRowsAbove(rows, rowsBelow) {
+  if (rows <= 0 || rowsBelow < 0 || !process.stdout.isTTY || process.env.CI === "true") {
+    return;
+  }
+  const up = rows + rowsBelow;
+  const restore = rowsBelow > 0 ? `\x1B[${rowsBelow}B` : "";
+  process.stdout.write(`\x1B[${up}A\x1B[${rows}M${restore}`);
+}
+function eraseClackLine(options = {}) {
+  if (!process.stdout.isTTY || process.env.CI === "true") return;
+  const below = (options.linesBelow ?? 0) * CLACK_LINE_ROWS;
+  const up = below + CLACK_LINE_ROWS;
+  const restore = below > 0 ? `\x1B[${below}B` : "";
+  process.stdout.write(`\x1B[${up}A\x1B[${CLACK_LINE_ROWS}M${restore}`);
+}
+var activeSpinners = 0;
+function hasActiveSpinner() {
+  return activeSpinners > 0;
+}
+function spinner2(options) {
+  const inner = p3.spinner({ ...options, cancelMessage: "Setup cancelled." });
+  const guided = options?.withGuide !== false;
+  let started = false;
+  const setStarted = (next) => {
+    if (started === next) return;
+    started = next;
+    activeSpinners += next ? 1 : -1;
+  };
+  return {
+    start: (message = "") => {
+      if (started) {
+        inner.message(fitSpinnerMessage(message));
+        return;
+      }
+      setStarted(true);
+      inner.start(fitSpinnerMessage(message));
+    },
+    message: (message = "") => inner.message(fitSpinnerMessage(message)),
+    stop: (message = "") => {
+      setStarted(false);
+      inner.stop(message);
+    },
+    clear: () => {
+      if (!started) return;
+      setStarted(false);
+      inner.clear();
+      if (guided && process.stdout.isTTY && process.env.CI !== "true") {
+        process.stdout.write("\x1B[1A\x1B[2K");
+      }
+    }
+  };
+}
 
 // adapters/next/init/scaffolders/dependencies.ts
 import { spawn } from "child_process";
@@ -1633,7 +1835,7 @@ async function syncProjectCliDependency(cwd, pm) {
 // adapters/next/utils/drizzle-push.ts
 import { spawn as spawn2 } from "child_process";
 import path9 from "path";
-import * as p2 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 var PG_SSL_WARNING_START = "Warning: SECURITY WARNING: The SSL modes 'prefer', 'require', and 'verify-ca' are treated as aliases for 'verify-full'.";
 var PG_SSL_WARNING_END = "See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode definitions.";
 var NODE_TRACE_WARNING_HINT = "(Use `node --trace-warnings";
@@ -1809,7 +2011,7 @@ function runDrizzlePush(cwd, options = {}) {
         }
         if (stdoutTtySuppressor.sawError() || stderrTtySuppressor.sawError()) {
           notifyOutput();
-          p2.log.info("Database changes need your input \u2014 continuing in drizzle-kit.");
+          p4.log.info("Database changes need your input \u2014 continuing in drizzle-kit.");
           const attached = spawn2(drizzleBin, ["push", "--force"], {
             cwd,
             stdio: "inherit",
@@ -1855,7 +2057,7 @@ ${stderr}`.trim();
 }
 
 // adapters/next/utils/next-steps.ts
-import * as p3 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 function printNextSteps(options) {
   const steps = [`1. Review ${options.reviewLabel}`];
   if (options.needsMigration) {
@@ -1864,11 +2066,12 @@ function printNextSteps(options) {
   } else {
     steps.push(`2. Start the dev server and visit ${options.route}`);
   }
-  p3.note(steps.join("\n"), "Next steps");
+  p5.note(steps.join("\n"), "Next steps");
 }
 
 // adapters/next/generators/post-generate.ts
 var BIOME_FORMAT_TIMEOUT_MS = 3e4;
+var execFileAsync = promisify(execFile);
 function loadEnvFile(cwd) {
   const envPath = path10.join(cwd, ".env.local");
   if (!fs8.existsSync(envPath)) return;
@@ -1892,10 +2095,10 @@ function loadEnvFile(cwd) {
     }
   }
 }
-function runPmScript(pm, script, cwd, timeout) {
+async function runPmScript(pm, script, cwd, timeout) {
   const args = pm === "bun" ? ["run", script] : [script];
   try {
-    execFileSync2(pm, args, { cwd, stdio: "pipe", timeout });
+    await execFileAsync(pm, args, { cwd, timeout });
     return true;
   } catch {
     return false;
@@ -1906,7 +2109,7 @@ function getExistingTrackedFilePaths(cwd) {
     (filePath) => fs8.existsSync(path10.join(cwd, ...filePath.split("/")))
   );
 }
-function runBiomeCheckWrite(cwd) {
+async function runBiomeCheckWrite(cwd) {
   const biomeBin = path10.join(cwd, "node_modules", ".bin", "biome");
   if (!fs8.existsSync(biomeBin)) {
     return false;
@@ -1925,9 +2128,8 @@ function runBiomeCheckWrite(cwd) {
       ...configPath ? ["--config-path", configPath] : [],
       ...chunk
     ];
-    execFileSync2(biomeBin, args, {
+    await execFileAsync(biomeBin, args, {
       cwd,
-      stdio: "pipe",
       timeout: BIOME_FORMAT_TIMEOUT_MS
     });
   }
@@ -1944,18 +2146,15 @@ function buildAddDependencyArgs(pm, dependency, dev) {
       return ["install", ...devFlag ? [devFlag] : [], dependency];
   }
 }
-function installDependency(cwd, pm, dependency, dev = false) {
+async function installDependency(cwd, pm, dependency, dev = false) {
   try {
-    execFileSync2(pm, buildAddDependencyArgs(pm, dependency, dev), {
-      cwd,
-      stdio: "pipe"
-    });
+    await execFileAsync(pm, buildAddDependencyArgs(pm, dependency, dev), { cwd });
     return true;
   } catch {
     return false;
   }
 }
-function ensureDatabasePushDependencies(cwd, pm) {
+async function ensureDatabasePushDependencies(cwd, pm) {
   const missing = [];
   if (!hasPostgresRuntimeDependency(cwd)) {
     missing.push({ name: POSTGRES_RUNTIME_DEP, dev: false });
@@ -1966,25 +2165,25 @@ function ensureDatabasePushDependencies(cwd, pm) {
   if (missing.length === 0) {
     return true;
   }
-  p4.log.info(
+  p6.log.info(
     `Installing database push dependencies (${missing.map((dependency) => dependency.name).join(", ")})...`
   );
   for (const dependency of missing) {
-    const installed2 = installDependency(cwd, pm, dependency.name, dependency.dev);
+    const installed2 = await installDependency(cwd, pm, dependency.name, dependency.dev);
     if (!installed2) {
-      p4.log.warn(`Failed to install ${dependency.name}`);
+      p6.log.warn(`Failed to install ${dependency.name}`);
       return false;
     }
   }
   const ready = hasPostgresRuntimeDependency(cwd) && hasDrizzleKitPostgresDriverDependency(cwd);
   if (ready) {
-    p4.log.success("Database push dependencies installed");
+    p6.log.success("Database push dependencies installed");
   } else {
     const unresolved = [
       !hasPostgresRuntimeDependency(cwd) ? POSTGRES_RUNTIME_DEP : null,
       !hasDrizzleKitPostgresDriverDependency(cwd) ? DRIZZLE_KIT_POSTGRES_DRIVER_DEP : null
     ].filter((dependency) => Boolean(dependency));
-    p4.log.warn(`Installed dependencies but could not resolve ${unresolved.join(", ")}`);
+    p6.log.warn(`Installed dependencies but could not resolve ${unresolved.join(", ")}`);
   }
   return ready;
 }
@@ -2027,8 +2226,8 @@ async function runPostGenerate(cwd, schemaName, options = {}) {
       "Formatting: skipped (biome refuses files with conflict markers)",
       ...(options.conflictPaths ?? []).map((conflictPath) => `  - ${conflictPath}`)
     ];
-    p4.log.warn(lines.join("\n"));
-    p4.log.message(
+    p6.log.warn(lines.join("\n"));
+    p6.log.message(
       "Resolve markers in the files above and re-run the BetterStart command that wrote them. Post-write tasks run automatically once every file is clean."
     );
     return result;
@@ -2038,62 +2237,83 @@ async function runPostGenerate(cwd, schemaName, options = {}) {
     const dbUrl = process.env.DATABASE_URL;
     if (!dbUrl) {
       result.dbPush = "no-db-url";
-      p4.log.warn(
+      p6.log.warn(
         [
           "Database: skipped (no DATABASE_URL configured)",
           "  To sync later: run db:push after setting DATABASE_URL"
         ].join("\n")
       );
-    } else if (!ensureDatabasePushDependencies(cwd, pm)) {
+    } else if (!await ensureDatabasePushDependencies(cwd, pm)) {
       result.dbPush = "failed";
-      p4.log.warn(
+      p6.log.warn(
         "Database push failed (install database dependencies and run drizzle-kit push manually)"
       );
     } else if (hasPkgScript(cwd, "db:push")) {
-      p4.log.info("Running db:push...");
-      const ok = runPmScript(pm, "db:push", cwd);
+      const s = spinner2();
+      s.start("Pushing database schema");
+      const ok = await runPmScript(pm, "db:push", cwd);
       result.dbPush = ok ? "success" : "failed";
       if (ok) {
-        p4.log.success("Database schema synced");
+        s.stop("Database schema synced");
       } else {
-        p4.log.warn("Database push failed (run db:push manually)");
+        s.clear();
+        p6.log.warn("Database push failed (run db:push manually)");
       }
     } else {
-      p4.log.info("Running drizzle-kit push...");
+      const s = spinner2();
+      let spinnerVisible = true;
+      const clearSpinner = () => {
+        if (!spinnerVisible) return;
+        spinnerVisible = false;
+        s.clear();
+      };
+      s.start("Pushing database schema");
       try {
-        const pushResult = await runDrizzlePush(cwd, { interactive: true });
+        const pushResult = await runDrizzlePush(cwd, {
+          interactive: true,
+          onOutput: clearSpinner
+        });
         if (!pushResult.success) {
           throw new Error(pushResult.error ?? "drizzle-kit push failed");
         }
         result.dbPush = "success";
-        p4.log.success("Database schema synced");
+        if (spinnerVisible) {
+          spinnerVisible = false;
+          s.stop("Database schema synced");
+        } else {
+          p6.log.success("Database schema synced");
+        }
       } catch {
         result.dbPush = "failed";
-        p4.log.warn("Database push failed (run drizzle-kit push manually)");
+        clearSpinner();
+        p6.log.warn("Database push failed (run drizzle-kit push manually)");
       }
     }
   } else {
-    p4.log.info(`Database: skipped (${options.skipMigrationMessage ?? "--skip-migration"})`);
+    p6.log.info(`Database: skipped (${options.skipMigrationMessage ?? "--skip-migration"})`);
   }
+  const formatSpinner = spinner2();
+  formatSpinner.start("Formatting generated files");
   if (hasPkgScript(cwd, "lint:fix")) {
-    p4.log.info("Running lint:fix...");
-    const ok = runPmScript(pm, "lint:fix", cwd, BIOME_FORMAT_TIMEOUT_MS);
+    const ok = await runPmScript(pm, "lint:fix", cwd, BIOME_FORMAT_TIMEOUT_MS);
     result.lintFix = ok ? "success" : "failed";
     if (ok) {
-      p4.log.success("Code formatted");
+      formatSpinner.stop("Code formatted");
     } else {
-      p4.log.warn("Lint fix had issues (run lint:fix manually)");
+      formatSpinner.clear();
+      p6.log.warn("Lint fix had issues (run lint:fix manually)");
     }
   } else {
     try {
-      if (!runBiomeCheckWrite(cwd)) {
+      if (!await runBiomeCheckWrite(cwd)) {
         throw new Error("Biome binary not found");
       }
       result.lintFix = "success";
-      p4.log.success("Code formatted with Biome");
+      formatSpinner.stop("Code formatted with Biome");
     } catch {
       result.lintFix = "failed";
-      p4.log.warn("Biome formatting had issues (run biome check --write manually)");
+      formatSpinner.clear();
+      p6.log.warn("Biome formatting had issues (run biome check --write manually)");
     }
   }
   if (options.showNextSteps !== false) {
@@ -2110,7 +2330,7 @@ async function runPostGenerate(cwd, schemaName, options = {}) {
 // adapters/next/integration-runtime.ts
 import fs14 from "fs";
 import path17 from "path";
-import * as p5 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 
 // core-engine/schema/schema-reader.ts
 import fs9 from "fs";
@@ -2916,15 +3136,15 @@ function collectSchemaSlotLayoutErrors(schema, errors) {
   }
   collectSlotLayoutErrors(input.slot, "slot", errors);
 }
-function collectSlotLayoutErrors(value, path61, errors) {
+function collectSlotLayoutErrors(value, path62, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path61} must be an object with "main" and/or "sidebar" field groups.`);
+    errors.push(`${path62} must be an object with "main" and/or "sidebar" field groups.`);
     return;
   }
   const validKeys = /* @__PURE__ */ new Set(["main", "sidebar"]);
   for (const key of Object.keys(value)) {
     if (!validKeys.has(key)) {
-      errors.push(`${path61} has unsupported key "${key}". Expected "main" or "sidebar".`);
+      errors.push(`${path62} has unsupported key "${key}". Expected "main" or "sidebar".`);
     }
   }
   const areas = [
@@ -2935,24 +3155,24 @@ function collectSlotLayoutErrors(value, path61, errors) {
   for (const [name, area] of areas) {
     if (area === void 0) continue;
     hasArea = true;
-    collectSlotAreaErrors(area, `${path61}.${name}`, errors);
+    collectSlotAreaErrors(area, `${path62}.${name}`, errors);
   }
   if (!hasArea) {
-    errors.push(`${path61} must define at least one of "main" or "sidebar".`);
+    errors.push(`${path62} must define at least one of "main" or "sidebar".`);
   }
 }
-function collectSlotAreaErrors(value, path61, errors) {
+function collectSlotAreaErrors(value, path62, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path61} must be an object with a "fields" array.`);
+    errors.push(`${path62} must be an object with a "fields" array.`);
     return;
   }
   const fields = value.fields;
   if (!Array.isArray(fields)) {
-    errors.push(`${path61}.fields must be an array.`);
+    errors.push(`${path62}.fields must be an array.`);
     return;
   }
   for (const field of fields) {
-    walkSlot(field, `${path61}.fields.${field.name ?? "unnamed"}`, errors);
+    walkSlot(field, `${path62}.fields.${field.name ?? "unnamed"}`, errors);
   }
 }
 function collectInvalidHeightErrors(topLevelFields, rootPath, errors) {
@@ -3436,12 +3656,12 @@ async function resolveTextEnvValue(options) {
   if (existingValue) {
     return existingValue;
   }
-  const result = await p5.text({
+  const result = await p7.text({
     message: options.message,
     defaultValue: options.defaultValue,
     validate: options.validate
   });
-  if (p5.isCancel(result)) {
+  if (p7.isCancel(result)) {
     throw new Error(options.cancelMessage);
   }
   options.overwriteEnvKeys.add(options.key);
@@ -3452,11 +3672,11 @@ async function resolvePasswordEnvValue(options) {
   if (existingValue) {
     return existingValue;
   }
-  const result = await p5.password({
+  const result = await p7.password({
     message: options.message,
     validate: options.validate
   });
-  if (p5.isCancel(result)) {
+  if (p7.isCancel(result)) {
     throw new Error(options.cancelMessage);
   }
   options.overwriteEnvKeys.add(options.key);
@@ -4788,9 +5008,9 @@ function getReadFieldType(field) {
   }
   return getFieldType(field, "output");
 }
-function collectReadSelectFields(fields, path61 = []) {
+function collectReadSelectFields(fields, path62 = []) {
   const matches = fields.flatMap((field) => {
-    const currentPath = [...path61, field.name];
+    const currentPath = [...path62, field.name];
     const matches2 = field.type === "select" ? [{ field, path: currentPath }] : [];
     if (field.fields) {
       matches2.push(...collectReadSelectFields(field.fields, currentPath));
@@ -5837,14 +6057,14 @@ function buildStepsConstant(steps) {
 ${entries.join(",\n")}
 ]`;
 }
-function buildComponentSource(p31) {
+function buildComponentSource(p32) {
   const providerOpen = `    <NuqsAdapter>
       <React.Suspense fallback={null}>
-        <${p31.pascal}FormInner />
+        <${p32.pascal}FormInner />
       </React.Suspense>
     </NuqsAdapter>`;
   const exportWrapper = `
-export function ${p31.pascal}Form() {
+export function ${p32.pascal}Form() {
   return (
 ${providerOpen}
   )
@@ -5853,22 +6073,22 @@ ${providerOpen}
   return `'use client'
 
 import { standardSchemaResolver } from '@hookform/resolvers/standard-schema'
-import { ChevronLeft, ChevronRight${p31.hasListFields ? ", Trash2" : ""} } from 'lucide-react'
+import { ChevronLeft, ChevronRight${p32.hasListFields ? ", Trash2" : ""} } from 'lucide-react'
 import { createParser, useQueryState } from 'nuqs'
 import { NuqsAdapter } from 'nuqs/adapters/next/app'
 import * as React from 'react'
-${p31.rhfImport}
+${p32.rhfImport}
 import { z } from 'zod/v3'
-import { create${p31.pascal}Submission } from '@admin/actions/${p31.actionImportPath}'
+import { create${p32.pascal}Submission } from '@admin/actions/${p32.actionImportPath}'
 
 const formSchema = z.object({
-${p31.zodFields}
+${p32.zodFields}
 })
 
 type FormValues = z.infer<typeof formSchema>
 ${buildFieldErrorHelper()}
 
-${p31.stepsConst}
+${p32.stepsConst}
 
 const stepParser = createParser({
   parse(value) {
@@ -5886,7 +6106,7 @@ const stepParser = createParser({
   }
 }).withDefault(0)
 
-function ${p31.pascal}FormInner() {
+function ${p32.pascal}FormInner() {
   const [currentStep, setCurrentStep] = useQueryState('step', stepParser)
   const [submitted, setSubmitted] = React.useState(false)
   const [submitting, startSubmitTransition] = React.useTransition()
@@ -5894,11 +6114,11 @@ function ${p31.pascal}FormInner() {
   const form = useForm<FormValues>({
     resolver: standardSchemaResolver(formSchema),
     defaultValues: {
-${p31.defaults}
+${p32.defaults}
     },
   })
 
-${p31.fieldArraySetup}${p31.watchSetup}
+${p32.fieldArraySetup}${p32.watchSetup}
   async function handleNext() {
     const stepFields = STEPS[currentStep].fields as (keyof FormValues)[]
     const isValid = await form.trigger(stepFields, { shouldFocus: true })
@@ -5914,9 +6134,9 @@ ${p31.fieldArraySetup}${p31.watchSetup}
   function onSubmit(values: FormValues) {
     startSubmitTransition(async () => {
       try {
-        const result = await create${p31.pascal}Submission(values)
+        const result = await create${p32.pascal}Submission(values)
         if (result.success) {
-          ${p31.successHandler}
+          ${p32.successHandler}
         } else {
           form.setError('root', { message: result.error || 'Something went wrong' })
         }
@@ -5930,7 +6150,7 @@ ${p31.fieldArraySetup}${p31.watchSetup}
     return (
       <div className="rounded-sm border p-6 text-center">
         <h3 className="text-lg font-semibold">Thank you!</h3>
-        <p className="mt-2 text-muted-foreground">${p31.successMessage}</p>
+        <p className="mt-2 text-muted-foreground">${p32.successMessage}</p>
       </div>
     )
   }
@@ -5947,7 +6167,7 @@ ${p31.fieldArraySetup}${p31.watchSetup}
 
         {/* Step content */}
         <div key={currentStep} className="animate-in fade-in duration-300 space-y-6">
-${p31.stepContentBlocks}
+${p32.stepContentBlocks}
         </div>
 
         {form.formState.errors.root && (
@@ -5981,7 +6201,7 @@ ${p31.stepContentBlocks}
               onClick={() => form.handleSubmit(onSubmit)()}
               className="inline-flex h-9 items-center justify-center rounded-md bg-primary px-4 py-2 text-sm font-medium text-primary-foreground shadow-xs transition-colors hover:bg-primary/90 disabled:pointer-events-none disabled:opacity-50"
             >
-              {submitting ? 'Submitting...' : ${p31.submitText}}
+              {submitting ? 'Submitting...' : ${p32.submitText}}
             </button>
           )}
         </div>
@@ -13997,14 +14217,14 @@ function safeIdentifier(value, fallback) {
   const base = pascal ? `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}` : fallback;
   return /^[A-Za-z_$]/.test(base) ? base : fallback;
 }
-function pathExpression(path61) {
-  return `\`${path61.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
+function pathExpression(path62) {
+  return `\`${path62.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
 }
-function pathNameProp(path61) {
-  if (path61.every((part) => typeof part === "string")) {
-    return `"${path61.map((part) => part).join(".")}"`;
+function pathNameProp(path62) {
+  if (path62.every((part) => typeof part === "string")) {
+    return `"${path62.map((part) => part).join(".")}"`;
   }
-  return `{${pathExpression(path61)}}`;
+  return `{${pathExpression(path62)}}`;
 }
 function findTitlePath(fields) {
   const stringTypes = ["string", "varchar", "text"];
@@ -14026,23 +14246,23 @@ function findTitlePath(fields) {
 function requiredLeafPaths(fields, prefix = []) {
   return fields.flatMap((field) => {
     if (field.hidden) return [];
-    const path61 = [...prefix, field.name];
+    const path62 = [...prefix, field.name];
     if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-      return requiredLeafPaths(field.fields, path61);
+      return requiredLeafPaths(field.fields, path62);
     }
-    if (field.required) return [path61.join(".")];
+    if (field.required) return [path62.join(".")];
     return [];
   });
 }
 function validationTriggerExpression(basePath, requiredPaths) {
   if (requiredPaths.length === 0) return `\`${basePath}.\${expandedIndex}\` as never`;
-  const paths = requiredPaths.map((path61) => `\`${basePath}.\${expandedIndex}.${path61}\``).join(", ");
+  const paths = requiredPaths.map((path62) => `\`${basePath}.\${expandedIndex}.${path62}\``).join(", ");
   return `[${paths}] as never`;
 }
-function renderTextInputField(field, indent, label, nestedHint, path61) {
+function renderTextInputField(field, indent, label, nestedHint, path62) {
   return `${indent}<FormField
 ${indent}  control={form.control}
-${indent}  name=${pathNameProp(path61)}
+${indent}  name=${pathNameProp(path62)}
 ${indent}  render={({ field: formField }) => (
 ${indent}    <FormItem${formItemProps(field)}>
 ${indent}      ${labelWithDescription(formLabel(field, label), nestedHint, `${indent}      `)}
@@ -14054,11 +14274,11 @@ ${indent}    </FormItem>
 ${indent}  )}
 ${indent}/>`;
 }
-function renderNestedField(field, indent, path61, depth) {
+function renderNestedField(field, indent, path62, depth) {
   const nestedLabel = field.label || field.name;
   const nestedHint = field.hint ? `<FormDescription>${field.hint}</FormDescription>` : "";
   if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path61, child.name], depth)).filter(Boolean).join("\n");
+    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path62, child.name], depth)).filter(Boolean).join("\n");
     if (!groupFields) return "";
     const heading = nestedLabel && nestedLabel !== field.name ? `${indent}<h3 className="text-base font-medium">${nestedLabel}</h3>
 ` : "";
@@ -14068,7 +14288,7 @@ ${groupFields}
 ${indent}</div>`;
   }
   if (field.type === "list" && field.fields?.length) {
-    return renderNestedObjectListField(field, indent, nestedLabel, path61, depth);
+    return renderNestedObjectListField(field, indent, nestedLabel, path62, depth);
   }
   if (field.type === "list") {
     const hideLabelProp = field.label ? "" : `
@@ -14076,7 +14296,7 @@ ${indent}  hideLabel`;
     const descriptionProp = field.hint ? `
 ${indent}  description={${JSON.stringify(field.hint)}}` : "";
     return `${indent}<DynamicListField
-${indent}  name={${pathExpression(path61)}}
+${indent}  name={${pathExpression(path62)}}
 ${indent}  label="${nestedLabel}"${hideLabelProp}${descriptionProp}
 ${indent}  disabled={isPending}${field.maxItems ? `
 ${indent}  maxItems={${field.maxItems}}` : ""}
@@ -14086,7 +14306,7 @@ ${indent}/>`;
   if (field.type === "boolean") {
     return `${indent}<FormField
 ${indent}  control={form.control}
-${indent}  name=${pathNameProp(path61)}
+${indent}  name=${pathNameProp(path62)}
 ${indent}  render={({ field: formField }) => (
 ${indent}    <FormItem${formItemProps(field, "flex flex-row items-start space-x-3 space-y-0")}>
 ${indent}      <FormControl>
@@ -14101,7 +14321,7 @@ ${indent}/>`;
     const acceptProp = field.type === "image" ? ' accept="image/*"' : field.type === "video" ? ' accept="video/*"' : "";
     return `${indent}<FormField
 ${indent}  control={form.control}
-${indent}  name=${pathNameProp(path61)}
+${indent}  name=${pathNameProp(path62)}
 ${indent}  render={({ field: formField }) => (
 ${indent}    <FormItem${formItemProps(field)}>
 ${indent}      ${labelWithDescription(formLabel(field, nestedLabel), nestedHint, `${indent}      `)}
@@ -14116,7 +14336,7 @@ ${indent}/>`;
   if (field.type === "icon") {
     return `${indent}<FormField
 ${indent}  control={form.control}
-${indent}  name=${pathNameProp(path61)}
+${indent}  name=${pathNameProp(path62)}
 ${indent}  render={({ field: formField }) => (
 ${indent}    <FormItem${formItemProps(field)}>
 ${indent}      ${labelWithDescription(formLabel(field, nestedLabel), nestedHint, `${indent}      `)}
@@ -14133,7 +14353,7 @@ ${indent}/>`;
     const emptyValue = field.required ? "undefined" : "null";
     return `${indent}<FormField
 ${indent}  control={form.control}
-${indent}  name=${pathNameProp(path61)}
+${indent}  name=${pathNameProp(path62)}
 ${indent}  render={({ field: formField }) => (
 ${indent}    <FormItem${formItemProps(field)}>
 ${indent}      ${labelWithDescription(formLabel(field, nestedLabel), nestedHint, `${indent}      `)}
@@ -14158,16 +14378,16 @@ ${indent}    </FormItem>
 ${indent}  )}
 ${indent}/>`;
   }
-  return renderTextInputField(field, indent, nestedLabel, nestedHint, path61);
+  return renderTextInputField(field, indent, nestedLabel, nestedHint, path62);
 }
-function renderNestedObjectListField(field, indent, label, path61, depth) {
+function renderNestedObjectListField(field, indent, label, path62, depth) {
   const singularLabel = singularize(label);
   const itemIndexVar = `${safeIdentifier(field.name, "nestedList")}Index${depth}`;
   const titlePath = findTitlePath(field.fields ?? []);
   const titlePathSuffix = titlePath ? `.${titlePath.join(".")}` : "";
   const renderTitleProp = titlePath ? `
 ${indent}  renderTitle={(${itemIndexVar}) =>
-${indent}    String(form.watch(\`${path61.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(
+${indent}    String(form.watch(\`${path62.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(
     "."
   )}.\${${itemIndexVar}}${titlePathSuffix}\` as never) || \`${singularLabel} \${${itemIndexVar} + 1}\`)
 ${indent}  }` : "";
@@ -14175,7 +14395,7 @@ ${indent}  }` : "";
     (child) => renderNestedField(
       child,
       `${indent}      `,
-      [...path61, { expression: itemIndexVar }, child.name],
+      [...path62, { expression: itemIndexVar }, child.name],
       depth + 1
     )
   ).filter(Boolean).join("\n");
@@ -14190,7 +14410,7 @@ ${indent}  maxItems={${field.maxItems}}` : "";
   const validatePathsProp = validatePaths.length > 0 ? `
 ${indent}  validatePaths={${JSON.stringify(validatePaths)}}` : "";
   return `${indent}<NestedObjectListField
-${indent}  name={${pathExpression(path61)}}
+${indent}  name={${pathExpression(path62)}}
 ${indent}  label={${JSON.stringify(label)}}
 ${indent}  singularLabel={${JSON.stringify(singularLabel)}}
 ${indent}  defaultValue={${defaultItem}}
@@ -17805,7 +18025,7 @@ function readPresetTemplate(presetId, relativePath) {
 // adapters/next/snapshots/apply.ts
 import fs20 from "fs";
 import path24 from "path";
-import * as p6 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 
 // core-engine/snapshots/ast-substitution.ts
 import { Node, Project } from "ts-morph";
@@ -17826,7 +18046,7 @@ function applyTextEdits(content, edits) {
     content
   );
 }
-function collectPreviewChanges(path61, beforeContent, afterContent) {
+function collectPreviewChanges(path62, beforeContent, afterContent) {
   const beforeLines = beforeContent.split("\n");
   const afterLines = afterContent.split("\n");
   const maxLength = Math.max(beforeLines.length, afterLines.length);
@@ -17838,7 +18058,7 @@ function collectPreviewChanges(path61, beforeContent, afterContent) {
       continue;
     }
     changes.push({
-      path: path61,
+      path: path62,
       line: index + 1,
       before: before.trim(),
       after: after.trim()
@@ -18167,7 +18387,7 @@ function hasConflictMarkers(content) {
 }
 
 // adapters/next/snapshots/format-for-merge.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import fs18 from "fs";
 import path22 from "path";
 var BIOME_FORMAT_TIMEOUT_MS2 = 15e3;
@@ -18217,7 +18437,7 @@ function formatContentForSnapshotMerge(cwd, filePath, content) {
   const configPath = findBiomeConfig(cwd);
   const targetPath = path22.join(cwd, ...filePath.split("/"));
   try {
-    return execFileSync3(
+    return execFileSync2(
       biomeBin,
       [
         "check",
@@ -18468,11 +18688,11 @@ function buildMergeInput(cwd, baseFile, localContent, remoteFile) {
     }
   };
 }
-function isInteractiveSession(interactive) {
+function isInteractiveSession2(interactive) {
   return interactive && Boolean(process.stdin.isTTY) && process.env.CI !== "true";
 }
 async function promptNoBaseDecision(filePath) {
-  const answer = await p6.select({
+  const answer = await p8.select({
     message: `File already exists without snapshot base: ${filePath}`,
     options: [
       { value: "backup", label: "Backup and overwrite", hint: "recommended" },
@@ -18481,7 +18701,7 @@ async function promptNoBaseDecision(filePath) {
     ],
     initialValue: "backup"
   });
-  if (p6.isCancel(answer)) {
+  if (p8.isCancel(answer)) {
     throw new Error("Generation cancelled.");
   }
   return answer;
@@ -18517,7 +18737,7 @@ async function applyGeneratedFiles({
   const remoteFiles = sortGeneratedFiles(generatedFiles);
   const remotePaths = new Set(remoteFiles.map((file) => file.path));
   const skipped = new Set(force ? [] : manifest?.skipped ?? []);
-  const interactiveSession = isInteractiveSession(interactive);
+  const interactiveSession = isInteractiveSession2(interactive);
   const aliasMap = renamePlan ? buildRenamePlanAliasMap(renamePlan) : /* @__PURE__ */ new Map();
   const consumedBasePaths = /* @__PURE__ */ new Set();
   let baseFiles = /* @__PURE__ */ new Map();
@@ -19362,18 +19582,18 @@ async function runAddCommand(items, options) {
   const presetIds = items.filter(isPresetId);
   const integrationIds = items.filter(isIntegrationId);
   if (!installIntegrationsMode && integrationIds.length > 0) {
-    p7.log.error(
+    p9.log.error(
       `Integration IDs require --integration. Run \`betterstart add --integration ${integrationIds.join(" ")}\`.`
     );
     process.exit(1);
   }
   if (installIntegrationsMode && presetIds.length > 0) {
-    p7.log.error(`Preset IDs cannot be installed with --integration: ${presetIds.join(", ")}`);
+    p9.log.error(`Preset IDs cannot be installed with --integration: ${presetIds.join(", ")}`);
     process.exit(1);
   }
   const invalidItems = installIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((presetId) => !isPresetId(presetId));
   if (invalidItems.length > 0) {
-    p7.log.error(
+    p9.log.error(
       installIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPresetMessage(invalidItems)
     );
     process.exit(1);
@@ -19384,7 +19604,7 @@ async function runAddCommand(items, options) {
   const pm = detectPackageManager(cwd);
   const cliSyncResult = await syncProjectCliDependency(cwd, pm);
   if (cliSyncResult && !cliSyncResult.success) {
-    p7.log.error(cliSyncResult.error ?? "Failed to sync betterstart-cli");
+    p9.log.error(cliSyncResult.error ?? "Failed to sync betterstart-cli");
     process.exit(1);
   }
   if (installIntegrationsMode) {
@@ -19398,10 +19618,10 @@ async function runAddCommand(items, options) {
     });
     writeConfigFile(cwd, result2.config);
     if (result2.warnings.length > 0) {
-      p7.note(result2.warnings.join("\n"), "Warnings");
+      p9.note(result2.warnings.join("\n"), "Warnings");
     }
     if (result2.installed.length === 0 && result2.activated.length === 0 && result2.skipped.length > 0) {
-      p7.outro(`No changes made. Already installed: ${result2.skipped.join(", ")}`);
+      p9.outro(`No changes made. Already installed: ${result2.skipped.join(", ")}`);
       return;
     }
     const conflictPaths2 = scanConflictPaths(cwd);
@@ -19423,12 +19643,12 @@ async function runAddCommand(items, options) {
       result2.installed.length > 0 ? `Installed integration${result2.installed.length === 1 ? "" : "s"}: ${result2.installed.join(", ")}` : null,
       result2.activated.length > 0 ? `Activated integration${result2.activated.length === 1 ? "" : "s"}: ${result2.activated.join(", ")}` : null
     ].filter(Boolean);
-    p7.outro(messages.join("\n"));
+    p9.outro(messages.join("\n"));
     return;
   }
   const invalidPresets = items.filter((presetId) => !isPresetId(presetId));
   if (invalidPresets.length > 0) {
-    p7.log.error(formatUnknownPresetMessage(invalidPresets));
+    p9.log.error(formatUnknownPresetMessage(invalidPresets));
     process.exit(1);
   }
   const result = await installPresets({
@@ -19441,11 +19661,11 @@ async function runAddCommand(items, options) {
   });
   writeConfigFile(cwd, result.config);
   if (result.installed.length === 0 && result.skipped.length > 0) {
-    p7.outro(`No changes made. Already installed: ${result.skipped.join(", ")}`);
+    p9.outro(`No changes made. Already installed: ${result.skipped.join(", ")}`);
     return;
   }
   if (result.warnings.length > 0) {
-    p7.note(result.warnings.join("\n"), "Warnings");
+    p9.note(result.warnings.join("\n"), "Warnings");
   }
   const installedSchemaNames = result.installed.flatMap(
     (presetId) => getPresetDefinition(presetId).schemaFiles.map((schemaFile) => schemaFile.replace(/\.json$/, ""))
@@ -19462,14 +19682,14 @@ async function runAddCommand(items, options) {
   if (conflictPaths.length === 0) {
     printAddNextSteps("preset", hasSchemaChanges, postGenerateResult, adminRoutePath);
   }
-  p7.outro(
+  p9.outro(
     `Installed preset${result.installed.length === 1 ? "" : "s"}: ${result.installed.join(", ")}`
   );
 }
 
 // adapters/next/commands/add-field.ts
 import path30 from "path";
-import * as p11 from "@clack/prompts";
+import * as p12 from "@clack/prompts";
 
 // core-engine/schema/add-field.ts
 import fs23 from "fs";
@@ -20121,7 +20341,7 @@ function getTabFields(tab) {
 // adapters/next/commands/generate.ts
 import fs24 from "fs";
 import path29 from "path";
-import * as p9 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 
 // core-engine/snapshots/rename-detector.ts
 function levenshtein(a, b) {
@@ -20213,90 +20433,8 @@ function diffSchemas(before, after) {
   };
 }
 
-// core-engine/utils/spinner.ts
-import { stripVTControlCharacters } from "util";
-import * as p8 from "@clack/prompts";
-var RENDER_OVERHEAD = 7;
-var MIN_MESSAGE_WIDTH = 8;
-function fitSpinnerMessage(message) {
-  const normalized = message.replace(/\t/g, " ");
-  const columns = process.stdout.columns ?? 80;
-  const max = Math.max(columns - RENDER_OVERHEAD, MIN_MESSAGE_WIDTH);
-  const visible = stripVTControlCharacters(normalized);
-  if (visible.length <= max) return normalized;
-  return `${visible.slice(0, max - 1)}\u2026`;
-}
-var CLACK_LINE_ROWS = 2;
-var LOG_PREFIX_WIDTH = 3;
-function clackPromptRows(message, value) {
-  const columns = process.stdout.columns ?? 80;
-  const rows = (text7) => Math.max(1, Math.ceil((stripVTControlCharacters(text7).length + LOG_PREFIX_WIDTH) / columns));
-  return 1 + rows(message) + rows(value);
-}
-function clackLogRows(message) {
-  const columns = process.stdout.columns ?? 80;
-  const width = stripVTControlCharacters(message).length + LOG_PREFIX_WIDTH;
-  return 1 + Math.max(1, Math.ceil(width / columns));
-}
-function eraseRows(rows) {
-  if (rows <= 0 || !process.stdout.isTTY || process.env.CI === "true") return;
-  process.stdout.write(`\x1B[${rows}A\x1B[${rows}M`);
-}
-function eraseRowsAbove(rows, rowsBelow) {
-  if (rows <= 0 || rowsBelow < 0 || !process.stdout.isTTY || process.env.CI === "true") {
-    return;
-  }
-  const up = rows + rowsBelow;
-  const restore = rowsBelow > 0 ? `\x1B[${rowsBelow}B` : "";
-  process.stdout.write(`\x1B[${up}A\x1B[${rows}M${restore}`);
-}
-function eraseClackLine(options = {}) {
-  if (!process.stdout.isTTY || process.env.CI === "true") return;
-  const below = (options.linesBelow ?? 0) * CLACK_LINE_ROWS;
-  const up = below + CLACK_LINE_ROWS;
-  const restore = below > 0 ? `\x1B[${below}B` : "";
-  process.stdout.write(`\x1B[${up}A\x1B[${CLACK_LINE_ROWS}M${restore}`);
-}
-var activeSpinners = 0;
-function hasActiveSpinner() {
-  return activeSpinners > 0;
-}
-function spinner2(options) {
-  const inner = p8.spinner({ ...options, cancelMessage: "Setup cancelled." });
-  const guided = options?.withGuide !== false;
-  let started = false;
-  const setStarted = (next) => {
-    if (started === next) return;
-    started = next;
-    activeSpinners += next ? 1 : -1;
-  };
-  return {
-    start: (message = "") => {
-      if (started) {
-        inner.message(fitSpinnerMessage(message));
-        return;
-      }
-      setStarted(true);
-      inner.start(fitSpinnerMessage(message));
-    },
-    message: (message = "") => inner.message(fitSpinnerMessage(message)),
-    stop: (message = "") => {
-      setStarted(false);
-      inner.stop(message);
-    },
-    clear: () => {
-      if (!started) return;
-      setStarted(false);
-      inner.clear();
-      if (guided && process.stdout.isTTY && process.env.CI !== "true") {
-        process.stdout.write("\x1B[1A\x1B[2K");
-      }
-    }
-  };
-}
-
 // adapters/next/commands/generate.ts
-function isInteractiveSession2() {
+function isInteractiveSession3() {
   return Boolean(process.stdin.isTTY) && process.env.CI !== "true";
 }
 function isStoredSchemaJson(schemaJson) {
@@ -20381,7 +20519,7 @@ function assertSnapshotStateOrExit(cwd) {
   if (snapshotRootExists(cwd)) {
     return;
   }
-  p9.log.error(UNSUPPORTED_PROJECT_STATE_MESSAGE);
+  p10.log.error(UNSUPPORTED_PROJECT_STATE_MESSAGE);
   process.exit(1);
 }
 function printSchemaDiff(scope, loaded, cwd) {
@@ -20416,14 +20554,14 @@ function printSchemaDiff(scope, loaded, cwd) {
       `  custom cells: +[${diff.customComponents.added.join(", ")}] -[${diff.customComponents.removed.join(", ")}]`
     );
   }
-  p9.log.message(lines.join("\n"));
+  p10.log.message(lines.join("\n"));
 }
 async function promptConfirm(message) {
-  const result = await p9.confirm({
+  const result = await p10.confirm({
     message,
     initialValue: true
   });
-  if (p9.isCancel(result)) {
+  if (p10.isCancel(result)) {
     throw new Error("Generation cancelled.");
   }
   return Boolean(result);
@@ -20553,7 +20691,7 @@ async function maybeBuildRenamePlan(loaded, cwd, config, generatedFiles, options
   };
   if (finalPlan.fields.length === 0 && finalPlan.customCells.length === 0) {
     if (validatedCustomCells.warnings.length > 0) {
-      p9.log.warn(validatedCustomCells.warnings.join("\n"));
+      p10.log.warn(validatedCustomCells.warnings.join("\n"));
     }
     return void 0;
   }
@@ -20571,10 +20709,10 @@ async function maybeBuildRenamePlan(loaded, cwd, config, generatedFiles, options
   if (preview.previewLines.length > previewLines.length) {
     renameLines.push(`  ... ${preview.previewLines.length - previewLines.length} more change(s)`);
   }
-  p9.log.message(renameLines.join("\n"));
+  p10.log.message(renameLines.join("\n"));
   const warnings = [...validatedCustomCells.warnings, ...preview.warnings];
   if (warnings.length > 0) {
-    p9.log.warn(warnings.join("\n"));
+    p10.log.warn(warnings.join("\n"));
   }
   const confirmed = await promptConfirm("Apply these rename substitutions before merge?");
   return confirmed ? finalPlan : void 0;
@@ -20685,16 +20823,16 @@ function printApplySummary(schemaName, summary) {
   if (summary.skippedCleared.length > 0) {
     lines.push(`  skip entries cleared: ${summary.skippedCleared.join(", ")}`);
   }
-  p9.log.message(lines.join("\n"));
+  p10.log.message(lines.join("\n"));
 }
 async function runGenerateCommand(schemaName, options) {
   const cwd = options.cwd ? path29.resolve(options.cwd) : process.cwd();
-  const interactive = options.all ? options.interactive && isInteractiveSession2() : isInteractiveSession2();
+  const interactive = options.all ? options.interactive && isInteractiveSession3() : isInteractiveSession3();
   let config;
   try {
     config = await resolveConfig(cwd);
   } catch (error) {
-    p9.log.error(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
+    p10.log.error(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
   assertSnapshotStateOrExit(cwd);
@@ -20704,7 +20842,7 @@ async function runGenerateCommand(schemaName, options) {
   if (options.all) {
     const schemaNames = listSchemaNames(schemasDir);
     if (schemaNames.length === 0) {
-      p9.log.error(`No schemas found in ${schemasDir}`);
+      p10.log.error(`No schemas found in ${schemasDir}`);
       process.exit(1);
     }
     const failed = [];
@@ -20712,14 +20850,14 @@ async function runGenerateCommand(schemaName, options) {
     const processedRoutes = [];
     let markdownDepsChecked = false;
     const adminRoutePath2 = resolveAdminNamespace(config.frameworkConfig.next.namespace).routePath;
-    p9.intro(`BetterStart Generator \u2014 regenerating ${schemaNames.length} schema(s)`);
+    p10.intro(`BetterStart Generator \u2014 regenerating ${schemaNames.length} schema(s)`);
     for (const name of schemaNames) {
       if (hasTombstone(cwd, name)) {
         if (loadManifest(cwd, name)) {
           clearTombstone(cwd, name);
-          p9.log.warn(`${name}: tombstone cleared (manifest present)`);
+          p10.log.warn(`${name}: tombstone cleared (manifest present)`);
         } else {
-          p9.log.message(`${name}: skipped (tombstoned)`);
+          p10.log.message(`${name}: skipped (tombstoned)`);
           continue;
         }
       }
@@ -20745,7 +20883,7 @@ async function runGenerateCommand(schemaName, options) {
         processed.push(name);
         processedRoutes.push(getGeneratedSchemaRoutePath(loaded2, adminRoutePath2));
       } catch (error) {
-        p9.log.error(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+        p10.log.error(`${name}: ${error instanceof Error ? error.message : String(error)}`);
         failed.push(name);
       }
     }
@@ -20768,14 +20906,14 @@ async function runGenerateCommand(schemaName, options) {
       });
     }
     if (failed.length > 0) {
-      p9.log.error(`Failed: ${failed.join(", ")}`);
+      p10.log.error(`Failed: ${failed.join(", ")}`);
       process.exit(1);
     }
-    p9.outro(`Regenerated ${processed.length}/${schemaNames.length} schema(s)`);
+    p10.outro(`Regenerated ${processed.length}/${schemaNames.length} schema(s)`);
     return;
   }
   if (!schemaName) {
-    p9.log.error("Error: schema name is required (or use --all)");
+    p10.log.error("Error: schema name is required (or use --all)");
     process.exit(1);
   }
   let loaded;
@@ -20783,20 +20921,20 @@ async function runGenerateCommand(schemaName, options) {
     loaded = loadSchema(schemasDir, schemaName);
   } catch (error) {
     if (error instanceof SchemaNotFoundError) {
-      p9.log.error(error.message);
+      p10.log.error(error.message);
     } else {
-      p9.log.error(`Error loading schema: ${error instanceof Error ? error.message : String(error)}`);
+      p10.log.error(`Error loading schema: ${error instanceof Error ? error.message : String(error)}`);
     }
     process.exit(1);
   }
   const validationErrors = validateLoadedSchema(loaded);
   if (validationErrors.length > 0) {
-    p9.log.error(
+    p10.log.error(
       ["Schema validation failed:", ...validationErrors.map((error) => `  - ${error}`)].join("\n")
     );
     process.exit(1);
   }
-  p9.intro(`BetterStart Generator \u2014 ${loaded.schema.name}`);
+  p10.intro(`BetterStart Generator \u2014 ${loaded.schema.name}`);
   const needsMarkdownRenderer = schemaNeedsMarkdownRenderer(loaded);
   await ensureMarkdownRendererDependencies(cwd, needsMarkdownRenderer);
   const result = await applySchemaGeneration(loaded, cwd, config, {
@@ -20821,38 +20959,38 @@ async function runGenerateCommand(schemaName, options) {
     adminRoutePath,
     schemaRoutePath: getGeneratedSchemaRoutePath(loaded, adminRoutePath)
   });
-  p9.outro(`Generated ${loaded.schema.name}`);
+  p10.outro(`Generated ${loaded.schema.name}`);
 }
 
 // adapters/next/commands/schema-prompts.ts
-import * as p10 from "@clack/prompts";
-function isInteractiveSession3() {
+import * as p11 from "@clack/prompts";
+function isInteractiveSession4() {
   return Boolean(process.stdin.isTTY) && process.env.CI !== "true";
 }
 function fail(message) {
-  p10.log.error(message);
+  p11.log.error(message);
   process.exit(1);
 }
-function cancel2(context) {
-  p10.cancel(context.cancelMessage);
+function cancel3(context) {
+  p11.cancel(context.cancelMessage);
   process.exit(0);
 }
 function cancelIfNeeded(context, value) {
-  if (p10.isCancel(value)) {
-    cancel2(context);
+  if (p11.isCancel(value)) {
+    cancel3(context);
   }
   return value;
 }
 async function promptConfirm2(context, message, initialValue = true) {
-  const confirmed = await p10.confirm({ message, initialValue });
-  if (p10.isCancel(confirmed)) {
-    cancel2(context);
+  const confirmed = await p11.confirm({ message, initialValue });
+  if (p11.isCancel(confirmed)) {
+    cancel3(context);
   }
   return Boolean(confirmed);
 }
 async function promptText(context, message, optionsOrDefaultValue) {
   const options = typeof optionsOrDefaultValue === "string" ? { defaultValue: optionsOrDefaultValue } : optionsOrDefaultValue ?? {};
-  const value = await p10.text({
+  const value = await p11.text({
     message,
     defaultValue: options.defaultValue,
     placeholder: options.placeholder,
@@ -20869,7 +21007,7 @@ async function promptText(context, message, optionsOrDefaultValue) {
   return String(cancelIfNeeded(context, value)).trim();
 }
 async function promptOptionalText(context, message) {
-  const value = await p10.text({
+  const value = await p11.text({
     message,
     placeholder: "Leave blank to skip"
   });
@@ -20877,7 +21015,7 @@ async function promptOptionalText(context, message) {
   return result || void 0;
 }
 async function promptSelectValue(context, message, options, initialValue) {
-  const value = await p10.select({
+  const value = await p11.select({
     message,
     options,
     initialValue
@@ -21096,7 +21234,7 @@ async function shouldPromptRequired(type) {
   return !["group", "section", "tabs", "separator"].includes(type);
 }
 async function promptFormFileOptions(context) {
-  const selected = await p10.multiselect({
+  const selected = await p11.multiselect({
     message: "Field options",
     options: [
       { value: "required", label: "Required field?" },
@@ -21135,7 +21273,7 @@ async function promptFieldOptions(context, kind, type, creatable) {
     try {
       return parseInteractiveOptionsList(value);
     } catch (error) {
-      p10.log.error(error instanceof Error ? error.message : String(error));
+      p11.log.error(error instanceof Error ? error.message : String(error));
     }
   }
 }
@@ -21253,7 +21391,7 @@ async function promptChildFields(context, kind, schemasDir, scope, fields, depth
     const addChild = fields.length === 0 ? await promptConfirm2(context, "Add a child field?", true) : await promptConfirm2(context, "Add another child field?", false);
     if (!addChild) {
       if (fields.length === 0) {
-        p10.log.warn("Containers need at least one child field.");
+        p11.log.warn("Containers need at least one child field.");
         continue;
       }
       return;
@@ -21278,7 +21416,7 @@ async function promptTabsField(context, kind, schemasDir, scope, name, label, de
     const addTab = field.tabs.length === 0 ? await promptConfirm2(context, "Add a tab?", true) : await promptConfirm2(context, "Add another tab?", false);
     if (!addTab) {
       if (field.tabs.length === 0) {
-        p10.log.warn("Tabs need at least one tab.");
+        p11.log.warn("Tabs need at least one tab.");
         continue;
       }
       return field;
@@ -21303,7 +21441,7 @@ async function promptTabsField(context, kind, schemasDir, scope, name, label, de
         const addChild = mainFields.length + sidebarFields.length === 0 ? await promptConfirm2(context, "Add a tab child field?", true) : await promptConfirm2(context, "Add another tab child field?", false);
         if (!addChild) {
           if (mainFields.length + sidebarFields.length === 0) {
-            p10.log.warn("Tabs need at least one child field.");
+            p11.log.warn("Tabs need at least one child field.");
             continue;
           }
           break;
@@ -21374,7 +21512,7 @@ async function applyAdvancedOptions(context, field, kind, type, options) {
       if (Number.isInteger(parsed) && parsed > 0) {
         record.length = parsed;
       } else {
-        p10.log.warn("Skipped invalid length.");
+        p11.log.warn("Skipped invalid length.");
       }
     }
   }
@@ -21532,11 +21670,11 @@ function hasNonInteractiveFieldOptions(options) {
   );
 }
 function fail2(message) {
-  p11.log.error(message);
+  p12.log.error(message);
   process.exit(1);
 }
-function cancel4(message = "Add field cancelled.") {
-  p11.cancel(message);
+function cancel5(message = "Add field cancelled.") {
+  p12.cancel(message);
   process.exit(0);
 }
 function schemaNameFromLoaded(loaded) {
@@ -21641,7 +21779,7 @@ function printPreview(loaded, owner, firstTimeGeneration, insertion, options) {
   } else {
     lines.push("schema integration: none");
   }
-  p11.note(
+  p12.note(
     `${lines.join("\n")}
 
 ${stringifyProjectJson(insertion.field).trim()}`,
@@ -21674,10 +21812,10 @@ Re-run with --yes to confirm these warning cases.`);
     }
     return;
   }
-  p11.note(warnings.join("\n"), "Warnings");
+  p12.note(warnings.join("\n"), "Warnings");
   const confirmed = await promptConfirm3("Continue with these warnings?", true);
   if (!confirmed) {
-    cancel4();
+    cancel5();
   }
 }
 function collectRelationshipTargetWarnings(cwd, owner, field) {
@@ -21719,7 +21857,7 @@ async function resolveSchemaNameInteractively(schemasDir, schemaName) {
   if (schemaName) {
     return schemaName;
   }
-  if (!isInteractiveSession3()) {
+  if (!isInteractiveSession4()) {
     fail2("Schema name is required in non-interactive sessions.");
   }
   const schemaNames = listSchemaNames(schemasDir);
@@ -21747,7 +21885,7 @@ async function runAddFieldCommand(schemaName, options) {
   } catch (error) {
     fail2(error instanceof Error ? error.message : String(error));
   }
-  if (!nonInteractive && !isInteractiveSession3()) {
+  if (!nonInteractive && !isInteractiveSession4()) {
     fail2("Interactive add-field requires a TTY. Provide --type, --field, and --label instead.");
   }
   const owner = resolveSchemaOwner(cwd, schemaNameFromLoaded(loaded));
@@ -21787,11 +21925,11 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
   if (!nonInteractive && !options.yes) {
     const confirmed = await promptConfirm3("Write schema JSON and regenerate this schema?", true);
     if (!confirmed) {
-      cancel4();
+      cancel5();
     }
   }
   writeAuthoredGeneratedSchema(loaded);
-  p11.log.success(`Updated ${path30.relative(cwd, loaded.filePath)}`);
+  p12.log.success(`Updated ${path30.relative(cwd, loaded.filePath)}`);
   try {
     await runGenerateCommand(selectedSchemaName, {
       force: false,
@@ -21802,8 +21940,8 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
       cwd
     });
   } catch (error) {
-    p11.log.error(error instanceof Error ? error.message : String(error));
-    p11.log.info(
+    p12.log.error(error instanceof Error ? error.message : String(error));
+    p12.log.info(
       `Schema JSON was kept. Re-run \`betterstart generate ${selectedSchemaName}${options.skipMigration ? " --skip-migration" : ""}\` after resolving the issue.`
     );
     process.exit(1);
@@ -21813,7 +21951,7 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
 // adapters/next/commands/create.ts
 import fs25 from "fs";
 import path31 from "path";
-import * as p12 from "@clack/prompts";
+import * as p13 from "@clack/prompts";
 var CREATE_PROMPT_CONTEXT = {
   cancelMessage: "Create schema cancelled."
 };
@@ -22004,7 +22142,7 @@ async function promptTabSlotFields(kind, schemasDir, titleField) {
     );
     if (!addField) {
       if (!hasFields) {
-        p12.log.warn("Tabs need at least one child field.");
+        p13.log.warn("Tabs need at least one child field.");
         continue;
       }
       return { main, sidebar };
@@ -22052,7 +22190,7 @@ async function promptSchemaTab(kind, schemasDir, titleField, existingTabs) {
       while (fields.length === 0) {
         await promptAdditionalSchemaFields(kind, schemasDir, fields);
         if (fields.length === 0) {
-          p12.log.warn("Tabs need at least one child field.");
+          p13.log.warn("Tabs need at least one child field.");
         }
       }
     }
@@ -22142,7 +22280,7 @@ async function promptFormSubmissionColumns(schema) {
   }
   const existingColumnNames = schema.columns ? new Set(schema.columns.map((column) => column.accessorKey)) : void 0;
   const initialValues = existingColumnNames ? fields.filter((field) => existingColumnNames.has(field.name)).map((field) => field.name) : fields.map((field) => field.name);
-  const selected = await p12.multiselect({
+  const selected = await p13.multiselect({
     message: "Submission table columns",
     options: fields.map((field) => ({
       value: field.name,
@@ -22151,8 +22289,8 @@ async function promptFormSubmissionColumns(schema) {
     initialValues,
     required: false
   });
-  if (p12.isCancel(selected)) {
-    cancel2(CREATE_PROMPT_CONTEXT);
+  if (p13.isCancel(selected)) {
+    cancel3(CREATE_PROMPT_CONTEXT);
   }
   const selectedNames = new Set(selected);
   schema.columns = fields.filter((field) => selectedNames.has(field.name)).map((field) => {
@@ -22211,7 +22349,7 @@ function schemaFilePath(kind, schemasDir, schemaName) {
   return kind === "form" ? path31.join(schemasDir, "forms", `${schemaName}.json`) : path31.join(schemasDir, `${schemaName}.json`);
 }
 function printPreview2(loaded, cwd) {
-  p12.note(
+  p13.note(
     `schema: ${loaded.name} (${loaded.kind})
 path: ${path31.relative(cwd, loaded.filePath)}
 owner: user
@@ -22226,7 +22364,7 @@ async function runCreateCommand(kindInput, schemaName, options) {
   if (!snapshotRootExists(cwd)) {
     fail(UNSUPPORTED_PROJECT_STATE_MESSAGE);
   }
-  if (!isInteractiveSession3()) {
+  if (!isInteractiveSession4()) {
     fail("Interactive create requires a TTY.");
   }
   const config = await resolveConfigOrExit(cwd);
@@ -22258,13 +22396,13 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
       break;
     }
     if (action === "cancel") {
-      cancel2(CREATE_PROMPT_CONTEXT);
+      cancel3(CREATE_PROMPT_CONTEXT);
     }
     await promptAdditionalCreateField(kind, schemasDir, schema);
   }
   fs25.mkdirSync(path31.dirname(filePath), { recursive: true });
   writeAuthoredGeneratedSchema(loaded);
-  p12.log.success(`Created ${path31.relative(cwd, filePath)}`);
+  p13.log.success(`Created ${path31.relative(cwd, filePath)}`);
   try {
     await runGenerateCommand(metadata.name, {
       force: false,
@@ -22275,8 +22413,8 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
       cwd
     });
   } catch (error) {
-    p12.log.error(error instanceof Error ? error.message : String(error));
-    p12.log.info(
+    p13.log.error(error instanceof Error ? error.message : String(error));
+    p13.log.info(
       `Schema JSON was kept. Re-run \`betterstart generate ${metadata.name}${options.skipMigration ? " --skip-migration" : ""}\` after resolving the issue.`
     );
     process.exit(1);
@@ -22284,18 +22422,18 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
 }
 
 // adapters/next/commands/init.ts
-import { execFileSync as execFileSync5, spawn as spawn6 } from "child_process";
+import { execFileSync as execFileSync4, spawn as spawn6 } from "child_process";
 import fs41 from "fs";
 import path52 from "path";
 import { PassThrough } from "stream";
-import * as p25 from "@clack/prompts";
+import * as p26 from "@clack/prompts";
 
 // core-engine/utils/cancel-guard.ts
-import * as p13 from "@clack/prompts";
+import * as p14 from "@clack/prompts";
 function installSetupCancelGuard() {
   const onSignal = () => {
     if (!hasActiveSpinner()) {
-      p13.cancel("Setup cancelled.");
+      p14.cancel("Setup cancelled.");
     }
     process.exit(0);
   };
@@ -22349,12 +22487,12 @@ function redactSecrets(text7) {
 }
 
 // adapters/next/init/prompts/database.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import * as p14 from "@clack/prompts";
+import { execFileSync as execFileSync3 } from "child_process";
+import * as p15 from "@clack/prompts";
 import pc from "picocolors";
 var VERCEL_NEON_URL = "https://vercel.com/dashboard/integrations/checkout/neon";
 async function promptServices() {
-  const choice = await p14.select({
+  const choice = await p15.select({
     message: "Connect a PostgreSQL Database",
     options: [
       {
@@ -22375,8 +22513,8 @@ async function promptServices() {
     ],
     initialValue: "vercel"
   });
-  if (p14.isCancel(choice)) {
-    p14.cancel("Setup cancelled.");
+  if (p15.isCancel(choice)) {
+    p15.cancel("Setup cancelled.");
     process.exit(0);
   }
   if (choice === "vercel") {
@@ -22390,7 +22528,7 @@ async function promptServices() {
 }
 function openBrowserVercelNeon() {
   openBrowser(VERCEL_NEON_URL);
-  p14.log.info(
+  p15.log.info(
     `Opening Vercel... Create a Neon Postgres database, then copy the ${pc.cyan("DATABASE_URL")} from the dashboard.`
   );
 }
@@ -22400,12 +22538,12 @@ function openBrowserVercelNeonResource(url) {
     return;
   }
   openBrowser(url);
-  p14.log.info(
+  p15.log.info(
     `Opening Vercel... Copy the Neon ${pc.cyan("DATABASE_URL")} from the database dashboard, then paste it below.`
   );
 }
 async function promptConnectionString() {
-  const input = await p14.text({
+  const input = await p15.text({
     message: "Paste your PostgreSQL connection string",
     placeholder: "postgres://user:pass@host/db",
     validate(val) {
@@ -22419,8 +22557,8 @@ async function promptConnectionString() {
       }
     }
   });
-  if (p14.isCancel(input)) {
-    p14.cancel("Setup cancelled.");
+  if (p15.isCancel(input)) {
+    p15.cancel("Setup cancelled.");
     process.exit(0);
   }
   return input.replace(/^['"]|['"]$/g, "").trim();
@@ -22429,18 +22567,18 @@ function openBrowser(url) {
   try {
     const platform = process.platform;
     if (platform === "darwin") {
-      execFileSync4("open", [url], { stdio: "ignore" });
+      execFileSync3("open", [url], { stdio: "ignore" });
     } else if (platform === "win32") {
-      execFileSync4("cmd", ["/c", "start", url], { stdio: "ignore" });
+      execFileSync3("cmd", ["/c", "start", url], { stdio: "ignore" });
     } else {
-      execFileSync4("xdg-open", [url], { stdio: "ignore" });
+      execFileSync3("xdg-open", [url], { stdio: "ignore" });
     }
   } catch {
   }
 }
 
 // adapters/next/init/prompts/presets.ts
-import * as p15 from "@clack/prompts";
+import * as p16 from "@clack/prompts";
 
 // adapters/next/init/scaffolders/env.ts
 import crypto2 from "crypto";
@@ -22605,7 +22743,7 @@ async function promptPresets(cwd, options = {}) {
       overwriteKeys.add(key);
     }
   };
-  const storage = await p15.select({
+  const storage = await p16.select({
     message: "Choose a file storage",
     options: [
       {
@@ -22629,8 +22767,8 @@ async function promptPresets(cwd, options = {}) {
     ],
     initialValue: "vercel-blob"
   });
-  if (p15.isCancel(storage)) {
-    p15.cancel("Setup cancelled.");
+  if (p16.isCancel(storage)) {
+    p16.cancel("Setup cancelled.");
     process.exit(0);
   }
   if (storage === "r2") {
@@ -22640,7 +22778,7 @@ async function promptPresets(cwd, options = {}) {
     if (flow?.ok && flow.config) {
       mergeIntegrationConfig(flow.config);
     } else if (flow) {
-      p15.log.warn(
+      p16.log.warn(
         "Continuing without Railway bucket credentials \u2014 rerun betterstart add --integration railway-bucket after fixing Railway access."
       );
     } else {
@@ -22657,7 +22795,7 @@ async function promptPresets(cwd, options = {}) {
       });
       overwriteKeys.add("BLOB_READ_WRITE_TOKEN");
     } else if (flow) {
-      p15.log.warn(
+      p16.log.warn(
         "Continuing without a Blob token \u2014 add BLOB_READ_WRITE_TOKEN to .env.local from the store on vercel.com/dashboard/stores."
       );
       sections.push({
@@ -22666,7 +22804,7 @@ async function promptPresets(cwd, options = {}) {
       });
     } else {
       if (existingToken) {
-        p15.log.info(
+        p16.log.info(
           `Using the existing BLOB_READ_WRITE_TOKEN from .env.local ${pc2.dim(
             `(${maskBlobToken(existingToken)})`
           )}`
@@ -22675,7 +22813,7 @@ async function promptPresets(cwd, options = {}) {
       mergeIntegrationConfig(await collectIntegrationConfig(cwd, ["vercel-blob"]));
     }
   }
-  const selectedPresets = await p15.multiselect({
+  const selectedPresets = await p16.multiselect({
     message: "Select presets",
     options: [
       {
@@ -22687,8 +22825,8 @@ async function promptPresets(cwd, options = {}) {
     required: false,
     initialValues: ["blog"]
   });
-  if (p15.isCancel(selectedPresets)) {
-    p15.cancel("Setup cancelled.");
+  if (p16.isCancel(selectedPresets)) {
+    p16.cancel("Setup cancelled.");
     process.exit(0);
   }
   const integrations = [];
@@ -22715,9 +22853,9 @@ async function promptPresets(cwd, options = {}) {
 }
 
 // adapters/next/init/prompts/project.ts
-import * as p16 from "@clack/prompts";
+import * as p17 from "@clack/prompts";
 async function promptProject(defaultName) {
-  const projectName = await p16.text({
+  const projectName = await p17.text({
     message: "What is your project named?",
     placeholder: defaultName ?? "(Press Enter to use default)",
     defaultValue: defaultName ?? ".",
@@ -22730,15 +22868,15 @@ async function promptProject(defaultName) {
       return void 0;
     }
   });
-  if (p16.isCancel(projectName)) {
-    p16.cancel("Setup cancelled.");
+  if (p17.isCancel(projectName)) {
+    p17.cancel("Setup cancelled.");
     process.exit(0);
   }
   return { projectName: projectName.trim() || "." };
 }
 
 // adapters/next/init/providers.ts
-import * as p17 from "@clack/prompts";
+import * as p18 from "@clack/prompts";
 var DATABASE_PROVIDERS = ["vercel", "railway", "manual"];
 var STORAGE_PROVIDERS = ["vercel-blob", "railway-bucket", "r2", "local"];
 var DEPLOY_PROVIDERS = ["vercel", "railway", "none"];
@@ -22795,7 +22933,7 @@ function validateResolvedDatabaseProvider(provider, options) {
   }
 }
 async function promptDeployProvider(initialValue = "none") {
-  const provider = await p17.select({
+  const provider = await p18.select({
     message: "Deploy this project",
     options: [
       {
@@ -22813,8 +22951,8 @@ async function promptDeployProvider(initialValue = "none") {
     ],
     initialValue
   });
-  if (p17.isCancel(provider)) {
-    p17.cancel("Setup cancelled.");
+  if (p18.isCancel(provider)) {
+    p18.cancel("Setup cancelled.");
     process.exit(0);
   }
   return provider;
@@ -22823,7 +22961,7 @@ async function promptDeployProvider(initialValue = "none") {
 // adapters/next/init/railway/deploy.ts
 import fs28 from "fs";
 import path34 from "path";
-import * as p19 from "@clack/prompts";
+import * as p20 from "@clack/prompts";
 
 // adapters/next/init/deploy/guard.ts
 import { spawn as spawn3 } from "child_process";
@@ -22920,7 +23058,7 @@ function guardBetterstartConfig(cwd, restores) {
 }
 
 // adapters/next/init/railway/project.ts
-import * as p18 from "@clack/prompts";
+import * as p19 from "@clack/prompts";
 
 // adapters/next/init/railway/runner.ts
 import { spawn as spawn4 } from "child_process";
@@ -23204,15 +23342,15 @@ async function ensureRailwayProject(runner, options) {
         createWorkspace = options.workspaces[0]?.id;
       } else if (!createWorkspace && options.interactive && options.workspaces?.length) {
         projectSpinner.clear();
-        const workspace = await p18.select({
+        const workspace = await p19.select({
           message: "Choose a Railway workspace",
           options: options.workspaces.map((candidate) => ({
             value: candidate.id,
             label: candidate.name
           }))
         });
-        if (p18.isCancel(workspace)) {
-          p18.cancel("Setup cancelled.");
+        if (p19.isCancel(workspace)) {
+          p19.cancel("Setup cancelled.");
           process.exit(0);
         }
         createWorkspace = workspace;
@@ -23738,7 +23876,7 @@ async function runRailwayDeployFlow(options) {
     );
     envSpinner.clear();
     for (const key of sync.failed) {
-      p19.log.warn(`Could not set ${pc4.cyan(key)} on Railway.`);
+      p20.log.warn(`Could not set ${pc4.cyan(key)} on Railway.`);
     }
     if (sync.failed.length > 0) {
       return {
@@ -23753,12 +23891,12 @@ async function runRailwayDeployFlow(options) {
     const packageGuard = await guardProjectForDeploy(options.cwd);
     guardSpinner.clear();
     if (packageGuard.lockfile === "failed") {
-      p19.log.warn(
+      p20.log.warn(
         "Could not refresh pnpm-lock.yaml after removing betterstart-cli \u2014 the remote install may fail."
       );
     }
     for (const dependency of packageGuard.localSpecDeps) {
-      p19.log.warn(
+      p20.log.warn(
         `Dependency ${pc4.cyan(dependency)} uses a local spec that cannot install on Railway.`
       );
     }
@@ -23811,7 +23949,7 @@ ${deploy.stderr}`) ?? deploy.errorMessage
 }
 
 // adapters/next/init/railway/auth.ts
-import * as p20 from "@clack/prompts";
+import * as p21 from "@clack/prompts";
 import pc5 from "picocolors";
 var WHOAMI_TIMEOUT_MS = 3e4;
 var LOGIN_TIMEOUT_MS = 3e5;
@@ -23881,7 +24019,7 @@ async function ensureRailwayAuth(runner, cwd, options) {
     return { authed: false, reason: existing.reason };
   }
   checkSpinner.clear();
-  p20.log.info(
+  p21.log.info(
     "Sign in to Railway to continue. Railway will open your browser or show a device code."
   );
   const login = await runRailway(runner, ["login"], {
@@ -25768,11 +25906,11 @@ function scaffoldTsconfig(cwd, config) {
 }
 
 // adapters/next/init/vercel/flow.ts
-import * as p24 from "@clack/prompts";
+import * as p25 from "@clack/prompts";
 import pc9 from "picocolors";
 
 // adapters/next/init/vercel/auth.ts
-import * as p21 from "@clack/prompts";
+import * as p22 from "@clack/prompts";
 import pc6 from "picocolors";
 
 // adapters/next/init/vercel/runner.ts
@@ -26016,7 +26154,7 @@ async function ensureVercelAuth(runner, cwd, options) {
   checkSpinner.clear();
   const signInMessage = `Sign in to Vercel to continue ${pc6.dim("(or press Ctrl-C to enter a connection string manually)")}`;
   const signInRows = clackLogRows(signInMessage);
-  p21.log.info(signInMessage);
+  p22.log.info(signInMessage);
   let streamedRows = 0;
   const login = await runVercel(runner, ["login"], {
     cwd,
@@ -26048,7 +26186,7 @@ function signedInMessage(username) {
 }
 
 // adapters/next/init/vercel/blob.ts
-import * as p22 from "@clack/prompts";
+import * as p23 from "@clack/prompts";
 import pc7 from "picocolors";
 
 // adapters/next/init/vercel/env-pull.ts
@@ -26290,7 +26428,7 @@ async function provisionBlobStoreInteractive(runner, cwd, options) {
     if (terminalFallbackRan) break;
     terminalFallbackRan = true;
     quietSpinner.clear();
-    p22.log.info(
+    p23.log.info(
       `Create your Blob store in the Vercel prompts below ${pc7.dim(
         "(connect it to all environments)."
       )}`
@@ -26489,7 +26627,7 @@ function guardEnvLocal(cwd) {
 }
 
 // adapters/next/init/vercel/neon.ts
-import * as p23 from "@clack/prompts";
+import * as p24 from "@clack/prompts";
 import pc8 from "picocolors";
 var PROVISION_TIMEOUT_MS2 = 18e4;
 var INTERACTIVE_PROVISION_TIMEOUT_MS2 = 6e5;
@@ -26508,7 +26646,7 @@ async function provisionNeonInteractive(runner, cwd, options) {
     termsResolved = true;
     quietSpinner.clear();
     eraseRows(termsNotice.rows);
-    p23.log.step(termsNotice.text);
+    p24.log.step(termsNotice.text);
   };
   const quiet = await runVercel(runner, neonAddArgs(options), {
     cwd,
@@ -26527,7 +26665,7 @@ ${pc8.dim(termsUrl)}`,
           rows: clackLogRows(message) + clackLogRows(termsUrl) - 1
         };
         quietSpinner.clear();
-        p23.log.info(termsNotice.text);
+        p24.log.info(termsNotice.text);
         quietSpinner.start("Waiting for the terms to be accepted");
         return;
       }
@@ -26543,7 +26681,7 @@ ${pc8.dim(termsUrl)}`,
     return readNeonProvisionInfo(quiet.stdout);
   }
   quietSpinner.clear();
-  p23.log.info(
+  p24.log.info(
     `Create your Neon database in the Vercel prompts below ${pc8.dim(
       "(the Free plan is recommended)."
     )}`
@@ -26620,14 +26758,14 @@ async function runVercelNeonFlow(options) {
       allowLogin: options.interactive
     });
     if (!auth.authed) {
-      p24.log.warn(authFailureMessage(auth.reason));
+      p25.log.warn(authFailureMessage(auth.reason));
       return { ok: false };
     }
     await ensureLinkedProject(runner, options.cwd, options.projectName, env, auth.username);
     const neon = await provisionNeonForMode(runner, options);
     if (neon.failure) {
-      p24.log.warn(neonFailureMessage(neon.failure));
-      if (neon.detail) p24.log.message(pc9.dim(redactSecrets(neon.detail)));
+      p25.log.warn(neonFailureMessage(neon.failure));
+      if (neon.detail) p25.log.message(pc9.dim(redactSecrets(neon.detail)));
       return { ok: false };
     }
     const databaseUrl = await pullNeonDatabaseUrl(runner, options.cwd, env);
@@ -26640,7 +26778,7 @@ async function runVercelNeonFlow(options) {
       dismissSignedInNote
     };
   } catch (error) {
-    p24.log.warn(
+    p25.log.warn(
       `Vercel provisioning failed: ${error instanceof Error ? error.message : String(error)}`
     );
     return { ok: false };
@@ -26662,14 +26800,14 @@ async function runVercelBlobFlow(options) {
       allowLogin: options.interactive
     });
     if (!auth.authed) {
-      p24.log.warn(authFailureMessage(auth.reason));
+      p25.log.warn(authFailureMessage(auth.reason));
       return { ok: false };
     }
     await ensureLinkedProject(runner, options.cwd, options.projectName, env, auth.username);
     const blob = await provisionBlobForMode(runner, options);
     if (blob.failure || !blob.token) {
-      p24.log.warn(blobFailureMessage(blob.failure));
-      if (blob.detail) p24.log.message(pc9.dim(redactSecrets(blob.detail)));
+      p25.log.warn(blobFailureMessage(blob.failure));
+      if (blob.detail) p25.log.message(pc9.dim(redactSecrets(blob.detail)));
       return { ok: false };
     }
     return {
@@ -26678,7 +26816,7 @@ async function runVercelBlobFlow(options) {
       blobStoreName: blob.storeName
     };
   } catch (error) {
-    p24.log.warn(
+    p25.log.warn(
       `Vercel provisioning failed: ${error instanceof Error ? error.message : String(error)}`
     );
     return { ok: false };
@@ -26700,7 +26838,7 @@ async function runVercelDeployFlow(options) {
       allowLogin: options.interactive ?? true
     });
     if (!auth.authed) {
-      p24.log.warn(authFailureMessage(auth.reason));
+      p25.log.warn(authFailureMessage(auth.reason));
       printManualDeployHint();
       return { ok: false };
     }
@@ -26710,7 +26848,7 @@ async function runVercelDeployFlow(options) {
     const sync = await syncVercelProductionEnv(runner, options.cwd, env);
     envSpinner.clear();
     for (const key of sync.failed) {
-      p24.log.warn(
+      p25.log.warn(
         `Could not set ${pc9.cyan(key)} on Vercel \u2014 add it in the project's environment settings.`
       );
     }
@@ -26720,12 +26858,12 @@ async function runVercelDeployFlow(options) {
     const packageGuard = await guardProjectForDeploy(options.cwd);
     guardSpinner.clear();
     if (packageGuard.lockfile === "failed") {
-      p24.log.warn(
+      p25.log.warn(
         "Could not refresh pnpm-lock.yaml after removing betterstart-cli \u2014 the remote install may fail."
       );
     }
     for (const dep of packageGuard.localSpecDeps) {
-      p24.log.warn(
+      p25.log.warn(
         `Dependency ${pc9.cyan(dep)} uses a local spec that cannot install on Vercel \u2014 the remote build may fail.`
       );
     }
@@ -26742,7 +26880,7 @@ async function runVercelDeployFlow(options) {
     }
     if (deploy.failure) {
       deploySpinner.stop(`${pc9.yellow("\u25B2")} ${deployFailureMessage(deploy.failure)}`);
-      if (deploy.detail) p24.log.message(pc9.dim(redactSecrets(deploy.detail)));
+      if (deploy.detail) p25.log.message(pc9.dim(redactSecrets(deploy.detail)));
       printManualDeployHint();
       return { ok: false };
     }
@@ -26750,7 +26888,7 @@ async function runVercelDeployFlow(options) {
     deploySpinner.stop(url ? `Deployed ${pc9.cyan(url)}` : "Deployed to Vercel");
     return { ok: true, url, syncedEnvKeys: sync.synced };
   } catch (error) {
-    p24.log.warn(`Vercel deploy failed: ${error instanceof Error ? error.message : String(error)}`);
+    p25.log.warn(`Vercel deploy failed: ${error instanceof Error ? error.message : String(error)}`);
     printManualDeployHint();
     return { ok: false };
   } finally {
@@ -26758,7 +26896,7 @@ async function runVercelDeployFlow(options) {
   }
 }
 function printManualDeployHint() {
-  p24.log.info(`You can deploy manually: ${pc9.cyan("vercel deploy --prod")}`);
+  p25.log.info(`You can deploy manually: ${pc9.cyan("vercel deploy --prod")}`);
 }
 async function ensureLinkedProject(runner, cwd, projectName, env, scope) {
   if (readLinkedProjectId(cwd)) return;
@@ -26841,13 +26979,6 @@ import pc10 from "picocolors";
 import fs40 from "fs";
 import path51 from "path";
 import * as clack2 from "@clack/prompts";
-
-// core-engine/utils/interactive.ts
-function isInteractiveSession4() {
-  return Boolean(process.stdin.isTTY) && process.env.CI !== "true";
-}
-
-// adapters/next/commands/seed.ts
 function buildSeedScript(authBasePath = "/api/admin/auth") {
   return `/**
  * BetterStart Admin \u2014 Seed Script
@@ -27029,7 +27160,7 @@ async function runSeedCommand(options) {
     process.exit(1);
   }
   const adminDir = config.paths?.admin ?? "./admin";
-  const interactive = isInteractiveSession4();
+  const interactive = isInteractiveSession();
   let email;
   if (options.email) {
     if (!options.email.includes("@")) {
@@ -27102,10 +27233,10 @@ async function runSeedCommand(options) {
   }
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
   fs40.writeFileSync(seedPath, buildSeedScript(`${namespace.apiPath}/auth`), "utf-8");
-  const { execFile } = await import("child_process");
+  const { execFile: execFile2 } = await import("child_process");
   const tsxBin = path51.join(cwd, "node_modules", ".bin", "tsx");
   const runSeed2 = (overwrite) => new Promise((resolve, reject) => {
-    execFile(
+    execFile2(
       tsxBin,
       [seedPath],
       {
@@ -27194,16 +27325,16 @@ function addVersionToBoxBottomBorder(box2, version2) {
   if (!bottomLine) {
     return box2;
   }
-  const leftCornerIndex = bottomLine.indexOf(p25.S_CORNER_BOTTOM_LEFT);
-  const rightCornerIndex = bottomLine.lastIndexOf(p25.S_CORNER_BOTTOM_RIGHT);
+  const leftCornerIndex = bottomLine.indexOf(p26.S_CORNER_BOTTOM_LEFT);
+  const rightCornerIndex = bottomLine.lastIndexOf(p26.S_CORNER_BOTTOM_RIGHT);
   const label = ` v${version2} `;
-  const borderWidth = rightCornerIndex - leftCornerIndex - p25.S_CORNER_BOTTOM_LEFT.length;
+  const borderWidth = rightCornerIndex - leftCornerIndex - p26.S_CORNER_BOTTOM_LEFT.length;
   if (leftCornerIndex === -1 || rightCornerIndex === -1 || borderWidth < label.length) {
     return box2;
   }
   const leftBorderWidth = Math.floor((borderWidth - label.length) / 2);
   const rightBorderWidth = borderWidth - label.length - leftBorderWidth;
-  lines[bottomLineIndex] = `${bottomLine.slice(0, leftCornerIndex + p25.S_CORNER_BOTTOM_LEFT.length)}${p25.S_BAR_H.repeat(leftBorderWidth)}${label}${p25.S_BAR_H.repeat(rightBorderWidth)}${bottomLine.slice(rightCornerIndex)}`;
+  lines[bottomLineIndex] = `${bottomLine.slice(0, leftCornerIndex + p26.S_CORNER_BOTTOM_LEFT.length)}${p26.S_BAR_H.repeat(leftBorderWidth)}${label}${p26.S_BAR_H.repeat(rightBorderWidth)}${bottomLine.slice(rightCornerIndex)}`;
   return lines.join("\n");
 }
 function renderInitBanner() {
@@ -27213,7 +27344,7 @@ function renderInitBanner() {
   output.on("data", (chunk) => {
     box2 += chunk.toString();
   });
-  p25.box(
+  p26.box(
     `
 \u2584   \u2597 \u2597     \u2584\u2596\u2597     \u2597
 \u2599\u2598\u2588\u258C\u259C\u2598\u259C\u2598\u2588\u258C\u259B\u2598\u259A \u259C\u2598\u2580\u258C\u259B\u2598\u259C\u2598
@@ -27309,7 +27440,7 @@ async function runInitCommand(name, options) {
   let restoreStdout;
   if (options.json) {
     if (!options.yes) {
-      p25.log.error("--json requires --yes.");
+      p26.log.error("--json requires --yes.");
       process.exit(1);
     }
     restoreStdout = redirectStdoutToStderr();
@@ -27330,7 +27461,7 @@ async function runInitCommand(name, options) {
     }
   } catch (error) {
     disposeCancelGuard();
-    p25.log.error(error instanceof Error ? error.message : String(error));
+    p26.log.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
   let cwd = process.cwd();
@@ -27341,7 +27472,7 @@ async function runInitCommand(name, options) {
     try {
       namespace = validateAdminNamespace(options.namespace);
     } catch (error) {
-      p25.log.error(error instanceof Error ? error.message : String(error));
+      p26.log.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
   }
@@ -27350,13 +27481,13 @@ async function runInitCommand(name, options) {
     try {
       projectPrompt = options.yes ? resolveNonInteractiveProject(name) : await promptProject(name);
     } catch (error) {
-      p25.log.error(error instanceof Error ? error.message : String(error));
+      p26.log.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
   }
   if (!options.yes && !options.namespace) {
     const defaultDashboardPath = resolveAdminNamespace(DEFAULT_ADMIN_NAMESPACE).routePath;
-    const namespaceInput = await p25.text({
+    const namespaceInput = await p26.text({
       message: "Enter the dashboard path",
       placeholder: `eg. ${defaultDashboardPath}`,
       defaultValue: defaultDashboardPath,
@@ -27369,8 +27500,8 @@ async function runInitCommand(name, options) {
         }
       }
     });
-    if (p25.isCancel(namespaceInput)) {
-      p25.cancel("Setup cancelled.");
+    if (p26.isCancel(namespaceInput)) {
+      p26.cancel("Setup cancelled.");
       process.exit(0);
     }
     namespace = validateAdminDashboardPath(namespaceInput);
@@ -27382,13 +27513,13 @@ async function runInitCommand(name, options) {
   if (project2.isExisting) {
     srcDir = project2.hasSrcDir;
     if (!project2.hasTypeScript) {
-      p25.log.error("TypeScript is required. Please add a tsconfig.json first.");
+      p26.log.error("TypeScript is required. Please add a tsconfig.json first.");
       process.exit(1);
     }
     if (forceMode) {
       const nuked = removeExistingAdminPaths(cwd, await resolveForceInitNamespaces(cwd, namespace));
       if (nuked > 0) {
-        p25.log.warn(`${pc10.yellow("Force mode:")} removed ${nuked} existing admin paths`);
+        p26.log.warn(`${pc10.yellow("Force mode:")} removed ${nuked} existing admin paths`);
       }
       project2 = detectProject(cwd, namespace);
     } else if (project2.conflicts.length > 0) {
@@ -27397,14 +27528,14 @@ async function runInitCommand(name, options) {
         "",
         pc10.dim(`Use ${pc10.bold("--force")} to remove existing admin files before scaffolding.`)
       );
-      p25.note(conflictLines.join("\n"), pc10.yellow("Conflicts"));
+      p26.note(conflictLines.join("\n"), pc10.yellow("Conflicts"));
       if (options.yes) {
-        p25.log.error(
+        p26.log.error(
           "Can't continue with --yes while admin files conflict. Re-run with --force to remove them first."
         );
         process.exit(1);
       }
-      const proceed = await p25.confirm({
+      const proceed = await p26.confirm({
         message: [
           `Continue with ${pc10.bold(pc10.cyan("--force"))}?`,
           `${pc10.cyan("\u2502")}  ${pc10.dim("This will force overwrite the existing admin code.")}`,
@@ -27412,14 +27543,14 @@ async function runInitCommand(name, options) {
         ].join("\n"),
         initialValue: true
       });
-      if (p25.isCancel(proceed) || !proceed) {
-        p25.cancel("Setup cancelled.");
+      if (p26.isCancel(proceed) || !proceed) {
+        p26.cancel("Setup cancelled.");
         process.exit(0);
       }
       forceMode = true;
       const nuked = removeExistingAdminPaths(cwd, await resolveForceInitNamespaces(cwd, namespace));
       if (nuked > 0) {
-        p25.log.warn(`${pc10.yellow("Force mode:")} removed ${nuked} existing admin paths`);
+        p26.log.warn(`${pc10.yellow("Force mode:")} removed ${nuked} existing admin paths`);
       }
       project2 = detectProject(cwd, namespace);
     }
@@ -27427,7 +27558,7 @@ async function runInitCommand(name, options) {
     const freshProject = projectPrompt;
     srcDir = false;
     if (!options.yes) {
-      const pmChoice = await p25.select({
+      const pmChoice = await p26.select({
         message: "Which package manager do you want to use?",
         options: [
           { value: "pnpm", label: "pnpm", hint: "recommended" },
@@ -27435,8 +27566,8 @@ async function runInitCommand(name, options) {
           { value: "bun", label: "bun" }
         ]
       });
-      if (p25.isCancel(pmChoice)) {
-        p25.cancel("Setup cancelled.");
+      if (p26.isCancel(pmChoice)) {
+        p26.cancel("Setup cancelled.");
         process.exit(0);
       }
       pm = pmChoice;
@@ -27471,8 +27602,8 @@ async function runInitCommand(name, options) {
         process.stderr.write(`${createNextAppResult.output.trimEnd()}
 `);
       }
-      p25.log.error(createNextAppResult.error);
-      p25.log.info(
+      p26.log.error(createNextAppResult.error);
+      p26.log.info(
         `You can create the project manually:
   ${pc10.cyan(`npx create-next-app@latest ${freshProject.projectName} --typescript --tailwind --app`)}
   Then run ${pc10.cyan("betterstart init")} inside it.`
@@ -27486,11 +27617,11 @@ async function runInitCommand(name, options) {
     );
     if (!hasPackageJson || !hasNextConfig) {
       createNextAppSpinner.stop(`Failed to create Next.js app: ${displayName}`);
-      p25.log.error(
+      p26.log.error(
         "create-next-app completed but the project was not created. This can happen with nested npx calls."
       );
       const manualCmd = `npx create-next-app@latest ${freshProject.projectName} --typescript --tailwind --app`;
-      p25.log.info(
+      p26.log.info(
         `Create the project manually:
   ${pc10.cyan(manualCmd)}
   Then run ${pc10.cyan("betterstart init")} inside it.`
@@ -27539,13 +27670,13 @@ async function runInitCommand(name, options) {
   try {
     validateResolvedDatabaseProvider(databaseProvider, options);
   } catch (error) {
-    p25.log.error(error instanceof Error ? error.message : String(error));
+    p26.log.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
   if (databaseProvider === "manual") {
     const candidate = options.databaseUrl ?? existingDbUrl ?? promptedManualUrl;
     if (candidate && !isValidDbUrl(candidate)) {
-      p25.log.error(
+      p26.log.error(
         `Invalid database URL. Must start with ${pc10.cyan("postgres://")} or ${pc10.cyan("postgresql://")}`
       );
       process.exit(1);
@@ -27553,7 +27684,7 @@ async function runInitCommand(name, options) {
     if (candidate) {
       databaseUrl = candidate;
       if (existingDbUrl === candidate && !options.databaseUrl) {
-        p25.log.info(
+        p26.log.info(
           `Using the existing DATABASE_URL from .env.local ${pc10.dim(`(${maskDbUrl(candidate)})`)}`
         );
       }
@@ -27573,7 +27704,7 @@ async function runInitCommand(name, options) {
       persistDatabaseUrl(cwd, databaseUrl);
       dismissVercelSignedInNote = flow.dismissSignedInNote;
     } else if (options.yes) {
-      p25.log.error(
+      p26.log.error(
         flow.ok ? "Created a Neon database, but DATABASE_URL could not be retrieved from Vercel." : "Vercel database provisioning did not complete."
       );
       process.exit(1);
@@ -27582,7 +27713,7 @@ async function runInitCommand(name, options) {
       databaseUrl = await promptConnectionString();
       persistDatabaseUrl(cwd, databaseUrl);
     } else {
-      p25.log.info("Falling back to a manual database connection string.");
+      p26.log.info("Falling back to a manual database connection string.");
       openBrowserVercelNeon();
       databaseUrl = await promptConnectionString();
     }
@@ -27596,11 +27727,11 @@ async function runInitCommand(name, options) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (options.yes) {
-        p25.log.error(`Railway database provisioning failed: ${message}`);
+        p26.log.error(`Railway database provisioning failed: ${message}`);
         process.exit(1);
       }
-      p25.log.warn(`Railway database provisioning failed: ${message}`);
-      p25.log.info("Falling back to a manual database connection string.");
+      p26.log.warn(`Railway database provisioning failed: ${message}`);
+      p26.log.info("Falling back to a manual database connection string.");
       databaseUrl = await promptConnectionString();
     }
   }
@@ -27630,7 +27761,7 @@ async function runInitCommand(name, options) {
       return { ok: true, config: config2 };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      p25.log.warn(`Railway bucket provisioning failed: ${message}`);
+      p26.log.warn(`Railway bucket provisioning failed: ${message}`);
       return { ok: false };
     }
   };
@@ -27644,7 +27775,7 @@ async function runInitCommand(name, options) {
     if (storage === "r2") {
       const missingR2Keys = R2_ENV_KEYS.filter((key) => !readEnvVar(cwd, key)?.trim());
       if (options.yes && missingR2Keys.length > 0) {
-        p25.log.error(
+        p26.log.error(
           `Cloudflare R2 is missing required environment variables: ${missingR2Keys.join(", ")}.`
         );
         process.exit(1);
@@ -27658,7 +27789,7 @@ async function runInitCommand(name, options) {
         if (flow.ok && flow.config) {
           mergeCollectedIntegrationConfig(flow.config);
         } else if (options.yes) {
-          p25.log.error("Railway bucket provisioning did not complete.");
+          p26.log.error("Railway bucket provisioning did not complete.");
           process.exit(1);
         }
       }
@@ -27677,10 +27808,10 @@ async function runInitCommand(name, options) {
         });
         collectedIntegrationConfig.overwriteKeys.add("BLOB_READ_WRITE_TOKEN");
       } else if (options.yes) {
-        p25.log.error("Vercel Blob provisioning did not complete.");
+        p26.log.error("Vercel Blob provisioning did not complete.");
         process.exit(1);
       } else {
-        p25.log.warn(
+        p26.log.warn(
           "Continuing without a Blob token \u2014 add BLOB_READ_WRITE_TOKEN to .env.local from the store on vercel.com/dashboard/stores."
         );
         collectedIntegrationConfig.sections.push({
@@ -27754,7 +27885,7 @@ async function runInitCommand(name, options) {
   const nextConfigResult = scaffoldNextConfig({ cwd, nextMajorVersion });
   s.clear();
   if (nextConfigResult.status === "unsupported") {
-    p25.log.warn("The Next.js config could not be updated automatically \u2014 review it manually.");
+    p26.log.warn("The Next.js config could not be updated automatically \u2014 review it manually.");
   }
   const drizzleConfigPath = path52.join(cwd, "drizzle.config.ts");
   if (!dbFiles.includes("drizzle.config.ts") && fs41.existsSync(drizzleConfigPath)) {
@@ -27765,20 +27896,20 @@ async function runInitCommand(name, options) {
         readNamespacedTemplate("drizzle.config.ts", namespace),
         "utf-8"
       );
-      p25.log.success("Updated drizzle.config.ts");
+      p26.log.success("Updated drizzle.config.ts");
     } else if (!options.yes) {
-      const overwrite = await p25.confirm({
+      const overwrite = await p26.confirm({
         message: "drizzle.config.ts already exists. Overwrite with latest version?",
         initialValue: true
       });
-      if (!p25.isCancel(overwrite) && overwrite) {
+      if (!p26.isCancel(overwrite) && overwrite) {
         const { readNamespacedTemplate } = await import("./template-reader-PVN53GS7.js");
         fs41.writeFileSync(
           drizzleConfigPath,
           readNamespacedTemplate("drizzle.config.ts", namespace),
           "utf-8"
         );
-        p25.log.success("Updated drizzle.config.ts");
+        p26.log.success("Updated drizzle.config.ts");
       }
     }
   }
@@ -27803,8 +27934,8 @@ async function runInitCommand(name, options) {
     s.stop("");
   } else {
     s.stop("Failed to install dependencies");
-    p25.log.warn(depsResult.error ?? "Unknown error");
-    p25.log.info(
+    p26.log.warn(depsResult.error ?? "Unknown error");
+    p26.log.info(
       `You can install them manually:
   ${pc10.cyan(`${pm} add ${depsResult.dependencies.join(" ")}`)}
   ${pc10.cyan(`${pm} add -D ${depsResult.devDeps.join(" ")}`)}`
@@ -27860,22 +27991,22 @@ async function runInitCommand(name, options) {
   writeConfigFile(cwd, resolvedIntegrationInstallResult.config);
   const usesLocalStorage = resolvedIntegrationInstallResult.config.storage.provider === "local";
   for (const err of coreSchemasResult.errors) {
-    p25.log.warn(`Core schemas: ${err}`);
+    p26.log.warn(`Core schemas: ${err}`);
   }
   for (const warning of resolvedPresetInstallResult.warnings) {
-    p25.log.warn(warning);
+    p26.log.warn(warning);
   }
   for (const warning of resolvedIntegrationInstallResult.warnings) {
-    p25.log.warn(warning);
+    p26.log.warn(warning);
   }
   if (usesLocalStorage) {
-    p25.log.warn(
+    p26.log.warn(
       "Local filesystem storage is only for development or self-hosted persistent-disk deployments. Use Vercel Blob, Railway Bucket, or Cloudflare R2 for hosted production."
     );
   }
   let dbPushed = false;
   if (depsResult.success && options.skipMigration && hasDbUrl(cwd)) {
-    p25.log.info(`Skipping database schema push ${pc10.dim("(--skip-migration)")}`);
+    p26.log.info(`Skipping database schema push ${pc10.dim("(--skip-migration)")}`);
   } else if (depsResult.success && hasDbUrl(cwd)) {
     let driverReady = hasDrizzleKitPostgresDriverDependency(cwd);
     if (!driverReady) {
@@ -27890,8 +28021,8 @@ async function runInitCommand(name, options) {
       });
       if (!driverResult.success) {
         s.stop("Database push failed");
-        p25.log.warn(driverResult.error ?? `Failed to install ${DRIZZLE_KIT_POSTGRES_DRIVER_DEP}`);
-        p25.log.info(
+        p26.log.warn(driverResult.error ?? `Failed to install ${DRIZZLE_KIT_POSTGRES_DRIVER_DEP}`);
+        p26.log.info(
           `Install ${DRIZZLE_KIT_POSTGRES_DRIVER_DEP} manually, then run: ${pc10.cyan(drizzlePushCommand(pm))}`
         );
       } else {
@@ -27919,8 +28050,8 @@ async function runInitCommand(name, options) {
           const verification = await verifyDatabaseReachable(cwd);
           clearDbSpinner();
           if (!verification.success) {
-            p25.log.warn(verification.error);
-            p25.log.error("Database was not reachable. Aborting setup.");
+            p26.log.warn(verification.error);
+            p26.log.error("Database was not reachable. Aborting setup.");
             process.exit(1);
           }
         } else {
@@ -27933,12 +28064,12 @@ async function runInitCommand(name, options) {
           s.stop("Database push failed");
         }
         const pushError = pushResult.error ?? "Unknown error";
-        p25.log.warn(pushError);
+        p26.log.warn(pushError);
         if (isDatabaseReachabilityError(pushError)) {
-          p25.log.error("Database was not reachable. Aborting setup.");
+          p26.log.error("Database was not reachable. Aborting setup.");
           process.exit(1);
         }
-        p25.log.info(`You can run it manually: ${pc10.cyan(drizzlePushCommand(pm))}`);
+        p26.log.info(`You can run it manually: ${pc10.cyan(drizzlePushCommand(pm))}`);
       }
     }
   }
@@ -27947,7 +28078,7 @@ async function runInitCommand(name, options) {
   let seedSuccess = false;
   let adminAccountReady = false;
   if (dbPushed && options.skipAdminCreation) {
-    p25.log.info(
+    p26.log.info(
       `Skipping admin user creation ${pc10.dim(`(use ${betterstartExecCommand(pm, "seed")} later)`)}`
     );
   }
@@ -27959,14 +28090,14 @@ async function runInitCommand(name, options) {
     const adminCheck = await checkExistingAdmin(cwd, adminDir, authBasePath);
     s.clear();
     if (adminCheck.error) {
-      p25.log.warn(`Could not verify existing admin account ${pc10.dim(`(${adminCheck.error})`)}`);
+      p26.log.warn(`Could not verify existing admin account ${pc10.dim(`(${adminCheck.error})`)}`);
       if (isDatabaseReachabilityError(adminCheck.error)) {
-        p25.log.error("Database was not reachable. Aborting setup.");
+        p26.log.error("Database was not reachable. Aborting setup.");
         process.exit(1);
       }
     } else if (adminCheck.existingAdmin) {
       const existingAdminLabel = formatAdminIdentity(adminCheck.existingAdmin);
-      const adminAction = await p25.select({
+      const adminAction = await p26.select({
         message: "Found an already existing admin account. Do you want to replace it or skip?",
         options: [
           {
@@ -27980,28 +28111,28 @@ async function runInitCommand(name, options) {
           }
         ]
       });
-      if (p25.isCancel(adminAction)) {
-        p25.cancel("Setup cancelled.");
+      if (p26.isCancel(adminAction)) {
+        p26.cancel("Setup cancelled.");
         process.exit(0);
       }
       if (adminAction === "skip") {
         adminAccountReady = true;
-        p25.log.info(`Keeping existing admin account ${pc10.dim(`(${existingAdminLabel})`)}`);
+        p26.log.info(`Keeping existing admin account ${pc10.dim(`(${existingAdminLabel})`)}`);
       } else {
         replaceExistingAdmin = true;
       }
     }
     if (!adminAccountReady) {
-      const credentials = await p25.group(
+      const credentials = await p26.group(
         {
-          email: () => p25.text({
+          email: () => p26.text({
             message: "Admin email",
             placeholder: "admin@example.com",
             validate: (v) => {
               if (!v || !v.includes("@")) return "Please enter a valid email";
             }
           }),
-          password: () => p25.password({
+          password: () => p26.password({
             message: "Admin password",
             validate: (v) => {
               if (!v || v.length < 8) return "Password must be at least 8 characters";
@@ -28010,14 +28141,14 @@ async function runInitCommand(name, options) {
         },
         {
           onCancel: () => {
-            p25.cancel("Setup cancelled.");
+            p26.cancel("Setup cancelled.");
             process.exit(0);
           }
         }
       );
       seedEmail = credentials.email;
       seedPassword = credentials.password;
-      const credentialPromptRows = clackPromptRows("Admin email", credentials.email) + clackPromptRows("Admin password", p25.S_PASSWORD_MASK.repeat(credentials.password.length));
+      const credentialPromptRows = clackPromptRows("Admin email", credentials.email) + clackPromptRows("Admin password", p26.S_PASSWORD_MASK.repeat(credentials.password.length));
       let rowsBelowCredentialPrompts = 0;
       let seedOverwriteMode = replaceExistingAdmin ? "admin" : void 0;
       s.start(replaceExistingAdmin ? "Replacing admin user" : "Creating admin user");
@@ -28034,7 +28165,7 @@ async function runInitCommand(name, options) {
         s.stop(existingAccountMessage);
         rowsBelowCredentialPrompts += clackLogRows(existingAccountMessage);
         const replaceAccountMessage = "Replace the existing account with this email?";
-        const replace = await p25.confirm({
+        const replace = await p26.confirm({
           message: replaceAccountMessage,
           initialValue: false
         });
@@ -28042,7 +28173,7 @@ async function runInitCommand(name, options) {
           replaceAccountMessage,
           replace === true ? "Yes" : "No"
         );
-        if (!p25.isCancel(replace) && replace) {
+        if (!p26.isCancel(replace) && replace) {
           seedOverwriteMode = "email";
           s.start("Replacing admin user");
           seedResult = await runSeed(
@@ -28064,14 +28195,14 @@ async function runInitCommand(name, options) {
         adminAccountReady = true;
       } else if (seedResult.error) {
         s.stop(`Failed to create admin user`);
-        p25.note(
+        p26.note(
           `${pc10.red(seedResult.error)}
 
 Run manually: ${pc10.cyan(betterstartExecCommand(pm, "seed"))}`,
           pc10.red("Seed failed")
         );
         if (isDatabaseReachabilityError(seedResult.error)) {
-          p25.log.error("Database was not reachable. Aborting setup.");
+          p26.log.error("Database was not reachable. Aborting setup.");
           process.exit(1);
         }
       }
@@ -28080,9 +28211,9 @@ Run manually: ${pc10.cyan(betterstartExecCommand(pm, "seed"))}`,
   if (isFreshProject) {
     s.start("Creating initial git commit");
     try {
-      execFileSync5("git", ["init"], { cwd, stdio: "pipe" });
-      execFileSync5("git", ["add", "."], { cwd, stdio: "pipe" });
-      execFileSync5("git", ["commit", "-m", "Initial commit from BetterStart"], {
+      execFileSync4("git", ["init"], { cwd, stdio: "pipe" });
+      execFileSync4("git", ["add", "."], { cwd, stdio: "pipe" });
+      execFileSync4("git", ["commit", "-m", "Initial commit from BetterStart"], {
         cwd,
         stdio: "pipe"
       });
@@ -28113,10 +28244,10 @@ Run manually: ${pc10.cyan(betterstartExecCommand(pm, "seed"))}`,
     deployedUrl = deployFlow.url;
     if (!deployFlow.ok) {
       if (options.yes) {
-        p25.log.error("Vercel deploy did not complete.");
+        p26.log.error("Vercel deploy did not complete.");
         process.exit(1);
       }
-      p25.log.warn("Vercel deploy did not complete; continuing.");
+      p26.log.warn("Vercel deploy did not complete; continuing.");
     }
   } else if (deployProvider === "railway") {
     try {
@@ -28134,29 +28265,29 @@ Run manually: ${pc10.cyan(betterstartExecCommand(pm, "seed"))}`,
       });
       deployedUrl = deployFlow.url;
       if (!deployFlow.ok) {
-        if (deployFlow.detail) p25.log.message(pc10.dim(redactSecrets(deployFlow.detail)));
+        if (deployFlow.detail) p26.log.message(pc10.dim(redactSecrets(deployFlow.detail)));
         if (options.yes) {
-          p25.log.error("Railway deploy did not complete.");
+          p26.log.error("Railway deploy did not complete.");
           process.exit(1);
         }
-        p25.log.warn("Railway deploy did not complete; continuing.");
+        p26.log.warn("Railway deploy did not complete; continuing.");
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (options.yes) {
-        p25.log.error(`Railway deploy failed: ${message}`);
+        p26.log.error(`Railway deploy failed: ${message}`);
         process.exit(1);
       }
-      p25.log.warn(`Railway deploy failed: ${message}`);
+      p26.log.warn(`Railway deploy failed: ${message}`);
     }
   }
   if (!options.yes && !options.skipDevServerStart) {
     const devCmd = runCommand(pm, "dev");
-    const startDev = await p25.confirm({
+    const startDev = await p26.confirm({
       message: "Start the development server?",
       initialValue: true
     });
-    if (!p25.isCancel(startDev) && startDev) {
+    if (!p26.isCancel(startDev) && startDev) {
       disposeCancelGuard();
       await startManagedDevServer(cwd, devCmd, adminLoginUrl, {
         email: seedSuccess && seedEmail ? seedEmail : void 0,
@@ -28188,7 +28319,7 @@ Run manually: ${pc10.cyan(betterstartExecCommand(pm, "seed"))}`,
     );
     return;
   }
-  p25.outro(`Admin ready at ${adminNamespace.routePath}`);
+  p26.outro(`Admin ready at ${adminNamespace.routePath}`);
 }
 function isValidDbUrl(url) {
   return url.startsWith("postgres://") || url.startsWith("postgresql://");
@@ -28581,7 +28712,7 @@ function printAdminReadyNote(state) {
   } else if (state.adminEmail) {
     lines.unshift(`Admin user: ${pc10.cyan(state.adminEmail)}`);
   }
-  p25.note(lines.join("\n"), "Admin ready");
+  p26.note(lines.join("\n"), "Admin ready");
 }
 function shouldSuppressDevServerStartupLine(line) {
   const plain = stripAnsi2(line).trim();
@@ -28693,7 +28824,7 @@ function startManagedDevServer(cwd, devCmd, adminLoginUrl, adminCredentials) {
 
 // adapters/next/commands/list-integrations.ts
 import path53 from "path";
-import * as p26 from "@clack/prompts";
+import * as p27 from "@clack/prompts";
 
 // core-engine/utils/table.ts
 function renderTableRows(rows) {
@@ -28740,15 +28871,15 @@ async function runListIntegrationsCommand(options) {
     integration.kind,
     integration.description
   ]);
-  p26.note(renderTableRows(rows).join("\n"), "BetterStart integrations");
-  p26.outro(
+  p27.note(renderTableRows(rows).join("\n"), "BetterStart integrations");
+  p27.outro(
     `${installedIntegrations.size} installed, ${rows.length - installedIntegrations.size} available`
   );
 }
 
 // adapters/next/commands/list-presets.ts
 import path54 from "path";
-import * as p27 from "@clack/prompts";
+import * as p28 from "@clack/prompts";
 async function runListPresetsCommand(options) {
   const cwd = options.cwd ? path54.resolve(options.cwd) : process.cwd();
   if (options.json) {
@@ -28778,48 +28909,73 @@ async function runListPresetsCommand(options) {
     preset.kind,
     preset.description
   ]);
-  p27.note(renderTableRows(rows).join("\n"), "BetterStart presets");
-  p27.outro(`${installedPresets.size} installed, ${rows.length - installedPresets.size} available`);
+  p28.note(renderTableRows(rows).join("\n"), "BetterStart presets");
+  p28.outro(`${installedPresets.size} installed, ${rows.length - installedPresets.size} available`);
 }
 
-// adapters/next/commands/remove.ts
+// adapters/next/commands/menu-choices.ts
 import path55 from "path";
-import * as p28 from "@clack/prompts";
+async function listInstallableChoices(cwd) {
+  const config = await resolveConfigOrExit(cwd);
+  const installedPresets = new Set(config.presets.installed);
+  const installedIntegrations = new Set(config.integrations.installed);
+  return {
+    presets: listAvailablePresets().map((preset) => ({
+      id: preset.id,
+      description: preset.description,
+      installed: installedPresets.has(preset.id)
+    })),
+    integrations: listAvailableIntegrations().map((integration) => ({
+      id: integration.id,
+      description: integration.description,
+      installed: installedIntegrations.has(integration.id)
+    }))
+  };
+}
+async function listSchemaChoices(cwd) {
+  const config = await resolveConfigOrExit(cwd);
+  const paths = resolveProjectPaths(config);
+  return listSchemaNames(path55.join(cwd, ...paths.schemasDir.split("/")));
+}
+
+// adapters/next/commands/remove.ts
+import path56 from "path";
+import * as p29 from "@clack/prompts";
 async function runRemoveCommand(items, options) {
   const removeIntegrationsMode = Boolean(options.integration);
   if (!removeIntegrationsMode && items.includes("core")) {
-    p28.log.error("The core Admin cannot be removed.");
+    p29.log.error("The core Admin cannot be removed.");
     process.exit(1);
   }
   const presetIds = items.filter(isPresetId);
   const integrationIds = items.filter(isIntegrationId);
   if (!removeIntegrationsMode && integrationIds.length > 0) {
-    p28.log.error(
+    p29.log.error(
       `Integration IDs require --integration. Run \`betterstart remove --integration ${integrationIds.join(" ")}\`.`
     );
     process.exit(1);
   }
   if (removeIntegrationsMode && presetIds.length > 0) {
-    p28.log.error(`Preset IDs cannot be removed with --integration: ${presetIds.join(", ")}`);
+    p29.log.error(`Preset IDs cannot be removed with --integration: ${presetIds.join(", ")}`);
     process.exit(1);
   }
   const invalidItems = removeIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((presetId) => !isPresetId(presetId));
   if (invalidItems.length > 0) {
-    p28.log.error(
+    p29.log.error(
       removeIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPresetMessage(invalidItems)
     );
     process.exit(1);
   }
-  const cwd = options.cwd ? path55.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path56.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const pm = detectPackageManager(cwd);
   if (!options.force) {
-    const confirmed = await p28.confirm({
+    const confirmed = await p29.confirm({
       message: `Remove ${removeIntegrationsMode ? "integration" : "preset"}${items.length === 1 ? "" : "s"} ${items.join(", ")}?`,
       initialValue: false
     });
-    if (p28.isCancel(confirmed) || !confirmed) {
-      p28.cancel(`${removeIntegrationsMode ? "Integration" : "Preset"} removal cancelled.`);
+    if (p29.isCancel(confirmed) || !confirmed) {
+      p29.cancel(`${removeIntegrationsMode ? "Integration" : "Preset"} removal cancelled.`);
       process.exit(0);
     }
   }
@@ -28832,13 +28988,13 @@ async function runRemoveCommand(items, options) {
     });
     writeConfigFile(cwd, result2.config);
     if (result2.removed.length === 0) {
-      p28.outro("No integrations were removed.");
+      p29.outro("No integrations were removed.");
       return;
     }
     if (result2.warnings.length > 0) {
-      p28.note(result2.warnings.join("\n"), "Warnings");
+      p29.note(result2.warnings.join("\n"), "Warnings");
     }
-    p28.outro(
+    p29.outro(
       `Removed integration${result2.removed.length === 1 ? "" : "s"}: ${result2.removed.join(", ")}`
     );
     return;
@@ -28851,37 +29007,37 @@ async function runRemoveCommand(items, options) {
   });
   writeConfigFile(cwd, result.config);
   if (result.removed.length === 0) {
-    p28.outro("No presets were removed.");
+    p29.outro("No presets were removed.");
     return;
   }
   if (result.warnings.length > 0) {
-    p28.note(result.warnings.join("\n"), "Warnings");
+    p29.note(result.warnings.join("\n"), "Warnings");
   }
-  p28.outro(`Removed preset${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`);
+  p29.outro(`Removed preset${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`);
 }
 
 // adapters/next/commands/remove-schema.ts
 import fs42 from "fs";
-import path56 from "path";
+import path57 from "path";
 import * as clack3 from "@clack/prompts";
 function removePath2(cwd, filePath) {
-  const fullPath = path56.join(cwd, ...filePath.split("/"));
+  const fullPath = path57.join(cwd, ...filePath.split("/"));
   const existed = fs42.existsSync(fullPath);
   fs42.rmSync(fullPath, { recursive: true, force: true });
   return existed;
 }
 function cleanupEmptyDirs3(cwd, deletedPaths, configPaths) {
   const stopRoots = /* @__PURE__ */ new Set([
-    path56.join(cwd, ...configPaths.adminDir.split("/")),
-    path56.join(cwd, ...configPaths.adminNavigationDir.split("/")),
-    path56.join(cwd, ...configPaths.adminWebhookEventsDir.split("/")),
-    path56.join(cwd, ...configPaths.pagesDir.split("/"))
+    path57.join(cwd, ...configPaths.adminDir.split("/")),
+    path57.join(cwd, ...configPaths.adminNavigationDir.split("/")),
+    path57.join(cwd, ...configPaths.adminWebhookEventsDir.split("/")),
+    path57.join(cwd, ...configPaths.pagesDir.split("/"))
   ]);
   for (const deletedPath of deletedPaths) {
-    let current = path56.dirname(path56.join(cwd, ...deletedPath.split("/")));
+    let current = path57.dirname(path57.join(cwd, ...deletedPath.split("/")));
     while (!stopRoots.has(current)) {
       if (!fs42.existsSync(current)) {
-        current = path56.dirname(current);
+        current = path57.dirname(current);
         continue;
       }
       const entries = fs42.readdirSync(current);
@@ -28889,7 +29045,7 @@ function cleanupEmptyDirs3(cwd, deletedPaths, configPaths) {
         break;
       }
       fs42.rmdirSync(current);
-      current = path56.dirname(current);
+      current = path57.dirname(current);
     }
   }
 }
@@ -28905,7 +29061,7 @@ function resolveSchemaOwnerForRemoval(cwd, schemaName) {
 }
 async function runRemoveSchemaCommand(schemaName, options) {
   const owner = resolveSchemaOwnerForRemoval(
-    options.cwd ? path56.resolve(options.cwd) : process.cwd(),
+    options.cwd ? path57.resolve(options.cwd) : process.cwd(),
     schemaName
   );
   if (owner === "core") {
@@ -28918,7 +29074,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
     clack3.log.error(`"${schemaName}" is owned by ${owner}. Remove the owning preset instead.`);
     process.exit(1);
   }
-  const cwd = options.cwd ? path56.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path57.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const paths = resolveProjectPaths(config);
   const manifest = loadManifest(cwd, schemaName);
@@ -28931,7 +29087,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
     process.exit(1);
   }
   if (!options.force) {
-    if (!isInteractiveSession4()) {
+    if (!isInteractiveSession()) {
       clack3.log.error(
         `Removing generated files for ${schemaName} needs confirmation. Re-run with --force.`
       );
@@ -28954,7 +29110,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
   }
   const loaded = (() => {
     try {
-      return loadSchema(path56.join(cwd, ...paths.schemasDir.split("/")), schemaName);
+      return loadSchema(path57.join(cwd, ...paths.schemasDir.split("/")), schemaName);
     } catch {
       return null;
     }
@@ -28999,8 +29155,8 @@ Schema JSON preserved.`
 
 // adapters/next/commands/uninstall.ts
 import fs44 from "fs";
-import path57 from "path";
-import * as p29 from "@clack/prompts";
+import path58 from "path";
+import * as p30 from "@clack/prompts";
 import pc11 from "picocolors";
 
 // adapters/next/commands/uninstall-cleaners.ts
@@ -29149,7 +29305,7 @@ function findMainCss2(cwd) {
     "globals.css"
   ];
   for (const candidate of candidates) {
-    const filePath = path57.join(cwd, candidate);
+    const filePath = path58.join(cwd, candidate);
     if (fs44.existsSync(filePath)) return filePath;
   }
   return void 0;
@@ -29166,13 +29322,13 @@ function isCLICreatedBiome(biomePath) {
 function buildUninstallPlan(cwd, namespaceValue) {
   const steps = [];
   const namespace = resolveAdminNamespace(namespaceValue);
-  const hasSrc = fs44.existsSync(path57.join(cwd, "src"));
+  const hasSrc = fs44.existsSync(path58.join(cwd, "src"));
   const appBase = hasSrc ? "src/app" : "app";
   const dirs = [];
-  const adminDir = path57.join(cwd, namespace.segment);
-  const legacyAdminDir = path57.join(cwd, "admin");
-  const adminRouteGroup = path57.join(cwd, appBase, namespace.routeGroup);
-  const legacyAdminRouteGroup = path57.join(cwd, appBase, "(admin)");
+  const adminDir = path58.join(cwd, namespace.segment);
+  const legacyAdminDir = path58.join(cwd, "admin");
+  const adminRouteGroup = path58.join(cwd, appBase, namespace.routeGroup);
+  const legacyAdminRouteGroup = path58.join(cwd, appBase, "(admin)");
   if (fs44.existsSync(adminDir)) dirs.push(`${namespace.segment}/`);
   if (namespace.segment !== "admin" && fs44.existsSync(legacyAdminDir)) dirs.push("admin/");
   if (fs44.existsSync(adminRouteGroup)) dirs.push(`${appBase}/${namespace.routeGroup}/`);
@@ -29200,9 +29356,9 @@ function buildUninstallPlan(cwd, namespaceValue) {
   const configFiles = [];
   const configPaths = [];
   const candidates = [
-    [CONFIG_FILE_NAME, path57.join(cwd, CONFIG_FILE_NAME)],
-    ["drizzle.config.ts", path57.join(cwd, "drizzle.config.ts")],
-    ["ADMIN.md", path57.join(cwd, "ADMIN.md")]
+    [CONFIG_FILE_NAME, path58.join(cwd, CONFIG_FILE_NAME)],
+    ["drizzle.config.ts", path58.join(cwd, "drizzle.config.ts")],
+    ["ADMIN.md", path58.join(cwd, "ADMIN.md")]
   ];
   for (const [label, fullPath] of candidates) {
     if (fs44.existsSync(fullPath)) {
@@ -29210,7 +29366,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       configPaths.push(fullPath);
     }
   }
-  const biomePath = path57.join(cwd, "biome.json");
+  const biomePath = path58.join(cwd, "biome.json");
   if (isCLICreatedBiome(biomePath)) {
     configFiles.push("biome.json (CLI-created)");
     configPaths.push(biomePath);
@@ -29222,13 +29378,13 @@ function buildUninstallPlan(cwd, namespaceValue) {
       count: configFiles.length,
       unit: configFiles.length === 1 ? "file" : "files",
       execute() {
-        for (const p31 of configPaths) {
-          if (fs44.existsSync(p31)) fs44.unlinkSync(p31);
+        for (const p32 of configPaths) {
+          if (fs44.existsSync(p32)) fs44.unlinkSync(p32);
         }
       }
     });
   }
-  const tsconfigPath = path57.join(cwd, "tsconfig.json");
+  const tsconfigPath = path58.join(cwd, "tsconfig.json");
   if (fs44.existsSync(tsconfigPath)) {
     const content = fs44.readFileSync(tsconfigPath, "utf-8");
     const aliasMatches = [
@@ -29255,7 +29411,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       (l) => new RegExp(`^@source\\s+"[^"]*(?:admin|${namespace.segment})[^"]*";\\s*$`).test(l)
     );
     if (sourceLines.length > 0) {
-      const relCss = path57.relative(cwd, cssFile);
+      const relCss = path58.relative(cwd, cssFile);
       steps.push({
         label: `CSS @source lines (${relCss})`,
         items: [`@source lines in ${relCss}`],
@@ -29267,7 +29423,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       });
     }
   }
-  const envPath = path57.join(cwd, ".env.local");
+  const envPath = path58.join(cwd, ".env.local");
   if (fs44.existsSync(envPath)) {
     const envContent = fs44.readFileSync(envPath, "utf-8");
     const bsVars = envContent.split("\n").filter((l) => l.trim().match(/^BETTERSTART_\w+=/)).map((l) => l.split("=")[0]);
@@ -29286,8 +29442,8 @@ function buildUninstallPlan(cwd, namespaceValue) {
   return steps;
 }
 async function runUninstallCommand(options) {
-  const cwd = options.cwd ? path57.resolve(options.cwd) : process.cwd();
-  p29.intro(pc11.bgRed(pc11.white(" BetterStart Uninstall ")));
+  const cwd = options.cwd ? path58.resolve(options.cwd) : process.cwd();
+  p30.intro(pc11.bgRed(pc11.white(" BetterStart Uninstall ")));
   let namespace = DEFAULT_ADMIN_NAMESPACE;
   try {
     const config = await resolveConfig(cwd);
@@ -29296,8 +29452,8 @@ async function runUninstallCommand(options) {
   }
   const steps = buildUninstallPlan(cwd, namespace);
   if (steps.length === 0) {
-    p29.log.success(`${pc11.green("\u2713")} Nothing to remove \u2014 project is already clean.`);
-    p29.outro("Project already clean");
+    p30.log.success(`${pc11.green("\u2713")} Nothing to remove \u2014 project is already clean.`);
+    p30.outro("Project already clean");
     return;
   }
   const planLines = steps.map((step) => {
@@ -29305,14 +29461,14 @@ async function runUninstallCommand(options) {
     const countLabel = pc11.dim(`${step.count} ${step.unit}`);
     return `${pc11.red("\u2717")} ${names}  ${countLabel}`;
   });
-  p29.note(planLines.join("\n"), "Uninstall plan");
+  p30.note(planLines.join("\n"), "Uninstall plan");
   if (!options.force) {
-    const confirmed = await p29.confirm({
+    const confirmed = await p30.confirm({
       message: "Proceed with uninstall?",
       initialValue: false
     });
-    if (p29.isCancel(confirmed) || !confirmed) {
-      p29.cancel("Uninstall cancelled.");
+    if (p30.isCancel(confirmed) || !confirmed) {
+      p30.cancel("Uninstall cancelled.");
       process.exit(0);
     }
   }
@@ -29324,14 +29480,14 @@ async function runUninstallCommand(options) {
   }
   const parts = steps.map((step) => `${step.count} ${step.unit}`);
   s.stop(`Removed ${parts.join(", ")}`);
-  p29.note(pc11.dim("Database tables were NOT dropped \u2014 drop them manually if needed."), "Next steps");
-  p29.outro("Uninstall complete");
+  p30.note(pc11.dim("Database tables were NOT dropped \u2014 drop them manually if needed."), "Next steps");
+  p30.outro("Uninstall complete");
 }
 
 // adapters/next/commands/update-component.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import fs45 from "fs";
-import path58 from "path";
+import path59 from "path";
 import * as clack4 from "@clack/prompts";
 import fsExtra from "fs-extra";
 var STATIC_CUSTOM_DEPENDENCIES = {
@@ -29592,14 +29748,14 @@ function copyNamespacedDirectory(srcDir, destDir, namespace) {
   const entries = fs45.readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const namespacedName = applyAdminNamespaceToPath(entry.name, namespace);
-    const srcPath = path58.join(srcDir, entry.name);
-    const destPath = path58.join(destDir, namespacedName);
+    const srcPath = path59.join(srcDir, entry.name);
+    const destPath = path59.join(destDir, namespacedName);
     if (entry.isDirectory()) {
       fsExtra.ensureDirSync(destPath);
       copyNamespacedDirectory(srcPath, destPath, namespace);
       continue;
     }
-    fsExtra.ensureDirSync(path58.dirname(destPath));
+    fsExtra.ensureDirSync(path59.dirname(destPath));
     writeNamespacedFile(srcPath, destPath, namespace);
   }
 }
@@ -29610,7 +29766,7 @@ function hasIntegration(config, integrationId) {
   return config.integrations.installed.includes(integrationId);
 }
 function readProjectPackageJson2(cwd) {
-  const pkgPath = path58.join(cwd, "package.json");
+  const pkgPath = path59.join(cwd, "package.json");
   if (!fs45.existsSync(pkgPath)) return null;
   try {
     return JSON.parse(fs45.readFileSync(pkgPath, "utf-8"));
@@ -31146,12 +31302,12 @@ function getStaticAssetComponentEntries(assetDirectory) {
       continue;
     }
     const indexFile = ["index.tsx", "index.ts"].find(
-      (file) => fs45.existsSync(path58.join(assetDir, entry.name, file))
+      (file) => fs45.existsSync(path59.join(assetDir, entry.name, file))
     );
     if (indexFile) {
       components.push({
         name: entry.name,
-        file: path58.join(entry.name, indexFile)
+        file: path59.join(entry.name, indexFile)
       });
     }
   }
@@ -31160,20 +31316,20 @@ function getStaticAssetComponentEntries(assetDirectory) {
 function findStaticAssetFile(assetDir, componentName) {
   if (!fs45.existsSync(assetDir)) return void 0;
   const isNestedComponentName = /[\\/]/.test(componentName);
-  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path58.sep);
-  if (isNestedComponentName && nestedComponentName && !path58.isAbsolute(componentName) && !nestedComponentName.split(path58.sep).includes("..")) {
+  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path59.sep);
+  if (isNestedComponentName && nestedComponentName && !path59.isAbsolute(componentName) && !nestedComponentName.split(path59.sep).includes("..")) {
     for (const extension of [".tsx", ".ts"]) {
       const relPath = `${nestedComponentName}${extension}`;
-      const filePath = path58.join(assetDir, relPath);
+      const filePath = path59.join(assetDir, relPath);
       if (fs45.existsSync(filePath) && fs45.statSync(filePath).isFile()) {
         return relPath;
       }
     }
   }
-  if (!isNestedComponentName && !componentName.includes("..") && !path58.isAbsolute(componentName)) {
+  if (!isNestedComponentName && !componentName.includes("..") && !path59.isAbsolute(componentName)) {
     for (const extension of [".tsx", ".ts"]) {
-      const relPath = path58.join(componentName, `index${extension}`);
-      const filePath = path58.join(assetDir, relPath);
+      const relPath = path59.join(componentName, `index${extension}`);
+      const filePath = path59.join(assetDir, relPath);
       if (fs45.existsSync(filePath) && fs45.statSync(filePath).isFile()) {
         return relPath;
       }
@@ -31198,7 +31354,7 @@ function getAllComponentNamesForConfig(config) {
   return [.../* @__PURE__ */ new Set([...staticUi, ...staticCustom, ...templateKeys, "tiptap"])].sort();
 }
 async function runUpdateCommand(components, options) {
-  const cwd = options.cwd ? path58.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path59.resolve(options.cwd) : process.cwd();
   const normalizedOnly = normalizeShadcnPresetOnly(options.only);
   validateShadcnPresetOptions(components, options);
   if (options.json && !options.list) {
@@ -31259,7 +31415,7 @@ async function runUpdateCommand(components, options) {
     return;
   }
   const config = await resolveConfigOrExit(cwd);
-  const admin = path58.resolve(cwd, config.paths.admin);
+  const admin = path59.resolve(cwd, config.paths.admin);
   if (!fs45.existsSync(admin)) {
     clack4.cancel(
       `Admin directory not found at ${config.paths.admin}. Run 'betterstart init' first.`
@@ -31314,7 +31470,7 @@ async function runUpdateCommand(components, options) {
     }
     const { relPath, content } = applyNamespaceToTemplateEntry(entry, config, cwd);
     const baseDir = entry.base === "cwd" ? cwd : admin;
-    const destPath = path58.join(baseDir, relPath);
+    const destPath = path59.join(baseDir, relPath);
     if (entry.preserveExisting && fs45.existsSync(destPath)) {
       clack4.log.info(`Preserved ${relPath}`);
       updatedTemplateNames.add(name);
@@ -31324,7 +31480,7 @@ async function runUpdateCommand(components, options) {
     pendingWrites.push({
       displayPath: relPath,
       write: () => {
-        fsExtra.ensureDirSync(path58.dirname(destPath));
+        fsExtra.ensureDirSync(path59.dirname(destPath));
         fs45.writeFileSync(destPath, content, "utf-8");
         clack4.log.success(`Updated ${relPath}`);
       }
@@ -31356,20 +31512,20 @@ async function runUpdateCommand(components, options) {
     }
     const namespace = config.frameworkConfig.next.namespace;
     const namespacedAssetFile = applyAdminNamespaceToPath(assetFile, namespace);
-    const destPath = path58.join(admin, "components", assetDirectory, namespacedAssetFile);
+    const destPath = path59.join(admin, "components", assetDirectory, namespacedAssetFile);
     pendingWrites.push({
       displayPath: `components/${assetDirectory}/${namespacedAssetFile}`,
       write: () => {
-        fsExtra.ensureDirSync(path58.dirname(destPath));
-        writeNamespacedFile(path58.join(assetDir, assetFile), destPath, namespace);
+        fsExtra.ensureDirSync(path59.dirname(destPath));
+        writeNamespacedFile(path59.join(assetDir, assetFile), destPath, namespace);
         clack4.log.success(`Updated components/${assetDirectory}/${namespacedAssetFile}`);
       }
     });
     if (assetDirectory === "custom") {
-      const assetSubdir = path58.join(assetDir, name);
+      const assetSubdir = path59.join(assetDir, name);
       if (fs45.existsSync(assetSubdir) && fs45.statSync(assetSubdir).isDirectory()) {
         const namespacedName = applyAdminNamespaceToPath(name, namespace);
-        const destSubdir = path58.join(admin, "components", assetDirectory, namespacedName);
+        const destSubdir = path59.join(admin, "components", assetDirectory, namespacedName);
         pendingWrites.push({
           displayPath: `components/${assetDirectory}/${namespacedName}/ (template files)`,
           write: () => {
@@ -31404,19 +31560,19 @@ async function runUpdateCommand(components, options) {
       "content-editor"
     );
     const namespace = config.frameworkConfig.next.namespace;
-    const destBaseDir = path58.join(admin, "components", "custom", "content-editor");
+    const destBaseDir = path59.join(admin, "components", "custom", "content-editor");
     if (!fs45.existsSync(srcBaseDir)) {
       return false;
     }
     const dirsToCopy = [];
     for (const directory of TIPTAP_CONTENT_EDITOR_DIRECTORIES) {
-      const srcDir = path58.join(srcBaseDir, directory);
+      const srcDir = path59.join(srcBaseDir, directory);
       if (!fs45.existsSync(srcDir)) {
         continue;
       }
       dirsToCopy.push({
         srcDir,
-        destDir: path58.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
+        destDir: path59.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
       });
     }
     if (dirsToCopy.length === 0) {
@@ -31430,7 +31586,7 @@ async function runUpdateCommand(components, options) {
           copyNamespacedDirectory(srcDir, destDir, namespace);
         }
         clack4.log.success("Updated components/custom/content-editor/tiptap-*/ (template files)");
-        removeLegacyDirectory(path58.join(admin, "components", "custom", "tiptap"));
+        removeLegacyDirectory(path59.join(admin, "components", "custom", "tiptap"));
       }
     });
     updatedStaticNames.add(key);
@@ -31490,7 +31646,7 @@ async function runUpdateCommand(components, options) {
       `Overwriting ${displayPaths.length} file${displayPaths.length === 1 ? "" : "s"}`
     );
     if (!options.yes) {
-      if (!isInteractiveSession4()) {
+      if (!isInteractiveSession()) {
         clack4.log.error(
           `Overwriting ${displayPaths.length} file${displayPaths.length === 1 ? "" : "s"} needs confirmation. Re-run with --yes.`
         );
@@ -31570,13 +31726,13 @@ function runShadcnPresetUpdate({
   only
 }) {
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const adminGlobalsPath = path58.join(cwd, config.paths.admin, namespace.globalsFile);
-  const componentsJsonPath = path58.join(cwd, "components.json");
+  const adminGlobalsPath = path59.join(cwd, config.paths.admin, namespace.globalsFile);
+  const componentsJsonPath = path59.join(cwd, "components.json");
   const shadcnBackupPath = `${componentsJsonPath}.bak`;
   const restoreAfterApplyPaths = [
     componentsJsonPath,
     shadcnBackupPath,
-    path58.join(cwd, config.paths.admin, "lib", "utils.ts"),
+    path59.join(cwd, config.paths.admin, "lib", "utils.ts"),
     ...getHostProjectFilesToRestore(cwd)
   ];
   if (!preset) {
@@ -31585,7 +31741,7 @@ function runShadcnPresetUpdate({
   }
   if (!fs45.existsSync(adminGlobalsPath)) {
     clack4.cancel(
-      `Admin globals file not found at ${path58.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
+      `Admin globals file not found at ${path59.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
     );
     process.exit(1);
   }
@@ -31595,7 +31751,7 @@ function runShadcnPresetUpdate({
     snapshot: snapshotFile(filePath)
   }));
   clack4.intro("BetterStart Shadcn Preset");
-  clack4.log.info(`Applying preset to ${path58.join(config.paths.admin, "components/ui")}`);
+  clack4.log.info(`Applying preset to ${path59.join(config.paths.admin, "components/ui")}`);
   let failed = false;
   try {
     fs45.writeFileSync(
@@ -31608,7 +31764,7 @@ function runShadcnPresetUpdate({
     if (only) {
       args.push("--only", only);
     }
-    execFileSync6(shadcnBin, args, { cwd, stdio: "inherit" });
+    execFileSync5(shadcnBin, args, { cwd, stdio: "inherit" });
   } catch {
     failed = true;
   } finally {
@@ -31654,7 +31810,7 @@ function toPosixPath(value) {
 }
 function resolveLocalShadcnBin(cwd) {
   const binName = process.platform === "win32" ? "shadcn.cmd" : "shadcn";
-  const shadcnBin = path58.join(cwd, "node_modules", ".bin", binName);
+  const shadcnBin = path59.join(cwd, "node_modules", ".bin", binName);
   if (!fs45.existsSync(shadcnBin)) {
     clack4.cancel(
       `shadcn is not installed in this project. Run 'betterstart update-deps' and try again.`
@@ -31676,7 +31832,7 @@ function getHostProjectFilesToRestore(cwd) {
     "app/globals.css",
     "src/app/globals.css"
   ];
-  return hostRelativePaths.map((relativePath) => path58.join(cwd, relativePath));
+  return hostRelativePaths.map((relativePath) => path59.join(cwd, relativePath));
 }
 function snapshotFile(filePath) {
   if (!fs45.existsSync(filePath)) {
@@ -31695,10 +31851,10 @@ function restoreFile(filePath, snapshot) {
 }
 
 // adapters/next/commands/update-deps.ts
-import path59 from "path";
+import path60 from "path";
 import * as clack5 from "@clack/prompts";
 async function runUpdateDepsCommand(options) {
-  const cwd = options.cwd ? path59.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path60.resolve(options.cwd) : process.cwd();
   clack5.intro("BetterStart Update Dependencies");
   const pm = detectPackageManager(cwd);
   clack5.log.info(`Package manager: ${pm}`);
@@ -31733,17 +31889,17 @@ async function runUpdateDepsCommand(options) {
 
 // adapters/next/commands/update-styles.ts
 import fs46 from "fs";
-import path60 from "path";
+import path61 from "path";
 import * as clack6 from "@clack/prompts";
 async function runUpdateStylesCommand(options) {
-  const cwd = options.cwd ? path60.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path61.resolve(options.cwd) : process.cwd();
   clack6.intro("BetterStart Update Styles");
   const config = await resolveConfigOrExit(cwd);
   const adminDir = config.paths.admin;
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const targetPath = path60.join(cwd, adminDir, namespace.globalsFile);
+  const targetPath = path61.join(cwd, adminDir, namespace.globalsFile);
   if (!fs46.existsSync(targetPath)) {
-    clack6.cancel(`${namespace.globalsFile} not found at ${path60.relative(cwd, targetPath)}`);
+    clack6.cancel(`${namespace.globalsFile} not found at ${path61.relative(cwd, targetPath)}`);
     process.exit(1);
   }
   fs46.writeFileSync(
@@ -31751,12 +31907,14 @@ async function runUpdateStylesCommand(options) {
     applyAdminNamespaceToContent(readTemplate("admin-globals.css"), namespace.segment),
     "utf-8"
   );
-  clack6.log.success(`Updated ${path60.relative(cwd, targetPath)}`);
+  clack6.log.success(`Updated ${path61.relative(cwd, targetPath)}`);
   clack6.outro("Styles updated");
 }
 
 // adapters/next/commands-runtime.ts
 var nextCommandRuntime = {
+  listInstallableChoices,
+  listSchemaChoices,
   runAdd: runAddCommand,
   runAddField: runAddFieldCommand,
   runCreate: runCreateCommand,
@@ -31780,7 +31938,7 @@ var { version } = JSON.parse(
   readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command2();
-program.name("betterstart").description("Scaffold a preset- and integration-based Admin into any Next.js 16 application").version(version);
+program.name("betterstart").description("A production ready dashboard, tailored for you in 5 Minutes.").version(version);
 program.hook("preAction", (_command, actionCommand) => {
   requireInitializedProject(actionCommand);
 });
@@ -31799,14 +31957,18 @@ program.addCommand(createUpdateCommand(nextCommandRuntime));
 program.addCommand(createUpdateDepsCommand(nextCommandRuntime));
 program.addCommand(createUpdateStylesCommand(nextCommandRuntime));
 try {
-  await program.parseAsync();
+  if (process.argv.slice(2).length === 0) {
+    await runDefaultAction(program, nextCommandRuntime);
+  } else {
+    await program.parseAsync();
+  }
 } catch (error) {
   if (process.env.BETTERSTART_DEBUG) {
     console.error(error);
   } else {
     const message = error instanceof Error && error.message ? error.message : String(error);
-    p30.log.error(message);
-    p30.log.message(pc12.dim("Re-run with BETTERSTART_DEBUG=1 for the full stack trace."));
+    p31.log.error(message);
+    p31.log.message(pc12.dim("Re-run with BETTERSTART_DEBUG=1 for the full stack trace."));
   }
   process.exit(1);
 }