vela 0.13.3 → 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.3",
+  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.9",
+    "@velastack/patterns": "^0.2.11",
     "@velastack/pocketbase-codegen": "^0.1.0",
     "annotate-json-schema": "^0.1.0",
     commander: "^13.1.0",
@@ -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);
@@ -316,7 +344,7 @@ function dropTemplateAdapters(user, template) {
   return copy;
 }
 function readPackageJson(path48) {
-  return JSON.parse(fs.readFileSync(path48, "utf8"));
+  return JSON.parse(fs2.readFileSync(path48, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -335,11 +363,11 @@ function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
 function readTemplatePackageJson(path48, values) {
-  const raw = fillTemplatePlaceholders(fs.readFileSync(path48, "utf8"), values);
+  const raw = fillTemplatePlaceholders(fs2.readFileSync(path48, "utf8"), values);
   return JSON.parse(raw);
 }
 function writePackageJson(path48, pkg) {
-  fs.writeFileSync(path48, JSON.stringify(pkg, null, "	") + "\n");
+  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,7 +2699,7 @@ async function runPattern(slug2, argv, input, report4) {
     throw new Error(`Unknown pattern: ${slug2}`);
   }
   checkProviderInput(pattern, argv, input);
-  const { workspaceRootDir, features } = await getWorkspace();
+  const { workspaceRootDir, features, routeGroups } = await getWorkspace();
   const log50 = p9.taskLog({ title: report4.task.title });
   let result;
   try {
@@ -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)
@@ -2751,24 +2760,22 @@ async function runPattern(slug2, argv, input, report4) {
 
 // src/lib/form-ui.ts
 import path17 from "node:path";
-var FORM_UIS = ["shadcn", "plain"];
+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]);
-  const shadcn = readComponentsJson(root) !== void 0 && (hasDep("shadcn-svelte") || hasDep("bits-ui"));
   return {
-    ui: shadcn ? "shadcn" : "plain",
     flash: hasDep("sveltekit-flash-message"),
     serverTests: hasDep("supertest")
   };
 }
-function resolveFormInput(root, requested) {
+function resolveFormInput(root, detectedUi, requested) {
   const detected = detectFormInput(root);
   if (requested === void 0) return detected;
-  if (!FORM_UIS.includes(requested)) {
-    throw new Error(`Unknown --ui "${requested}". Expected one of: ${FORM_UIS.join(", ")}.`);
+  if (!UIS.includes(requested)) {
+    throw new Error(`Unknown --ui "${requested}". Expected one of: ${UIS.join(", ")}.`);
   }
-  if (requested === "shadcn" && detected.ui !== "shadcn") {
+  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."
     );
@@ -3063,7 +3070,7 @@ function writeLayoutSidecar(workspaceRootDir, modelName, layout) {
 // 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.'
@@ -3099,9 +3106,9 @@ var form = new Command5("form").description("generate a form from a model").argu
       argv = [model, ...fields];
       modelName = model;
     }
-    const { workspaceRootDir } = await getWorkspace();
-    const formInput = resolveFormInput(workspaceRootDir, options.ui);
-    if (formInput.ui === "plain" && !options.ui) {
+    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";
@@ -3207,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)"