vela 0.11.5 → 0.12.0

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import process39 from "node:process";
+import process42 from "node:process";
 
 // src/lib/argv.ts
 function normalizeArgv(argv) {
@@ -11,9 +11,9 @@ function normalizeArgv(argv) {
 }
 
 // src/program.ts
-import process38 from "node:process";
-import * as p61 from "@clack/prompts";
-import { Command as Command104 } from "commander";
+import process41 from "node:process";
+import * as p63 from "@clack/prompts";
+import { Command as Command105 } from "commander";
 import nodePath from "node:path";
 import dotenv2 from "dotenv";
 import pc38 from "picocolors";
@@ -21,7 +21,7 @@ import pc38 from "picocolors";
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.11.5",
+  version: "0.12.0",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -57,7 +57,7 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^1.7.0",
     "@faker-js/faker": "^10.6.0",
-    "@velastack/patterns": "^0.2.4",
+    "@velastack/patterns": "^0.2.5",
     "@velastack/pocketbase-codegen": "^0.1.0",
     "annotate-json-schema": "^0.1.0",
     commander: "^13.1.0",
@@ -66,7 +66,7 @@ var package_default = {
     dotenv: "^17.4.2",
     "fetch-cookie": "^3.2.0",
     "json-schema-faker": "^0.6.3",
-    "magic-string": "^0.30.21",
+    "magic-string": "^1.2.3",
     "package-manager-detector": "^1.8.0",
     picocolors: "^1.1.1",
     pocketbase: "^0.28.0",
@@ -321,10 +321,15 @@ function readPackageJson(path47) {
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
 var CLI_VERSION_PLACEHOLDER = /~VELA_VERSION~/g;
+var SITE_URL_PLACEHOLDER = /~SITE_URL~/g;
+var CMS_ENDPOINT_PLACEHOLDER = /~CMS_ENDPOINT~/g;
+var LOCAL_SITE_URL = "http://localhost:5173";
 function fillTemplatePlaceholders(raw, values) {
   const packageName = toValidPackageName(values.appName);
   const appName = escapeSingleQuoted(values.appName);
-  return raw.replace(PACKAGE_NAME_PLACEHOLDER, () => packageName).replace(APP_NAME_PLACEHOLDER, () => appName).replace(CLI_VERSION_PLACEHOLDER, () => values.cliVersion);
+  const siteUrl = escapeSingleQuoted(values.siteUrl ?? LOCAL_SITE_URL);
+  const cmsEndpoint = escapeSingleQuoted(values.cmsEndpoint ?? "");
+  return raw.replace(PACKAGE_NAME_PLACEHOLDER, () => packageName).replace(APP_NAME_PLACEHOLDER, () => appName).replace(CLI_VERSION_PLACEHOLDER, () => values.cliVersion).replace(SITE_URL_PLACEHOLDER, () => siteUrl).replace(CMS_ENDPOINT_PLACEHOLDER, () => cmsEndpoint);
 }
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -562,6 +567,10 @@ var entrySchema = v2.object({
   price: v2.optional(v2.number()),
   previewUrl: v2.optional(v2.string()),
   nextSteps: v2.optional(v2.array(v2.string())),
+  /** Reads its copy from a hosted CMS through `site.cmsEndpoint`. */
+  cms: v2.optional(v2.boolean()),
+  /** A prebuilt static build is published for velastack.dev's instant deploys. */
+  instantDeploy: v2.optional(v2.boolean()),
   /** Tarball location, relative to the index URL. */
   file: v2.string(),
   sha256: v2.pipe(v2.string(), v2.regex(/^[0-9a-f]{64}$/)),
@@ -593,10 +602,10 @@ function writeCachedIndex(cached2) {
   fs5.mkdirSync(cacheRoot(), { recursive: true });
   fs5.writeFileSync(indexCachePath(), JSON.stringify(cached2, null, 2));
 }
-function parseTemplateIndex(text18, url) {
+function parseTemplateIndex(text19, url) {
   let parsed;
   try {
-    parsed = JSON.parse(text18);
+    parsed = JSON.parse(text19);
   } catch (e) {
     throw new Error(`Template index at ${url} is not valid JSON: ${e.message}`);
   }
@@ -753,6 +762,7 @@ async function listAllTemplates(options = {}) {
       tags: entry.tags,
       price: entry.price,
       nextSteps: entry.nextSteps,
+      cms: entry.cms,
       entry,
       indexUrl
     });
@@ -833,6 +843,7 @@ function readManifest(root, name) {
     tags: optionalStringArray(manifest.tags),
     price: typeof manifest.price === "number" ? manifest.price : void 0,
     nextSteps: optionalStringArray(manifest.nextSteps),
+    cms: typeof manifest.cms === "boolean" ? manifest.cms : void 0,
     dir: path5.join(root, name)
   };
 }
@@ -968,7 +979,7 @@ function waitForReadyOrExit(proc, url, maxAttempts = 40) {
     };
     proc.once("exit", onExit);
     let attempts = 0;
-    const check = async () => {
+    const check2 = async () => {
       if (settled) return;
       attempts++;
       try {
@@ -989,9 +1000,9 @@ function waitForReadyOrExit(proc, url, maxAttempts = 40) {
         reject(new Error(`Timed out waiting for health at ${url}`));
         return;
       }
-      setTimeout(check, 250);
+      setTimeout(check2, 250);
     };
-    check();
+    check2();
   });
 }
 async function startPocketbaseServe(opts) {
@@ -1912,37 +1923,493 @@ function printNextSteps(projectPath, packageManager2) {
 }
 
 // src/commands/create.ts
+import fs17 from "node:fs";
+import path15 from "node:path";
+import process11 from "node:process";
+import * as v4 from "valibot";
+import { Command as Command4 } from "commander";
+import * as p8 from "@clack/prompts";
+import { detect as detect3, resolveCommand as resolveCommand3 } from "package-manager-detector";
+
+// src/lib/providers.ts
+import process8 from "node:process";
+import * as p5 from "@clack/prompts";
+import { bySlug } from "@velastack/patterns";
+function capabilityName(slug2) {
+  return slug2.replace(/^enable-/, "");
+}
+function choices(providers) {
+  return `--provider <${providers.map((provider) => provider.id).join("|")}>`;
+}
+function unknownProviderMessage(name, raw, providers) {
+  return [
+    `Unknown provider "${raw}" for ${name}.`,
+    "",
+    "Available providers:",
+    ...providers.map((provider) => `  ${provider.id}`)
+  ].join("\n");
+}
+function decideProvider(request) {
+  const { patternName, providers, flagValue, interactive } = request;
+  if (flagValue !== void 0) {
+    const provider = providers.find((candidate) => candidate.id === flagValue);
+    if (!provider) {
+      return { kind: "error", message: unknownProviderMessage(patternName, flagValue, providers) };
+    }
+    return { kind: "use", provider };
+  }
+  if (interactive) return { kind: "prompt" };
+  return {
+    kind: "error",
+    message: `Choose ${article(patternName)} ${patternName} provider: pass ${choices(providers)}. There is no terminal to ask on.`
+  };
+}
+function article(word) {
+  return /^[aeiou]/i.test(word) ? "an" : "a";
+}
+function isInteractive() {
+  return Boolean(process8.stdout.isTTY) && !process8.env.CI;
+}
+function providerFlagInArgv(argv) {
+  return argv.some((arg) => arg === "--provider" || arg.startsWith("--provider="));
+}
+function checkProviderInput(pattern, argv, input) {
+  const providers = pattern.providers ?? [];
+  if (providers.length > 0) {
+    if (typeof input.provider !== "string" || input.provider.length === 0) {
+      throw new Error(`${pattern.title} needs a provider. Pass ${choices(providers)}.`);
+    }
+    return;
+  }
+  if (providerFlagInArgv(argv)) {
+    throw new Error(`${pattern.title} does not support --provider.`);
+  }
+}
+async function resolveProvider(slug2, flagValue) {
+  const pattern = bySlug[slug2];
+  const providers = pattern.providers ?? [];
+  if (providers.length === 0) {
+    throw new Error(`${pattern.title} does not support --provider.`);
+  }
+  const patternName = capabilityName(slug2);
+  const decision = decideProvider({
+    patternName,
+    providers,
+    flagValue,
+    interactive: isInteractive()
+  });
+  if (decision.kind === "error") throw new Error(decision.message);
+  if (decision.kind === "use") return decision.provider;
+  const selected = await p5.select({
+    message: `Select ${patternName} provider`,
+    options: providers.map((provider) => ({ value: provider.id, label: provider.label }))
+  });
+  if (p5.isCancel(selected)) {
+    p5.cancel("Operation cancelled.");
+    process8.exit(0);
+  }
+  return providers.find((provider) => provider.id === selected);
+}
+async function collectProviderEnv(provider) {
+  const values = {};
+  const interactive = isInteractive();
+  for (const variable of provider.env ?? []) {
+    const existing = process8.env[variable.key];
+    if (existing) {
+      values[variable.key] = existing;
+      continue;
+    }
+    if (!interactive) {
+      values[variable.key] = variable.default ?? "";
+      continue;
+    }
+    const value = await p5.text({
+      message: variable.label,
+      placeholder: variable.placeholder,
+      initialValue: variable.default
+    });
+    if (p5.isCancel(value)) {
+      p5.cancel("Operation cancelled.");
+      process8.exit(0);
+    }
+    values[variable.key] = (value ?? "").trim();
+  }
+  return values;
+}
+function missingEnvKeys(provider, values) {
+  return (provider.env ?? []).filter((variable) => !(values[variable.key] ?? "").trim() && !variable.default).map((variable) => variable.key);
+}
+
+// src/lib/link-on-create.ts
+var FREE_CMS_HINT = "Get a free CMS at https://velastack.dev";
+var PROJECT_ID_RE = /^[a-z0-9]{15}$/;
+var CMS_URL_RE = /^https?:\/\/\S+$/;
+var NOT_LOGGED_IN = "Not logged in. Run `vela login` to login, or set VELA_API_KEY.";
+var NO_CMS_WARNING = `No CMS configured: \`cmsEndpoint\` in src/lib/site.ts is empty, so the site shows its fallback copy. Pass \`--link new\`, \`--link <project-id>\` or \`--cms <url>\` to set it, or fill it in later. ${FREE_CMS_HINT}.`;
+function decideLink(request) {
+  const { link: link2, needsCms, loggedIn, interactive } = request;
+  if (link2 === "none") return { kind: "none" };
+  if (link2 === "new") {
+    return loggedIn ? { kind: "create" } : { kind: "error", message: NOT_LOGGED_IN };
+  }
+  if (link2 !== void 0) {
+    return loggedIn ? { kind: "existing", projectId: link2 } : { kind: "error", message: NOT_LOGGED_IN };
+  }
+  if (!interactive) return { kind: "none", warn: needsCms ? NO_CMS_WARNING : void 0 };
+  if (loggedIn) return { kind: "create" };
+  return needsCms ? { kind: "prompt-cms" } : { kind: "none" };
+}
+function cmsEndpointFor(projectId) {
+  return `${API_URL}/v1/projects/${projectId}/cms`;
+}
+function normalizeCmsUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function linkNextSteps(outcome) {
+  const steps = [];
+  const { linked, cmsEndpoint, cmsSource, templateCms, loggedIn, interactive } = outcome;
+  if (templateCms && linked && cmsSource === "linked") {
+    steps.push(
+      `Add an editor at ${linked.dashboardUrl}/cms/editors, then open any page with \`?edit\` and sign in from the admin bar.`
+    );
+  } else if (cmsEndpoint) {
+    steps.push("Open any page with `?edit` and sign in from the admin bar.");
+  } else if (templateCms) {
+    steps.push(
+      `When you have a CMS, set \`cmsEndpoint\` in \`src/lib/site.ts\`. ${FREE_CMS_HINT}.`
+    );
+  }
+  if (linked && !(templateCms && cmsSource === "linked")) {
+    steps.push(
+      `Run \`vela deploy\` when you're ready; the project is linked to ${linked.dashboardUrl}.`
+    );
+  } else if (!linked && interactive && !loggedIn && !templateCms) {
+    steps.push("Run `vela login` then `vela link` to get a free velastack.app hostname on deploy.");
+  }
+  return steps;
+}
+
+// src/lib/link-project.ts
+import process9 from "node:process";
+import * as p6 from "@clack/prompts";
+
+// src/lib/velastack-api.ts
+async function apiFetch(apiKey, pathAndQuery, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Authorization", `Bearer ${apiKey}`);
+  if (init?.body && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  const res = await fetch(`${API_URL}${pathAndQuery}`, { ...init, headers });
+  if (res.status === 401) {
+    throw new Error("API key invalid \u2014 run `vela login`");
+  }
+  if (res.status === 403) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`velastack.dev refused this key (${body || "forbidden"}) \u2014 run \`vela login\``);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Velastack API error (${res.status}): ${body || res.statusText}`);
+  }
+  return await res.json();
+}
+async function getCurrentUser(apiKey) {
+  const data = await apiFetch(
+    apiKey,
+    "/api/collections/users/records?perPage=1"
+  );
+  const user = data.items[0];
+  if (!user) throw new Error("No user found. Run `vela login` to login.");
+  return user;
+}
+async function listTeams(apiKey) {
+  const data = await apiFetch(
+    apiKey,
+    "/api/collections/teams/records?perPage=200"
+  );
+  return data.items;
+}
+async function listProjects(apiKey) {
+  const data = await apiFetch(
+    apiKey,
+    "/api/collections/projects/records?perPage=200&expand=team"
+  );
+  return data.items;
+}
+async function createProject(apiKey, args) {
+  return apiFetch(apiKey, "/api/collections/projects/records", {
+    method: "POST",
+    body: JSON.stringify({
+      name: args.name,
+      team: args.teamId,
+      user: args.userId,
+      ...args.template ? { template: args.template } : {}
+    })
+  });
+}
+async function registerServer(apiKey, input) {
+  return apiFetch(apiKey, "/v1/servers", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function startDeployment(apiKey, projectId, input) {
+  return apiFetch(apiKey, `/v1/projects/${projectId}/deployments`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function finishDeployment(apiKey, projectId, deploymentId, input) {
+  return apiFetch(apiKey, `/v1/projects/${projectId}/deployments/${deploymentId}`, {
+    method: "PATCH",
+    body: JSON.stringify(input)
+  });
+}
+async function destroyEnvironment(apiKey, projectId, envTag) {
+  return apiFetch(apiKey, `/v1/projects/${projectId}/environments/${encodeURIComponent(envTag)}`, {
+    method: "DELETE"
+  });
+}
+
+// src/lib/link-project.ts
+function dashboardUrl(teamSlug, projectSlug) {
+  return teamSlug && projectSlug ? `${API_URL}/${teamSlug}/${projectSlug}` : API_URL;
+}
+async function pickTeam(teams3) {
+  if (teams3.length === 1) return teams3[0];
+  const choice = await p6.select({
+    message: "Select a team",
+    options: teams3.map((team) => ({
+      value: team.id,
+      label: team.is_personal ? `${team.name} (personal)` : team.name
+    }))
+  });
+  if (p6.isCancel(choice)) {
+    p6.cancel("Operation cancelled.");
+    process9.exit(0);
+  }
+  return teams3.find((team) => team.id === choice);
+}
+async function resolveTeam(teams3, options) {
+  if (options.teamId) {
+    const team = teams3.find((candidate) => candidate.id === options.teamId);
+    if (!team) {
+      throw new Error(
+        `You are not a member of team ${options.teamId}. Omit --team to use your personal team.`
+      );
+    }
+    return team;
+  }
+  if (teams3.length === 0) throw new Error("No team found on velastack.dev for this account.");
+  const personal = teams3.find((team) => team.is_personal);
+  if (personal) return personal;
+  if (options.interactive) return pickTeam(teams3);
+  throw new Error("Several teams and no personal one: pass --team <id>.");
+}
+async function linkNewProject(apiKey, args) {
+  const [user, teams3] = await Promise.all([getCurrentUser(apiKey), listTeams(apiKey)]);
+  const team = await resolveTeam(teams3, { teamId: args.teamId, interactive: args.interactive });
+  const project = await createProject(apiKey, {
+    name: args.name,
+    teamId: team.id,
+    userId: user.id,
+    template: args.template
+  });
+  return toLinked(project, team);
+}
+async function linkExistingProject(apiKey, projectId) {
+  const projects = await listProjects(apiKey);
+  const project = projects.find((candidate) => candidate.id === projectId);
+  if (!project) {
+    throw new Error(`No project ${projectId} on velastack.dev for this account.`);
+  }
+  return toLinked(project, project.expand?.team);
+}
+function toLinked(project, team) {
+  return {
+    projectId: project.id,
+    teamId: project.team,
+    projectName: project.name,
+    dashboardUrl: dashboardUrl(team?.slug, project.slug)
+  };
+}
+
+// src/lib/project-config.ts
 import fs16 from "node:fs";
 import path14 from "node:path";
-import process8 from "node:process";
-import * as v4 from "valibot";
+function projectConfigPath(workspaceRootDir) {
+  return path14.join(workspaceRootDir, ".vela", "project.json");
+}
+function readProjectConfig(workspaceRootDir) {
+  const file = projectConfigPath(workspaceRootDir);
+  if (!fs16.existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(fs16.readFileSync(file, "utf8"));
+    if (typeof parsed.projectId !== "string" || typeof parsed.teamId !== "string" || typeof parsed.projectName !== "string") {
+      return null;
+    }
+    return {
+      projectId: parsed.projectId,
+      teamId: parsed.teamId,
+      projectName: parsed.projectName
+    };
+  } catch {
+    return null;
+  }
+}
+function writeProjectConfig(workspaceRootDir, config) {
+  const file = projectConfigPath(workspaceRootDir);
+  fs16.mkdirSync(path14.dirname(file), { recursive: true });
+  let existing = {};
+  if (fs16.existsSync(file)) {
+    try {
+      existing = JSON.parse(fs16.readFileSync(file, "utf8"));
+    } catch {
+    }
+  }
+  fs16.writeFileSync(file, JSON.stringify({ ...existing, ...config }, null, 2) + "\n");
+}
+
+// src/commands/login.ts
+import os3 from "node:os";
+import process10 from "node:process";
 import { Command as Command3 } from "commander";
-import * as p5 from "@clack/prompts";
-import { detect as detect3, resolveCommand as resolveCommand3 } from "package-manager-detector";
+import * as p7 from "@clack/prompts";
+import makeFetchCookie from "fetch-cookie";
+var login = new Command3("login").description("login to velastack.dev").configureHelp(helpConfig).action(
+  () => runCommand(async () => {
+    await loginInteractively();
+    p7.log.success("Logged in to velastack.dev");
+  }, "Failed to login.")
+);
+async function loginInteractively() {
+  const { email: email3, password: password11 } = await p7.group(
+    {
+      email: () => p7.text({ message: "Email" }),
+      password: () => p7.password({ message: "Password" })
+    },
+    {
+      onCancel: () => {
+        p7.cancel("Operation cancelled.");
+        process10.exit(0);
+      }
+    }
+  );
+  const fetchCookie = makeFetchCookie(fetch);
+  const loginRes = await fetchCookie(`${API_URL}/login`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Origin: API_URL
+    },
+    body: new URLSearchParams({ type: "password", email: email3, password: password11 }).toString()
+  });
+  if (!loginRes.headers.get("Set-Cookie")) {
+    throw new Error(
+      "Run `vela signup` to create an account or reset at https://velastack.dev/reset"
+    );
+  }
+  const apiKey = await issueApiKey(fetchCookie);
+  writeConfig({ apiKey });
+  return apiKey;
+}
+async function issueApiKey(fetchCookie) {
+  const label4 = `CLI - ${os3.hostname()}`;
+  await fetchCookie(`${API_URL}/api-keys/new`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Origin: API_URL
+    },
+    body: new URLSearchParams({ label: label4 }).toString()
+  });
+  const cookie = await fetchCookie.cookieJar.getCookieString(API_URL);
+  const apiKey = extractApiKey(cookie);
+  if (!apiKey) {
+    throw new Error("Failed to create API key. Try again or contact support.");
+  }
+  const [id] = apiKey.split(".");
+  const res = await fetchCookie(`${API_URL}/api/collections/api_keys/records`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  const data = await res.json();
+  for (const item of data.items) {
+    if (item.label === label4 && item.id !== id) {
+      await fetchCookie(`${API_URL}/api/collections/api_keys/records/${item.id}`, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+    }
+  }
+  return apiKey;
+}
+function extractApiKey(cookie) {
+  const flashCookie = cookie.split(";").find((c) => c.trim().startsWith("flash="));
+  if (!flashCookie) return null;
+  const decoded = decodeURIComponent(flashCookie.split("=")[1]);
+  return JSON.parse(decoded).apiKey;
+}
+
+// src/commands/create.ts
 function optionsSchema2(listing) {
   const names = listing.templates.map((template) => template.name);
-  let choices = `must be one of: ${templateChoicesMessage(listing.templates)}`;
+  let choices2 = `must be one of: ${templateChoicesMessage(listing.templates)}`;
   if (listing.registryError) {
-    choices += ` (could not reach the template registry: ${listing.registryError})`;
+    choices2 += ` (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)),
+    template: v4.optional(v4.picklist(names, choices2)),
     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")))
+    password: v4.optional(v4.pipe(v4.string(), v4.minLength(8, "must be at least 8 characters long"))),
+    link: v4.optional(
+      v4.pipe(
+        v4.string(),
+        v4.check(
+          (value) => value === "new" || value === "none" || PROJECT_ID_RE.test(value),
+          "must be `new`, `none` or a velastack.dev project id"
+        )
+      )
+    ),
+    team: v4.optional(v4.pipe(v4.string(), v4.trim(), v4.minLength(1, "must not be empty"))),
+    cms: v4.optional(
+      v4.pipe(v4.string(), v4.trim(), v4.regex(CMS_URL_RE, "must be an absolute CMS URL"))
+    )
   });
 }
-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) => {
+function checkFlagsForTemplate(template, options) {
+  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.`
+    );
+  }
+  if (options.cms !== void 0 && !template.cms) {
+    throw new Error(
+      `--cms doesn't apply to the ${template.name} template \u2014 it reads no copy from a CMS.`
+    );
+  }
+  if (options.team !== void 0 && options.link !== "new") {
+    throw new Error("--team only applies together with --link new.");
+  }
+}
+var create = new Command4("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").option(
+  "--link <new|none|project-id>",
+  "link to a velastack.dev project: create one, skip, or use an existing project id (default: create when logged in at a terminal)"
+).option("--team <id>", "velastack.dev team for `--link new` (default: your personal team)").option(
+  "--cms <url>",
+  "read from a CMS at this URL instead of the linked project's (CMS-ready templates only)"
+).addOption(installOption).configureHelp(helpConfig).action((projectPath, rawOpts) => {
   return runCommand(async () => {
     const listing = await listAllTemplates();
     const options = parseOptions(optionsSchema2(listing), rawOpts);
-    const { directory, packageManager: packageManager2, name, template } = await createProject(
+    const { directory, packageManager: packageManager2, name, template, link: link2 } = await createProject2(
       projectPath,
       options,
       listing
     );
-    const relative = path14.relative(process8.cwd(), directory);
+    const relative = path15.relative(process11.cwd(), directory);
     const pm = packageManager2 ?? (await detect3({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
     const nextSteps = [];
     if (relative !== "") {
@@ -1973,6 +2440,7 @@ var create = new Command3("create").description("scaffold a new velastack projec
       );
       nextSteps.push("Run `vela ui add <component>` to add UI components.");
     }
+    nextSteps.push(...linkNextSteps(link2));
     nextSteps.push("Stuck? Visit https://docs.velastack.dev");
     reportResult({
       summary: `Created ${name} at ${directory}.`,
@@ -1980,42 +2448,38 @@ var create = new Command3("create").description("scaffold a new velastack projec
     });
   }, "Failed to create project.");
 });
-async function createProject(cwdArg, options, listing) {
+async function createProject2(cwdArg, options, listing) {
   const onCancel2 = () => {
-    p5.cancel("Operation cancelled.");
-    process8.exit(0);
+    p8.cancel("Operation cancelled.");
+    process11.exit(0);
   };
   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.`
-    );
-  }
+  checkFlagsForTemplate(template, options);
   let directory;
   if (cwdArg) {
-    directory = path14.resolve(cwdArg);
+    directory = path15.resolve(cwdArg);
   } else {
-    const answer = await p5.text({
+    const answer = await p8.text({
       message: "Where would you like your project to be created?",
       placeholder: "  (hit Enter to use current directory)",
       defaultValue: "./"
     });
-    if (p5.isCancel(answer)) onCancel2();
-    directory = path14.resolve(answer);
+    if (p8.isCancel(answer)) onCancel2();
+    directory = path15.resolve(answer);
   }
-  if (fs16.existsSync(directory) && fs16.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
-    const force = await p5.confirm({
+  if (fs17.existsSync(directory) && fs17.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
+    const force = await p8.confirm({
       message: "Directory not empty. Continue?",
       initialValue: false
     });
-    if (p5.isCancel(force) || !force) onCancel2();
+    if (p8.isCancel(force) || !force) onCancel2();
   }
-  const dirName = path14.basename(directory);
-  const { name } = await p5.group(
+  const dirName = path15.basename(directory);
+  const { name } = await p8.group(
     {
       name: () => {
         if (options.name) return Promise.resolve(options.name);
-        return p5.text({
+        return p8.text({
           message: "App name (used for emails, etc)",
           initialValue: dirName || "SvelteKit",
           validate: (value) => value?.trim() ? void 0 : "App name is required"
@@ -2025,19 +2489,28 @@ async function createProject(cwdArg, options, listing) {
     { onCancel: onCancel2 }
   );
   const credentials = template.backend ? await promptCredentials(options, onCancel2) : void 0;
+  const link2 = await linkOnCreate(name, template, options, onCancel2);
   const projectPath = directory;
-  if (template.source === "remote") p5.log.step(`Downloading template ${template.name}...`);
+  if (template.source === "remote") p8.log.step(`Downloading template ${template.name}...`);
   const resolved = await resolveTemplate(template);
   try {
     copyTemplate(resolved, projectPath);
-    applyTemplateFiles(projectPath, { appName: name, cliVersion: package_default.version });
+    applyTemplateFiles(projectPath, {
+      appName: name,
+      cliVersion: package_default.version,
+      cmsEndpoint: link2.cmsEndpoint
+    });
   } finally {
     resolved.cleanup();
   }
-  if (!fs16.existsSync(path14.join(projectPath, "package.json"))) {
+  if (!fs17.existsSync(path15.join(projectPath, "package.json"))) {
     throw new Error(`Template ${template.name} is missing package.template.json`);
   }
-  p5.log.success("Project created");
+  if (link2.linked) {
+    const { projectId, teamId, projectName } = link2.linked;
+    writeProjectConfig(projectPath, { projectId, teamId, projectName });
+  }
+  p8.log.success("Project created");
   let packageManager2;
   if (options.install !== false) {
     const pm = typeof options.install === "string" ? options.install : await packageManagerPrompt(projectPath);
@@ -2050,7 +2523,7 @@ async function createProject(cwdArg, options, listing) {
   }
   if (credentials) {
     const { email: email3, password: password11 } = credentials;
-    p5.log.step("Initializing PocketBase...");
+    p8.log.step("Initializing PocketBase...");
     await createSuperuser(projectPath, email3, password11);
     await withPocketbase(
       projectPath,
@@ -2069,16 +2542,99 @@ async function createProject(cwdArg, options, listing) {
       },
       ["PocketBase superuser credentials \u2014 used by `vela` commands"]
     );
-    p5.log.success("PocketBase initialized");
+    p8.log.success("PocketBase initialized");
   }
-  return { directory: projectPath, packageManager: packageManager2, name, template };
+  return { directory: projectPath, packageManager: packageManager2, name, template, link: link2 };
+}
+async function linkOnCreate(name, template, options, onCancel2) {
+  const templateCms = template.cms === true;
+  const interactive = isInteractive();
+  const loggedIn = readApiKey() !== null;
+  const outcome = {
+    cmsEndpoint: options.cms ? normalizeCmsUrl(options.cms) : "",
+    cmsSource: options.cms ? "flag" : "none",
+    templateCms,
+    loggedIn,
+    interactive
+  };
+  let decision = decideLink({
+    link: options.link,
+    needsCms: templateCms && !options.cms,
+    loggedIn,
+    interactive
+  });
+  if (decision.kind === "prompt-cms") {
+    const choice = await promptCms(onCancel2);
+    if (choice.kind === "url") {
+      outcome.cmsEndpoint = choice.url;
+      outcome.cmsSource = "prompt";
+      decision = { kind: "none" };
+    } else {
+      decision = { kind: choice.kind === "login" ? "login-then-create" : "none" };
+    }
+  }
+  if (decision.kind === "error") throw new Error(decision.message);
+  let apiKey;
+  if (decision.kind === "login-then-create") {
+    apiKey = await loginInteractively();
+    outcome.loggedIn = true;
+    decision = { kind: "create" };
+  }
+  let linked;
+  if (decision.kind === "create") {
+    p8.log.step(
+      options.link === "new" ? "Linking to a new velastack.dev project..." : "Linking to a new velastack.dev project (pass `--link none` to skip)..."
+    );
+    linked = await linkNewProject(apiKey ?? requireApiKey(), {
+      name,
+      template: template.name,
+      teamId: options.team,
+      interactive
+    });
+  } else if (decision.kind === "existing") {
+    p8.log.step("Linking to velastack.dev...");
+    linked = await linkExistingProject(requireApiKey(), decision.projectId);
+  } else if (decision.kind === "none" && decision.warn) {
+    p8.log.warn(decision.warn);
+  }
+  if (linked) {
+    outcome.linked = linked;
+    p8.log.success(`Linked to ${linked.projectName} (${linked.dashboardUrl})`);
+    if (templateCms && !outcome.cmsEndpoint) {
+      outcome.cmsEndpoint = cmsEndpointFor(linked.projectId);
+      outcome.cmsSource = "linked";
+      p8.log.success(`CMS: ${outcome.cmsEndpoint}`);
+    }
+  }
+  return outcome;
+}
+async function promptCms(onCancel2) {
+  p8.note(`This template reads its copy from a hosted CMS.
+${FREE_CMS_HINT}.`, "CMS");
+  const choice = await p8.select({
+    message: "Where should the site read its content from?",
+    options: [
+      { value: "login", label: "Log in to velastack.dev and create one", hint: "free" },
+      { value: "url", label: "Use an existing CMS URL" },
+      { value: "skip", label: "Skip for now", hint: "the site shows its fallback copy" }
+    ]
+  });
+  if (p8.isCancel(choice)) onCancel2();
+  if (choice !== "url") return { kind: choice };
+  const url = await p8.text({
+    message: "CMS URL",
+    placeholder: "https://velastack.dev/v1/projects/<project>/cms",
+    validate: (value) => CMS_URL_RE.test(value?.trim() ?? "") ? void 0 : "Enter an absolute http(s) URL"
+  });
+  if (p8.isCancel(url)) onCancel2();
+  return { kind: "url", url: normalizeCmsUrl(url) };
 }
 function promptCredentials(options, onCancel2) {
-  return p5.group(
+  return p8.group(
     {
       email: () => {
         if (options.email) return Promise.resolve(options.email);
-        return p5.text({
+        return p8.text({
           message: "Enter an email for the admin user",
           initialValue: "admin@example.com",
           validate: (value) => !value ? "Email is required" : !value.includes("@") ? "Invalid email" : void 0
@@ -2086,7 +2642,7 @@ function promptCredentials(options, onCancel2) {
       },
       password: () => {
         if (options.password) return Promise.resolve(options.password);
-        return p5.password({
+        return p8.password({
           message: "Enter a password for the admin user (at least 8 characters)",
           validate: (value) => !value ? "Password is required" : value.length < 8 ? "Password must be at least 8 characters long" : void 0
         });
@@ -2097,27 +2653,28 @@ function promptCredentials(options, onCancel2) {
 }
 
 // src/commands/generate.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/commands/generate/form.ts
-import { Command as Command4 } from "commander";
-import * as p11 from "@clack/prompts";
+import { Command as Command5 } from "commander";
+import * as p14 from "@clack/prompts";
 
 // src/lib/pattern-runner.ts
-import path15 from "node:path";
-import * as p6 from "@clack/prompts";
-import { bySlug } from "@velastack/patterns";
+import path16 from "node:path";
+import * as p9 from "@clack/prompts";
+import { bySlug as bySlug2 } from "@velastack/patterns";
 function toRelative(root, filePath) {
-  return path15.isAbsolute(filePath) ? path15.relative(root, filePath) : filePath;
+  return path16.isAbsolute(filePath) ? path16.relative(root, filePath) : filePath;
 }
 var isSuccess = (f) => (f.status ?? "success") === "success";
 async function runPattern(slug2, argv, input, report4) {
-  const pattern = bySlug[slug2];
+  const pattern = bySlug2[slug2];
   if (!pattern) {
     throw new Error(`Unknown pattern: ${slug2}`);
   }
+  checkProviderInput(pattern, argv, input);
   const { workspaceRootDir, features } = await getWorkspace();
-  const log45 = p6.taskLog({ title: report4.task.title });
+  const log45 = p9.taskLog({ title: report4.task.title });
   let result;
   try {
     result = await pattern.generate({
@@ -2156,7 +2713,7 @@ async function runPattern(slug2, argv, input, report4) {
   const deleted = result.deletes.filter(isSuccess);
   const totalChanges = created.length + modified.length + deleted.length + result.components.length + result.packages.length + result.collections.length;
   if (totalChanges === 0 && failures.length === 0) {
-    p6.log.info(`${pattern.title ?? slug2} produced no changes.`);
+    p9.log.info(`${pattern.title ?? slug2} produced no changes.`);
     return;
   }
   reportResult({
@@ -2177,45 +2734,9 @@ async function runPattern(slug2, argv, input, report4) {
 // src/lib/ai-flow.ts
 import fs18 from "node:fs";
 import path17 from "node:path";
-import * as p10 from "@clack/prompts";
+import * as p13 from "@clack/prompts";
 import pc4 from "picocolors";
 
-// src/lib/project-config.ts
-import fs17 from "node:fs";
-import path16 from "node:path";
-function projectConfigPath(workspaceRootDir) {
-  return path16.join(workspaceRootDir, ".vela", "project.json");
-}
-function readProjectConfig(workspaceRootDir) {
-  const file = projectConfigPath(workspaceRootDir);
-  if (!fs17.existsSync(file)) return null;
-  try {
-    const parsed = JSON.parse(fs17.readFileSync(file, "utf8"));
-    if (typeof parsed.projectId !== "string" || typeof parsed.teamId !== "string" || typeof parsed.projectName !== "string") {
-      return null;
-    }
-    return {
-      projectId: parsed.projectId,
-      teamId: parsed.teamId,
-      projectName: parsed.projectName
-    };
-  } catch {
-    return null;
-  }
-}
-function writeProjectConfig(workspaceRootDir, config) {
-  const file = projectConfigPath(workspaceRootDir);
-  fs17.mkdirSync(path16.dirname(file), { recursive: true });
-  let existing = {};
-  if (fs17.existsSync(file)) {
-    try {
-      existing = JSON.parse(fs17.readFileSync(file, "utf8"));
-    } catch {
-    }
-  }
-  fs17.writeFileSync(file, JSON.stringify({ ...existing, ...config }, null, 2) + "\n");
-}
-
 // src/lib/ai-client.ts
 async function aiPost(workspaceRootDir, endpoint, body) {
   const apiKey = requireApiKey();
@@ -2250,14 +2771,14 @@ var aiSchema = (workspaceRootDir, body) => aiPost(workspaceRootDir, "schema", bo
 var aiForm = (workspaceRootDir, body) => aiPost(workspaceRootDir, "form", body);
 
 // src/lib/ai-loop.ts
-import * as p7 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 async function aiLoop(opts) {
   let prompt = opts.initialPrompt;
   let history = [];
   let attempt = 0;
   while (true) {
     attempt++;
-    const spinner7 = p7.spinner();
+    const spinner7 = p10.spinner();
     spinner7.start(`${opts.stageLabel} (${attempt > 1 ? "iteration " + attempt : "first pass"})\u2026`);
     let result;
     let turn;
@@ -2271,12 +2792,12 @@ async function aiLoop(opts) {
       throw e;
     }
     opts.renderPreview(result);
-    const next = await p7.text({
+    const next = await p10.text({
       message: "Refine the result, or press Enter to apply.",
       placeholder: opts.refinePlaceholder,
       defaultValue: ""
     });
-    if (p7.isCancel(next)) return null;
+    if (p10.isCancel(next)) return null;
     const trimmed = (typeof next === "string" ? next : "").trim();
     if (trimmed === "") return result;
     history = turn;
@@ -2285,7 +2806,7 @@ async function aiLoop(opts) {
 }
 
 // src/lib/ai-existing-models.ts
-import * as p8 from "@clack/prompts";
+import * as p11 from "@clack/prompts";
 async function loadExistingModels(workspaceRootDir) {
   let result = [];
   try {
@@ -2310,7 +2831,7 @@ async function loadExistingModels(workspaceRootDir) {
     });
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    p8.log.warn(
+    p11.log.warn(
       `Could not load existing schema from PocketBase (${msg}). The AI agent will design without that context.`
     );
     return [];
@@ -2319,7 +2840,7 @@ async function loadExistingModels(workspaceRootDir) {
 }
 
 // src/lib/ai-to-argv.ts
-import * as p9 from "@clack/prompts";
+import * as p12 from "@clack/prompts";
 var PRIMITIVE_TYPES = /* @__PURE__ */ new Set(["text", "number", "bool", "email", "date", "url", "file"]);
 function singularize(name) {
   if (name.endsWith("ies") && name.length > 3) return `${name.slice(0, -3)}y`;
@@ -2342,7 +2863,7 @@ function collectionSpecToArgv(spec) {
   for (const field of spec.fields) {
     const type = typeArg(field);
     if (type === null) {
-      p9.log.warn(
+      p12.log.warn(
         `Skipping field "${field.name}" (type "${field.type}" cannot be represented as a pattern argument)`
       );
       continue;
@@ -2445,10 +2966,10 @@ function renderModel(spec) {
     const tail = extra.length > 0 ? "  " + pc4.dim(extra.join(" ")) : "";
     lines.push(`  ${f.name.padEnd(nameWidth)}  ${f.type.padEnd(typeWidth)} ${required}${tail}`);
   }
-  p10.log.message(lines.join("\n"));
+  p13.log.message(lines.join("\n"));
 }
 function renderLayout(layout) {
-  p10.log.message(renderGrid(layout));
+  p13.log.message(renderGrid(layout));
 }
 async function runSchemaStage(opts) {
   const { workspaceRootDir } = await getWorkspace();
@@ -2495,7 +3016,7 @@ function writeLayoutSidecar(workspaceRootDir, modelName, layout) {
 }
 
 // src/commands/generate/form.ts
-var form = new Command4("form").description("generate a form from a model").argument("[model]", 'model name (e.g. "contact")').argument("[fields...]", 'field definitions (e.g. "name:text", "email:email")').option("--remote", "generate a form backed by a remote PocketBase collection").option(
+var form = new Command5("form").description("generate a form from a model").argument("[model]", 'model name (e.g. "contact")').argument("[fields...]", 'field definitions (e.g. "name:text", "email:email")').option("--remote", "generate a form backed by a remote PocketBase collection").option(
   "--route <route>",
   'place the form at a custom route (e.g. "(app)/[team_id]/projects/new"). Defaults to the model name under (app)/(public).'
 ).option(
@@ -2512,12 +3033,12 @@ var form = new Command4("form").description("generate a form from a model").argu
       }
       const stage2 = await runSchemaStage({ prompt: options.ai, useCase: "form" });
       if (!stage2) {
-        p11.cancel("Aborted before any files were written.");
+        p14.cancel("Aborted before any files were written.");
         return;
       }
       const layout = await runLayoutStage(stage2.workspaceRootDir, stage2.model);
       if (!layout) {
-        p11.cancel("Aborted before any files were written.");
+        p14.cancel("Aborted before any files were written.");
         return;
       }
       argv = specToArgv(stage2.model);
@@ -2558,9 +3079,9 @@ var form = new Command4("form").description("generate a form from a model").argu
 );
 
 // src/commands/generate/schema.ts
-import { Command as Command5 } from "commander";
-import * as p12 from "@clack/prompts";
-var schema = new Command5("schema").description("generate a schema from a model").argument("[model]", "model name").argument("[fields...]", "field definitions").option("--ai <description>", "design the schema with AI from a natural-language description").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command6 } from "commander";
+import * as p15 from "@clack/prompts";
+var schema = new Command6("schema").description("generate a schema from a model").argument("[model]", "model name").argument("[fields...]", "field definitions").option("--ai <description>", "design the schema with AI from a natural-language description").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (model, fields, options) => runCommand(async () => {
     let argv;
     let modelName;
@@ -2570,7 +3091,7 @@ var schema = new Command5("schema").description("generate a schema from a model"
       }
       const stage2 = await runSchemaStage({ prompt: options.ai, useCase: "schema" });
       if (!stage2) {
-        p12.cancel("Aborted before any files were written.");
+        p15.cancel("Aborted before any files were written.");
         return;
       }
       argv = specToArgv(stage2.model);
@@ -2603,8 +3124,8 @@ var schema = new Command5("schema").description("generate a schema from a model"
 );
 
 // src/commands/generate/resource.ts
-import { Command as Command6 } from "commander";
-var resource = new Command6("resource").description("generate a resource (model + CRUD pages)").argument("<model>", "model name").argument("[fields...]", "field definitions").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command7 } from "commander";
+var resource = new Command7("resource").description("generate a resource (model + CRUD pages)").argument("<model>", "model name").argument("[fields...]", "field definitions").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (model, fields) => runCommand(
     () => runPattern(
       "generate-resource",
@@ -2629,9 +3150,9 @@ var resource = new Command6("resource").description("generate a resource (model
 );
 
 // src/commands/generate/scaffold.ts
-import { Command as Command7 } from "commander";
-import * as p13 from "@clack/prompts";
-var scaffold = new Command7("scaffold").description("generate a full CRUD scaffold (model, forms, list, detail)").argument("[model]", "model name").argument("[fields...]", "field definitions").option("--remote", "generate a scaffold backed by a remote PocketBase collection").option(
+import { Command as Command8 } from "commander";
+import * as p16 from "@clack/prompts";
+var scaffold = new Command8("scaffold").description("generate a full CRUD scaffold (model, forms, list, detail)").argument("[model]", "model name").argument("[fields...]", "field definitions").option("--remote", "generate a scaffold backed by a remote PocketBase collection").option(
   "--route <route>",
   'place the scaffold at a custom route (e.g. "(app)/[team_id]/projects"). Defaults to the pluralized model name under (app)/(public).'
 ).option(
@@ -2648,12 +3169,12 @@ var scaffold = new Command7("scaffold").description("generate a full CRUD scaffo
       }
       const stage2 = await runSchemaStage({ prompt: options.ai, useCase: "scaffold" });
       if (!stage2) {
-        p13.cancel("Aborted before any files were written.");
+        p16.cancel("Aborted before any files were written.");
         return;
       }
       const layout = await runLayoutStage(stage2.workspaceRootDir, stage2.model);
       if (!layout) {
-        p13.cancel("Aborted before any files were written.");
+        p16.cancel("Aborted before any files were written.");
         return;
       }
       argv = specToArgv(stage2.model);
@@ -2695,8 +3216,8 @@ var scaffold = new Command7("scaffold").description("generate a full CRUD scaffo
 );
 
 // src/commands/generate/migration.ts
-import { Command as Command8 } from "commander";
-var migration = new Command8("migration").description("generate a migration for an existing collection").argument("<collection>", "collection name").argument("<op>", "operation (add, remove, rename, references)").argument("[args...]", 'operation arguments (e.g. "birthday:date")').allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command9 } from "commander";
+var migration = new Command9("migration").description("generate a migration for an existing collection").argument("<collection>", "collection name").argument("<op>", "operation (add, remove, rename, references)").argument("[args...]", 'operation arguments (e.g. "birthday:date")').allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (collection, op, args) => runCommand(
     () => runPattern(
       "generate-migration",
@@ -2720,14 +3241,45 @@ var migration = new Command8("migration").description("generate a migration for
 );
 
 // src/commands/generate.ts
-var generate = new Command9("generate").description("generate scaffolding for database models and forms").configureHelp(helpConfig).addCommand(form).addCommand(schema).addCommand(resource).addCommand(scaffold).addCommand(migration);
+var generate = new Command10("generate").description("generate scaffolding for database models and forms").configureHelp(helpConfig).addCommand(form).addCommand(schema).addCommand(resource).addCommand(scaffold).addCommand(migration);
 
 // src/commands/enable.ts
-import { Command as Command24 } from "commander";
+import { Command as Command26 } from "commander";
+
+// src/commands/enable/analytics.ts
+import { Command as Command11 } from "commander";
+var analytics = new Command11("analytics").description("enable web analytics (Plausible, Google Analytics or PostHog)").option("--provider <provider>", "analytics provider: plausible, google or posthog").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+  (opts, cmd) => runCommand(async () => {
+    const provider = await resolveProvider("enable-analytics", opts.provider);
+    const providerEnv = await collectProviderEnv(provider);
+    const blank = missingEnvKeys(provider, providerEnv);
+    await runPattern(
+      "enable-analytics",
+      cmd.args,
+      { provider: provider.id, providerEnv },
+      {
+        summary: `Enabled analytics with ${provider.label}.`,
+        nextSteps: [
+          ...blank.map(
+            (key) => `Set ${key} in .env; the analytics component renders nothing until it is set.`
+          ),
+          `Run \`vela dev\` and look for a page view in ${provider.label}.`,
+          "Set the same PUBLIC_* variables on each deploy target with `vela env set`.",
+          "The component lives in src/lib/components/analytics/analytics.svelte; edit it freely."
+        ],
+        task: {
+          title: "Enabling analytics",
+          success: `Enabled analytics with ${provider.label}`,
+          error: "Failed to enable analytics"
+        }
+      }
+    );
+  }, "Failed to enable analytics.")
+);
 
 // src/commands/enable/auth.ts
-import { Command as Command10 } from "commander";
-var auth = new Command10("auth").description("enable authentication (email/password + OAuth scaffold)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command12 } from "commander";
+var auth = new Command12("auth").description("enable authentication (email/password + OAuth scaffold)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-auth",
@@ -2752,8 +3304,8 @@ var auth = new Command10("auth").description("enable authentication (email/passw
 );
 
 // src/commands/enable/api.ts
-import { Command as Command11 } from "commander";
-var api = new Command11("api").description("enable the PocketBase REST API").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command13 } from "commander";
+var api = new Command13("api").description("enable the PocketBase REST API").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-api",
@@ -2778,8 +3330,8 @@ var api = new Command11("api").description("enable the PocketBase REST API").all
 );
 
 // src/commands/enable/api-keys.ts
-import { Command as Command12 } from "commander";
-var apiKeys = new Command12("api-keys").description("enable API key management").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command14 } from "commander";
+var apiKeys = new Command14("api-keys").description("enable API key management").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-api-keys",
@@ -2804,8 +3356,8 @@ var apiKeys = new Command12("api-keys").description("enable API key management")
 );
 
 // src/commands/enable/backend.ts
