betterstart-cli 0.0.42 → 0.0.44

package/dist/cli.js

@@ -70,9 +70,9 @@ function requireInitializedProject(command) {
 import { Argument, Command } from "commander";
 var CREATE_SCHEMA_KINDS = ["entity", "single", "form"];
 function createAddCommand(runtime) {
-  return new Command("add").description("Install BetterStart plugins or integrations into an existing Admin").argument("<items...>", "Plugin or integration IDs to install (e.g. blog, r2)").option("-y, --yes", "Skip interactive configuration prompts", false).option("--integration", "Install integration IDs instead of content plugin IDs", false).option(
+  return new Command("add").description("Install BetterStart presets or integrations into an existing Admin").argument("<items...>", "Preset or integration IDs to install (e.g. blog, r2)").option("-y, --yes", "Skip interactive configuration prompts", false).option("--integration", "Install integration IDs instead of content preset IDs", false).option(
     "--skip-migration",
-    "Skip running db:push after installing schema-backed plugins",
+    "Skip running db:push after installing schema-backed presets",
     false
   ).option("--cwd <path>", "Project root path").action((items, options) => runtime.runAdd(items, options));
 }
@@ -109,21 +109,21 @@ function createGenerateCommand(runtime) {
   );
 }
 function createInitCommand(runtime) {
-  return new Command("init").description("Scaffold Admin into a new or existing Next.js app").argument("[name]", "Project name (creates new directory if fresh project)").option("--plugins <plugins>", "Comma-separated content plugin IDs (e.g. blog)").option("--integrations <integrations>", "Comma-separated integration IDs (e.g. r2,resend)").option("--namespace <name>", "Generated admin namespace (e.g. admin, dashboard)").option("-y, --yes", "Skip all prompts (accept defaults)").option("--skip-migration", "Skip running drizzle-kit push after scaffolding").option("--skip-admin-creation", "Skip prompting to create the initial admin user").option("--skip-dev-server-start", "Skip prompting to start the development server").option(
+  return new Command("init").description("Scaffold Admin into a new or existing Next.js app").argument("[name]", "Project name (creates new directory if fresh project)").option("--presets <presets>", "Comma-separated content preset IDs (e.g. blog)").option("--integrations <integrations>", "Comma-separated integration IDs (e.g. r2,resend)").option("--namespace <name>", "Generated admin namespace (e.g. admin, dashboard)").option("-y, --yes", "Skip all prompts (accept defaults)").option("--skip-migration", "Skip running drizzle-kit push after scaffolding").option("--skip-admin-creation", "Skip prompting to create the initial admin user").option("--skip-dev-server-start", "Skip prompting to start the development server").option(
     "--database-url <url>",
     "PostgreSQL database connection string (postgres:// or postgresql://)"
   ).option("--no-vercel", "Disable the Vercel (Neon) provisioning flow (manual connection only)").option("--vercel-plan <id>", "Neon plan id passed to `vercel integration add neon`").option("--skip-deploy", "Skip the post-scaffold deploy to the linked Vercel project").option("--force", "Overwrite all existing Admin files (nuclear option)").action(
     (name, options) => runtime.runInit(name, options)
   );
 }
-function createListPluginsCommand(runtime) {
-  return new Command("list-plugins").description("List available BetterStart plugins").option("--cwd <path>", "Project root path").action((options) => runtime.runListPlugins(options));
+function createListPresetsCommand(runtime) {
+  return new Command("list-presets").description("List available BetterStart presets").option("--cwd <path>", "Project root path").action((options) => runtime.runListPresets(options));
 }
 function createListIntegrationsCommand(runtime) {
   return new Command("list-integrations").description("List available BetterStart integrations").option("--cwd <path>", "Project root path").action((options) => runtime.runListIntegrations(options));
 }
 function createRemoveCommand(runtime) {
-  return new Command("remove").description("Remove installed BetterStart plugins or integrations").argument("<items...>", "Plugin or integration IDs to remove (e.g. blog r2)").option("-f, --force", "Skip confirmation prompt", false).option("--integration", "Remove integration IDs instead of content plugin IDs", false).option("--cwd <path>", "Project root path").action((items, options) => runtime.runRemove(items, options));
+  return new Command("remove").description("Remove installed BetterStart presets or integrations").argument("<items...>", "Preset or integration IDs to remove (e.g. blog r2)").option("-f, --force", "Skip confirmation prompt", false).option("--integration", "Remove integration IDs instead of content preset IDs", false).option("--cwd <path>", "Project root path").action((items, options) => runtime.runRemove(items, options));
 }
 function createRemoveSchemaCommand(runtime) {
   return new Command("remove-schema").description("Remove generated files for a user-authored schema").argument("<schema>", "Schema name to remove (e.g. posts, categories, contact)").option("-f, --force", "Skip confirmation prompt", false).option("--cwd <path>", "Project root path").action(
@@ -191,8 +191,8 @@ export default defineConfig({
     migrationsDir: ${quote(config.database.migrationsDir)},
   },
 
-  plugins: {
-    installed: ${formatArray(config.plugins.installed)},
+  presets: {
+    installed: ${formatArray(config.presets.installed)},
   },
 
   integrations: {
@@ -442,7 +442,7 @@ function getDefaultConfig(srcDir, nextMajorVersion = 16) {
       provider: "postgres",
       migrationsDir: deriveMigrationsDir(namespace)
     },
-    plugins: {
+    presets: {
       installed: []
     },
     integrations: {
@@ -507,7 +507,7 @@ async function resolveConfig(cwd) {
       provider: "postgres",
       migrationsDir: loadedDatabase.migrationsDir
     },
-    plugins: loadedConfig.plugins ?? defaultConfig.plugins,
+    presets: loadedConfig.presets ?? defaultConfig.presets,
     integrations: loadedConfig.integrations ?? defaultConfig.integrations,
     email: loadedConfig.email ?? defaultConfig.email,
     storage: loadedConfig.storage ?? defaultConfig.storage,
@@ -899,8 +899,8 @@ function formatUnknownIntegrationMessage(integrationIds) {
   return `Unknown integration(s): ${integrationIds.join(", ")}. Available for next: ${Object.keys(integrationRegistry).join(", ")}`;
 }
 
-// adapters/next/plugins/blog/plugin.ts
-var blogPlugin = {
+// adapters/next/presets/blog/preset.ts
+var blogPreset = {
   id: "blog",
   title: "Blog",
   description: "Posts content module",
@@ -916,8 +916,8 @@ var blogPlugin = {
   configure: "none"
 };
 
-// adapters/next/plugins/portfolio/plugin.ts
-var portfolioPlugin = {
+// adapters/next/presets/portfolio/preset.ts
+var portfolioPreset = {
   id: "portfolio",
   title: "Portfolio",
   description: "Portfolio content module",
@@ -933,26 +933,26 @@ var portfolioPlugin = {
   configure: "none"
 };
 
-// adapters/next/plugin-registry.ts
-var pluginRegistry = {
-  blog: blogPlugin,
-  portfolio: portfolioPlugin
+// adapters/next/preset-registry.ts
+var presetRegistry = {
+  blog: blogPreset,
+  portfolio: portfolioPreset
 };
-function listPluginDefinitions() {
-  return Object.values(pluginRegistry);
+function listPresetDefinitions() {
+  return Object.values(presetRegistry);
 }
-function getPluginDefinition(pluginId) {
-  const definition = pluginRegistry[pluginId];
+function getPresetDefinition(presetId) {
+  const definition = presetRegistry[presetId];
   if (!definition) {
-    throw new Error(formatUnknownPluginMessage([pluginId]));
+    throw new Error(formatUnknownPresetMessage([presetId]));
   }
   return definition;
 }
-function isPluginId(value) {
-  return value in pluginRegistry;
+function isPresetId(value) {
+  return value in presetRegistry;
 }
-function formatUnknownPluginMessage(pluginIds) {
-  return `Unknown plugin(s): ${pluginIds.join(", ")}. Available for next: ${Object.keys(pluginRegistry).join(", ")}`;
+function formatUnknownPresetMessage(presetIds) {
+  return `Unknown preset(s): ${presetIds.join(", ")}. Available for next: ${Object.keys(presetRegistry).join(", ")}`;
 }
 
 // shared-assets/react-admin/dependencies.ts
@@ -1313,12 +1313,12 @@ function spawnAsync(cmd, args, cwd) {
 function unique(values) {
   return Array.from(new Set(values));
 }
-function getDependencyPlan(pluginIds, integrationIds, includeBiome) {
-  const pluginDependencies = pluginIds.flatMap(
-    (pluginId) => getPluginDefinition(pluginId).packageDependencies
+function getDependencyPlan(presetIds, integrationIds, includeBiome) {
+  const presetDependencies = presetIds.flatMap(
+    (presetId) => getPresetDefinition(presetId).packageDependencies
   );
-  const pluginDevDependencies = pluginIds.flatMap(
-    (pluginId) => getPluginDefinition(pluginId).devDependencies
+  const presetDevDependencies = presetIds.flatMap(
+    (presetId) => getPresetDefinition(presetId).devDependencies
   );
   const integrationDependencies = integrationIds.flatMap(
     (integrationId) => getIntegrationDefinition(integrationId).packageDependencies
@@ -1327,10 +1327,10 @@ function getDependencyPlan(pluginIds, integrationIds, includeBiome) {
     (integrationId) => getIntegrationDefinition(integrationId).devDependencies
   );
   return {
-    dependencies: unique([...CORE_DEPS, ...pluginDependencies, ...integrationDependencies]),
+    dependencies: unique([...CORE_DEPS, ...presetDependencies, ...integrationDependencies]),
     devDependencies: unique([
       ...DEV_DEPS,
-      ...pluginDevDependencies,
+      ...presetDevDependencies,
       ...integrationDevDependencies,
       ...includeBiome ? BIOME_DEV_DEPS : []
     ])
@@ -2916,7 +2916,7 @@ function readIntegrationTemplate(integrationId, relativePath) {
   return fs12.readFileSync(path15.join(integrationTemplateRoot(integrationId), relativePath), "utf-8");
 }
 
-// plugin-engine/ownership.ts
+// preset-engine/ownership.ts
 import fs13 from "fs";
 import path16 from "path";
 function ownershipPath(cwd) {
@@ -3499,16 +3499,16 @@ function getUnusedIntegrationDependencies(config, remainingIntegrations, removed
   const remainingIntegrationDefinitions = remainingIntegrations.map(
     (integrationId) => getIntegrationDefinition(integrationId)
   );
-  const remainingPluginDefinitions = config.plugins.installed.map(
-    (pluginId) => getPluginDefinition(pluginId)
+  const remainingPresetDefinitions = config.presets.installed.map(
+    (presetId) => getPresetDefinition(presetId)
   );
   const remainingDependencies = /* @__PURE__ */ new Set([
     ...remainingIntegrationDefinitions.flatMap((definition) => definition.packageDependencies),
-    ...remainingPluginDefinitions.flatMap((definition) => definition.packageDependencies)
+    ...remainingPresetDefinitions.flatMap((definition) => definition.packageDependencies)
   ]);
   const remainingDevDependencies = /* @__PURE__ */ new Set([
     ...remainingIntegrationDefinitions.flatMap((definition) => definition.devDependencies),
-    ...remainingPluginDefinitions.flatMap((definition) => definition.devDependencies)
+    ...remainingPresetDefinitions.flatMap((definition) => definition.devDependencies)
   ]);
   const corePlan = getDependencyPlan([], [], false);
   const removedDefinition = getIntegrationDefinition(removedIntegrationId);
@@ -3666,12 +3666,12 @@ async function installIntegrations({
     ensureIntegrationDirectFileTargetsAvailable(cwd, config, definition);
     const configureResult = await configureIntegration(definition, cwd, interactive);
     const dependencyPlan = getDependencyPlan(
-      config.plugins.installed,
+      config.presets.installed,
       [...installedIntegrationIds, integrationId],
       includeBiome
     );
     const currentPlan = getDependencyPlan(
-      config.plugins.installed,
+      config.presets.installed,
       installedIntegrationIds,
       includeBiome
     );
@@ -3829,7 +3829,7 @@ function listAvailableIntegrations() {
   return listIntegrationDefinitions();
 }
 
-// adapters/next/plugin-runtime.ts
+// adapters/next/preset-runtime.ts
 import fs22 from "fs";
 import path26 from "path";
 
@@ -17347,14 +17347,14 @@ function runSinglePipeline(schema, cwd, config, options = {}) {
   };
 }
 
-// adapters/next/plugin-template-reader.ts
+// adapters/next/preset-template-reader.ts
 import fs16 from "fs";
 import path20 from "path";
-function pluginTemplateRoot(pluginId) {
-  return resolveCliAssetPath("adapters", "next", "plugins", pluginId);
+function presetTemplateRoot(presetId) {
+  return resolveCliAssetPath("adapters", "next", "presets", presetId);
 }
-function readPluginTemplate(pluginId, relativePath) {
-  return fs16.readFileSync(path20.join(pluginTemplateRoot(pluginId), relativePath), "utf-8");
+function readPresetTemplate(presetId, relativePath) {
+  return fs16.readFileSync(path20.join(presetTemplateRoot(presetId), relativePath), "utf-8");
 }
 
 // adapters/next/snapshots/apply.ts
@@ -18267,62 +18267,62 @@ async function applyGeneratedFiles({
   return summary;
 }
 
-// plugin-engine/manifests.ts
+// preset-engine/manifests.ts
 import fs21 from "fs";
 import path25 from "path";
-function pluginsDir(cwd) {
-  return path25.join(cwd, ".betterstart", "plugins");
+function presetsDir(cwd) {
+  return path25.join(cwd, ".betterstart", "presets");
 }
-function pluginManifestPath(cwd, pluginId) {
-  return path25.join(pluginsDir(cwd), pluginId, "manifest.json");
+function presetManifestPath(cwd, presetId) {
+  return path25.join(presetsDir(cwd), presetId, "manifest.json");
 }
-function loadInstalledPluginManifest(cwd, pluginId) {
-  const filePath = pluginManifestPath(cwd, pluginId);
+function loadInstalledPresetManifest(cwd, presetId) {
+  const filePath = presetManifestPath(cwd, presetId);
   if (!fs21.existsSync(filePath)) {
     return null;
   }
   return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
 }
-function saveInstalledPluginManifest(cwd, manifest) {
-  const filePath = pluginManifestPath(cwd, manifest.id);
+function saveInstalledPresetManifest(cwd, manifest) {
+  const filePath = presetManifestPath(cwd, manifest.id);
   fs21.mkdirSync(path25.dirname(filePath), { recursive: true });
   fs21.writeFileSync(filePath, stringifyProjectJson(manifest), "utf-8");
 }
-function deleteInstalledPluginManifest(cwd, pluginId) {
-  fs21.rmSync(path25.dirname(pluginManifestPath(cwd, pluginId)), {
+function deleteInstalledPresetManifest(cwd, presetId) {
+  fs21.rmSync(path25.dirname(presetManifestPath(cwd, presetId)), {
     recursive: true,
     force: true
   });
 }
 
-// adapters/next/plugin-runtime.ts
+// adapters/next/preset-runtime.ts
 function unique3(values) {
   return Array.from(new Set(values));
 }
-function normalizeInstalledPlugins(config) {
-  return unique3((config.plugins.installed ?? []).filter(isPluginId)).sort();
+function normalizeInstalledPresets(config) {
+  return unique3((config.presets.installed ?? []).filter(isPresetId)).sort();
 }
-function resolvePluginInstallOrder(pluginIds) {
+function resolvePresetInstallOrder(presetIds) {
   const ordered = [];
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  function visit(pluginId) {
-    if (visited.has(pluginId)) {
+  function visit(presetId) {
+    if (visited.has(presetId)) {
       return;
     }
-    if (visiting.has(pluginId)) {
-      throw new Error(`Circular plugin dependency detected at "${pluginId}".`);
+    if (visiting.has(presetId)) {
+      throw new Error(`Circular preset dependency detected at "${presetId}".`);
     }
-    visiting.add(pluginId);
-    for (const dependency of getPluginDefinition(pluginId).dependencies) {
+    visiting.add(presetId);
+    for (const dependency of getPresetDefinition(presetId).dependencies) {
       visit(dependency);
     }
-    visiting.delete(pluginId);
-    visited.add(pluginId);
-    ordered.push(pluginId);
+    visiting.delete(presetId);
+    visited.add(presetId);
+    ordered.push(presetId);
   }
-  for (const pluginId of pluginIds) {
-    visit(pluginId);
+  for (const presetId of presetIds) {
+    visit(presetId);
   }
   return ordered;
 }
@@ -18381,14 +18381,14 @@ async function regenerateBarrels(cwd, config) {
     interactive: false
   });
 }
-function resolvePluginProjectPath(config, outputPath) {
+function resolvePresetProjectPath(config, outputPath) {
   const namespacedOutputPath = applyAdminNamespaceToPath(
     outputPath,
     config.frameworkConfig.next.namespace
   );
   return path26.posix.join(config.paths.admin.replace(/^\.\//, ""), namespacedOutputPath);
 }
-function namespacePluginContent(config, content) {
+function namespacePresetContent(config, content) {
   return applyAdminNamespaceToContent(content, config.frameworkConfig.next.namespace);
 }
 function flattenEnvKeys2(definition) {
@@ -18404,7 +18404,7 @@ function tryReadCoreManagedTemplate2(relativeOutputPath) {
     return null;
   }
 }
-function configurePlugin(definition, cwd) {
+function configurePreset(definition, cwd) {
   const envResult = appendEnvVars(cwd, definition.envSections);
   return {
     configured: true,
@@ -18412,7 +18412,7 @@ function configurePlugin(definition, cwd) {
     updatedEnvKeys: envResult.updated
   };
 }
-function ensurePluginSchemaTargetsAvailable(cwd, config, definition) {
+function ensurePresetSchemaTargetsAvailable(cwd, config, definition) {
   const schemasDir = getSchemasDir(cwd, config);
   for (const schemaFile of definition.schemaFiles) {
     const schemaName = schemaFile.replace(/\.json$/, "");
@@ -18421,21 +18421,21 @@ function ensurePluginSchemaTargetsAvailable(cwd, config, definition) {
       continue;
     }
     const owner = getSchemaOwner(cwd, schemaName);
-    if (owner && owner !== `plugin:${definition.id}`) {
+    if (owner && owner !== `preset:${definition.id}`) {
       throw new Error(
         `Schema "${schemaName}" is already owned by "${owner}". Remove or rename it before installing ${definition.id}.`
       );
     }
     if (!owner) {
       throw new Error(
-        `Schema "${schemaName}" already exists and is not plugin-owned. Remove or rename it before installing ${definition.id}.`
+        `Schema "${schemaName}" already exists and is not preset-owned. Remove or rename it before installing ${definition.id}.`
       );
     }
   }
 }
-function ensurePluginDirectFileTargetsAvailable(cwd, config, definition) {
+function ensurePresetDirectFileTargetsAvailable(cwd, config, definition) {
   for (const file of definition.files) {
-    const projectRelativePath = resolvePluginProjectPath(config, file.outputPath);
+    const projectRelativePath = resolvePresetProjectPath(config, file.outputPath);
     const fullPath = path26.join(cwd, ...projectRelativePath.split("/"));
     if (!fs22.existsSync(fullPath)) {
       continue;
@@ -18447,14 +18447,14 @@ function ensurePluginDirectFileTargetsAvailable(cwd, config, definition) {
       );
     }
     const existingContent = normalizeManagedFileContent2(fs22.readFileSync(fullPath, "utf-8"));
-    const pluginTemplate = normalizeManagedFileContent2(
-      namespacePluginContent(config, readPluginTemplate(definition.id, file.templatePath))
+    const presetTemplate = normalizeManagedFileContent2(
+      namespacePresetContent(config, readPresetTemplate(definition.id, file.templatePath))
     );
-    if (existingContent === pluginTemplate) {
+    if (existingContent === presetTemplate) {
       continue;
     }
     const coreTemplate = tryReadCoreManagedTemplate2(file.outputPath);
-    if (coreTemplate && existingContent === normalizeManagedFileContent2(namespacePluginContent(config, coreTemplate))) {
+    if (coreTemplate && existingContent === normalizeManagedFileContent2(namespacePresetContent(config, coreTemplate))) {
       continue;
     }
     throw new Error(
@@ -18462,15 +18462,15 @@ function ensurePluginDirectFileTargetsAvailable(cwd, config, definition) {
     );
   }
 }
-function writePluginDirectFiles(cwd, config, definition) {
+function writePresetDirectFiles(cwd, config, definition) {
   const writtenFiles = [];
   for (const file of definition.files) {
-    const projectRelativePath = resolvePluginProjectPath(config, file.outputPath);
+    const projectRelativePath = resolvePresetProjectPath(config, file.outputPath);
     const fullPath = path26.join(cwd, ...projectRelativePath.split("/"));
     fs22.mkdirSync(path26.dirname(fullPath), { recursive: true });
     fs22.writeFileSync(
       fullPath,
-      namespacePluginContent(config, readPluginTemplate(definition.id, file.templatePath)),
+      namespacePresetContent(config, readPresetTemplate(definition.id, file.templatePath)),
       "utf-8"
     );
     writtenFiles.push(projectRelativePath);
@@ -18493,7 +18493,7 @@ function cleanupEmptyDirs2(cwd, deletedPaths, config) {
     toProjectAbsolutePath2(cwd, paths.pagesDir),
     toProjectAbsolutePath2(cwd, paths.schemasDir),
     path26.join(projectRoot, ".betterstart"),
-    path26.join(projectRoot, ".betterstart", "plugins"),
+    path26.join(projectRoot, ".betterstart", "presets"),
     path26.join(projectRoot, ".betterstart", "snapshots")
   ]);
   for (const deletedPath of deletedPaths) {
@@ -18511,13 +18511,13 @@ function cleanupEmptyDirs2(cwd, deletedPaths, config) {
     }
   }
 }
-function restoreOrDeletePluginFile(cwd, config, relativeOutputPath) {
-  const projectRelativePath = resolvePluginProjectPath(config, relativeOutputPath);
+function restoreOrDeletePresetFile(cwd, config, relativeOutputPath) {
+  const projectRelativePath = resolvePresetProjectPath(config, relativeOutputPath);
   const fullPath = toProjectAbsolutePath2(cwd, projectRelativePath);
   try {
     const coreTemplate = readTemplate(relativeOutputPath);
     fs22.mkdirSync(path26.dirname(fullPath), { recursive: true });
-    fs22.writeFileSync(fullPath, namespacePluginContent(config, coreTemplate), "utf-8");
+    fs22.writeFileSync(fullPath, namespacePresetContent(config, coreTemplate), "utf-8");
     return null;
   } catch {
     const existed = fs22.existsSync(fullPath);
@@ -18525,7 +18525,7 @@ function restoreOrDeletePluginFile(cwd, config, relativeOutputPath) {
     return existed ? projectRelativePath : null;
   }
 }
-function writePluginSchemas(cwd, config, definition) {
+function writePresetSchemas(cwd, config, definition) {
   const schemasDir = getSchemasDir(cwd, config);
   const writtenSchemaNames = [];
   for (const schemaFile of definition.schemaFiles) {
@@ -18533,7 +18533,7 @@ function writePluginSchemas(cwd, config, definition) {
     fs22.mkdirSync(path26.dirname(outputPath), { recursive: true });
     fs22.writeFileSync(
       outputPath,
-      readPluginTemplate(definition.id, `schemas/${schemaFile}`),
+      readPresetTemplate(definition.id, `schemas/${schemaFile}`),
       "utf-8"
     );
     writtenSchemaNames.push(schemaFile.replace(/\.json$/, ""));
@@ -18546,7 +18546,7 @@ function removePath(cwd, filePath) {
   fs22.rmSync(fullPath, { recursive: true, force: true });
   return existed;
 }
-function removePluginSchemas(cwd, config, manifest) {
+function removePresetSchemas(cwd, config, manifest) {
   const paths = resolveProjectPaths(config);
   const deletedPaths = [];
   const manifestsBySchema = /* @__PURE__ */ new Map();
@@ -18561,9 +18561,9 @@ function removePluginSchemas(cwd, config, manifest) {
   }
   if (missingManifests.length > 0) {
     throw new Error(
-      `Cannot remove ${manifest.id}. Missing snapshot manifest${missingManifests.length === 1 ? "" : "s"} for plugin-owned schema${missingManifests.length === 1 ? "" : "s"}: ${missingManifests.join(
+      `Cannot remove ${manifest.id}. Missing snapshot manifest${missingManifests.length === 1 ? "" : "s"} for preset-owned schema${missingManifests.length === 1 ? "" : "s"}: ${missingManifests.join(
         ", "
-      )}. Re-run \`pnpm betterstart init --force\` to restore snapshot state before removing the plugin.`
+      )}. Re-run \`pnpm betterstart init --force\` to restore snapshot state before removing the preset.`
     );
   }
   for (const schemaName of manifest.ownedSchemas) {
@@ -18646,14 +18646,14 @@ function findBlockingSchemaDependencies(cwd, config, ownedSchemas) {
     );
     if (relationshipTargets.length > 0) {
       blockers.push(
-        `${schemaName} references plugin-owned schema(s): ${relationshipTargets.join(", ")}`
+        `${schemaName} references preset-owned schema(s): ${relationshipTargets.join(", ")}`
       );
     }
   }
   return blockers;
 }
-function getUnusedPluginDependencies(remainingPlugins, removedPluginId, installedIntegrations) {
-  const remainingDefinitions = remainingPlugins.map((pluginId) => getPluginDefinition(pluginId));
+function getUnusedPresetDependencies(remainingPresets, removedPresetId, installedIntegrations) {
+  const remainingDefinitions = remainingPresets.map((presetId) => getPresetDefinition(presetId));
   const integrationDefinitions = installedIntegrations.map(
     (integrationId) => getIntegrationDefinition(integrationId)
   );
@@ -18666,7 +18666,7 @@ function getUnusedPluginDependencies(remainingPlugins, removedPluginId, installe
     ...integrationDefinitions.flatMap((definition) => definition.devDependencies)
   ]);
   const corePlan = getDependencyPlan([], [], false);
-  const removedDefinition = getPluginDefinition(removedPluginId);
+  const removedDefinition = getPresetDefinition(removedPresetId);
   return {
     dependencies: removedDefinition.packageDependencies.filter(
       (dependency) => !remainingDependencies.has(dependency) && !corePlan.dependencies.includes(dependency)
@@ -18676,39 +18676,39 @@ function getUnusedPluginDependencies(remainingPlugins, removedPluginId, installe
     )
   };
 }
-function parsePluginList(value) {
+function parsePresetList(value) {
   if (!value) {
     return [];
   }
-  const pluginIds = value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  const invalid = pluginIds.filter((pluginId) => !isPluginId(pluginId));
+  const presetIds = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  const invalid = presetIds.filter((presetId) => !isPresetId(presetId));
   if (invalid.length > 0) {
-    throw new Error(formatUnknownPluginMessage(invalid));
+    throw new Error(formatUnknownPresetMessage(invalid));
   }
-  return unique3(pluginIds);
+  return unique3(presetIds);
 }
-function getInstalledPlugins(config) {
-  return normalizeInstalledPlugins(config);
+function getInstalledPresets(config) {
+  return normalizeInstalledPresets(config);
 }
-function syncInstalledPluginManifests(cwd, config) {
-  for (const pluginId of normalizeInstalledPlugins(config)) {
-    const manifest = loadInstalledPluginManifest(cwd, pluginId);
+function syncInstalledPresetManifests(cwd, config) {
+  for (const presetId of normalizeInstalledPresets(config)) {
+    const manifest = loadInstalledPresetManifest(cwd, presetId);
     if (!manifest) {
       continue;
     }
-    const definition = getPluginDefinition(pluginId);
+    const definition = getPresetDefinition(presetId);
     const nextManifest = {
       ...manifest,
       version: definition.version,
       kind: definition.kind,
-      ownedFiles: definition.files.map((file) => resolvePluginProjectPath(config, file.outputPath)),
+      ownedFiles: definition.files.map((file) => resolvePresetProjectPath(config, file.outputPath)),
       packageDependencies: definition.packageDependencies,
       devDependencies: definition.devDependencies,
       dependencies: definition.dependencies,
       conflicts: definition.conflicts
     };
     if (JSON.stringify(nextManifest) !== JSON.stringify(manifest)) {
-      saveInstalledPluginManifest(cwd, nextManifest);
+      saveInstalledPresetManifest(cwd, nextManifest);
     }
   }
 }
@@ -18725,35 +18725,35 @@ function ensureUserSchemaOwnership(cwd, schemaName) {
     setSchemaOwner(cwd, schemaName, "user");
   }
 }
-async function installPlugins({
+async function installPresets({
   cwd,
   config,
   pm,
-  pluginIds,
+  presetIds,
   includeBiome
 }) {
-  const orderedPluginIds = resolvePluginInstallOrder(pluginIds);
-  const installedPluginIds = normalizeInstalledPlugins(config);
+  const orderedPresetIds = resolvePresetInstallOrder(presetIds);
+  const installedPresetIds = normalizeInstalledPresets(config);
   const skipped = [];
   const installed2 = [];
   const warnings = [];
   ensureSnapshotGitFiles(cwd);
-  for (const pluginId of orderedPluginIds) {
-    if (installedPluginIds.includes(pluginId)) {
-      skipped.push(pluginId);
+  for (const presetId of orderedPresetIds) {
+    if (installedPresetIds.includes(presetId)) {
+      skipped.push(presetId);
       continue;
     }
-    const definition = getPluginDefinition(pluginId);
-    ensurePluginSchemaTargetsAvailable(cwd, config, definition);
-    ensurePluginDirectFileTargetsAvailable(cwd, config, definition);
-    const configureResult = configurePlugin(definition, cwd);
+    const definition = getPresetDefinition(presetId);
+    ensurePresetSchemaTargetsAvailable(cwd, config, definition);
+    ensurePresetDirectFileTargetsAvailable(cwd, config, definition);
+    const configureResult = configurePreset(definition, cwd);
     const dependencyPlan = getDependencyPlan(
-      [...installedPluginIds, pluginId],
+      [...installedPresetIds, presetId],
       config.integrations.installed,
       includeBiome
     );
     const currentPlan = getDependencyPlan(
-      installedPluginIds,
+      installedPresetIds,
       config.integrations.installed,
       includeBiome
     );
@@ -18773,23 +18773,23 @@ async function installPlugins({
         devDependencies: dependencyDiff.devDependencies
       });
       if (!result.success) {
-        throw new Error(result.error ?? `Failed to install dependencies for ${pluginId}.`);
+        throw new Error(result.error ?? `Failed to install dependencies for ${presetId}.`);
       }
     }
-    const writtenFiles = writePluginDirectFiles(cwd, config, definition);
-    const writtenSchemas = writePluginSchemas(cwd, config, definition);
+    const writtenFiles = writePresetDirectFiles(cwd, config, definition);
+    const writtenSchemas = writePresetSchemas(cwd, config, definition);
     for (const schemaName of writtenSchemas) {
       const loaded = loadSchema(getSchemasDir(cwd, config), schemaName);
-      await applyGeneratedSchema(cwd, config, loaded, pluginId);
-      setSchemaOwner(cwd, schemaName, `plugin:${pluginId}`);
+      await applyGeneratedSchema(cwd, config, loaded, presetId);
+      setSchemaOwner(cwd, schemaName, `preset:${presetId}`);
     }
     if (writtenSchemas.length > 0) {
       await regenerateBarrels(cwd, config);
     }
-    installedPluginIds.push(pluginId);
-    config.plugins.installed = unique3(installedPluginIds).sort();
+    installedPresetIds.push(presetId);
+    config.presets.installed = unique3(installedPresetIds).sort();
     const manifest = {
-      id: pluginId,
+      id: presetId,
       version: definition.version,
       kind: definition.kind,
       ownedSchemas: writtenSchemas,
@@ -18802,9 +18802,9 @@ async function installPlugins({
       conflicts: definition.conflicts,
       installedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    saveInstalledPluginManifest(cwd, manifest);
+    saveInstalledPresetManifest(cwd, manifest);
     writeConfigFile(cwd, config);
-    installed2.push(pluginId);
+    installed2.push(presetId);
   }
   return {
     installed: installed2,
@@ -18813,58 +18813,58 @@ async function installPlugins({
     config
   };
 }
-async function removePlugins({
+async function removePresets({
   cwd,
   config,
   pm,
-  pluginIds
+  presetIds
 }) {
-  const installedPlugins = normalizeInstalledPlugins(config);
+  const installedPresets = normalizeInstalledPresets(config);
   const removed = [];
   const warnings = [];
-  for (const pluginId of pluginIds) {
-    if (!installedPlugins.includes(pluginId)) {
-      warnings.push(`${pluginId} is not installed.`);
+  for (const presetId of presetIds) {
+    if (!installedPresets.includes(presetId)) {
+      warnings.push(`${presetId} is not installed.`);
       continue;
     }
-    const manifest = loadInstalledPluginManifest(cwd, pluginId);
+    const manifest = loadInstalledPresetManifest(cwd, presetId);
     if (!manifest) {
-      throw new Error(`Missing manifest for installed plugin "${pluginId}".`);
+      throw new Error(`Missing manifest for installed preset "${presetId}".`);
     }
-    const dependents = installedPlugins.filter((installedPluginId) => {
-      if (installedPluginId === pluginId) {
+    const dependents = installedPresets.filter((installedPresetId) => {
+      if (installedPresetId === presetId) {
         return false;
       }
-      return getPluginDefinition(installedPluginId).dependencies.includes(pluginId);
+      return getPresetDefinition(installedPresetId).dependencies.includes(presetId);
     });
     if (dependents.length > 0) {
       throw new Error(
-        `Cannot remove ${pluginId}. The following plugins depend on it: ${dependents.join(", ")}`
+        `Cannot remove ${presetId}. The following presets depend on it: ${dependents.join(", ")}`
       );
     }
     const blockers = findBlockingSchemaDependencies(cwd, config, manifest.ownedSchemas);
     if (blockers.length > 0) {
-      throw new Error(`Cannot remove ${pluginId}:
+      throw new Error(`Cannot remove ${presetId}:
 - ${blockers.join("\n- ")}`);
     }
-    const deletedPaths = removePluginSchemas(cwd, config, manifest);
+    const deletedPaths = removePresetSchemas(cwd, config, manifest);
     for (const filePath of manifest.ownedFiles) {
       const relativeOutputPath = filePath.replace(`${config.paths.admin.replace(/^\.\//, "")}/`, "");
-      const deletedPath = restoreOrDeletePluginFile(cwd, config, relativeOutputPath);
+      const deletedPath = restoreOrDeletePresetFile(cwd, config, relativeOutputPath);
       if (deletedPath) {
         deletedPaths.push(deletedPath);
       }
     }
-    deleteInstalledPluginManifest(cwd, pluginId);
-    const nextInstalledPlugins = installedPlugins.filter(
-      (installedPluginId) => installedPluginId !== pluginId
+    deleteInstalledPresetManifest(cwd, presetId);
+    const nextInstalledPresets = installedPresets.filter(
+      (installedPresetId) => installedPresetId !== presetId
     );
-    installedPlugins.splice(0, installedPlugins.length, ...nextInstalledPlugins);
-    config.plugins.installed = [...nextInstalledPlugins].sort();
-    const remainingPlugins = normalizeInstalledPlugins(config);
-    const dependencyDiff = getUnusedPluginDependencies(
-      remainingPlugins,
-      pluginId,
+    installedPresets.splice(0, installedPresets.length, ...nextInstalledPresets);
+    config.presets.installed = [...nextInstalledPresets].sort();
+    const remainingPresets = normalizeInstalledPresets(config);
+    const dependencyDiff = getUnusedPresetDependencies(
+      remainingPresets,
+      presetId,
       config.integrations.installed
     );
     if (dependencyDiff.dependencies.length > 0 || dependencyDiff.devDependencies.length > 0) {
@@ -18875,12 +18875,12 @@ async function removePlugins({
         devDependencies: dependencyDiff.devDependencies
       });
       if (!result.success) {
-        warnings.push(result.error ?? `Failed to remove dependencies for ${pluginId}.`);
+        warnings.push(result.error ?? `Failed to remove dependencies for ${presetId}.`);
       }
     }
     const usedEnvKeys = new Set(
-      remainingPlugins.flatMap(
-        (installedPluginId) => flattenEnvKeys2(getPluginDefinition(installedPluginId))
+      remainingPresets.flatMap(
+        (installedPresetId) => flattenEnvKeys2(getPresetDefinition(installedPresetId))
       )
     );
     const removableEnvKeys = manifest.envKeys.filter((envKey) => !usedEnvKeys.has(envKey));
@@ -18892,7 +18892,7 @@ async function removePlugins({
     }
     cleanupEmptyDirs2(cwd, deletedPaths, config);
     writeConfigFile(cwd, config);
-    removed.push(pluginId);
+    removed.push(presetId);
   }
   return {
     removed,
@@ -18900,8 +18900,8 @@ async function removePlugins({
     config
   };
 }
-function listAvailablePlugins() {
-  return listPluginDefinitions();
+function listAvailablePresets() {
+  return listPresetDefinitions();
 }
 
 // adapters/next/commands/add.ts
@@ -18917,7 +18917,7 @@ function printAddNextSteps(installKind, hasSchemaChanges, result, adminRoutePath
 }
 async function runAddCommand(items, options) {
   const installIntegrationsMode = Boolean(options.integration);
-  const pluginIds = items.filter(isPluginId);
+  const presetIds = items.filter(isPresetId);
   const integrationIds = items.filter(isIntegrationId);
   if (!installIntegrationsMode && integrationIds.length > 0) {
     p4.log.error(
@@ -18925,14 +18925,14 @@ async function runAddCommand(items, options) {
     );
     process.exit(1);
   }
-  if (installIntegrationsMode && pluginIds.length > 0) {
-    p4.log.error(`Plugin IDs cannot be installed with --integration: ${pluginIds.join(", ")}`);
+  if (installIntegrationsMode && presetIds.length > 0) {
+    p4.log.error(`Preset IDs cannot be installed with --integration: ${presetIds.join(", ")}`);
     process.exit(1);
   }
-  const invalidItems = installIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((pluginId) => !isPluginId(pluginId));
+  const invalidItems = installIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((presetId) => !isPresetId(presetId));
   if (invalidItems.length > 0) {
     p4.log.error(
-      installIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPluginMessage(invalidItems)
+      installIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPresetMessage(invalidItems)
     );
     process.exit(1);
   }
@@ -18984,16 +18984,16 @@ async function runAddCommand(items, options) {
     p4.outro(messages.join("\n"));
     return;
   }
-  const invalidPlugins = items.filter((pluginId) => !isPluginId(pluginId));
-  if (invalidPlugins.length > 0) {
-    p4.log.error(formatUnknownPluginMessage(invalidPlugins));
+  const invalidPresets = items.filter((presetId) => !isPresetId(presetId));
+  if (invalidPresets.length > 0) {
+    p4.log.error(formatUnknownPresetMessage(invalidPresets));
     process.exit(1);
   }
-  const result = await installPlugins({
+  const result = await installPresets({
     cwd,
     config,
     pm,
-    pluginIds,
+    presetIds,
     interactive: !options.yes,
     includeBiome: false
   });
@@ -19006,7 +19006,7 @@ async function runAddCommand(items, options) {
     p4.note(result.warnings.join("\n"), "Warnings");
   }
   const installedSchemaNames = result.installed.flatMap(
-    (pluginId) => getPluginDefinition(pluginId).schemaFiles.map((schemaFile) => schemaFile.replace(/\.json$/, ""))
+    (presetId) => getPresetDefinition(presetId).schemaFiles.map((schemaFile) => schemaFile.replace(/\.json$/, ""))
   );
   const hasSchemaChanges = installedSchemaNames.length > 0;
   const conflictPaths = scanConflictPaths(cwd);
@@ -19018,10 +19018,10 @@ async function runAddCommand(items, options) {
     showNextSteps: false
   });
   if (conflictPaths.length === 0) {
-    printAddNextSteps("plugin", hasSchemaChanges, postGenerateResult, adminRoutePath);
+    printAddNextSteps("preset", hasSchemaChanges, postGenerateResult, adminRoutePath);
   }
   p4.outro(
-    `Installed plugin${result.installed.length === 1 ? "" : "s"}: ${result.installed.join(", ")}`
+    `Installed preset${result.installed.length === 1 ? "" : "s"}: ${result.installed.join(", ")}`
   );
 }
 
@@ -20129,7 +20129,7 @@ function validateIntegrationRequirements(loaded, config) {
 }
 function runPipeline(loaded, cwd, config, options) {
   const owner = getSchemaOwner(cwd, loaded.schema.name);
-  const outputNamespace = owner === "core" ? "core" : owner?.startsWith("plugin:") ? owner.replace(/^plugin:/, "") : void 0;
+  const outputNamespace = owner === "core" ? "core" : owner?.startsWith("preset:") ? owner.replace(/^preset:/, "") : void 0;
   if (loaded.type === "form") {
     return runFormPipeline(loaded.schema, cwd, config, {
       force: options.force,
@@ -21098,8 +21098,8 @@ function schemaNameFromLoaded(loaded) {
 function resolveSchemaOwner(cwd, schemaName) {
   return getSchemaOwner(cwd, schemaName) ?? (schemaName === "settings" ? "core" : "user");
 }
-function pluginIdFromOwner(owner) {
-  return owner.startsWith("plugin:") ? owner.replace(/^plugin:/, "") : null;
+function presetIdFromOwner(owner) {
+  return owner.startsWith("preset:") ? owner.replace(/^preset:/, "") : null;
 }
 async function promptConfirm3(message, initialValue = true) {
   return promptConfirm2(ADD_FIELD_PROMPT_CONTEXT, message, initialValue);
@@ -21170,7 +21170,7 @@ async function createInteractiveInsertion2(loaded, schemasDir) {
   return createInteractiveInsertion(ADD_FIELD_PROMPT_CONTEXT, loaded, schemasDir);
 }
 function printPreview(loaded, owner, firstTimeGeneration, insertion, options) {
-  const pluginId = pluginIdFromOwner(owner);
+  const presetId = presetIdFromOwner(owner);
   const lines = [
     `schema: ${loaded.name} (${formatKind(loaded.kind)})`,
     `display: ${getSchemaDisplayName(loaded)}`,
@@ -21180,9 +21180,9 @@ function printPreview(loaded, owner, firstTimeGeneration, insertion, options) {
     `migration: ${options.skipMigration ? "skip db:push" : "run post-generate default"}`,
     `merge conflicts: ${options.acceptGenerated || options.yes ? "accept generated output" : "write conflict markers"}`
   ];
-  if (pluginId) {
+  if (presetId) {
     lines.push(
-      `warning: plugin-owned schema; uninstalling "${pluginId}" can remove this schema and generated output`
+      `warning: preset-owned schema; uninstalling "${presetId}" can remove this schema and generated output`
     );
   }
   if (firstTimeGeneration) {
@@ -21202,10 +21202,10 @@ ${stringifyProjectJson(insertion.field).trim()}`,
 }
 async function confirmWarningCases(owner, firstTimeGeneration, requiredPersistedField, nonInteractive, yes, extraWarnings = []) {
   const warnings = [...extraWarnings];
-  const pluginId = pluginIdFromOwner(owner);
-  if (pluginId) {
+  const presetId = presetIdFromOwner(owner);
+  if (presetId) {
     warnings.push(
-      `Schema is plugin-owned by "${pluginId}". Removing that plugin can remove the customized schema JSON, generated files, snapshots, and ownership entry.`
+      `Schema is preset-owned by "${presetId}". Removing that preset can remove the customized schema JSON, generated files, snapshots, and ownership entry.`
     );
   }
   if (firstTimeGeneration) {
@@ -21240,8 +21240,8 @@ function collectRelationshipTargetWarnings(cwd, owner, field) {
   collectRelationshipTargets(field, targetNames);
   return Array.from(targetNames).map((targetName) => {
     const targetOwner = getSchemaOwner(cwd, targetName);
-    const pluginId = targetOwner ? pluginIdFromOwner(targetOwner) : null;
-    return pluginId ? `This user-owned schema references plugin-owned schema "${targetName}". Removing plugin "${pluginId}" may affect that relationship.` : null;
+    const presetId = targetOwner ? presetIdFromOwner(targetOwner) : null;
+    return presetId ? `This user-owned schema references preset-owned schema "${targetName}". Removing preset "${presetId}" may affect that relationship.` : null;
   }).filter((warning) => Boolean(warning));
 }
 function collectRelationshipTargets(field, targets) {
@@ -22032,7 +22032,7 @@ function openBrowser(url) {
   }
 }
 
-// adapters/next/init/prompts/plugins.ts
+// adapters/next/init/prompts/presets.ts
 import { styleText } from "util";
 import * as p12 from "@clack/prompts";
 
@@ -22183,13 +22183,13 @@ function scaffoldEnv(cwd, options) {
   return appendEnvVars(cwd, sections, overwrite);
 }
 
-// adapters/next/init/prompts/plugins.ts
+// adapters/next/init/prompts/presets.ts
 function maskBlobToken(token) {
   const match = /^(vercel_blob_rw_[A-Za-z0-9]+)_/.exec(token);
   if (match) return `${match[1]}_***`;
   return `${token.slice(0, 8)}***`;
 }
-async function promptPlugins(cwd, options = {}) {
+async function promptPresets(cwd, options = {}) {
   const sections = [];
   const overwriteKeys = /* @__PURE__ */ new Set();
   const mergeIntegrationConfig = (collected) => {
@@ -22261,7 +22261,7 @@ async function promptPlugins(cwd, options = {}) {
   } else {
     storageStep.confirm();
   }
-  const selectedPlugins = await p12.multiselect({
+  const selectedPresets = await p12.multiselect({
     message: "Select presets",
     options: [
       {
@@ -22273,7 +22273,7 @@ async function promptPlugins(cwd, options = {}) {
     required: false,
     initialValues: ["blog"]
   });
-  if (p12.isCancel(selectedPlugins)) {
+  if (p12.isCancel(selectedPresets)) {
     p12.cancel("Setup cancelled.");
     process.exit(0);
   }
@@ -22291,7 +22291,7 @@ async function promptPlugins(cwd, options = {}) {
     integrations.push("vercel-blob");
   }
   return {
-    plugins: selectedPlugins,
+    presets: selectedPresets,
     integrations,
     storage,
     integrationConfig: { sections, overwriteKeys }
@@ -24889,6 +24889,8 @@ import * as p16 from "@clack/prompts";
 import pc5 from "picocolors";
 var PROVISION_TIMEOUT_MS2 = 18e4;
 var INTERACTIVE_PROVISION_TIMEOUT_MS2 = 6e5;
+var RESOURCE_CONNECT_TIMEOUT_MS = 6e4;
+var NEON_FREE_PLAN_ID = "free_v3";
 async function provisionNeonInteractive(runner, cwd, options) {
   const quietSpinner = spinner2();
   quietSpinner.start("Creating your Neon database");
@@ -24953,12 +24955,54 @@ function readNeonProvisionInfo(stdout) {
   const info = {};
   if (meta.dashboardUrl) info.dashboardUrl = meta.dashboardUrl;
   if (meta.ssoUrl?.resource) info.resourceUrl = meta.ssoUrl.resource;
+  if (meta.resource?.name) info.resourceName = meta.resource.name;
+  const connectWarning = (meta.warnings ?? []).some((warning) => /failed to connect/i.test(warning));
+  if (meta.envPulled === false || connectWarning) info.connectedToProject = false;
+  else if (meta.envPulled === true) info.connectedToProject = true;
   return info;
 }
+async function replaceNeonProjectConnection(runner, cwd, resourceName, env) {
+  const list = await runVercel(runner, ["integration", "list", "--format", "json"], {
+    cwd,
+    mode: "capture",
+    timeoutMs: RESOURCE_CONNECT_TIMEOUT_MS,
+    env
+  });
+  if (list.success) {
+    const payload = parseVercelJson(list.stdout);
+    for (const resource of payload?.resources ?? []) {
+      if (!resource.name || resource.name === resourceName) continue;
+      if (resource.product && !/neon/i.test(resource.product)) continue;
+      await runVercel(runner, ["integration-resource", "disconnect", resource.name, "--yes"], {
+        cwd,
+        mode: "capture",
+        timeoutMs: RESOURCE_CONNECT_TIMEOUT_MS,
+        env
+      });
+    }
+  }
+  const connect = await runVercel(
+    runner,
+    ["integration-resource", "connect", resourceName, "--yes"],
+    {
+      cwd,
+      mode: "capture",
+      timeoutMs: RESOURCE_CONNECT_TIMEOUT_MS,
+      env
+    }
+  );
+  return connect.success;
+}
 function neonAddArgs(options) {
-  const addArgs = ["integration", "add", "neon", "--format", "json"];
-  if (options.plan) addArgs.push("--plan", options.plan);
-  return addArgs;
+  return [
+    "integration",
+    "add",
+    "neon",
+    "--format",
+    "json",
+    "--plan",
+    options.plan ?? NEON_FREE_PLAN_ID
+  ];
 }
 function connectedNeonAddArgs(options) {
   const addArgs = ["integration", "add", "neon"];
@@ -24980,14 +25024,28 @@ async function runVercelNeonFlow(options) {
       p17.log.warn(authFailureMessage(auth.reason));
       return { ok: false };
     }
+    const linkPreExisted = Boolean(readLinkedProjectId(options.cwd));
     const linkLinePrinted = await ensureLinkedProject(runner, options.cwd, options.projectName, env);
+    const preExistingDbUrl = linkPreExisted ? await pullPreExistingDbUrl(runner, options.cwd, env) : void 0;
     const neon = await provisionNeonForMode(runner, options);
     if (neon.failure) {
       p17.log.warn(neonFailureMessage(neon.failure));
       if (neon.detail) p17.log.message(pc6.dim(neon.detail));
       return { ok: false };
     }
-    const databaseUrl = await pullNeonDatabaseUrl(runner, options.cwd, env);
+    if (neon.connectedToProject === false && neon.resourceName) {
+      const connectSpinner = spinner2();
+      connectSpinner.start("Connecting the database to your Vercel project");
+      await replaceNeonProjectConnection(runner, options.cwd, neon.resourceName, env);
+      connectSpinner.clear();
+    }
+    let databaseUrl = await pullNeonDatabaseUrl(runner, options.cwd, env);
+    if (databaseUrl && databaseUrl === preExistingDbUrl) {
+      databaseUrl = void 0;
+      p17.log.warn(
+        "The linked Vercel project still returns its previous DATABASE_URL \u2014 the new database could not be connected."
+      );
+    }
     const dismissSignedInNote = databaseUrl && auth.dismissNote && !neon.usedTerminalFallback ? () => auth.dismissNote?.({ linesBelow: linkLinePrinted ? 1 : 0 }) : void 0;
     return {
       ok: true,
@@ -25083,7 +25141,7 @@ async function runVercelDeployFlow(options) {
       );
     }
     const deploySpinner = spinner2();
-    deploySpinner.start("Deploying to Vercel (this may take a few minutes)");
+    deploySpinner.start("Deploying to Vercel, This may take a moment");
     let deploy;
     try {
       deploy = await deployVercelProject(runner, options.cwd, env);
@@ -25121,6 +25179,13 @@ async function ensureLinkedProject(runner, cwd, projectName, env) {
   );
   return true;
 }
+async function pullPreExistingDbUrl(runner, cwd, env) {
+  const snapshotSpinner = spinner2();
+  snapshotSpinner.start("Checking the linked Vercel project");
+  const url = await pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, env);
+  snapshotSpinner.clear();
+  return url;
+}
 async function pullNeonDatabaseUrl(runner, cwd, env) {
   const neonSpinner = spinner2();
   neonSpinner.start("Retrieving DATABASE_URL from Vercel");
@@ -25822,9 +25887,9 @@ async function runInitCommand(name, options) {
       databaseStep.confirm();
     }
   }
-  const selectedPlugins = (() => {
-    if (options.plugins) {
-      return parsePluginList(options.plugins);
+  const selectedPresets = (() => {
+    if (options.presets) {
+      return parsePresetList(options.presets);
     }
     return [];
   })();
@@ -25838,15 +25903,15 @@ async function runInitCommand(name, options) {
     sections: [],
     overwriteKeys: /* @__PURE__ */ new Set()
   };
-  let pluginSelection;
+  let presetSelection;
   const vercelBlobAllowed = options.vercel !== false;
-  if (selectedPlugins.length > 0 || selectedIntegrations.length > 0) {
-    pluginSelection = {
-      plugins: selectedPlugins,
+  if (selectedPresets.length > 0 || selectedIntegrations.length > 0) {
+    presetSelection = {
+      presets: selectedPresets,
       integrations: selectedIntegrations,
       storage: selectedIntegrations.includes("vercel-blob") ? "vercel-blob" : selectedIntegrations.includes("r2") ? "r2" : "local"
     };
-    if (pluginSelection.storage === "vercel-blob" && !readEnvVar(cwd, "BLOB_READ_WRITE_TOKEN")?.trim() && vercelBlobAllowed && (!options.yes || process.env.VERCEL_TOKEN)) {
+    if (presetSelection.storage === "vercel-blob" && !readEnvVar(cwd, "BLOB_READ_WRITE_TOKEN")?.trim() && vercelBlobAllowed && (!options.yes || process.env.VERCEL_TOKEN)) {
       const flow = await runVercelBlobFlow({
         cwd,
         projectName,
@@ -25871,15 +25936,15 @@ async function runInitCommand(name, options) {
       }
     }
   } else if (options.yes) {
-    pluginSelection = { plugins: [], integrations: [], storage: "local" };
+    presetSelection = { presets: [], integrations: [], storage: "local" };
   } else {
     dismissVercelSignedInNote?.();
-    const promptResult = await promptPlugins(cwd, {
+    const promptResult = await promptPresets(cwd, {
       provisionVercelBlob: vercelBlobAllowed ? () => runVercelBlobFlow({ cwd, projectName, interactive: true, env: process.env }) : void 0
     });
     collectedIntegrationConfig = promptResult.integrationConfig;
-    pluginSelection = {
-      plugins: promptResult.plugins,
+    presetSelection = {
+      presets: promptResult.presets,
       integrations: promptResult.integrations,
       storage: promptResult.storage
     };
@@ -25897,7 +25962,7 @@ async function runInitCommand(name, options) {
   scaffoldBase({
     cwd,
     config,
-    includeEmailTemplatesDir: pluginSelection.integrations.some(isEmailProviderIntegration)
+    includeEmailTemplatesDir: presetSelection.integrations.some(isEmailProviderIntegration)
   });
   s.message("TypeScript aliases");
   scaffoldTsconfig(cwd, config);
@@ -25962,7 +26027,7 @@ async function runInitCommand(name, options) {
   }
   const coreDependencyPlan = getDependencyPlan([], [], project2.linter.type === "none");
   const cliDependencyPlan = getCliDependencySyncPlan(cwd);
-  s.start("Installing dependencies (this may take a minute)");
+  s.start("Installing dependencies, This may take a moment");
   const depsResult = await installDependenciesAsync({
     cwd,
     pm,
@@ -25996,29 +26061,29 @@ async function runInitCommand(name, options) {
   const coreSchemasResult = scaffoldCoreSchemas({ cwd, config });
   s.stop("");
   process.stdout.write("\x1B[2A\x1B[J");
-  const pluginInstallResult = pluginSelection.plugins.length > 0 ? (() => {
-    s.start(`Installing plugins: ${pluginSelection.plugins.join(", ")}`);
-    return installPlugins({
+  const presetInstallResult = presetSelection.presets.length > 0 ? (() => {
+    s.start(`Installing presets: ${presetSelection.presets.join(", ")}`);
+    return installPresets({
       cwd,
       config,
       pm,
-      pluginIds: pluginSelection.plugins,
+      presetIds: presetSelection.presets,
       interactive: !options.yes,
       includeBiome: project2.linter.type === "none"
     });
   })() : Promise.resolve({ installed: [], skipped: [], warnings: [], config });
-  const resolvedPluginInstallResult = await pluginInstallResult;
-  if (pluginSelection.plugins.length > 0) {
+  const resolvedPresetInstallResult = await presetInstallResult;
+  if (presetSelection.presets.length > 0) {
     s.stop("");
     process.stdout.write("\x1B[2A\x1B[J");
   }
-  const integrationInstallResult = pluginSelection.integrations.length > 0 ? (() => {
-    s.start(`Installing integrations: ${pluginSelection.integrations.join(", ")}`);
+  const integrationInstallResult = presetSelection.integrations.length > 0 ? (() => {
+    s.start(`Installing integrations: ${presetSelection.integrations.join(", ")}`);
     return installIntegrations({
       cwd,
-      config: resolvedPluginInstallResult.config,
+      config: resolvedPresetInstallResult.config,
       pm,
-      integrationIds: pluginSelection.integrations,
+      integrationIds: presetSelection.integrations,
       // Secrets were already collected up front and persisted/written to
       // .env.local, so the install runs without prompting (rule: no
       // mid-scaffold input).
@@ -26029,10 +26094,10 @@ async function runInitCommand(name, options) {
     installed: [],
     skipped: [],
     warnings: [],
-    config: resolvedPluginInstallResult.config
+    config: resolvedPresetInstallResult.config
   });
   const resolvedIntegrationInstallResult = await integrationInstallResult;
-  if (pluginSelection.integrations.length > 0) {
+  if (presetSelection.integrations.length > 0) {
     s.stop("");
     process.stdout.write("\x1B[2A\x1B[J");
   }
@@ -26041,7 +26106,7 @@ async function runInitCommand(name, options) {
   for (const err of coreSchemasResult.errors) {
     p18.log.warn(`Core schemas: ${err}`);
   }
-  for (const warning of resolvedPluginInstallResult.warnings) {
+  for (const warning of resolvedPresetInstallResult.warnings) {
     p18.log.warn(warning);
   }
   for (const warning of resolvedIntegrationInstallResult.warnings) {
@@ -26804,19 +26869,19 @@ async function runListIntegrationsCommand(options) {
   );
 }
 
-// adapters/next/commands/list-plugins.ts
+// adapters/next/commands/list-presets.ts
 import path52 from "path";
 import * as p20 from "@clack/prompts";
-async function runListPluginsCommand(options) {
+async function runListPresetsCommand(options) {
   const cwd = options.cwd ? path52.resolve(options.cwd) : process.cwd();
   const config = await resolveConfig(cwd);
-  const installedPlugins = new Set(config.plugins.installed);
-  const lines = listAvailablePlugins().map((plugin) => {
-    const status = installedPlugins.has(plugin.id) ? "installed" : "available";
-    return `${plugin.id.padEnd(10)} ${status.padEnd(10)} ${plugin.kind.padEnd(12)} ${plugin.description}`;
+  const installedPresets = new Set(config.presets.installed);
+  const lines = listAvailablePresets().map((preset) => {
+    const status = installedPresets.has(preset.id) ? "installed" : "available";
+    return `${preset.id.padEnd(10)} ${status.padEnd(10)} ${preset.kind.padEnd(12)} ${preset.description}`;
   });
-  p20.note(lines.join("\n"), "BetterStart plugins");
-  p20.outro(`${installedPlugins.size} installed, ${lines.length - installedPlugins.size} available`);
+  p20.note(lines.join("\n"), "BetterStart presets");
+  p20.outro(`${installedPresets.size} installed, ${lines.length - installedPresets.size} available`);
 }
 
 // adapters/next/commands/remove.ts
@@ -26828,7 +26893,7 @@ async function runRemoveCommand(items, options) {
     p21.log.error("The core Admin cannot be removed.");
     process.exit(1);
   }
-  const pluginIds = items.filter(isPluginId);
+  const presetIds = items.filter(isPresetId);
   const integrationIds = items.filter(isIntegrationId);
   if (!removeIntegrationsMode && integrationIds.length > 0) {
     p21.log.error(
@@ -26836,14 +26901,14 @@ async function runRemoveCommand(items, options) {
     );
     process.exit(1);
   }
-  if (removeIntegrationsMode && pluginIds.length > 0) {
-    p21.log.error(`Plugin IDs cannot be removed with --integration: ${pluginIds.join(", ")}`);
+  if (removeIntegrationsMode && presetIds.length > 0) {
+    p21.log.error(`Preset IDs cannot be removed with --integration: ${presetIds.join(", ")}`);
     process.exit(1);
   }
-  const invalidItems = removeIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((pluginId) => !isPluginId(pluginId));
+  const invalidItems = removeIntegrationsMode ? items.filter((integrationId) => !isIntegrationId(integrationId)) : items.filter((presetId) => !isPresetId(presetId));
   if (invalidItems.length > 0) {
     p21.log.error(
-      removeIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPluginMessage(invalidItems)
+      removeIntegrationsMode ? formatUnknownIntegrationMessage(invalidItems) : formatUnknownPresetMessage(invalidItems)
     );
     process.exit(1);
   }
@@ -26852,11 +26917,11 @@ async function runRemoveCommand(items, options) {
   const pm = detectPackageManager(cwd);
   if (!options.force) {
     const confirmed = await p21.confirm({
-      message: `Remove ${removeIntegrationsMode ? "integration" : "plugin"}${items.length === 1 ? "" : "s"} ${items.join(", ")}?`,
+      message: `Remove ${removeIntegrationsMode ? "integration" : "preset"}${items.length === 1 ? "" : "s"} ${items.join(", ")}?`,
       initialValue: false
     });
     if (p21.isCancel(confirmed) || !confirmed) {
-      p21.cancel(`${removeIntegrationsMode ? "Integration" : "Plugin"} removal cancelled.`);
+      p21.cancel(`${removeIntegrationsMode ? "Integration" : "Preset"} removal cancelled.`);
       process.exit(0);
     }
   }
@@ -26880,21 +26945,21 @@ async function runRemoveCommand(items, options) {
     );
     return;
   }
-  const result = await removePlugins({
+  const result = await removePresets({
     cwd,
     config,
     pm,
-    pluginIds
+    presetIds
   });
   writeConfigFile(cwd, result.config);
   if (result.removed.length === 0) {
-    p21.outro("No plugins were removed.");
+    p21.outro("No presets were removed.");
     return;
   }
   if (result.warnings.length > 0) {
     p21.note(result.warnings.join("\n"), "Warnings");
   }
-  p21.outro(`Removed plugin${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`);
+  p21.outro(`Removed preset${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`);
 }
 
 // adapters/next/commands/remove-schema.ts
@@ -26963,8 +27028,8 @@ async function runRemoveSchemaCommand(schemaName, options) {
     );
     process.exit(1);
   }
-  if (owner.startsWith("plugin:")) {
-    console.error(`  "${schemaName}" is owned by ${owner}. Remove the owning plugin instead.`);
+  if (owner.startsWith("preset:")) {
+    console.error(`  "${schemaName}" is owned by ${owner}. Remove the owning preset instead.`);
     process.exit(1);
   }
   const cwd = options.cwd ? path54.resolve(options.cwd) : process.cwd();
@@ -27646,8 +27711,8 @@ function copyNamespacedDirectory(srcDir, destDir, namespace) {
     writeNamespacedFile(srcPath, destPath, namespace);
   }
 }
-function hasPlugin(config, pluginId) {
-  return config.plugins.installed.includes(pluginId);
+function hasPreset(config, presetId) {
+  return config.presets.installed.includes(presetId);
 }
 function hasIntegration(config, integrationId) {
   return config.integrations.installed.includes(integrationId);
@@ -29224,7 +29289,7 @@ function getAllComponentNamesForConfig(config) {
   const staticUi = getStaticUiComponents();
   const staticCustom = getStaticCustomComponents();
   const templateKeys = Object.entries(TEMPLATE_REGISTRY).filter(
-    ([, entry]) => (!entry.requiredPlugin || hasPlugin(config, entry.requiredPlugin)) && (!entry.requiredIntegration || hasIntegration(config, entry.requiredIntegration))
+    ([, entry]) => (!entry.requiredPreset || hasPreset(config, entry.requiredPreset)) && (!entry.requiredIntegration || hasIntegration(config, entry.requiredIntegration))
   ).map(([name]) => name);
   return [.../* @__PURE__ */ new Set([...staticUi, ...staticCustom, ...templateKeys, "tiptap"])].sort();
 }
@@ -29313,8 +29378,8 @@ async function runUpdateCommand(components, options) {
     if (updatedTemplateNames.has(name)) {
       return false;
     }
-    if (entry.requiredPlugin && !hasPlugin(config, entry.requiredPlugin)) {
-      clack2.log.warning(`${name} requires the ${entry.requiredPlugin} plugin and was skipped.`);
+    if (entry.requiredPreset && !hasPreset(config, entry.requiredPreset)) {
+      clack2.log.warning(`${name} requires the ${entry.requiredPreset} preset and was skipped.`);
       skipped++;
       return false;
     }
@@ -29466,7 +29531,7 @@ async function runUpdateCommand(components, options) {
     clack2.log.warning(`Unknown component: ${name}`);
     skipped++;
   }
-  syncInstalledPluginManifests(cwd, config);
+  syncInstalledPresetManifests(cwd, config);
   syncInstalledIntegrationManifests(cwd, config);
   const projectPackageJson = readProjectPackageJson2(cwd);
   const missingPackageDependencies = Array.from(requiredPackageDependencies).filter(
@@ -29661,7 +29726,7 @@ async function runUpdateDepsCommand(options) {
   clack3.log.info(`Package manager: ${pm}`);
   const config = await resolveConfig(cwd);
   const dependencyPlan = getDependencyPlan(
-    getInstalledPlugins(config),
+    getInstalledPresets(config),
     getInstalledIntegrations(config),
     false
   );
@@ -29720,7 +29785,7 @@ var nextCommandRuntime = {
   runGenerate: runGenerateCommand,
   runInit: runInitCommand,
   runListIntegrations: runListIntegrationsCommand,
-  runListPlugins: runListPluginsCommand,
+  runListPresets: runListPresetsCommand,
   runRemove: runRemoveCommand,
   runRemoveSchema: runRemoveSchemaCommand,
   runSeed: runSeedCommand,
@@ -29736,7 +29801,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 plugin and integration based Admin into any Next.js 16 application").version(version);
+program.name("betterstart").description("Scaffold a preset and integration based Admin into any Next.js 16 application").version(version);
 program.hook("preAction", (_command, actionCommand) => {
   requireInitializedProject(actionCommand);
 });
@@ -29745,7 +29810,7 @@ program.addCommand(createAddFieldCommand(nextCommandRuntime));
 program.addCommand(createCreateCommand(nextCommandRuntime));
 program.addCommand(createInitCommand(nextCommandRuntime));
 program.addCommand(createListIntegrationsCommand(nextCommandRuntime));
-program.addCommand(createListPluginsCommand(nextCommandRuntime));
+program.addCommand(createListPresetsCommand(nextCommandRuntime));
 program.addCommand(createGenerateCommand(nextCommandRuntime));
 program.addCommand(createRemoveCommand(nextCommandRuntime));
 program.addCommand(createRemoveSchemaCommand(nextCommandRuntime));