vela 0.13.2 → 0.13.4

package/dist/bin.js

@@ -21,7 +21,7 @@ import pc42 from "picocolors";
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.13.2",
+  version: "0.13.4",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -57,7 +57,7 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^1.7.0",
     "@faker-js/faker": "^10.6.0",
-    "@velastack/patterns": "^0.2.8",
+    "@velastack/patterns": "^0.2.11",
     "@velastack/pocketbase-codegen": "^0.1.0",
     "annotate-json-schema": "^0.1.0",
     commander: "^13.1.0",
@@ -80,11 +80,11 @@ var package_default = {
   },
   devDependencies: {
     "@types/cross-spawn": "^6.0.6",
-    "@types/node": "^22.0.0",
+    "@types/node": "^26.5.1",
     esbuild: "^0.28.2",
     prettier: "^3.9.6",
     shellcheck: "^4.1.0",
-    typescript: "^5.6.0",
+    typescript: "^7.0.2",
     vite: "^8.2.2",
     vitest: "^5.0.1"
   },
@@ -236,8 +236,8 @@ function stubCommand(name, description, fullName) {
 }
 
 // src/lib/workspace.ts
-import fs2 from "node:fs";
-import path from "node:path";
+import fs3 from "node:fs";
+import path2 from "node:path";
 import process3 from "node:process";
 
 // src/lib/constants.ts
@@ -254,8 +254,36 @@ var API_URL = (process2.env.VELA_API_URL?.trim() || "https://velastack.dev").rep
 var FIXTURE_PREFIX = "vela";
 var TEMPLATE_INDEX_URL = process2.env.VELA_TEMPLATE_INDEX_URL?.trim() || "https://templates.velastack.app/index.json";
 
-// src/lib/package-json.ts
+// src/lib/components-json.ts
 import fs from "node:fs";