-import { Command as Command13 } from "commander";
-var backend = new Command13("backend").description("enable the PocketBase backend").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command15 } from "commander";
+var backend = new Command15("backend").description("enable the PocketBase backend").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-backend",
@@ -2830,8 +3382,8 @@ var backend = new Command13("backend").description("enable the PocketBase backen
 );
 
 // src/commands/enable/i18n.ts
-import { Command as Command14 } from "commander";
-var i18n = new Command14("i18n").description("enable internationalization").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command16 } from "commander";
+var i18n = new Command16("i18n").description("enable internationalization").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-i18n",
@@ -2856,8 +3408,8 @@ var i18n = new Command14("i18n").description("enable internationalization").allo
 );
 
 // src/commands/enable/teams.ts
-import { Command as Command15 } from "commander";
-var teams = new Command15("teams").description("enable team / multi-tenant support").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command17 } from "commander";
+var teams = new Command17("teams").description("enable team / multi-tenant support").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-teams",
@@ -2882,13 +3434,13 @@ var teams = new Command15("teams").description("enable team / multi-tenant suppo
 );
 
 // src/commands/enable/payments.ts
-import process9 from "node:process";
-import { Command as Command16 } from "commander";
-import * as p14 from "@clack/prompts";
+import process12 from "node:process";
+import { Command as Command18 } from "commander";
+import * as p17 from "@clack/prompts";
 var PROVIDERS = [{ value: "stripe", label: "Stripe" }];
-var payments = new Command16("payments").description("enable payments").option("--provider <provider>", "payment provider", "stripe").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+var payments = new Command18("payments").description("enable payments").option("--provider <provider>", "payment provider", "stripe").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(async () => {
-    const provider = await resolveProvider(opts.provider, cmd.getOptionValueSource("provider"));
+    const provider = await resolveProvider2(opts.provider, cmd.getOptionValueSource("provider"));
     const input = {
       provider,
       stripeSecretKey: await ensureKey("STRIPE_SECRET_KEY", "Stripe secret key (sk_...)"),
@@ -2914,28 +3466,28 @@ var payments = new Command16("payments").description("enable payments").option("
     });
   }, "Failed to enable payments.")
 );
