vela 0.11.0 → 0.11.2

package/dist/bin.js

@@ -21,7 +21,7 @@ import pc38 from "picocolors";
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.11.0",
+  version: "0.11.2",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -71,6 +71,7 @@ var package_default = {
     "pocketbase-server": "^0.39.11",
     stripe: "^19.3.0",
     svelte: "^5.56.10",
+    tar: "^7.5.22",
     tinyexec: "^1.3.0",
     "ts-morph": "^28.0.0",
     valibot: "^1.4.2"
@@ -236,6 +237,7 @@ 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
 import fs from "node:fs";
@@ -286,8 +288,8 @@ function mergePackageJson(user, template) {
   }
   return { merged, added, conflicts, replaced };
 }
-function readPackageJson(path45) {
-  return JSON.parse(fs.readFileSync(path45, "utf8"));
+function readPackageJson(path46) {
+  return JSON.parse(fs.readFileSync(path46, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -300,12 +302,12 @@ function fillTemplatePlaceholders(raw, values) {
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
-function readTemplatePackageJson(path45, values) {
-  const raw = fillTemplatePlaceholders(fs.readFileSync(path45, "utf8"), values);
+function readTemplatePackageJson(path46, values) {
+  const raw = fillTemplatePlaceholders(fs.readFileSync(path46, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path45, pkg) {
-  fs.writeFileSync(path45, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path46, pkg) {
+  fs.writeFileSync(path46, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -383,10 +385,10 @@ function detectFeatures(root, { isAppMode, isPaymentsMode }) {
 }
 
 // src/commands/bless.ts
-import fs13 from "node:fs";
-import path11 from "node:path";
-import process6 from "node:process";
-import * as v2 from "valibot";
+import fs15 from "node:fs";
+import path13 from "node:path";
+import process7 from "node:process";
+import * as v3 from "valibot";
 import { Command as Command2 } from "commander";
 import * as p4 from "@clack/prompts";
 import pc3 from "picocolors";
@@ -420,32 +422,279 @@ function toFlag(key) {
 }
 
 // src/lib/templates.ts
+import fs6 from "node:fs";
+import path5 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";
+var PUBLISH_SAFE_NAMES = {
+  ".gitignore": "_gitignore",
+  ".npmrc": "_npmrc"
+};
+function templateName(projectRelPath) {
+  const safe = PUBLISH_SAFE_NAMES[path2.basename(projectRelPath)];
+  if (!safe) return projectRelPath;
+  const dir = path2.dirname(projectRelPath);
+  return dir === "." ? safe : path2.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));
+  }
+}
+var TEMPLATE_SOURCE = /\.template\.([^.]+)$/;
+function applyTemplateFiles(target, values) {
+  const written = [];
+  for (const source of findTemplateSources(target)) {
+    const raw = fs3.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));
+  }
+  return written.sort();
+}
+function findTemplateSources(dir) {
+  const found = [];
+  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      found.push(...findTemplateSources(full));
+    } else if (entry.isFile() && TEMPLATE_SOURCE.test(entry.name)) {
+      found.push(full);
+    }
+  }
+  return found;
+}
+
+// src/lib/template-registry.ts
+import fs5 from "node:fs";
+import os2 from "node:os";
+import path4 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 os from "node:os";
+import path3 from "node:path";
+import process4 from "node:process";
+function configDir() {
+  return path3.join(os.homedir(), ".vela");
+}
+var CONFIG_DIR = configDir();
+var CONFIG_PATH = path3.join(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!fs4.existsSync(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(fs4.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));
+}
+function clearConfig() {
+  if (fs4.existsSync(CONFIG_PATH)) fs4.unlinkSync(CONFIG_PATH);
+}
+function readApiKey() {
+  const fromEnv = process4.env.VELA_API_KEY?.trim();
+  if (fromEnv) return fromEnv;
+  return readConfig()?.apiKey ?? null;
+}
+function requireApiKey() {
+  const apiKey = readApiKey();
+  if (!apiKey) {
+    throw new Error("Not logged in. Run `vela login` to login, or set VELA_API_KEY.");
+  }
+  return apiKey;
+}
+
+// src/lib/template-registry.ts
+var CACHE_DIR_NAME = "templates";
+var INDEX_CACHE_FILE = "index.json";
+var TARBALL_CACHE_DIR = "cache";
+var INDEX_CACHE_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var entrySchema = v2.object({
+  name: v2.pipe(v2.string(), v2.regex(/^[a-z0-9][a-z0-9-]*$/)),
+  description: v2.string(),
+  backend: v2.boolean(),
+  title: v2.optional(v2.string()),
+  category: v2.optional(v2.string()),
+  tags: v2.optional(v2.array(v2.string())),
+  price: v2.optional(v2.number()),
+  previewUrl: v2.optional(v2.string()),
+  nextSteps: v2.optional(v2.array(v2.string())),
+  /** Tarball location, relative to the index URL. */
+  file: v2.string(),
+  sha256: v2.pipe(v2.string(), v2.regex(/^[0-9a-f]{64}$/)),
+  size: v2.optional(v2.number()),
+  version: v2.optional(v2.string())
+});
+var indexSchema = v2.object({
+  schemaVersion: v2.literal(1),
+  templates: v2.array(v2.unknown())
+});
+function cacheRoot() {
+  return path4.join(configDir(), CACHE_DIR_NAME);
+}
+function indexCachePath() {
+  return path4.join(cacheRoot(), INDEX_CACHE_FILE);
+}
+function readCachedIndex(url) {
+  const file = indexCachePath();
+  if (!fs5.existsSync(file)) return null;
+  try {
+    const cached2 = JSON.parse(fs5.readFileSync(file, "utf8"));
+    if (cached2.url !== url) return null;
+    return cached2;
+  } catch {
+    return null;
+  }
+}
+function writeCachedIndex(cached2) {
+  fs5.mkdirSync(cacheRoot(), { recursive: true });
+  fs5.writeFileSync(indexCachePath(), JSON.stringify(cached2, null, 2));
+}
+function parseTemplateIndex(text18, url) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text18);
+  } catch (e) {
+    throw new Error(`Template index at ${url} is not valid JSON: ${e.message}`);
+  }
+  const doc = v2.safeParse(indexSchema, parsed);
+  if (!doc.success) {
+    throw new Error(`Template index at ${url} has an unsupported format`);
+  }
+  const templates = [];
+  let skipped = 0;
+  for (const raw of doc.output.templates) {
+    const entry = v2.safeParse(entrySchema, raw);
+    if (entry.success) templates.push(entry.output);
+    else skipped++;
+  }
+  return { url, templates, skipped };
+}
+function isFileUrl(url) {
+  return url.startsWith("file:");
+}
+async function readBytes(url, options) {
+  if (isFileUrl(url)) {
+    return new Uint8Array(fs5.readFileSync(fileURLToPath(url)));
+  }
+  const res = await fetch(url, {
+    headers: options.headers,
+    signal: AbortSignal.timeout(options.timeoutMs)
+  });
+  if (!res.ok) {
+    throw new Error(`${res.status} ${res.statusText}`.trim());
+  }
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function fetchTemplateIndex(url, options = {}) {
+  const now = options.now ?? Date.now();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const cached2 = options.noCache ? null : readCachedIndex(url);
+  if (cached2 && now - cached2.fetchedAt < INDEX_CACHE_TTL_MS && !isFileUrl(url)) {
+    return { index: cached2.index, stale: false };
+  }
+  try {
+    const bytes = await readBytes(url, { timeoutMs, headers: options.headers });
+    const index = parseTemplateIndex(Buffer.from(bytes).toString("utf8"), url);
+    if (!options.noCache && !isFileUrl(url)) {
+      writeCachedIndex({ url, fetchedAt: now, index });
+    }
+    return { index, stale: false };
+  } catch (e) {
+    const reason = e.message;
+    if (cached2) return { index: cached2.index, stale: true, reason };
+    return { index: null, stale: false, reason };
+  }
+}
+function resolveDownloadUrl(entry, indexUrl) {
+  return new URL(entry.file, indexUrl).href;
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function tarballCachePath(entry) {
+  return path4.join(
+    cacheRoot(),
+    TARBALL_CACHE_DIR,
+    `${entry.name}-${entry.sha256.slice(0, 12)}.tgz`
+  );
+}
+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));
+    haveTarball = sha256(cached2) === entry.sha256;
+  }
+  if (!haveTarball) {
+    const url = resolveDownloadUrl(entry, indexUrl);
+    let fetched;
+    try {
+      fetched = await readBytes(url, { timeoutMs, headers: options.headers });
+    } catch (e) {
+      throw new Error(`Could not download template ${entry.name}: ${e.message}`);
+    }
+    const digest = sha256(fetched);
+    if (digest !== entry.sha256) {
+      throw new Error(
+        `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);
+  }
+  const dir = fs5.mkdtempSync(path4.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 });
+    throw new Error(`Could not unpack template ${entry.name}: ${e.message}`);
+  }
+  return dir;
+}
+
+// src/lib/templates.ts
 var TEMPLATE_MANIFEST = "template.json";
 var DEFAULT_TEMPLATE = "minimal";
+var DEFAULT_CATEGORY = "starter";
 var cached;
 function templatesDir() {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
-  const { root } = path2.parse(dir);
+  let dir = path5.dirname(fileURLToPath2(import.meta.url));
+  const { root } = path5.parse(dir);
   while (dir !== root) {
-    const candidate = path2.join(dir, "templates");
+    const candidate = path5.join(dir, "templates");
     if (holdsManifest(candidate)) return candidate;
-    dir = path2.dirname(dir);
+    dir = path5.dirname(dir);
   }
   throw new Error("Could not locate the templates directory");
 }
 function holdsManifest(dir) {
-  if (!fs3.existsSync(dir)) return false;
-  return fs3.readdirSync(dir, { withFileTypes: true }).some(
-    (entry) => entry.isDirectory() && fs3.existsSync(path2.join(dir, entry.name, TEMPLATE_MANIFEST))
+  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))
   );
 }
 function listProjectTemplates() {
   if (cached) return cached;
   const root = templatesDir();
-  cached = fs3.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 = 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));
   return cached;
 }
 function projectTemplateNames(options = {}) {
@@ -458,12 +707,84 @@ function findProjectTemplate(name) {
   if (!template) throw new Error(`Template not found: ${name}`);
   return template;
 }
+async function listAllTemplates(options = {}) {
+  const indexUrl = options.indexUrl ?? TEMPLATE_INDEX_URL;
+  const builtin = listProjectTemplates();
+  const names = new Set(builtin.map((template) => template.name));
+  const templates = [...builtin];
+  const result = await fetchTemplateIndex(indexUrl);
+  for (const entry of result.index?.templates ?? []) {
+    if (names.has(entry.name)) continue;
+    names.add(entry.name);
+    templates.push({
+      name: entry.name,
+      description: entry.description,
+      backend: entry.backend,
+      source: "remote",
+      category: entry.category ?? DEFAULT_CATEGORY,
+      title: entry.title,
+      tags: entry.tags,
+      price: entry.price,
+      nextSteps: entry.nextSteps,
+      entry,
+      indexUrl
+    });
+  }
+  templates.sort(compareTemplates);
+  return result.index ? { templates } : { templates, registryError: result.reason };
+}
+function compareTemplates(a, b) {
+  if (a.category !== b.category) {
+    if (a.category === DEFAULT_CATEGORY) return -1;
+    if (b.category === DEFAULT_CATEGORY) return 1;
+    return a.category.localeCompare(b.category);
+  }
+  return a.name.localeCompare(b.name);
+}
+function findTemplate(listing, name) {
+  const template = listing.templates.find((candidate) => candidate.name === name);
+  if (!template) throw new Error(`Template not found: ${name}`);
+  return template;
+}
+function templateChoicesMessage(templates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const template of [...templates].sort(compareTemplates)) {
+    const names = groups.get(template.category) ?? [];
+    names.push(template.name);
+    groups.set(template.category, names);
+  }
+  return [...groups].map(([category, names]) => `${category}: ${names.join(", ")}`).join("; ");
+}
+async function resolveTemplate(template) {
+  if (!("entry" in template)) {
+    return { ...template, cleanup() {
+    } };
+  }
+  const { entry, indexUrl, ...info } = template;
+  const dir = await downloadTemplate(entry, indexUrl);
+  return {
+    ...info,
+    dir,
+    cleanup() {
+      fs6.rmSync(dir, { recursive: true, force: true });
+    }
+  };
+}
+function copyTemplate(template, target) {
+  fs6.mkdirSync(target, { recursive: true });
+  fs6.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
+  });
+  restoreTemplateNames(target);
+}
 function readManifest(root, name) {
-  const manifestPath = path2.join(root, name, TEMPLATE_MANIFEST);
-  if (!fs3.existsSync(manifestPath)) return void 0;
+  const manifestPath = path5.join(root, name, TEMPLATE_MANIFEST);
+  if (!fs6.existsSync(manifestPath)) return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
+    parsed = JSON.parse(fs6.readFileSync(manifestPath, "utf8"));
   } catch (e) {
     throw new Error(
       `Template ${name} has an unreadable ${TEMPLATE_MANIFEST}: ${e.message}`
@@ -479,14 +800,28 @@ function readManifest(root, name) {
     name,
     description: manifest.description,
     backend: manifest.backend,
-    dir: path2.join(root, name)
+    source: "builtin",
+    category: optionalString(manifest.category) ?? DEFAULT_CATEGORY,
+    title: optionalString(manifest.title),
+    tags: optionalStringArray(manifest.tags),
+    price: typeof manifest.price === "number" ? manifest.price : void 0,
+    nextSteps: optionalStringArray(manifest.nextSteps),
+    dir: path5.join(root, name)
   };
 }
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length > 0 ? strings : void 0;
+}
 
 // src/lib/package-manager.ts
-import fs4 from "node:fs";
-import path3 from "node:path";
-import process4 from "node:process";
+import fs7 from "node:fs";
+import path6 from "node:path";
+import process5 from "node:process";
 import { exec } from "tinyexec";
 import { Option } from "commander";
 import * as p2 from "@clack/prompts";
@@ -502,7 +837,7 @@ var installOption = new Option(
   "installs dependencies with a specified package manager"
 ).choices(AGENT_NAMES);
 function getUserAgent() {
-  const userAgent = process4.env.npm_config_user_agent;
+  const userAgent = process5.env.npm_config_user_agent;
   if (!userAgent) return void 0;
   const pmSpec = userAgent.split(" ")[0];
   const separatorPos = pmSpec.lastIndexOf("/");
@@ -512,7 +847,7 @@ function getUserAgent() {
 async function packageManagerPrompt(cwd) {
   const detected = await detect({ cwd });
   const agent = detected?.name ?? getUserAgent();
-  if (!process4.stdout.isTTY) return agent;
+  if (!process5.stdout.isTTY) return agent;
   const options = [
     { label: "None", value: void 0 },
     ...AGENT_NAMES.map((pm2) => ({ value: pm2, label: pm2 }))
@@ -524,14 +859,14 @@ async function packageManagerPrompt(cwd) {
   });
   if (p2.isCancel(pm)) {
     p2.cancel("Operation cancelled.");
-    process4.exit(1);
+    process5.exit(1);
   }
   return pm;
 }
 async function installDependencies(agent, cwd) {
   const task = p2.taskLog({
     title: `Installing dependencies with ${agent}...`,
-    limit: Math.ceil(process4.stdout.rows / 2),
+    limit: Math.ceil(process5.stdout.rows / 2),
     spacing: 0,
     retainLog: true
   });
@@ -548,14 +883,14 @@ async function installDependencies(agent, cwd) {
   } catch {
     task.error("Failed to install dependencies");
     p2.cancel("Operation failed.");
-    process4.exit(2);
+    process5.exit(2);
   }
 }
 function addPnpmBuildDependencies(cwd, packageManager, allowedPackages) {
   if (!packageManager || packageManager !== "pnpm") return;
-  const pkgPath = path3.join(cwd, "package.json");
-  if (!fs4.existsSync(pkgPath)) return;
-  const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path6.join(cwd, "package.json");
+  if (!fs7.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
   pkg.pnpm ??= {};
   pkg.pnpm.onlyBuiltDependencies ??= [];
   for (const name of allowedPackages) {
@@ -563,14 +898,14 @@ function addPnpmBuildDependencies(cwd, packageManager, allowedPackages) {
       pkg.pnpm.onlyBuiltDependencies.push(name);
     }
   }
-  fs4.writeFileSync(pkgPath, JSON.stringify(pkg, null, "	") + "\n");
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkg, null, "	") + "\n");
 }
 
 // src/lib/pocketbase.ts
-import fs5 from "node:fs";
+import fs8 from "node:fs";
 import net from "node:net";
-import path4 from "node:path";
-import process5 from "node:process";
+import path7 from "node:path";
+import process6 from "node:process";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import PocketBase from "pocketbase";
@@ -682,9 +1017,9 @@ async function authWithRetries(pb, email3, password11, attempts = 3) {
   }
 }
 function getPocketbaseMetadata(cwd) {
-  const metadataPath = path4.join(cwd, "node_modules", ".vite", "_pocketbase_metadata.json");
-  if (fs5.existsSync(metadataPath)) {
-    return JSON.parse(fs5.readFileSync(metadataPath, "utf8"));
+  const metadataPath = path7.join(cwd, "node_modules", ".vite", "_pocketbase_metadata.json");
+  if (fs8.existsSync(metadataPath)) {
+    return JSON.parse(fs8.readFileSync(metadataPath, "utf8"));
   }
   return null;
 }
@@ -697,12 +1032,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 = path4.join(cwd, DATA_DIR);
-  const migrationsDir = path4.join(cwd, MIGRATIONS_DIR);
+  const dir = path7.join(cwd, DATA_DIR);
+  const migrationsDir = path7.join(cwd, MIGRATIONS_DIR);
   const host = "localhost";
-  const email3 = creds?.email ?? process5.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password11 = creds?.password ?? process5.env.POCKETBASE_SUPERUSER_PASSWORD;
-  if (!fs5.existsSync(dir)) {
+  const email3 = creds?.email ?? process6.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password11 = creds?.password ?? process6.env.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!fs8.existsSync(dir)) {
     throw new Error("PocketBase data directory does not exist");
   }
   const metadata = getPocketbaseMetadata(cwd);
@@ -727,10 +1062,10 @@ async function withPocketbase(cwd, fn, creds) {
   }
 }
 async function createSuperuser(cwd, email3, password11) {
-  const dir = path4.join(cwd, DATA_DIR);
-  const migrationsDir = path4.join(cwd, MIGRATIONS_DIR);
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.mkdirSync(migrationsDir, { recursive: true });
+  const dir = path7.join(cwd, DATA_DIR);
+  const migrationsDir = path7.join(cwd, MIGRATIONS_DIR);
+  fs8.mkdirSync(dir, { recursive: true });
+  fs8.mkdirSync(migrationsDir, { recursive: true });
   await execPackageBin(
     cwd,
     [
@@ -755,8 +1090,8 @@ async function launchPocketbase(cwd, {
   password: password11
 }) {
   const host = "localhost";
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.mkdirSync(migrationsDir, { recursive: true });
+  fs8.mkdirSync(dir, { recursive: true });
+  fs8.mkdirSync(migrationsDir, { recursive: true });
   await execPackageBin(
     cwd,
     [
@@ -795,11 +1130,11 @@ function pocketbaseVersion() {
   return pkg.version;
 }
 async function ensureSuperuser(cwd) {
-  const email3 = process5.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password11 = process5.env.POCKETBASE_SUPERUSER_PASSWORD;
+  const email3 = process6.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password11 = process6.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email3 || !password11) return;
-  const dir = path4.join(cwd, DATA_DIR);
-  if (!fs5.existsSync(dir)) return;
+  const dir = path7.join(cwd, DATA_DIR);
+  if (!fs8.existsSync(dir)) return;
   const { getBinaryPath } = await import("pocketbase-server");
   await x(
     getBinaryPath(),
@@ -807,7 +1142,7 @@ async function ensureSuperuser(cwd) {
       "--dir",
       dir,
       "--migrationsDir",
-      path4.join(cwd, MIGRATIONS_DIR),
+      path7.join(cwd, MIGRATIONS_DIR),
       "superuser",
       "upsert",
       email3,
@@ -818,8 +1153,8 @@ async function ensureSuperuser(cwd) {
 }
 
 // src/lib/env.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs9 from "node:fs";
+import path8 from "node:path";
 function addEnvVar(content, key, value) {
   if (content.includes(`${key}=`)) return content;
   return appendLine(content, `${key}=${value}`);
@@ -834,11 +1169,11 @@ function appendLine(existing, line) {
   return withNewline + line + "\n";
 }
 function writeEnvFile(cwd, vars, comments = []) {
-  const envPath = path5.join(cwd, ".env");
-  let content = fs6.existsSync(envPath) ? fs6.readFileSync(envPath, "utf8") : "";
+  const envPath = path8.join(cwd, ".env");
+  let content = fs9.existsSync(envPath) ? fs9.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);
-  fs6.writeFileSync(envPath, content);
+  fs9.writeFileSync(envPath, content);
 }
 function upsertEnvVar(content, key, value) {
   const line = `${key}=${quoteEnvValue(value)}`;
@@ -871,7 +1206,7 @@ function quoteEnvValue(value) {
 }
 
 // src/lib/app-css.ts
-import fs7 from "node:fs";
+import fs10 from "node:fs";
 var SHADCN_TAILWIND_CSS = "shadcn-svelte/tailwind.css";
 var SHADCN_TAILWIND_IMPORT = `@import '${SHADCN_TAILWIND_CSS}';`;
 function hasShadcnImport(css) {
@@ -897,21 +1232,21 @@ ${css}`;
   return lines.join("\n");
 }
 function ensureShadcnImport(appCssPath) {
-  if (!fs7.existsSync(appCssPath)) return false;
-  const css = fs7.readFileSync(appCssPath, "utf8");
+  if (!fs10.existsSync(appCssPath)) return false;
+  const css = fs10.readFileSync(appCssPath, "utf8");
   if (hasShadcnImport(css)) return false;
-  fs7.writeFileSync(appCssPath, insertShadcnImport(css));
+  fs10.writeFileSync(appCssPath, insertShadcnImport(css));
   return true;
 }
 
 // src/lib/components-json.ts
-import fs8 from "node:fs";
-import path6 from "node:path";
+import fs11 from "node:fs";
+import path9 from "node:path";
 function readComponentsJson(root) {
-  const file = path6.join(root, "components.json");
-  if (!fs8.existsSync(file)) return void 0;
+  const file = path9.join(root, "components.json");
+  if (!fs11.existsSync(file)) return void 0;
   try {
-    const parsed = JSON.parse(fs8.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(file, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : void 0;
   } catch {
     return void 0;
@@ -933,12 +1268,12 @@ function componentsJsonHints(config) {
 }
 
 // src/lib/config-merge.ts
-import fs10 from "node:fs";
-import path8 from "node:path";
+import fs13 from "node:fs";
+import path11 from "node:path";
 
 // src/lib/config-target.ts
-import fs9 from "node:fs";
-import path7 from "node:path";
+import fs12 from "node:fs";
+import path10 from "node:path";
 import {
   Project,
   QuoteKind,
@@ -958,8 +1293,8 @@ var SVELTE_CONFIG_CANDIDATES = [
 ];
 function probeFirstExisting(root, candidates) {
   for (const rel of candidates) {
-    const abs = path7.join(root, rel);
-    if (fs9.existsSync(abs)) return abs;
+    const abs = path10.join(root, rel);
+    if (fs12.existsSync(abs)) return abs;
   }
   return null;
 }
@@ -1035,7 +1370,7 @@ function mergeSvelteConfig(projectRoot) {
   };
 }
 function mergeRunesIntoViteArg(vite, arg) {
-  const file = path8.basename(vite.filePath);
+  const file = path11.basename(vite.filePath);
   const compilerOptions = getOrCreateObjectLiteralProperty(arg, "compilerOptions", "{}");
   if (!compilerOptions) {
     return {
@@ -1054,8 +1389,8 @@ function mergeRunesIntoViteArg(vite, arg) {
   return { applied: true, reason: "added runes compilerOption", file };
 }
 function mergeRunesIntoSvelteConfig(filePath) {
-  const file = path8.basename(filePath);
-  const original = fs10.readFileSync(filePath, "utf8");
+  const file = path11.basename(filePath);
+  const original = fs13.readFileSync(filePath, "utf8");
   if (/runes\s*:/m.test(original)) {
     return { applied: false, reason: "runes already configured", file };
   }
@@ -1078,11 +1413,11 @@ function mergeRunesIntoSvelteConfig(filePath) {
   }
   const insertAt = anchor.index + anchor[0].length;
   const updated = original.slice(0, insertAt) + RUNES_SNIPPET + original.slice(insertAt);
-  fs10.writeFileSync(filePath, updated);
+  fs13.writeFileSync(filePath, updated);
   return { applied: true, reason: "added runes compilerOption", file };
 }
 function mergeViteConfig(filePath) {
-  if (!fs10.existsSync(filePath)) {
+  if (!fs13.existsSync(filePath)) {
     return {
       applied: false,
       reason: "vite.config.ts not found",
@@ -1090,7 +1425,7 @@ function mergeViteConfig(filePath) {
 // then add tailwindcss() to the plugins array`
     };
   }
-  const original = fs10.readFileSync(filePath, "utf8");
+  const original = fs13.readFileSync(filePath, "utf8");
   if (original.includes("@tailwindcss/vite")) {
     return { applied: false, reason: "tailwindcss plugin already present" };
   }
@@ -1109,14 +1444,14 @@ function mergeViteConfig(filePath) {
   const trailing = withImport.slice(insertAt);
   const prefix = /^\s*\]/.test(trailing) ? "tailwindcss()" : "tailwindcss(), ";
   const updated = withImport.slice(0, insertAt) + prefix + withImport.slice(insertAt);
-  fs10.writeFileSync(filePath, updated);
+  fs13.writeFileSync(filePath, updated);
   return { applied: true, reason: "added @tailwindcss/vite plugin" };
 }
 function mergeTsconfig(filePath) {
-  if (!fs10.existsSync(filePath)) {
+  if (!fs13.existsSync(filePath)) {
     return { applied: false, reason: "tsconfig.json not found" };
   }
-  const original = fs10.readFileSync(filePath, "utf8");
+  const original = fs13.readFileSync(filePath, "utf8");
   if (/rewriteRelativeImportExtensions/.test(original)) {
     return { applied: false, reason: "rewriteRelativeImportExtensions already set" };
   }
@@ -1132,7 +1467,7 @@ function mergeTsconfig(filePath) {
   const indent = detectIndent(original, insertAt);
   const updated = original.slice(0, insertAt) + `
 ${indent}"rewriteRelativeImportExtensions": true,` + original.slice(insertAt);
-  fs10.writeFileSync(filePath, updated);
+  fs13.writeFileSync(filePath, updated);
   return { applied: true, reason: "added rewriteRelativeImportExtensions" };
 }
 var GITIGNORE_ENTRIES = [
@@ -1144,7 +1479,7 @@ var GITIGNORE_ENTRIES = [
   "vite.config.ts.timestamp-*"
 ];
 function mergeGitignore(filePath) {
-  const existing = fs10.existsSync(filePath) ? fs10.readFileSync(filePath, "utf8") : "";
+  const existing = fs13.existsSync(filePath) ? fs13.readFileSync(filePath, "utf8") : "";
   const lines = existing.split("\n").map((l) => l.trim());
   const missing = GITIGNORE_ENTRIES.filter((entry) => !lines.includes(entry));
   if (missing.length === 0) {
@@ -1153,7 +1488,7 @@ function mergeGitignore(filePath) {
   const needsNewline = existing.length > 0 && !existing.endsWith("\n");
   const appended = `${existing}${needsNewline ? "\n" : ""}${missing.join("\n")}
 `;
-  fs10.writeFileSync(filePath, appended);
+  fs13.writeFileSync(filePath, appended);
   return { applied: true, reason: `added ${missing.length} gitignore entries` };
 }
 function addImport(source, importLine) {
@@ -1178,14 +1513,14 @@ function detectIndent(source, atOffset) {
 }
 
 // src/lib/scaffold-detect.ts
-import fs11 from "node:fs";
-import path9 from "node:path";
+import fs14 from "node:fs";
+import path12 from "node:path";
 var VANILLA_MARKER = "Welcome to SvelteKit";
-var PAGE_REL = path9.join("src", "routes", "+page.svelte");
+var PAGE_REL = path12.join("src", "routes", "+page.svelte");
 function isVanillaRoutes(cwd) {
-  const pagePath = path9.join(cwd, PAGE_REL);
-  if (!fs11.existsSync(pagePath)) return false;
-  return fs11.readFileSync(pagePath, "utf8").includes(VANILLA_MARKER);
+  const pagePath = path12.join(cwd, PAGE_REL);
+  if (!fs14.existsSync(pagePath)) return false;
+  return fs14.readFileSync(pagePath, "utf8").includes(VANILLA_MARKER);
 }
 
 // src/lib/result-report.ts
@@ -1232,62 +1567,16 @@ ${failure.message}` : headline);
   }
 }
 
-// src/lib/template-files.ts
-import fs12 from "node:fs";
-import path10 from "node:path";
-var PUBLISH_SAFE_NAMES = {
-  ".gitignore": "_gitignore",
-  ".npmrc": "_npmrc"
-};
-function templateName(projectRelPath) {
-  const safe = PUBLISH_SAFE_NAMES[path10.basename(projectRelPath)];
-  if (!safe) return projectRelPath;
-  const dir = path10.dirname(projectRelPath);
-  return dir === "." ? safe : path10.join(dir, safe);
-}
-function restoreTemplateNames(target) {
-  for (const [real, safe] of Object.entries(PUBLISH_SAFE_NAMES)) {
-    const from = path10.join(target, safe);
-    if (!fs12.existsSync(from)) continue;
-    fs12.renameSync(from, path10.join(target, real));
-  }
-}
-var TEMPLATE_SOURCE = /\.template\.([^.]+)$/;
-function applyTemplateFiles(target, values) {
-  const written = [];
-  for (const source of findTemplateSources(target)) {
-    const raw = fs12.readFileSync(source, "utf8");
-    const dest = source.replace(TEMPLATE_SOURCE, ".$1");
-    fs12.writeFileSync(dest, fillTemplatePlaceholders(raw, values));
-    fs12.unlinkSync(source);
-    written.push(path10.relative(target, dest));
-  }
-  return written.sort();
-}
-function findTemplateSources(dir) {
-  const found = [];
-  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-    const full = path10.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      found.push(...findTemplateSources(full));
-    } else if (entry.isFile() && TEMPLATE_SOURCE.test(entry.name)) {
-      found.push(full);
-    }
-  }
-  return found;
-}
-
 // src/commands/bless.ts
 function optionsSchema() {
   const templates = projectTemplateNames({ backend: true });
-  return v2.strictObject({
-    install: v2.union([v2.boolean(), v2.picklist(AGENT_NAMES)], "must be a package manager"),
-    template: v2.optional(v2.picklist(templates, `must be one of: ${templates.join(", ")}`)),
-    email: v2.optional(v2.pipe(v2.string(), v2.email("must be a valid email address"))),
-    password: v2.optional(v2.pipe(v2.string(), v2.minLength(8, "must be at least 8 characters long"))),
-    skipRoutes: v2.optional(v2.boolean()),
-    forceRoutes: v2.optional(v2.boolean())
+  return v3.strictObject({
+    install: v3.union([v3.boolean(), v3.picklist(AGENT_NAMES)], "must be a package manager"),
+    template: v3.optional(v3.picklist(templates, `must be one of: ${templates.join(", ")}`)),
+    email: v3.optional(v3.pipe(v3.string(), v3.email("must be a valid email address"))),
+    password: v3.optional(v3.pipe(v3.string(), v3.minLength(8, "must be at least 8 characters long"))),
+    skipRoutes: v3.optional(v3.boolean()),
+    forceRoutes: v3.optional(v3.boolean())
   });
 }
 var VELA_ONLY_FILES = [
@@ -1343,7 +1632,7 @@ async function blessProject(cwdArg, options) {
     {
       onCancel: () => {
         p4.cancel("Operation cancelled.");
-        process6.exit(0);
+        process7.exit(0);
       }
     }
   );
@@ -1378,7 +1667,7 @@ async function blessProject(cwdArg, options) {
   printNextSteps(projectPath, packageManager);
 }
 function ensureShadcnCss(projectPath) {
-  if (ensureShadcnImport(path11.join(projectPath, "src", "app.css"))) {
+  if (ensureShadcnImport(path13.join(projectPath, "src", "app.css"))) {
     p4.log.info(
       "src/app.css: added the shadcn-svelte/tailwind.css import its registry components rely on."
     );
@@ -1390,22 +1679,22 @@ function hintComponentsJson(projectPath) {
   for (const hint of componentsJsonHints(config)) p4.log.warn(hint);
 }
 function resolveProjectPath(cwdArg) {
-  const projectPath = path11.resolve(cwdArg);
-  if (!fs13.existsSync(projectPath)) {
+  const projectPath = path13.resolve(cwdArg);
+  if (!fs15.existsSync(projectPath)) {
     throw new Error(`Path does not exist: ${projectPath}`);
   }
-  if (!fs13.existsSync(path11.join(projectPath, "package.json"))) {
+  if (!fs15.existsSync(path13.join(projectPath, "package.json"))) {
     throw new Error(`No package.json found at ${projectPath}`);
   }
-  if (!fs13.existsSync(path11.join(projectPath, "src", "routes"))) {
+  if (!fs15.existsSync(path13.join(projectPath, "src", "routes"))) {
     throw new Error(`No src/routes directory found at ${projectPath}`);
   }
   return projectPath;
 }
 function assertNotAlreadyBlessed(projectPath) {
-  const hooksPath = path11.join(projectPath, "src", "hooks.server.ts");
-  if (!fs13.existsSync(hooksPath)) return;
-  const content = fs13.readFileSync(hooksPath, "utf8");
+  const hooksPath = path13.join(projectPath, "src", "hooks.server.ts");
+  if (!fs15.existsSync(hooksPath)) return;
+  const content = fs15.readFileSync(hooksPath, "utf8");
   if (content.includes("@velastack/pocketbase")) {
     throw new Error(
       "This project already looks blessed (src/hooks.server.ts imports @velastack/pocketbase). Run `vela sync` instead."
@@ -1413,8 +1702,8 @@ function assertNotAlreadyBlessed(projectPath) {
   }
 }
 function mergeDependencies(projectPath, templateDir) {
-  const userPkgPath = path11.join(projectPath, "package.json");
-  const templatePkgPath = path11.join(templateDir, "package.template.json");
+  const userPkgPath = path13.join(projectPath, "package.json");
+  const templatePkgPath = path13.join(templateDir, "package.template.json");
   const userPkg = readPackageJson(userPkgPath);
   const appName = typeof userPkg.name === "string" ? userPkg.name : "sveltekit";
   const templatePkg = readTemplatePackageJson(templatePkgPath, {
@@ -1446,21 +1735,21 @@ ${lines.join("\n")}`);
 function copyVelaOnlyFiles(templateDir, projectPath) {
   const kept = [];
   for (const file of VELA_ONLY_FILES) {
-    const src = path11.join(templateDir, templateName(file.path));
-    const dest = path11.join(projectPath, file.path);
-    if (!fs13.existsSync(src)) continue;
-    if (fs13.existsSync(dest)) {
+    const src = path13.join(templateDir, templateName(file.path));
+    const dest = path13.join(projectPath, file.path);
+    if (!fs15.existsSync(src)) continue;
+    if (fs15.existsSync(dest)) {
       kept.push(file);
       continue;
     }
-    fs13.mkdirSync(path11.dirname(dest), { recursive: true });
-    fs13.copyFileSync(src, dest);
+    fs15.mkdirSync(path13.dirname(dest), { recursive: true });
+    fs15.copyFileSync(src, dest);
   }
   reportKeptFiles(kept);
   for (const rel of VELA_ONLY_DIRS) {
-    const src = path11.join(templateDir, rel);
-    const dest = path11.join(projectPath, rel);
-    if (!fs13.existsSync(src)) continue;
+    const src = path13.join(templateDir, rel);
+    const dest = path13.join(projectPath, rel);
+    if (!fs15.existsSync(src)) continue;
     copyDirShallow(src, dest);
   }
 }
@@ -1474,15 +1763,15 @@ ${lines.join("\n")}`
   );
 }
 function copyDirShallow(src, dest) {
-  fs13.mkdirSync(dest, { recursive: true });
-  for (const entry of fs13.readdirSync(src, { withFileTypes: true })) {
+  fs15.mkdirSync(dest, { recursive: true });
+  for (const entry of fs15.readdirSync(src, { withFileTypes: true })) {
     if (entry.name === ".DS_Store") continue;
-    const srcChild = path11.join(src, entry.name);
-    const destChild = path11.join(dest, entry.name);
+    const srcChild = path13.join(src, entry.name);
+    const destChild = path13.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirShallow(srcChild, destChild);
-    } else if (entry.isFile() && !fs13.existsSync(destChild)) {
-      fs13.copyFileSync(srcChild, destChild);
+    } else if (entry.isFile() && !fs15.existsSync(destChild)) {
+      fs15.copyFileSync(srcChild, destChild);
     }
   }
 }
@@ -1490,9 +1779,9 @@ function mergeConfigFiles(projectPath) {
   const runes = mergeSvelteConfig(projectPath);
   const outcomes = [
     [runes.file ?? "svelte.config", runes],
-    ["vite.config.ts", mergeViteConfig(path11.join(projectPath, "vite.config.ts"))],
-    ["tsconfig.json", mergeTsconfig(path11.join(projectPath, "tsconfig.json"))],
-    [".gitignore", mergeGitignore(path11.join(projectPath, ".gitignore"))]
+    ["vite.config.ts", mergeViteConfig(path13.join(projectPath, "vite.config.ts"))],
+    ["tsconfig.json", mergeTsconfig(path13.join(projectPath, "tsconfig.json"))],
+    [".gitignore", mergeGitignore(path13.join(projectPath, ".gitignore"))]
   ];
   for (const [name, outcome] of outcomes) {
     if (outcome.applied) {
@@ -1509,14 +1798,14 @@ ${pc3.cyan(outcome.snippet)}`
   }
 }
 function mergeAppDts(templateDir, projectPath) {
-  const dest = path11.join(projectPath, "src", "app.d.ts");
-  const templateFile = path11.join(templateDir, "src", "app.d.ts");
-  if (!fs13.existsSync(dest)) {
-    if (!fs13.existsSync(templateFile)) return;
-    fs13.copyFileSync(templateFile, dest);
+  const dest = path13.join(projectPath, "src", "app.d.ts");
+  const templateFile = path13.join(templateDir, "src", "app.d.ts");
+  if (!fs15.existsSync(dest)) {
+    if (!fs15.existsSync(templateFile)) return;
+    fs15.copyFileSync(templateFile, dest);
     return;
   }
-  const current = fs13.readFileSync(dest, "utf8");
+  const current = fs15.readFileSync(dest, "utf8");
   if (current.includes("namespace Superforms")) return;
   const block = `	namespace Superforms {
 		type Message = {
@@ -1535,7 +1824,7 @@ ${pc3.cyan(block)}`
   }
   const insertAt = match.index + match[0].length;
   const updated = current.slice(0, insertAt) + block + current.slice(insertAt);
-  fs13.writeFileSync(dest, updated);
+  fs15.writeFileSync(dest, updated);
 }
 function maybeReplaceRoutes(projectPath, templateDir, options) {
   if (options.skipRoutes) {
@@ -1546,12 +1835,12 @@ function maybeReplaceRoutes(projectPath, templateDir, options) {
     p4.log.info("Leaving src/routes alone (looks customized).");
     return;
   }
-  const target = path11.join(projectPath, "src", "routes");
-  fs13.rmSync(target, { recursive: true, force: true });
-  const src = path11.join(templateDir, "src", "routes");
-  fs13.cpSync(src, target, {
+  const target = path13.join(projectPath, "src", "routes");
+  fs15.rmSync(target, { recursive: true, force: true });
+  const src = path13.join(templateDir, "src", "routes");
+  fs15.cpSync(src, target, {
     recursive: true,
-    filter: (s) => path11.basename(s) !== ".DS_Store"
+    filter: (s) => path13.basename(s) !== ".DS_Store"
   });
   p4.log.success("Replaced src/routes with the vela template.");
 }
@@ -1560,7 +1849,7 @@ function summarize(names) {
   return `${names.slice(0, 3).join(", ")}, and ${names.length - 3} more`;
 }
 function printNextSteps(projectPath, packageManager) {
-  const relative = path11.relative(process6.cwd(), projectPath);
+  const relative = path13.relative(process7.cwd(), projectPath);
   const pm = packageManager ?? getUserAgent() ?? "npm";
   const nextSteps = [];
   if (relative !== "") {
@@ -1584,31 +1873,37 @@ function printNextSteps(projectPath, packageManager) {
 }
 
 // src/commands/create.ts
-import fs14 from "node:fs";
-import path12 from "node:path";
-import process7 from "node:process";
-import * as v3 from "valibot";
+import fs16 from "node:fs";
+import path14 from "node:path";
+import process8 from "node:process";
+import * as v4 from "valibot";
 import { Command as Command3 } from "commander";
 import * as p5 from "@clack/prompts";
 import { detect as detect3, resolveCommand as resolveCommand3 } from "package-manager-detector";
-function optionsSchema2() {
-  const templates = projectTemplateNames();
-  return v3.strictObject({
-    install: v3.union([v3.boolean(), v3.picklist(AGENT_NAMES)], "must be a package manager"),
-    template: v3.optional(v3.picklist(templates, `must be one of: ${templates.join(", ")}`)),
-    name: v3.optional(v3.pipe(v3.string(), v3.trim(), v3.minLength(1, "must not be empty"))),
-    email: v3.optional(v3.pipe(v3.string(), v3.email("must be a valid email address"))),
-    password: v3.optional(v3.pipe(v3.string(), v3.minLength(8, "must be at least 8 characters long")))
+function optionsSchema2(listing) {
+  const names = listing.templates.map((template) => template.name);
+  let choices = `must be one of: ${templateChoicesMessage(listing.templates)}`;
+  if (listing.registryError) {
+    choices += ` (could not reach the template registry: ${listing.registryError})`;
+  }
+  return v4.strictObject({
+    install: v4.union([v4.boolean(), v4.picklist(AGENT_NAMES)], "must be a package manager"),
+    template: v4.optional(v4.picklist(names, choices)),
+    name: v4.optional(v4.pipe(v4.string(), v4.trim(), v4.minLength(1, "must not be empty"))),
+    email: v4.optional(v4.pipe(v4.string(), v4.email("must be a valid email address"))),
+    password: v4.optional(v4.pipe(v4.string(), v4.minLength(8, "must be at least 8 characters long")))
   });
 }
-var create = new Command3("create").description("scaffold a new velastack project").argument("[path]", "where the project will be created").option("--template <type>", "template to scaffold", "minimal").option("--no-install", "skip installing dependencies").option("--name <name>", "app name (used for emails, etc)").option("--email <email>", "email of the admin user").option("--password <password>", "password of the admin user").addOption(installOption).configureHelp(helpConfig).action((projectPath, rawOpts) => {
+var create = new Command3("create").description("scaffold a new velastack project").argument("[path]", "where the project will be created").option("--template <type>", "template to scaffold (built-in or from the registry)", "minimal").option("--no-install", "skip installing dependencies").option("--name <name>", "app name (used for emails, etc)").option("--email <email>", "email of the admin user").option("--password <password>", "password of the admin user").addOption(installOption).configureHelp(helpConfig).action((projectPath, rawOpts) => {
   return runCommand(async () => {
-    const options = parseOptions(optionsSchema2(), rawOpts);
+    const listing = await listAllTemplates();
+    const options = parseOptions(optionsSchema2(listing), rawOpts);
     const { directory, packageManager, name, template } = await createProject(
       projectPath,
-      options
+      options,
+      listing
     );
-    const relative = path12.relative(process7.cwd(), directory);
+    const relative = path14.relative(process8.cwd(), directory);
     const pm = packageManager ?? (await detect3({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
     const nextSteps = [];
     if (relative !== "") {
@@ -1629,7 +1924,9 @@ var create = new Command3("create").description("scaffold a new velastack projec
         `\`${runDev.command} ${runDev.args.join(" ")}\` to start the dev server (Ctrl-C to stop)`
       );
     }
-    if (template.backend) {
+    if (template.nextSteps) {
+      nextSteps.push(...template.nextSteps);
+    } else if (template.backend) {
       nextSteps.push("Run `vela generate scaffold <model>` to generate your first CRUD pages.");
     } else {
       nextSteps.push(
@@ -1644,12 +1941,12 @@ var create = new Command3("create").description("scaffold a new velastack projec
     });
   }, "Failed to create project.");
 });
-async function createProject(cwdArg, options) {
+async function createProject(cwdArg, options, listing) {
   const onCancel2 = () => {
     p5.cancel("Operation cancelled.");
-    process7.exit(0);
+    process8.exit(0);
   };
-  const template = findProjectTemplate(options.template ?? DEFAULT_TEMPLATE);
+  const template = findTemplate(listing, options.template ?? DEFAULT_TEMPLATE);
   if (!template.backend && (options.email || options.password)) {
     throw new Error(
       `--email and --password don't apply to the ${template.name} template \u2014 it has no backend.`
@@ -1657,7 +1954,7 @@ async function createProject(cwdArg, options) {
   }
   let directory;
   if (cwdArg) {
-    directory = path12.resolve(cwdArg);
+    directory = path14.resolve(cwdArg);
   } else {
     const answer = await p5.text({
       message: "Where would you like your project to be created?",
@@ -1665,16 +1962,16 @@ async function createProject(cwdArg, options) {
       defaultValue: "./"
     });
     if (p5.isCancel(answer)) onCancel2();
-    directory = path12.resolve(answer);
+    directory = path14.resolve(answer);
   }
-  if (fs14.existsSync(directory) && fs14.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
+  if (fs16.existsSync(directory) && fs16.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
     const force = await p5.confirm({
       message: "Directory not empty. Continue?",
       initialValue: false
     });
     if (p5.isCancel(force) || !force) onCancel2();
   }
-  const dirName = path12.basename(directory);
+  const dirName = path14.basename(directory);
   const { name } = await p5.group(
     {
       name: () => {
@@ -1690,9 +1987,15 @@ async function createProject(cwdArg, options) {
   );
   const credentials = template.backend ? await promptCredentials(options, onCancel2) : void 0;
   const projectPath = directory;
-  copyTemplate(template, projectPath);
-  applyTemplateFiles(projectPath, { appName: name, cliVersion: package_default.version });
-  if (!fs14.existsSync(path12.join(projectPath, "package.json"))) {
+  if (template.source === "remote") p5.log.step(`Downloading template ${template.name}...`);
+  const resolved = await resolveTemplate(template);
+  try {
+    copyTemplate(resolved, projectPath);
+    applyTemplateFiles(projectPath, { appName: name, cliVersion: package_default.version });
+  } finally {
+    resolved.cleanup();
+  }
+  if (!fs16.existsSync(path14.join(projectPath, "package.json"))) {
     throw new Error(`Template ${template.name} is missing package.template.json`);
   }
   p5.log.success("Project created");
@@ -1753,15 +2056,6 @@ function promptCredentials(options, onCancel2) {
     { onCancel: onCancel2 }
   );
 }
-function copyTemplate(template, target) {
-  fs14.mkdirSync(target, { recursive: true });
-  fs14.cpSync(template.dir, target, {
-    recursive: true,
-    // The manifest describes the template to the CLI; it isn't part of the project.
-    filter: (src) => path12.basename(src) !== ".DS_Store" && path12.relative(template.dir, src) !== TEMPLATE_MANIFEST
-  });
-  restoreTemplateNames(target);
-}
 
 // src/commands/generate.ts
 import { Command as Command9 } from "commander";
@@ -1771,11 +2065,11 @@ import { Command as Command4 } from "commander";
 import * as p11 from "@clack/prompts";
 
 // src/lib/pattern-runner.ts
-import path13 from "node:path";
+import path15 from "node:path";
 import * as p6 from "@clack/prompts";
 import { bySlug } from "@velastack/patterns";
 function toRelative(root, filePath) {
-  return path13.isAbsolute(filePath) ? path13.relative(root, filePath) : filePath;
+  return path15.isAbsolute(filePath) ? path15.relative(root, filePath) : filePath;
 }
 var isSuccess = (f) => (f.status ?? "success") === "success";
 async function runPattern(slug2, argv, input, report4) {
@@ -1842,57 +2136,22 @@ async function runPattern(slug2, argv, input, report4) {
 }
 
 // src/lib/ai-flow.ts
-import fs17 from "node:fs";
-import path16 from "node:path";
+import fs18 from "node:fs";
+import path17 from "node:path";
 import * as p10 from "@clack/prompts";
 import pc4 from "picocolors";
 
-// src/lib/config.ts
-import fs15 from "node:fs";
-import os from "node:os";
-import path14 from "node:path";
-import process8 from "node:process";
-var CONFIG_DIR = path14.join(os.homedir(), ".vela");
-var CONFIG_PATH = path14.join(CONFIG_DIR, "config.json");
-function readConfig() {
-  if (!fs15.existsSync(CONFIG_PATH)) return null;
-  try {
-    return JSON.parse(fs15.readFileSync(CONFIG_PATH, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeConfig(config) {
-  fs15.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs15.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-}
-function clearConfig() {
-  if (fs15.existsSync(CONFIG_PATH)) fs15.unlinkSync(CONFIG_PATH);
-}
-function readApiKey() {
-  const fromEnv = process8.env.VELA_API_KEY?.trim();
-  if (fromEnv) return fromEnv;
-  return readConfig()?.apiKey ?? null;
-}
-function requireApiKey() {
-  const apiKey = readApiKey();
-  if (!apiKey) {
-    throw new Error("Not logged in. Run `vela login` to login, or set VELA_API_KEY.");
-  }
-  return apiKey;
-}
-
 // src/lib/project-config.ts
-import fs16 from "node:fs";
-import path15 from "node:path";
+import fs17 from "node:fs";
+import path16 from "node:path";
 function projectConfigPath(workspaceRootDir) {
-  return path15.join(workspaceRootDir, ".vela", "project.json");
+  return path16.join(workspaceRootDir, ".vela", "project.json");
 }
 function readProjectConfig(workspaceRootDir) {
   const file = projectConfigPath(workspaceRootDir);
-  if (!fs16.existsSync(file)) return null;
+  if (!fs17.existsSync(file)) return null;
   try {
-    const parsed = JSON.parse(fs16.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs17.readFileSync(file, "utf8"));
     if (typeof parsed.projectId !== "string" || typeof parsed.teamId !== "string" || typeof parsed.projectName !== "string") {
       return null;
     }
@@ -1907,15 +2166,15 @@ function readProjectConfig(workspaceRootDir) {
 }
 function writeProjectConfig(workspaceRootDir, config) {
   const file = projectConfigPath(workspaceRootDir);
-  fs16.mkdirSync(path15.dirname(file), { recursive: true });
+  fs17.mkdirSync(path16.dirname(file), { recursive: true });
   let existing = {};
-  if (fs16.existsSync(file)) {
+  if (fs17.existsSync(file)) {
     try {
-      existing = JSON.parse(fs16.readFileSync(file, "utf8"));
+      existing = JSON.parse(fs17.readFileSync(file, "utf8"));
     } catch {
     }
   }
-  fs16.writeFileSync(file, JSON.stringify({ ...existing, ...config }, null, 2) + "\n");
+  fs17.writeFileSync(file, JSON.stringify({ ...existing, ...config }, null, 2) + "\n");
 }
 
 // src/lib/ai-client.ts
@@ -2189,11 +2448,11 @@ function specToArgv(spec) {
   return collectionSpecToArgv(spec);
 }
 function writeLayoutSidecar(workspaceRootDir, modelName, layout) {
-  const dir = path16.join(workspaceRootDir, "data", "ai-form-layouts");
-  fs17.mkdirSync(dir, { recursive: true });
-  const file = path16.join(dir, `${modelName}.json`);
-  fs17.writeFileSync(file, JSON.stringify(layout, null, 2) + "\n");
-  return path16.relative(workspaceRootDir, file);
+  const dir = path17.join(workspaceRootDir, "data", "ai-form-layouts");
+  fs18.mkdirSync(dir, { recursive: true });
+  const file = path17.join(dir, `${modelName}.json`);
+  fs18.writeFileSync(file, JSON.stringify(layout, null, 2) + "\n");
+  return path17.relative(workspaceRootDir, file);
 }
 
 // src/commands/generate/form.ts
@@ -2675,7 +2934,7 @@ async function ensureKey(envVar, message) {
 async function promptPassword(message) {
   const value = await p14.password({
     message,
-    validate: (v9) => v9 && v9.length ? void 0 : "Required"
+    validate: (v10) => v10 && v10.length ? void 0 : "Required"
   });
   if (p14.isCancel(value)) {
     p14.cancel("Operation cancelled.");
@@ -2744,13 +3003,13 @@ import pc8 from "picocolors";
 
 // src/lib/server-command.ts
 import process11 from "node:process";
-import * as v5 from "valibot";
+import * as v6 from "valibot";
 import * as p15 from "@clack/prompts";
 import pc5 from "picocolors";
 
 // src/lib/deploy-config.ts
-import fs18 from "node:fs";
-import path17 from "node:path";
+import fs19 from "node:fs";
+import path18 from "node:path";
 import crypto from "node:crypto";
 import { pathToFileURL } from "node:url";
 var CONFIG_BASENAMES = [
@@ -2761,8 +3020,8 @@ var CONFIG_BASENAMES = [
 ];
 function findConfigFile(workspaceRootDir) {
   for (const name of CONFIG_BASENAMES) {
-    const file = path17.join(workspaceRootDir, name);
-    if (fs18.existsSync(file)) return file;
+    const file = path18.join(workspaceRootDir, name);
+    if (fs19.existsSync(file)) return file;
   }
   return null;
 }
@@ -2770,49 +3029,49 @@ async function loadDeployConfig(workspaceRootDir) {
   const file = findConfigFile(workspaceRootDir);
   if (!file) return {};
   if (file.endsWith(".json")) {
-    return JSON.parse(fs18.readFileSync(file, "utf8"));
+    return JSON.parse(fs19.readFileSync(file, "utf8"));
   }
   const url = file.endsWith(".ts") ? await transpileToTemp(file) : pathToFileURL(file).href;
   try {
     const mod = await import(url);
     const config = mod.default;
     if (!config || typeof config !== "object") {
-      throw new Error(`${path17.basename(file)} must export a config object as its default export.`);
+      throw new Error(`${path18.basename(file)} must export a config object as its default export.`);
     }
     return config;
   } finally {
-    if (url !== pathToFileURL(file).href) fs18.rmSync(new URL(url), { force: true });
+    if (url !== pathToFileURL(file).href) fs19.rmSync(new URL(url), { force: true });
   }
 }
 async function transpileToTemp(file) {
   const { ts } = await import("ts-morph");
-  const source = fs18.readFileSync(file, "utf8");
+  const source = fs19.readFileSync(file, "utf8");
   const { outputText } = ts.transpileModule(source, {
     compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 }
   });
-  const temp = path17.join(
-    path17.dirname(file),
+  const temp = path18.join(
+    path18.dirname(file),
     `.velastack.config.${crypto.randomBytes(4).toString("hex")}.mjs`
   );
-  fs18.writeFileSync(temp, outputText);
+  fs19.writeFileSync(temp, outputText);
   return pathToFileURL(temp).href;
 }
 function projectFilePath(workspaceRootDir) {
-  return path17.join(workspaceRootDir, ".vela", "project.json");
+  return path18.join(workspaceRootDir, ".vela", "project.json");
 }
 function readProjectFile(workspaceRootDir) {
   const file = projectFilePath(workspaceRootDir);
-  if (!fs18.existsSync(file)) return {};
+  if (!fs19.existsSync(file)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(file, "utf8"));
+    return JSON.parse(fs19.readFileSync(file, "utf8"));
   } catch {
     return {};
   }
 }
 function writeProjectFile(workspaceRootDir, data) {
   const file = projectFilePath(workspaceRootDir);
-  fs18.mkdirSync(path17.dirname(file), { recursive: true });
-  fs18.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+  fs19.mkdirSync(path18.dirname(file), { recursive: true });
+  fs19.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
 }
 function resolveAppIdentity(workspaceRootDir, config = {}) {
   const project = readProjectFile(workspaceRootDir);
@@ -2837,11 +3096,11 @@ function readAppIdentity(workspaceRootDir, config = {}) {
 }
 function defaultProjectName(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path17.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path18.join(workspaceRootDir, "package.json"));
     if (typeof pkg.name === "string" && pkg.name.trim()) return pkg.name.trim();
   } catch {
   }
-  return path17.basename(workspaceRootDir);
+  return path18.basename(workspaceRootDir);
 }
 function slug(value) {
   return value.toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "app";
@@ -2902,15 +3161,15 @@ function releaseId(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/lib/artifact.ts
-import fs20 from "node:fs";
-import path19 from "node:path";
+import fs21 from "node:fs";
+import path20 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 fs19 from "node:fs";
-import os2 from "node:os";
-import path18 from "node:path";
+import fs20 from "node:fs";
+import os3 from "node:os";
+import path19 from "node:path";
 import crypto2 from "node:crypto";
 import process10 from "node:process";
 import { spawn as spawn2 } from "node:child_process";
@@ -2953,9 +3212,9 @@ var SshSession = class {
   }
   async open() {
     if (this.controlPath) return;
-    const dir = path18.join(os2.tmpdir(), "vela-ssh");
-    fs19.mkdirSync(dir, { recursive: true, mode: 448 });
-    const socket = path18.join(dir, `${crypto2.randomBytes(6).toString("hex")}.sock`);
+    const dir = path19.join(os3.tmpdir(), "vela-ssh");
+    fs20.mkdirSync(dir, { recursive: true, mode: 448 });
+    const socket = path19.join(dir, `${crypto2.randomBytes(6).toString("hex")}.sock`);
     this.controlPath = socket;
     const args = [
       ...this.sshArgs(),
@@ -3245,11 +3504,11 @@ function collectArtifact(cwd, config = {}) {
   const outputDir = config.outputDir ?? DEFAULT_OUTPUT_DIR;
   const entries = [];
   const add2 = (rel, remoteDir = "") => {
-    const localPath = path19.join(cwd, rel);
-    if (fs20.existsSync(localPath)) entries.push({ localPath, remoteDir });
+    const localPath = path20.join(cwd, rel);
+    if (fs21.existsSync(localPath)) entries.push({ localPath, remoteDir });
   };
-  const buildPath = path19.join(cwd, outputDir);
-  if (!fs20.existsSync(path19.join(buildPath, "index.js"))) {
+  const buildPath = path20.join(cwd, outputDir);
+  if (!fs21.existsSync(path20.join(buildPath, "index.js"))) {
     throw new BuildError(
       `No ${outputDir}/index.js after the build.
 
@@ -3262,8 +3521,8 @@ the adapter in your Vite or Svelte config, then build again.`
   add2("package-lock.json");
   add2(".npmrc");
   add2(MIGRATIONS_DIR);
-  const hooks = path19.join(cwd, DATA_DIR, "hooks");
-  if (fs20.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
+  const hooks = path20.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;
 }
@@ -3285,11 +3544,11 @@ Name it: \`-t preview:<branch>\`.`
 }
 
 // src/lib/ssh-options.ts
-import * as v4 from "valibot";
+import * as v5 from "valibot";
 var SSH_OPTION_SCHEMA = {
-  identity: v4.optional(v4.string()),
-  sshPort: v4.optional(v4.string()),
-  acceptHostKeys: v4.optional(v4.boolean())
+  identity: v5.optional(v5.string()),
+  sshPort: v5.optional(v5.string()),
+  acceptHostKeys: v5.optional(v5.boolean())
 };
 function addSshOptions(command) {
   return command.option("-i, --identity <file>", "SSH private key to authenticate with").option("--ssh-port <port>", "SSH port").option("--accept-host-keys", "trust an unknown host key on first connect (CI)");
@@ -3303,7 +3562,7 @@ function sshOptionsFrom(options) {
 }
 
 // src/lib/remote.ts
-import path20 from "node:path";
+import path21 from "node:path";
 var VELA_ROOT = "/var/lib/vela";
 var VELA_ETC = "/etc/vela";
 var VELA_USER = "vela";
@@ -3311,7 +3570,7 @@ var SCRIPTS_DIR = `${VELA_ROOT}/scripts`;
 var PROVISIONED_MARKER = `${VELA_ETC}/provisioned`;
 var ORIGIN_FILE = `${VELA_ETC}/origin.json`;
 function serverTemplatesDir() {
-  return path20.join(templatesDir(), "server");
+  return path21.join(templatesDir(), "server");
 }
 async function syncServerScripts(session) {
   await session.script(`mkdir -p "$1" && chmod 0755 "$1"`, { args: [SCRIPTS_DIR] });
@@ -3394,7 +3653,7 @@ var remotePaths = {
 };
 
 // src/lib/remote-env.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 import dotenv from "dotenv";
 var KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function isValidKey(key) {
@@ -3442,7 +3701,7 @@ function quote(value) {
   return `"${escaped}"`;
 }
 function readLocalEnvFile(file) {
-  const parsed = dotenv.parse(fs21.readFileSync(file));
+  const parsed = dotenv.parse(fs22.readFileSync(file));
   const result = {};
   for (const [key, value] of Object.entries(parsed)) {
     if (isValidKey(key)) result[key] = value;
@@ -3554,10 +3813,10 @@ function bold(text18) {
 // src/lib/server-command.ts
 var SERVER_OPTIONS_SCHEMA = {
   ...SSH_OPTION_SCHEMA,
-  target: v5.optional(v5.string()),
-  server: v5.optional(v5.string())
+  target: v6.optional(v6.string()),
+  server: v6.optional(v6.string())
 };
-var OptionsSchema = v5.object(SERVER_OPTIONS_SCHEMA);
+var OptionsSchema = v6.object(SERVER_OPTIONS_SCHEMA);
 function addTargetOptions(command, fallback) {
   return addSshOptions(command).option("-t, --target <target>", "which copy of the app to act on", fallback).option("--server <ssh>", "server this target runs on \u2014 recorded on first use");
 }
@@ -3737,17 +3996,17 @@ function envFilePath(workspaceRootDir) {
 import pc7 from "picocolors";
 
 // src/lib/local-env.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import * as p16 from "@clack/prompts";
 import pc6 from "picocolors";
 function readLocalEnv(envFile) {
-  if (!fs22.existsSync(envFile)) return {};
+  if (!fs23.existsSync(envFile)) return {};
   return readLocalEnvFile(envFile);
 }
 function editLocalEnv(envFile, edit) {
-  const before = fs22.existsSync(envFile) ? fs22.readFileSync(envFile, "utf8") : "";
+  const before = fs23.existsSync(envFile) ? fs23.readFileSync(envFile, "utf8") : "";
   const after = edit(before);
-  if (after !== before) fs22.writeFileSync(envFile, after);
+  if (after !== before) fs23.writeFileSync(envFile, after);
 }
 function setLocalEnv(envFile, key, value) {
   editLocalEnv(envFile, (content) => upsertEnvVar(content, key, value));
@@ -3879,8 +4138,8 @@ Set ${pc7.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc7.cyan("POCKETBASE_SUPERUS
 }
 
 // src/lib/s3-settings.ts
-import fs23 from "node:fs";
-import path21 from "node:path";
+import fs24 from "node:fs";
+import path22 from "node:path";
 var VIRTUAL_HOSTED = [/\.amazonaws\.com$/i, /\.r2\.cloudflarestorage\.com$/i];
 function defaultForcePathStyle(endpoint) {
   let host;
@@ -3918,18 +4177,18 @@ async function hasLocalUploads(session, instance, workspaceRootDir) {
     });
     return result.stdout.trim().length > 0;
   }
-  return hasFile(path21.join(workspaceRootDir, DATA_DIR, "storage"));
+  return hasFile(path22.join(workspaceRootDir, DATA_DIR, "storage"));
 }
 function hasFile(dir) {
   let entries;
   try {
-    entries = fs23.readdirSync(dir, { withFileTypes: true });
+    entries = fs24.readdirSync(dir, { withFileTypes: true });
   } catch {
     return false;
   }
   for (const entry of entries) {
     if (entry.isFile()) return true;
-    if (entry.isDirectory() && hasFile(path21.join(dir, entry.name))) return true;
+    if (entry.isDirectory() && hasFile(path22.join(dir, entry.name))) return true;
   }
   return false;
 }
@@ -4053,14 +4312,14 @@ var smtp = new Command20("smtp").description("configure SMTP for transactional e
         host: () => p18.text({
           message: "SMTP host",
           placeholder: "smtp.example.com",
-          validate: (v9) => v9 ? void 0 : "Host is required"
+          validate: (v10) => v10 ? void 0 : "Host is required"
         }),
         port: () => p18.text({
           message: "SMTP port",
           initialValue: "587",
-          validate: (v9) => {
-            if (!v9) return "Port is required";
-            const n = Number(v9);
+          validate: (v10) => {
+            if (!v10) return "Port is required";
+            const n = Number(v10);
             if (!Number.isInteger(n) || n <= 0 || n > 65535) return "Invalid port";
             return void 0;
           }
@@ -5119,8 +5378,8 @@ var ui = new Command47("ui").description("generate ui components").configureHelp
 import { Command as Command50 } from "commander";
 
 // src/commands/legal/terms.ts
-import fs24 from "node:fs";
-import path22 from "node:path";
+import fs25 from "node:fs";
+import path23 from "node:path";
 import { Command as Command48 } from "commander";
 import * as p32 from "@clack/prompts";
 
@@ -5779,22 +6038,22 @@ async function termsAction() {
     mobileApp,
     contact
   });
-  const termsPage = path22.join(
+  const termsPage = path23.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "terms",
     "+page.svelte"
   );
-  const termsPageTs = path22.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
-  fs24.mkdirSync(path22.dirname(termsPage), { recursive: true });
-  fs24.writeFileSync(termsPage, html);
-  fs24.writeFileSync(
+  const termsPageTs = path23.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
+  fs25.mkdirSync(path23.dirname(termsPage), { recursive: true });
+  fs25.writeFileSync(termsPage, html);
+  fs25.writeFileSync(
     termsPageTs,
     pageMetaTagsLoader("Terms of Service", `Terms of Service for ${core.websiteName}`)
   );
-  const relativeTermsPage = path22.relative(workspaceRootDir, termsPage);
-  const relativeTermsPageTs = path22.relative(workspaceRootDir, termsPageTs);
+  const relativeTermsPage = path23.relative(workspaceRootDir, termsPage);
+  const relativeTermsPageTs = path23.relative(workspaceRootDir, termsPageTs);
   reportResult({
     summary: "Generated placeholder terms and conditions.",
     filesCreated: [relativeTermsPage, relativeTermsPageTs],
@@ -5808,8 +6067,8 @@ async function termsAction() {
 var terms = new Command48("terms").description("generate placeholder terms and conditions").configureHelp(helpConfig).action(() => runCommand(termsAction, "Failed to generate terms and conditions."));
 
 // src/commands/legal/privacy.ts
-import fs25 from "node:fs";
-import path23 from "node:path";
+import fs26 from "node:fs";
+import path24 from "node:path";
 import { Command as Command49 } from "commander";
 import * as p33 from "@clack/prompts";
 var mapLabels = {
@@ -5898,9 +6157,9 @@ var compute2 = (a) => {
   });
   const piSelections = a.personalInfo ?? [];
   const piLabels = piSelections.map(
-    (v9) => mapLabels.personalInfo[v9] ?? v9
+    (v10) => mapLabels.personalInfo[v10] ?? v10
   );
-  const lookup = (map, vs) => (vs ?? []).map((v9) => map[v9] ?? v9);
+  const lookup = (map, vs) => (vs ?? []).map((v10) => map[v10] ?? v10);
   const companyName = a.core?.entityType === "business" ? a.core?.businessName ?? a.core?.websiteName : a.core?.websiteName ?? "Our Company";
   const companyAddress = a.core?.entityType === "business" ? a.core?.businessAddress ?? "" : "";
   const websiteName = a.core?.websiteName ?? "our website";
@@ -6522,28 +6781,28 @@ async function privacyAction() {
     kids,
     retention
   });
-  const privacyPage = path23.join(
+  const privacyPage = path24.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.svelte"
   );
-  const privacyPageTs = path23.join(
+  const privacyPageTs = path24.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.ts"
   );
-  fs25.mkdirSync(path23.dirname(privacyPage), { recursive: true });
-  fs25.writeFileSync(privacyPage, html);
-  fs25.writeFileSync(
+  fs26.mkdirSync(path24.dirname(privacyPage), { recursive: true });
+  fs26.writeFileSync(privacyPage, html);
+  fs26.writeFileSync(
     privacyPageTs,
     pageMetaTagsLoader("Privacy Policy", `Privacy Policy for ${core.websiteName}`)
   );
-  const relativePrivacyPage = path23.relative(workspaceRootDir, privacyPage);
-  const relativePrivacyPageTs = path23.relative(workspaceRootDir, privacyPageTs);
+  const relativePrivacyPage = path24.relative(workspaceRootDir, privacyPage);
+  const relativePrivacyPageTs = path24.relative(workspaceRootDir, privacyPageTs);
   reportResult({
     summary: "Generated placeholder privacy policy.",
     filesCreated: [relativePrivacyPage, relativePrivacyPageTs],
@@ -6566,8 +6825,8 @@ import { Command as Command56 } from "commander";
 import { Command as Command51 } from "commander";
 
 // src/lib/data.ts
-import fs26 from "node:fs";
-import path24 from "node:path";
+import fs27 from "node:fs";
+import path25 from "node:path";
 import { ClientResponseError } from "pocketbase";
 
 // src/lib/collections.ts
@@ -6604,14 +6863,14 @@ function dependencyOrder(collections2, startingCollectionId) {
 
 // src/lib/data.ts
 function dataDir(cwd, kind) {
-  return path24.join(cwd, DATA_DIR, kind);
+  return path25.join(cwd, DATA_DIR, kind);
 }
 function getDataFiles(cwd, kind) {
   const dir = dataDir(cwd, kind);
-  if (!fs26.existsSync(dir)) return [];
-  return fs26.readdirSync(dir).filter((file) => file.endsWith(".json")).sort((a, b) => a.localeCompare(b)).map((file) => ({
+  if (!fs27.existsSync(dir)) return [];
+  return fs27.readdirSync(dir).filter((file) => file.endsWith(".json")).sort((a, b) => a.localeCompare(b)).map((file) => ({
     collectionName: file.replace(/\.json$/i, "").replace(/^\d+[-_]?/, ""),
-    filePath: path24.join(dir, file)
+    filePath: path25.join(dir, file)
   }));
 }
 function getSeedFiles(cwd) {
@@ -6621,7 +6880,7 @@ function getFixtureFiles(cwd) {
   return getDataFiles(cwd, "fixtures");
 }
 function readRecords(filePath) {
-  return JSON.parse(fs26.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs27.readFileSync(filePath, "utf8"));
 }
 function readSeedIds(cwd) {
   const ids = /* @__PURE__ */ new Map();
@@ -6658,7 +6917,7 @@ function describeError(e) {
   return e instanceof Error ? e.message : String(e);
 }
 function label3(cwd, filePath, count) {
-  return `${path24.relative(cwd, filePath)} (${count} records)`;
+  return `${path25.relative(cwd, filePath)} (${count} records)`;
 }
 async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
   const records = readRecords(filePath);
@@ -6666,7 +6925,7 @@ async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
     try {
       await pb.collection(collectionName).create(record);
     } catch (e) {
-      throw new DataLoadError(kind, path24.relative(cwd, filePath), index, e);
+      throw new DataLoadError(kind, path25.relative(cwd, filePath), index, e);
     }
   }
   return records.length;
@@ -6840,8 +7099,8 @@ var reset = new Command53("reset").description("clear and reload fixtures").conf
 );
 
 // src/commands/fixtures/generate.ts
-import fs27 from "node:fs";
-import path25 from "node:path";
+import fs28 from "node:fs";
+import path26 from "node:path";
 import { Command as Command54, InvalidArgumentError } from "commander";
 import * as p34 from "@clack/prompts";
 import { annotate } from "annotate-json-schema";
@@ -6878,9 +7137,9 @@ async function loadCollections(pb) {
 }
 async function generateFixtureFiles(pb, workspaceRootDir, opts) {
   const fixturesDir = dataDir(workspaceRootDir, "fixtures");
-  fs27.mkdirSync(fixturesDir, { recursive: true });
-  for (const file of fs27.readdirSync(fixturesDir)) {
-    if (file.endsWith(".json")) fs27.unlinkSync(path25.join(fixturesDir, file));
+  fs28.mkdirSync(fixturesDir, { recursive: true });
+  for (const file of fs28.readdirSync(fixturesDir)) {
+    if (file.endsWith(".json")) fs28.unlinkSync(path26.join(fixturesDir, file));
   }
   if (opts.seed !== void 0) faker.seed(opts.seed);
   const generator = createGenerator({
@@ -6947,8 +7206,8 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
       items.push(record);
     }
     const filename = `${padZeros(fileIndex, 2)}-${collection.name}.json`;
-    fs27.writeFileSync(path25.join(fixturesDir, filename), JSON.stringify(items, null, 2));
-    writtenFiles.push(`${path25.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
+    fs28.writeFileSync(path26.join(fixturesDir, filename), JSON.stringify(items, null, 2));
+    writtenFiles.push(`${path26.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
     fileIndex++;
   }
   return { writtenFiles, warnings };
@@ -7095,8 +7354,8 @@ var load2 = new Command57("load").description("load seeds into the database").op
 );
 
 // src/commands/seeds/save.ts
-import fs28 from "node:fs";
-import path26 from "node:path";
+import fs29 from "node:fs";
+import path27 from "node:path";
 import { Command as Command58 } from "commander";
 var padZeros2 = (num, length) => num.toString().padStart(length, "0");
 function filterSystemFields(record, systemFieldNames) {
@@ -7116,10 +7375,10 @@ var save = new Command58("save").description("save the current data as seeds").o
     if (existing.length > 0 && !opts.force) {
       throw new Error("Existing seed files found in data/seeds. Pass --force to overwrite.");
     }
-    fs28.mkdirSync(seedsPath, { recursive: true });
+    fs29.mkdirSync(seedsPath, { recursive: true });
     if (opts.force) {
-      for (const file of fs28.readdirSync(seedsPath)) {
-        if (file.endsWith(".json")) fs28.unlinkSync(path26.join(seedsPath, file));
+      for (const file of fs29.readdirSync(seedsPath)) {
+        if (file.endsWith(".json")) fs29.unlinkSync(path27.join(seedsPath, file));
       }
     }
     const saved = [];
@@ -7148,13 +7407,13 @@ var save = new Command58("save").description("save the current data as seeds").o
         const filtered = records.map(
           (r) => filterSystemFields(r, systemFieldNames)
         );
-        const relativeSeedPath = path26.join(
+        const relativeSeedPath = path27.join(
           DATA_DIR,
           "seeds",
           `${padZeros2(count, 2)}-${collectionName}.json`
         );
-        const seedPath = path26.join(workspaceRootDir, relativeSeedPath);
-        fs28.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
+        const seedPath = path27.join(workspaceRootDir, relativeSeedPath);
+        fs29.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
         saved.push(`${relativeSeedPath} (${filtered.length} records)`);
         count++;
       }
@@ -7220,7 +7479,7 @@ import * as p37 from "@clack/prompts";
 import makeFetchCookie2 from "fetch-cookie";
 
 // src/commands/login.ts
-import os3 from "node:os";
+import os4 from "node:os";
 import { Command as Command61 } from "commander";
 import * as p36 from "@clack/prompts";
 import makeFetchCookie from "fetch-cookie";
@@ -7254,7 +7513,7 @@ var login = new Command61("login").description("login to velastack.dev").configu
   }, "Failed to login.")
 );
 async function issueApiKey(fetchCookie) {
-  const label4 = `CLI - ${os3.hostname()}`;
+  const label4 = `CLI - ${os4.hostname()}`;
   await fetchCookie(`${API_URL}/api-keys/new`, {
     method: "POST",
     headers: {
@@ -7365,7 +7624,7 @@ import { Command as Command70 } from "commander";
 import { Command as Command65 } from "commander";
 
 // src/lib/migrate.ts
-import path27 from "node:path";
+import path28 from "node:path";
 import process19 from "node:process";
 import { x as x2 } from "tinyexec";
 async function runPocketbaseMigrate(args) {
@@ -7376,9 +7635,9 @@ async function runPocketbaseMigrate(args) {
     binaryPath,
     [
       "--dir",
-      path27.join(cwd, DATA_DIR),
+      path28.join(cwd, DATA_DIR),
       "--migrationsDir",
-      path27.join(cwd, MIGRATIONS_DIR),
+      path28.join(cwd, MIGRATIONS_DIR),
       "migrate",
       ...args
     ],
@@ -7426,8 +7685,8 @@ var down = new Command66("down").alias("rollback").description("revert the last
 );
 
 // src/commands/migrate/create.ts
-import fs29 from "node:fs";
-import path28 from "node:path";
+import fs30 from "node:fs";
+import path29 from "node:path";
 import process20 from "node:process";
 import { Command as Command67 } from "commander";
 var create2 = new Command67("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
@@ -7439,7 +7698,7 @@ var create2 = new Command67("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) => path28.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path29.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."
@@ -7448,14 +7707,14 @@ var create2 = new Command67("create").alias("new").description("create a new bla
   }, "Failed to create migration.")
 );
 function listMigrationFiles(cwd) {
-  const dir = path28.join(cwd, MIGRATIONS_DIR);
-  if (!fs29.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs29.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  const dir = path29.join(cwd, MIGRATIONS_DIR);
+  if (!fs30.existsSync(dir)) return /* @__PURE__ */ new Set();
+  return new Set(fs30.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/collections.ts
-import fs30 from "node:fs";
-import path29 from "node:path";
+import fs31 from "node:fs";
+import path30 from "node:path";
 import process21 from "node:process";
 import { Command as Command68 } from "commander";
 var collections = new Command68("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
@@ -7473,7 +7732,7 @@ var collections = new Command68("collections").alias("snapshot").description("sn
     }
     reportResult({
       summary: "Snapshotted local collections into a new migration.",
-      filesCreated: added.map((f) => path29.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path30.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Review the generated snapshot in ${MIGRATIONS_DIR}/.`,
         "Commit the snapshot so teammates pick up the new schema.",
@@ -7483,9 +7742,9 @@ var collections = new Command68("collections").alias("snapshot").description("sn
   }, "Failed to snapshot collections.")
 );
 function listMigrationFiles2(cwd) {
-  const dir = path29.join(cwd, MIGRATIONS_DIR);
-  if (!fs30.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs30.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  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/history-sync.ts
@@ -7504,8 +7763,8 @@ var historySync = new Command69("history-sync").description("drop _migrations ro
 var migrate = new Command70("migrate").description("manage database migrations").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations.")).addCommand(up).addCommand(down).addCommand(create2).addCommand(collections).addCommand(historySync);
 
 // src/commands/dev.ts
-import fs31 from "node:fs";
-import path31 from "node:path";
+import fs32 from "node:fs";
+import path32 from "node:path";
 import process23 from "node:process";
 import { performance } from "node:perf_hooks";
 import { Command as Command71, InvalidArgumentError as InvalidArgumentError4 } from "commander";
@@ -7513,7 +7772,7 @@ import pc15 from "picocolors";
 import PocketBase4 from "pocketbase";
 
 // src/lib/vite.ts
-import path30 from "node:path";
+import path31 from "node:path";
 import process22 from "node:process";
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -7533,7 +7792,7 @@ function viteVersionError(version) {
 }
 function resolveProjectVite(cwd) {
   try {
-    return createRequire2(path30.join(cwd, "package.json")).resolve("vite");
+    return createRequire2(path31.join(cwd, "package.json")).resolve("vite");
   } catch {
     return null;
   }
@@ -7562,21 +7821,21 @@ var dev = new Command71("dev").description("start the development server").optio
   process23.env.VELA_DATA_DIR ??= localDataDir(cwd);
   const startTime = performance.now();
   const { createServer, version } = await loadVite(cwd);
-  const viteMetadataDir = path31.join(cwd, "node_modules", ".vite");
-  const viteMetadataFile = path31.join(viteMetadataDir, "_pocketbase_metadata.json");
+  const viteMetadataDir = path32.join(cwd, "node_modules", ".vite");
+  const viteMetadataFile = path32.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
   const needsStart = backend3 && !process23.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
-    if (fs31.existsSync(viteMetadataFile)) fs31.rmSync(viteMetadataFile);
+    if (fs32.existsSync(viteMetadataFile)) fs32.rmSync(viteMetadataFile);
   };
   if (needsStart) {
-    const dataDir2 = path31.join(cwd, DATA_DIR);
+    const dataDir2 = path32.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path31.join(dataDir2, "hooks"),
+      hooksDir: path32.join(dataDir2, "hooks"),
       dev: true,
       stdio: "pipe"
     });
@@ -7607,8 +7866,8 @@ var dev = new Command71("dev").description("start the development server").optio
     if (!backend3) return;
     const { address, port: vitePort } = server.httpServer.address();
     const viteHost = address === "::1" ? "localhost" : address;
-    await fs31.promises.mkdir(viteMetadataDir, { recursive: true });
-    await fs31.promises.writeFile(
+    await fs32.promises.mkdir(viteMetadataDir, { recursive: true });
+    await fs32.promises.writeFile(
       viteMetadataFile,
       JSON.stringify({
         pocketbaseUrl: process23.env.POCKETBASE_URL,
@@ -7640,18 +7899,18 @@ var dev = new Command71("dev").description("start the development server").optio
 });
 async function startWatchingTypes(cwd, pb) {
   const { processTypes } = await import("@velastack/pocketbase-codegen");
-  const typesDir = path31.resolve(cwd, ".svelte-kit", "types");
-  const pocketbaseDir = path31.join(typesDir, "pocketbase");
-  const pocketbaseTypes = path31.join(pocketbaseDir, "$types.d.ts");
+  const typesDir = path32.resolve(cwd, ".svelte-kit", "types");
+  const pocketbaseDir = path32.join(typesDir, "pocketbase");
+  const pocketbaseTypes = path32.join(pocketbaseDir, "$types.d.ts");
   const regenerate = () => processTypes(pb, typesDir).catch(() => {
   });
   await regenerate();
   void (async () => {
     for (; ; ) {
       try {
-        await fs31.promises.mkdir(pocketbaseDir, { recursive: true });
-        for await (const event of fs31.promises.watch(pocketbaseDir)) {
-          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs31.existsSync(pocketbaseTypes)) {
+        await fs32.promises.mkdir(pocketbaseDir, { recursive: true });
+        for await (const event of fs32.promises.watch(pocketbaseDir)) {
+          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs32.existsSync(pocketbaseTypes)) {
             setTimeout(regenerate, 100);
           }
         }
@@ -7663,8 +7922,8 @@ async function startWatchingTypes(cwd, pb) {
 }
 
 // src/commands/build.ts
-import fs32 from "node:fs";
-import path32 from "node:path";
+import fs33 from "node:fs";
+import path33 from "node:path";
 import process25 from "node:process";
 import { Command as Command72 } from "commander";
 import * as p40 from "@clack/prompts";
@@ -7702,7 +7961,7 @@ function splitHosts(value) {
 }
 
 // src/commands/build.ts
-var PRERENDERED_DIR = path32.join(".svelte-kit", "output", "prerendered");
+var PRERENDERED_DIR = path33.join(".svelte-kit", "output", "prerendered");
 var build = new Command72("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 = process25.cwd();
   applyBuildEnv(cwd);
@@ -7715,11 +7974,11 @@ var build = new Command72("build").description("build the app").configureHelp(he
   };
   if (needsStart) {
     await ensureSuperuser(cwd);
-    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
     });
     pbProc = started.proc;
@@ -7758,8 +8017,8 @@ async function originForBuild(cwd, target) {
   }
 }
 function warnIfPrerendered(cwd) {
-  const dir = path32.join(cwd, PRERENDERED_DIR);
-  if (!fs32.existsSync(dir) || fs32.readdirSync(dir).length === 0) return;
+  const dir = path33.join(cwd, PRERENDERED_DIR);
+  if (!fs33.existsSync(dir) || fs33.readdirSync(dir).length === 0) return;
   p40.log.warn(
     `Prerendered pages were built with no domain configured, so their canonical
 links point at SvelteKit's placeholder host rather than at this site.
@@ -7769,7 +8028,7 @@ Set one with ${pc16.cyan("vela deploy --domain example.com")}, or pass ${pc16.cy
 }
 
 // src/commands/preview.ts
-import path33 from "node:path";
+import path34 from "node:path";
 import process26 from "node:process";
 import { Command as Command73 } from "commander";
 import { x as x4 } from "tinyexec";
@@ -7784,11 +8043,11 @@ var preview = new Command73("preview").description("preview the built app").conf
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
-    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;
@@ -7814,12 +8073,12 @@ var preview = new Command73("preview").description("preview the built app").conf
 });
 
 // src/commands/sync.ts
-import path34 from "node:path";
+import path35 from "node:path";
 import { Command as Command74 } from "commander";
 var sync = new Command74("sync").description("sync types from the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const typesDir = path34.join(workspaceRootDir, ".svelte-kit", "types");
+    const typesDir = path35.join(workspaceRootDir, ".svelte-kit", "types");
     const { processTypes } = await import("@velastack/pocketbase-codegen");
     await withPocketbase(workspaceRootDir, async (pb) => {
       await processTypes(pb, typesDir);
@@ -7832,11 +8091,11 @@ var sync = new Command74("sync").description("sync types from the database").con
 import { Command as Command75 } from "commander";
 import * as p41 from "@clack/prompts";
 import pc17 from "picocolors";
-import * as v6 from "valibot";
-var OptionsSchema2 = v6.object({
+import * as v7 from "valibot";
+var OptionsSchema2 = v7.object({
   ...SSH_OPTION_SCHEMA,
-  pbVersion: v6.optional(v6.string()),
-  nodeMajor: v6.optional(v6.string())
+  pbVersion: v7.optional(v7.string()),
+  nodeMajor: v7.optional(v7.string())
 });
 var provision = addSshOptions(
   new Command75("provision").description("prepare a server to host vela apps").argument("<target>", "SSH target \u2014 an alias from ~/.ssh/config, or user@host").configureHelp(helpConfig)
@@ -7881,22 +8140,22 @@ var provision = addSshOptions(
 );
 
 // src/commands/deploy.ts
-import path36 from "node:path";
-import fs34 from "node:fs";
+import path37 from "node:path";
+import fs35 from "node:fs";
 import { Command as Command76, Option as Option2 } from "commander";
 import * as p42 from "@clack/prompts";
 import pc18 from "picocolors";
-import * as v7 from "valibot";
+import * as v8 from "valibot";
 
 // src/lib/pocketbase-settings.ts
-import fs33 from "node:fs";
-import path35 from "node:path";
+import fs34 from "node:fs";
+import path36 from "node:path";
 import process27 from "node:process";
 import PocketBase5 from "pocketbase";
 var COPIED_KEYS = ["appName", "senderName", "senderAddress"];
 async function readLocalMeta(cwd) {
-  const dataDir2 = path35.join(cwd, DATA_DIR);
-  if (!fs33.existsSync(dataDir2)) return null;
+  const dataDir2 = path36.join(cwd, DATA_DIR);
+  if (!fs34.existsSync(dataDir2)) return null;
   const email3 = process27.env.POCKETBASE_SUPERUSER_EMAIL;
   const password11 = process27.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email3 || !password11) return null;
@@ -7905,7 +8164,7 @@ async function readLocalMeta(cwd) {
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path35.join(dataDir2, "hooks")
+      hooksDir: path36.join(dataDir2, "hooks")
     });
     proc = started.proc;
     const pb = new PocketBase5(started.url);
@@ -7947,16 +8206,16 @@ async function seedRemoteMeta(session, instance, local, appURL) {
 }
 
 // src/commands/deploy.ts
-var OptionsSchema3 = v7.object({
+var OptionsSchema3 = v8.object({
   ...SSH_OPTION_SCHEMA,
-  env: v7.optional(v7.string()),
-  project: v7.optional(v7.string()),
-  remoteDb: v7.optional(v7.boolean()),
-  domain: v7.optional(v7.string()),
-  healthPath: v7.optional(v7.string()),
-  keep: v7.optional(v7.string()),
-  pbVersion: v7.optional(v7.string()),
-  build: v7.optional(v7.boolean())
+  env: v8.optional(v8.string()),
+  project: v8.optional(v8.string()),
+  remoteDb: v8.optional(v8.boolean()),
+  domain: v8.optional(v8.string()),
+  healthPath: v8.optional(v8.string()),
+  keep: v8.optional(v8.string()),
+  pbVersion: v8.optional(v8.string()),
+  build: v8.optional(v8.boolean())
 });
 var deploy = addTargetOptions(
   new Command76("deploy").description("deploy the app").configureHelp(helpConfig),
@@ -8255,7 +8514,7 @@ async function uploadRelease(session, instance, release, entries) {
 }
 function isDirectory(target) {
   try {
-    return fs34.statSync(target).isDirectory();
+    return fs35.statSync(target).isDirectory();
   } catch {
     return false;
   }
@@ -8263,7 +8522,7 @@ function isDirectory(target) {
 async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
-  if (!fs34.existsSync(path36.join(workspaceRootDir, ".env"))) return;
+  if (!fs35.existsSync(path37.join(workspaceRootDir, ".env"))) return;
   p42.log.warn(
     `This app has no production environment variables yet.
 
@@ -8273,7 +8532,7 @@ ${pc18.cyan("vela env set KEY")}, or copy a file across with ${pc18.cyan("vela e
 }
 
 // src/commands/link.ts
-import path37 from "node:path";
+import path38 from "node:path";
 import process28 from "node:process";
 import { Command as Command77 } from "commander";
 import * as p43 from "@clack/prompts";
@@ -8351,7 +8610,7 @@ async function promptProjectName(workspaceRootDir) {
     defaultValue,
     initialValue: defaultValue,
     placeholder: defaultValue,
-    validate: (v9) => !v9?.trim() ? "Required" : void 0
+    validate: (v10) => !v10?.trim() ? "Required" : void 0
   });
   if (p43.isCancel(value)) {
     p43.cancel("Operation cancelled.");
@@ -8361,12 +8620,12 @@ async function promptProjectName(workspaceRootDir) {
 }
 function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path37.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path38.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path37.basename(workspaceRootDir);
+  return path38.basename(workspaceRootDir);
 }
 
 // src/commands/env.ts
@@ -8497,8 +8756,8 @@ var envUnset = addTargetOptions(
 );
 
 // src/commands/env/import.ts
-import fs35 from "node:fs";
-import path38 from "node:path";
+import fs36 from "node:fs";
+import path39 from "node:path";
 import process30 from "node:process";
 import { Command as Command81 } from "commander";
 import * as p47 from "@clack/prompts";
@@ -8544,10 +8803,10 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path38.resolve(process30.cwd(), file);
+  return path39.resolve(process30.cwd(), file);
 }
 function read(resolved, shown) {
-  if (!fs35.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
+  if (!fs36.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
   const incoming = readLocalEnvFile(resolved);
   if (Object.keys(incoming).length === 0) p47.log.info(`${shown} has no variables to import.`);
   return incoming;
@@ -8819,8 +9078,8 @@ var admin = new Command87("admin").description("manage admin panel logins").conf
 import { Command as Command93 } from "commander";
 
 // src/commands/backup/create.ts
-import fs36 from "node:fs";
-import path39 from "node:path";
+import fs37 from "node:fs";
+import path40 from "node:path";
 import { Command as Command88 } from "commander";
 import * as p51 from "@clack/prompts";
 import pc26 from "picocolors";
@@ -8974,12 +9233,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 = path39.resolve(ctx.workspaceRootDir, outputDir);
-  fs36.mkdirSync(dir, { recursive: true });
-  const destination = path39.join(dir, key);
+  const dir = path40.resolve(ctx.workspaceRootDir, outputDir);
+  fs37.mkdirSync(dir, { recursive: true });
+  const destination = path40.join(dir, key);
   if (!ctx.session) {
-    fs36.copyFileSync(path39.join(ctx.workspaceRootDir, "data", "backups", key), destination);
-    return path39.relative(ctx.workspaceRootDir, destination);
+    fs37.copyFileSync(path40.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+    return path40.relative(ctx.workspaceRootDir, destination);
   }
   const spinner7 = p51.spinner();
   spinner7.start(`Downloading ${key}`);
@@ -8990,7 +9249,7 @@ async function download(ctx, key, outputDir) {
     throw error;
   }
   spinner7.stop(`Downloaded ${key}`);
-  return path39.relative(ctx.workspaceRootDir, destination);
+  return path40.relative(ctx.workspaceRootDir, destination);
 }
 
 // src/commands/backup/list.ts
@@ -9024,8 +9283,8 @@ Take one with ${pc27.cyan("vela backup create")}.`
 );
 
 // src/commands/backup/download.ts
-import fs37 from "node:fs";
-import path40 from "node:path";
+import fs38 from "node:fs";
+import path41 from "node:path";
 import { Command as Command90 } from "commander";
 import * as p53 from "@clack/prompts";
 import pc28 from "picocolors";
@@ -9052,11 +9311,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 = path40.resolve(ctx.workspaceRootDir, options.output);
-      fs37.mkdirSync(dir, { recursive: true });
-      const destination = path40.join(dir, key);
+      const dir = path41.resolve(ctx.workspaceRootDir, options.output);
+      fs38.mkdirSync(dir, { recursive: true });
+      const destination = path41.join(dir, key);
       if (!ctx.session) {
-        fs37.copyFileSync(path40.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+        fs38.copyFileSync(path41.join(ctx.workspaceRootDir, "data", "backups", key), destination);
       } else {
         const spinner7 = p53.spinner();
         spinner7.start(`Downloading ${key} (${formatBytes(found.size)})`);
@@ -9070,7 +9329,7 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
       }
       reportResult({
         summary: `Saved ${key} from ${ctx.targetName}.`,
-        filesCreated: [path40.relative(ctx.workspaceRootDir, destination)]
+        filesCreated: [path41.relative(ctx.workspaceRootDir, destination)]
       });
     });
   }, "Failed to download the backup.")
@@ -9165,8 +9424,8 @@ Set one with ${pc30.cyan('vela backup schedule "0 3 * * *"')}.`
 var backup = new Command93("backup").description("back up the database and uploads, locally or on a target").configureHelp(helpConfig).addCommand(backupCreate).addCommand(backupList).addCommand(backupDownload).addCommand(backupDelete).addCommand(backupSchedule);
 
 // src/commands/restore.ts
-import fs38 from "node:fs";
-import path41 from "node:path";
+import fs39 from "node:fs";
+import path42 from "node:path";
 import process33 from "node:process";
 import { Command as Command94 } from "commander";
 import * as p56 from "@clack/prompts";
@@ -9187,7 +9446,7 @@ var restore = addTargetOptions(
               `${ctx.targetName} was deployed without a database, so there is nothing to restore.`
             );
           }
-          const local = source && fs38.existsSync(source) ? source : void 0;
+          const local = source && fs39.existsSync(source) ? source : void 0;
           const key = local ? void 0 : await resolveKey(ctx, source);
           if (!options.yes) {
             await confirm12(ctx.appName, ctx.targetName, ctx.envTag, local ?? key);
@@ -9209,7 +9468,7 @@ var restore = addTargetOptions(
           });
           p56.log.success(
             `Restored ${pc31.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${pc31.cyan(
-              local ? path41.basename(local) : key
+              local ? path42.basename(local) : key
             )}.`
           );
           if (result?.storageCarriedOver) {
@@ -9275,21 +9534,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}/${path41.basename(file)}`;
+  const remote = `${dir}/${path42.basename(file)}`;
   const spinner7 = p56.spinner();
-  spinner7.start(`Uploading ${path41.basename(file)}`);
+  spinner7.start(`Uploading ${path42.basename(file)}`);
   try {
     await ctx.session.script(`mkdir -p "$1"`, { args: [dir] });
     await ctx.session.upload([file], dir);
   } catch (error) {
-    spinner7.stop(`Could not upload ${path41.basename(file)}.`);
+    spinner7.stop(`Could not upload ${path42.basename(file)}.`);
     throw error;
   }
-  spinner7.stop(`Uploaded ${path41.basename(file)}`);
+  spinner7.stop(`Uploaded ${path42.basename(file)}`);
   return remote;
 }
 async function confirm12(appName, targetName, envTag, from) {
-  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path41.basename(from))}`;
+  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path42.basename(from))}`;
   if (isProd(envTag)) {
     const answer = await p56.text({
       message: `This replaces the database and uploads of ${what}. Type the app name to confirm`,
@@ -9315,11 +9574,11 @@ async function confirm12(appName, targetName, envTag, from) {
 import { Command as Command95 } from "commander";
 import * as p57 from "@clack/prompts";
 import pc32 from "picocolors";
-import * as v8 from "valibot";
-var OptionsSchema4 = v8.object({
+import * as v9 from "valibot";
+var OptionsSchema4 = v9.object({
   ...SSH_OPTION_SCHEMA,
-  json: v8.optional(v8.boolean()),
-  offline: v8.optional(v8.boolean())
+  json: v9.optional(v9.boolean()),
+  offline: v9.optional(v9.boolean())
 });
 var targets = addSshOptions(
   new Command95("targets").description("list the targets this project can deploy to").configureHelp(helpConfig)
@@ -9400,7 +9659,7 @@ Release and domain are shown from what this project recorded.`
 }
 
 // src/commands/test.ts
-import path42 from "node:path";
+import path43 from "node:path";
 import process34 from "node:process";
 import { Command as Command96 } from "commander";
 import PocketBase6 from "pocketbase";
@@ -9408,20 +9667,20 @@ import pc33 from "picocolors";
 import { x as x5 } from "tinyexec";
 import { detect as detect7 } from "package-manager-detector";
 import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
-import fs39 from "node:fs";
+import fs40 from "node:fs";
 var testServer = new Command96("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
   const cwd = process34.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password11 = "password";
-  const testDataDir = path42.join(cwd, "test-data");
-  fs39.rmSync(testDataDir, { recursive: true, force: true });
+  const testDataDir = path43.join(cwd, "test-data");
+  fs40.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path42.join(cwd, MIGRATIONS_DIR),
+    migrationsDir: path43.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: path42.join(cwd, DATA_DIR, "hooks"),
+    hooksDir: path43.join(cwd, DATA_DIR, "hooks"),
     email: email3,
     password: password11
   });
@@ -9437,7 +9696,7 @@ var testServer = new Command96("test:server").description("run server tests").al
     if (cleanedUp) return;
     cleanedUp = true;
     stop();
-    fs39.rmSync(testDataDir, { recursive: true, force: true });
+    fs40.rmSync(testDataDir, { recursive: true, force: true });
   };
   const cleanup = async () => {
     if (cleanedUp) return;
@@ -9536,8 +9795,8 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs40 from "node:fs";
-import path43 from "node:path";
+import fs41 from "node:fs";
+import path44 from "node:path";
 import { Command as Command97 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
@@ -9551,30 +9810,30 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
 ]);
 var routes = new Command97("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path43.join(workspaceRootDir, routesDir);
+  const routesRoot = path44.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);
 });
 function walk(root, dir) {
-  const entries = fs40.readdirSync(dir, { withFileTypes: true });
+  const entries = fs41.readdirSync(dir, { withFileTypes: true });
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
-    const id = "/" + path43.relative(root, dir).split(path43.sep).filter(Boolean).join("/");
+    const id = "/" + path44.relative(root, dir).split(path44.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(path43.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path44.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, path43.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path44.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -9583,7 +9842,7 @@ function isRouteFile(name) {
 }
 function extractMethods(file) {
   try {
-    const content = fs40.readFileSync(file, "utf8");
+    const content = fs41.readFileSync(file, "utf8");
     const methods = [];
     const exportRegex = /export\s+(?:const|async\s+function|function)\s+(\w+)/g;
     let match;
@@ -9640,11 +9899,11 @@ async function runWuchale(extraArgs) {
     throwOnError: true
   });
 }
-var extract = new Command98("extract").description("extract translatable strings").configureHelp(helpConfig).action(() => runWuchale([]));
+var extract2 = new Command98("extract").description("extract translatable strings").configureHelp(helpConfig).action(() => runWuchale([]));
 var watch = new Command98("watch").description("watch and extract translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--watch"]));
 var status2 = new Command98("status").description("show i18n status").configureHelp(helpConfig).action(() => runWuchale(["status"]));
 var clean = new Command98("clean").description("clean unused translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--clean"]));
-var i18n3 = new Command98("i18n").description("i18n utilities").configureHelp(helpConfig).addCommand(extract, { isDefault: true }).addCommand(watch).addCommand(status2).addCommand(clean);
+var i18n3 = new Command98("i18n").description("i18n utilities").configureHelp(helpConfig).addCommand(extract2, { isDefault: true }).addCommand(watch).addCommand(status2).addCommand(clean);
 
 // src/commands/oauth.ts
 var oauth = stubCommand("oauth", "configure OAuth providers");
@@ -9666,7 +9925,7 @@ import pc35 from "picocolors";
 
 // src/lib/cms-backend.ts
 import { createRequire as createRequire3 } from "node:module";
-import path44 from "node:path";
+import path45 from "node:path";
 import process36 from "node:process";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import pc34 from "picocolors";
@@ -9674,7 +9933,7 @@ var DEFAULT_PROJECT = "default";
 async function loadBackendModule(root) {
   let entry;
   try {
-    entry = createRequire3(path44.join(root, "package.json")).resolve("@velastack/cms/backend");
+    entry = createRequire3(path45.join(root, "package.json")).resolve("@velastack/cms/backend");
   } catch {
     throw new Error(
       `@velastack/cms is not installed in this project.
@@ -9692,8 +9951,8 @@ async function withCmsBackend(fn, cwd = process36.cwd()) {
   const { createCmsBackend } = await loadBackendModule(root);
   const dataDir2 = localDataDir(root);
   const backend3 = createCmsBackend({
-    dbPath: path44.join(dataDir2, "cms.sqlite"),
-    uploadDir: path44.join(dataDir2, "uploads")
+    dbPath: path45.join(dataDir2, "cms.sqlite"),
+    uploadDir: path45.join(dataDir2, "uploads")
   });
   try {
     return await fn(backend3);
@@ -9805,14 +10064,14 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (isStub(actionCommand)) return;
   const envRoot = findWorkspaceRoot() ?? process37.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
-  const path45 = getCommandPath(actionCommand);
-  if (NO_BACKEND_COMMMANDS.has(path45)) return;
-  const top = path45.split(" ", 1)[0];
+  const path46 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path46)) return;
+  const top = path46.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
     p61.log.error(
-      `${pc38.cyan(`vela ${path45}`)} needs a backend, and this project does not have one.
+      `${pc38.cyan(`vela ${path46}`)} needs a backend, and this project does not have one.
 
 Static projects have no database to talk to.
 
@@ -9822,7 +10081,7 @@ To add a backend to this project, run ${pc38.cyan("vela bless")}.`
     p61.cancel("Operation failed.");
     process37.exit(1);
   }
-  if (SELF_CREDENTIALED_COMMANDS.has(path45)) return;
+  if (SELF_CREDENTIALED_COMMANDS.has(path46)) return;
   if (!process37.env.POCKETBASE_SUPERUSER_EMAIL || !process37.env.POCKETBASE_SUPERUSER_PASSWORD) {
     p61.log.error(
       `PocketBase superuser credentials are required.