+import path from "node:path";
+function readComponentsJson(root) {
+  const file = path.join(root, "components.json");
+  if (!fs.existsSync(file)) return void 0;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function componentsJsonHints(config) {
+  const hints = [];
+  if (!config.style) {
+    hints.push(
+      'components.json has no "style": shadcn-svelte defaults to "nova", while vela ships "vega". Add "style": "vega" so new components match.'
+    );
+  }
+  if (!config.iconLibrary) {
+    hints.push(
+      `components.json has no "iconLibrary": add "iconLibrary": "lucide", the library vela's components use.`
+    );
+  }
+  return hints;
+}
+
+// src/lib/package-json.ts
+import fs2 from "node:fs";
 var DEP_KINDS = ["dependencies", "devDependencies"];
 function mergePackageJson(user, template) {
   const merged = structuredClone(user);
@@ -315,8 +343,8 @@ function dropTemplateAdapters(user, template) {
   }
   return copy;
 }
-function readPackageJson(path47) {
-  return JSON.parse(fs.readFileSync(path47, "utf8"));
+function readPackageJson(path48) {
+  return JSON.parse(fs2.readFileSync(path48, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -334,12 +362,12 @@ function fillTemplatePlaceholders(raw, values) {
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
-function readTemplatePackageJson(path47, values) {
-  const raw = fillTemplatePlaceholders(fs.readFileSync(path47, "utf8"), values);
+function readTemplatePackageJson(path48, values) {
+  const raw = fillTemplatePlaceholders(fs2.readFileSync(path48, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path47, pkg) {
-  fs.writeFileSync(path47, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path48, pkg) {
+  fs2.writeFileSync(path48, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -353,44 +381,40 @@ function sortKeys(obj) {
 // src/lib/workspace.ts
 function findWorkspaceRoot(from = process3.cwd()) {
   let currentDir = from;
-  while (currentDir !== path.parse(currentDir).root) {
-    if (fs2.existsSync(path.join(currentDir, "package.json"))) return currentDir;
-    currentDir = path.dirname(currentDir);
+  while (currentDir !== path2.parse(currentDir).root) {
+    if (fs3.existsSync(path2.join(currentDir, "package.json"))) return currentDir;
+    currentDir = path2.dirname(currentDir);
   }
   return null;
 }
 function hasBackend(from = process3.cwd()) {
   const root = findWorkspaceRoot(from);
-  return root !== null && fs2.existsSync(path.join(root, DATA_DIR));
+  return root !== null && fs3.existsSync(path2.join(root, DATA_DIR));
 }
 function hasApiRoutes(root) {
-  const dir = path.join(root, "src", "routes", "api");
-  if (!fs2.existsSync(dir)) return false;
-  return fs2.readdirSync(dir).some((entry) => entry !== "README.md");
+  const dir = path2.join(root, "src", "routes", "api");
+  if (!fs3.existsSync(dir)) return false;
+  return fs3.readdirSync(dir).some((entry) => entry !== "README.md");
 }
 function localDataDir(from = process3.cwd()) {
-  return path.join(findWorkspaceRoot(from) ?? from, DATA_DIR);
+  return path2.join(findWorkspaceRoot(from) ?? from, DATA_DIR);
 }
 async function getWorkspace() {
   const workspaceRootDir = findWorkspaceRoot();
   if (!workspaceRootDir) {
     throw new Error("Could not find workspace root (no package.json found)");
   }
-  const routesDir = path.join("src", "routes");
-  const fullRoutesPath = path.join(workspaceRootDir, routesDir);
-  if (!fs2.existsSync(fullRoutesPath)) {
+  const routesDir = path2.join("src", "routes");
+  const fullRoutesPath = path2.join(workspaceRootDir, routesDir);
+  if (!fs3.existsSync(fullRoutesPath)) {
     throw new Error("Could not find src/routes directory");
   }
-  let publicRoutesDir = path.join(routesDir, PUBLIC_DIR);
-  if (!fs2.existsSync(path.join(workspaceRootDir, publicRoutesDir))) {
-    publicRoutesDir = routesDir;
-  }
-  let appRoutesDir;
-  const appRoutesPath = path.join(fullRoutesPath, APP_DIR);
-  const isAppMode = fs2.existsSync(appRoutesPath);
-  if (isAppMode) appRoutesDir = path.join(routesDir, APP_DIR);
-  const isPaymentsMode = fs2.existsSync(
-    path.join(workspaceRootDir, routesDir, "webhooks", "stripe")
+  const routeGroups = detectRouteGroups(workspaceRootDir);
+  const publicRoutesDir = path2.join(routesDir, routeGroups.public ?? "");
+  const isAppMode = routeGroups.app !== null;
+  const appRoutesDir = routeGroups.app ? path2.join(routesDir, routeGroups.app) : void 0;
+  const isPaymentsMode = fs3.existsSync(
+    path2.join(workspaceRootDir, routesDir, "webhooks", "stripe")
   );
   const features = detectFeatures(workspaceRootDir, { isAppMode, isPaymentsMode });
   return {
@@ -398,14 +422,25 @@ async function getWorkspace() {
     routesDir,
     publicRoutesDir,
     appRoutesDir,
+    routeGroups,
     isAppMode,
     isPaymentsMode,
     features
   };
 }
+function detectRouteGroups(root) {
+  const group8 = (name) => fs3.existsSync(path2.join(root, "src", "routes", name)) ? name : null;
+  return { public: group8(PUBLIC_DIR), app: group8(APP_DIR) };
+}
+function detectUi(root) {
+  const pkg = readPackageJson(path2.join(root, "package.json"));
+  const hasDep = (name) => Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+  const shadcn = readComponentsJson(root) !== void 0 && (hasDep("shadcn-svelte") || hasDep("bits-ui"));
+  return shadcn ? "shadcn" : "plain";
+}
 function detectFeatures(root, { isAppMode, isPaymentsMode }) {
-  const has = (rel) => fs2.existsSync(path.join(root, rel));
-  const pkg = readPackageJson(path.join(root, "package.json"));
+  const has = (rel) => fs3.existsSync(path2.join(root, rel));
+  const pkg = readPackageJson(path2.join(root, "package.json"));
   const hasDep = (name) => Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
   return {
     auth: isAppMode,
@@ -418,7 +453,8 @@ function detectFeatures(root, { isAppMode, isPaymentsMode }) {
     blog: hasDep("mdsvex"),
     contentNegotiation: hasDep("sveltekit-negotiate"),
     cms: hasDep("@velastack/cms"),
-    workflows: has("src/lib/server/workflows.ts")
+    workflows: has("src/lib/server/workflows.ts"),
+    ui: detectUi(root)
   };
 }
 
@@ -460,46 +496,46 @@ function toFlag(key) {
 }
 
 // src/lib/templates.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/lib/template-files.ts
-import fs3 from "node:fs";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import path3 from "node:path";
 var PUBLISH_SAFE_NAMES = {
   ".gitignore": "_gitignore",
   ".npmrc": "_npmrc"
 };
 function templateName(projectRelPath) {
-  const safe = PUBLISH_SAFE_NAMES[path2.basename(projectRelPath)];
+  const safe = PUBLISH_SAFE_NAMES[path3.basename(projectRelPath)];
   if (!safe) return projectRelPath;
-  const dir = path2.dirname(projectRelPath);
-  return dir === "." ? safe : path2.join(dir, safe);
+  const dir = path3.dirname(projectRelPath);
+  return dir === "." ? safe : path3.join(dir, safe);
 }
 function restoreTemplateNames(target) {
   for (const [real, safe] of Object.entries(PUBLISH_SAFE_NAMES)) {
-    const from = path2.join(target, safe);
-    if (!fs3.existsSync(from)) continue;
-    fs3.renameSync(from, path2.join(target, real));
+    const from = path3.join(target, safe);
+    if (!fs4.existsSync(from)) continue;
+    fs4.renameSync(from, path3.join(target, real));
   }
 }
 var TEMPLATE_SOURCE = /\.template\.([^.]+)$/;
 function applyTemplateFiles(target, values) {
   const written = [];
   for (const source of findTemplateSources(target)) {
-    const raw = fs3.readFileSync(source, "utf8");
+    const raw = fs4.readFileSync(source, "utf8");
     const dest = source.replace(TEMPLATE_SOURCE, ".$1");
-    fs3.writeFileSync(dest, fillTemplatePlaceholders(raw, values));
-    fs3.unlinkSync(source);
-    written.push(path2.relative(target, dest));
+    fs4.writeFileSync(dest, fillTemplatePlaceholders(raw, values));
+    fs4.unlinkSync(source);
+    written.push(path3.relative(target, dest));
   }
   return written.sort();
 }
 function findTemplateSources(dir) {
   const found = [];
-  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const full = path2.join(dir, entry.name);
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    const full = path3.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
       found.push(...findTemplateSources(full));
@@ -511,38 +547,38 @@ function findTemplateSources(dir) {
 }
 
 // src/lib/template-registry.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os2 from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import * as v2 from "valibot";
 import * as tar from "tar";
 
 // src/lib/config.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 import process4 from "node:process";
 function configDir() {
-  return path3.join(os.homedir(), ".vela");
+  return path4.join(os.homedir(), ".vela");
 }
 var CONFIG_DIR = configDir();
-var CONFIG_PATH = path3.join(CONFIG_DIR, "config.json");
+var CONFIG_PATH = path4.join(CONFIG_DIR, "config.json");
 function readConfig() {
-  if (!fs4.existsSync(CONFIG_PATH)) return null;
+  if (!fs5.existsSync(CONFIG_PATH)) return null;
   try {
-    return JSON.parse(fs4.readFileSync(CONFIG_PATH, "utf8"));
+    return JSON.parse(fs5.readFileSync(CONFIG_PATH, "utf8"));
   } catch {
     return null;
   }
 }
 function writeConfig(config) {
-  fs4.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs4.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  fs5.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs5.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
 function clearConfig() {
-  if (fs4.existsSync(CONFIG_PATH)) fs4.unlinkSync(CONFIG_PATH);
+  if (fs5.existsSync(CONFIG_PATH)) fs5.unlinkSync(CONFIG_PATH);
 }
 function readApiKey() {
   const fromEnv = process4.env.VELA_API_KEY?.trim();
@@ -588,16 +624,16 @@ var indexSchema = v2.object({
   templates: v2.array(v2.unknown())
 });
 function cacheRoot() {
-  return path4.join(configDir(), CACHE_DIR_NAME);
+  return path5.join(configDir(), CACHE_DIR_NAME);
 }
 function indexCachePath() {
-  return path4.join(cacheRoot(), INDEX_CACHE_FILE);
+  return path5.join(cacheRoot(), INDEX_CACHE_FILE);
 }
 function readCachedIndex(url) {
   const file = indexCachePath();
-  if (!fs5.existsSync(file)) return null;
+  if (!fs6.existsSync(file)) return null;
   try {
-    const cached2 = JSON.parse(fs5.readFileSync(file, "utf8"));
+    const cached2 = JSON.parse(fs6.readFileSync(file, "utf8"));
     if (cached2.url !== url) return null;
     return cached2;
   } catch {
@@ -605,8 +641,8 @@ function readCachedIndex(url) {
   }
 }
 function writeCachedIndex(cached2) {
-  fs5.mkdirSync(cacheRoot(), { recursive: true });
-  fs5.writeFileSync(indexCachePath(), JSON.stringify(cached2, null, 2));
+  fs6.mkdirSync(cacheRoot(), { recursive: true });
+  fs6.writeFileSync(indexCachePath(), JSON.stringify(cached2, null, 2));
 }
 function parseTemplateIndex(text19, url) {
   let parsed;
@@ -633,7 +669,7 @@ function isFileUrl(url) {
 }
 async function readBytes(url, options) {
   if (isFileUrl(url)) {
-    return new Uint8Array(fs5.readFileSync(fileURLToPath(url)));
+    return new Uint8Array(fs6.readFileSync(fileURLToPath(url)));
   }
   const res = await fetch(url, {
     headers: options.headers,
@@ -671,7 +707,7 @@ function sha256(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
 }
 function tarballCachePath(entry) {
-  return path4.join(
+  return path5.join(
     cacheRoot(),
     TARBALL_CACHE_DIR,
     `${entry.name}-${entry.sha256.slice(0, 12)}.tgz`
@@ -681,8 +717,8 @@ async function downloadTemplate(entry, indexUrl, options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS * 6;
   const cacheFile = tarballCachePath(entry);
   let haveTarball = false;
-  if (fs5.existsSync(cacheFile)) {
-    const cached2 = new Uint8Array(fs5.readFileSync(cacheFile));
+  if (fs6.existsSync(cacheFile)) {
+    const cached2 = new Uint8Array(fs6.readFileSync(cacheFile));
     haveTarball = sha256(cached2) === entry.sha256;
   }
   if (!haveTarball) {
@@ -699,14 +735,14 @@ async function downloadTemplate(entry, indexUrl, options = {}) {
         `Downloaded template ${entry.name} did not match its checksum (expected ${entry.sha256}, got ${digest}). Try again, or set VELA_TEMPLATE_INDEX_URL to a registry you trust.`
       );
     }
-    fs5.mkdirSync(path4.dirname(cacheFile), { recursive: true });
-    fs5.writeFileSync(cacheFile, fetched);
+    fs6.mkdirSync(path5.dirname(cacheFile), { recursive: true });
+    fs6.writeFileSync(cacheFile, fetched);
   }
-  const dir = fs5.mkdtempSync(path4.join(os2.tmpdir(), `vela-template-${entry.name}-`));
+  const dir = fs6.mkdtempSync(path5.join(os2.tmpdir(), `vela-template-${entry.name}-`));
   try {
     await tar.extract({ file: cacheFile, cwd: dir, strip: 1 });
   } catch (e) {
-    fs5.rmSync(dir, { recursive: true, force: true });
+    fs6.rmSync(dir, { recursive: true, force: true });
     throw new Error(`Could not unpack template ${entry.name}: ${e.message}`);
   }
   return dir;
@@ -718,25 +754,25 @@ var DEFAULT_TEMPLATE = "minimal";
 var DEFAULT_CATEGORY = "starter";
 var cached;
 function templatesDir() {
-  let dir = path5.dirname(fileURLToPath2(import.meta.url));
-  const { root } = path5.parse(dir);
+  let dir = path6.dirname(fileURLToPath2(import.meta.url));
+  const { root } = path6.parse(dir);
   while (dir !== root) {
-    const candidate = path5.join(dir, "templates");
+    const candidate = path6.join(dir, "templates");
     if (holdsManifest(candidate)) return candidate;
-    dir = path5.dirname(dir);
+    dir = path6.dirname(dir);
   }
   throw new Error("Could not locate the templates directory");
 }
 function holdsManifest(dir) {
-  if (!fs6.existsSync(dir)) return false;
-  return fs6.readdirSync(dir, { withFileTypes: true }).some(
-    (entry) => entry.isDirectory() && fs6.existsSync(path5.join(dir, entry.name, TEMPLATE_MANIFEST))
+  if (!fs7.existsSync(dir)) return false;
+  return fs7.readdirSync(dir, { withFileTypes: true }).some(
+    (entry) => entry.isDirectory() && fs7.existsSync(path6.join(dir, entry.name, TEMPLATE_MANIFEST))
   );
 }
 function listProjectTemplates() {
   if (cached) return cached;
   const root = templatesDir();
-  cached = fs6.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readManifest(root, entry.name)).filter((template) => template !== void 0).sort((a, b) => a.name.localeCompare(b.name));
+  cached = fs7.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readManifest(root, entry.name)).filter((template) => template !== void 0).sort((a, b) => a.name.localeCompare(b.name));
   return cached;
 }
 function projectTemplateNames(options = {}) {
@@ -809,25 +845,25 @@ async function resolveTemplate(template) {
     ...info,
     dir,
     cleanup() {
-      fs6.rmSync(dir, { recursive: true, force: true });
+      fs7.rmSync(dir, { recursive: true, force: true });
     }
   };
 }
 function copyTemplate(template, target) {
-  fs6.mkdirSync(target, { recursive: true });
-  fs6.cpSync(template.dir, target, {
+  fs7.mkdirSync(target, { recursive: true });
+  fs7.cpSync(template.dir, target, {
     recursive: true,
     // The manifest describes the template to the CLI; it isn't part of the project.
-    filter: (src) => path5.basename(src) !== ".DS_Store" && path5.relative(template.dir, src) !== TEMPLATE_MANIFEST
+    filter: (src) => path6.basename(src) !== ".DS_Store" && path6.relative(template.dir, src) !== TEMPLATE_MANIFEST
   });
   restoreTemplateNames(target);
 }
 function readManifest(root, name) {
-  const manifestPath = path5.join(root, name, TEMPLATE_MANIFEST);
-  if (!fs6.existsSync(manifestPath)) return void 0;
+  const manifestPath = path6.join(root, name, TEMPLATE_MANIFEST);
+  if (!fs7.existsSync(manifestPath)) return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(fs6.readFileSync(manifestPath, "utf8"));
+    parsed = JSON.parse(fs7.readFileSync(manifestPath, "utf8"));
   } catch (e) {
     throw new Error(
       `Template ${name} has an unreadable ${TEMPLATE_MANIFEST}: ${e.message}`
@@ -850,7 +886,7 @@ function readManifest(root, name) {
     price: typeof manifest.price === "number" ? manifest.price : void 0,
     nextSteps: optionalStringArray(manifest.nextSteps),
     cms: typeof manifest.cms === "boolean" ? manifest.cms : void 0,
-    dir: path5.join(root, name)
+    dir: path6.join(root, name)
   };
 }
 function optionalString(value) {
@@ -863,8 +899,8 @@ function optionalStringArray(value) {
 }
 
 // src/lib/package-manager.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path7 from "node:path";
 import process5 from "node:process";
 import { exec } from "tinyexec";
 import { Option } from "commander";
@@ -934,9 +970,9 @@ async function installDependencies(agent, cwd, { exitOnFailure = true } = {}) {
 }
 function addPnpmBuildDependencies(cwd, packageManager2, allowedPackages) {
   if (!packageManager2 || packageManager2 !== "pnpm") return;
-  const pkgPath = path6.join(cwd, "package.json");
-  if (!fs7.existsSync(pkgPath)) return;
-  const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path7.join(cwd, "package.json");
+  if (!fs8.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
   pkg.pnpm ??= {};
   pkg.pnpm.onlyBuiltDependencies ??= [];
   for (const name of allowedPackages) {
@@ -944,13 +980,13 @@ function addPnpmBuildDependencies(cwd, packageManager2, allowedPackages) {
       pkg.pnpm.onlyBuiltDependencies.push(name);
     }
   }
-  fs7.writeFileSync(pkgPath, JSON.stringify(pkg, null, "	") + "\n");
+  fs8.writeFileSync(pkgPath, JSON.stringify(pkg, null, "	") + "\n");
 }
 
 // src/lib/pocketbase.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import net from "node:net";
-import path7 from "node:path";
+import path8 from "node:path";
 import process6 from "node:process";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
@@ -1063,9 +1099,9 @@ async function authWithRetries(pb, email3, password11, attempts = 3) {
   }
 }
 function getPocketbaseMetadata(cwd) {
-  const metadataPath = path7.join(cwd, "node_modules", ".vite", "_pocketbase_metadata.json");
-  if (fs8.existsSync(metadataPath)) {
-    return JSON.parse(fs8.readFileSync(metadataPath, "utf8"));
+  const metadataPath = path8.join(cwd, "node_modules", ".vite", "_pocketbase_metadata.json");
+  if (fs9.existsSync(metadataPath)) {
+    return JSON.parse(fs9.readFileSync(metadataPath, "utf8"));
   }
   return null;
 }
@@ -1078,12 +1114,12 @@ async function execPackageBin(cwd, args, stdio = "pipe") {
   return x(command, resolvedArgs, { nodeOptions: { cwd, stdio }, throwOnError: true });
 }
 async function withPocketbase(cwd, fn, creds) {
-  const dir = path7.join(cwd, DATA_DIR);
-  const migrationsDir = path7.join(cwd, MIGRATIONS_DIR);
+  const dir = path8.join(cwd, DATA_DIR);
+  const migrationsDir = path8.join(cwd, MIGRATIONS_DIR);
   const host = "localhost";
   const email3 = creds?.email ?? process6.env.POCKETBASE_SUPERUSER_EMAIL;
   const password11 = creds?.password ?? process6.env.POCKETBASE_SUPERUSER_PASSWORD;
-  if (!fs8.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     throw new Error("PocketBase data directory does not exist");
   }
   const metadata = getPocketbaseMetadata(cwd);
@@ -1108,10 +1144,10 @@ async function withPocketbase(cwd, fn, creds) {
   }
 }
 async function createSuperuser(cwd, email3, password11) {
-  const dir = path7.join(cwd, DATA_DIR);
-  const migrationsDir = path7.join(cwd, MIGRATIONS_DIR);
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.mkdirSync(migrationsDir, { recursive: true });
+  const dir = path8.join(cwd, DATA_DIR);
+  const migrationsDir = path8.join(cwd, MIGRATIONS_DIR);
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.mkdirSync(migrationsDir, { recursive: true });
   await execPackageBin(
     cwd,
     [
@@ -1136,8 +1172,8 @@ async function launchPocketbase(cwd, {
   password: password11
 }) {
   const host = "localhost";
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.mkdirSync(migrationsDir, { recursive: true });
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.mkdirSync(migrationsDir, { recursive: true });
   await execPackageBin(
     cwd,
     [
@@ -1179,8 +1215,8 @@ async function ensureSuperuser(cwd) {
   const email3 = process6.env.POCKETBASE_SUPERUSER_EMAIL;
   const password11 = process6.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email3 || !password11) return;
-  const dir = path7.join(cwd, DATA_DIR);
-  if (!fs8.existsSync(dir)) return;
+  const dir = path8.join(cwd, DATA_DIR);
+  if (!fs9.existsSync(dir)) return;
   const { getBinaryPath } = await import("pocketbase-server");
   await x(
     getBinaryPath(),
@@ -1188,7 +1224,7 @@ async function ensureSuperuser(cwd) {
       "--dir",
       dir,
       "--migrationsDir",
-      path7.join(cwd, MIGRATIONS_DIR),
+      path8.join(cwd, MIGRATIONS_DIR),
       "superuser",
       "upsert",
       email3,
@@ -1199,8 +1235,8 @@ async function ensureSuperuser(cwd) {
 }
 
 // src/lib/env.ts
-import fs9 from "node:fs";
-import path8 from "node:path";
+import fs10 from "node:fs";
+import path9 from "node:path";
 function addEnvVar(content, key, value) {
   if (content.includes(`${key}=`)) return content;
   return appendLine(content, `${key}=${value}`);
@@ -1215,11 +1251,11 @@ function appendLine(existing, line) {
   return withNewline + line + "\n";
 }
 function writeEnvFile(cwd, vars, comments = []) {
-  const envPath = path8.join(cwd, ".env");
-  let content = fs9.existsSync(envPath) ? fs9.readFileSync(envPath, "utf8") : "";
+  const envPath = path9.join(cwd, ".env");
+  let content = fs10.existsSync(envPath) ? fs10.readFileSync(envPath, "utf8") : "";
   for (const comment of comments) content = addEnvComment(content, comment);
   for (const [key, value] of Object.entries(vars)) content = addEnvVar(content, key, value);
-  fs9.writeFileSync(envPath, content);
+  fs10.writeFileSync(envPath, content);
 }
 function upsertEnvVar(content, key, value) {
   const line = `${key}=${quoteEnvValue(value)}`;
@@ -1252,7 +1288,7 @@ function quoteEnvValue(value) {
 }
 
 // src/lib/app-css.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 var SHADCN_TAILWIND_CSS = "shadcn-svelte/tailwind.css";
 var SHADCN_TAILWIND_IMPORT = `@import '${SHADCN_TAILWIND_CSS}';`;
 function hasShadcnImport(css) {
@@ -1278,41 +1314,13 @@ ${css}`;
   return lines.join("\n");
 }
 function ensureShadcnImport(appCssPath) {
-  if (!fs10.existsSync(appCssPath)) return false;
-  const css = fs10.readFileSync(appCssPath, "utf8");
+  if (!fs11.existsSync(appCssPath)) return false;
+  const css = fs11.readFileSync(appCssPath, "utf8");
   if (hasShadcnImport(css)) return false;
-  fs10.writeFileSync(appCssPath, insertShadcnImport(css));
+  fs11.writeFileSync(appCssPath, insertShadcnImport(css));
   return true;
 }
 
-// src/lib/components-json.ts
-import fs11 from "node:fs";
-import path9 from "node:path";
-function readComponentsJson(root) {
-  const file = path9.join(root, "components.json");
-  if (!fs11.existsSync(file)) return void 0;
-  try {
-    const parsed = JSON.parse(fs11.readFileSync(file, "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function componentsJsonHints(config) {
-  const hints = [];
-  if (!config.style) {
-    hints.push(
-      'components.json has no "style": shadcn-svelte defaults to "nova", while vela ships "vega". Add "style": "vega" so new components match.'
-    );
-  }
-  if (!config.iconLibrary) {
-    hints.push(
-      `components.json has no "iconLibrary": add "iconLibrary": "lucide", the library vela's components use.`
-    );
-  }
-  return hints;
-}
-
 // src/lib/config-merge.ts
 import fs13 from "node:fs";
 import path11 from "node:path";
@@ -2691,8 +2699,8 @@ async function runPattern(slug2, argv, input, report4) {
     throw new Error(`Unknown pattern: ${slug2}`);
   }
   checkProviderInput(pattern, argv, input);
-  const { workspaceRootDir, features } = await getWorkspace();
-  const log49 = p9.taskLog({ title: report4.task.title });
+  const { workspaceRootDir, features, routeGroups } = await getWorkspace();
+  const log50 = p9.taskLog({ title: report4.task.title });
   let result;
   try {
     result = await pattern.generate({
@@ -2700,6 +2708,7 @@ async function runPattern(slug2, argv, input, report4) {
       env: "runtime",
       root: workspaceRootDir,
       features,
+      routeGroups,
       input,
       // Patterns no longer read the schema themselves: @velastack/pocketbase-codegen
       // takes an injected client, and only the CLI knows how to reach (or spawn)
@@ -2712,11 +2721,11 @@ async function runPattern(slug2, argv, input, report4) {
         });
         return collections2;
       },
-      logger: { info: (message) => log49.message(message) }
+      logger: { info: (message) => log50.message(message) }
     });
-    log49.success(report4.task.success);
+    log50.success(report4.task.success);
   } catch (e) {
-    log49.error(report4.task.error);
+    log50.error(report4.task.error);
     throw e;
   }
   const rel = (f) => toRelative(workspaceRootDir, f);
@@ -2749,9 +2758,34 @@ async function runPattern(slug2, argv, input, report4) {
   });
 }
 
+// src/lib/form-ui.ts
+import path17 from "node:path";
+var UIS = ["shadcn", "plain"];
+function detectFormInput(root) {
+  const pkg = readPackageJson(path17.join(root, "package.json"));
+  const hasDep = (name) => Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+  return {
+    flash: hasDep("sveltekit-flash-message"),
+    serverTests: hasDep("supertest")
+  };
+}
+function resolveFormInput(root, detectedUi, requested) {
+  const detected = detectFormInput(root);
+  if (requested === void 0) return detected;
+  if (!UIS.includes(requested)) {
+    throw new Error(`Unknown --ui "${requested}". Expected one of: ${UIS.join(", ")}.`);
+  }
+  if (requested === "shadcn" && detectedUi !== "shadcn") {
+    throw new Error(
+      "--ui shadcn needs a shadcn-svelte project (a components.json and the shadcn-svelte package). Run `vela bless` to set one up, or use --ui plain."
+    );
+  }
+  return { ...detected, ui: requested };
+}
+
 // src/lib/ai-flow.ts
 import fs18 from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 import * as p13 from "@clack/prompts";
 import pc4 from "picocolors";
 
@@ -3026,17 +3060,20 @@ function specToArgv(spec) {
   return collectionSpecToArgv(spec);
 }
 function writeLayoutSidecar(workspaceRootDir, modelName, layout) {
-  const dir = path17.join(workspaceRootDir, "data", "ai-form-layouts");
+  const dir = path18.join(workspaceRootDir, "data", "ai-form-layouts");
   fs18.mkdirSync(dir, { recursive: true });
-  const file = path17.join(dir, `${modelName}.json`);
+  const file = path18.join(dir, `${modelName}.json`);
   fs18.writeFileSync(file, JSON.stringify(layout, null, 2) + "\n");
-  return path17.relative(workspaceRootDir, file);
+  return path18.relative(workspaceRootDir, file);
 }
 
 // src/commands/generate/form.ts
 var form = new Command5("form").description("generate a form from a model").argument("[model]", 'model name (e.g. "contact")').argument("[fields...]", 'field definitions (e.g. "name:text", "email:email")').option("--remote", "generate a form backed by a remote PocketBase collection").option(
   "--route <route>",
-  'place the form at a custom route (e.g. "(app)/[team_id]/projects/new"). Defaults to the model name under (app)/(public).'
+  'place the form at a custom route (e.g. "(app)/[team_id]/projects/new"). Defaults to the model name under the (app) or (public) group, or src/routes when it has neither.'
+).option(
+  "--ui <ui>",
+  'markup to generate: "shadcn" components or "plain" HTML. Defaults to shadcn when the project has shadcn-svelte, plain otherwise.'
 ).option(
   "--ai <description>",
   "design the form with AI from a natural-language description (two stages: schema \u2192 layout)"
@@ -3069,6 +3106,11 @@ var form = new Command5("form").description("generate a form from a model").argu
       argv = [model, ...fields];
       modelName = model;
     }
+    const { workspaceRootDir, features } = await getWorkspace();
+    const formInput = resolveFormInput(workspaceRootDir, features.ui, options.ui);
+    if (features.ui === "plain" && !options.ui) {
+      p14.log.info("shadcn-svelte not detected: generating a plain HTML form.");
+    }
     const slug2 = options.remote ? "generate-form-remote" : "generate-form";
     const nextSteps = [
       "Edit the form fields and validation in the generated +page.svelte.",
@@ -3082,7 +3124,7 @@ var form = new Command5("form").description("generate a form from a model").argu
     await runPattern(
       slug2,
       argv,
-      { route: options.route },
+      { route: options.route, ...formInput },
       {
         summary: `Created ${modelName} form.`,
         nextSteps,
@@ -3172,7 +3214,7 @@ import { Command as Command8 } from "commander";
 import * as p16 from "@clack/prompts";
 var scaffold = new Command8("scaffold").description("generate a full CRUD scaffold (model, forms, list, detail)").argument("[model]", "model name").argument("[fields...]", "field definitions").option("--remote", "generate a scaffold backed by a remote PocketBase collection").option(
   "--route <route>",
-  'place the scaffold at a custom route (e.g. "(app)/[team_id]/projects"). Defaults to the pluralized model name under (app)/(public).'
+  'place the scaffold at a custom route (e.g. "(app)/[team_id]/projects"). Defaults to the pluralized model name under the (app) or (public) group, or src/routes when it has neither.'
 ).option(
   "--ai <description>",
   "design the scaffold with AI from a natural-language description (two stages: schema \u2192 layout)"
@@ -3644,7 +3686,7 @@ import pc5 from "picocolors";
 
 // src/lib/deploy-config.ts
 import fs19 from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 import crypto from "node:crypto";
 import { pathToFileURL } from "node:url";
 var CONFIG_BASENAMES = [
@@ -3655,7 +3697,7 @@ var CONFIG_BASENAMES = [
 ];
 function findConfigFile(workspaceRootDir) {
   for (const name of CONFIG_BASENAMES) {
-    const file = path18.join(workspaceRootDir, name);
+    const file = path19.join(workspaceRootDir, name);
     if (fs19.existsSync(file)) return file;
   }
   return null;
@@ -3671,7 +3713,7 @@ async function loadDeployConfig(workspaceRootDir) {
     const mod = await import(url);
     const config = mod.default;
     if (!config || typeof config !== "object") {
-      throw new Error(`${path18.basename(file)} must export a config object as its default export.`);
+      throw new Error(`${path19.basename(file)} must export a config object as its default export.`);
     }
     return config;
   } finally {
@@ -3684,15 +3726,15 @@ async function transpileToTemp(file) {
   const { outputText } = ts.transpileModule(source, {
     compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 }
   });
-  const temp = path18.join(
-    path18.dirname(file),
+  const temp = path19.join(
+    path19.dirname(file),
     `.velastack.config.${crypto.randomBytes(4).toString("hex")}.mjs`
   );
   fs19.writeFileSync(temp, outputText);
   return pathToFileURL(temp).href;
 }
 function projectFilePath(workspaceRootDir) {
-  return path18.join(workspaceRootDir, ".vela", "project.json");
+  return path19.join(workspaceRootDir, ".vela", "project.json");
 }
 function readProjectFile(workspaceRootDir) {
   const file = projectFilePath(workspaceRootDir);
@@ -3705,7 +3747,7 @@ function readProjectFile(workspaceRootDir) {
 }
 function writeProjectFile(workspaceRootDir, data) {
   const file = projectFilePath(workspaceRootDir);
-  fs19.mkdirSync(path18.dirname(file), { recursive: true });
+  fs19.mkdirSync(path19.dirname(file), { recursive: true });
   fs19.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
 }
 function resolveAppIdentity(workspaceRootDir, config = {}) {
@@ -3731,11 +3773,11 @@ function readAppIdentity(workspaceRootDir, config = {}) {
 }
 function defaultProjectName(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path18.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path19.join(workspaceRootDir, "package.json"));
     if (typeof pkg.name === "string" && pkg.name.trim()) return pkg.name.trim();
   } catch {
   }
-  return path18.basename(workspaceRootDir);
+  return path19.basename(workspaceRootDir);
 }
 function slug(value) {
   return value.toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "app";
@@ -3807,14 +3849,14 @@ function randomSuffix() {
 
 // src/lib/artifact.ts
 import fs21 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 import { detect as detect4 } from "package-manager-detector";
 import { resolveCommand as resolveCommand4 } from "package-manager-detector/commands";
 
 // src/lib/ssh.ts
 import fs20 from "node:fs";
 import os4 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 import crypto3 from "node:crypto";
 import process13 from "node:process";
 import { spawn as spawn2 } from "node:child_process";
@@ -3857,9 +3899,9 @@ var SshSession = class {
   }
   async open() {
     if (this.controlPath) return;
-    const dir = path19.join(os4.tmpdir(), "vela-ssh");
+    const dir = path20.join(os4.tmpdir(), "vela-ssh");
     fs20.mkdirSync(dir, { recursive: true, mode: 448 });
-    const socket = path19.join(dir, `${crypto3.randomBytes(6).toString("hex")}.sock`);
+    const socket = path20.join(dir, `${crypto3.randomBytes(6).toString("hex")}.sock`);
     this.controlPath = socket;
     const args = [
       ...this.sshArgs(),
@@ -4149,11 +4191,11 @@ function collectArtifact(cwd, config = {}) {
   const outputDir = config.outputDir ?? DEFAULT_OUTPUT_DIR;
   const entries = [];
   const add2 = (rel, remoteDir = "") => {
-    const localPath = path20.join(cwd, rel);
+    const localPath = path21.join(cwd, rel);
     if (fs21.existsSync(localPath)) entries.push({ localPath, remoteDir });
   };
-  const buildPath = path20.join(cwd, outputDir);
-  if (!fs21.existsSync(path20.join(buildPath, "index.js"))) {
+  const buildPath = path21.join(cwd, outputDir);
+  if (!fs21.existsSync(path21.join(buildPath, "index.js"))) {
     throw new BuildError(
       `No ${outputDir}/index.js to deploy.
 
@@ -4167,7 +4209,7 @@ matches where it writes), then deploy again.`
   add2("package-lock.json");
   add2(".npmrc");
   add2(MIGRATIONS_DIR);
-  const hooks = path20.join(cwd, DATA_DIR, "hooks");
+  const hooks = path21.join(cwd, DATA_DIR, "hooks");
   if (fs21.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
   for (const extra of config.include ?? []) add2(extra);
   return entries;
@@ -4210,7 +4252,7 @@ function sshOptionsFrom(options) {
 // src/lib/remote.ts
 import crypto4 from "node:crypto";
 import fs22 from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 import process14 from "node:process";
 var VELA_ROOT = "/var/lib/vela";
 var VELA_ETC = "/etc/vela";
@@ -4223,19 +4265,19 @@ function instanceHasBackend(state) {
   return state.backend ?? Boolean(state.pbPort);
 }
 function serverTemplatesDir() {
-  return path21.join(templatesDir(), "server");
+  return path22.join(templatesDir(), "server");
 }
 var DIGEST_LENGTH = 12;
 function serverScriptsDigest(dir = serverTemplatesDir()) {
   const hash = crypto4.createHash("sha256");
   for (const file of listFiles(dir).sort()) {
-    hash.update(file).update("\0").update(fs22.readFileSync(path21.join(dir, file))).update("\0");
+    hash.update(file).update("\0").update(fs22.readFileSync(path22.join(dir, file))).update("\0");
   }
   return hash.digest("hex").slice(0, DIGEST_LENGTH);
 }
 function listFiles(root, prefix = "") {
   const files = [];
-  for (const entry of fs22.readdirSync(path21.join(root, prefix), { withFileTypes: true })) {
+  for (const entry of fs22.readdirSync(path22.join(root, prefix), { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) files.push(...listFiles(root, rel));
     else if (entry.isFile()) files.push(rel);
@@ -4875,7 +4917,7 @@ Set ${pc7.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc7.cyan("POCKETBASE_SUPERUS
 
 // src/lib/s3-settings.ts
 import fs25 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 var VIRTUAL_HOSTED = [/\.amazonaws\.com$/i, /\.r2\.cloudflarestorage\.com$/i];
 function defaultForcePathStyle(endpoint) {
   let host;
@@ -4913,7 +4955,7 @@ async function hasLocalUploads(session, instance, workspaceRootDir) {
     });
     return result.stdout.trim().length > 0;
   }
-  return hasFile(path22.join(workspaceRootDir, DATA_DIR, "storage"));
+  return hasFile(path23.join(workspaceRootDir, DATA_DIR, "storage"));
 }
 function hasFile(dir) {
   let entries;
@@ -4924,7 +4966,7 @@ function hasFile(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile()) return true;
-    if (entry.isDirectory() && hasFile(path22.join(dir, entry.name))) return true;
+    if (entry.isDirectory() && hasFile(path23.join(dir, entry.name))) return true;
   }
   return false;
 }
@@ -5964,18 +6006,18 @@ function uiAddReport(requested, outcome) {
 var add = new Command48("add").description("add ui components (shadcn-svelte items and vela components such as data-table)").argument("<components...>", "the components to add").option("--overwrite", "replace components that already exist", false).configureHelp(helpConfig).action(
   (components, options) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log49 = p29.taskLog({ title: "Adding UI components..." });
+    const log50 = p29.taskLog({ title: "Adding UI components..." });
     let outcome;
     try {
       outcome = await installComponents({
         root: workspaceRootDir,
         components,
         overwrite: options.overwrite,
-        logger: { info: (message) => log49.message(message) }
+        logger: { info: (message) => log50.message(message) }
       });
-      log49.success("UI components ready");
+      log50.success("UI components ready");
     } catch (e) {
-      log49.error("Could not add UI components");
+      log50.error("Could not add UI components");
       throw e;
     }
     reportResult(uiAddReport(components, outcome));
@@ -5989,13 +6031,13 @@ import { applyBaseColor } from "@velastack/patterns";
 var base = new Command49("base").description("change the base (gray) palette").argument("<color>", `base color to use (${BASE_COLORS.join(", ")})`).configureHelp(helpConfig).action(
   (color) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log49 = p30.taskLog({ title: `Applying the ${color} palette...` });
+    const log50 = p30.taskLog({ title: `Applying the ${color} palette...` });
     let outcome;
     try {
       outcome = await applyBaseColor({ root: workspaceRootDir, color });
-      log49.success("Palette applied");
+      log50.success("Palette applied");
     } catch (e) {
-      log49.error("Could not change the base color");
+      log50.error("Could not change the base color");
       throw e;
     }
     reportResult({
@@ -6102,14 +6144,14 @@ var style = new Command51("style").description("switch the shadcn-svelte style,
     const { workspaceRootDir } = await getWorkspace();
     const spinner8 = p32.spinner();
     spinner8.start(`Reading the ${name} registry...`);
-    let log49;
+    let log50;
     let outcome;
     try {
       outcome = await switchStyle({
         root: workspaceRootDir,
         style: name,
         font: options.font,
-        logger: { info: (message) => log49?.message(message) },
+        logger: { info: (message) => log50?.message(message) },
         confirm: async (components) => {
           spinner8.stop(`Read the ${name} registry`);
           if (components.length > 0) {
@@ -6126,13 +6168,13 @@ ${components.map((c) => `- ${c}`).join("\n")}`
             const ok = await p32.confirm({ message: `Switch to ${name}?`, initialValue: false });
             if (p32.isCancel(ok) || !ok) return false;
           }
-          log49 = p32.taskLog({ title: `Switching to the ${name} style...` });
+          log50 = p32.taskLog({ title: `Switching to the ${name} style...` });
           return true;
         }
       });
     } catch (e) {
       spinner8.stop(`Could not switch to ${name}`);
-      log49?.error("Could not switch style");
+      log50?.error("Could not switch style");
       throw e;
     }
     spinner8.stop(`Read the ${name} registry`);
@@ -6144,7 +6186,7 @@ ${components.map((c) => `- ${c}`).join("\n")}`
       p32.cancel("Operation cancelled.");
       return;
     }
-    log49?.success("Style switched");
+    log50?.success("Style switched");
     reportResult(uiStyleReport(outcome));
   }, "Failed to switch style.")
 );
@@ -6156,13 +6198,13 @@ import { applyTheme } from "@velastack/patterns";
 var theme = new Command52("theme").description("change the accent color, keeping the base palette").argument("<accent>", `accent to use (${THEMES.join(", ")})`).configureHelp(helpConfig).action(
   (accent) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log49 = p33.taskLog({ title: `Applying the ${accent} accent...` });
+    const log50 = p33.taskLog({ title: `Applying the ${accent} accent...` });
     let outcome;
     try {
       outcome = await applyTheme({ root: workspaceRootDir, theme: accent });
-      log49.success("Accent applied");
+      log50.success("Accent applied");
     } catch (e) {
-      log49.error("Could not change the accent");
+      log50.error("Could not change the accent");
       throw e;
     }
     reportResult({
@@ -6185,7 +6227,7 @@ import { Command as Command56 } from "commander";
 
 // src/commands/legal/terms.ts
 import fs26 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 import { Command as Command54 } from "commander";
 import * as p35 from "@clack/prompts";
 
@@ -6844,22 +6886,22 @@ async function termsAction() {
     mobileApp,
     contact
   });
-  const termsPage = path23.join(
+  const termsPage = path24.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "terms",
     "+page.svelte"
   );
-  const termsPageTs = path23.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
-  fs26.mkdirSync(path23.dirname(termsPage), { recursive: true });
+  const termsPageTs = path24.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
+  fs26.mkdirSync(path24.dirname(termsPage), { recursive: true });
   fs26.writeFileSync(termsPage, html);
   fs26.writeFileSync(
     termsPageTs,
     pageMetaTagsLoader("Terms of Service", `Terms of Service for ${core.websiteName}`)
   );
-  const relativeTermsPage = path23.relative(workspaceRootDir, termsPage);
-  const relativeTermsPageTs = path23.relative(workspaceRootDir, termsPageTs);
+  const relativeTermsPage = path24.relative(workspaceRootDir, termsPage);
+  const relativeTermsPageTs = path24.relative(workspaceRootDir, termsPageTs);
   reportResult({
     summary: "Generated placeholder terms and conditions.",
     filesCreated: [relativeTermsPage, relativeTermsPageTs],
@@ -6874,7 +6916,7 @@ var terms = new Command54("terms").description("generate placeholder terms and c
 
 // src/commands/legal/privacy.ts
 import fs27 from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import { Command as Command55 } from "commander";
 import * as p36 from "@clack/prompts";
 var mapLabels = {
@@ -7587,28 +7629,28 @@ async function privacyAction() {
     kids,
     retention
   });
-  const privacyPage = path24.join(
+  const privacyPage = path25.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.svelte"
   );
-  const privacyPageTs = path24.join(
+  const privacyPageTs = path25.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.ts"
   );
-  fs27.mkdirSync(path24.dirname(privacyPage), { recursive: true });
+  fs27.mkdirSync(path25.dirname(privacyPage), { recursive: true });
   fs27.writeFileSync(privacyPage, html);
   fs27.writeFileSync(
     privacyPageTs,
     pageMetaTagsLoader("Privacy Policy", `Privacy Policy for ${core.websiteName}`)
   );
-  const relativePrivacyPage = path24.relative(workspaceRootDir, privacyPage);
-  const relativePrivacyPageTs = path24.relative(workspaceRootDir, privacyPageTs);
+  const relativePrivacyPage = path25.relative(workspaceRootDir, privacyPage);
+  const relativePrivacyPageTs = path25.relative(workspaceRootDir, privacyPageTs);
   reportResult({
     summary: "Generated placeholder privacy policy.",
     filesCreated: [relativePrivacyPage, relativePrivacyPageTs],
@@ -7632,7 +7674,7 @@ import { Command as Command57 } from "commander";
 
 // src/lib/data.ts
 import fs28 from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 import { ClientResponseError } from "pocketbase";
 
 // src/lib/collections.ts
@@ -7669,14 +7711,14 @@ function dependencyOrder(collections2, startingCollectionId) {
 
 // src/lib/data.ts
 function dataDir(cwd, kind) {
-  return path25.join(cwd, DATA_DIR, kind);
+  return path26.join(cwd, DATA_DIR, kind);
 }
 function getDataFiles(cwd, kind) {
   const dir = dataDir(cwd, kind);
   if (!fs28.existsSync(dir)) return [];
   return fs28.readdirSync(dir).filter((file) => file.endsWith(".json")).sort((a, b) => a.localeCompare(b)).map((file) => ({
     collectionName: file.replace(/\.json$/i, "").replace(/^\d+[-_]?/, ""),
-    filePath: path25.join(dir, file)
+    filePath: path26.join(dir, file)
   }));
 }
 function getSeedFiles(cwd) {
@@ -7723,7 +7765,7 @@ function describeError(e) {
   return e instanceof Error ? e.message : String(e);
 }
 function label3(cwd, filePath, count) {
-  return `${path25.relative(cwd, filePath)} (${count} records)`;
+  return `${path26.relative(cwd, filePath)} (${count} records)`;
 }
 async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
   const records = readRecords(filePath);
@@ -7731,7 +7773,7 @@ async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
     try {
       await pb.collection(collectionName).create(record);
     } catch (e) {
-      throw new DataLoadError(kind, path25.relative(cwd, filePath), index, e);
+      throw new DataLoadError(kind, path26.relative(cwd, filePath), index, e);
     }
   }
   return records.length;
@@ -7906,7 +7948,7 @@ var reset = new Command59("reset").description("clear and reload fixtures").conf
 
 // src/commands/fixtures/generate.ts
 import fs29 from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 import { Command as Command60, InvalidArgumentError } from "commander";
 import * as p37 from "@clack/prompts";
 import { annotate } from "annotate-json-schema";
@@ -7945,7 +7987,7 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
   const fixturesDir = dataDir(workspaceRootDir, "fixtures");
   fs29.mkdirSync(fixturesDir, { recursive: true });
   for (const file of fs29.readdirSync(fixturesDir)) {
-    if (file.endsWith(".json")) fs29.unlinkSync(path26.join(fixturesDir, file));
+    if (file.endsWith(".json")) fs29.unlinkSync(path27.join(fixturesDir, file));
   }
   if (opts.seed !== void 0) faker.seed(opts.seed);
   const generator = createGenerator({
@@ -8012,8 +8054,8 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
       items.push(record);
     }
     const filename = `${padZeros(fileIndex, 2)}-${collection.name}.json`;
-    fs29.writeFileSync(path26.join(fixturesDir, filename), JSON.stringify(items, null, 2));
-    writtenFiles.push(`${path26.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
+    fs29.writeFileSync(path27.join(fixturesDir, filename), JSON.stringify(items, null, 2));
+    writtenFiles.push(`${path27.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
     fileIndex++;
   }
   return { writtenFiles, warnings };
@@ -8161,7 +8203,7 @@ var load2 = new Command63("load").description("load seeds into the database").op
 
 // src/commands/seeds/save.ts
 import fs30 from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 import { Command as Command64 } from "commander";
 var padZeros2 = (num, length) => num.toString().padStart(length, "0");
 function filterSystemFields(record, systemFieldNames) {
@@ -8184,7 +8226,7 @@ var save = new Command64("save").description("save the current data as seeds").o
     fs30.mkdirSync(seedsPath, { recursive: true });
     if (opts.force) {
       for (const file of fs30.readdirSync(seedsPath)) {
-        if (file.endsWith(".json")) fs30.unlinkSync(path27.join(seedsPath, file));
+        if (file.endsWith(".json")) fs30.unlinkSync(path28.join(seedsPath, file));
       }
     }
     const saved = [];
@@ -8213,12 +8255,12 @@ var save = new Command64("save").description("save the current data as seeds").o
         const filtered = records.map(
           (r) => filterSystemFields(r, systemFieldNames)
         );
-        const relativeSeedPath = path27.join(
+        const relativeSeedPath = path28.join(
           DATA_DIR,
           "seeds",
           `${padZeros2(count, 2)}-${collectionName}.json`
         );
-        const seedPath = path27.join(workspaceRootDir, relativeSeedPath);
+        const seedPath = path28.join(workspaceRootDir, relativeSeedPath);
         fs30.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
         saved.push(`${relativeSeedPath} (${filtered.length} records)`);
         count++;
@@ -8357,7 +8399,7 @@ import { Command as Command75 } from "commander";
 import { Command as Command70 } from "commander";
 
 // src/lib/migrate.ts
-import path28 from "node:path";
+import path29 from "node:path";
 import process23 from "node:process";
 import { x as x2 } from "tinyexec";
 async function runPocketbaseMigrate(args) {
@@ -8368,9 +8410,9 @@ async function runPocketbaseMigrate(args) {
     binaryPath,
     [
       "--dir",
-      path28.join(cwd, DATA_DIR),
+      path29.join(cwd, DATA_DIR),
       "--migrationsDir",
-      path28.join(cwd, MIGRATIONS_DIR),
+      path29.join(cwd, MIGRATIONS_DIR),
       "migrate",
       ...args
     ],
@@ -8419,7 +8461,7 @@ var down = new Command71("down").alias("rollback").description("revert the last
 
 // src/commands/migrate/create.ts
 import fs31 from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 import process24 from "node:process";
 import { Command as Command72 } from "commander";
 var create2 = new Command72("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
@@ -8431,7 +8473,7 @@ var create2 = new Command72("create").alias("new").description("create a new bla
     const added = [...after].filter((f) => !before.has(f));
     reportResult({
       summary: `Created blank migration ${name}.`,
-      filesCreated: added.map((f) => path29.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path30.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Open the new file in ${MIGRATIONS_DIR}/ and fill in the up/down handlers.`,
         "Run `vela migrate up` to apply the migration once the handlers are written."
@@ -8440,14 +8482,14 @@ var create2 = new Command72("create").alias("new").description("create a new bla
   }, "Failed to create migration.")
 );
 function listMigrationFiles(cwd) {
-  const dir = path29.join(cwd, MIGRATIONS_DIR);
+  const dir = path30.join(cwd, MIGRATIONS_DIR);
   if (!fs31.existsSync(dir)) return /* @__PURE__ */ new Set();
   return new Set(fs31.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/collections.ts
 import fs32 from "node:fs";
-import path30 from "node:path";
+import path31 from "node:path";
 import process25 from "node:process";
 import { Command as Command73 } from "commander";
 var collections = new Command73("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
@@ -8465,7 +8507,7 @@ var collections = new Command73("collections").alias("snapshot").description("sn
     }
     reportResult({
       summary: "Snapshotted local collections into a new migration.",
-      filesCreated: added.map((f) => path30.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path31.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Review the generated snapshot in ${MIGRATIONS_DIR}/.`,
         "Commit the snapshot so teammates pick up the new schema.",
@@ -8475,7 +8517,7 @@ var collections = new Command73("collections").alias("snapshot").description("sn
   }, "Failed to snapshot collections.")
 );
 function listMigrationFiles2(cwd) {
-  const dir = path30.join(cwd, MIGRATIONS_DIR);
+  const dir = path31.join(cwd, MIGRATIONS_DIR);
   if (!fs32.existsSync(dir)) return /* @__PURE__ */ new Set();
   return new Set(fs32.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
@@ -8497,7 +8539,7 @@ var migrate = new Command75("migrate").description("manage database migrations")
 
 // src/commands/dev.ts
 import fs33 from "node:fs";
-import path32 from "node:path";
+import path33 from "node:path";
 import process27 from "node:process";
 import { performance } from "node:perf_hooks";
 import { Command as Command76, InvalidArgumentError as InvalidArgumentError4 } from "commander";
@@ -8529,7 +8571,7 @@ function createPocketbaseLogFilter() {
 }
 
 // src/lib/vite.ts
-import path31 from "node:path";
+import path32 from "node:path";
 import process26 from "node:process";
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -8549,7 +8591,7 @@ function viteVersionError(version) {
 }
 function resolveProjectVite(cwd) {
   try {
-    return createRequire2(path31.join(cwd, "package.json")).resolve("vite");
+    return createRequire2(path32.join(cwd, "package.json")).resolve("vite");
   } catch {
     return null;
   }
@@ -8578,8 +8620,8 @@ var dev = new Command76("dev").description("start the development server").optio
   process27.env.VELA_DATA_DIR ??= localDataDir(cwd);
   const startTime = performance.now();
   const { createServer, version } = await loadVite(cwd);
-  const viteMetadataDir = path32.join(cwd, "node_modules", ".vite");
-  const viteMetadataFile = path32.join(viteMetadataDir, "_pocketbase_metadata.json");
+  const viteMetadataDir = path33.join(cwd, "node_modules", ".vite");
+  const viteMetadataFile = path33.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
   const needsStart = backend3 && !process27.env.POCKETBASE_URL;
@@ -8588,11 +8630,11 @@ var dev = new Command76("dev").description("start the development server").optio
     if (fs33.existsSync(viteMetadataFile)) fs33.rmSync(viteMetadataFile);
   };
   if (needsStart) {
-    const dataDir2 = path32.join(cwd, DATA_DIR);
+    const dataDir2 = path33.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path32.join(dataDir2, "hooks"),
+      hooksDir: path33.join(dataDir2, "hooks"),
       dev: true,
       stdio: "pipe"
     });
@@ -8657,9 +8699,9 @@ var dev = new Command76("dev").description("start the development server").optio
 });
 async function startWatchingTypes(cwd, pb) {
   const { processTypes } = await import("@velastack/pocketbase-codegen");
-  const typesDir = path32.resolve(cwd, ".svelte-kit", "types");
-  const pocketbaseDir = path32.join(typesDir, "pocketbase");
-  const pocketbaseTypes = path32.join(pocketbaseDir, "$types.d.ts");
+  const typesDir = path33.resolve(cwd, ".svelte-kit", "types");
+  const pocketbaseDir = path33.join(typesDir, "pocketbase");
+  const pocketbaseTypes = path33.join(pocketbaseDir, "$types.d.ts");
   const regenerate = () => processTypes(pb, typesDir).catch(() => {
   });
   await regenerate();
@@ -8681,7 +8723,7 @@ async function startWatchingTypes(cwd, pb) {
 
 // src/commands/build.ts
 import fs34 from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 import process29 from "node:process";
 import { Command as Command77 } from "commander";
 import * as p42 from "@clack/prompts";
@@ -8719,7 +8761,7 @@ function splitHosts(value) {
 }
 
 // src/commands/build.ts
-var PRERENDERED_DIR = path33.join(".svelte-kit", "output", "prerendered");
+var PRERENDERED_DIR = path34.join(".svelte-kit", "output", "prerendered");
 var build = new Command77("build").description("build the app").configureHelp(helpConfig).option("-t, --target <target>", "which copy of the app to build for", PRODUCTION_TARGET).action(async (options) => {
   const cwd = process29.cwd();
   applyBuildEnv(cwd);
@@ -8732,11 +8774,11 @@ var build = new Command77("build").description("build the app").configureHelp(he
   };
   if (needsStart) {
     await ensureSuperuser(cwd);
-    const dataDir2 = path33.join(cwd, DATA_DIR);
+    const dataDir2 = path34.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path33.join(dataDir2, "hooks"),
+      hooksDir: path34.join(dataDir2, "hooks"),
       dev: true
     });
     pbProc = started.proc;
@@ -8775,7 +8817,7 @@ async function originForBuild(cwd, target) {
   }
 }
 function warnIfPrerendered(cwd) {
-  const dir = path33.join(cwd, PRERENDERED_DIR);
+  const dir = path34.join(cwd, PRERENDERED_DIR);
   if (!fs34.existsSync(dir) || fs34.readdirSync(dir).length === 0) return;
   p42.log.warn(
     `Prerendered pages were built with no domain configured, so their canonical
@@ -8786,7 +8828,7 @@ Set one with ${pc16.cyan("vela deploy --domain example.com")}, or pass ${pc16.cy
 }
 
 // src/commands/preview.ts
-import path34 from "node:path";
+import path35 from "node:path";
 import process30 from "node:process";
 import { Command as Command78 } from "commander";
 import { x as x4 } from "tinyexec";
@@ -8801,11 +8843,11 @@ var preview = new Command78("preview").description("preview the built app").conf
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
-    const dataDir2 = path34.join(cwd, DATA_DIR);
+    const dataDir2 = path35.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path34.join(dataDir2, "hooks"),
+      hooksDir: path35.join(dataDir2, "hooks"),
       dev: true
     });
     pbProc = started.proc;
@@ -8831,12 +8873,12 @@ var preview = new Command78("preview").description("preview the built app").conf
 });
 
 // src/commands/sync.ts
-import path35 from "node:path";
+import path36 from "node:path";
 import { Command as Command79 } from "commander";
 var sync = new Command79("sync").description("sync types from the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const typesDir = path35.join(workspaceRootDir, ".svelte-kit", "types");
+    const typesDir = path36.join(workspaceRootDir, ".svelte-kit", "types");
     const { processTypes } = await import("@velastack/pocketbase-codegen");
     await withPocketbase(workspaceRootDir, async (pb) => {
       await processTypes(pb, typesDir);
@@ -8898,7 +8940,7 @@ var provision = addSshOptions(
 );
 
 // src/commands/deploy.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import fs37 from "node:fs";
 import { Command as Command81, Option as Option2 } from "commander";
 import * as p44 from "@clack/prompts";
@@ -8907,12 +8949,12 @@ import * as v8 from "valibot";
 
 // src/lib/pocketbase-settings.ts
 import fs35 from "node:fs";
-import path36 from "node:path";
+import path37 from "node:path";
 import process31 from "node:process";
 import PocketBase5 from "pocketbase";
 var COPIED_KEYS = ["appName", "senderName", "senderAddress"];
 async function readLocalMeta(cwd) {
-  const dataDir2 = path36.join(cwd, DATA_DIR);
+  const dataDir2 = path37.join(cwd, DATA_DIR);
   if (!fs35.existsSync(dataDir2)) return null;
   const email3 = process31.env.POCKETBASE_SUPERUSER_EMAIL;
   const password11 = process31.env.POCKETBASE_SUPERUSER_PASSWORD;
@@ -8922,7 +8964,7 @@ async function readLocalMeta(cwd) {
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path36.join(dataDir2, "hooks")
+      hooksDir: path37.join(dataDir2, "hooks")
     });
     proc = started.proc;
     const pb = new PocketBase5(started.url);
@@ -8965,7 +9007,7 @@ async function seedRemoteMeta(session, instance, local, appURL) {
 
 // src/lib/adapter.ts
 import fs36 from "node:fs";
-import path37 from "node:path";
+import path38 from "node:path";
 import {
   Project as Project2,
   QuoteKind as QuoteKind2,
@@ -9021,7 +9063,7 @@ function resolveKitTarget(root) {
   }
   const sveltePath = probeFirstExisting(root, SVELTE_CONFIG_CANDIDATES);
   if (sveltePath) {
-    const name = path37.basename(sveltePath);
+    const name = path38.basename(sveltePath);
     if (sveltePath.endsWith(".cjs")) {
       throw new AdapterError(`${name} is CommonJS, which vela does not edit.`);
     }
@@ -9041,7 +9083,7 @@ function resolveKitTarget(root) {
     };
   }
   if (vite?.sveltekitCall) {
-    const name = path37.basename(vite.filePath);
+    const name = path38.basename(vite.filePath);
     if (vite.nonObjectArg) {
       throw new AdapterError(`${name} passes sveltekit() something other than an object literal.`);
     }
@@ -9094,7 +9136,7 @@ function inspectAdapter(target) {
 async function ensureNodeAdapter(root, { install = true } = {}) {
   const target = resolveKitTarget(root);
   const { info, importDecl } = inspectAdapter(target);
-  const name = path37.basename(target.filePath);
+  const name = path38.basename(target.filePath);
   const outcome = {
     previous: info.kind,
     removedDeps: [],
@@ -9127,7 +9169,7 @@ vela deploy runs the app as a Node server, which needs ${ADAPTER_NODE}:`
       break;
   }
   if (outcome.configFile) saveTarget(target);
-  const pkgPath = path37.join(root, "package.json");
+  const pkgPath = path38.join(root, "package.json");
   if (fs36.existsSync(pkgPath)) {
     const pkg = readPackageJson(pkgPath);
     const { changed, removed } = adoptNodeAdapter(pkg);
@@ -9180,7 +9222,7 @@ function addAdapter(target) {
   const taken = importOf(target.sourceFile, "adapter") ?? target.sourceFile.getVariableDeclaration("adapter");
   if (taken) {
     throw new AdapterError(
-      `${path37.basename(target.filePath)} already binds the name \`adapter\` to something that is not the SvelteKit adapter.`
+      `${path38.basename(target.filePath)} already binds the name \`adapter\` to something that is not the SvelteKit adapter.`
     );
   }
   target.sourceFile.addImportDeclaration({
@@ -9591,7 +9633,7 @@ function isDirectory(target) {
 async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
-  if (!fs37.existsSync(path38.join(workspaceRootDir, ".env"))) return;
+  if (!fs37.existsSync(path39.join(workspaceRootDir, ".env"))) return;
   p44.log.warn(
     `This app has no production environment variables yet.
 
@@ -9609,7 +9651,7 @@ async function serverTimeOrLocal(session) {
 }
 
 // src/commands/link.ts
-import path39 from "node:path";
+import path40 from "node:path";
 import process32 from "node:process";
 import { Command as Command82 } from "commander";
 import * as p45 from "@clack/prompts";
@@ -9672,12 +9714,12 @@ async function promptProjectName(workspaceRootDir) {
 }
 function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path39.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path40.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path39.basename(workspaceRootDir);
+  return path40.basename(workspaceRootDir);
 }
 
 // src/commands/env.ts
@@ -9809,7 +9851,7 @@ var envUnset = addTargetOptions(
 
 // src/commands/env/import.ts
 import fs38 from "node:fs";
-import path40 from "node:path";
+import path41 from "node:path";
 import process34 from "node:process";
 import { Command as Command86 } from "commander";
 import * as p49 from "@clack/prompts";
@@ -9855,7 +9897,7 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path40.resolve(process34.cwd(), file);
+  return path41.resolve(process34.cwd(), file);
 }
 function read(resolved, shown) {
   if (!fs38.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
@@ -10137,7 +10179,7 @@ import { Command as Command98 } from "commander";
 
 // src/commands/backup/create.ts
 import fs39 from "node:fs";
-import path41 from "node:path";
+import path42 from "node:path";
 import { Command as Command93 } from "commander";
 import * as p53 from "@clack/prompts";
 import pc26 from "picocolors";
@@ -10291,12 +10333,12 @@ Your bucket's own versioning is what protects the uploaded files.`
   }, "Failed to create the backup.")
 );
 async function download(ctx, key, outputDir) {
-  const dir = path41.resolve(ctx.workspaceRootDir, outputDir);
+  const dir = path42.resolve(ctx.workspaceRootDir, outputDir);
   fs39.mkdirSync(dir, { recursive: true });
-  const destination = path41.join(dir, key);
+  const destination = path42.join(dir, key);
   if (!ctx.session) {
-    fs39.copyFileSync(path41.join(ctx.workspaceRootDir, "data", "backups", key), destination);
-    return path41.relative(ctx.workspaceRootDir, destination);
+    fs39.copyFileSync(path42.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+    return path42.relative(ctx.workspaceRootDir, destination);
   }
   const spinner8 = p53.spinner();
   spinner8.start(`Downloading ${key}`);
@@ -10307,7 +10349,7 @@ async function download(ctx, key, outputDir) {
     throw error;
   }
   spinner8.stop(`Downloaded ${key}`);
-  return path41.relative(ctx.workspaceRootDir, destination);
+  return path42.relative(ctx.workspaceRootDir, destination);
 }
 
 // src/commands/backup/list.ts
@@ -10342,7 +10384,7 @@ Take one with ${pc27.cyan("vela backup create")}.`
 
 // src/commands/backup/download.ts
 import fs40 from "node:fs";
-import path42 from "node:path";
+import path43 from "node:path";
 import { Command as Command95 } from "commander";
 import * as p55 from "@clack/prompts";
 import pc28 from "picocolors";
@@ -10369,11 +10411,11 @@ Run ${pc28.cyan("vela backup list")} to see what it does have.`
 Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
         );
       }
-      const dir = path42.resolve(ctx.workspaceRootDir, options.output);
+      const dir = path43.resolve(ctx.workspaceRootDir, options.output);
       fs40.mkdirSync(dir, { recursive: true });
-      const destination = path42.join(dir, key);
+      const destination = path43.join(dir, key);
       if (!ctx.session) {
-        fs40.copyFileSync(path42.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+        fs40.copyFileSync(path43.join(ctx.workspaceRootDir, "data", "backups", key), destination);
       } else {
         const spinner8 = p55.spinner();
         spinner8.start(`Downloading ${key} (${formatBytes(found.size)})`);
@@ -10387,7 +10429,7 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
       }
       reportResult({
         summary: `Saved ${key} from ${ctx.targetName}.`,
-        filesCreated: [path42.relative(ctx.workspaceRootDir, destination)]
+        filesCreated: [path43.relative(ctx.workspaceRootDir, destination)]
       });
     });
   }, "Failed to download the backup.")
@@ -10483,7 +10525,7 @@ var backup = new Command98("backup").description("back up the database and uploa
 
 // src/commands/restore.ts
 import fs41 from "node:fs";
-import path43 from "node:path";
+import path44 from "node:path";
 import process37 from "node:process";
 import { Command as Command99 } from "commander";
 import * as p58 from "@clack/prompts";
@@ -10529,7 +10571,7 @@ var restore = addLockWaitOption(
           });
           p58.log.success(
             `Restored ${pc31.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${pc31.cyan(
-              local ? path43.basename(local) : key
+              local ? path44.basename(local) : key
             )}.`
           );
           if (result?.storageCarriedOver) {
@@ -10595,21 +10637,21 @@ Take one with ${pc31.cyan("vela backup create")}, or pass the path to an archive
 }
 async function stage(ctx, file) {
   const dir = remotePaths.restoreStage(ctx.instance);
-  const remote = `${dir}/${path43.basename(file)}`;
+  const remote = `${dir}/${path44.basename(file)}`;
   const spinner8 = p58.spinner();
-  spinner8.start(`Uploading ${path43.basename(file)}`);
+  spinner8.start(`Uploading ${path44.basename(file)}`);
   try {
     await ctx.session.script(`mkdir -p "$1"`, { args: [dir] });
     await ctx.session.upload([file], dir);
   } catch (error) {
-    spinner8.stop(`Could not upload ${path43.basename(file)}.`);
+    spinner8.stop(`Could not upload ${path44.basename(file)}.`);
     throw error;
   }
-  spinner8.stop(`Uploaded ${path43.basename(file)}`);
+  spinner8.stop(`Uploaded ${path44.basename(file)}`);
   return remote;
 }
 async function confirm13(appName, targetName, envTag, from) {
-  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path43.basename(from))}`;
+  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path44.basename(from))}`;
   if (isProd(envTag)) {
     const answer = await p58.text({
       message: `This replaces the database and uploads of ${what}. Type the app name to confirm`,
@@ -10720,7 +10762,7 @@ Release and domain are shown from what this project recorded.`
 }
 
 // src/commands/test.ts
-import path44 from "node:path";
+import path45 from "node:path";
 import process38 from "node:process";
 import { Command as Command101 } from "commander";
 import PocketBase6 from "pocketbase";
@@ -10733,15 +10775,15 @@ var testServer = new Command101("test:server").description("run server tests").a
   const cwd = process38.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password11 = "password";
-  const testDataDir = path44.join(cwd, "test-data");
+  const testDataDir = path45.join(cwd, "test-data");
   fs42.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path44.join(cwd, MIGRATIONS_DIR),
+    migrationsDir: path45.join(cwd, MIGRATIONS_DIR),
     // The app's PocketBase hooks (slug generation, personal teams, …) are part
     // of its behaviour; the suite runs against the same server dev and build
     // start, so it loads them from the same place.
-    hooksDir: path44.join(cwd, DATA_DIR, "hooks"),
+    hooksDir: path45.join(cwd, DATA_DIR, "hooks"),
     email: email3,
     password: password11
   });
@@ -10859,7 +10901,7 @@ function stubPagesPlugin() {
 
 // src/commands/routes.ts
 import fs43 from "node:fs";
-import path45 from "node:path";
+import path46 from "node:path";
 import { Command as Command102 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
@@ -10873,7 +10915,7 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
 ]);
 var routes = new Command102("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path45.join(workspaceRootDir, routesDir);
+  const routesRoot = path46.join(workspaceRootDir, routesDir);
   const found = walk(routesRoot, routesRoot).filter((r) => r.methods.length > 0);
   found.sort((a, b) => a.urlPattern.localeCompare(b.urlPattern));
   printTable(found);
@@ -10883,20 +10925,20 @@ function walk(root, dir) {
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
-    const id = "/" + path45.relative(root, dir).split(path45.sep).filter(Boolean).join("/");
+    const id = "/" + path46.relative(root, dir).split(path46.sep).filter(Boolean).join("/");
     const urlPattern = id.replace(/\([^)]+\)\/?/g, "").replace(/\/$/, "") || "/";
     const methods = /* @__PURE__ */ new Set();
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (entry.name.endsWith("+page.svelte")) methods.add("GET");
       if (entry.name.endsWith("+server.ts") || entry.name.endsWith("+server.js") || entry.name.endsWith("+page.server.ts") || entry.name.endsWith("+page.server.js")) {
-        extractMethods(path45.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path46.join(dir, entry.name)).forEach((m) => methods.add(m));
       }
     }
     routes2.push({ id: id || "/", urlPattern, methods: [...methods] });
   }
   for (const entry of entries) {
-    if (entry.isDirectory()) routes2.push(...walk(root, path45.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path46.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -11084,7 +11126,7 @@ import pc36 from "picocolors";
 
 // src/lib/cms-backend.ts
 import { createRequire as createRequire3 } from "node:module";
-import path46 from "node:path";
+import path47 from "node:path";
 import process41 from "node:process";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import pc35 from "picocolors";
@@ -11092,7 +11134,7 @@ var DEFAULT_PROJECT = "default";
 async function loadBackendModule(root) {
   let entry;
   try {
-    entry = createRequire3(path46.join(root, "package.json")).resolve("@velastack/cms/backend");
+    entry = createRequire3(path47.join(root, "package.json")).resolve("@velastack/cms/backend");
   } catch {
     throw new Error(
       `@velastack/cms is not installed in this project.
@@ -11110,8 +11152,8 @@ async function withCmsBackend(fn, cwd = process41.cwd()) {
   const { createCmsBackend } = await loadBackendModule(root);
   const dataDir2 = localDataDir(root);
   const backend3 = createCmsBackend({
-    dbPath: path46.join(dataDir2, "cms.sqlite"),
-    uploadDir: path46.join(dataDir2, "uploads")
+    dbPath: path47.join(dataDir2, "cms.sqlite"),
+    uploadDir: path47.join(dataDir2, "uploads")
   });
   try {
     return await fn(backend3);
@@ -11372,14 +11414,14 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (isStub(actionCommand)) return;
   const envRoot = findWorkspaceRoot() ?? process45.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
-  const path47 = getCommandPath(actionCommand);
-  if (NO_BACKEND_COMMMANDS.has(path47)) return;
-  const top = path47.split(" ", 1)[0];
+  const path48 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path48)) return;
+  const top = path48.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
     p67.log.error(
-      `${pc42.cyan(`vela ${path47}`)} needs a backend, and this project does not have one.
+      `${pc42.cyan(`vela ${path48}`)} needs a backend, and this project does not have one.
 
 Static projects have no database to talk to.
 
@@ -11389,7 +11431,7 @@ To add a backend to this project, run ${pc42.cyan("vela bless")}.`
     p67.cancel("Operation failed.");
     process45.exit(1);
   }
-  if (SELF_CREDENTIALED_COMMANDS.has(path47)) return;
+  if (SELF_CREDENTIALED_COMMANDS.has(path48)) return;
   if (!process45.env.POCKETBASE_SUPERUSER_EMAIL || !process45.env.POCKETBASE_SUPERUSER_PASSWORD) {
     p67.log.error(
       `PocketBase superuser credentials are required.