-async function resolveProvider(value, source) {
+async function resolveProvider2(value, source) {
   if (source && source !== "default") {
     if (!PROVIDERS.some((o) => o.value === value)) {
       throw new Error(`Unknown payment provider: ${value}`);
     }
     return value;
   }
-  const selected = await p14.select({
+  const selected = await p17.select({
     message: "Which payment provider?",
     options: PROVIDERS,
     initialValue: "stripe"
   });
-  if (p14.isCancel(selected)) {
-    p14.cancel("Operation cancelled.");
-    process9.exit(0);
+  if (p17.isCancel(selected)) {
+    p17.cancel("Operation cancelled.");
+    process12.exit(0);
   }
   return selected;
 }
 async function ensureWebhookSecret() {
-  const existing = process9.env.STRIPE_WEBHOOK_SECRET;
+  const existing = process12.env.STRIPE_WEBHOOK_SECRET;
   if (existing) return existing;
-  p14.note(
+  p17.note(
     [
       "Download the Stripe CLI (https://stripe.com/docs/stripe-cli), then run:",
       "  stripe listen --forward-to localhost:5173/webhooks/stripe",
@@ -2947,7 +3499,7 @@ async function ensureWebhookSecret() {
   return promptPassword("Stripe webhook signing secret (whsec_...)");
 }
 async function ensurePriceId() {
-  p14.note(
+  p17.note(
     [
       "Stripe checkout requires a product and price_id.",
       "If you have a demo product price_id, enter it below, or leave blank to create a demo one for you."
@@ -2955,36 +3507,36 @@ async function ensurePriceId() {
     "Stripe demo product",
     { format: (line) => line }
   );
-  const value = await p14.text({
+  const value = await p17.text({
     message: "Stripe price_id (price_...)",
     placeholder: "leave blank to create a demo product"
   });
-  if (p14.isCancel(value)) {
-    p14.cancel("Operation cancelled.");
-    process9.exit(0);
+  if (p17.isCancel(value)) {
+    p17.cancel("Operation cancelled.");
+    process12.exit(0);
   }
   return (value ?? "").trim();
 }
 async function ensureKey(envVar, message) {
-  const existing = process9.env[envVar];
+  const existing = process12.env[envVar];
   if (existing) return existing;
   return promptPassword(message);
 }
 async function promptPassword(message) {
-  const value = await p14.password({
+  const value = await p17.password({
     message,
     validate: (v10) => v10 && v10.length ? void 0 : "Required"
   });
-  if (p14.isCancel(value)) {
-    p14.cancel("Operation cancelled.");
-    process9.exit(0);
+  if (p17.isCancel(value)) {
+    p17.cancel("Operation cancelled.");
+    process12.exit(0);
   }
   return value;
 }
 
 // src/commands/enable/subscriptions.ts
-import { Command as Command17 } from "commander";
-var subscriptions = new Command17("subscriptions").description("enable Stripe subscriptions (requires auth and payments)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command19 } from "commander";
+var subscriptions = new Command19("subscriptions").description("enable Stripe subscriptions (requires auth and payments)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-subscriptions",
@@ -3009,8 +3561,8 @@ var subscriptions = new Command17("subscriptions").description("enable Stripe su
 );
 
 // src/commands/enable/notifications.ts
-import { Command as Command18 } from "commander";
-var notifications = new Command18("notifications").description("enable in-app notifications with a bell dropdown (requires auth)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command20 } from "commander";
+var notifications = new Command20("notifications").description("enable in-app notifications with a bell dropdown (requires auth)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-notifications",
@@ -3035,15 +3587,15 @@ var notifications = new Command18("notifications").description("enable in-app no
 );
 
 // src/commands/enable/s3.ts
-import process13 from "node:process";
-import { Command as Command19 } from "commander";
-import * as p17 from "@clack/prompts";
+import process16 from "node:process";
+import { Command as Command21 } from "commander";
+import * as p20 from "@clack/prompts";
 import pc8 from "picocolors";
 
 // src/lib/server-command.ts
-import process12 from "node:process";
+import process15 from "node:process";
 import * as v6 from "valibot";
-import * as p15 from "@clack/prompts";
+import * as p18 from "@clack/prompts";
 import pc5 from "picocolors";
 
 // src/lib/deploy-config.ts
@@ -3217,10 +3769,10 @@ import { resolveCommand as resolveCommand4 } from "package-manager-detector/comm
 
 // src/lib/ssh.ts
 import fs20 from "node:fs";
-import os3 from "node:os";
+import os4 from "node:os";
 import path19 from "node:path";
 import crypto3 from "node:crypto";
-import process10 from "node:process";
+import process13 from "node:process";
 import { spawn as spawn2 } from "node:child_process";
 var RemoteCommandError = class extends Error {
   exitCode;
@@ -3261,7 +3813,7 @@ var SshSession = class {
   }
   async open() {
     if (this.controlPath) return;
-    const dir = path19.join(os3.tmpdir(), "vela-ssh");
+    const dir = path19.join(os4.tmpdir(), "vela-ssh");
     fs20.mkdirSync(dir, { recursive: true, mode: 448 });
     const socket = path19.join(dir, `${crypto3.randomBytes(6).toString("hex")}.sock`);
     this.controlPath = socket;
@@ -3498,17 +4050,17 @@ function spawnCapture(command, args, opts = {}) {
     const child = spawn2(command, args, {
       stdio,
       cwd: opts.cwd,
-      env: opts.env ? { ...process10.env, ...opts.env } : void 0
+      env: opts.env ? { ...process13.env, ...opts.env } : void 0
     });
     let stdout = "";
     let stderr = "";
     child.stdout?.on("data", (chunk) => {
       stdout += chunk;
-      if (opts.streamStdout) process10.stdout.write(chunk);
+      if (opts.streamStdout) process13.stdout.write(chunk);
     });
     child.stderr?.on("data", (chunk) => {
       stderr += chunk;
-      if (opts.stream) process10.stderr.write(chunk);
+      if (opts.stream) process13.stderr.write(chunk);
     });
     child.on("error", reject);
     child.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? 1 }));
@@ -3615,7 +4167,7 @@ function sshOptionsFrom(options) {
 import crypto4 from "node:crypto";
 import fs22 from "node:fs";
 import path21 from "node:path";
-import process11 from "node:process";
+import process14 from "node:process";
 var VELA_ROOT = "/var/lib/vela";
 var VELA_ETC = "/etc/vela";
 var VELA_USER = "vela";
@@ -3652,7 +4204,7 @@ async function syncServerScripts(session) {
   const dir = `${SCRIPT_VERSIONS_DIR}/${digest}`;
   const present = await session.script(`[ -d "$1" ] && echo yes || echo no`, { args: [dir] });
   if (present.stdout.trim() !== "yes") {
-    const incoming = `${SCRIPT_VERSIONS_DIR}/.incoming.${digest}.${process11.pid}.${Date.now()}`;
+    const incoming = `${SCRIPT_VERSIONS_DIR}/.incoming.${digest}.${process14.pid}.${Date.now()}`;
     await session.script(`mkdir -p "$1" && chmod 0755 "$(dirname "$1")" "$1"`, {
       args: [incoming]
     });
@@ -3911,8 +4463,8 @@ function describeTarget(target) {
       return target.name;
   }
 }
-function bold(text18) {
-  return `\`${text18}\``;
+function bold(text19) {
+  return `\`${text19}\``;
 }
 
 // src/lib/server-command.ts
@@ -4016,7 +4568,7 @@ async function ensureBinding(workspaceRootDir, target, request = {}) {
     writeBinding(workspaceRootDir, key, binding);
   }
   if (moving) {
-    p15.log.warn(
+    p18.log.warn(
       `${pc5.cyan(bindingName(target))} now points at ${pc5.cyan(server)}.
 
 Whatever is running on ${existing.server} is left there, and this project can no
@@ -4027,7 +4579,7 @@ longer reach it. Remove it there first if that was not intended.`
 }
 async function confirmMove(target, from, to) {
   const name = bindingName(target);
-  if (!process12.stdout.isTTY || process12.env.CI) {
+  if (!process15.stdout.isTTY || process15.env.CI) {
     throw new Error(
       `${pc5.cyan(`--server ${to}`)} does not match the server recorded for ${pc5.cyan(name)}, ${pc5.cyan(from)}.
 
@@ -4035,13 +4587,13 @@ Drop ${pc5.cyan("--server")} to use the recorded one, or move the binding on pur
 this command once from a terminal (or editing .vela/project.json).`
     );
   }
-  const ok = await p15.confirm({
+  const ok = await p18.confirm({
     message: `${name} ${target.kind === "preview" ? "run" : "runs"} on ${from}. Point ${name} at ${to} instead?`,
     initialValue: false
   });
-  if (p15.isCancel(ok) || !ok) {
-    p15.cancel("Operation cancelled.");
-    process12.exit(0);
+  if (p18.isCancel(ok) || !ok) {
+    p18.cancel("Operation cancelled.");
+    process15.exit(0);
   }
 }
 function bindingName(target) {
@@ -4049,7 +4601,7 @@ function bindingName(target) {
 }
 async function promptServer(target) {
   const name = bindingName(target);
-  if (!process12.stdout.isTTY || process12.env.CI) {
+  if (!process15.stdout.isTTY || process15.env.CI) {
     throw new Error(
       `${name} ${target.kind === "preview" ? "are" : "is"} not bound to a server yet, and there is no terminal to ask on.
 
@@ -4057,29 +4609,29 @@ Pass ${pc5.cyan("--server user@host")}, or run the command once from your own ma
 and commit ${pc5.cyan(".vela/project.json")}.`
     );
   }
-  p15.log.info(
+  p18.log.info(
     `${pc5.cyan(name)} ${target.kind === "preview" ? "are" : "is"} not bound to a server yet.`
   );
-  const value = await p15.text({
+  const value = await p18.text({
     message: `Which server should ${name} run on?`,
     placeholder: "root@203.0.113.10",
     validate: (input) => input?.trim() ? void 0 : "An ssh_config alias, or user@host"
   });
-  if (p15.isCancel(value)) {
-    p15.cancel("Operation cancelled.");
-    process12.exit(0);
+  if (p18.isCancel(value)) {
+    p18.cancel("Operation cancelled.");
+    process15.exit(0);
   }
   return value.trim();
 }
 async function promptDomain(target) {
-  if (!process12.stdout.isTTY || process12.env.CI) return void 0;
-  const value = await p15.text({
+  if (!process15.stdout.isTTY || process15.env.CI) return void 0;
+  const value = await p18.text({
     message: `Which hostname should ${target.name} be served on?`,
     placeholder: "example.com \u2014 leave blank to decide later"
   });
-  if (p15.isCancel(value)) {
-    p15.cancel("Operation cancelled.");
-    process12.exit(0);
+  if (p18.isCancel(value)) {
+    p18.cancel("Operation cancelled.");
+    process15.exit(0);
   }
   return value.trim() || void 0;
 }
@@ -4087,10 +4639,10 @@ async function applyRestart(ctx) {
   const outcome = await restartInstance(ctx.session, ctx.instance);
   if (!outcome.deployed) return;
   if (outcome.restarted) {
-    p15.log.success("App restarted");
+    p18.log.success("App restarted");
     return;
   }
-  p15.log.error(
+  p18.log.error(
     `App restart failed.
 
 The new value is stored and will be used the next time the app starts.
@@ -4099,7 +4651,7 @@ ${pc5.dim(outcome.error ?? "")}`
 }
 async function applyEnvRestart(ctx, changed) {
   if (touchesSuperuser(changed)) {
-    p15.log.warn(
+    p18.log.warn(
       `PocketBase superuser credentials changed.
 
 The database still holds the old ones, so the app has not been restarted.
@@ -4136,7 +4688,7 @@ import pc7 from "picocolors";
 
 // src/lib/local-env.ts
 import fs24 from "node:fs";
-import * as p16 from "@clack/prompts";
+import * as p19 from "@clack/prompts";
 import pc6 from "picocolors";
 function readLocalEnv(envFile) {
   if (!fs24.existsSync(envFile)) return {};
@@ -4162,16 +4714,16 @@ async function applyLocalEnvChange(ctx, changed) {
       process.env.POCKETBASE_SUPERUSER_EMAIL = email3;
       process.env.POCKETBASE_SUPERUSER_PASSWORD = password11;
       await ensureSuperuser(ctx.workspaceRootDir);
-      p16.log.success("Local superuser updated to match");
+      p19.log.success("Local superuser updated to match");
     } else {
-      p16.log.warn(
+      p19.log.warn(
         `The local database still has the old superuser.
 Set both ${pc6.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc6.cyan("POCKETBASE_SUPERUSER_PASSWORD")} to reconcile it.`
       );
     }
   }
   if (getPocketbaseMetadata(ctx.workspaceRootDir)) {
-    p16.log.info(`Restart ${pc6.cyan("vela dev")} to pick this up.`);
+    p19.log.info(`Restart ${pc6.cyan("vela dev")} to pick this up.`);
   }
 }
 
@@ -4335,7 +4887,7 @@ function hasFile(dir) {
 
 // src/commands/enable/s3.ts
 var s3 = addTargetOptions(
-  new Command19("s3").description("enable S3 file storage").option("--backups", "configure where backups are kept, not where uploads go").option("--endpoint <url>", "S3 endpoint URL").option("--bucket <name>", "S3 bucket name").option("--region <region>", "S3 region").option("--access-key <key>", "S3 access key").option("--secret <secret>", "S3 secret key \u2014 prefer VELA_S3_SECRET").option("--force-path-style", "address the bucket in the path (MinIO, Ceph)").option("--no-force-path-style", "address the bucket as a subdomain (AWS, R2)").option("--force", "enable it even though uploads already exist on disk").configureHelp(helpConfig),
+  new Command21("s3").description("enable S3 file storage").option("--backups", "configure where backups are kept, not where uploads go").option("--endpoint <url>", "S3 endpoint URL").option("--bucket <name>", "S3 bucket name").option("--region <region>", "S3 region").option("--access-key <key>", "S3 access key").option("--secret <secret>", "S3 secret key \u2014 prefer VELA_S3_SECRET").option("--force-path-style", "address the bucket in the path (MinIO, Ceph)").option("--no-force-path-style", "address the bucket as a subdomain (AWS, R2)").option("--force", "enable it even though uploads already exist on disk").configureHelp(helpConfig),
   "local"
 ).action(
   (raw) => runCommand(() => {
@@ -4353,7 +4905,7 @@ var s3 = addTargetOptions(
         failure = error instanceof Error ? error.message : String(error);
       }
       if (failure) {
-        p17.log.warn(
+        p20.log.warn(
           `The connection test failed \u2014 the settings are saved but may be wrong.
 
 ${pc8.dim(failure)}
@@ -4397,64 +4949,64 @@ Do that first, then re-run with ${pc8.cyan("--force")}.`
   );
 }
 async function promptConfig(options, existing) {
-  const endpoint = options.endpoint ?? await text7("S3 endpoint URL", existing.endpoint || "https://s3.amazonaws.com");
-  const bucket = options.bucket ?? await text7("S3 bucket name", existing.bucket);
-  const region = options.region ?? await text7("S3 region", existing.region || "us-east-1");
-  const accessKey = options.accessKey ?? await text7("S3 access key", existing.accessKey);
-  const secret = options.secret ?? process13.env.VELA_S3_SECRET ?? await password5("S3 secret key");
+  const endpoint = options.endpoint ?? await text9("S3 endpoint URL", existing.endpoint || "https://s3.amazonaws.com");
+  const bucket = options.bucket ?? await text9("S3 bucket name", existing.bucket);
+  const region = options.region ?? await text9("S3 region", existing.region || "us-east-1");
+  const accessKey = options.accessKey ?? await text9("S3 access key", existing.accessKey);
+  const secret = options.secret ?? process16.env.VELA_S3_SECRET ?? await password6("S3 secret key");
   const forcePathStyle = options.forcePathStyle ?? await confirm4(
     "Address the bucket in the path? (MinIO, Ceph and most self-hosted gateways need this)",
     defaultForcePathStyle(endpoint)
   );
   return { endpoint, bucket, region, accessKey, secret, forcePathStyle };
 }
-async function text7(message, initialValue = "") {
-  const value = await p17.text({
+async function text9(message, initialValue = "") {
+  const value = await p20.text({
     message,
     initialValue,
     validate: (input) => input?.trim() ? void 0 : `${message} is required`
   });
-  if (p17.isCancel(value)) {
-    p17.cancel("Operation cancelled.");
-    process13.exit(0);
+  if (p20.isCancel(value)) {
+    p20.cancel("Operation cancelled.");
+    process16.exit(0);
   }
   return value.trim();
 }
-async function password5(message) {
-  const value = await p17.password({
+async function password6(message) {
+  const value = await p20.password({
     message,
     validate: (input) => input ? void 0 : `${message} is required`
   });
-  if (p17.isCancel(value)) {
-    p17.cancel("Operation cancelled.");
-    process13.exit(0);
+  if (p20.isCancel(value)) {
+    p20.cancel("Operation cancelled.");
+    process16.exit(0);
   }
   return value;
 }
 async function confirm4(message, initialValue) {
-  const value = await p17.confirm({ message, initialValue });
-  if (p17.isCancel(value)) {
-    p17.cancel("Operation cancelled.");
-    process13.exit(0);
+  const value = await p20.confirm({ message, initialValue });
+  if (p20.isCancel(value)) {
+    p20.cancel("Operation cancelled.");
+    process16.exit(0);
   }
   return value;
 }
 
 // src/commands/enable/smtp.ts
-import process14 from "node:process";
-import { Command as Command20 } from "commander";
-import * as p18 from "@clack/prompts";
-var smtp = new Command20("smtp").description("configure SMTP for transactional email").configureHelp(helpConfig).action(
+import process17 from "node:process";
+import { Command as Command22 } from "commander";
+import * as p21 from "@clack/prompts";
+var smtp = new Command22("smtp").description("configure SMTP for transactional email").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const config = await p18.group(
+    const config = await p21.group(
       {
-        host: () => p18.text({
+        host: () => p21.text({
           message: "SMTP host",
           placeholder: "smtp.example.com",
           validate: (v10) => v10 ? void 0 : "Host is required"
         }),
-        port: () => p18.text({
+        port: () => p21.text({
           message: "SMTP port",
           initialValue: "587",
           validate: (v10) => {
@@ -4464,13 +5016,13 @@ var smtp = new Command20("smtp").description("configure SMTP for transactional e
             return void 0;
           }
         }),
-        username: () => p18.text({ message: "SMTP username" }),
-        password: () => p18.password({ message: "SMTP password" })
+        username: () => p21.text({ message: "SMTP username" }),
+        password: () => p21.password({ message: "SMTP password" })
       },
       {
         onCancel: () => {
-          p18.cancel("Operation cancelled.");
-          process14.exit(0);
+          p21.cancel("Operation cancelled.");
+          process17.exit(0);
         }
       }
     );
@@ -4497,24 +5049,24 @@ var smtp = new Command20("smtp").description("configure SMTP for transactional e
 );
 
 // src/commands/enable/cms.ts
-import process15 from "node:process";
-import { Command as Command21 } from "commander";
-import * as p19 from "@clack/prompts";
+import process18 from "node:process";
+import { Command as Command23 } from "commander";
+import * as p22 from "@clack/prompts";
 import pc9 from "picocolors";
-var cms = new Command21("cms").description("enable an inline-editing CMS with an admin bar").option(
+var cms = new Command23("cms").description("enable an inline-editing CMS with an admin bar").option(
   "--endpoint <url>",
   "read from a hosted CMS at this URL instead of installing the backend in this app"
 ).allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(async () => {
     if (!opts.endpoint && !hasBackend()) {
-      p19.log.error(
+      p22.log.error(
         `${pc9.cyan("vela enable cms")} needs a server to host the CMS backend, and this project is static.
 
 Run ${pc9.cyan("vela bless")} to add a backend, or point at a hosted CMS with ${pc9.cyan("vela enable cms --endpoint <url>")}.`
       );
-      p19.log.message();
-      p19.cancel("Operation failed.");
-      process15.exitCode = 1;
+      p22.log.message();
+      p22.cancel("Operation failed.");
+      process18.exitCode = 1;
       return;
     }
     await runPattern("enable-cms", cmd.args, opts.endpoint ? { endpoint: opts.endpoint } : {}, {
@@ -4534,8 +5086,8 @@ Run ${pc9.cyan("vela bless")} to add a backend, or point at a hosted CMS with ${
 );
 
 // src/commands/enable/blog.ts
-import { Command as Command22 } from "commander";
-var blog = new Command22("blog").description("enable an mdsvex blog with posts, tags, and RSS").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command24 } from "commander";
+var blog = new Command24("blog").description("enable an mdsvex blog with posts, tags, and RSS").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-blog",
@@ -4560,8 +5112,8 @@ var blog = new Command22("blog").description("enable an mdsvex blog with posts,
 );
 
 // src/commands/enable/content-negotiation.ts
-import { Command as Command23 } from "commander";
-var contentNegotiation = new Command23("content-negotiation").description("enable content negotiation (sveltekit-negotiate)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command25 } from "commander";
+var contentNegotiation = new Command25("content-negotiation").description("enable content negotiation (sveltekit-negotiate)").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (_opts, cmd) => runCommand(
     () => runPattern(
       "enable-content-negotiation",
@@ -4585,33 +5137,33 @@ var contentNegotiation = new Command23("content-negotiation").description("enabl
 );
 
 // src/commands/enable.ts
-var enable = new Command24("enable").description("enable features").configureHelp(helpConfig).addCommand(auth).addCommand(api).addCommand(apiKeys).addCommand(backend).addCommand(contentNegotiation).addCommand(i18n).addCommand(teams).addCommand(payments).addCommand(subscriptions).addCommand(notifications).addCommand(s3).addCommand(smtp).addCommand(cms).addCommand(blog);
+var enable = new Command26("enable").description("enable features").configureHelp(helpConfig).addCommand(analytics).addCommand(auth).addCommand(api).addCommand(apiKeys).addCommand(backend).addCommand(contentNegotiation).addCommand(i18n).addCommand(teams).addCommand(payments).addCommand(subscriptions).addCommand(notifications).addCommand(s3).addCommand(smtp).addCommand(cms).addCommand(blog);
 
 // src/commands/disable.ts
-import { Command as Command35 } from "commander";
+import { Command as Command37 } from "commander";
 
 // src/commands/disable/auth.ts
-import { Command as Command25 } from "commander";
+import { Command as Command27 } from "commander";
 
 // src/commands/disable/_shared.ts
-import process16 from "node:process";
-import * as p20 from "@clack/prompts";
+import process19 from "node:process";
+import * as p23 from "@clack/prompts";
 async function runDisable(opts, flags, cmdArgs) {
   if (!flags.yes) {
-    const ok = await p20.confirm({
+    const ok = await p23.confirm({
       message: opts.confirmMessage,
       initialValue: false
     });
-    if (p20.isCancel(ok) || !ok) {
-      p20.cancel("Operation cancelled.");
-      process16.exit(0);
+    if (p23.isCancel(ok) || !ok) {
+      p23.cancel("Operation cancelled.");
+      process19.exit(0);
     }
   }
   await runPattern(opts.slug, cmdArgs, { destructive: true }, opts.report);
 }
 
 // src/commands/disable/auth.ts
-var auth2 = new Command25("auth").description("disable authentication").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+var auth2 = new Command27("auth").description("disable authentication").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4637,8 +5189,8 @@ var auth2 = new Command25("auth").description("disable authentication").option("
 );
 
 // src/commands/disable/api.ts
-import { Command as Command26 } from "commander";
-var api2 = new Command26("api").description("disable the REST API").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command28 } from "commander";
+var api2 = new Command28("api").description("disable the REST API").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4661,8 +5213,8 @@ var api2 = new Command26("api").description("disable the REST API").option("-y,
 );
 
 // src/commands/disable/api-keys.ts
-import { Command as Command27 } from "commander";
-var apiKeys2 = new Command27("api-keys").description("disable API key management").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command29 } from "commander";
+var apiKeys2 = new Command29("api-keys").description("disable API key management").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4685,8 +5237,8 @@ var apiKeys2 = new Command27("api-keys").description("disable API key management
 );
 
 // src/commands/disable/backend.ts
-import { Command as Command28 } from "commander";
-var backend2 = new Command28("backend").description("disable the PocketBase backend").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command30 } from "commander";
+var backend2 = new Command30("backend").description("disable the PocketBase backend").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4709,8 +5261,8 @@ var backend2 = new Command28("backend").description("disable the PocketBase back
 );
 
 // src/commands/disable/content-negotiation.ts
-import { Command as Command29 } from "commander";
-var contentNegotiation2 = new Command29("content-negotiation").description("disable content negotiation").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command31 } from "commander";
+var contentNegotiation2 = new Command31("content-negotiation").description("disable content negotiation").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4733,8 +5285,8 @@ var contentNegotiation2 = new Command29("content-negotiation").description("disa
 );
 
 // src/commands/disable/i18n.ts
-import { Command as Command30 } from "commander";
-var i18n2 = new Command30("i18n").description("disable internationalization").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command32 } from "commander";
+var i18n2 = new Command32("i18n").description("disable internationalization").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4760,8 +5312,8 @@ var i18n2 = new Command30("i18n").description("disable internationalization").op
 );
 
 // src/commands/disable/teams.ts
-import { Command as Command31 } from "commander";
-var teams2 = new Command31("teams").description("disable teams").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command33 } from "commander";
+var teams2 = new Command33("teams").description("disable teams").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4787,8 +5339,8 @@ var teams2 = new Command31("teams").description("disable teams").option("-y, --y
 );
 
 // src/commands/disable/payments.ts
-import { Command as Command32 } from "commander";
-var payments2 = new Command32("payments").description("disable payments").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command34 } from "commander";
+var payments2 = new Command34("payments").description("disable payments").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (opts, cmd) => runCommand(
     () => runDisable(
       {
@@ -4815,11 +5367,11 @@ var payments2 = new Command32("payments").description("disable payments").option
 );
 
 // src/commands/disable/s3.ts
-import { Command as Command33 } from "commander";
-import * as p21 from "@clack/prompts";
+import { Command as Command35 } from "commander";
+import * as p24 from "@clack/prompts";
 import pc10 from "picocolors";
 var s32 = addTargetOptions(
-  new Command33("s3").description("disable S3 file storage").option("--backups", "keep backups on the server again, rather than uploads").configureHelp(helpConfig),
+  new Command35("s3").description("disable S3 file storage").option("--backups", "keep backups on the server again, rather than uploads").configureHelp(helpConfig),
   "local"
 ).action(
   (raw) => runCommand(() => {
@@ -4828,7 +5380,7 @@ var s32 = addTargetOptions(
     return withBackupTarget(raw, "disable s3", async (ctx) => {
       const existing = await readS3(ctx.pb, filesystem);
       if (!existing.enabled) {
-        p21.log.info(`S3 ${label2(filesystem)} is already off for ${ctx.targetName}.`);
+        p24.log.info(`S3 ${label2(filesystem)} is already off for ${ctx.targetName}.`);
         return;
       }
       await disableS3(ctx.pb, filesystem);
@@ -4848,8 +5400,8 @@ function label2(filesystem) {
 }
 
 // src/commands/disable/smtp.ts
-import { Command as Command34 } from "commander";
-var smtp2 = new Command34("smtp").description("disable SMTP configuration").configureHelp(helpConfig).action(
+import { Command as Command36 } from "commander";
+var smtp2 = new Command36("smtp").description("disable SMTP configuration").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     await withPocketbase(workspaceRootDir, async (pb) => {
@@ -4866,30 +5418,30 @@ var smtp2 = new Command34("smtp").description("disable SMTP configuration").conf
 );
 
 // src/commands/disable.ts
-var disable = new Command35("disable").description("disable features").configureHelp(helpConfig).addCommand(auth2).addCommand(api2).addCommand(apiKeys2).addCommand(backend2).addCommand(contentNegotiation2).addCommand(i18n2).addCommand(teams2).addCommand(payments2).addCommand(s32).addCommand(smtp2);
+var disable = new Command37("disable").description("disable features").configureHelp(helpConfig).addCommand(auth2).addCommand(api2).addCommand(apiKeys2).addCommand(backend2).addCommand(contentNegotiation2).addCommand(i18n2).addCommand(teams2).addCommand(payments2).addCommand(s32).addCommand(smtp2);
 
 // src/commands/destroy.ts
-import { Command as Command41 } from "commander";
+import { Command as Command43 } from "commander";
 
 // src/commands/destroy/form.ts
-import { Command as Command36 } from "commander";
+import { Command as Command38 } from "commander";
 
 // src/commands/destroy/_shared.ts
-import process17 from "node:process";
-import * as p22 from "@clack/prompts";
+import process20 from "node:process";
+import * as p25 from "@clack/prompts";
 async function runDestroy(slug2, model, confirmMessage, report4, flags) {
   if (!flags.yes) {
-    const ok = await p22.confirm({ message: confirmMessage, initialValue: false });
-    if (p22.isCancel(ok) || !ok) {
-      p22.cancel("Operation cancelled.");
-      process17.exit(0);
+    const ok = await p25.confirm({ message: confirmMessage, initialValue: false });
+    if (p25.isCancel(ok) || !ok) {
+      p25.cancel("Operation cancelled.");
+      process20.exit(0);
     }
   }
   await runPattern(slug2, [model], { destructive: true, route: flags.route }, report4);
 }
 
 // src/commands/destroy/form.ts
-var form2 = new Command36("form").description("destroy a form generated by `vela generate form`").argument("<model>", "model name used when the form was generated (e.g., contact, login)").option("-y, --yes", "skip confirmation prompt").option(
+var form2 = new Command38("form").description("destroy a form generated by `vela generate form`").argument("<model>", "model name used when the form was generated (e.g., contact, login)").option("-y, --yes", "skip confirmation prompt").option(
   "--route <route>",
   "custom route the form was generated at (must match the --route used at generation)"
 ).allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
@@ -4913,8 +5465,8 @@ var form2 = new Command36("form").description("destroy a form generated by `vela
 );
 
 // src/commands/destroy/schema.ts
-import { Command as Command37 } from "commander";
-var schema2 = new Command37("schema").description("destroy a zod schema generated by `vela generate schema`").argument("<model>", "schema model name (e.g., contact, login)").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command39 } from "commander";
+var schema2 = new Command39("schema").description("destroy a zod schema generated by `vela generate schema`").argument("<model>", "schema model name (e.g., contact, login)").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (model, opts) => runCommand(
     () => runDestroy(
       "destroy-schema",
@@ -4935,8 +5487,8 @@ var schema2 = new Command37("schema").description("destroy a zod schema generate
 );
 
 // src/commands/destroy/resource.ts
-import { Command as Command38 } from "commander";
-var resource2 = new Command38("resource").description("destroy a resource generated by `vela generate resource`").argument("<model>", "model path used when the resource was generated (e.g., contacts, articles)").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
+import { Command as Command40 } from "commander";
+var resource2 = new Command40("resource").description("destroy a resource generated by `vela generate resource`").argument("<model>", "model path used when the resource was generated (e.g., contacts, articles)").option("-y, --yes", "skip confirmation prompt").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
   (model, opts) => runCommand(
     () => runDestroy(
       "destroy-resource",
@@ -4957,8 +5509,8 @@ var resource2 = new Command38("resource").description("destroy a resource genera
 );
 
 // src/commands/destroy/scaffold.ts
-import { Command as Command39 } from "commander";
-var scaffold2 = new Command39("scaffold").description("destroy a scaffold generated by `vela generate scaffold`").argument("<model>", "model name used when the scaffold was generated (e.g., contact, todo)").option("-y, --yes", "skip confirmation prompt").option(
+import { Command as Command41 } from "commander";
+var scaffold2 = new Command41("scaffold").description("destroy a scaffold generated by `vela generate scaffold`").argument("<model>", "model name used when the scaffold was generated (e.g., contact, todo)").option("-y, --yes", "skip confirmation prompt").option(
   "--route <route>",
   "custom route the scaffold was generated at (must match the --route used at generation)"
 ).allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(
@@ -4985,9 +5537,9 @@ var scaffold2 = new Command39("scaffold").description("destroy a scaffold genera
 );
 
 // src/commands/destroy/deployment.ts
-import process18 from "node:process";
-import { Command as Command40 } from "commander";
-import * as p25 from "@clack/prompts";
+import process21 from "node:process";
+import { Command as Command42 } from "commander";
+import * as p28 from "@clack/prompts";
 import pc13 from "picocolors";
 
 // src/lib/destroy-guard.ts
@@ -5035,88 +5587,12 @@ function describe({ appName, envTag, purge }) {
 }
 
 // src/lib/deploy-report.ts
-import * as p24 from "@clack/prompts";
+import * as p27 from "@clack/prompts";
 import pc12 from "picocolors";
 
 // src/lib/server-identity.ts
-import * as p23 from "@clack/prompts";
+import * as p26 from "@clack/prompts";
 import pc11 from "picocolors";
-
-// src/lib/velastack-api.ts
-async function apiFetch(apiKey, pathAndQuery, init) {
-  const headers = new Headers(init?.headers);
-  headers.set("Authorization", `Bearer ${apiKey}`);
-  if (init?.body && !headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json");
-  }
-  const res = await fetch(`${API_URL}${pathAndQuery}`, { ...init, headers });
-  if (res.status === 401) {
-    throw new Error("API key invalid \u2014 run `vela login`");
-  }
-  if (res.status === 403) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`velastack.dev refused this key (${body || "forbidden"}) \u2014 run \`vela login\``);
-  }
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`Velastack API error (${res.status}): ${body || res.statusText}`);
-  }
-  return await res.json();
-}
-async function getCurrentUser(apiKey) {
-  const data = await apiFetch(
-    apiKey,
-    "/api/collections/users/records?perPage=1"
-  );
-  const user = data.items[0];
-  if (!user) throw new Error("No user found. Run `vela login` to login.");
-  return user;
-}
-async function listTeams(apiKey) {
-  const data = await apiFetch(
-    apiKey,
-    "/api/collections/teams/records?perPage=200"
-  );
-  return data.items;
-}
-async function listProjects(apiKey) {
-  const data = await apiFetch(
-    apiKey,
-    "/api/collections/projects/records?perPage=200&expand=team"
-  );
-  return data.items;
-}
-async function createProject2(apiKey, args) {
-  return apiFetch(apiKey, "/api/collections/projects/records", {
-    method: "POST",
-    body: JSON.stringify({ name: args.name, team: args.teamId, user: args.userId })
-  });
-}
-async function registerServer(apiKey, input) {
-  return apiFetch(apiKey, "/v1/servers", {
-    method: "POST",
-    body: JSON.stringify(input)
-  });
-}
-async function startDeployment(apiKey, projectId, input) {
-  return apiFetch(apiKey, `/v1/projects/${projectId}/deployments`, {
-    method: "POST",
-    body: JSON.stringify(input)
-  });
-}
-async function finishDeployment(apiKey, projectId, deploymentId, input) {
-  return apiFetch(apiKey, `/v1/projects/${projectId}/deployments/${deploymentId}`, {
-    method: "PATCH",
-    body: JSON.stringify(input)
-  });
-}
-async function destroyEnvironment(apiKey, projectId, envTag) {
-  return apiFetch(apiKey, `/v1/projects/${projectId}/environments/${encodeURIComponent(envTag)}`, {
-    method: "DELETE"
-  });
-}
-
-// src/lib/server-identity.ts
 var IPV4 = /^\d{1,3}(?:\.\d{1,3}){3}$/;
 async function ensureServerIdentity(session, apiKey) {
   const existing = await readServerIdentity(session);
@@ -5129,7 +5605,7 @@ async function ensureServerIdentity(session, apiKey) {
   if (!existing || existing.serverId !== registered.serverId || existing.originHost !== registered.originHost || existing.token !== registered.token) {
     await writeServerIdentity(session, registered);
     if (existing) {
-      p23.log.info(`${pc11.cyan(session.target)} was re-registered with velastack.dev.`);
+      p26.log.info(`${pc11.cyan(session.target)} was re-registered with velastack.dev.`);
     }
   }
   await runServerScript(session, "origin.sh");
@@ -5169,7 +5645,7 @@ function createDeployReporter(workspaceRootDir) {
   const link2 = readProjectConfig(workspaceRootDir);
   const apiKey = link2 ? readApiKey() : null;
   if (link2 && !apiKey) {
-    p24.log.warn(
+    p27.log.warn(
       `This project is linked to ${pc12.cyan(link2.projectName)} on velastack.dev, but there is no
 API key here, so this deploy will not be recorded. Run ${pc12.cyan("vela login")}, or set
 ${pc12.cyan("VELA_API_KEY")}.`
@@ -5219,7 +5695,7 @@ async function reportEnvironmentDestroyed(workspaceRootDir, envTag) {
   }
 }
 function warn(what, err) {
-  p24.log.warn(
+  p27.log.warn(
     `velastack.dev could not ${what}.
 ${pc12.dim(err instanceof Error ? err.message : String(err))}`
   );
@@ -5228,7 +5704,7 @@ ${pc12.dim(err instanceof Error ? err.message : String(err))}`
 // src/commands/destroy/deployment.ts
 var deployment = addLockWaitOption(
   addTargetOptions(
-    new Command40("deployment").description("remove a deployed environment from its server").configureHelp(helpConfig),
+    new Command42("deployment").description("remove a deployed environment from its server").configureHelp(helpConfig),
     "production"
   )
 ).option("--purge", "also delete the database and uploaded files").option("-y, --yes", "skip the confirmation prompt").option(
@@ -5247,7 +5723,7 @@ var deployment = addLockWaitOption(
             purge: options.purge === true,
             yes: options.yes === true,
             confirm: options.confirm,
-            interactive: Boolean(process18.stdin.isTTY && process18.stdout.isTTY)
+            interactive: Boolean(process21.stdin.isTTY && process21.stdout.isTTY)
           });
           if (decision.kind === "refuse") throw new Error(decision.message);
           if (decision.kind === "prompt") {
@@ -5262,13 +5738,13 @@ var deployment = addLockWaitOption(
             stream: true
           });
           if (result?.existed === false) {
-            p25.log.info(
+            p28.log.info(
               `Nothing named ${pc13.cyan(`${ctx.appName} (${ctx.targetName})`)} on ${ctx.server}; nothing to remove.`
             );
             return;
           }
           await reportEnvironmentDestroyed(ctx.workspaceRootDir, ctx.envTag);
-          p25.log.success(
+          p28.log.success(
             `Removed ${pc13.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${ctx.server}.` + (result?.purged ? result.trash ? `
 
 A snapshot of its data is at ${pc13.cyan(result.trash)} on the server for two weeks.` : "" : `
@@ -5286,35 +5762,35 @@ The database and uploads are still in the instance's shared directory. Pass ${pc
 );
 async function confirm8(appName, targetName, byName) {
   if (byName) {
-    const answer = await p25.text({
+    const answer = await p28.text({
       message: `This removes ${pc13.cyan(`${appName} (${targetName})`)}. Type the app name to confirm`,
       validate: (value) => value === appName ? void 0 : `Type ${appName} to confirm`
     });
-    if (p25.isCancel(answer)) {
-      p25.cancel("Operation cancelled.");
-      process18.exit(0);
+    if (p28.isCancel(answer)) {
+      p28.cancel("Operation cancelled.");
+      process21.exit(0);
     }
     return;
   }
-  const ok = await p25.confirm({
+  const ok = await p28.confirm({
     message: `Remove ${appName} (${targetName})?`,
     initialValue: false
   });
-  if (p25.isCancel(ok) || !ok) {
-    p25.cancel("Operation cancelled.");
-    process18.exit(0);
+  if (p28.isCancel(ok) || !ok) {
+    p28.cancel("Operation cancelled.");
+    process21.exit(0);
   }
 }
 
 // src/commands/destroy.ts
-var destroy = new Command41("destroy").description("destroy scaffolding, or a deployment").configureHelp(helpConfig).addCommand(form2).addCommand(schema2).addCommand(resource2).addCommand(scaffold2).addCommand(deployment);
+var destroy = new Command43("destroy").description("destroy scaffolding, or a deployment").configureHelp(helpConfig).addCommand(form2).addCommand(schema2).addCommand(resource2).addCommand(scaffold2).addCommand(deployment);
 
 // src/commands/ui.ts
-import { Command as Command47 } from "commander";
+import { Command as Command49 } from "commander";
 
 // src/commands/ui/add.ts
-import { Command as Command42 } from "commander";
-import * as p26 from "@clack/prompts";
+import { Command as Command44 } from "commander";
+import * as p29 from "@clack/prompts";
 import { installComponents } from "@velastack/patterns";
 
 // src/lib/ui-add.ts
@@ -5363,10 +5839,10 @@ function uiAddReport(requested, outcome) {
 }
 
 // src/commands/ui/add.ts
-var add = new Command42("add").description("add ui components (shadcn-svelte items and vela components such as data-table)").argument("<components...>", "the components to add").option("--overwrite", "replace components that already exist", false).configureHelp(helpConfig).action(
+var add = new Command44("add").description("add ui components (shadcn-svelte items and vela components such as data-table)").argument("<components...>", "the components to add").option("--overwrite", "replace components that already exist", false).configureHelp(helpConfig).action(
   (components, options) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log45 = p26.taskLog({ title: "Adding UI components..." });
+    const log45 = p29.taskLog({ title: "Adding UI components..." });
     let outcome;
     try {
       outcome = await installComponents({
@@ -5385,13 +5861,13 @@ var add = new Command42("add").description("add ui components (shadcn-svelte ite
 );
 
 // src/commands/ui/base.ts
-import { Command as Command43 } from "commander";
-import * as p27 from "@clack/prompts";
+import { Command as Command45 } from "commander";
+import * as p30 from "@clack/prompts";
 import { applyBaseColor } from "@velastack/patterns";
-var base = new Command43("base").description("change the base (gray) palette").argument("<color>", `base color to use (${BASE_COLORS.join(", ")})`).configureHelp(helpConfig).action(
+var base = new Command45("base").description("change the base (gray) palette").argument("<color>", `base color to use (${BASE_COLORS.join(", ")})`).configureHelp(helpConfig).action(
   (color) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log45 = p27.taskLog({ title: `Applying the ${color} palette...` });
+    const log45 = p30.taskLog({ title: `Applying the ${color} palette...` });
     let outcome;
     try {
       outcome = await applyBaseColor({ root: workspaceRootDir, color });
@@ -5413,8 +5889,8 @@ var base = new Command43("base").description("change the base (gray) palette").a
 );
 
 // src/commands/ui/list.ts
-import { Command as Command44 } from "commander";
-import * as p28 from "@clack/prompts";
+import { Command as Command46 } from "commander";
+import * as p31 from "@clack/prompts";
 import { listComponents } from "@velastack/patterns";
 
 // src/lib/ui-list.ts
@@ -5445,7 +5921,7 @@ function uiListReport(result) {
 }
 
 // src/commands/ui/list.ts
-var list = new Command44("list").description("list installed ui components, vela components and the style registry").option("--json", "print the result as JSON", false).configureHelp(helpConfig).action(
+var list = new Command46("list").description("list installed ui components, vela components and the style registry").option("--json", "print the result as JSON", false).configureHelp(helpConfig).action(
   (options) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     if (options.json) {
@@ -5453,7 +5929,7 @@ var list = new Command44("list").description("list installed ui components, vela
       console.log(JSON.stringify(result2, null, 2));
       return;
     }
-    const spinner7 = p28.spinner();
+    const spinner7 = p31.spinner();
     spinner7.start("Reading the registry...");
     let result;
     try {
@@ -5465,15 +5941,15 @@ var list = new Command44("list").description("list installed ui components, vela
     spinner7.stop(`Read the ${result.style} registry`);
     reportResult(uiListReport(result));
     if (result.registryUnavailable) {
-      p28.log.warn(`${result.registryUnavailable}
+      p31.log.warn(`${result.registryUnavailable}
 Registry components are not listed.`);
     }
   }, "Failed to list UI components.")
 );
 
 // src/commands/ui/style.ts
-import { Command as Command45 } from "commander";
-import * as p29 from "@clack/prompts";
+import { Command as Command47 } from "commander";
+import * as p32 from "@clack/prompts";
 import { switchStyle } from "@velastack/patterns";
 
 // src/lib/ui-style.ts
@@ -5499,10 +5975,10 @@ function uiStyleReport(result) {
 }
 
 // src/commands/ui/style.ts
-var style = new Command45("style").description("switch the shadcn-svelte style, re-adding its components").argument("<style>", `style to switch to (${STYLES.join(", ")})`).option("-y, --yes", "skip the confirmation prompt").option("--no-font", "keep the current font instead of applying the style's").configureHelp(helpConfig).action(
+var style = new Command47("style").description("switch the shadcn-svelte style, re-adding its components").argument("<style>", `style to switch to (${STYLES.join(", ")})`).option("-y, --yes", "skip the confirmation prompt").option("--no-font", "keep the current font instead of applying the style's").configureHelp(helpConfig).action(
   (name, options) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const spinner7 = p29.spinner();
+    const spinner7 = p32.spinner();
     spinner7.start(`Reading the ${name} registry...`);
     let log45;
     let outcome;
@@ -5515,20 +5991,20 @@ var style = new Command45("style").description("switch the shadcn-svelte style,
         confirm: async (components) => {
           spinner7.stop(`Read the ${name} registry`);
           if (components.length > 0) {
-            p29.log.info(
+            p32.log.info(
               `Re-adds ${components.length} component(s) from the ${name} registry; local edits to their files are lost:
 ${components.map((c) => `- ${c}`).join("\n")}`
             );
           } else {
-            p29.log.info(
+            p32.log.info(
               `No installed component comes from the registry; only the config changes.`
             );
           }
           if (!options.yes) {
-            const ok = await p29.confirm({ message: `Switch to ${name}?`, initialValue: false });
-            if (p29.isCancel(ok) || !ok) return false;
+            const ok = await p32.confirm({ message: `Switch to ${name}?`, initialValue: false });
+            if (p32.isCancel(ok) || !ok) return false;
           }
-          log45 = p29.taskLog({ title: `Switching to the ${name} style...` });
+          log45 = p32.taskLog({ title: `Switching to the ${name} style...` });
           return true;
         }
       });
@@ -5539,11 +6015,11 @@ ${components.map((c) => `- ${c}`).join("\n")}`
     }
     spinner7.stop(`Read the ${name} registry`);
     if (outcome.status === "unchanged") {
-      p29.log.info(`Already using the ${name} style.`);
+      p32.log.info(`Already using the ${name} style.`);
       return;
     }
     if (outcome.status === "cancelled") {
-      p29.cancel("Operation cancelled.");
+      p32.cancel("Operation cancelled.");
       return;
     }
     log45?.success("Style switched");
@@ -5552,13 +6028,13 @@ ${components.map((c) => `- ${c}`).join("\n")}`
 );
 
 // src/commands/ui/theme.ts
-import { Command as Command46 } from "commander";
-import * as p30 from "@clack/prompts";
+import { Command as Command48 } from "commander";
+import * as p33 from "@clack/prompts";
 import { applyTheme } from "@velastack/patterns";
-var theme = new Command46("theme").description("change the accent color, keeping the base palette").argument("<accent>", `accent to use (${THEMES.join(", ")})`).configureHelp(helpConfig).action(
+var theme = new Command48("theme").description("change the accent color, keeping the base palette").argument("<accent>", `accent to use (${THEMES.join(", ")})`).configureHelp(helpConfig).action(
   (accent) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const log45 = p30.taskLog({ title: `Applying the ${accent} accent...` });
+    const log45 = p33.taskLog({ title: `Applying the ${accent} accent...` });
     let outcome;
     try {
       outcome = await applyTheme({ root: workspaceRootDir, theme: accent });
@@ -5580,22 +6056,22 @@ var theme = new Command46("theme").description("change the accent color, keeping
 );
 
 // src/commands/ui.ts
-var ui = new Command47("ui").description("generate ui components").configureHelp(helpConfig).addCommand(add).addCommand(list).addCommand(style).addCommand(base).addCommand(theme);
+var ui = new Command49("ui").description("generate ui components").configureHelp(helpConfig).addCommand(add).addCommand(list).addCommand(style).addCommand(base).addCommand(theme);
 
 // src/commands/legal.ts
-import { Command as Command50 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/commands/legal/terms.ts
 import fs26 from "node:fs";
 import path23 from "node:path";
-import { Command as Command48 } from "commander";
-import * as p32 from "@clack/prompts";
+import { Command as Command50 } from "commander";
+import * as p35 from "@clack/prompts";
 
 // src/commands/legal/shared.ts
-import process19 from "node:process";
-import * as p31 from "@clack/prompts";
+import process22 from "node:process";
+import * as p34 from "@clack/prompts";
 var sharedFields = {
-  websiteUrl: () => p31.text({
+  websiteUrl: () => p34.text({
     message: "What is your website URL?",
     placeholder: "http://www.mysite.com",
     validate: (value) => {
@@ -5604,7 +6080,7 @@ var sharedFields = {
       }
     }
   }),
-  websiteName: () => p31.text({
+  websiteName: () => p34.text({
     message: "What is your website name?",
     placeholder: "My Site",
     validate: (value) => {
@@ -5613,7 +6089,7 @@ var sharedFields = {
       }
     }
   }),
-  entityType: () => p31.select({
+  entityType: () => p34.select({
     message: "Entity type",
     options: [
       {
@@ -5624,7 +6100,7 @@ var sharedFields = {
       { value: "individual", label: "I'm an Individual" }
     ]
   }),
-  businessName: ({ results }) => results?.entityType === "business" ? p31.text({
+  businessName: ({ results }) => results?.entityType === "business" ? p34.text({
     message: "What is the name of the business?",
     placeholder: "My Company LLC",
     validate: (value) => {
@@ -5633,7 +6109,7 @@ var sharedFields = {
       }
     }
   }) : void 0,
-  businessAddress: ({ results }) => results?.entityType === "business" ? p31.text({
+  businessAddress: ({ results }) => results?.entityType === "business" ? p34.text({
     message: "What is the address of the business?",
     placeholder: "1 Cupertino, CA 95014",
     validate: (value) => {
@@ -5642,7 +6118,7 @@ var sharedFields = {
       }
     }
   }) : void 0,
-  country: () => p31.text({
+  country: () => p34.text({
     message: "Enter the country",
     validate: (value) => {
       if (!value) {
@@ -5650,7 +6126,7 @@ var sharedFields = {
       }
     }
   }),
-  state: () => p31.text({
+  state: () => p34.text({
     message: "Enter the state",
     validate: (value) => {
       if (!value) {
@@ -5660,11 +6136,11 @@ var sharedFields = {
   })
 };
 var onCancel = () => {
-  p31.cancel("Operation cancelled.");
-  process19.exit(0);
+  p34.cancel("Operation cancelled.");
+  process22.exit(0);
 };
 async function contactMethods(type) {
-  const selection = await p31.multiselect({
+  const selection = await p34.multiselect({
     message: `How can users contact you for any questions regarding your ${type === "privacy" ? "Privacy Policy" : "Terms & Conditions"}? Check all that apply`,
     options: [
       { value: "email", label: "By email" },
@@ -5673,11 +6149,11 @@ async function contactMethods(type) {
       { value: "mail", label: "By sending post mail" }
     ]
   });
-  if (p31.isCancel(selection)) onCancel();
+  if (p34.isCancel(selection)) onCancel();
   const contact = selection;
   const details = {};
   if (contact.includes("email")) {
-    const email3 = await p31.text({
+    const email3 = await p34.text({
       message: "What's the email?",
       placeholder: "office@mycompany.com",
       validate: (value) => {
@@ -5686,11 +6162,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p31.isCancel(email3)) onCancel();
+    if (p34.isCancel(email3)) onCancel();
     details.email = email3;
   }
   if (contact.includes("page")) {
-    const page = await p31.text({
+    const page = await p34.text({
       message: "What's the link?",
       placeholder: "http://www.mycompany.com/contact",
       validate: (value) => {
@@ -5699,11 +6175,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p31.isCancel(page)) onCancel();
+    if (p34.isCancel(page)) onCancel();
     details.page = page;
   }
   if (contact.includes("phone")) {
-    const phone = await p31.text({
+    const phone = await p34.text({
       message: "What's the phone number?",
       placeholder: "408.996.1010",
       validate: (value) => {
@@ -5712,11 +6188,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p31.isCancel(phone)) onCancel();
+    if (p34.isCancel(phone)) onCancel();
     details.phone = phone;
   }
   if (contact.includes("mail")) {
-    const address = await p31.text({
+    const address = await p34.text({
       message: "What's the address?",
       placeholder: "767 Fifth Avenue New York, NY 10153, United States",
       validate: (value) => {
@@ -5725,7 +6201,7 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p31.isCancel(address)) onCancel();
+    if (p34.isCancel(address)) onCancel();
     details.address = address;
   }
   return { methods: contact, details };
@@ -6121,7 +6597,7 @@ var generateTermsHtml = (answers) => {
 };
 async function termsAction() {
   const { workspaceRootDir, publicRoutesDir } = await getWorkspace();
-  const core = await p32.group(
+  const core = await p35.group(
     {
       websiteUrl: sharedFields.websiteUrl,
       websiteName: sharedFields.websiteName,
@@ -6133,25 +6609,25 @@ async function termsAction() {
     },
     { onCancel }
   );
-  const accounts = await p32.select({
+  const accounts = await p35.select({
     message: "Can users create accounts?",
     options: [
       { value: "yes", label: "Yes, users can create accounts" },
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(accounts)) onCancel();
-  const userContent = await p32.select({
+  if (p35.isCancel(accounts)) onCancel();
+  const userContent = await p35.select({
     message: "Can users create and/or upload content (ie. text, images)?",
     options: [
       { value: "yes", label: "Yes, users can create and/or upload content" },
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(userContent)) onCancel();
+  if (p35.isCancel(userContent)) onCancel();
   let infringementEmail;
   if (userContent === "yes") {
-    const email3 = await p32.text({
+    const email3 = await p35.text({
       message: "What's the email address where you will receive infringements notices?",
       placeholder: "dmca@website.com",
       validate: (value) => {
@@ -6160,10 +6636,10 @@ async function termsAction() {
         }
       }
     });
-    if (p32.isCancel(email3)) onCancel();
+    if (p35.isCancel(email3)) onCancel();
     infringementEmail = email3;
   }
-  const canBuyGoods = await p32.select({
+  const canBuyGoods = await p35.select({
     message: "Can users buy goods (products, items)?",
     options: [
       {
@@ -6173,28 +6649,28 @@ async function termsAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(canBuyGoods)) onCancel();
-  const subscriptions2 = await p32.select({
+  if (p35.isCancel(canBuyGoods)) onCancel();
+  const subscriptions2 = await p35.select({
     message: "Do you offer subscription plans?",
     options: [
       { value: "yes", label: "Yes, we offer subscription plans" },
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(subscriptions2)) onCancel();
+  if (p35.isCancel(subscriptions2)) onCancel();
   let freeTrial;
   if (subscriptions2 === "yes") {
-    const ft = await p32.select({
+    const ft = await p35.select({
       message: "Do you offer a free trial?",
       options: [
         { value: "yes", label: "Yes" },
         { value: "no", label: "No" }
       ]
     });
-    if (p32.isCancel(ft)) onCancel();
+    if (p35.isCancel(ft)) onCancel();
     freeTrial = ft;
   }
-  const exclusiveContent = await p32.select({
+  const exclusiveContent = await p35.select({
     message: "Do you want to make it clear that your own content & trademarks are your exclusive property?",
     options: [
       {
@@ -6204,24 +6680,24 @@ async function termsAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(exclusiveContent)) onCancel();
-  const feedbackReuse = await p32.select({
+  if (p35.isCancel(exclusiveContent)) onCancel();
+  const feedbackReuse = await p35.select({
     message: "If users provide you feedback & suggestions, do you want to use this feedback without compensation or credits given?",
     options: [
       { value: "yes", label: "Yes, we may implement any feedback or suggestions we receive" },
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(feedbackReuse)) onCancel();
-  const promotions = await p32.select({
+  if (p35.isCancel(feedbackReuse)) onCancel();
+  const promotions = await p35.select({
     message: "Do you plan to offer promotions, contests, sweepstakes?",
     options: [
       { value: "yes", label: "Yes, we may offer promotions, contests, sweepstakes" },
       { value: "no", label: "No" }
     ]
   });
-  if (p32.isCancel(promotions)) onCancel();
-  const mobileAppRaw = await p32.multiselect({
+  if (p35.isCancel(promotions)) onCancel();
+  const mobileAppRaw = await p35.multiselect({
     message: "Is the Service distributed through any mobile app stores? Check all that apply",
     options: [
       { value: "apple", label: "Apple App Store" },
@@ -6229,7 +6705,7 @@ async function termsAction() {
     ],
     required: false
   });
-  if (p32.isCancel(mobileAppRaw)) onCancel();
+  if (p35.isCancel(mobileAppRaw)) onCancel();
   const mobileApp = mobileAppRaw ?? [];
   const contact = await contactMethods("terms");
   const html = generateTermsHtml({
@@ -6272,13 +6748,13 @@ 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."));
+var terms = new Command50("terms").description("generate placeholder terms and conditions").configureHelp(helpConfig).action(() => runCommand(termsAction, "Failed to generate terms and conditions."));
 
 // src/commands/legal/privacy.ts
 import fs27 from "node:fs";
 import path24 from "node:path";
-import { Command as Command49 } from "commander";
-import * as p33 from "@clack/prompts";
+import { Command as Command51 } from "commander";
+import * as p36 from "@clack/prompts";
 var mapLabels = {
   personalInfo: {
     email: "Email address",
@@ -6696,12 +7172,12 @@ var generatePrivacyHtml = (answers) => {
   return `<section data-role="content">${sections.join("")}</section>`;
 };
 async function promptWithCustom(message, options, customMessage) {
-  const selection = await p33.multiselect({ message, options });
-  if (p33.isCancel(selection)) onCancel();
+  const selection = await p36.multiselect({ message, options });
+  if (p36.isCancel(selection)) onCancel();
   const values = selection;
   if (values.includes("custom")) {
-    const custom = await p33.text({ message: customMessage });
-    if (p33.isCancel(custom)) onCancel();
+    const custom = await p36.text({ message: customMessage });
+    if (p36.isCancel(custom)) onCancel();
     const idx = values.indexOf("custom");
     if (idx !== -1) values.splice(idx, 1);
     if (custom) values.push(String(custom));
@@ -6710,7 +7186,7 @@ async function promptWithCustom(message, options, customMessage) {
 }
 async function privacyAction() {
   const { workspaceRootDir, publicRoutesDir } = await getWorkspace();
-  const core = await p33.group(
+  const core = await p36.group(
     {
       websiteUrl: sharedFields.websiteUrl,
       websiteName: sharedFields.websiteName,
@@ -6722,7 +7198,7 @@ async function privacyAction() {
     },
     { onCancel }
   );
-  const personalInfo = await p33.multiselect({
+  const personalInfo = await p36.multiselect({
     message: "What kind of personal information do you collect from users? Check all that apply",
     options: [
       { value: "email", label: "Email address" },
@@ -6737,16 +7213,16 @@ async function privacyAction() {
     ],
     required: false
   });
-  if (p33.isCancel(personalInfo)) onCancel();
+  if (p36.isCancel(personalInfo)) onCancel();
   const contact = await contactMethods("privacy");
-  const tracking = await p33.select({
+  const tracking = await p36.select({
     message: "Do you use tracking and/or analytics tools, such as Google Analytics?",
     options: [
       { value: "yes", label: "Yes, we use Google Analytics or other related tools" },
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(tracking)) onCancel();
+  if (p36.isCancel(tracking)) onCancel();
   let trackingTools;
   if (tracking === "yes") {
     trackingTools = await promptWithCustom(
@@ -6765,7 +7241,7 @@ async function privacyAction() {
       "Enter your custom tracking/analytics tool name"
     );
   }
-  const sendEmails = await p33.select({
+  const sendEmails = await p36.select({
     message: "Do you send emails to users?",
     options: [
       {
@@ -6775,7 +7251,7 @@ async function privacyAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(sendEmails)) onCancel();
+  if (p36.isCancel(sendEmails)) onCancel();
   let emailPlatforms;
   if (sendEmails === "yes") {
     emailPlatforms = await promptWithCustom(
@@ -6790,14 +7266,14 @@ async function privacyAction() {
       "Enter your custom email platform"
     );
   }
-  const showAds = await p33.select({
+  const showAds = await p36.select({
     message: "Do you show ads?",
     options: [
       { value: "yes", label: "Yes, we show ads" },
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(showAds)) onCancel();
+  if (p36.isCancel(showAds)) onCancel();
   let adsPlatforms;
   if (showAds === "yes") {
     adsPlatforms = await promptWithCustom(
@@ -6820,7 +7296,7 @@ async function privacyAction() {
       "Enter your custom ads platform"
     );
   }
-  const canPay = await p33.select({
+  const canPay = await p36.select({
     message: "Can users pay for products or services?",
     options: [
       { value: "yes", label: "Yes, users can pay for our products/services" },
@@ -6830,7 +7306,7 @@ async function privacyAction() {
       }
     ]
   });
-  if (p33.isCancel(canPay)) onCancel();
+  if (p36.isCancel(canPay)) onCancel();
   let paymentProcessors;
   if (canPay === "yes") {
     paymentProcessors = await promptWithCustom(
@@ -6861,14 +7337,14 @@ async function privacyAction() {
       "Enter your custom payment processor/method"
     );
   }
-  const remarketing = await p33.select({
+  const remarketing = await p36.select({
     message: "Do you use remarketing services for marketing & advertising purposes?",
     options: [
       { value: "yes", label: "Yes, we use remarketing services to advertise our business" },
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(remarketing)) onCancel();
+  if (p36.isCancel(remarketing)) onCancel();
   let remarketingPlatforms;
   if (remarketing === "yes") {
     remarketingPlatforms = await promptWithCustom(
@@ -6887,7 +7363,7 @@ async function privacyAction() {
       "Enter your custom remarketing platform"
     );
   }
-  const providersRaw = await p33.multiselect({
+  const providersRaw = await p36.multiselect({
     message: "Select if you use any of the following providers",
     options: [
       { value: "recaptcha", label: "Invisible reCAPTCHA" },
@@ -6898,16 +7374,16 @@ async function privacyAction() {
     ],
     required: false
   });
-  if (p33.isCancel(providersRaw)) onCancel();
+  if (p36.isCancel(providersRaw)) onCancel();
   const providers = providersRaw;
   if (providers.includes("custom")) {
-    const custom = await p33.text({ message: "Enter your custom provider" });
-    if (p33.isCancel(custom)) onCancel();
+    const custom = await p36.text({ message: "Enter your custom provider" });
+    if (p36.isCancel(custom)) onCancel();
     const idx = providers.indexOf("custom");
     if (idx !== -1) providers.splice(idx, 1);
     if (custom) providers.push(String(custom));
   }
-  const usStates = await p33.select({
+  const usStates = await p36.select({
     message: "Include U.S. state privacy rights (CCPA/CPRA, VCDPA, CPA, CTDPA, UCPA, TX, OR, etc.)?",
     options: [
       {
@@ -6918,55 +7394,55 @@ async function privacyAction() {
     ],
     initialValue: "yes"
   });
-  if (p33.isCancel(usStates)) onCancel();
-  const gdpr = await p33.select({
+  if (p36.isCancel(usStates)) onCancel();
+  const gdpr = await p36.select({
     message: "Do you want your Privacy Policy to include GDPR / UK GDPR wording?",
     options: [
       { value: "yes", label: "Yes. Include GDPR rights for EEA, UK, and Swiss residents" },
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(gdpr)) onCancel();
+  if (p36.isCancel(gdpr)) onCancel();
   let facebookFanPage = "no";
   const facebookDetails = { name: "", url: "" };
   if (gdpr === "yes") {
-    const fan = await p33.select({
+    const fan = await p36.select({
       message: "Do you have a Facebook Fan Page?",
       options: [
         { value: "yes", label: "Yes, we have a Facebook Fan Page" },
         { value: "no", label: "No" }
       ]
     });
-    if (p33.isCancel(fan)) onCancel();
+    if (p36.isCancel(fan)) onCancel();
     facebookFanPage = fan;
     if (facebookFanPage === "yes") {
-      const name = await p33.text({
+      const name = await p36.text({
         message: "What is the name of the Facebook Fan Page?",
         placeholder: "My Facebook Page"
       });
-      if (p33.isCancel(name)) onCancel();
+      if (p36.isCancel(name)) onCancel();
       facebookDetails.name = name;
-      const url = await p33.text({
+      const url = await p36.text({
         message: "What is the URL of the Facebook Fan Page?",
         placeholder: "https://facebook.com/my-facebook-page"
       });
-      if (p33.isCancel(url)) onCancel();
+      if (p36.isCancel(url)) onCancel();
       facebookDetails.url = url;
     }
   }
-  const kids = await p33.select({
+  const kids = await p36.select({
     message: "Do you collect information from kids under the age of 13?",
     options: [
       { value: "yes", label: "Yes. We collect information from children under the age of 13" },
       { value: "no", label: "No" }
     ]
   });
-  if (p33.isCancel(kids)) onCancel();
-  const retention = await p33.text({
+  if (p36.isCancel(kids)) onCancel();
+  const retention = await p36.text({
     message: "How long do you retain personal information? (leave blank for default wording)",
     placeholder: "e.g. 12 months after account closure"
   });
-  if (p33.isCancel(retention)) onCancel();
+  if (p36.isCancel(retention)) onCancel();
   const html = generatePrivacyHtml({
     core,
     personalInfo: personalInfo ?? [],
@@ -7021,16 +7497,16 @@ async function privacyAction() {
     ]
   });
 }
-var privacy = new Command49("privacy").description("generate placeholder privacy policy").configureHelp(helpConfig).action(() => runCommand(privacyAction, "Failed to generate privacy policy."));
+var privacy = new Command51("privacy").description("generate placeholder privacy policy").configureHelp(helpConfig).action(() => runCommand(privacyAction, "Failed to generate privacy policy."));
 
 // src/commands/legal.ts
-var legal = new Command50("legal").description("generate placeholder legal documents").configureHelp(helpConfig).addCommand(terms).addCommand(privacy);
+var legal = new Command52("legal").description("generate placeholder legal documents").configureHelp(helpConfig).addCommand(terms).addCommand(privacy);
 
 // src/commands/fixtures.ts
-import { Command as Command56 } from "commander";
+import { Command as Command58 } from "commander";
 
 // src/commands/fixtures/load.ts
-import { Command as Command51 } from "commander";
+import { Command as Command53 } from "commander";
 
 // src/lib/data.ts
 import fs28 from "node:fs";
@@ -7220,7 +7696,7 @@ async function hasLoadedFixtures(pb) {
 }
 
 // src/commands/fixtures/load.ts
-var load = new Command51("load").description("load fixtures into the database").configureHelp(helpConfig).action(
+var load = new Command53("load").description("load fixtures into the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let loaded = [];
@@ -7246,8 +7722,8 @@ var load = new Command51("load").description("load fixtures into the database").
 );
 
 // src/commands/fixtures/clear.ts
-import { Command as Command52 } from "commander";
-var clear = new Command52("clear").description("clear loaded fixtures").configureHelp(helpConfig).action(
+import { Command as Command54 } from "commander";
+var clear = new Command54("clear").description("clear loaded fixtures").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let cleared = [];
@@ -7276,8 +7752,8 @@ var clear = new Command52("clear").description("clear loaded fixtures").configur
 );
 
 // src/commands/fixtures/reset.ts
-import { Command as Command53 } from "commander";
-var reset = new Command53("reset").description("clear and reload fixtures").configureHelp(helpConfig).action(
+import { Command as Command55 } from "commander";
+var reset = new Command55("reset").description("clear and reload fixtures").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let cleared = [];
@@ -7309,8 +7785,8 @@ var reset = new Command53("reset").description("clear and reload fixtures").conf
 // src/commands/fixtures/generate.ts
 import fs29 from "node:fs";
 import path26 from "node:path";
-import { Command as Command54, InvalidArgumentError } from "commander";
-import * as p34 from "@clack/prompts";
+import { Command as Command56, InvalidArgumentError } from "commander";
+import * as p37 from "@clack/prompts";
 import { annotate } from "annotate-json-schema";
 import { createGenerator } from "json-schema-faker";
 import { faker } from "@faker-js/faker";
@@ -7420,7 +7896,7 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
   }
   return { writtenFiles, warnings };
 }
-var generate2 = new Command54("generate").description("generate fixture data").option("-c, --count <count>", "number of records per collection", parseCount, 10).option("-s, --seed <seed>", "seed for deterministic output", parseSeed).option("-f, --force", "overwrite existing fixture files and clear loaded fixtures").configureHelp(helpConfig).action(
+var generate2 = new Command56("generate").description("generate fixture data").option("-c, --count <count>", "number of records per collection", parseCount, 10).option("-s, --seed <seed>", "seed for deterministic output", parseSeed).option("-f, --force", "overwrite existing fixture files and clear loaded fixtures").configureHelp(helpConfig).action(
   (opts) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const existing = getFixtureFiles(workspaceRootDir);
@@ -7449,7 +7925,7 @@ var generate2 = new Command54("generate").description("generate fixture data").o
         seed: opts.seed
       });
     });
-    for (const warning of result.warnings) p34.log.warn(warning);
+    for (const warning of result.warnings) p37.log.warn(warning);
     if (result.writtenFiles.length === 0) {
       reportResult({
         summary: "No eligible collections found to generate fixtures for.",
@@ -7473,8 +7949,8 @@ var generate2 = new Command54("generate").description("generate fixture data").o
 );
 
 // src/commands/fixtures/regen.ts
-import { Command as Command55, InvalidArgumentError as InvalidArgumentError2 } from "commander";
-import * as p35 from "@clack/prompts";
+import { Command as Command57, InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import * as p38 from "@clack/prompts";
 function parseCount2(value) {
   const n = parseInt(value, 10);
   if (!Number.isFinite(n) || n <= 0 || n > 999) {
@@ -7489,7 +7965,7 @@ function parseSeed2(value) {
   }
   return n;
 }
-var regen = new Command55("regen").description("clear the database, regenerate fixture files, and reload them").option("-c, --count <count>", "number of records per collection", parseCount2, 10).option("-s, --seed <seed>", "seed for deterministic output", parseSeed2).configureHelp(helpConfig).action(
+var regen = new Command57("regen").description("clear the database, regenerate fixture files, and reload them").option("-c, --count <count>", "number of records per collection", parseCount2, 10).option("-s, --seed <seed>", "seed for deterministic output", parseSeed2).configureHelp(helpConfig).action(
   (opts) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let cleared = [];
@@ -7503,7 +7979,7 @@ var regen = new Command55("regen").description("clear the database, regenerate f
       });
       loaded = await loadFixtures(pb, workspaceRootDir);
     });
-    for (const warning of result.warnings) p35.log.warn(warning);
+    for (const warning of result.warnings) p38.log.warn(warning);
     reportResult({
       summary: `Regenerated fixtures (${loaded.length} collection(s) reloaded).`,
       filesCreated: result.writtenFiles,
@@ -7518,14 +7994,14 @@ var regen = new Command55("regen").description("clear the database, regenerate f
 );
 
 // src/commands/fixtures.ts
-var fixtures = new Command56("fixtures").description("manage fixture data").configureHelp(helpConfig).addCommand(generate2).addCommand(load).addCommand(clear).addCommand(reset).addCommand(regen);
+var fixtures = new Command58("fixtures").description("manage fixture data").configureHelp(helpConfig).addCommand(generate2).addCommand(load).addCommand(clear).addCommand(reset).addCommand(regen);
 
 // src/commands/seeds.ts
-import { Command as Command60 } from "commander";
+import { Command as Command62 } from "commander";
 
 // src/commands/seeds/load.ts
-import { Command as Command57 } from "commander";
-var load2 = new Command57("load").description("load seeds into the database").option("-f, --force", "load even if target collections already have records").configureHelp(helpConfig).action(
+import { Command as Command59 } from "commander";
+var load2 = new Command59("load").description("load seeds into the database").option("-f, --force", "load even if target collections already have records").configureHelp(helpConfig).action(
   (opts) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const seedFiles = getSeedFiles(workspaceRootDir);
@@ -7564,7 +8040,7 @@ var load2 = new Command57("load").description("load seeds into the database").op
 // src/commands/seeds/save.ts
 import fs30 from "node:fs";
 import path27 from "node:path";
-import { Command as Command58 } from "commander";
+import { Command as Command60 } from "commander";
 var padZeros2 = (num, length) => num.toString().padStart(length, "0");
 function filterSystemFields(record, systemFieldNames) {
   const out = {};
@@ -7575,7 +8051,7 @@ function filterSystemFields(record, systemFieldNames) {
   }
   return out;
 }
-var save = new Command58("save").description("save the current data as seeds").option("-f, --force", "overwrite existing seed files").configureHelp(helpConfig).action(
+var save = new Command60("save").description("save the current data as seeds").option("-f, --force", "overwrite existing seed files").configureHelp(helpConfig).action(
   (opts) => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const seedsPath = dataDir(workspaceRootDir, "seeds");
@@ -7647,123 +8123,50 @@ var save = new Command58("save").description("save the current data as seeds").o
 );
 
 // src/commands/seeds/clear.ts
-import { Command as Command59 } from "commander";
-var clear2 = new Command59("clear").description("clear seeded records").configureHelp(helpConfig).action(
+import { Command as Command61 } from "commander";
+var clear2 = new Command61("clear").description("clear seeded records").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const seedFiles = getSeedFiles(workspaceRootDir);
     if (seedFiles.length === 0) {
-      reportResult({
-        summary: "No seed files found in data/seeds.",
-        nextSteps: ["Run `vela seeds save` to create seed files from the current database."]
-      });
-      return;
-    }
-    let cleared = [];
-    await withPocketbase(workspaceRootDir, async (pb) => {
-      cleared = await clearSeeds(pb, workspaceRootDir, seedFiles);
-    });
-    if (cleared.length === 0) {
-      reportResult({
-        summary: "No seeded records found to clear.",
-        nextSteps: ["Run `vela seeds load` to load seed records into the database."]
-      });
-      return;
-    }
-    reportResult({
-      summary: `Cleared ${cleared.length} seed file(s) worth of records.`,
-      recordsCleared: cleared,
-      nextSteps: ["Run `vela seeds load` to reload seeds from the files in data/seeds."]
-    });
-  }, "Failed to clear seeds.")
-);
-
-// src/commands/seeds.ts
-var seeds = new Command60("seeds").description("manage seed data").configureHelp(helpConfig).addCommand(load2).addCommand(save).addCommand(clear2);
-
-// src/commands/signup.ts
-import { Command as Command62 } from "commander";
-import * as p37 from "@clack/prompts";
-import makeFetchCookie2 from "fetch-cookie";
-
-// src/commands/login.ts
-import os4 from "node:os";
-import { Command as Command61 } from "commander";
-import * as p36 from "@clack/prompts";
-import makeFetchCookie from "fetch-cookie";
-var login = new Command61("login").description("login to velastack.dev").configureHelp(helpConfig).action(
-  () => runCommand(async () => {
-    const { email: email3, password: password11 } = await p36.group({
-      email: () => p36.text({ message: "Email" }),
-      password: () => p36.password({ message: "Password" })
-    });
-    const fetchCookie = makeFetchCookie(fetch);
-    const loginRes = await fetchCookie(`${API_URL}/login`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Origin: API_URL
-      },
-      body: new URLSearchParams({
-        type: "password",
-        email: email3,
-        password: password11
-      }).toString()
-    });
-    if (!loginRes.headers.get("Set-Cookie")) {
-      throw new Error(
-        "Run `vela signup` to create an account or reset at https://velastack.dev/reset"
-      );
+      reportResult({
+        summary: "No seed files found in data/seeds.",
+        nextSteps: ["Run `vela seeds save` to create seed files from the current database."]
+      });
+      return;
     }
-    const apiKey = await issueApiKey(fetchCookie);
-    writeConfig({ apiKey });
-    p36.log.success("Logged in to velastack.dev");
-  }, "Failed to login.")
-);
-async function issueApiKey(fetchCookie) {
-  const label4 = `CLI - ${os4.hostname()}`;
-  await fetchCookie(`${API_URL}/api-keys/new`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      Origin: API_URL
-    },
-    body: new URLSearchParams({ label: label4 }).toString()
-  });
-  const cookie = await fetchCookie.cookieJar.getCookieString(API_URL);
-  const apiKey = extractApiKey(cookie);
-  if (!apiKey) {
-    throw new Error("Failed to create API key. Try again or contact support.");
-  }
-  const [id] = apiKey.split(".");
-  const res = await fetchCookie(`${API_URL}/api/collections/api_keys/records`, {
-    headers: { Authorization: `Bearer ${apiKey}` }
-  });
-  const data = await res.json();
-  for (const item of data.items) {
-    if (item.label === label4 && item.id !== id) {
-      await fetchCookie(`${API_URL}/api/collections/api_keys/records/${item.id}`, {
-        method: "DELETE",
-        headers: { Authorization: `Bearer ${apiKey}` }
+    let cleared = [];
+    await withPocketbase(workspaceRootDir, async (pb) => {
+      cleared = await clearSeeds(pb, workspaceRootDir, seedFiles);
+    });
+    if (cleared.length === 0) {
+      reportResult({
+        summary: "No seeded records found to clear.",
+        nextSteps: ["Run `vela seeds load` to load seed records into the database."]
       });
+      return;
     }
-  }
-  return apiKey;
-}
-function extractApiKey(cookie) {
-  const flashCookie = cookie.split(";").find((c) => c.trim().startsWith("flash="));
-  if (!flashCookie) return null;
-  const decoded = decodeURIComponent(flashCookie.split("=")[1]);
-  return JSON.parse(decoded).apiKey;
-}
+    reportResult({
+      summary: `Cleared ${cleared.length} seed file(s) worth of records.`,
+      recordsCleared: cleared,
+      nextSteps: ["Run `vela seeds load` to reload seeds from the files in data/seeds."]
+    });
+  }, "Failed to clear seeds.")
+);
+
+// src/commands/seeds.ts
+var seeds = new Command62("seeds").description("manage seed data").configureHelp(helpConfig).addCommand(load2).addCommand(save).addCommand(clear2);
 
 // src/commands/signup.ts
-var signup = new Command62("signup").description("signup to velastack.dev").configureHelp(helpConfig).action(
+import { Command as Command63 } from "commander";
+import * as p39 from "@clack/prompts";
+import makeFetchCookie2 from "fetch-cookie";
+var signup = new Command63("signup").description("signup to velastack.dev").configureHelp(helpConfig).action(
   () => runCommand(async () => {
-    const { email: email3, password: password11, passwordConfirm } = await p37.group({
-      email: () => p37.text({ message: "Email" }),
-      password: () => p37.password({ message: "Password" }),
-      passwordConfirm: () => p37.password({ message: "Confirm password" })
+    const { email: email3, password: password11, passwordConfirm } = await p39.group({
+      email: () => p39.text({ message: "Email" }),
+      password: () => p39.password({ message: "Password" }),
+      passwordConfirm: () => p39.password({ message: "Confirm password" })
     });
     if (password11 !== passwordConfirm) {
       throw new Error("Passwords do not match.");
@@ -7787,33 +8190,33 @@ var signup = new Command62("signup").description("signup to velastack.dev").conf
     }
     const apiKey = await issueApiKey(fetchCookie);
     writeConfig({ apiKey });
-    p37.log.success("Signed up to velastack.dev");
-    p37.log.info("Check your email for a confirmation link.");
+    p39.log.success("Signed up to velastack.dev");
+    p39.log.info("Check your email for a confirmation link.");
   }, "Failed to signup.")
 );
 
 // src/commands/logout.ts
-import { Command as Command63 } from "commander";
-import * as p38 from "@clack/prompts";
-var logout = new Command63("logout").alias("signout").description("logout from velastack.dev").configureHelp(helpConfig).action(
+import { Command as Command64 } from "commander";
+import * as p40 from "@clack/prompts";
+var logout = new Command64("logout").alias("signout").description("logout from velastack.dev").configureHelp(helpConfig).action(
   () => runCommand(() => {
     if (!readConfig()) {
-      p38.log.info("Not logged in");
+      p40.log.info("Not logged in");
       return;
     }
     clearConfig();
-    p38.log.success("Logged out of velastack.dev");
+    p40.log.success("Logged out of velastack.dev");
   })
 );
 
 // src/commands/whoami.ts
-import { Command as Command64 } from "commander";
-import * as p39 from "@clack/prompts";
-var whoami = new Command64("whoami").description("show the current user").configureHelp(helpConfig).action(
+import { Command as Command65 } from "commander";
+import * as p41 from "@clack/prompts";
+var whoami = new Command65("whoami").description("show the current user").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const apiKey = readConfig()?.apiKey;
     if (!apiKey) {
-      p39.log.info("Not logged in. Run `vela login` to login.");
+      p41.log.info("Not logged in. Run `vela login` to login.");
       return;
     }
     const res = await fetch(`${API_URL}/api/collections/users/records`, {
@@ -7821,22 +8224,22 @@ var whoami = new Command64("whoami").description("show the current user").config
     });
     const data = await res.json();
     if (!data.items.length) throw new Error("No user found. Run `vela login` to login.");
-    p39.log.success(`Logged in as ${data.items[0].email}`);
+    p41.log.success(`Logged in as ${data.items[0].email}`);
   })
 );
 
 // src/commands/migrate.ts
-import { Command as Command70 } from "commander";
+import { Command as Command71 } from "commander";
 
 // src/commands/migrate/up.ts
-import { Command as Command65 } from "commander";
+import { Command as Command66 } from "commander";
 
 // src/lib/migrate.ts
 import path28 from "node:path";
-import process20 from "node:process";
+import process23 from "node:process";
 import { x as x2 } from "tinyexec";
 async function runPocketbaseMigrate(args) {
-  const cwd = process20.cwd();
+  const cwd = process23.cwd();
   const { getBinaryPath } = await import("pocketbase-server");
   const binaryPath = getBinaryPath();
   await x2(
@@ -7868,10 +8271,10 @@ async function runMigrateUp() {
     ]
   });
 }
-var up = new Command65("up").description("apply all pending migrations").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations."));
+var up = new Command66("up").description("apply all pending migrations").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations."));
 
 // src/commands/migrate/down.ts
-import { Command as Command66, InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import { Command as Command67, InvalidArgumentError as InvalidArgumentError3 } from "commander";
 function parseSteps(value) {
   const n = parseInt(value, 10);
   if (!Number.isFinite(n) || n <= 0) {
@@ -7879,7 +8282,7 @@ function parseSteps(value) {
   }
   return n;
 }
-var down = new Command66("down").alias("rollback").description("revert the last N applied migrations").argument("[number]", "how many migrations to revert", parseSteps, 1).configureHelp(helpConfig).action(
+var down = new Command67("down").alias("rollback").description("revert the last N applied migrations").argument("[number]", "how many migrations to revert", parseSteps, 1).configureHelp(helpConfig).action(
   (n) => runCommand(async () => {
     await runPocketbaseMigrate(["down", String(n)]);
     reportResult({
@@ -7895,11 +8298,11 @@ var down = new Command66("down").alias("rollback").description("revert the last
 // src/commands/migrate/create.ts
 import fs31 from "node:fs";
 import path29 from "node:path";
-import process21 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(
+import process24 from "node:process";
+import { Command as Command68 } from "commander";
+var create2 = new Command68("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
   (name) => runCommand(async () => {
-    const cwd = process21.cwd();
+    const cwd = process24.cwd();
     const before = listMigrationFiles(cwd);
     await runPocketbaseMigrate(["create", name]);
     const after = listMigrationFiles(cwd);
@@ -7923,11 +8326,11 @@ function listMigrationFiles(cwd) {
 // src/commands/migrate/collections.ts
 import fs32 from "node:fs";
 import path30 from "node:path";
-import process22 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(
+import process25 from "node:process";
+import { Command as Command69 } from "commander";
+var collections = new Command69("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
   () => runCommand(async () => {
-    const cwd = process22.cwd();
+    const cwd = process25.cwd();
     const before = listMigrationFiles2(cwd);
     await runPocketbaseMigrate(["collections"]);
     const after = listMigrationFiles2(cwd);
@@ -7956,8 +8359,8 @@ function listMigrationFiles2(cwd) {
 }
 
 // src/commands/migrate/history-sync.ts
-import { Command as Command69 } from "commander";
-var historySync = new Command69("history-sync").description("drop _migrations rows whose files no longer exist").configureHelp(helpConfig).action(
+import { Command as Command70 } from "commander";
+var historySync = new Command70("history-sync").description("drop _migrations rows whose files no longer exist").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     await runPocketbaseMigrate(["history-sync"]);
     reportResult({
@@ -7968,20 +8371,20 @@ var historySync = new Command69("history-sync").description("drop _migrations ro
 );
 
 // src/commands/migrate.ts
-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);
+var migrate = new Command71("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 fs33 from "node:fs";
 import path32 from "node:path";
-import process24 from "node:process";
+import process27 from "node:process";
 import { performance } from "node:perf_hooks";
-import { Command as Command71, InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { Command as Command72, InvalidArgumentError as InvalidArgumentError4 } from "commander";
 import pc15 from "picocolors";
 import PocketBase4 from "pocketbase";
 
 // src/lib/vite.ts
 import path31 from "node:path";
-import process23 from "node:process";
+import process26 from "node:process";
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import pc14 from "picocolors";
@@ -8005,13 +8408,13 @@ function resolveProjectVite(cwd) {
     return null;
   }
 }
-async function loadVite(cwd = process23.cwd()) {
+async function loadVite(cwd = process26.cwd()) {
   const entry = resolveProjectVite(cwd);
   const vite = entry ? await import(pathToFileURL2(entry).href) : await import("vite");
   const error = viteVersionError(vite.version);
   if (error) {
     console.error(`${pc14.redBright("\u2717")} ${error}`);
-    process23.exit(1);
+    process26.exit(1);
   }
   return vite;
 }
@@ -8024,16 +8427,16 @@ function parsePort(value) {
   }
   return port;
 }
-var dev = new Command71("dev").description("start the development server").option("--open [path]", "open the app in a browser once the server is ready").option("--host [host]", "expose the server on the network").option("--port <port>", "port to listen on", parsePort).option("--strictPort", "exit if the port is already in use instead of taking the next one").option("--cors", "enable CORS").option("--force", "re-bundle dependencies, ignoring the optimizer cache").configureHelp(helpConfig).action(async (options) => {
-  const cwd = process24.cwd();
-  process24.env.VELA_DATA_DIR ??= localDataDir(cwd);
+var dev = new Command72("dev").description("start the development server").option("--open [path]", "open the app in a browser once the server is ready").option("--host [host]", "expose the server on the network").option("--port <port>", "port to listen on", parsePort).option("--strictPort", "exit if the port is already in use instead of taking the next one").option("--cors", "enable CORS").option("--force", "re-bundle dependencies, ignoring the optimizer cache").configureHelp(helpConfig).action(async (options) => {
+  const cwd = process27.cwd();
+  process27.env.VELA_DATA_DIR ??= localDataDir(cwd);
   const startTime = performance.now();
   const { createServer, version } = await loadVite(cwd);
   const viteMetadataDir = path32.join(cwd, "node_modules", ".vite");
   const viteMetadataFile = path32.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
-  const needsStart = backend3 && !process24.env.POCKETBASE_URL;
+  const needsStart = backend3 && !process27.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
     if (fs33.existsSync(viteMetadataFile)) fs33.rmSync(viteMetadataFile);
@@ -8048,15 +8451,15 @@ var dev = new Command71("dev").description("start the development server").optio
       stdio: "pipe"
     });
     pbProc = started.proc;
-    process24.env.POCKETBASE_URL = started.url;
-    pbProc.stdout?.pipe(process24.stdout);
-    pbProc.stderr?.pipe(process24.stderr);
+    process27.env.POCKETBASE_URL = started.url;
+    pbProc.stdout?.pipe(process27.stdout);
+    pbProc.stderr?.pipe(process27.stderr);
     pbProc.on("error", (err) => console.error("PocketBase error:", err));
     pbProc.on("exit", (code) => console.log(`PocketBase exited with code ${code}`));
-    process24.on("exit", cleanup);
-    process24.on("SIGINT", () => {
+    process27.on("exit", cleanup);
+    process27.on("SIGINT", () => {
       cleanup();
-      process24.exit(0);
+      process27.exit(0);
     });
   }
   const serverOptions = {};
@@ -8078,21 +8481,21 @@ var dev = new Command71("dev").description("start the development server").optio
     await fs33.promises.writeFile(
       viteMetadataFile,
       JSON.stringify({
-        pocketbaseUrl: process24.env.POCKETBASE_URL,
+        pocketbaseUrl: process27.env.POCKETBASE_URL,
         vitePort,
         viteHost
       })
     );
-    const pb = new PocketBase4(process24.env.POCKETBASE_URL);
+    const pb = new PocketBase4(process27.env.POCKETBASE_URL);
     await pb.collection("_superusers").authWithPassword(
-      process24.env.POCKETBASE_SUPERUSER_EMAIL,
-      process24.env.POCKETBASE_SUPERUSER_PASSWORD
+      process27.env.POCKETBASE_SUPERUSER_EMAIL,
+      process27.env.POCKETBASE_SUPERUSER_PASSWORD
     );
     await pb.settings.update({ meta: { appURL: `http://${viteHost}:${vitePort}` } });
     await startWatchingTypes(cwd, pb);
   });
   await server.listen();
-  const hasExistingLogs = process24.stdout.bytesWritten > 0 || process24.stderr.bytesWritten > 0;
+  const hasExistingLogs = process27.stdout.bytesWritten > 0 || process27.stderr.bytesWritten > 0;
   const startupDurationString = pc15.dim(
     `ready in ${pc15.reset(pc15.bold(Math.ceil(performance.now() - startTime)))} ms`
   );
@@ -8132,9 +8535,9 @@ async function startWatchingTypes(cwd, pb) {
 // src/commands/build.ts
 import fs34 from "node:fs";
 import path33 from "node:path";
-import process26 from "node:process";
-import { Command as Command72 } from "commander";
-import * as p40 from "@clack/prompts";
+import process29 from "node:process";
+import { Command as Command73 } from "commander";
+import * as p42 from "@clack/prompts";
 import pc16 from "picocolors";
 import { x as x3 } from "tinyexec";
 import { detect as detect5 } from "package-manager-detector";
@@ -8147,10 +8550,10 @@ function applyBuildEnv(cwd, env2 = process.env) {
 }
 
 // src/lib/origin.ts
-import process25 from "node:process";
+import process28 from "node:process";
 function resolveOrigin(workspaceRootDir, envTag, config = {}) {
   return normalizeOrigin(
-    process25.env.VELA_ORIGIN ?? readBinding(workspaceRootDir, envTag)?.domain ?? config.deploy?.domain
+    process28.env.VELA_ORIGIN ?? readBinding(workspaceRootDir, envTag)?.domain ?? config.deploy?.domain
   );
 }
 function normalizeOrigin(value) {
@@ -8170,13 +8573,13 @@ function splitHosts(value) {
 
 // src/commands/build.ts
 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 = process26.cwd();
+var build = new Command73("build").description("build the app").configureHelp(helpConfig).option("-t, --target <target>", "which copy of the app to build for", PRODUCTION_TARGET).action(async (options) => {
+  const cwd = process29.cwd();
   applyBuildEnv(cwd);
   const origin = await originForBuild(cwd, options.target);
-  if (origin) process26.env.VELA_ORIGIN = origin;
+  if (origin) process29.env.VELA_ORIGIN = origin;
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process26.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process29.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
@@ -8190,11 +8593,11 @@ var build = new Command72("build").description("build the app").configureHelp(he
       dev: true
     });
     pbProc = started.proc;
-    process26.env.POCKETBASE_URL = started.url;
-    process26.on("exit", cleanup);
-    process26.on("SIGINT", () => {
+    process29.env.POCKETBASE_URL = started.url;
+    process29.on("exit", cleanup);
+    process29.on("SIGINT", () => {
       cleanup();
-      process26.exit(0);
+      process29.exit(0);
     });
   }
   try {
@@ -8227,7 +8630,7 @@ async function originForBuild(cwd, target) {
 function warnIfPrerendered(cwd) {
   const dir = path33.join(cwd, PRERENDERED_DIR);
   if (!fs34.existsSync(dir) || fs34.readdirSync(dir).length === 0) return;
-  p40.log.warn(
+  p42.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.
 
@@ -8237,16 +8640,16 @@ Set one with ${pc16.cyan("vela deploy --domain example.com")}, or pass ${pc16.cy
 
 // src/commands/preview.ts
 import path34 from "node:path";
-import process27 from "node:process";
-import { Command as Command73 } from "commander";
+import process30 from "node:process";
+import { Command as Command74 } from "commander";
 import { x as x4 } from "tinyexec";
 import { detect as detect6 } from "package-manager-detector";
 import { resolveCommand as resolveCommand6 } from "package-manager-detector/commands";
-var preview = new Command73("preview").description("preview the built app").configureHelp(helpConfig).action(async () => {
-  const cwd = process27.cwd();
-  process27.env.VELA_DATA_DIR ??= localDataDir(cwd);
+var preview = new Command74("preview").description("preview the built app").configureHelp(helpConfig).action(async () => {
+  const cwd = process30.cwd();
+  process30.env.VELA_DATA_DIR ??= localDataDir(cwd);
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process27.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process30.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
@@ -8259,11 +8662,11 @@ var preview = new Command73("preview").description("preview the built app").conf
       dev: true
     });
     pbProc = started.proc;
-    process27.env.POCKETBASE_URL = started.url;
-    process27.on("exit", cleanup);
-    process27.on("SIGINT", () => {
+    process30.env.POCKETBASE_URL = started.url;
+    process30.on("exit", cleanup);
+    process30.on("SIGINT", () => {
       cleanup();
-      process27.exit(0);
+      process30.exit(0);
     });
   }
   try {
@@ -8282,8 +8685,8 @@ var preview = new Command73("preview").description("preview the built app").conf
 
 // src/commands/sync.ts
 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(
+import { Command as Command75 } from "commander";
+var sync = new Command75("sync").description("sync types from the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const typesDir = path35.join(workspaceRootDir, ".svelte-kit", "types");
@@ -8296,8 +8699,8 @@ var sync = new Command74("sync").description("sync types from the database").con
 );
 
 // src/commands/provision.ts
-import { Command as Command75 } from "commander";
-import * as p41 from "@clack/prompts";
+import { Command as Command76 } from "commander";
+import * as p43 from "@clack/prompts";
 import pc17 from "picocolors";
 import * as v7 from "valibot";
 var OptionsSchema2 = v7.object({
@@ -8306,24 +8709,24 @@ var OptionsSchema2 = v7.object({
   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)
+  new Command76("provision").description("prepare a server to host vela apps").argument("<target>", "SSH target \u2014 an alias from ~/.ssh/config, or user@host").configureHelp(helpConfig)
 ).option("--pb-version <version>", "PocketBase version to install").option("--node-major <version>", "Node.js major version to install", "22").action(
   (target, raw) => runCommand(async () => {
     const options = parseOptions(OptionsSchema2, raw);
     const pbVersion = options.pbVersion ?? pocketbaseVersion();
-    p41.intro(pc17.bgCyan(pc17.black(" vela provision ")));
-    p41.log.info(`Target ${pc17.cyan(target)}`);
+    p43.intro(pc17.bgCyan(pc17.black(" vela provision ")));
+    p43.log.info(`Target ${pc17.cyan(target)}`);
     await withSsh(target, sshOptionsFrom(options), async (session) => {
       await session.detectElevation();
       const existing = await readServerInfo(session);
       if (existing) {
-        p41.log.info(
+        p43.log.info(
           `Already provisioned by vela ${existing.cliVersion} on ${existing.provisionedAt}. Bringing it up to date.`
         );
       }
-      p41.log.step("Uploading server scripts");
+      p43.log.step("Uploading server scripts");
       await syncServerScripts(session);
-      p41.log.step("Running provision");
+      p43.log.step("Running provision");
       const result = await runServerScript(session, "provision.sh", {
         args: [
           "--pb-version",
@@ -8335,7 +8738,7 @@ var provision = addSshOptions(
         ],
         stream: true
       });
-      p41.log.success(
+      p43.log.success(
         `${target} is ready.
 
   Node        ${result?.node ?? "installed"}
@@ -8343,29 +8746,29 @@ var provision = addSshOptions(
   PocketBase  ${result?.pocketbase ?? pbVersion}`
       );
     });
-    p41.outro(`Deploy with ${pc17.cyan(`vela deploy --server ${target}`)}`);
+    p43.outro(`Deploy with ${pc17.cyan(`vela deploy --server ${target}`)}`);
   }, "Failed to provision.")
 );
 
 // src/commands/deploy.ts
 import path38 from "node:path";
 import fs37 from "node:fs";
-import { Command as Command76, Option as Option2 } from "commander";
-import * as p42 from "@clack/prompts";
+import { Command as Command77, Option as Option2 } from "commander";
+import * as p44 from "@clack/prompts";
 import pc18 from "picocolors";
 import * as v8 from "valibot";
 
 // src/lib/pocketbase-settings.ts
 import fs35 from "node:fs";
 import path36 from "node:path";
-import process28 from "node:process";
+import process31 from "node:process";
 import PocketBase5 from "pocketbase";
 var COPIED_KEYS = ["appName", "senderName", "senderAddress"];
 async function readLocalMeta(cwd) {
   const dataDir2 = path36.join(cwd, DATA_DIR);
   if (!fs35.existsSync(dataDir2)) return null;
-  const email3 = process28.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password11 = process28.env.POCKETBASE_SUPERUSER_PASSWORD;
+  const email3 = process31.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password11 = process31.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email3 || !password11) return null;
   let proc;
   try {
@@ -8694,7 +9097,7 @@ var OptionsSchema3 = v8.object({
 });
 var deploy = addLockWaitOption(
   addTargetOptions(
-    new Command76("deploy").description("deploy the app").configureHelp(helpConfig),
+    new Command77("deploy").description("deploy the app").configureHelp(helpConfig),
     "production"
   )
 ).option("--project <name>", "override the project name").option("--domain <hosts>", "hostname(s) to serve on, comma separated").option("--health-path <path>", "path the health check requests").option("--keep <count>", "how many old releases to keep on the server").option("--pb-version <version>", "PocketBase version to run").option("--no-build", "deploy the existing build output without rebuilding").addOption(
@@ -8710,7 +9113,7 @@ var deploy = addLockWaitOption(
   (raw) => runCommand(async () => {
     const options = parseOptions(OptionsSchema3, raw);
     const backend3 = hasBackend();
-    p42.intro(pc18.bgCyan(pc18.black(" vela deploy ")));
+    p44.intro(pc18.bgCyan(pc18.black(" vela deploy ")));
     if (options.build !== false) {
       const { workspaceRootDir } = await getWorkspace();
       await prepareAdapter(workspaceRootDir);
@@ -8720,7 +9123,7 @@ var deploy = addLockWaitOption(
       {
         remote: async (ctx) => {
           const { session, instance, workspaceRootDir, config } = ctx;
-          p42.log.info(
+          p44.log.info(
             `${pc18.cyan(ctx.appName)} ${pc18.dim("\u2192")} ${pc18.cyan(ctx.targetName)} ${pc18.dim(`(${ctx.server})`)}`
           );
           const [existing] = await readInstanceStates(session, instance);
@@ -8730,7 +9133,7 @@ var deploy = addLockWaitOption(
           const askedForRemoteDb = options.remoteDb ?? config.deploy?.buildAgainstRemote;
           const remoteDb = askedForRemoteDb ?? instanceHasBackend(existing);
           if (existing && instanceHasBackend(existing) !== backend3) {
-            p42.log.info(
+            p44.log.info(
               backend3 ? `${pc18.cyan(ctx.targetName)} was deployed without a backend before. This deploy adds PocketBase.` : `${pc18.cyan(ctx.targetName)} was deployed with a backend before. This deploy removes PocketBase; its database stays on the server.`
             );
           }
@@ -8773,7 +9176,7 @@ with DNS of your own pointing at ${ctx.server}.`
                   tunnel = await openDatabaseTunnel(session, instance, existing);
                 } catch (err) {
                   if (askedForRemoteDb) throw err;
-                  p42.log.warn(
+                  p44.log.warn(
                     `Could not build against the ${pc18.cyan(ctx.targetName)} database, using a local one instead.
 ${pc18.dim(String(err))}`
                   );
@@ -8781,13 +9184,13 @@ ${pc18.dim(String(err))}`
               }
               if (tunnel) {
                 buildEnv = { ...buildEnv, ...tunnel.env };
-                p42.log.info(
+                p44.log.info(
                   `Building against the ${pc18.cyan(ctx.targetName)} database on ${ctx.server} ${pc18.dim(`(port ${tunnel.pbPort})`)}`
                 );
               } else if (backend3) {
                 await ensureSuperuser(workspaceRootDir);
               }
-              p42.log.step("Building");
+              p44.log.step("Building");
               try {
                 await runBuild(workspaceRootDir, config.deploy?.buildCommand, buildEnv);
               } finally {
@@ -8795,9 +9198,9 @@ ${pc18.dim(String(err))}`
               }
             }
             const entries = collectArtifact(workspaceRootDir, config.deploy ?? {});
-            p42.log.step(`Uploading release ${pc18.dim(release)}`);
+            p44.log.step(`Uploading release ${pc18.dim(release)}`);
             await uploadRelease(session, instance, release, entries);
-            p42.log.step("Activating");
+            p44.log.step("Activating");
             result = await runServerScript(session, "apply.sh", {
               args: [
                 instance,
@@ -8848,7 +9251,7 @@ ${pc18.dim(String(err))}`
             url: primaryHost ? url : void 0
           });
           const redirects = started?.environment.redirects ?? [];
-          p42.log.success(
+          p44.log.success(
             `Deployed ${pc18.cyan(ctx.appName)} ${pc18.dim(release)}
 
   URL   ${url}
@@ -8856,7 +9259,7 @@ ${pc18.dim(String(err))}`
 ` : "") + `  Port  ${result?.webPort ?? "?"}${backend3 ? ` (PocketBase ${result?.pbPort ?? "?"})` : ""}`
           );
           if (managed && managed !== existing?.managed) {
-            p42.log.info(`${pc18.cyan(managed)} goes live within a minute.`);
+            p44.log.info(`${pc18.cyan(managed)} goes live within a minute.`);
           }
           if (result?.superuserCreated) {
             await copyLocalBranding(
@@ -8865,7 +9268,7 @@ ${pc18.dim(String(err))}`
               workspaceRootDir,
               primaryHost ? result?.url ?? "" : ""
             );
-            p42.log.info(
+            p44.log.info(
               `Created the PocketBase superuser this app authenticates as.
 
 Its credentials are stored in the environment on the server. To use
@@ -8876,7 +9279,7 @@ and deploy again.`
             await reportAppURLDrift(session, instance, primaryHost);
           }
           if (!primaryHost) {
-            p42.log.warn(
+            p44.log.warn(
               `No domain configured, so nothing is proxied to this app yet.
 Redeploy with ${pc18.cyan("--domain example.com")} once DNS points at ${ctx.server}` + (reporter.enabled ? "" : `,
 or ${pc18.cyan("vela link")} it to get a free velastack.app hostname.`) + `.`
@@ -8886,7 +9289,7 @@ or ${pc18.cyan("vela link")} it to get a free velastack.app hostname.`) + `.`
       },
       { project: options.project, askDomain: true, label: "deploy" }
     );
-    p42.outro(`${pc18.cyan("vela status")} to see what is running`);
+    p44.outro(`${pc18.cyan("vela status")} to see what is running`);
   }, "Failed to deploy.")
 );
 async function prepareAdapter(workspaceRootDir) {
@@ -8905,8 +9308,8 @@ ${pc18.cyan(err.snippet)}` : err.message);
     outcome.packageJsonChanged ? "package.json" : void 0
   ].filter((f) => Boolean(f));
   const why = outcome.previous === "auto" ? `${ADAPTER_AUTO} builds nothing for a server of your own` : outcome.previous === "none" ? "No adapter was configured" : `${ADAPTER_NODE} was configured but not in package.json`;
-  p42.log.step(`Switching the adapter to ${pc18.cyan(ADAPTER_NODE)}`);
-  p42.log.info(
+  p44.log.step(`Switching the adapter to ${pc18.cyan(ADAPTER_NODE)}`);
+  p44.log.info(
     `${why}, and vela deploy runs the app as a Node server.
 
   Changed  ${changed.join(", ")}` + (outcome.removedDeps.length ? `
@@ -8919,14 +9322,14 @@ ${pc18.cyan(err.snippet)}` : err.message);
       rethrow(err);
     }
   }
-  p42.log.warn(`Commit ${changed.join(", ")} so every deploy builds the same way.`);
+  p44.log.warn(`Commit ${changed.join(", ")} so every deploy builds the same way.`);
 }
 async function reportAppURLDrift(session, instance, domain) {
   const expected = normalizeOrigin(domain);
   if (!expected) return;
   const current = await readRemoteAppURL(session, instance);
   if (!current || normalizeOrigin(current) === expected) return;
-  p42.log.warn(
+  p44.log.warn(
     `This app's PocketBase ${pc18.cyan("appURL")} is ${pc18.dim(current)}, but it is served on ${pc18.dim(expected)}.
 
 Emails and anything else PocketBase links to will use the former. Update it in
@@ -8941,15 +9344,15 @@ async function copyLocalBranding(session, instance, workspaceRootDir, appURL) {
     if (copied.length === 0) return;
     const outcome = await restartInstance(session, instance);
     if (outcome.deployed && !outcome.restarted) {
-      p42.log.warn(
+      p44.log.warn(
         `Copied ${copied.join(", ")}, but the app did not restart to pick them up.
 ${pc18.dim(outcome.error ?? "")}`
       );
       return;
     }
-    p42.log.success(`Copied ${copied.join(", ")} from this project's database`);
+    p44.log.success(`Copied ${copied.join(", ")} from this project's database`);
   } catch (err) {
-    p42.log.warn(
+    p44.log.warn(
       `Could not copy this project's PocketBase settings across.
 Set them in the admin panel instead. ${pc18.dim(String(err))}`
     );
@@ -9042,7 +9445,7 @@ async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
   if (!fs37.existsSync(path38.join(workspaceRootDir, ".env"))) return;
-  p42.log.warn(
+  p44.log.warn(
     `This app has no production environment variables yet.
 
 Local ${pc18.cyan(".env")} values are not uploaded by a deploy. Set them with
@@ -9053,53 +9456,43 @@ async function serverTimeOrLocal(session) {
   try {
     return await serverTime(session);
   } catch {
-    p42.log.warn("Could not read the clock on the server; stamping this release from this machine.");
+    p44.log.warn("Could not read the clock on the server; stamping this release from this machine.");
     return /* @__PURE__ */ new Date();
   }
 }
 
 // src/commands/link.ts
 import path39 from "node:path";
-import process29 from "node:process";
-import { Command as Command77 } from "commander";
-import * as p43 from "@clack/prompts";
+import process32 from "node:process";
+import { Command as Command78 } from "commander";
+import * as p45 from "@clack/prompts";
 var CREATE_NEW = "__new__";
-var link = new Command77("link").description("link this project to a velastack.dev project").configureHelp(helpConfig).action(() => runCommand(linkProject, "Failed to link the project."));
+var link = new Command78("link").description("link this project to a velastack.dev project").configureHelp(helpConfig).action(() => runCommand(linkProject, "Failed to link the project."));
 async function linkProject() {
   const { workspaceRootDir } = await getWorkspace();
   const existing = readProjectConfig(workspaceRootDir);
   if (existing) {
-    p43.log.success(`Linked to ${existing.projectName}.`);
+    p45.log.success(`Linked to ${existing.projectName}.`);
     return;
   }
   const apiKey = requireApiKey();
-  const [user, teams3, projects] = await Promise.all([
-    getCurrentUser(apiKey),
-    listTeams(apiKey),
-    listProjects(apiKey)
-  ]);
-  let projectId;
-  let teamId;
-  let projectName;
+  const [teams3, projects] = await Promise.all([listTeams(apiKey), listProjects(apiKey)]);
   const picked = projects.length > 0 ? await pickExistingProject(projects) : CREATE_NEW;
+  let linked;
   if (picked !== CREATE_NEW) {
     const project = projects.find((pr) => pr.id === picked);
-    projectId = project.id;
-    teamId = project.team;
-    projectName = project.name;
+    linked = toLinked(project, project.expand?.team);
   } else {
     const team = await pickTeam(teams3);
     const name = await promptProjectName(workspaceRootDir);
-    const created = await createProject2(apiKey, { name, teamId: team.id, userId: user.id });
-    projectId = created.id;
-    teamId = team.id;
-    projectName = created.name;
+    linked = await linkNewProject(apiKey, { name, teamId: team.id, interactive: true });
   }
+  const { projectId, teamId, projectName } = linked;
   writeProjectConfig(workspaceRootDir, { projectId, teamId, projectName });
-  p43.log.success(`Linked to ${projectName}.`);
+  p45.log.success(`Linked to ${projectName} (${linked.dashboardUrl}).`);
 }
 async function pickExistingProject(projects) {
-  const choice = await p43.select({
+  const choice = await p45.select({
     message: "Select a project",
     options: [
       ...projects.map((pr) => ({
@@ -9109,39 +9502,24 @@ async function pickExistingProject(projects) {
       { value: CREATE_NEW, label: "Create a new project" }
     ]
   });
-  if (p43.isCancel(choice)) {
-    p43.cancel("Operation cancelled.");
-    process29.exit(0);
+  if (p45.isCancel(choice)) {
+    p45.cancel("Operation cancelled.");
+    process32.exit(0);
   }
   return choice;
 }
-async function pickTeam(teams3) {
-  if (teams3.length === 1) return teams3[0];
-  const choice = await p43.select({
-    message: "Select a team",
-    options: teams3.map((team) => ({
-      value: team.id,
-      label: team.is_personal ? `${team.name} (personal)` : team.name
-    }))
-  });
-  if (p43.isCancel(choice)) {
-    p43.cancel("Operation cancelled.");
-    process29.exit(0);
-  }
-  return teams3.find((team) => team.id === choice);
-}
 async function promptProjectName(workspaceRootDir) {
   const defaultValue = defaultProjectName2(workspaceRootDir);
-  const value = await p43.text({
+  const value = await p45.text({
     message: "Project name",
     defaultValue,
     initialValue: defaultValue,
     placeholder: defaultValue,
     validate: (v10) => !v10?.trim() ? "Required" : void 0
   });
-  if (p43.isCancel(value)) {
-    p43.cancel("Operation cancelled.");
-    process29.exit(0);
+  if (p45.isCancel(value)) {
+    p45.cancel("Operation cancelled.");
+    process32.exit(0);
   }
   return value.trim();
 }
@@ -9156,14 +9534,14 @@ function defaultProjectName2(workspaceRootDir) {
 }
 
 // src/commands/env.ts
-import { Command as Command82 } from "commander";
+import { Command as Command83 } from "commander";
 
 // src/commands/env/list.ts
-import { Command as Command78 } from "commander";
-import * as p44 from "@clack/prompts";
+import { Command as Command79 } from "commander";
+import * as p46 from "@clack/prompts";
 import pc19 from "picocolors";
 var envList = addTargetOptions(
-  new Command78("list").description("list environment variable names").configureHelp(helpConfig),
+  new Command79("list").description("list environment variable names").configureHelp(helpConfig),
   "local"
 ).action(
   (raw) => runCommand(
@@ -9185,10 +9563,10 @@ var envList = addTargetOptions(
 );
 function report(keys, where) {
   if (keys.length === 0) {
-    p44.log.info(`No environment variables configured ${pc19.dim(`(${where})`)}.`);
+    p46.log.info(`No environment variables configured ${pc19.dim(`(${where})`)}.`);
     return;
   }
-  p44.log.info(
+  p46.log.info(
     `Environment ${pc19.dim(`(${where})`)}
 
 ` + keys.sort().map((key) => `  ${key}`).join("\n")
@@ -9196,12 +9574,12 @@ function report(keys, where) {
 }
 
 // src/commands/env/set.ts
-import process30 from "node:process";
-import { Command as Command79 } from "commander";
-import * as p45 from "@clack/prompts";
+import process33 from "node:process";
+import { Command as Command80 } from "commander";
+import * as p47 from "@clack/prompts";
 import pc20 from "picocolors";
 var envSet = addTargetOptions(
-  new Command79("set").description("set an environment variable").argument("<key>", "variable name").argument("[value]", "value \u2014 prompted for, without echo, when omitted").configureHelp(helpConfig),
+  new Command80("set").description("set an environment variable").argument("<key>", "variable name").argument("[value]", "value \u2014 prompted for, without echo, when omitted").configureHelp(helpConfig),
   "local"
 ).action(
   (key, value, raw) => runCommand(
@@ -9211,14 +9589,14 @@ var envSet = addTargetOptions(
         local: async (ctx) => {
           const resolved = await resolveValue(key, value);
           setLocalEnv(ctx.envFile, key, resolved);
-          p45.log.success(`${key} updated ${pc20.dim("(local)")}`);
+          p47.log.success(`${key} updated ${pc20.dim("(local)")}`);
           await applyLocalEnvChange(ctx, [key]);
         },
         remote: async (ctx) => {
           const resolved = await resolveValue(key, value);
           const env2 = await readRemoteEnv(ctx.session, ctx.instance);
           await writeRemoteEnv(ctx.session, ctx.instance, { ...env2, [key]: resolved });
-          p45.log.success(`${key} updated ${pc20.dim(`(${ctx.targetName})`)}`);
+          p47.log.success(`${key} updated ${pc20.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -9232,23 +9610,23 @@ async function resolveValue(key, value) {
   return value ?? await promptValue(key);
 }
 async function promptValue(key) {
-  const value = await p45.password({
+  const value = await p47.password({
     message: `Value for ${pc20.cyan(key)}`,
     validate: (input) => !input?.length ? "Required" : void 0
   });
-  if (p45.isCancel(value)) {
-    p45.cancel("Operation cancelled.");
-    process30.exit(0);
+  if (p47.isCancel(value)) {
+    p47.cancel("Operation cancelled.");
+    process33.exit(0);
   }
   return value;
 }
 
 // src/commands/env/unset.ts
-import { Command as Command80 } from "commander";
-import * as p46 from "@clack/prompts";
+import { Command as Command81 } from "commander";
+import * as p48 from "@clack/prompts";
 import pc21 from "picocolors";
 var envUnset = addTargetOptions(
-  new Command80("unset").description("remove an environment variable").argument("<key>", "variable name").configureHelp(helpConfig),
+  new Command81("unset").description("remove an environment variable").argument("<key>", "variable name").configureHelp(helpConfig),
   "local"
 ).action(
   (key, raw) => runCommand(
@@ -9257,22 +9635,22 @@ var envUnset = addTargetOptions(
       {
         local: async (ctx) => {
           if (!(key in readLocalEnv(ctx.envFile))) {
-            p46.log.info(`${key} is not set \u2014 nothing to remove.`);
+            p48.log.info(`${key} is not set \u2014 nothing to remove.`);
             return;
           }
           unsetLocalEnv(ctx.envFile, key);
-          p46.log.success(`${key} removed ${pc21.dim("(local)")}`);
+          p48.log.success(`${key} removed ${pc21.dim("(local)")}`);
           await applyLocalEnvChange(ctx, [key]);
         },
         remote: async (ctx) => {
           const env2 = await readRemoteEnv(ctx.session, ctx.instance);
           if (!(key in env2)) {
-            p46.log.info(`${key} is not set \u2014 nothing to remove.`);
+            p48.log.info(`${key} is not set \u2014 nothing to remove.`);
             return;
           }
           delete env2[key];
           await writeRemoteEnv(ctx.session, ctx.instance, env2);
-          p46.log.success(`${key} removed ${pc21.dim(`(${ctx.targetName})`)}`);
+          p48.log.success(`${key} removed ${pc21.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -9285,12 +9663,12 @@ var envUnset = addTargetOptions(
 // src/commands/env/import.ts
 import fs38 from "node:fs";
 import path40 from "node:path";
-import process31 from "node:process";
-import { Command as Command81 } from "commander";
-import * as p47 from "@clack/prompts";
+import process34 from "node:process";
+import { Command as Command82 } from "commander";
+import * as p49 from "@clack/prompts";
 import pc22 from "picocolors";
 var envImport = addTargetOptions(
-  new Command81("import").description("merge a dotenv file into the environment").argument("<file>", "dotenv file to read").configureHelp(helpConfig),
+  new Command82("import").description("merge a dotenv file into the environment").argument("<file>", "dotenv file to read").configureHelp(helpConfig),
   "local"
 ).action(
   (file, raw) => runCommand(
@@ -9305,22 +9683,22 @@ var envImport = addTargetOptions(
           const incoming = read(source, file);
           const keys = Object.keys(incoming);
           if (keys.length === 0) return;
-          p47.log.step(`Importing ${keys.length} variable(s) from ${pc22.cyan(file)}`);
+          p49.log.step(`Importing ${keys.length} variable(s) from ${pc22.cyan(file)}`);
           editLocalEnv(
             ctx.envFile,
             (content) => keys.reduce((acc, key) => upsertEnvVar(acc, key, incoming[key]), content)
           );
-          p47.log.success(`${keys.length} variable(s) updated ${pc22.dim("(local)")}`);
+          p49.log.success(`${keys.length} variable(s) updated ${pc22.dim("(local)")}`);
           await applyLocalEnvChange(ctx, keys);
         },
         remote: async (ctx) => {
           const incoming = read(resolve(file), file);
           const keys = Object.keys(incoming);
           if (keys.length === 0) return;
-          p47.log.step(`Importing ${keys.length} variable(s) from ${pc22.cyan(file)}`);
+          p49.log.step(`Importing ${keys.length} variable(s) from ${pc22.cyan(file)}`);
           const existing = await readRemoteEnv(ctx.session, ctx.instance);
           await writeRemoteEnv(ctx.session, ctx.instance, { ...existing, ...incoming });
-          p47.log.success(`${keys.length} variable(s) updated ${pc22.dim(`(${ctx.targetName})`)}`);
+          p49.log.success(`${keys.length} variable(s) updated ${pc22.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, keys);
         }
       },
@@ -9330,24 +9708,24 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path40.resolve(process31.cwd(), file);
+  return path40.resolve(process34.cwd(), file);
 }
 function read(resolved, shown) {
   if (!fs38.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.`);
+  if (Object.keys(incoming).length === 0) p49.log.info(`${shown} has no variables to import.`);
   return incoming;
 }
 
 // src/commands/env.ts
-var env = new Command82("env").description("manage environment variables, locally or on a target").configureHelp(helpConfig).addCommand(envList).addCommand(envSet).addCommand(envUnset).addCommand(envImport);
+var env = new Command83("env").description("manage environment variables, locally or on a target").configureHelp(helpConfig).addCommand(envList).addCommand(envSet).addCommand(envUnset).addCommand(envImport);
 
 // src/commands/status.ts
-import { Command as Command83 } from "commander";
-import * as p48 from "@clack/prompts";
+import { Command as Command84 } from "commander";
+import * as p50 from "@clack/prompts";
 import pc23 from "picocolors";
 var status = addTargetOptions(
-  new Command83("status").description("show what is deployed").configureHelp(helpConfig),
+  new Command84("status").description("show what is deployed").configureHelp(helpConfig),
   "production"
 ).option("--all", "show every app on the server, not just this project").option("--json", "print raw JSON").action(
   (raw) => runCommand(async () => {
@@ -9378,11 +9756,11 @@ function report2(states, json) {
     return;
   }
   if (states.length === 0) {
-    p48.log.info("Nothing is deployed here yet.");
+    p50.log.info("Nothing is deployed here yet.");
     return;
   }
   for (const state of states) {
-    p48.log.info(describe2(state));
+    p50.log.info(describe2(state));
   }
 }
 function describe2(state) {
@@ -9406,12 +9784,12 @@ function describe2(state) {
 }
 
 // src/commands/rollback.ts
-import { Command as Command84 } from "commander";
-import * as p49 from "@clack/prompts";
+import { Command as Command85 } from "commander";
+import * as p51 from "@clack/prompts";
 import pc24 from "picocolors";
 var rollback = addLockWaitOption(
   addTargetOptions(
-    new Command84("rollback").description("put the previous release back").configureHelp(helpConfig),
+    new Command85("rollback").description("put the previous release back").configureHelp(helpConfig),
     "production"
   )
 ).option("--to <release>", "roll back to a specific release instead of the previous one").action(
@@ -9421,7 +9799,7 @@ var rollback = addLockWaitOption(
       raw,
       {
         remote: async (ctx) => {
-          p49.log.step(
+          p51.log.step(
             `Rolling back ${pc24.cyan(ctx.appName)} ${pc24.dim(`(${ctx.targetName})`)} on ${ctx.server}`
           );
           const result = await runServerScript(
@@ -9436,7 +9814,7 @@ var rollback = addLockWaitOption(
               stream: true
             }
           );
-          p49.log.success(
+          p51.log.success(
             `Rolled back to ${pc24.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc24.dim(`(was ${result.from})`)}` : "")
           );
         }
@@ -9450,9 +9828,9 @@ var rollback = addLockWaitOption(
 );
 
 // src/commands/logs.ts
-import { Command as Command85 } from "commander";
+import { Command as Command86 } from "commander";
 var logs = addTargetOptions(
-  new Command85("logs").description("tail the logs of a deployed app").configureHelp(helpConfig),
+  new Command86("logs").description("tail the logs of a deployed app").configureHelp(helpConfig),
   "production"
 ).option("-f, --follow", "keep streaming new output").option("-n, --lines <count>", "how many lines of history to show", "100").option("--pocketbase", "show the PocketBase service instead of the app").action(
   (raw) => runCommand(async () => {
@@ -9486,16 +9864,16 @@ var logs = addTargetOptions(
 );
 
 // src/commands/admin.ts
-import { Command as Command87 } from "commander";
+import { Command as Command88 } from "commander";
 
 // src/commands/admin/create.ts
-import process32 from "node:process";
-import { Command as Command86 } from "commander";
-import * as p50 from "@clack/prompts";
+import process35 from "node:process";
+import { Command as Command87 } from "commander";
+import * as p52 from "@clack/prompts";
 import pc25 from "picocolors";
 var MIN_PASSWORD = 10;
 var adminCreate = addTargetOptions(
-  new Command86("create").description("create a login for the admin panel").argument("[email]", "email to sign in with \u2014 prompted for when omitted").configureHelp(helpConfig),
+  new Command87("create").description("create a login for the admin panel").argument("[email]", "email to sign in with \u2014 prompted for when omitted").configureHelp(helpConfig),
   "local"
 ).action(
   (email3, raw) => runCommand(
@@ -9523,7 +9901,7 @@ var adminCreate = addTargetOptions(
             const metadata = getPocketbaseMetadata(ctx.workspaceRootDir);
             if (metadata) signIn = `http://${metadata.viteHost}:${metadata.vitePort}`;
           }
-          p50.log.info(
+          p52.log.info(
             signIn ? `Sign in at ${pc25.cyan(`${signIn}/admin`)}` : `Sign in at ${pc25.cyan("/admin")} once ${pc25.cyan("vela dev")} is running.`
           );
         },
@@ -9537,7 +9915,7 @@ var adminCreate = addTargetOptions(
             (pb) => upsertSuperuser(pb, address, password11)
           );
           const base2 = state?.domain ? `https://${state.domain.split(",")[0].trim()}` : "";
-          p50.log.info(
+          p52.log.info(
             base2 ? `Sign in at ${pc25.cyan(`${base2}/admin`)}` : `Sign in at ${pc25.cyan("/admin")} once a domain is configured for this target.`
           );
         }
@@ -9550,20 +9928,20 @@ var adminCreate = addTargetOptions(
 async function upsertSuperuser(pb, email3, password11) {
   const existing = await findSuperuser(pb, email3);
   if (existing) {
-    const confirmed = await p50.confirm({
+    const confirmed = await p52.confirm({
       message: `${email3} already has an account, update its password?`,
       initialValue: false
     });
-    if (p50.isCancel(confirmed) || !confirmed) {
-      p50.cancel("Operation cancelled.");
-      process32.exit(0);
+    if (p52.isCancel(confirmed) || !confirmed) {
+      p52.cancel("Operation cancelled.");
+      process35.exit(0);
     }
     await pb.collection("_superusers").update(existing, { password: password11, passwordConfirm: password11 });
-    p50.log.success(`Password updated for ${pc25.cyan(email3)}, you can sign in now`);
+    p52.log.success(`Password updated for ${pc25.cyan(email3)}, you can sign in now`);
     return;
   }
   await pb.collection("_superusers").create({ email: email3, password: password11, passwordConfirm: password11 });
-  p50.log.success(`${pc25.cyan(email3)} can now sign in`);
+  p52.log.success(`${pc25.cyan(email3)} can now sign in`);
 }
 async function findSuperuser(pb, email3) {
   try {
@@ -9574,47 +9952,47 @@ async function findSuperuser(pb, email3) {
   }
 }
 async function promptEmail() {
-  const value = await p50.text({
+  const value = await p52.text({
     message: "Email to sign in with",
     validate: (input) => input?.includes("@") ? void 0 : "An email address is required"
   });
-  if (p50.isCancel(value)) {
-    p50.cancel("Operation cancelled.");
-    process32.exit(0);
+  if (p52.isCancel(value)) {
+    p52.cancel("Operation cancelled.");
+    process35.exit(0);
   }
   return value.trim();
 }
 async function promptPassword2() {
-  const value = await p50.password({
+  const value = await p52.password({
     message: "Password",
     validate: (input) => (input?.length ?? 0) >= MIN_PASSWORD ? void 0 : `At least ${MIN_PASSWORD} characters is required`
   });
-  if (p50.isCancel(value)) {
-    p50.cancel("Operation cancelled.");
-    process32.exit(0);
+  if (p52.isCancel(value)) {
+    p52.cancel("Operation cancelled.");
+    process35.exit(0);
   }
-  const again = await p50.password({
+  const again = await p52.password({
     message: "Password again",
     validate: (input) => input === value ? void 0 : "The two do not match"
   });
-  if (p50.isCancel(again)) {
-    p50.cancel("Operation cancelled.");
-    process32.exit(0);
+  if (p52.isCancel(again)) {
+    p52.cancel("Operation cancelled.");
+    process35.exit(0);
   }
   return value;
 }
 
 // src/commands/admin.ts
-var admin = new Command87("admin").description("manage admin panel logins").configureHelp(helpConfig).addCommand(adminCreate);
+var admin = new Command88("admin").description("manage admin panel logins").configureHelp(helpConfig).addCommand(adminCreate);
 
 // src/commands/backup.ts
-import { Command as Command93 } from "commander";
+import { Command as Command94 } from "commander";
 
 // src/commands/backup/create.ts
 import fs39 from "node:fs";
 import path41 from "node:path";
-import { Command as Command88 } from "commander";
-import * as p51 from "@clack/prompts";
+import { Command as Command89 } from "commander";
+import * as p53 from "@clack/prompts";
 import pc26 from "picocolors";
 
 // src/lib/backups.ts
@@ -9702,7 +10080,7 @@ async function writeSchedule(pb, cron, maxKeep) {
 // src/commands/backup/create.ts
 var DEFAULT_BACKUP_DIR = "backups";
 var backupCreate = addTargetOptions(
-  new Command88("create").description("take a backup of the database and uploads").argument("[name]", "name for the archive \u2014 generated when omitted").option("-o, --output <dir>", "where to save the archive", DEFAULT_BACKUP_DIR).option("--no-download", "leave the archive on the server").configureHelp(helpConfig),
+  new Command89("create").description("take a backup of the database and uploads").argument("[name]", "name for the archive \u2014 generated when omitted").option("-o, --output <dir>", "where to save the archive", DEFAULT_BACKUP_DIR).option("--no-download", "leave the archive on the server").configureHelp(helpConfig),
   "production"
 ).action(
   (name, raw) => runCommand(() => {
@@ -9718,7 +10096,7 @@ Backup names are lowercase letters, digits, ${pc26.cyan("-")} and ${pc26.cyan("_
       }
       const storage = await readStorageSettings(ctx.pb);
       if (storage.s3Enabled) {
-        p51.log.warn(
+        p53.log.warn(
           `Uploads are stored in S3, so this archive holds the database only.
 
 PocketBase leaves ${pc26.cyan("storage/")} out of a backup whenever S3 is on.
@@ -9726,7 +10104,7 @@ Your bucket's own versioning is what protects the uploaded files.`
         );
       }
       if (ctx.session) await checkpointAppDatabases(ctx.session, ctx.instance);
-      const spinner7 = p51.spinner();
+      const spinner7 = p53.spinner();
       spinner7.start(`Backing up ${ctx.targetName}`);
       try {
         await createBackup(ctx.pb, key);
@@ -9773,7 +10151,7 @@ async function download(ctx, key, outputDir) {
     fs39.copyFileSync(path41.join(ctx.workspaceRootDir, "data", "backups", key), destination);
     return path41.relative(ctx.workspaceRootDir, destination);
   }
-  const spinner7 = p51.spinner();
+  const spinner7 = p53.spinner();
   spinner7.start(`Downloading ${key}`);
   try {
     await ctx.session.download(remotePaths.backup(ctx.instance, key), destination);
@@ -9786,18 +10164,18 @@ async function download(ctx, key, outputDir) {
 }
 
 // src/commands/backup/list.ts
-import { Command as Command89 } from "commander";
-import * as p52 from "@clack/prompts";
+import { Command as Command90 } from "commander";
+import * as p54 from "@clack/prompts";
 import pc27 from "picocolors";
 var backupList = addTargetOptions(
-  new Command89("list").description("list the backups on a target").configureHelp(helpConfig),
+  new Command90("list").description("list the backups on a target").configureHelp(helpConfig),
   "production"
 ).action(
   (raw) => runCommand(
     () => withBackupTarget(raw, "backup list", async (ctx) => {
       const backups = await listBackups(ctx.pb);
       if (backups.length === 0) {
-        p52.log.info(
+        p54.log.info(
           `${pc27.cyan(ctx.targetName)} has no backups yet.
 
 Take one with ${pc27.cyan("vela backup create")}.`
@@ -9805,7 +10183,7 @@ Take one with ${pc27.cyan("vela backup create")}.`
         return;
       }
       const width = Math.max(...backups.map((b) => b.key.length));
-      p52.log.message(
+      p54.log.message(
         backups.map(
           (b) => `${b.key.padEnd(width)}  ${pc27.dim(formatBytes(b.size).padStart(8))}  ${pc27.dim(b.modified)}`
         ).join("\n")
@@ -9818,11 +10196,11 @@ Take one with ${pc27.cyan("vela backup create")}.`
 // src/commands/backup/download.ts
 import fs40 from "node:fs";
 import path42 from "node:path";
-import { Command as Command90 } from "commander";
-import * as p53 from "@clack/prompts";
+import { Command as Command91 } from "commander";
+import * as p55 from "@clack/prompts";
 import pc28 from "picocolors";
 var backupDownload = addTargetOptions(
-  new Command90("download").description("save a backup off the server").argument("<key>", "archive to download, as shown by `vela backup list`").option("-o, --output <dir>", "where to save the archive", DEFAULT_BACKUP_DIR).configureHelp(helpConfig),
+  new Command91("download").description("save a backup off the server").argument("<key>", "archive to download, as shown by `vela backup list`").option("-o, --output <dir>", "where to save the archive", DEFAULT_BACKUP_DIR).configureHelp(helpConfig),
   "production"
 ).action(
   (key, raw) => runCommand(() => {
@@ -9850,7 +10228,7 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
       if (!ctx.session) {
         fs40.copyFileSync(path42.join(ctx.workspaceRootDir, "data", "backups", key), destination);
       } else {
-        const spinner7 = p53.spinner();
+        const spinner7 = p55.spinner();
         spinner7.start(`Downloading ${key} (${formatBytes(found.size)})`);
         try {
           await ctx.session.download(remotePaths.backup(ctx.instance, key), destination);
@@ -9869,12 +10247,12 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
 );
 
 // src/commands/backup/delete.ts
-import process33 from "node:process";
-import { Command as Command91 } from "commander";
-import * as p54 from "@clack/prompts";
+import process36 from "node:process";
+import { Command as Command92 } from "commander";
+import * as p56 from "@clack/prompts";
 import pc29 from "picocolors";
 var backupDelete = addTargetOptions(
-  new Command91("delete").description("remove a backup from a target").argument("<key>", "archive to delete, as shown by `vela backup list`").option("-y, --yes", "skip the confirmation").configureHelp(helpConfig),
+  new Command92("delete").description("remove a backup from a target").argument("<key>", "archive to delete, as shown by `vela backup list`").option("-y, --yes", "skip the confirmation").configureHelp(helpConfig),
   "production"
 ).action(
   (key, raw) => runCommand(() => {
@@ -9889,13 +10267,13 @@ Run ${pc29.cyan("vela backup list")} to see what it does have.`
         );
       }
       if (!options.yes) {
-        const confirmed = await p54.confirm({
+        const confirmed = await p56.confirm({
           message: `Delete ${key} (${formatBytes(found.size)}) from ${ctx.targetName}?`,
           initialValue: false
         });
-        if (p54.isCancel(confirmed) || !confirmed) {
-          p54.cancel("Operation cancelled.");
-          process33.exit(0);
+        if (p56.isCancel(confirmed) || !confirmed) {
+          p56.cancel("Operation cancelled.");
+          process36.exit(0);
         }
       }
       await ctx.pb.backups.delete(key);
@@ -9905,12 +10283,12 @@ Run ${pc29.cyan("vela backup list")} to see what it does have.`
 );
 
 // src/commands/backup/schedule.ts
-import { Command as Command92 } from "commander";
-import * as p55 from "@clack/prompts";
+import { Command as Command93 } from "commander";
+import * as p57 from "@clack/prompts";
 import pc30 from "picocolors";
 var DEFAULT_KEEP = 7;
 var backupSchedule = addTargetOptions(
-  new Command92("schedule").description("back up automatically on a schedule").argument("[cron]", "when to run, as a cron expression \u2014 shows the current one when omitted").option("--keep <n>", "how many scheduled archives to keep", String(DEFAULT_KEEP)).option("--off", "stop backing up automatically").configureHelp(helpConfig),
+  new Command93("schedule").description("back up automatically on a schedule").argument("[cron]", "when to run, as a cron expression \u2014 shows the current one when omitted").option("--keep <n>", "how many scheduled archives to keep", String(DEFAULT_KEEP)).option("--off", "stop backing up automatically").configureHelp(helpConfig),
   "production"
 ).action(
   (cron, raw) => runCommand(() => {
@@ -9923,7 +10301,7 @@ var backupSchedule = addTargetOptions(
       }
       if (!cron) {
         const current = await readSchedule(ctx.pb);
-        p55.log.info(
+        p57.log.info(
           current.cron ? `${ctx.targetName} backs up on ${pc30.cyan(current.cron)}, keeping ${current.maxKeep}.` : `${ctx.targetName} has no backup schedule.
 
 Set one with ${pc30.cyan('vela backup schedule "0 3 * * *"')}.`
@@ -9954,18 +10332,18 @@ Set one with ${pc30.cyan('vela backup schedule "0 3 * * *"')}.`
 );
 
 // src/commands/backup.ts
-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);
+var backup = new Command94("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 fs41 from "node:fs";
 import path43 from "node:path";
-import process34 from "node:process";
-import { Command as Command94 } from "commander";
-import * as p56 from "@clack/prompts";
+import process37 from "node:process";
+import { Command as Command95 } from "commander";
+import * as p58 from "@clack/prompts";
 import pc31 from "picocolors";
 var restore = addLockWaitOption(
   addTargetOptions(
-    new Command94("restore").description("replace a deployment\u2019s database and uploads from a backup").argument("[source]", "a backup key on the target, or a path to a local archive").configureHelp(helpConfig),
+    new Command95("restore").description("replace a deployment\u2019s database and uploads from a backup").argument("[source]", "a backup key on the target, or a path to a local archive").configureHelp(helpConfig),
     "production"
   )
 ).option("-y, --yes", "skip the confirmation prompt").option("--no-migrate", "do not run migrations against the restored database").option("--keep-previous <n>", "how many replaced databases to keep", "1").action(
@@ -10002,18 +10380,18 @@ var restore = addLockWaitOption(
             ],
             stream: true
           });
-          p56.log.success(
+          p58.log.success(
             `Restored ${pc31.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${pc31.cyan(
               local ? path43.basename(local) : key
             )}.`
           );
           if (result?.storageCarriedOver) {
-            p56.log.info(
+            p58.log.info(
               "The archive held no uploads, so the files already on the server were kept."
             );
           }
           if (result?.previousDataDir) {
-            p56.log.info(
+            p58.log.info(
               `The database this replaced is at ${pc31.cyan(result.previousDataDir)}.
 
 It is the only way back. Remove it once you are satisfied with the restore.`
@@ -10054,7 +10432,7 @@ Run ${pc31.cyan("vela backup list")} to see what it does have.`
 Take one with ${pc31.cyan("vela backup create")}, or pass the path to an archive on this machine.`
     );
   }
-  const chosen = await p56.select({
+  const chosen = await p58.select({
     message: `Which backup should ${ctx.targetName} be restored from?`,
     options: backups.map((b) => ({
       value: b.key,
@@ -10062,16 +10440,16 @@ Take one with ${pc31.cyan("vela backup create")}, or pass the path to an archive
       hint: `${formatBytes(b.size)}, ${b.modified}`
     }))
   });
-  if (p56.isCancel(chosen)) {
-    p56.cancel("Operation cancelled.");
-    process34.exit(0);
+  if (p58.isCancel(chosen)) {
+    p58.cancel("Operation cancelled.");
+    process37.exit(0);
   }
   return chosen;
 }
 async function stage(ctx, file) {
   const dir = remotePaths.restoreStage(ctx.instance);
   const remote = `${dir}/${path43.basename(file)}`;
-  const spinner7 = p56.spinner();
+  const spinner7 = p58.spinner();
   spinner7.start(`Uploading ${path43.basename(file)}`);
   try {
     await ctx.session.script(`mkdir -p "$1"`, { args: [dir] });
@@ -10086,29 +10464,29 @@ async function stage(ctx, file) {
 async function confirm13(appName, targetName, envTag, from) {
   const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path43.basename(from))}`;
   if (isProd(envTag)) {
-    const answer = await p56.text({
+    const answer = await p58.text({
       message: `This replaces the database and uploads of ${what}. Type the app name to confirm`,
       validate: (value) => value === appName ? void 0 : `Type ${appName} to confirm`
     });
-    if (p56.isCancel(answer)) {
-      p56.cancel("Operation cancelled.");
-      process34.exit(0);
+    if (p58.isCancel(answer)) {
+      p58.cancel("Operation cancelled.");
+      process37.exit(0);
     }
     return;
   }
-  const ok = await p56.confirm({
+  const ok = await p58.confirm({
     message: `Replace the database and uploads of ${what}?`,
     initialValue: false
   });
-  if (p56.isCancel(ok) || !ok) {
-    p56.cancel("Operation cancelled.");
-    process34.exit(0);
+  if (p58.isCancel(ok) || !ok) {
+    p58.cancel("Operation cancelled.");
+    process37.exit(0);
   }
 }
 
 // src/commands/targets.ts
-import { Command as Command95 } from "commander";
-import * as p57 from "@clack/prompts";
+import { Command as Command96 } from "commander";
+import * as p59 from "@clack/prompts";
 import pc32 from "picocolors";
 import * as v9 from "valibot";
 var OptionsSchema4 = v9.object({
@@ -10117,7 +10495,7 @@ var OptionsSchema4 = v9.object({
   offline: v9.optional(v9.boolean())
 });
 var targets = addSshOptions(
-  new Command95("targets").description("list the targets this project can deploy to").configureHelp(helpConfig)
+  new Command96("targets").description("list the targets this project can deploy to").configureHelp(helpConfig)
 ).option("--json", "print raw JSON").option("--offline", "skip connecting to servers").action(
   (raw) => runCommand(async () => {
     const options = parseOptions(OptionsSchema4, raw);
@@ -10183,11 +10561,11 @@ function report3(rows, offline) {
   const lines = rows.map(
     (row) => `${row.kind === "local" ? pc32.dim(row.target.padEnd(target)) : pc32.cyan(row.target.padEnd(target))}  ${row.server.padEnd(server)}  ${row.domain.padEnd(domain)}  ${row.release}`
   );
-  p57.log.info(`${pc32.dim(header)}
+  p59.log.info(`${pc32.dim(header)}
 ${lines.join("\n")}`);
   const unreachable = rows.filter((row) => row.kind === "remote" && !row.reachable);
   if (!offline && unreachable.length > 0) {
-    p57.log.warn(
+    p59.log.warn(
       `Could not reach ${unreachable.map((row) => row.server).join(", ")}.
 Release and domain are shown from what this project recorded.`
     );
@@ -10196,16 +10574,16 @@ Release and domain are shown from what this project recorded.`
 
 // src/commands/test.ts
 import path44 from "node:path";
-import process35 from "node:process";
-import { Command as Command96 } from "commander";
+import process38 from "node:process";
+import { Command as Command97 } from "commander";
 import PocketBase6 from "pocketbase";
 import pc33 from "picocolors";
 import { x as x5 } from "tinyexec";
 import { detect as detect8 } from "package-manager-detector";
 import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
 import fs42 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 = process35.cwd();
+var testServer = new Command97("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
+  const cwd = process38.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password11 = "password";
   const testDataDir = path44.join(cwd, "test-data");
@@ -10220,11 +10598,11 @@ var testServer = new Command96("test:server").description("run server tests").al
     email: email3,
     password: password11
   });
-  process35.env.POCKETBASE_URL = url;
-  process35.env.POCKETBASE_SUPERUSER_EMAIL = email3;
-  process35.env.POCKETBASE_SUPERUSER_PASSWORD = password11;
-  process35.env.VELA_DATA_DIR = testDataDir;
-  process35.env.TEST = "true";
+  process38.env.POCKETBASE_URL = url;
+  process38.env.POCKETBASE_SUPERUSER_EMAIL = email3;
+  process38.env.POCKETBASE_SUPERUSER_PASSWORD = password11;
+  process38.env.VELA_DATA_DIR = testDataDir;
+  process38.env.TEST = "true";
   console.log(`${pc33.greenBright("\u2713")} Created test database`);
   let vite;
   let cleanedUp = false;
@@ -10243,12 +10621,12 @@ var testServer = new Command96("test:server").description("run server tests").al
   const fail = async (message) => {
     console.error(`${pc33.redBright("\u2717")} ${message}`);
     await cleanup();
-    process35.exit(1);
+    process38.exit(1);
   };
-  process35.on("exit", cleanupSync);
-  process35.on("SIGINT", () => {
+  process38.on("exit", cleanupSync);
+  process38.on("SIGINT", () => {
     cleanupSync();
-    process35.exit(130);
+    process38.exit(130);
   });
   const pb = new PocketBase6(url);
   try {
@@ -10276,7 +10654,7 @@ var testServer = new Command96("test:server").description("run server tests").al
   });
   const vitePort = await findFreePort();
   await vite.listen(vitePort);
-  process35.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
+  process38.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
   console.log(`${pc33.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
   console.log(`${pc33.greenBright("\u2713")} Started PocketBase: ${url}`);
   const extraArgs = (cmd.parent?.args ?? []).slice(1);
@@ -10295,12 +10673,12 @@ var testServer = new Command96("test:server").description("run server tests").al
     const resolvedArgs = resolved.args.slice();
     if (pm === "npm") resolvedArgs.unshift("--yes");
     const result = await x5(resolved.command, resolvedArgs, {
-      nodeOptions: { cwd, stdio: "inherit", env: { ...process35.env, CI: "1" } }
+      nodeOptions: { cwd, stdio: "inherit", env: { ...process38.env, CI: "1" } }
     });
-    process35.exitCode = result.exitCode ?? 1;
+    process38.exitCode = result.exitCode ?? 1;
   } catch (e) {
     console.error(`${pc33.redBright("\u2717")} ${e.message}`);
-    process35.exitCode = 1;
+    process38.exitCode = 1;
   } finally {
     await cleanup();
   }
@@ -10333,7 +10711,7 @@ function stubPagesPlugin() {
 // src/commands/routes.ts
 import fs43 from "node:fs";
 import path45 from "node:path";
-import { Command as Command97 } from "commander";
+import { Command as Command98 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -10344,7 +10722,7 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
   "HEAD",
   "fallback"
 ]);
-var routes = new Command97("routes").description("list routes").configureHelp(helpConfig).action(async () => {
+var routes = new Command98("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
   const routesRoot = path45.join(workspaceRootDir, routesDir);
   const found = walk(routesRoot, routesRoot).filter((r) => r.methods.length > 0);
@@ -10419,13 +10797,13 @@ function printTable(routes2) {
 }
 
 // src/commands/i18n.ts
-import process36 from "node:process";
-import { Command as Command98 } from "commander";
+import process39 from "node:process";
+import { Command as Command99 } from "commander";
 import { x as x6 } from "tinyexec";
 import { detect as detect9 } from "package-manager-detector";
 import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
 async function runWuchale(extraArgs) {
-  const cwd = process36.cwd();
+  const cwd = process39.cwd();
   const pm = (await detect9({ cwd }))?.name ?? "npm";
   const resolved = resolveCommand8(pm, "execute", ["wuchale", ...extraArgs]);
   const args = resolved.args.slice();
@@ -10435,11 +10813,11 @@ async function runWuchale(extraArgs) {
     throwOnError: true
   });
 }
-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(extract2, { isDefault: true }).addCommand(watch).addCommand(status2).addCommand(clean);
+var extract2 = new Command99("extract").description("extract translatable strings").configureHelp(helpConfig).action(() => runWuchale([]));
+var watch = new Command99("watch").description("watch and extract translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--watch"]));
+var status2 = new Command99("status").description("show i18n status").configureHelp(helpConfig).action(() => runWuchale(["status"]));
+var clean = new Command99("clean").description("clean unused translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--clean"]));
+var i18n3 = new Command99("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");
@@ -10448,21 +10826,21 @@ var oauth = stubCommand("oauth", "configure OAuth providers");
 var schemas = stubCommand("schemas", "manage database schemas");
 
 // src/commands/cms.ts
-import { Command as Command103 } from "commander";
+import { Command as Command104 } from "commander";
 
 // src/commands/cms/editor.ts
-import { Command as Command102 } from "commander";
+import { Command as Command103 } from "commander";
 
 // src/commands/cms/editor/add.ts
 import { randomBytes } from "node:crypto";
-import { Command as Command99 } from "commander";
-import * as p58 from "@clack/prompts";
+import { Command as Command100 } from "commander";
+import * as p60 from "@clack/prompts";
 import pc35 from "picocolors";
 
 // src/lib/cms-backend.ts
 import { createRequire as createRequire3 } from "node:module";
 import path46 from "node:path";
-import process37 from "node:process";
+import process40 from "node:process";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import pc34 from "picocolors";
 var DEFAULT_PROJECT = "default";
@@ -10479,7 +10857,7 @@ Run ${pc34.cyan("vela enable cms")} first.`
   }
   return await import(pathToFileURL3(entry).href);
 }
-async function withCmsBackend(fn, cwd = process37.cwd()) {
+async function withCmsBackend(fn, cwd = process40.cwd()) {
   const root = findWorkspaceRoot(cwd);
   if (!root) {
     throw new Error("Could not find workspace root (no package.json found)");
@@ -10498,7 +10876,7 @@ async function withCmsBackend(fn, cwd = process37.cwd()) {
 }
 
 // src/commands/cms/editor/add.ts
-var editorAdd = new Command99("add").description("create an editor who can sign in to the admin bar").argument("<email>", "email the editor signs in with").option("--password <password>", "password to set \u2014 generated and shown once when omitted").option("--project <id>", "project the editor may edit", DEFAULT_PROJECT).configureHelp(helpConfig).action(
+var editorAdd = new Command100("add").description("create an editor who can sign in to the admin bar").argument("<email>", "email the editor signs in with").option("--password <password>", "password to set \u2014 generated and shown once when omitted").option("--project <id>", "project the editor may edit", DEFAULT_PROJECT).configureHelp(helpConfig).action(
   (email3, options) => runCommand(async () => {
     const generated = options.password === void 0;
     const password11 = options.password ?? randomBytes(12).toString("base64url");
@@ -10509,31 +10887,31 @@ var editorAdd = new Command99("add").description("create an editor who can sign
     if (generated) {
       lines.push("", `Password: ${pc35.bold(password11)}`, "", "It is shown once; copy it now.");
     }
-    p58.log.success(lines.join("\n"));
-    p58.log.info(
+    p60.log.success(lines.join("\n"));
+    p60.log.info(
       `Run ${pc35.cyan("vela dev")}, open any page with ${pc35.cyan("?edit")} on the URL (or press ${pc35.cyan("Ctrl+E")}), and sign in.`
     );
   }, "Failed to add the editor.")
 );
 
 // src/commands/cms/editor/password.ts
-import { Command as Command100 } from "commander";
-import * as p59 from "@clack/prompts";
+import { Command as Command101 } from "commander";
+import * as p61 from "@clack/prompts";
 import pc36 from "picocolors";
-var editorPassword = new Command100("password").description("set an editor's password").argument("<email>", "email of the editor").argument("<password>", "new password").configureHelp(helpConfig).action(
+var editorPassword = new Command101("password").description("set an editor's password").argument("<email>", "email of the editor").argument("<password>", "new password").configureHelp(helpConfig).action(
   (email3, password11) => runCommand(async () => {
     await withCmsBackend((cms3) => cms3.editors.setPassword(email3, password11));
-    p59.log.success(
+    p61.log.success(
       `Updated the password for ${pc36.cyan(email3)}. Existing sessions were signed out.`
     );
   }, "Failed to set the password.")
 );
 
 // src/commands/cms/editor/list.ts
-import { Command as Command101 } from "commander";
-import * as p60 from "@clack/prompts";
+import { Command as Command102 } from "commander";
+import * as p62 from "@clack/prompts";
 import pc37 from "picocolors";
-var editorList = new Command101("list").description("list editors and the projects they may edit").configureHelp(helpConfig).action(
+var editorList = new Command102("list").description("list editors and the projects they may edit").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const rows = await withCmsBackend(
       async (cms3) => cms3.editors.list().map((editor2) => ({
@@ -10542,11 +10920,11 @@ var editorList = new Command101("list").description("list editors and the projec
       }))
     );
     if (rows.length === 0) {
-      p60.log.info(`No editors yet. Add one with ${pc37.cyan("vela cms editor add <email>")}.`);
+      p62.log.info(`No editors yet. Add one with ${pc37.cyan("vela cms editor add <email>")}.`);
       return;
     }
     const width = Math.max(...rows.map((row) => row.email.length));
-    p60.log.info(
+    p62.log.info(
       `Editors
 
 ` + rows.map(
@@ -10557,10 +10935,10 @@ var editorList = new Command101("list").description("list editors and the projec
 );
 
 // src/commands/cms/editor.ts
-var editor = new Command102("editor").description("manage who can sign in to the admin bar").configureHelp(helpConfig).addCommand(editorAdd).addCommand(editorPassword).addCommand(editorList);
+var editor = new Command103("editor").description("manage who can sign in to the admin bar").configureHelp(helpConfig).addCommand(editorAdd).addCommand(editorPassword).addCommand(editorList);
 
 // src/commands/cms.ts
-var cms2 = new Command103("cms").description("manage the CMS").configureHelp(helpConfig).addCommand(editor);
+var cms2 = new Command104("cms").description("manage the CMS").configureHelp(helpConfig).addCommand(editor);
 
 // src/program.ts
 var NO_BACKEND_COMMMANDS = /* @__PURE__ */ new Set([
@@ -10578,6 +10956,8 @@ var NO_BACKEND_COMMMANDS = /* @__PURE__ */ new Set([
   "generate form",
   // The CMS keeps its own SQLite database and editors; PocketBase is never involved.
   "enable cms",
+  // Analytics only touches the root layout and .env; it must work on static sites.
+  "enable analytics",
   "cms",
   // Server commands talk to a VPS over SSH, never to the local database.
   "provision",
@@ -10598,10 +10978,10 @@ var NO_BACKEND_COMMMANDS = /* @__PURE__ */ new Set([
 ]);
 var BACKEND_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["dev", "build", "preview", "deploy"]);
 var SELF_CREDENTIALED_COMMANDS = /* @__PURE__ */ new Set(["test:server"]);
-var program = new Command104().name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version").configureHelp(helpConfig);
+var program = new Command105().name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version").configureHelp(helpConfig);
 program.hook("preAction", (_thisCommand, actionCommand) => {
   if (isStub(actionCommand)) return;
-  const envRoot = findWorkspaceRoot() ?? process38.cwd();
+  const envRoot = findWorkspaceRoot() ?? process41.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
   const path47 = getCommandPath(actionCommand);
   if (NO_BACKEND_COMMMANDS.has(path47)) return;
@@ -10609,20 +10989,20 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
-    p61.log.error(
+    p63.log.error(
       `${pc38.cyan(`vela ${path47}`)} needs a backend, and this project does not have one.
 
 Static projects have no database to talk to.
 
 To add a backend to this project, run ${pc38.cyan("vela bless")}.`
     );
-    p61.log.message();
-    p61.cancel("Operation failed.");
-    process38.exit(1);
+    p63.log.message();
+    p63.cancel("Operation failed.");
+    process41.exit(1);
   }
   if (SELF_CREDENTIALED_COMMANDS.has(path47)) return;
-  if (!process38.env.POCKETBASE_SUPERUSER_EMAIL || !process38.env.POCKETBASE_SUPERUSER_PASSWORD) {
-    p61.log.error(
+  if (!process41.env.POCKETBASE_SUPERUSER_EMAIL || !process41.env.POCKETBASE_SUPERUSER_PASSWORD) {
+    p63.log.error(
       `PocketBase superuser credentials are required.
 
 Set ${pc38.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc38.cyan("POCKETBASE_SUPERUSER_PASSWORD")} in your .env file.
@@ -10630,9 +11010,9 @@ Set ${pc38.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc38.cyan("POCKETBASE_SUPER
 To set up a new project, run ${pc38.cyan("vela create")}.
 To set up an existing project, run ${pc38.cyan("vela bless")}.`
     );
-    p61.log.message();
-    p61.cancel("Operation failed.");
-    process38.exit(1);
+    p63.log.message();
+    p63.cancel("Operation failed.");
+    process41.exit(1);
   }
 });
 function getCommandPath(cmd) {
@@ -10686,5 +11066,5 @@ for (const command of [
 }
 
 // src/bin.ts
-program.parse(normalizeArgv(process39.argv.slice(2)), { from: "user" });
+program.parse(normalizeArgv(process42.argv.slice(2)), { from: "user" });
 //# sourceMappingURL=bin.js.map