vela 0.10.2 → 0.10.3

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import process24 from "node:process";
+import process31 from "node:process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.10.2",
+  version: "0.10.3",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -152,15 +152,15 @@ function isDelegatable(argv2) {
   return first === void 0 || !NO_DELEGATE_COMMANDS.has(first);
 }
 function delegateToLocalCli(opts) {
-  const env = opts.env ?? process2.env;
-  if (env[NO_DELEGATE_ENV]) return null;
+  const env2 = opts.env ?? process2.env;
+  if (env2[NO_DELEGATE_ENV]) return null;
   const argv2 = opts.argv ?? process2.argv.slice(2);
   if (!isDelegatable(argv2)) return null;
   const local = findLocalCli(opts.cwd ?? process2.cwd(), opts.selfPath);
   if (!local || local.version === opts.selfVersion) return null;
   const result = spawnSync(process2.execPath, [local.binPath, ...argv2], {
     stdio: "inherit",
-    env: { ...env, [NO_DELEGATE_ENV]: "1" }
+    env: { ...env2, [NO_DELEGATE_ENV]: "1" }
   });
   if (result.error) return null;
   if (result.signal) return 1;
@@ -168,11 +168,12 @@ function delegateToLocalCli(opts) {
 }
 
 // src/program.ts
-import process23 from "node:process";
-import * as p29 from "@clack/prompts";
-import { Command as Command73 } from "commander";
-import dotenv from "dotenv";
-import pc7 from "picocolors";
+import process30 from "node:process";
+import * as p42 from "@clack/prompts";
+import { Command as Command87 } from "commander";
+import nodePath from "node:path";
+import dotenv2 from "dotenv";
+import pc20 from "picocolors";
 
 // src/lib/help.ts
 import pc from "picocolors";
@@ -349,8 +350,8 @@ function mergePackageJson(user, template) {
   }
   return { merged, added, conflicts, replaced };
 }
-function readPackageJson(path36) {
-  return JSON.parse(fs2.readFileSync(path36, "utf8"));
+function readPackageJson(path43) {
+  return JSON.parse(fs2.readFileSync(path43, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -363,12 +364,12 @@ function fillTemplatePlaceholders(raw, values) {
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
-function readTemplatePackageJson(path36, values) {
-  const raw = fillTemplatePlaceholders(fs2.readFileSync(path36, "utf8"), values);
+function readTemplatePackageJson(path43, values) {
+  const raw = fillTemplatePlaceholders(fs2.readFileSync(path43, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path36, pkg) {
-  fs2.writeFileSync(path36, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path43, pkg) {
+  fs2.writeFileSync(path43, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -630,13 +631,14 @@ import fs6 from "node:fs";
 import net from "node:net";
 import path5 from "node:path";
 import process5 from "node:process";
+import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import PocketBase from "pocketbase";
 import { detect as detect2 } from "package-manager-detector";
 import { resolveCommand } from "package-manager-detector/commands";
 import { x } from "tinyexec";
 function findFreePort(host = "localhost") {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = net.createServer();
     server.unref();
     server.once("error", reject);
@@ -645,13 +647,13 @@ function findFreePort(host = "localhost") {
       server.close((err) => {
         if (err) reject(err);
         else if (!addr) reject(new Error("Failed to obtain a free port"));
-        else resolve(addr.port);
+        else resolve2(addr.port);
       });
     });
   });
 }
 function waitForReadyOrExit(proc, url, maxAttempts = 40) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const onExit = (code, signal) => {
       if (settled) return;
@@ -671,7 +673,7 @@ function waitForReadyOrExit(proc, url, maxAttempts = 40) {
           if (settled) return;
           settled = true;
           proc.removeListener("exit", onExit);
-          resolve();
+          resolve2();
           return;
         }
       } catch {
@@ -715,8 +717,8 @@ async function startPocketbaseServe(opts) {
     } catch (err) {
       lastErr = err;
       if (proc.exitCode === null && proc.signalCode === null) {
-        await new Promise((resolve) => {
-          proc.once("exit", () => resolve());
+        await new Promise((resolve2) => {
+          proc.once("exit", () => resolve2());
           proc.kill();
         });
       }
@@ -724,10 +726,10 @@ async function startPocketbaseServe(opts) {
   }
   throw lastErr instanceof Error ? lastErr : new Error("Failed to start PocketBase");
 }
-async function authWithRetries(pb, email3, password8, attempts = 3) {
+async function authWithRetries(pb, email3, password10, attempts = 3) {
   for (let attempt = 1; attempt <= attempts; attempt++) {
     try {
-      await pb.collection("_superusers").authWithPassword(email3, password8);
+      await pb.collection("_superusers").authWithPassword(email3, password10);
       return;
     } catch (e) {
       if (attempt === attempts) {
@@ -759,14 +761,14 @@ async function withPocketbase(cwd, fn, creds) {
   const migrationsDir = path5.join(cwd, MIGRATIONS_DIR);
   const host = "localhost";
   const email3 = creds?.email ?? process5.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password8 = creds?.password ?? process5.env.POCKETBASE_SUPERUSER_PASSWORD;
+  const password10 = creds?.password ?? process5.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!fs6.existsSync(dir)) {
     throw new Error("PocketBase data directory does not exist");
   }
   const metadata = getPocketbaseMetadata(cwd);
   if (metadata?.pocketbaseUrl) {
     const pb = new PocketBase(metadata.pocketbaseUrl);
-    await authWithRetries(pb, email3, password8);
+    await authWithRetries(pb, email3, password10);
     await fn(pb);
     return;
   }
@@ -778,13 +780,13 @@ async function withPocketbase(cwd, fn, creds) {
   });
   try {
     const pb = new PocketBase(url);
-    await authWithRetries(pb, email3, password8);
+    await authWithRetries(pb, email3, password10);
     await fn(pb);
   } finally {
     proc.kill();
   }
 }
-async function createSuperuser(cwd, email3, password8) {
+async function createSuperuser(cwd, email3, password10) {
   const dir = path5.join(cwd, DATA_DIR);
   const migrationsDir = path5.join(cwd, MIGRATIONS_DIR);
   fs6.mkdirSync(dir, { recursive: true });
@@ -800,7 +802,7 @@ async function createSuperuser(cwd, email3, password8) {
       "superuser",
       "create",
       email3,
-      password8
+      password10
     ],
     "pipe"
   );
@@ -809,7 +811,7 @@ async function launchPocketbase(cwd, {
   dir,
   migrationsDir,
   email: email3,
-  password: password8
+  password: password10
 }) {
   const host = "localhost";
   fs6.mkdirSync(dir, { recursive: true });
@@ -825,7 +827,7 @@ async function launchPocketbase(cwd, {
       "superuser",
       "create",
       email3,
-      password8
+      password10
     ],
     "pipe"
   );
@@ -845,6 +847,33 @@ async function launchPocketbase(cwd, {
     url
   };
 }
+function pocketbaseVersion() {
+  const require2 = createRequire(import.meta.url);
+  const pkg = require2("pocketbase-server/package.json");
+  return pkg.version;
+}
+async function ensureSuperuser(cwd) {
+  const email3 = process5.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password10 = process5.env.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!email3 || !password10) return;
+  const dir = path5.join(cwd, DATA_DIR);
+  if (!fs6.existsSync(dir)) return;
+  const { getBinaryPath } = await import("pocketbase-server");
+  await x(
+    getBinaryPath(),
+    [
+      "--dir",
+      dir,
+      "--migrationsDir",
+      path5.join(cwd, MIGRATIONS_DIR),
+      "superuser",
+      "upsert",
+      email3,
+      password10
+    ],
+    { nodeOptions: { cwd, stdio: "ignore" } }
+  );
+}
 
 // src/lib/env.ts
 import fs7 from "node:fs";
@@ -869,6 +898,35 @@ function writeEnvFile(cwd, vars, comments = []) {
   for (const [key, value] of Object.entries(vars)) content = addEnvVar(content, key, value);
   fs7.writeFileSync(envPath, content);
 }
+function upsertEnvVar(content, key, value) {
+  const line = `${key}=${quoteEnvValue(value)}`;
+  const pattern = keyPattern(key);
+  let replaced = false;
+  const lines = content.split("\n").map((existing) => {
+    if (replaced || !pattern.test(existing)) return existing;
+    replaced = true;
+    return existing.trimStart().startsWith("export ") ? `export ${line}` : line;
+  });
+  return replaced ? lines.join("\n") : appendLine(content, line);
+}
+function removeEnvVar(content, key) {
+  const pattern = keyPattern(key);
+  const lines = content.split("\n");
+  const kept = lines.filter((line) => !pattern.test(line));
+  if (kept.length === lines.length) return content;
+  return kept.join("\n");
+}
+function keyPattern(key) {
+  return new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(key)}\\s*=`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function quoteEnvValue(value) {
+  if (/^[A-Za-z0-9_./:@+-]*$/.test(value)) return value;
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n");
+  return `"${escaped}"`;
+}
 
 // src/lib/config-merge.ts
 import fs9 from "node:fs";
@@ -1128,18 +1186,18 @@ function isVanillaRoutes(cwd) {
 
 // src/lib/result-report.ts
 import * as p3 from "@clack/prompts";
-function reportResult(report) {
+function reportResult(report4) {
   const sections = [
-    ["Files created", report.filesCreated],
-    ["Files modified", report.filesModified],
-    ["Files deleted", report.filesDeleted],
-    ["UI components added", report.componentsAdded],
-    ["Packages installed", report.packagesInstalled],
-    ["Collections added", report.collectionsAdded],
-    ["Records loaded", report.recordsLoaded],
-    ["Records cleared", report.recordsCleared]
+    ["Files created", report4.filesCreated],
+    ["Files modified", report4.filesModified],
+    ["Files deleted", report4.filesDeleted],
+    ["UI components added", report4.componentsAdded],
+    ["Packages installed", report4.packagesInstalled],
+    ["Collections added", report4.collectionsAdded],
+    ["Records loaded", report4.recordsLoaded],
+    ["Records cleared", report4.recordsCleared]
   ];
-  for (const extra of report.sections ?? []) {
+  for (const extra of report4.sections ?? []) {
     sections.push([extra.label, extra.items]);
   }
   const body = [];
@@ -1150,14 +1208,14 @@ function reportResult(report) {
     for (const item of items) body.push(`- ${item}`);
   }
   if (body.length > 0) {
-    p3.log.success(`${report.summary}
+    p3.log.success(`${report4.summary}
 
 ${body.join("\n")}`);
   } else {
-    p3.log.success(report.summary);
+    p3.log.success(report4.summary);
   }
-  if (report.nextSteps && report.nextSteps.length > 0) {
-    p3.note(report.nextSteps.map((s) => `- ${s}`).join("\n"), "Next steps", {
+  if (report4.nextSteps && report4.nextSteps.length > 0) {
+    p3.note(report4.nextSteps.map((s) => `- ${s}`).join("\n"), "Next steps", {
       format: (line) => line
     });
   }
@@ -1247,7 +1305,7 @@ async function blessProject(cwdArg, options) {
   const projectPath = cwdArg ? resolveProjectPath(cwdArg) : (await getWorkspace()).workspaceRootDir;
   assertNotAlreadyBlessed(projectPath);
   const templateDir = findProjectTemplate(options.template ?? DEFAULT_TEMPLATE).dir;
-  const { email: email3, password: password8 } = await p4.group(
+  const { email: email3, password: password10 } = await p4.group(
     {
       email: () => {
         if (options.email) return Promise.resolve(options.email);
@@ -1288,12 +1346,12 @@ async function blessProject(cwdArg, options) {
     }
   }
   p4.log.step("Initializing PocketBase...");
-  await createSuperuser(projectPath, email3, password8);
+  await createSuperuser(projectPath, email3, password10);
   writeEnvFile(
     projectPath,
     {
       POCKETBASE_SUPERUSER_EMAIL: email3,
-      POCKETBASE_SUPERUSER_PASSWORD: password8
+      POCKETBASE_SUPERUSER_PASSWORD: password10
     },
     ["PocketBase superuser credentials \u2014 used by `vela` commands"]
   );
@@ -1618,9 +1676,9 @@ async function createProject(cwdArg, options) {
     }
   }
   if (credentials) {
-    const { email: email3, password: password8 } = credentials;
+    const { email: email3, password: password10 } = credentials;
     p5.log.step("Initializing PocketBase...");
-    await createSuperuser(projectPath, email3, password8);
+    await createSuperuser(projectPath, email3, password10);
     await withPocketbase(
       projectPath,
       async (pb) => {
@@ -1628,13 +1686,13 @@ async function createProject(cwdArg, options) {
           meta: { appName: name, appURL: "http://localhost:5173" }
         });
       },
-      { email: email3, password: password8 }
+      { email: email3, password: password10 }
     );
     writeEnvFile(
       projectPath,
       {
         POCKETBASE_SUPERUSER_EMAIL: email3,
-        POCKETBASE_SUPERUSER_PASSWORD: password8
+        POCKETBASE_SUPERUSER_PASSWORD: password10
       },
       ["PocketBase superuser credentials \u2014 used by `vela` commands"]
     );
@@ -1688,13 +1746,13 @@ import { bySlug } from "@velastack/patterns";
 function toRelative(root, filePath) {
   return path13.isAbsolute(filePath) ? path13.relative(root, filePath) : filePath;
 }
-async function runPattern(slug, argv2, input, report) {
-  const pattern = bySlug[slug];
+async function runPattern(slug2, argv2, input, report4) {
+  const pattern = bySlug[slug2];
   if (!pattern) {
-    throw new Error(`Unknown pattern: ${slug}`);
+    throw new Error(`Unknown pattern: ${slug2}`);
   }
   const { workspaceRootDir, features } = await getWorkspace();
-  const log18 = p6.taskLog({ title: report.task.title });
+  const log31 = p6.taskLog({ title: report4.task.title });
   let result;
   try {
     result = await pattern.generate({
@@ -1714,28 +1772,28 @@ async function runPattern(slug, argv2, input, report) {
         });
         return collections2;
       },
-      logger: { info: (message) => log18.message(message) }
+      logger: { info: (message) => log31.message(message) }
     });
-    log18.success(report.task.success);
+    log31.success(report4.task.success);
   } catch (e) {
-    log18.error(report.task.error);
+    log31.error(report4.task.error);
     throw e;
   }
   const rel = (f) => toRelative(workspaceRootDir, f);
   const totalChanges = result.creates.length + result.modifies.length + result.deletes.length + result.components.length + result.packages.length + result.collections.length;
   if (totalChanges === 0) {
-    p6.log.info(`${pattern.title ?? slug} produced no changes.`);
+    p6.log.info(`${pattern.title ?? slug2} produced no changes.`);
     return;
   }
   reportResult({
-    summary: report.summary ?? `Applied ${pattern.title ?? slug}.`,
+    summary: report4.summary ?? `Applied ${pattern.title ?? slug2}.`,
     filesCreated: result.creates.map((f) => rel(f.path)),
     filesModified: result.modifies.map((f) => rel(f.path)),
     filesDeleted: result.deletes.map((f) => rel(f.path)),
     componentsAdded: result.components,
     packagesInstalled: result.packages,
     collectionsAdded: result.collections.map((c) => c.name),
-    nextSteps: report.nextSteps
+    nextSteps: report4.nextSteps
   });
 }
 
@@ -1800,7 +1858,14 @@ function readProjectConfig(workspaceRootDir) {
 function writeProjectConfig(workspaceRootDir, config) {
   const file = projectConfigPath(workspaceRootDir);
   fs15.mkdirSync(path15.dirname(file), { recursive: true });
-  fs15.writeFileSync(file, JSON.stringify(config, null, 2) + "\n");
+  let existing = {};
+  if (fs15.existsSync(file)) {
+    try {
+      existing = JSON.parse(fs15.readFileSync(file, "utf8"));
+    } catch {
+    }
+  }
+  fs15.writeFileSync(file, JSON.stringify({ ...existing, ...config }, null, 2) + "\n");
 }
 
 // src/lib/ai-client.ts
@@ -2117,7 +2182,7 @@ var form = new Command4("form").description("generate a form from a model").argu
       argv2 = [model, ...fields];
       modelName = model;
     }
-    const slug = options.remote ? "generate-form-remote" : "generate-form";
+    const slug2 = options.remote ? "generate-form-remote" : "generate-form";
     const nextSteps = [
       "Edit the form fields and validation in the generated +page.svelte.",
       "Run `vela dev` to preview the form in the browser."
@@ -2128,7 +2193,7 @@ var form = new Command4("form").description("generate a form from a model").argu
       );
     }
     await runPattern(
-      slug,
+      slug2,
       argv2,
       { route: options.route },
       {
@@ -2253,7 +2318,7 @@ var scaffold = new Command7("scaffold").description("generate a full CRUD scaffo
       argv2 = [model, ...fields];
       modelName = model;
     }
-    const slug = options.remote ? "generate-scaffold-remote" : "generate-scaffold";
+    const slug2 = options.remote ? "generate-scaffold-remote" : "generate-scaffold";
     const nextSteps = [
       `Run \`vela fixtures generate\` to create 10 ${modelName} records for development.`,
       "Run `vela dev` and visit the generated route to use the scaffold.",
@@ -2265,7 +2330,7 @@ var scaffold = new Command7("scaffold").description("generate a full CRUD scaffo
       );
     }
     await runPattern(
-      slug,
+      slug2,
       argv2,
       { route: options.route },
       {
@@ -2560,7 +2625,7 @@ async function ensureKey(envVar, message) {
 async function promptPassword(message) {
   const value = await p14.password({
     message,
-    validate: (v4) => v4 && v4.length ? void 0 : "Required"
+    validate: (v9) => v9 && v9.length ? void 0 : "Required"
   });
   if (p14.isCancel(value)) {
     p14.cancel("Operation cancelled.");
@@ -2607,24 +2672,24 @@ var s3 = new Command18("s3").description("enable S3 file storage").configureHelp
         endpoint: () => p15.text({
           message: "S3 endpoint URL",
           initialValue: "https://s3.amazonaws.com",
-          validate: (v4) => v4 ? void 0 : "Endpoint is required"
+          validate: (v9) => v9 ? void 0 : "Endpoint is required"
         }),
         accessKey: () => p15.text({
           message: "S3 access key",
-          validate: (v4) => v4 ? void 0 : "Access key is required"
+          validate: (v9) => v9 ? void 0 : "Access key is required"
         }),
         secret: () => p15.password({
           message: "S3 secret key",
-          validate: (v4) => v4 ? void 0 : "Secret key is required"
+          validate: (v9) => v9 ? void 0 : "Secret key is required"
         }),
         bucket: () => p15.text({
           message: "S3 bucket name",
-          validate: (v4) => v4 ? void 0 : "Bucket name is required"
+          validate: (v9) => v9 ? void 0 : "Bucket name is required"
         }),
         region: () => p15.text({
           message: "S3 region",
           initialValue: "us-east-1",
-          validate: (v4) => v4 ? void 0 : "Region is required"
+          validate: (v9) => v9 ? void 0 : "Region is required"
         })
       },
       {
@@ -2678,14 +2743,14 @@ var smtp = new Command19("smtp").description("configure SMTP for transactional e
         host: () => p16.text({
           message: "SMTP host",
           placeholder: "smtp.example.com",
-          validate: (v4) => v4 ? void 0 : "Host is required"
+          validate: (v9) => v9 ? void 0 : "Host is required"
         }),
         port: () => p16.text({
           message: "SMTP port",
           initialValue: "587",
-          validate: (v4) => {
-            if (!v4) return "Port is required";
-            const n = Number(v4);
+          validate: (v9) => {
+            if (!v9) return "Port is required";
+            const n = Number(v9);
             if (!Number.isInteger(n) || n <= 0 || n > 65535) return "Invalid port";
             return void 0;
           }
@@ -3046,7 +3111,7 @@ var smtp2 = new Command32("smtp").description("disable SMTP configuration").conf
 var disable = new Command33("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 Command38 } from "commander";
+import { Command as Command39 } from "commander";
 
 // src/commands/destroy/form.ts
 import { Command as Command34 } from "commander";
@@ -3054,7 +3119,7 @@ import { Command as Command34 } from "commander";
 // src/commands/destroy/_shared.ts
 import process12 from "node:process";
 import * as p18 from "@clack/prompts";
-async function runDestroy(slug, model, confirmMessage, report, flags) {
+async function runDestroy(slug2, model, confirmMessage, report4, flags) {
   if (!flags.yes) {
     const ok = await p18.confirm({ message: confirmMessage, initialValue: false });
     if (p18.isCancel(ok) || !ok) {
@@ -3062,7 +3127,7 @@ async function runDestroy(slug, model, confirmMessage, report, flags) {
       process12.exit(0);
     }
   }
-  await runPattern(slug, [model], { destructive: true, route: flags.route }, report);
+  await runPattern(slug2, [model], { destructive: true, route: flags.route }, report4);
 }
 
 // src/commands/destroy/form.ts
@@ -3161,198 +3226,1111 @@ var scaffold2 = new Command37("scaffold").description("destroy a scaffold genera
   )
 );
 
-// src/commands/destroy.ts
-var destroy = new Command38("destroy").description("destroy scaffolding").configureHelp(helpConfig).addCommand(form2).addCommand(schema2).addCommand(resource2).addCommand(scaffold2);
-
-// src/commands/ui.ts
-import { Command as Command41 } from "commander";
+// src/commands/destroy/deployment.ts
+import process15 from "node:process";
+import { Command as Command38 } from "commander";
+import * as p20 from "@clack/prompts";
+import pc6 from "picocolors";
 
-// src/commands/ui/add.ts
-import { Command as Command39 } from "commander";
-import { exec as exec2 } from "tinyexec";
-import { detect as detect4, resolveCommand as resolveCommand4 } from "package-manager-detector";
-var add = new Command39("add").description("add ui components").argument("<components...>", "the components to add").configureHelp(helpConfig).action(
-  (components) => runCommand(async () => {
-    const { workspaceRootDir } = await getWorkspace();
-    const packageManager = (await detect4({ cwd: workspaceRootDir }))?.name ?? "npm";
-    const resolved = resolveCommand4(packageManager, "execute", [
-      "shadcn-svelte",
-      "add",
-      ...components
-    ]);
-    if (!resolved) {
-      throw new Error(`Unable to resolve execute command for ${packageManager}`);
-    }
-    const args = [...resolved.args];
-    if (packageManager === "npm") args.unshift("--yes");
-    try {
-      await exec2(resolved.command, args, {
-        nodeOptions: { cwd: workspaceRootDir, stdio: "inherit" },
-        throwOnError: true
-      });
-    } catch (error) {
-      const typed = error;
-      throw new Error(
-        `Failed to execute '${resolved.command} ${args.join(" ")}': ${typed.message}`,
-        { cause: typed.output }
-      );
-    }
-    reportResult({
-      summary: `Added ${components.length} UI component(s).`,
-      componentsAdded: components,
-      nextSteps: [
-        `Import a component with: import { Button } from '$lib/components/ui/button';`,
-        "Tweak styling in src/lib/components/ui/<component>/*.svelte.",
-        "Run `vela ui base <color>` to change the palette (slate, gray, zinc, stone, neutral)."
-      ]
-    });
-  }, "Failed to add UI components.")
-);
+// src/lib/server-command.ts
+import process14 from "node:process";
+import * as v5 from "valibot";
+import * as p19 from "@clack/prompts";
+import pc5 from "picocolors";
 
-// src/commands/ui/base.ts
+// src/lib/deploy-config.ts
 import fs17 from "node:fs";
 import path17 from "node:path";
-import { Command as Command40, InvalidArgumentError } from "commander";
-var VALID_COLORS = ["slate", "gray", "zinc", "stone", "neutral"];
-function findThemeFile(color) {
-  const candidate = path17.join(templatesDir(), "ui", "css", `${color}.css`);
-  if (!fs17.existsSync(candidate)) {
-    throw new Error(`Theme file not found for color: ${color}`);
+import crypto from "node:crypto";
+import { pathToFileURL } from "node:url";
+var CONFIG_BASENAMES = [
+  "velastack.config.ts",
+  "velastack.config.js",
+  "velastack.config.mjs",
+  "velastack.config.json"
+];
+function findConfigFile(workspaceRootDir) {
+  for (const name of CONFIG_BASENAMES) {
+    const file = path17.join(workspaceRootDir, name);
+    if (fs17.existsSync(file)) return file;
   }
-  return candidate;
+  return null;
 }
-function extractSelectors(css) {
-  const rootMatch = css.match(/:root\s*{[^}]*}/);
-  const darkMatch = css.match(/\.dark\s*{[^}]*}/);
-  if (!rootMatch || !darkMatch) {
-    throw new Error("Invalid theme file: missing :root or .dark selector");
+async function loadDeployConfig(workspaceRootDir) {
+  const file = findConfigFile(workspaceRootDir);
+  if (!file) return {};
+  if (file.endsWith(".json")) {
+    return JSON.parse(fs17.readFileSync(file, "utf8"));
+  }
+  const url = file.endsWith(".ts") ? await transpileToTemp(file) : pathToFileURL(file).href;
+  try {
+    const mod = await import(url);
+    const config = mod.default;
+    if (!config || typeof config !== "object") {
+      throw new Error(`${path17.basename(file)} must export a config object as its default export.`);
+    }
+    return config;
+  } finally {
+    if (url !== pathToFileURL(file).href) fs17.rmSync(new URL(url), { force: true });
   }
-  return { root: rootMatch[0], dark: darkMatch[0] };
 }
-function applyTheme(appCss, selectors) {
-  let out = appCss;
-  out = out.match(/:root\s*{[^}]*}/) ? out.replace(/:root\s*{[^}]*}/, selectors.root) : `${selectors.root}
-
-${out}`;
-  out = out.match(/\.dark\s*{[^}]*}/) ? out.replace(/\.dark\s*{[^}]*}/, selectors.dark) : `${out}
-
-${selectors.dark}`;
-  return out;
+async function transpileToTemp(file) {
+  const { ts } = await import("ts-morph");
+  const source = fs17.readFileSync(file, "utf8");
+  const { outputText } = ts.transpileModule(source, {
+    compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 }
+  });
+  const temp = path17.join(
+    path17.dirname(file),
+    `.velastack.config.${crypto.randomBytes(4).toString("hex")}.mjs`
+  );
+  fs17.writeFileSync(temp, outputText);
+  return pathToFileURL(temp).href;
 }
-var base = new Command40("base").description("change the base color").argument("<color>", "base color to use", (value) => {
-  if (!VALID_COLORS.includes(value)) {
-    throw new InvalidArgumentError(`Valid colors are: ${VALID_COLORS.join(", ")}`);
+function projectFilePath(workspaceRootDir) {
+  return path17.join(workspaceRootDir, ".vela", "project.json");
+}
+function readProjectFile(workspaceRootDir) {
+  const file = projectFilePath(workspaceRootDir);
+  if (!fs17.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs17.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeProjectFile(workspaceRootDir, data) {
+  const file = projectFilePath(workspaceRootDir);
+  fs17.mkdirSync(path17.dirname(file), { recursive: true });
+  fs17.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+}
+function resolveAppIdentity(workspaceRootDir, config = {}) {
+  const project = readProjectFile(workspaceRootDir);
+  const name = config.project ?? project.projectName ?? defaultProjectName(workspaceRootDir);
+  if (project.appId) return { appId: project.appId, name };
+  const appId = project.projectId ?? `${slug(name)}-${crypto.randomBytes(4).toString("hex")}`;
+  writeProjectFile(workspaceRootDir, {
+    ...project,
+    appId,
+    projectName: project.projectName ?? name
+  });
+  return { appId, name };
+}
+function readAppIdentity(workspaceRootDir, config = {}) {
+  const project = readProjectFile(workspaceRootDir);
+  const appId = project.appId ?? project.projectId;
+  if (!appId) return null;
+  return {
+    appId,
+    name: config.project ?? project.projectName ?? defaultProjectName(workspaceRootDir)
+  };
+}
+function defaultProjectName(workspaceRootDir) {
+  try {
+    const pkg = readPackageJson(path17.join(workspaceRootDir, "package.json"));
+    if (typeof pkg.name === "string" && pkg.name.trim()) return pkg.name.trim();
+  } catch {
   }
-  return value;
-}).configureHelp(helpConfig).action(
-  (color) => runCommand(async () => {
-    const { workspaceRootDir } = await getWorkspace();
-    const appCssPath = path17.join(workspaceRootDir, "src", "app.css");
-    if (!fs17.existsSync(appCssPath)) {
-      throw new Error(`Could not find ${path17.relative(workspaceRootDir, appCssPath)}`);
-    }
-    const themeContent = fs17.readFileSync(findThemeFile(color), "utf8");
-    const selectors = extractSelectors(themeContent);
-    const appCss = fs17.readFileSync(appCssPath, "utf8");
-    fs17.writeFileSync(appCssPath, applyTheme(appCss, selectors));
-    reportResult({
-      summary: `Set base color to ${color}.`,
-      filesModified: [path17.relative(workspaceRootDir, appCssPath)],
-      nextSteps: [
-        "Run your dev server to preview the new palette.",
-        "Tweak individual CSS variables in src/app.css if you want to customize the theme further."
-      ]
-    });
-  }, "Failed to change base color.")
-);
+  return path17.basename(workspaceRootDir);
+}
+function slug(value) {
+  return value.toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "app";
+}
+function readBinding(workspaceRootDir, envTag) {
+  const project = readProjectFile(workspaceRootDir);
+  const bound = project.targets?.[envTag];
+  if (bound?.server) return bound;
+  const legacy = project.deployments?.[envTag];
+  if (legacy?.target) return { server: legacy.target, domain: legacy.domain };
+  return null;
+}
+function readBindings(workspaceRootDir) {
+  const project = readProjectFile(workspaceRootDir);
+  const bindings = {};
+  for (const [envTag, legacy] of Object.entries(project.deployments ?? {})) {
+    if (legacy?.target) bindings[envTag] = { server: legacy.target, domain: legacy.domain };
+  }
+  for (const [envTag, bound] of Object.entries(project.targets ?? {})) {
+    if (bound?.server) bindings[envTag] = bound;
+  }
+  return bindings;
+}
+function writeBinding(workspaceRootDir, envTag, binding) {
+  const project = readProjectFile(workspaceRootDir);
+  writeProjectFile(workspaceRootDir, {
+    ...project,
+    targets: { ...project.targets, [envTag]: binding }
+  });
+}
 
-// src/commands/ui.ts
-var ui = new Command41("ui").description("generate ui components").configureHelp(helpConfig).addCommand(add).addCommand(base);
+// src/lib/instance.ts
+var PROD_ENV = "prod";
+var MAX_SEGMENT = 48;
+function normalizeEnvTag(tag) {
+  const raw = (tag ?? PROD_ENV).trim();
+  if (!raw) return PROD_ENV;
+  const normalized = raw.toLowerCase().replace(/\//g, "--").replace(/[^a-z0-9-]+/g, "-").replace(/-{3,}/g, "--").replace(/^-+|-+$/g, "");
+  if (!normalized) throw new Error(`Invalid environment tag: ${tag}`);
+  if (normalized === "local") {
+    throw new Error("`local` is not a deployable environment \u2014 it is the copy on this machine.");
+  }
+  return normalized === "production" ? PROD_ENV : normalized;
+}
+function branchToEnvTag(branch) {
+  const slug2 = branch.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SEGMENT);
+  return `preview--${slug2}`;
+}
+function instanceId(appId, envTag = PROD_ENV) {
+  const env2 = normalizeEnvTag(envTag);
+  return env2 === PROD_ENV ? appId : `${appId}--${env2}`;
+}
+function isProd(envTag) {
+  return normalizeEnvTag(envTag) === PROD_ENV;
+}
+function releaseId(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
 
-// src/commands/legal.ts
-import { Command as Command44 } from "commander";
+// src/lib/ssh-options.ts
+import * as v4 from "valibot";
+var SSH_OPTION_SCHEMA = {
+  identity: v4.optional(v4.string()),
+  sshPort: v4.optional(v4.string()),
+  acceptHostKeys: v4.optional(v4.boolean())
+};
+function addSshOptions(command) {
+  return command.option("-i, --identity <file>", "SSH private key to authenticate with").option("--ssh-port <port>", "SSH port").option("--accept-host-keys", "trust an unknown host key on first connect (CI)");
+}
+function sshOptionsFrom(options) {
+  return {
+    identityFile: options.identity,
+    port: options.sshPort ? Number(options.sshPort) : void 0,
+    acceptNewHostKeys: options.acceptHostKeys
+  };
+}
 
-// src/commands/legal/terms.ts
+// src/lib/ssh.ts
 import fs18 from "node:fs";
+import os2 from "node:os";
 import path18 from "node:path";
-import { Command as Command42 } from "commander";
-import * as p20 from "@clack/prompts";
-
-// src/commands/legal/shared.ts
+import crypto2 from "node:crypto";
 import process13 from "node:process";
-import * as p19 from "@clack/prompts";
-var sharedFields = {
-  websiteUrl: () => p19.text({
-    message: "What is your website URL?",
-    placeholder: "http://www.mysite.com",
-    validate: (value) => {
-      if (!value || !value.startsWith("http")) {
-        return "Please enter a valid URL starting with http or https";
-      }
+import { spawn as spawn2 } from "node:child_process";
+var RemoteCommandError = class extends Error {
+  exitCode;
+  stdout;
+  stderr;
+  constructor(message, result) {
+    super(message);
+    this.name = "RemoteCommandError";
+    this.exitCode = result.exitCode;
+    this.stdout = result.stdout;
+    this.stderr = result.stderr;
+  }
+};
+var SshSession = class {
+  target;
+  elevation = "none";
+  options;
+  controlPath = null;
+  constructor(target, options = {}) {
+    this.target = target;
+    this.options = options;
+  }
+  sshArgs() {
+    const args = [];
+    if (this.controlPath) args.push("-o", `ControlPath=${this.controlPath}`);
+    if (this.options.identityFile) {
+      args.push("-i", this.options.identityFile, "-o", "IdentitiesOnly=yes");
     }
-  }),
-  websiteName: () => p19.text({
-    message: "What is your website name?",
-    placeholder: "My Site",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter a website name";
-      }
+    if (this.options.port) args.push("-p", String(this.options.port));
+    if (this.options.acceptNewHostKeys) args.push("-o", "StrictHostKeyChecking=accept-new");
+    args.push("-o", "BatchMode=yes");
+    return args;
+  }
+  /** The `ssh` invocation rsync should use, as a single shell word list. */
+  rsyncShell() {
+    const parts = ["ssh", ...this.sshArgs()];
+    return parts.map(shellQuote).join(" ");
+  }
+  async open() {
+    if (this.controlPath) return;
+    const dir = path18.join(os2.tmpdir(), "vela-ssh");
+    fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+    const socket = path18.join(dir, `${crypto2.randomBytes(6).toString("hex")}.sock`);
+    this.controlPath = socket;
+    const args = [
+      ...this.sshArgs(),
+      "-o",
+      "ControlMaster=yes",
+      "-o",
+      "ControlPersist=60",
+      "-N",
+      "-f",
+      this.target
+    ];
+    const result = await spawnCapture("ssh", args);
+    if (result.exitCode !== 0) {
+      this.controlPath = null;
+      throw new Error(
+        `Could not connect to ${this.target} over SSH.
+
+${result.stderr.trim() || result.stdout.trim()}`
+      );
     }
-  }),
-  entityType: () => p19.select({
-    message: "Entity type",
-    options: [
-      {
-        value: "business",
-        label: "I'm a Business",
-        hint: "e.g. Corporation, Limited Liability Company, Non-profit, Partnership, Sole Proprietor"
-      },
-      { value: "individual", label: "I'm an Individual" }
-    ]
-  }),
-  businessName: ({ results }) => results?.entityType === "business" ? p19.text({
-    message: "What is the name of the business?",
-    placeholder: "My Company LLC",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter a business name";
-      }
+  }
+  async close() {
+    if (!this.controlPath) return;
+    const socket = this.controlPath;
+    this.controlPath = null;
+    await spawnCapture("ssh", ["-o", `ControlPath=${socket}`, "-O", "exit", this.target]);
+  }
+  /**
+   * Run a bash program on the server. The program is piped over stdin, so it can
+   * safely embed anything — quoting, newlines, base64 blobs — and `args` arrive
+   * as ordinary positional parameters.
+   */
+  async script(source, opts = {}) {
+    const shell = this.elevation === "sudo" ? "sudo -n bash -s" : "bash -s";
+    const remote = [shell, "--", ...(opts.args ?? []).map(shellQuote)].join(" ");
+    const args = [...this.sshArgs(), this.target, remote];
+    const result = await spawnCapture("ssh", args, {
+      stdin: `set -euo pipefail
+${source}`,
+      stream: opts.stream
+    });
+    if (opts.check !== false && result.exitCode !== 0) {
+      throw new RemoteCommandError(remoteFailure(this.target, result), result);
     }
-  }) : void 0,
-  businessAddress: ({ results }) => results?.entityType === "business" ? p19.text({
-    message: "What is the address of the business?",
-    placeholder: "1 Cupertino, CA 95014",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter a business address";
-      }
+    return result;
+  }
+  /** Attach the terminal to a remote command — used by `vela logs -f`. */
+  async interactive(command) {
+    const args = [...this.sshArgs(), "-t", this.target, command.map(shellQuote).join(" ")];
+    return await new Promise((resolve2) => {
+      const child = spawn2("ssh", args, { stdio: "inherit" });
+      child.on("close", (code) => resolve2(code ?? 1));
+    });
+  }
+  /**
+   * Write a file on the server atomically, with an explicit mode.
+   *
+   * The payload rides inside the piped script as base64, so it never lands in
+   * argv (visible in `ps`) or in a shell history, and binary-unsafe characters
+   * are not an issue.
+   */
+  async writeFile(remotePath, content, mode = "0644") {
+    const payload = Buffer.from(content, "utf8").toString("base64");
+    await this.script(
+      `dest="$1"; mode="$2"
+mkdir -p "$(dirname "$dest")"
+tmp=$(mktemp "$(dirname "$dest")/.vela.XXXXXX")
+printf %s ${payload} | base64 -d > "$tmp"
+chmod "$mode" "$tmp"
+mv -f "$tmp" "$dest"`,
+      { args: [remotePath, mode] }
+    );
+  }
+  /**
+   * Tunnel a local port to a port on the server, through the connection that is
+   * already open. Used to point a local build at the target's database.
+   */
+  async forwardLocalPort(localPort, remoteHost, remotePort) {
+    if (!this.controlPath) throw new Error("Cannot forward a port without an open session.");
+    const spec = `${localPort}:${remoteHost}:${remotePort}`;
+    const result = await spawnCapture("ssh", [
+      ...this.sshArgs(),
+      "-O",
+      "forward",
+      "-L",
+      spec,
+      this.target
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Could not forward port ${spec} to ${this.target}.
+
+${result.stderr.trim()}`
+      );
     }
-  }) : void 0,
-  country: () => p19.text({
-    message: "Enter the country",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter a country";
-      }
+  }
+  async cancelForward(localPort, remoteHost, remotePort) {
+    if (!this.controlPath) return;
+    await spawnCapture("ssh", [
+      ...this.sshArgs(),
+      "-O",
+      "cancel",
+      "-L",
+      `${localPort}:${remoteHost}:${remotePort}`,
+      this.target
+    ]);
+  }
+  async readFile(remotePath) {
+    const result = await this.script(`cat "$1" 2>/dev/null || exit 44`, {
+      args: [remotePath],
+      check: false
+    });
+    if (result.exitCode === 44) return null;
+    if (result.exitCode !== 0)
+      throw new RemoteCommandError(remoteFailure(this.target, result), result);
+    return result.stdout;
+  }
+  /** rsync a local directory (contents) into a remote directory. */
+  async uploadDir(localDir, remoteDir, extraArgs = []) {
+    const src = localDir.endsWith("/") ? localDir : `${localDir}/`;
+    const args = [
+      "-az",
+      "--delete",
+      "-e",
+      this.rsyncShell(),
+      ...this.rsyncPath(),
+      ...extraArgs,
+      src,
+      `${this.target}:${remoteDir}`
+    ];
+    const result = await spawnCapture("rsync", args);
+    if (result.exitCode !== 0) {
+      throw new Error(`rsync to ${this.target}:${remoteDir} failed.
+
+${result.stderr.trim()}`);
     }
-  }),
-  state: () => p19.text({
-    message: "Enter the state",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter a state";
-      }
+  }
+  rsyncPath() {
+    return this.elevation === "sudo" ? ["--rsync-path=sudo -n rsync"] : [];
+  }
+  /** rsync one or more local paths to a remote directory. */
+  async upload(localPaths, remoteDir, extraArgs = []) {
+    const args = [
+      "-az",
+      "-e",
+      this.rsyncShell(),
+      ...this.rsyncPath(),
+      ...extraArgs,
+      ...localPaths,
+      `${this.target}:${remoteDir}`
+    ];
+    const result = await spawnCapture("rsync", args);
+    if (result.exitCode !== 0) {
+      throw new Error(`rsync to ${this.target}:${remoteDir} failed.
+
+${result.stderr.trim()}`);
     }
-  })
-};
-var onCancel = () => {
-  p19.cancel("Operation cancelled.");
-  process13.exit(0);
+  }
+  /**
+   * Decide once whether remote commands need `sudo`, and fail with something
+   * actionable if they do but cannot get it.
+   */
+  async detectElevation() {
+    const uid = await this.script("id -u", { check: false });
+    if (uid.stdout.trim() === "0") {
+      this.elevation = "none";
+      return this.elevation;
+    }
+    const sudo = await this.script("sudo -n true", { check: false });
+    if (sudo.exitCode !== 0) {
+      throw new Error(
+        `${this.target} connects as a non-root user without passwordless sudo.
+
+Use an SSH target that logs in as root, or give the user NOPASSWD sudo.`
+      );
+    }
+    this.elevation = "sudo";
+    return this.elevation;
+  }
 };
-async function contactMethods(type) {
-  const selection = await p19.multiselect({
-    message: `How can users contact you for any questions regarding your ${type === "privacy" ? "Privacy Policy" : "Terms & Conditions"}? Check all that apply`,
+function remoteFailure(target, result) {
+  const detail = (result.stderr.trim() || result.stdout.trim()).split("\n").slice(-12).join("\n");
+  return `Remote command failed on ${target} (exit ${result.exitCode}).
+
+${detail}`;
+}
+async function withSsh(target, options, fn) {
+  const session = new SshSession(target, options);
+  await session.open();
+  try {
+    return await fn(session);
+  } finally {
+    await session.close();
+  }
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function spawnCapture(command, args, opts = {}) {
+  return new Promise((resolve2, reject) => {
+    const stdio = [opts.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"];
+    const child = spawn2(command, args, {
+      stdio,
+      cwd: opts.cwd,
+      env: opts.env ? { ...process13.env, ...opts.env } : void 0
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      if (opts.streamStdout) process13.stdout.write(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+      if (opts.stream) process13.stderr.write(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? 1 }));
+    if (opts.stdin !== void 0) {
+      child.stdin.end(opts.stdin);
+    }
+  });
+}
+
+// src/lib/remote.ts
+import path19 from "node:path";
+var VELA_ROOT = "/var/lib/vela";
+var VELA_ETC = "/etc/vela";
+var SCRIPTS_DIR = `${VELA_ROOT}/scripts`;
+var PROVISIONED_MARKER = `${VELA_ETC}/provisioned`;
+function serverTemplatesDir() {
+  return path19.join(templatesDir(), "server");
+}
+async function syncServerScripts(session) {
+  await session.script(`mkdir -p "$1" && chmod 0755 "$1"`, { args: [SCRIPTS_DIR] });
+  await session.uploadDir(serverTemplatesDir(), SCRIPTS_DIR, ["--chmod=D755,F755"]);
+  await session.script(`chown -R root:root "$1"`, { args: [SCRIPTS_DIR] });
+}
+async function runServerScript(session, name, opts = {}) {
+  const result = await session.script(`script="$1"; shift; exec "$script" "$@"`, {
+    args: [`${SCRIPTS_DIR}/${name}`, ...opts.args ?? []],
+    stream: opts.stream
+  });
+  return parseResult(result);
+}
+function parseResult(result) {
+  const line = result.stdout.split("\n").reverse().find((l) => l.startsWith("VELA_RESULT "));
+  if (!line) return null;
+  try {
+    return JSON.parse(line.slice("VELA_RESULT ".length));
+  } catch {
+    return null;
+  }
+}
+async function readServerInfo(session) {
+  const raw = await session.readFile(PROVISIONED_MARKER);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function requireProvisioned(session) {
+  const info = await readServerInfo(session);
+  if (!info) {
+    throw new Error(
+      `${session.target} has not been provisioned for vela yet.
+
+Run \`vela provision ${session.target}\` first.`
+    );
+  }
+  return info;
+}
+async function readInstanceStates(session, instance) {
+  const result = await runServerScript(session, "status.sh", {
+    args: instance ? [instance] : []
+  });
+  return Array.isArray(result) ? result : [];
+}
+var remotePaths = {
+  app: (instance) => `${VELA_ROOT}/apps/${instance}`,
+  releases: (instance) => `${VELA_ROOT}/apps/${instance}/releases`,
+  release: (instance, release) => `${VELA_ROOT}/apps/${instance}/releases/${release}`,
+  env: (instance) => `${VELA_ETC}/apps/${instance}/env`,
+  runtimeEnv: (instance) => `${VELA_ETC}/apps/${instance}/runtime.env`,
+  caddy: (instance) => `${VELA_ETC}/caddy/${instance}.caddy`,
+  webUnit: (instance) => `vela-web@${instance}.service`,
+  pbUnit: (instance) => `vela-pb@${instance}.service`
+};
+
+// src/lib/remote-env.ts
+import fs19 from "node:fs";
+import dotenv from "dotenv";
+var KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isValidKey(key) {
+  return KEY_PATTERN.test(key);
+}
+function parseEnv(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq < 1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    if (!isValidKey(key)) continue;
+    result[key] = unquote(trimmed.slice(eq + 1).trim());
+  }
+  return result;
+}
+function unquote(raw) {
+  if (!raw.startsWith('"')) return raw;
+  const body = raw.endsWith('"') && raw.length > 1 ? raw.slice(1, -1) : raw.slice(1);
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== "\\" || i === body.length - 1) {
+      out += body[i];
+      continue;
+    }
+    const next = body[++i];
+    if (next === "n") out += "\n";
+    else if (next === "t") out += "	";
+    else out += next;
+  }
+  return out;
+}
+function serializeEnv(env2) {
+  const keys = Object.keys(env2).sort();
+  const lines = [
+    "# Managed by `vela env`. Values are read by systemd at service start.",
+    ...keys.map((key) => `${key}=${quote(env2[key])}`)
+  ];
+  return lines.join("\n") + "\n";
+}
+function quote(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("	", "\\t");
+  return `"${escaped}"`;
+}
+function readLocalEnvFile(file) {
+  const parsed = dotenv.parse(fs19.readFileSync(file));
+  const result = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (isValidKey(key)) result[key] = value;
+  }
+  return result;
+}
+async function readRemoteEnv(session, instance) {
+  const content = await session.readFile(remotePaths.env(instance));
+  return content ? parseEnv(content) : {};
+}
+async function writeRemoteEnv(session, instance, env2) {
+  const file = remotePaths.env(instance);
+  await session.writeFile(file, serializeEnv(env2), "0600");
+  await session.script(`chown root:root "$1" && chmod 0600 "$1"`, { args: [file] });
+}
+var SUPERUSER_KEYS = [
+  "POCKETBASE_SUPERUSER_EMAIL",
+  "POCKETBASE_SUPERUSER_PASSWORD"
+];
+function touchesSuperuser(keys) {
+  for (const key of keys) {
+    if (SUPERUSER_KEYS.includes(key)) return true;
+  }
+  return false;
+}
+async function restartInstance(session, instance) {
+  const result = await session.script(
+    `instance="$1"
+enabled=()
+for unit in "vela-pb@$instance.service" "vela-web@$instance.service"; do
+	if systemctl is-enabled "$unit" >/dev/null 2>&1; then enabled+=("$unit"); fi
+done
+if [ \${#enabled[@]} -eq 0 ]; then echo NOT_DEPLOYED; exit 0; fi
+systemctl restart "\${enabled[@]}"`,
+    { args: [instance], check: false }
+  );
+  if (result.stdout.includes("NOT_DEPLOYED")) return { deployed: false, restarted: false };
+  if (result.exitCode !== 0) {
+    return { deployed: true, restarted: false, error: result.stderr.trim() };
+  }
+  return { deployed: true, restarted: true };
+}
+
+// src/lib/target.ts
+var LOCAL_TARGET = "local";
+var PRODUCTION_TARGET = "production";
+var TargetError = class extends Error {
+};
+var SERVER_SHAPED = /@|^\d{1,3}(?:\.\d{1,3}){3}$|\.[a-z]{2,}$/i;
+var PREVIEW = "preview";
+var TARGET_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function parseTarget(raw, fallback) {
+  const value = raw?.trim();
+  if (!value) {
+    return fallback === "local" ? { kind: "local" } : production();
+  }
+  if (SERVER_SHAPED.test(value)) {
+    throw new TargetError(
+      `${value} looks like a server, and ${bold("-t")} now selects a target rather than a machine.
+
+Targets are ${bold("local")}, ${bold("production")}, or a name you choose such as ${bold("staging")}.
+To point a target at a server, pass ${bold("--server")} on \`vela deploy\`.`
+    );
+  }
+  const lower = value.toLowerCase();
+  if (lower === LOCAL_TARGET) return { kind: "local" };
+  if (lower === PREVIEW || lower.startsWith(`${PREVIEW}:`)) {
+    const branch = lower.slice(PREVIEW.length + 1) || void 0;
+    return {
+      kind: "preview",
+      branch,
+      // Held for when previews are built, so the grammar and the instance
+      // naming cannot drift apart in the meantime.
+      envTag: branch ? branchToEnvTag(branch) : PREVIEW
+    };
+  }
+  if (value.includes(":")) {
+    throw new TargetError(
+      `${value} is not a target. Only ${bold("preview")} takes a \`:branch\` suffix.`
+    );
+  }
+  if (!TARGET_NAME.test(lower)) {
+    throw new TargetError(
+      `${value} is not a target name.
+
+Use lowercase letters, digits and single dashes, such as ${bold("staging")}.`
+    );
+  }
+  return { kind: "remote", name: lower, envTag: normalizeEnvTag(lower) };
+}
+function production() {
+  return { kind: "remote", name: PRODUCTION_TARGET, envTag: PROD_ENV };
+}
+function describeTarget(target) {
+  switch (target.kind) {
+    case "local":
+      return LOCAL_TARGET;
+    case "preview":
+      return target.branch ? `${PREVIEW}:${target.branch}` : PREVIEW;
+    case "remote":
+      return target.name;
+  }
+}
+function bold(text16) {
+  return `\`${text16}\``;
+}
+
+// src/lib/server-command.ts
+var SERVER_OPTIONS_SCHEMA = {
+  ...SSH_OPTION_SCHEMA,
+  target: v5.optional(v5.string()),
+  server: v5.optional(v5.string())
+};
+var OptionsSchema = v5.object(SERVER_OPTIONS_SCHEMA);
+function addTargetOptions(command, fallback) {
+  return addSshOptions(command).option("-t, --target <target>", "which copy of the app to act on", fallback).option("--server <ssh>", "server this target runs on \u2014 recorded on first use");
+}
+async function withTarget(raw, handlers, run = {}) {
+  const options = parseOptions(OptionsSchema, raw);
+  const target = parseTarget(options.target, "production");
+  const label = run.label ? `vela ${run.label}` : "this command";
+  if (target.kind === "preview") {
+    throw new Error(
+      `Preview targets are not supported yet.
+
+\`${describeTarget(target)}\` parses, but nothing deploys it: previews need wildcard
+DNS and certificates that \`vela provision\` does not set up yet.`
+    );
+  }
+  const { workspaceRootDir } = await getWorkspace();
+  const config = await loadDeployConfig(workspaceRootDir);
+  const app = resolveAppIdentity(workspaceRootDir, {
+    ...config,
+    project: run.project ?? config.project
+  });
+  const base2 = {
+    workspaceRootDir,
+    appName: app.name,
+    appId: app.appId,
+    config
+  };
+  if (target.kind === "local") {
+    if (!handlers.local) {
+      throw new Error(
+        `${label} has no local target.` + (run.localHint ? `
+
+${run.localHint}` : "")
+      );
+    }
+    await handlers.local({
+      ...base2,
+      kind: "local",
+      envFile: envFilePath(workspaceRootDir)
+    });
+    return;
+  }
+  if (!handlers.remote) {
+    throw new Error(`${label} only acts on ${pc5.cyan("local")}.`);
+  }
+  const binding = await ensureBinding(workspaceRootDir, target, {
+    server: options.server,
+    askDomain: run.askDomain
+  });
+  await withSsh(binding.server, sshOptionsFrom(options), async (session) => {
+    await session.detectElevation();
+    await requireProvisioned(session);
+    await syncServerScripts(session);
+    await handlers.remote({
+      ...base2,
+      kind: "remote",
+      session,
+      instance: instanceId(app.appId, target.envTag),
+      envTag: target.envTag,
+      targetName: target.name,
+      server: binding.server,
+      binding
+    });
+  });
+}
+async function ensureBinding(workspaceRootDir, target, request = {}) {
+  const existing = readBinding(workspaceRootDir, target.envTag);
+  const moving = Boolean(request.server && existing && existing.server !== request.server);
+  let server = request.server ?? existing?.server;
+  if (!server) {
+    server = await promptServer(target);
+  }
+  let domain = request.domain ?? existing?.domain;
+  if (!domain && request.askDomain && !request.server) {
+    domain = await promptDomain(target);
+  }
+  const binding = domain ? { server, domain } : { server };
+  if (!existing || existing.server !== server || existing.domain !== domain) {
+    writeBinding(workspaceRootDir, target.envTag, binding);
+  }
+  if (moving) {
+    p19.log.warn(
+      `${pc5.cyan(target.name)} now points at ${pc5.cyan(server)}.
+
+Whatever is running on ${existing.server} is left there, and this project can no
+longer reach it. Remove it there first if that was not intended.`
+    );
+  }
+  return binding;
+}
+async function promptServer(target) {
+  if (!process14.stdout.isTTY || process14.env.CI) {
+    throw new Error(
+      `${target.name} is not bound to a server yet, and there is no terminal to ask on.
+
+Pass ${pc5.cyan("--server user@host")}, or run the command once from your own machine
+and commit ${pc5.cyan(".vela/project.json")}.`
+    );
+  }
+  p19.log.info(`${pc5.cyan(target.name)} is not bound to a server yet.`);
+  const value = await p19.text({
+    message: `Which server should ${target.name} run on?`,
+    placeholder: "root@203.0.113.10",
+    validate: (input) => input?.trim() ? void 0 : "An ssh_config alias, or user@host"
+  });
+  if (p19.isCancel(value)) {
+    p19.cancel("Operation cancelled.");
+    process14.exit(0);
+  }
+  return value.trim();
+}
+async function promptDomain(target) {
+  if (!process14.stdout.isTTY || process14.env.CI) return void 0;
+  const value = await p19.text({
+    message: `Which hostname should ${target.name} be served on?`,
+    placeholder: "example.com \u2014 leave blank to decide later"
+  });
+  if (p19.isCancel(value)) {
+    p19.cancel("Operation cancelled.");
+    process14.exit(0);
+  }
+  return value.trim() || void 0;
+}
+async function applyRestart(ctx) {
+  const outcome = await restartInstance(ctx.session, ctx.instance);
+  if (!outcome.deployed) return;
+  if (outcome.restarted) {
+    p19.log.success("App restarted");
+    return;
+  }
+  p19.log.error(
+    `App restart failed.
+
+The new value is stored and will be used the next time the app starts.
+${pc5.dim(outcome.error ?? "")}`
+  );
+}
+async function applyEnvRestart(ctx, changed) {
+  if (touchesSuperuser(changed)) {
+    p19.log.warn(
+      `PocketBase superuser credentials changed.
+
+The database still holds the old ones, so the app has not been restarted.
+Run ${pc5.cyan("vela deploy")} to push them into the database and restart.`
+    );
+    return;
+  }
+  await applyRestart(ctx);
+}
+async function withServerSession(raw, fn) {
+  const options = parseOptions(OptionsSchema, raw);
+  let server = options.server;
+  if (!server) {
+    const { workspaceRootDir } = await getWorkspace();
+    const target = parseTarget(options.target, "production");
+    if (target.kind !== "remote") {
+      throw new Error(`${describeTarget(target)} does not run on a server.`);
+    }
+    server = (await ensureBinding(workspaceRootDir, target, { server: options.server })).server;
+  }
+  await withSsh(server, sshOptionsFrom(options), async (session) => {
+    await session.detectElevation();
+    await requireProvisioned(session);
+    await syncServerScripts(session);
+    await fn(session);
+  });
+}
+function envFilePath(workspaceRootDir) {
+  return `${workspaceRootDir}/.env`;
+}
+
+// src/commands/destroy/deployment.ts
+var deployment = addTargetOptions(
+  new Command38("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").action(
+  (raw) => runCommand(async () => {
+    const options = raw;
+    await withTarget(
+      raw,
+      {
+        remote: async (ctx) => {
+          if (!options.yes) {
+            await confirm5(ctx.appName, ctx.targetName, ctx.envTag, options.purge === true);
+          }
+          const result = await runServerScript(ctx.session, "destroy.sh", {
+            args: [ctx.instance, ...options.purge ? ["--purge"] : []],
+            stream: true
+          });
+          p20.log.success(
+            `Removed ${pc6.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${ctx.server}.` + (result?.purged ? "" : `
+
+The database and uploads are still in the instance's shared directory. Pass ${pc6.cyan("--purge")} to delete them.`)
+          );
+        }
+      },
+      {
+        label: "destroy deployment",
+        localHint: "There is nothing deployed locally to remove."
+      }
+    );
+  }, "Failed to remove the deployment.")
+);
+async function confirm5(appName, targetName, envTag, purge) {
+  if (isProd(envTag) || purge) {
+    const answer = await p20.text({
+      message: `This removes ${pc6.cyan(`${appName} (${targetName})`)}${purge ? " and its database" : ""}. Type the app name to confirm`,
+      validate: (value) => value === appName ? void 0 : `Type ${appName} to confirm`
+    });
+    if (p20.isCancel(answer)) {
+      p20.cancel("Operation cancelled.");
+      process15.exit(0);
+    }
+    return;
+  }
+  const ok = await p20.confirm({
+    message: `Remove ${appName} (${targetName})?`,
+    initialValue: false
+  });
+  if (p20.isCancel(ok) || !ok) {
+    p20.cancel("Operation cancelled.");
+    process15.exit(0);
+  }
+}
+
+// src/commands/destroy.ts
+var destroy = new Command39("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 Command42 } from "commander";
+
+// src/commands/ui/add.ts
+import { Command as Command40 } from "commander";
+import { exec as exec2 } from "tinyexec";
+import { detect as detect4, resolveCommand as resolveCommand4 } from "package-manager-detector";
+var add = new Command40("add").description("add ui components").argument("<components...>", "the components to add").configureHelp(helpConfig).action(
+  (components) => runCommand(async () => {
+    const { workspaceRootDir } = await getWorkspace();
+    const packageManager = (await detect4({ cwd: workspaceRootDir }))?.name ?? "npm";
+    const resolved = resolveCommand4(packageManager, "execute", [
+      "shadcn-svelte",
+      "add",
+      ...components
+    ]);
+    if (!resolved) {
+      throw new Error(`Unable to resolve execute command for ${packageManager}`);
+    }
+    const args = [...resolved.args];
+    if (packageManager === "npm") args.unshift("--yes");
+    try {
+      await exec2(resolved.command, args, {
+        nodeOptions: { cwd: workspaceRootDir, stdio: "inherit" },
+        throwOnError: true
+      });
+    } catch (error) {
+      const typed = error;
+      throw new Error(
+        `Failed to execute '${resolved.command} ${args.join(" ")}': ${typed.message}`,
+        { cause: typed.output }
+      );
+    }
+    reportResult({
+      summary: `Added ${components.length} UI component(s).`,
+      componentsAdded: components,
+      nextSteps: [
+        `Import a component with: import { Button } from '$lib/components/ui/button';`,
+        "Tweak styling in src/lib/components/ui/<component>/*.svelte.",
+        "Run `vela ui base <color>` to change the palette (slate, gray, zinc, stone, neutral)."
+      ]
+    });
+  }, "Failed to add UI components.")
+);
+
+// src/commands/ui/base.ts
+import fs20 from "node:fs";
+import path20 from "node:path";
+import { Command as Command41, InvalidArgumentError } from "commander";
+var VALID_COLORS = ["slate", "gray", "zinc", "stone", "neutral"];
+function findThemeFile(color) {
+  const candidate = path20.join(templatesDir(), "ui", "css", `${color}.css`);
+  if (!fs20.existsSync(candidate)) {
+    throw new Error(`Theme file not found for color: ${color}`);
+  }
+  return candidate;
+}
+function extractSelectors(css) {
+  const rootMatch = css.match(/:root\s*{[^}]*}/);
+  const darkMatch = css.match(/\.dark\s*{[^}]*}/);
+  if (!rootMatch || !darkMatch) {
+    throw new Error("Invalid theme file: missing :root or .dark selector");
+  }
+  return { root: rootMatch[0], dark: darkMatch[0] };
+}
+function applyTheme(appCss, selectors) {
+  let out = appCss;
+  out = out.match(/:root\s*{[^}]*}/) ? out.replace(/:root\s*{[^}]*}/, selectors.root) : `${selectors.root}
+
+${out}`;
+  out = out.match(/\.dark\s*{[^}]*}/) ? out.replace(/\.dark\s*{[^}]*}/, selectors.dark) : `${out}
+
+${selectors.dark}`;
+  return out;
+}
+var base = new Command41("base").description("change the base color").argument("<color>", "base color to use", (value) => {
+  if (!VALID_COLORS.includes(value)) {
+    throw new InvalidArgumentError(`Valid colors are: ${VALID_COLORS.join(", ")}`);
+  }
+  return value;
+}).configureHelp(helpConfig).action(
+  (color) => runCommand(async () => {
+    const { workspaceRootDir } = await getWorkspace();
+    const appCssPath = path20.join(workspaceRootDir, "src", "app.css");
+    if (!fs20.existsSync(appCssPath)) {
+      throw new Error(`Could not find ${path20.relative(workspaceRootDir, appCssPath)}`);
+    }
+    const themeContent = fs20.readFileSync(findThemeFile(color), "utf8");
+    const selectors = extractSelectors(themeContent);
+    const appCss = fs20.readFileSync(appCssPath, "utf8");
+    fs20.writeFileSync(appCssPath, applyTheme(appCss, selectors));
+    reportResult({
+      summary: `Set base color to ${color}.`,
+      filesModified: [path20.relative(workspaceRootDir, appCssPath)],
+      nextSteps: [
+        "Run your dev server to preview the new palette.",
+        "Tweak individual CSS variables in src/app.css if you want to customize the theme further."
+      ]
+    });
+  }, "Failed to change base color.")
+);
+
+// src/commands/ui.ts
+var ui = new Command42("ui").description("generate ui components").configureHelp(helpConfig).addCommand(add).addCommand(base);
+
+// src/commands/legal.ts
+import { Command as Command45 } from "commander";
+
+// src/commands/legal/terms.ts
+import fs21 from "node:fs";
+import path21 from "node:path";
+import { Command as Command43 } from "commander";
+import * as p22 from "@clack/prompts";
+
+// src/commands/legal/shared.ts
+import process16 from "node:process";
+import * as p21 from "@clack/prompts";
+var sharedFields = {
+  websiteUrl: () => p21.text({
+    message: "What is your website URL?",
+    placeholder: "http://www.mysite.com",
+    validate: (value) => {
+      if (!value || !value.startsWith("http")) {
+        return "Please enter a valid URL starting with http or https";
+      }
+    }
+  }),
+  websiteName: () => p21.text({
+    message: "What is your website name?",
+    placeholder: "My Site",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter a website name";
+      }
+    }
+  }),
+  entityType: () => p21.select({
+    message: "Entity type",
+    options: [
+      {
+        value: "business",
+        label: "I'm a Business",
+        hint: "e.g. Corporation, Limited Liability Company, Non-profit, Partnership, Sole Proprietor"
+      },
+      { value: "individual", label: "I'm an Individual" }
+    ]
+  }),
+  businessName: ({ results }) => results?.entityType === "business" ? p21.text({
+    message: "What is the name of the business?",
+    placeholder: "My Company LLC",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter a business name";
+      }
+    }
+  }) : void 0,
+  businessAddress: ({ results }) => results?.entityType === "business" ? p21.text({
+    message: "What is the address of the business?",
+    placeholder: "1 Cupertino, CA 95014",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter a business address";
+      }
+    }
+  }) : void 0,
+  country: () => p21.text({
+    message: "Enter the country",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter a country";
+      }
+    }
+  }),
+  state: () => p21.text({
+    message: "Enter the state",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter a state";
+      }
+    }
+  })
+};
+var onCancel = () => {
+  p21.cancel("Operation cancelled.");
+  process16.exit(0);
+};
+async function contactMethods(type) {
+  const selection = await p21.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" },
       { value: "page", label: "By visiting a page on our website" },
@@ -3360,11 +4338,11 @@ async function contactMethods(type) {
       { value: "mail", label: "By sending post mail" }
     ]
   });
-  if (p19.isCancel(selection)) onCancel();
+  if (p21.isCancel(selection)) onCancel();
   const contact = selection;
   const details = {};
   if (contact.includes("email")) {
-    const email3 = await p19.text({
+    const email3 = await p21.text({
       message: "What's the email?",
       placeholder: "office@mycompany.com",
       validate: (value) => {
@@ -3373,11 +4351,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p19.isCancel(email3)) onCancel();
+    if (p21.isCancel(email3)) onCancel();
     details.email = email3;
   }
   if (contact.includes("page")) {
-    const page = await p19.text({
+    const page = await p21.text({
       message: "What's the link?",
       placeholder: "http://www.mycompany.com/contact",
       validate: (value) => {
@@ -3386,11 +4364,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p19.isCancel(page)) onCancel();
+    if (p21.isCancel(page)) onCancel();
     details.page = page;
   }
   if (contact.includes("phone")) {
-    const phone = await p19.text({
+    const phone = await p21.text({
       message: "What's the phone number?",
       placeholder: "408.996.1010",
       validate: (value) => {
@@ -3399,11 +4377,11 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p19.isCancel(phone)) onCancel();
+    if (p21.isCancel(phone)) onCancel();
     details.phone = phone;
   }
   if (contact.includes("mail")) {
-    const address = await p19.text({
+    const address = await p21.text({
       message: "What's the address?",
       placeholder: "767 Fifth Avenue New York, NY 10153, United States",
       validate: (value) => {
@@ -3412,7 +4390,7 @@ async function contactMethods(type) {
         }
       }
     });
-    if (p19.isCancel(address)) onCancel();
+    if (p21.isCancel(address)) onCancel();
     details.address = address;
   }
   return { methods: contact, details };
@@ -3808,7 +4786,7 @@ var generateTermsHtml = (answers) => {
 };
 async function termsAction() {
   const { workspaceRootDir, publicRoutesDir } = await getWorkspace();
-  const core = await p20.group(
+  const core = await p22.group(
     {
       websiteUrl: sharedFields.websiteUrl,
       websiteName: sharedFields.websiteName,
@@ -3820,25 +4798,25 @@ async function termsAction() {
     },
     { onCancel }
   );
-  const accounts = await p20.select({
+  const accounts = await p22.select({
     message: "Can users create accounts?",
     options: [
       { value: "yes", label: "Yes, users can create accounts" },
       { value: "no", label: "No" }
     ]
   });
-  if (p20.isCancel(accounts)) onCancel();
-  const userContent = await p20.select({
+  if (p22.isCancel(accounts)) onCancel();
+  const userContent = await p22.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 (p20.isCancel(userContent)) onCancel();
+  if (p22.isCancel(userContent)) onCancel();
   let infringementEmail;
   if (userContent === "yes") {
-    const email3 = await p20.text({
+    const email3 = await p22.text({
       message: "What's the email address where you will receive infringements notices?",
       placeholder: "dmca@website.com",
       validate: (value) => {
@@ -3847,10 +4825,10 @@ async function termsAction() {
         }
       }
     });
-    if (p20.isCancel(email3)) onCancel();
+    if (p22.isCancel(email3)) onCancel();
     infringementEmail = email3;
   }
-  const canBuyGoods = await p20.select({
+  const canBuyGoods = await p22.select({
     message: "Can users buy goods (products, items)?",
     options: [
       {
@@ -3860,28 +4838,28 @@ async function termsAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p20.isCancel(canBuyGoods)) onCancel();
-  const subscriptions2 = await p20.select({
+  if (p22.isCancel(canBuyGoods)) onCancel();
+  const subscriptions2 = await p22.select({
     message: "Do you offer subscription plans?",
     options: [
       { value: "yes", label: "Yes, we offer subscription plans" },
       { value: "no", label: "No" }
     ]
   });
-  if (p20.isCancel(subscriptions2)) onCancel();
+  if (p22.isCancel(subscriptions2)) onCancel();
   let freeTrial;
   if (subscriptions2 === "yes") {
-    const ft = await p20.select({
+    const ft = await p22.select({
       message: "Do you offer a free trial?",
       options: [
         { value: "yes", label: "Yes" },
         { value: "no", label: "No" }
       ]
     });
-    if (p20.isCancel(ft)) onCancel();
+    if (p22.isCancel(ft)) onCancel();
     freeTrial = ft;
   }
-  const exclusiveContent = await p20.select({
+  const exclusiveContent = await p22.select({
     message: "Do you want to make it clear that your own content & trademarks are your exclusive property?",
     options: [
       {
@@ -3891,24 +4869,24 @@ async function termsAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p20.isCancel(exclusiveContent)) onCancel();
-  const feedbackReuse = await p20.select({
+  if (p22.isCancel(exclusiveContent)) onCancel();
+  const feedbackReuse = await p22.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 (p20.isCancel(feedbackReuse)) onCancel();
-  const promotions = await p20.select({
+  if (p22.isCancel(feedbackReuse)) onCancel();
+  const promotions = await p22.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 (p20.isCancel(promotions)) onCancel();
-  const mobileAppRaw = await p20.multiselect({
+  if (p22.isCancel(promotions)) onCancel();
+  const mobileAppRaw = await p22.multiselect({
     message: "Is the Service distributed through any mobile app stores? Check all that apply",
     options: [
       { value: "apple", label: "Apple App Store" },
@@ -3916,7 +4894,7 @@ async function termsAction() {
     ],
     required: false
   });
-  if (p20.isCancel(mobileAppRaw)) onCancel();
+  if (p22.isCancel(mobileAppRaw)) onCancel();
   const mobileApp = mobileAppRaw ?? [];
   const contact = await contactMethods("terms");
   const html = generateTermsHtml({
@@ -3933,22 +4911,22 @@ async function termsAction() {
     mobileApp,
     contact
   });
-  const termsPage = path18.join(
+  const termsPage = path21.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "terms",
     "+page.svelte"
   );
-  const termsPageTs = path18.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
-  fs18.mkdirSync(path18.dirname(termsPage), { recursive: true });
-  fs18.writeFileSync(termsPage, html);
-  fs18.writeFileSync(
+  const termsPageTs = path21.join(workspaceRootDir, publicRoutesDir, LEGAL_DIR, "terms", "+page.ts");
+  fs21.mkdirSync(path21.dirname(termsPage), { recursive: true });
+  fs21.writeFileSync(termsPage, html);
+  fs21.writeFileSync(
     termsPageTs,
     pageMetaTagsLoader("Terms of Service", `Terms of Service for ${core.websiteName}`)
   );
-  const relativeTermsPage = path18.relative(workspaceRootDir, termsPage);
-  const relativeTermsPageTs = path18.relative(workspaceRootDir, termsPageTs);
+  const relativeTermsPage = path21.relative(workspaceRootDir, termsPage);
+  const relativeTermsPageTs = path21.relative(workspaceRootDir, termsPageTs);
   reportResult({
     summary: "Generated placeholder terms and conditions.",
     filesCreated: [relativeTermsPage, relativeTermsPageTs],
@@ -3959,13 +4937,13 @@ async function termsAction() {
     ]
   });
 }
-var terms = new Command42("terms").description("generate placeholder terms and conditions").configureHelp(helpConfig).action(() => runCommand(termsAction, "Failed to generate terms and conditions."));
+var terms = new Command43("terms").description("generate placeholder terms and conditions").configureHelp(helpConfig).action(() => runCommand(termsAction, "Failed to generate terms and conditions."));
 
 // src/commands/legal/privacy.ts
-import fs19 from "node:fs";
-import path19 from "node:path";
-import { Command as Command43 } from "commander";
-import * as p21 from "@clack/prompts";
+import fs22 from "node:fs";
+import path22 from "node:path";
+import { Command as Command44 } from "commander";
+import * as p23 from "@clack/prompts";
 var mapLabels = {
   personalInfo: {
     email: "Email address",
@@ -4052,9 +5030,9 @@ var compute2 = (a) => {
   });
   const piSelections = a.personalInfo ?? [];
   const piLabels = piSelections.map(
-    (v4) => mapLabels.personalInfo[v4] ?? v4
+    (v9) => mapLabels.personalInfo[v9] ?? v9
   );
-  const lookup = (map, vs) => (vs ?? []).map((v4) => map[v4] ?? v4);
+  const lookup = (map, vs) => (vs ?? []).map((v9) => map[v9] ?? v9);
   const companyName = a.core?.entityType === "business" ? a.core?.businessName ?? a.core?.websiteName : a.core?.websiteName ?? "Our Company";
   const companyAddress = a.core?.entityType === "business" ? a.core?.businessAddress ?? "" : "";
   const websiteName = a.core?.websiteName ?? "our website";
@@ -4248,7 +5226,7 @@ var sectionShare = (a, c) => {
 };
 var sectionSaleSharing = (a, c) => {
   const sells = a.showAds === "yes" || a.remarketing === "yes";
-  const intro = sells ? `<p>For purposes of certain U.S. state privacy laws (including the California Consumer Privacy Act, as amended by the California Privacy Rights Act, and the Virginia, Colorado, Connecticut, Utah, Texas, and Oregon consumer privacy laws), our use of cookies, pixels, and similar advertising and analytics technologies \u2014 including for cross-context behavioral advertising and targeted advertising \u2014 may be considered a "sale" or "share" of personal information. The categories of personal information involved typically include online identifiers, IP addresses, internet or other electronic network activity information, and inferences derived from this information.</p>` : '<p>We do not "sell" your personal information for monetary consideration. We do not "share" your personal information for cross-context behavioral advertising as those terms are defined under the California Privacy Rights Act ("CPRA") or comparable U.S. state privacy laws. We do not knowingly sell or share personal information of consumers under 16 years of age.</p>';
+  const intro3 = sells ? `<p>For purposes of certain U.S. state privacy laws (including the California Consumer Privacy Act, as amended by the California Privacy Rights Act, and the Virginia, Colorado, Connecticut, Utah, Texas, and Oregon consumer privacy laws), our use of cookies, pixels, and similar advertising and analytics technologies \u2014 including for cross-context behavioral advertising and targeted advertising \u2014 may be considered a "sale" or "share" of personal information. The categories of personal information involved typically include online identifiers, IP addresses, internet or other electronic network activity information, and inferences derived from this information.</p>` : '<p>We do not "sell" your personal information for monetary consideration. We do not "share" your personal information for cross-context behavioral advertising as those terms are defined under the California Privacy Rights Act ("CPRA") or comparable U.S. state privacy laws. We do not knowingly sell or share personal information of consumers under 16 years of age.</p>';
   let recipients = "";
   if (sells) {
     const partners = [...c.adsPlatforms, ...c.remarketingPlatforms];
@@ -4260,7 +5238,7 @@ var sectionSaleSharing = (a, c) => {
   const optOut = `<p><strong>Your right to opt out.</strong> You have the right to opt out of the sale or sharing of your personal information at any time. To exercise this right, you may use the controls described in the "Tracking Technologies and Cookies" section, change the privacy settings in your browser or mobile device, contact us using the methods listed in the "Contact Us" section, or send an opt-out preference signal \u2014 we honor the Global Privacy Control ("GPC") signal as a request to opt out of sale and sharing for the browser or device on which the signal is detected.</p>`;
   return titledSection(
     "Sale or Sharing of Personal Information; Targeted Advertising",
-    `${intro}${recipients}${optOut}`
+    `${intro3}${recipients}${optOut}`
   );
 };
 var sectionCookies = (a, c) => {
@@ -4299,8 +5277,8 @@ var sectionAutomated = () => titledSection(
   "<p>We do not use your Personal Information to make decisions based solely on automated processing \u2014 including profiling \u2014 that produce legal effects concerning you or similarly significantly affect you, except as may be necessary for entering into or performing a contract with you, where authorized by applicable law, or where you have given your explicit consent. If we ever do, we will provide meaningful information about the logic involved and the significance and envisaged consequences of such processing, and you may request human review of any such decision.</p>"
 );
 var sectionRights = (a, c) => {
-  const intro = '<p>This section describes your privacy rights under applicable laws and how to exercise them. Even if a particular section does not apply to you, you may always contact us using the methods in the "Contact Us" section to ask about your privacy choices.</p>';
-  let body = intro;
+  const intro3 = '<p>This section describes your privacy rights under applicable laws and how to exercise them. Even if a particular section does not apply to you, you may always contact us using the methods in the "Contact Us" section to ask about your privacy choices.</p>';
+  let body = intro3;
   if (a.usStates === "yes") {
     body += subSection("U.S. State Privacy Rights", usStateRightsBlock(c.companyName));
   }
@@ -4383,12 +5361,12 @@ var generatePrivacyHtml = (answers) => {
   return `<section data-role="content">${sections.join("")}</section>`;
 };
 async function promptWithCustom(message, options, customMessage) {
-  const selection = await p21.multiselect({ message, options });
-  if (p21.isCancel(selection)) onCancel();
+  const selection = await p23.multiselect({ message, options });
+  if (p23.isCancel(selection)) onCancel();
   const values = selection;
   if (values.includes("custom")) {
-    const custom = await p21.text({ message: customMessage });
-    if (p21.isCancel(custom)) onCancel();
+    const custom = await p23.text({ message: customMessage });
+    if (p23.isCancel(custom)) onCancel();
     const idx = values.indexOf("custom");
     if (idx !== -1) values.splice(idx, 1);
     if (custom) values.push(String(custom));
@@ -4397,7 +5375,7 @@ async function promptWithCustom(message, options, customMessage) {
 }
 async function privacyAction() {
   const { workspaceRootDir, publicRoutesDir } = await getWorkspace();
-  const core = await p21.group(
+  const core = await p23.group(
     {
       websiteUrl: sharedFields.websiteUrl,
       websiteName: sharedFields.websiteName,
@@ -4409,7 +5387,7 @@ async function privacyAction() {
     },
     { onCancel }
   );
-  const personalInfo = await p21.multiselect({
+  const personalInfo = await p23.multiselect({
     message: "What kind of personal information do you collect from users? Check all that apply",
     options: [
       { value: "email", label: "Email address" },
@@ -4424,16 +5402,16 @@ async function privacyAction() {
     ],
     required: false
   });
-  if (p21.isCancel(personalInfo)) onCancel();
+  if (p23.isCancel(personalInfo)) onCancel();
   const contact = await contactMethods("privacy");
-  const tracking = await p21.select({
+  const tracking = await p23.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 (p21.isCancel(tracking)) onCancel();
+  if (p23.isCancel(tracking)) onCancel();
   let trackingTools;
   if (tracking === "yes") {
     trackingTools = await promptWithCustom(
@@ -4452,7 +5430,7 @@ async function privacyAction() {
       "Enter your custom tracking/analytics tool name"
     );
   }
-  const sendEmails = await p21.select({
+  const sendEmails = await p23.select({
     message: "Do you send emails to users?",
     options: [
       {
@@ -4462,7 +5440,7 @@ async function privacyAction() {
       { value: "no", label: "No" }
     ]
   });
-  if (p21.isCancel(sendEmails)) onCancel();
+  if (p23.isCancel(sendEmails)) onCancel();
   let emailPlatforms;
   if (sendEmails === "yes") {
     emailPlatforms = await promptWithCustom(
@@ -4477,14 +5455,14 @@ async function privacyAction() {
       "Enter your custom email platform"
     );
   }
-  const showAds = await p21.select({
+  const showAds = await p23.select({
     message: "Do you show ads?",
     options: [
       { value: "yes", label: "Yes, we show ads" },
       { value: "no", label: "No" }
     ]
   });
-  if (p21.isCancel(showAds)) onCancel();
+  if (p23.isCancel(showAds)) onCancel();
   let adsPlatforms;
   if (showAds === "yes") {
     adsPlatforms = await promptWithCustom(
@@ -4507,7 +5485,7 @@ async function privacyAction() {
       "Enter your custom ads platform"
     );
   }
-  const canPay = await p21.select({
+  const canPay = await p23.select({
     message: "Can users pay for products or services?",
     options: [
       { value: "yes", label: "Yes, users can pay for our products/services" },
@@ -4517,7 +5495,7 @@ async function privacyAction() {
       }
     ]
   });
-  if (p21.isCancel(canPay)) onCancel();
+  if (p23.isCancel(canPay)) onCancel();
   let paymentProcessors;
   if (canPay === "yes") {
     paymentProcessors = await promptWithCustom(
@@ -4548,14 +5526,14 @@ async function privacyAction() {
       "Enter your custom payment processor/method"
     );
   }
-  const remarketing = await p21.select({
+  const remarketing = await p23.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 (p21.isCancel(remarketing)) onCancel();
+  if (p23.isCancel(remarketing)) onCancel();
   let remarketingPlatforms;
   if (remarketing === "yes") {
     remarketingPlatforms = await promptWithCustom(
@@ -4574,7 +5552,7 @@ async function privacyAction() {
       "Enter your custom remarketing platform"
     );
   }
-  const providersRaw = await p21.multiselect({
+  const providersRaw = await p23.multiselect({
     message: "Select if you use any of the following providers",
     options: [
       { value: "recaptcha", label: "Invisible reCAPTCHA" },
@@ -4585,16 +5563,16 @@ async function privacyAction() {
     ],
     required: false
   });
-  if (p21.isCancel(providersRaw)) onCancel();
+  if (p23.isCancel(providersRaw)) onCancel();
   const providers = providersRaw;
   if (providers.includes("custom")) {
-    const custom = await p21.text({ message: "Enter your custom provider" });
-    if (p21.isCancel(custom)) onCancel();
+    const custom = await p23.text({ message: "Enter your custom provider" });
+    if (p23.isCancel(custom)) onCancel();
     const idx = providers.indexOf("custom");
     if (idx !== -1) providers.splice(idx, 1);
     if (custom) providers.push(String(custom));
   }
-  const usStates = await p21.select({
+  const usStates = await p23.select({
     message: "Include U.S. state privacy rights (CCPA/CPRA, VCDPA, CPA, CTDPA, UCPA, TX, OR, etc.)?",
     options: [
       {
@@ -4605,55 +5583,55 @@ async function privacyAction() {
     ],
     initialValue: "yes"
   });
-  if (p21.isCancel(usStates)) onCancel();
-  const gdpr = await p21.select({
+  if (p23.isCancel(usStates)) onCancel();
+  const gdpr = await p23.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 (p21.isCancel(gdpr)) onCancel();
+  if (p23.isCancel(gdpr)) onCancel();
   let facebookFanPage = "no";
   const facebookDetails = { name: "", url: "" };
   if (gdpr === "yes") {
-    const fan = await p21.select({
+    const fan = await p23.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 (p21.isCancel(fan)) onCancel();
+    if (p23.isCancel(fan)) onCancel();
     facebookFanPage = fan;
     if (facebookFanPage === "yes") {
-      const name = await p21.text({
+      const name = await p23.text({
         message: "What is the name of the Facebook Fan Page?",
         placeholder: "My Facebook Page"
       });
-      if (p21.isCancel(name)) onCancel();
+      if (p23.isCancel(name)) onCancel();
       facebookDetails.name = name;
-      const url = await p21.text({
+      const url = await p23.text({
         message: "What is the URL of the Facebook Fan Page?",
         placeholder: "https://facebook.com/my-facebook-page"
       });
-      if (p21.isCancel(url)) onCancel();
+      if (p23.isCancel(url)) onCancel();
       facebookDetails.url = url;
     }
   }
-  const kids = await p21.select({
+  const kids = await p23.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 (p21.isCancel(kids)) onCancel();
-  const retention = await p21.text({
+  if (p23.isCancel(kids)) onCancel();
+  const retention = await p23.text({
     message: "How long do you retain personal information? (leave blank for default wording)",
     placeholder: "e.g. 12 months after account closure"
   });
-  if (p21.isCancel(retention)) onCancel();
+  if (p23.isCancel(retention)) onCancel();
   const html = generatePrivacyHtml({
     core,
     personalInfo: personalInfo ?? [],
@@ -4676,28 +5654,28 @@ async function privacyAction() {
     kids,
     retention
   });
-  const privacyPage = path19.join(
+  const privacyPage = path22.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.svelte"
   );
-  const privacyPageTs = path19.join(
+  const privacyPageTs = path22.join(
     workspaceRootDir,
     publicRoutesDir,
     LEGAL_DIR,
     "privacy",
     "+page.ts"
   );
-  fs19.mkdirSync(path19.dirname(privacyPage), { recursive: true });
-  fs19.writeFileSync(privacyPage, html);
-  fs19.writeFileSync(
+  fs22.mkdirSync(path22.dirname(privacyPage), { recursive: true });
+  fs22.writeFileSync(privacyPage, html);
+  fs22.writeFileSync(
     privacyPageTs,
     pageMetaTagsLoader("Privacy Policy", `Privacy Policy for ${core.websiteName}`)
   );
-  const relativePrivacyPage = path19.relative(workspaceRootDir, privacyPage);
-  const relativePrivacyPageTs = path19.relative(workspaceRootDir, privacyPageTs);
+  const relativePrivacyPage = path22.relative(workspaceRootDir, privacyPage);
+  const relativePrivacyPageTs = path22.relative(workspaceRootDir, privacyPageTs);
   reportResult({
     summary: "Generated placeholder privacy policy.",
     filesCreated: [relativePrivacyPage, relativePrivacyPageTs],
@@ -4708,23 +5686,23 @@ async function privacyAction() {
     ]
   });
 }
-var privacy = new Command43("privacy").description("generate placeholder privacy policy").configureHelp(helpConfig).action(() => runCommand(privacyAction, "Failed to generate privacy policy."));
+var privacy = new Command44("privacy").description("generate placeholder privacy policy").configureHelp(helpConfig).action(() => runCommand(privacyAction, "Failed to generate privacy policy."));
 
 // src/commands/legal.ts
-var legal = new Command44("legal").description("generate placeholder legal documents").configureHelp(helpConfig).addCommand(terms).addCommand(privacy);
+var legal = new Command45("legal").description("generate placeholder legal documents").configureHelp(helpConfig).addCommand(terms).addCommand(privacy);
 
 // src/commands/fixtures.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/commands/fixtures/load.ts
-import fs20 from "node:fs";
-import path20 from "node:path";
-import { Command as Command45 } from "commander";
+import fs23 from "node:fs";
+import path23 from "node:path";
+import { Command as Command46 } from "commander";
 function getFixtureFiles(cwd) {
-  const fixturesDir = path20.join(cwd, "data", "fixtures");
-  if (!fs20.existsSync(fixturesDir)) return [];
-  return fs20.readdirSync(fixturesDir).filter((file) => file.endsWith(".json")).map((file) => path20.join(fixturesDir, file)).sort((a, b) => a.localeCompare(b)).map((fixturePath) => {
-    const file = path20.basename(fixturePath);
+  const fixturesDir = path23.join(cwd, "data", "fixtures");
+  if (!fs23.existsSync(fixturesDir)) return [];
+  return fs23.readdirSync(fixturesDir).filter((file) => file.endsWith(".json")).map((file) => path23.join(fixturesDir, file)).sort((a, b) => a.localeCompare(b)).map((fixturePath) => {
+    const file = path23.basename(fixturePath);
     const nameWithoutExt = file.replace(/\.json$/i, "");
     const collectionName = nameWithoutExt.replace(/^\d+[-_]?/, "");
     return { collectionName, fixturePath };
@@ -4745,15 +5723,15 @@ async function loadFixtures(pb, workspaceRootDir) {
         `${collectionName} collection already has fixture records. Run \`vela fixtures reset\` to clear and reload, or \`vela fixtures clear\` first.`
       );
     }
-    const items = JSON.parse(fs20.readFileSync(fixturePath, "utf8"));
+    const items = JSON.parse(fs23.readFileSync(fixturePath, "utf8"));
     for (const fixture of items) {
       await pb.collection(collectionName).create(fixture);
     }
-    loaded.push(`${path20.relative(workspaceRootDir, fixturePath)} (${items.length} records)`);
+    loaded.push(`${path23.relative(workspaceRootDir, fixturePath)} (${items.length} records)`);
   }
   return loaded;
 }
-var load = new Command45("load").description("load fixtures into the database").configureHelp(helpConfig).action(
+var load = new Command46("load").description("load fixtures into the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let loaded = [];
@@ -4779,8 +5757,8 @@ var load = new Command45("load").description("load fixtures into the database").
 );
 
 // src/commands/fixtures/clear.ts
-import path21 from "node:path";
-import { Command as Command46 } from "commander";
+import path24 from "node:path";
+import { Command as Command47 } from "commander";
 
 // src/lib/collections.ts
 function dependencyOrder(collections2, startingCollectionId) {
@@ -4842,12 +5820,12 @@ async function clearFixtures(pb, workspaceRootDir) {
       await pb.collection(collectionName).delete(id);
     }
     const fixturePath = fixturePathByName.get(collectionName);
-    const label = fixturePath ? path21.relative(workspaceRootDir, fixturePath) : collectionName;
+    const label = fixturePath ? path24.relative(workspaceRootDir, fixturePath) : collectionName;
     cleared.push(`${label} (${records.length} records)`);
   }
   return cleared;
 }
-var clear = new Command46("clear").description("clear loaded fixtures").configureHelp(helpConfig).action(
+var clear = new Command47("clear").description("clear loaded fixtures").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let cleared = [];
@@ -4876,8 +5854,8 @@ var clear = new Command46("clear").description("clear loaded fixtures").configur
 );
 
 // src/commands/fixtures/reset.ts
-import { Command as Command47 } from "commander";
-var reset = new Command47("reset").description("clear and reload fixtures").configureHelp(helpConfig).action(
+import { Command as Command48 } from "commander";
+var reset = new Command48("reset").description("clear and reload fixtures").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     let cleared = [];
@@ -4907,10 +5885,10 @@ var reset = new Command47("reset").description("clear and reload fixtures").conf
 );
 
 // src/commands/fixtures/generate.ts
-import fs21 from "node:fs";
-import path22 from "node:path";
-import { Command as Command48, InvalidArgumentError as InvalidArgumentError2 } from "commander";
-import * as p22 from "@clack/prompts";
+import fs24 from "node:fs";
+import path25 from "node:path";
+import { Command as Command49, InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import * as p24 from "@clack/prompts";
 import { annotate } from "annotate-json-schema";
 import { createGenerator } from "json-schema-faker";
 import { faker } from "@faker-js/faker";
@@ -4957,10 +5935,10 @@ async function loadCollections(pb) {
   }));
 }
 async function generateFixtureFiles(pb, workspaceRootDir, opts) {
-  const fixturesDir = path22.join(workspaceRootDir, "data", "fixtures");
-  fs21.mkdirSync(fixturesDir, { recursive: true });
-  for (const file of fs21.readdirSync(fixturesDir)) {
-    if (file.endsWith(".json")) fs21.unlinkSync(path22.join(fixturesDir, file));
+  const fixturesDir = path25.join(workspaceRootDir, "data", "fixtures");
+  fs24.mkdirSync(fixturesDir, { recursive: true });
+  for (const file of fs24.readdirSync(fixturesDir)) {
+    if (file.endsWith(".json")) fs24.unlinkSync(path25.join(fixturesDir, file));
   }
   if (opts.seed !== void 0) faker.seed(opts.seed);
   const generator = createGenerator({
@@ -5024,13 +6002,13 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
       items.push(record);
     }
     const filename = `${padZeros(fileIndex, 2)}-${collection.name}.json`;
-    fs21.writeFileSync(path22.join(fixturesDir, filename), JSON.stringify(items, null, 2));
-    writtenFiles.push(`${path22.join("data", "fixtures", filename)} (${items.length} records)`);
+    fs24.writeFileSync(path25.join(fixturesDir, filename), JSON.stringify(items, null, 2));
+    writtenFiles.push(`${path25.join("data", "fixtures", filename)} (${items.length} records)`);
     fileIndex++;
   }
   return { writtenFiles, warnings };
 }
-var generate2 = new Command48("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 Command49("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);
@@ -5059,7 +6037,7 @@ var generate2 = new Command48("generate").description("generate fixture data").o
         seed: opts.seed
       });
     });
-    for (const warning of result.warnings) p22.log.warn(warning);
+    for (const warning of result.warnings) p24.log.warn(warning);
     if (result.writtenFiles.length === 0) {
       reportResult({
         summary: "No eligible collections found to generate fixtures for.",
@@ -5083,8 +6061,8 @@ var generate2 = new Command48("generate").description("generate fixture data").o
 );
 
 // src/commands/fixtures/regen.ts
-import { Command as Command49, InvalidArgumentError as InvalidArgumentError3 } from "commander";
-import * as p23 from "@clack/prompts";
+import { Command as Command50, InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import * as p25 from "@clack/prompts";
 function parseCount2(value) {
   const n = parseInt(value, 10);
   if (!Number.isFinite(n) || n <= 0 || n > 999) {
@@ -5099,7 +6077,7 @@ function parseSeed2(value) {
   }
   return n;
 }
-var regen = new Command49("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 Command50("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 = [];
@@ -5113,7 +6091,7 @@ var regen = new Command49("regen").description("clear the database, regenerate f
       });
       loaded = await loadFixtures(pb, workspaceRootDir);
     });
-    for (const warning of result.warnings) p23.log.warn(warning);
+    for (const warning of result.warnings) p25.log.warn(warning);
     reportResult({
       summary: `Regenerated fixtures (${loaded.length} collection(s) reloaded).`,
       filesCreated: result.writtenFiles,
@@ -5128,26 +6106,26 @@ var regen = new Command49("regen").description("clear the database, regenerate f
 );
 
 // src/commands/fixtures.ts
-var fixtures = new Command50("fixtures").description("manage fixture data").configureHelp(helpConfig).addCommand(generate2).addCommand(load).addCommand(clear).addCommand(reset).addCommand(regen);
+var fixtures = new Command51("fixtures").description("manage fixture data").configureHelp(helpConfig).addCommand(generate2).addCommand(load).addCommand(clear).addCommand(reset).addCommand(regen);
 
 // src/commands/seeds.ts
-import { Command as Command54 } from "commander";
+import { Command as Command55 } from "commander";
 
 // src/commands/seeds/load.ts
-import fs22 from "node:fs";
-import path23 from "node:path";
-import { Command as Command51 } from "commander";
+import fs25 from "node:fs";
+import path26 from "node:path";
+import { Command as Command52 } from "commander";
 function getSeedFiles(cwd) {
-  const seedsDir = path23.join(cwd, "data", "seeds");
-  if (!fs22.existsSync(seedsDir)) return [];
-  return fs22.readdirSync(seedsDir).filter((file) => file.endsWith(".json")).map((file) => path23.join(seedsDir, file)).sort((a, b) => a.localeCompare(b)).map((seedPath) => {
-    const file = path23.basename(seedPath);
+  const seedsDir = path26.join(cwd, "data", "seeds");
+  if (!fs25.existsSync(seedsDir)) return [];
+  return fs25.readdirSync(seedsDir).filter((file) => file.endsWith(".json")).map((file) => path26.join(seedsDir, file)).sort((a, b) => a.localeCompare(b)).map((seedPath) => {
+    const file = path26.basename(seedPath);
     const nameWithoutExt = file.replace(/\.json$/i, "");
     const collectionName = nameWithoutExt.replace(/^\d+[-_]?/, "");
     return { collectionName, seedPath };
   });
 }
-var load2 = new Command51("load").description("load seeds into the database").option("-f, --force", "load even if target collections already have records").configureHelp(helpConfig).action(
+var load2 = new Command52("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);
@@ -5171,11 +6149,11 @@ var load2 = new Command51("load").description("load seeds into the database").op
         }
       }
       for (const { collectionName, seedPath } of seedFiles) {
-        const seeds2 = JSON.parse(fs22.readFileSync(seedPath, "utf8"));
+        const seeds2 = JSON.parse(fs25.readFileSync(seedPath, "utf8"));
         for (const seed of seeds2) {
           await pb.collection(collectionName).create(seed);
         }
-        loaded.push(`${path23.relative(workspaceRootDir, seedPath)} (${seeds2.length} records)`);
+        loaded.push(`${path26.relative(workspaceRootDir, seedPath)} (${seeds2.length} records)`);
       }
     });
     reportResult({
@@ -5190,9 +6168,9 @@ var load2 = new Command51("load").description("load seeds into the database").op
 );
 
 // src/commands/seeds/save.ts
-import fs23 from "node:fs";
-import path24 from "node:path";
-import { Command as Command52 } from "commander";
+import fs26 from "node:fs";
+import path27 from "node:path";
+import { Command as Command53 } from "commander";
 var padZeros2 = (num, length) => num.toString().padStart(length, "0");
 function filterSystemFields(record, systemFieldNames) {
   const out = {};
@@ -5203,18 +6181,18 @@ function filterSystemFields(record, systemFieldNames) {
   }
   return out;
 }
-var save = new Command52("save").description("save the current data as seeds").option("-f, --force", "overwrite existing seed files").configureHelp(helpConfig).action(
+var save = new Command53("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 = path24.join(workspaceRootDir, "data", "seeds");
+    const seedsPath = path27.join(workspaceRootDir, "data", "seeds");
     const existing = getSeedFiles(workspaceRootDir);
     if (existing.length > 0 && !opts.force) {
       throw new Error("Existing seed files found in data/seeds. Pass --force to overwrite.");
     }
-    fs23.mkdirSync(seedsPath, { recursive: true });
+    fs26.mkdirSync(seedsPath, { recursive: true });
     if (opts.force) {
-      for (const file of fs23.readdirSync(seedsPath)) {
-        if (file.endsWith(".json")) fs23.unlinkSync(path24.join(seedsPath, file));
+      for (const file of fs26.readdirSync(seedsPath)) {
+        if (file.endsWith(".json")) fs26.unlinkSync(path27.join(seedsPath, file));
       }
     }
     const saved = [];
@@ -5243,13 +6221,13 @@ var save = new Command52("save").description("save the current data as seeds").o
         const filtered = records.map(
           (r) => filterSystemFields(r, systemFieldNames)
         );
-        const relativeSeedPath = path24.join(
+        const relativeSeedPath = path27.join(
           "data",
           "seeds",
           `${padZeros2(count, 2)}-${collectionName}.json`
         );
-        const seedPath = path24.join(workspaceRootDir, relativeSeedPath);
-        fs23.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
+        const seedPath = path27.join(workspaceRootDir, relativeSeedPath);
+        fs26.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
         saved.push(`${relativeSeedPath} (${filtered.length} records)`);
         count++;
       }
@@ -5275,21 +6253,21 @@ var save = new Command52("save").description("save the current data as seeds").o
 );
 
 // src/commands/seeds/clear.ts
-import fs24 from "node:fs";
-import path25 from "node:path";
-import { Command as Command53 } from "commander";
+import fs27 from "node:fs";
+import path28 from "node:path";
+import { Command as Command54 } from "commander";
 async function clearSeeds(pb, workspaceRootDir, seedFiles) {
   const cleared = [];
   for (const { collectionName, seedPath } of seedFiles) {
-    const seeds2 = JSON.parse(fs24.readFileSync(seedPath, "utf8"));
+    const seeds2 = JSON.parse(fs27.readFileSync(seedPath, "utf8"));
     for (const { id } of seeds2) {
       await pb.collection(collectionName).delete(id);
     }
-    cleared.push(`${path25.relative(workspaceRootDir, seedPath)} (${seeds2.length} records)`);
+    cleared.push(`${path28.relative(workspaceRootDir, seedPath)} (${seeds2.length} records)`);
   }
   return cleared;
 }
-var clear2 = new Command53("clear").description("clear seeded records").configureHelp(helpConfig).action(
+var clear2 = new Command54("clear").description("clear seeded records").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
     const seedFiles = getSeedFiles(workspaceRootDir);
@@ -5320,23 +6298,23 @@ var clear2 = new Command53("clear").description("clear seeded records").configur
 );
 
 // src/commands/seeds.ts
-var seeds = new Command54("seeds").description("manage seed data").configureHelp(helpConfig).addCommand(load2).addCommand(save).addCommand(clear2);
+var seeds = new Command55("seeds").description("manage seed data").configureHelp(helpConfig).addCommand(load2).addCommand(save).addCommand(clear2);
 
 // src/commands/signup.ts
-import { Command as Command56 } from "commander";
-import * as p25 from "@clack/prompts";
+import { Command as Command57 } from "commander";
+import * as p27 from "@clack/prompts";
 import makeFetchCookie2 from "fetch-cookie";
 
 // src/commands/login.ts
-import os2 from "node:os";
-import { Command as Command55 } from "commander";
-import * as p24 from "@clack/prompts";
+import os3 from "node:os";
+import { Command as Command56 } from "commander";
+import * as p26 from "@clack/prompts";
 import makeFetchCookie from "fetch-cookie";
-var login = new Command55("login").description("login to velastack.dev").configureHelp(helpConfig).action(
+var login = new Command56("login").description("login to velastack.dev").configureHelp(helpConfig).action(
   () => runCommand(async () => {
-    const { email: email3, password: password8 } = await p24.group({
-      email: () => p24.text({ message: "Email" }),
-      password: () => p24.password({ message: "Password" })
+    const { email: email3, password: password10 } = await p26.group({
+      email: () => p26.text({ message: "Email" }),
+      password: () => p26.password({ message: "Password" })
     });
     const fetchCookie = makeFetchCookie(fetch);
     const loginRes = await fetchCookie(`${API_URL}/login`, {
@@ -5348,7 +6326,7 @@ var login = new Command55("login").description("login to velastack.dev").configu
       body: new URLSearchParams({
         type: "password",
         email: email3,
-        password: password8
+        password: password10
       }).toString()
     });
     if (!loginRes.headers.get("Set-Cookie")) {
@@ -5358,11 +6336,11 @@ var login = new Command55("login").description("login to velastack.dev").configu
     }
     const apiKey = await issueApiKey(fetchCookie);
     writeConfig({ apiKey });
-    p24.log.success("Logged in to velastack.dev");
+    p26.log.success("Logged in to velastack.dev");
   }, "Failed to login.")
 );
 async function issueApiKey(fetchCookie) {
-  const label = `CLI - ${os2.hostname()}`;
+  const label = `CLI - ${os3.hostname()}`;
   await fetchCookie(`${API_URL}/api-keys/new`, {
     method: "POST",
     headers: {
@@ -5399,14 +6377,14 @@ function extractApiKey(cookie) {
 }
 
 // src/commands/signup.ts
-var signup = new Command56("signup").description("signup to velastack.dev").configureHelp(helpConfig).action(
+var signup = new Command57("signup").description("signup to velastack.dev").configureHelp(helpConfig).action(
   () => runCommand(async () => {
-    const { email: email3, password: password8, passwordConfirm } = await p25.group({
-      email: () => p25.text({ message: "Email" }),
-      password: () => p25.password({ message: "Password" }),
-      passwordConfirm: () => p25.password({ message: "Confirm password" })
+    const { email: email3, password: password10, passwordConfirm } = await p27.group({
+      email: () => p27.text({ message: "Email" }),
+      password: () => p27.password({ message: "Password" }),
+      passwordConfirm: () => p27.password({ message: "Confirm password" })
     });
-    if (password8 !== passwordConfirm) {
+    if (password10 !== passwordConfirm) {
       throw new Error("Passwords do not match.");
     }
     const fetchCookie = makeFetchCookie2(fetch);
@@ -5419,7 +6397,7 @@ var signup = new Command56("signup").description("signup to velastack.dev").conf
       body: new URLSearchParams({
         type: "password",
         email: email3,
-        password: password8,
+        password: password10,
         passwordConfirm
       }).toString()
     });
@@ -5428,33 +6406,33 @@ var signup = new Command56("signup").description("signup to velastack.dev").conf
     }
     const apiKey = await issueApiKey(fetchCookie);
     writeConfig({ apiKey });
-    p25.log.success("Signed up to velastack.dev");
-    p25.log.info("Check your email for a confirmation link.");
+    p27.log.success("Signed up to velastack.dev");
+    p27.log.info("Check your email for a confirmation link.");
   }, "Failed to signup.")
 );
 
 // src/commands/logout.ts
-import { Command as Command57 } from "commander";
-import * as p26 from "@clack/prompts";
-var logout = new Command57("logout").alias("signout").description("logout from velastack.dev").configureHelp(helpConfig).action(
+import { Command as Command58 } from "commander";
+import * as p28 from "@clack/prompts";
+var logout = new Command58("logout").alias("signout").description("logout from velastack.dev").configureHelp(helpConfig).action(
   () => runCommand(() => {
     if (!readConfig()) {
-      p26.log.info("Not logged in");
+      p28.log.info("Not logged in");
       return;
     }
     clearConfig();
-    p26.log.success("Logged out of velastack.dev");
+    p28.log.success("Logged out of velastack.dev");
   })
 );
 
 // src/commands/whoami.ts
-import { Command as Command58 } from "commander";
-import * as p27 from "@clack/prompts";
-var whoami = new Command58("whoami").description("show the current user").configureHelp(helpConfig).action(
+import { Command as Command59 } from "commander";
+import * as p29 from "@clack/prompts";
+var whoami = new Command59("whoami").description("show the current user").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const apiKey = readConfig()?.apiKey;
     if (!apiKey) {
-      p27.log.info("Not logged in. Run `vela login` to login.");
+      p29.log.info("Not logged in. Run `vela login` to login.");
       return;
     }
     const res = await fetch(`${API_URL}/api/collections/users/records`, {
@@ -5462,31 +6440,31 @@ var whoami = new Command58("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.");
-    p27.log.success(`Logged in as ${data.items[0].email}`);
+    p29.log.success(`Logged in as ${data.items[0].email}`);
   })
 );
 
 // src/commands/migrate.ts
-import { Command as Command64 } from "commander";
+import { Command as Command65 } from "commander";
 
 // src/commands/migrate/up.ts
-import { Command as Command59 } from "commander";
+import { Command as Command60 } from "commander";
 
 // src/lib/migrate.ts
-import path26 from "node:path";
-import process14 from "node:process";
+import path29 from "node:path";
+import process17 from "node:process";
 import { x as x2 } from "tinyexec";
 async function runPocketbaseMigrate(args) {
-  const cwd = process14.cwd();
+  const cwd = process17.cwd();
   const { getBinaryPath } = await import("pocketbase-server");
   const binaryPath = getBinaryPath();
   await x2(
     binaryPath,
     [
       "--dir",
-      path26.join(cwd, DATA_DIR),
+      path29.join(cwd, DATA_DIR),
       "--migrationsDir",
-      path26.join(cwd, MIGRATIONS_DIR),
+      path29.join(cwd, MIGRATIONS_DIR),
       "migrate",
       ...args
     ],
@@ -5509,10 +6487,10 @@ async function runMigrateUp() {
     ]
   });
 }
-var up = new Command59("up").description("apply all pending migrations").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations."));
+var up = new Command60("up").description("apply all pending migrations").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations."));
 
 // src/commands/migrate/down.ts
-import { Command as Command60, InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { Command as Command61, InvalidArgumentError as InvalidArgumentError4 } from "commander";
 function parseSteps(value) {
   const n = parseInt(value, 10);
   if (!Number.isFinite(n) || n <= 0) {
@@ -5520,7 +6498,7 @@ function parseSteps(value) {
   }
   return n;
 }
-var down = new Command60("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 Command61("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({
@@ -5534,20 +6512,20 @@ var down = new Command60("down").alias("rollback").description("revert the last
 );
 
 // src/commands/migrate/create.ts
-import fs25 from "node:fs";
-import path27 from "node:path";
-import process15 from "node:process";
-import { Command as Command61 } from "commander";
-var create2 = new Command61("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
+import fs28 from "node:fs";
+import path30 from "node:path";
+import process18 from "node:process";
+import { Command as Command62 } from "commander";
+var create2 = new Command62("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
   (name) => runCommand(async () => {
-    const cwd = process15.cwd();
+    const cwd = process18.cwd();
     const before = listMigrationFiles(cwd);
     await runPocketbaseMigrate(["create", name]);
     const after = listMigrationFiles(cwd);
     const added = [...after].filter((f) => !before.has(f));
     reportResult({
       summary: `Created blank migration ${name}.`,
-      filesCreated: added.map((f) => path27.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path30.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Open the new file in ${MIGRATIONS_DIR}/ and fill in the up/down handlers.`,
         "Run `vela migrate up` to apply the migration once the handlers are written."
@@ -5556,19 +6534,19 @@ var create2 = new Command61("create").alias("new").description("create a new bla
   }, "Failed to create migration.")
 );
 function listMigrationFiles(cwd) {
-  const dir = path27.join(cwd, MIGRATIONS_DIR);
-  if (!fs25.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs25.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  const dir = path30.join(cwd, MIGRATIONS_DIR);
+  if (!fs28.existsSync(dir)) return /* @__PURE__ */ new Set();
+  return new Set(fs28.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/collections.ts
-import fs26 from "node:fs";
-import path28 from "node:path";
-import process16 from "node:process";
-import { Command as Command62 } from "commander";
-var collections = new Command62("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
+import fs29 from "node:fs";
+import path31 from "node:path";
+import process19 from "node:process";
+import { Command as Command63 } from "commander";
+var collections = new Command63("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
   () => runCommand(async () => {
-    const cwd = process16.cwd();
+    const cwd = process19.cwd();
     const before = listMigrationFiles2(cwd);
     await runPocketbaseMigrate(["collections"]);
     const after = listMigrationFiles2(cwd);
@@ -5581,7 +6559,7 @@ var collections = new Command62("collections").alias("snapshot").description("sn
     }
     reportResult({
       summary: "Snapshotted local collections into a new migration.",
-      filesCreated: added.map((f) => path28.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path31.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Review the generated snapshot in ${MIGRATIONS_DIR}/.`,
         "Commit the snapshot so teammates pick up the new schema.",
@@ -5591,14 +6569,14 @@ var collections = new Command62("collections").alias("snapshot").description("sn
   }, "Failed to snapshot collections.")
 );
 function listMigrationFiles2(cwd) {
-  const dir = path28.join(cwd, MIGRATIONS_DIR);
-  if (!fs26.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs26.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  const dir = path31.join(cwd, MIGRATIONS_DIR);
+  if (!fs29.existsSync(dir)) return /* @__PURE__ */ new Set();
+  return new Set(fs29.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/history-sync.ts
-import { Command as Command63 } from "commander";
-var historySync = new Command63("history-sync").description("drop _migrations rows whose files no longer exist").configureHelp(helpConfig).action(
+import { Command as Command64 } from "commander";
+var historySync = new Command64("history-sync").description("drop _migrations rows whose files no longer exist").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     await runPocketbaseMigrate(["history-sync"]);
     reportResult({
@@ -5609,15 +6587,15 @@ var historySync = new Command63("history-sync").description("drop _migrations ro
 );
 
 // src/commands/migrate.ts
-var migrate = new Command64("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 Command65("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 fs27 from "node:fs";
-import path29 from "node:path";
-import process17 from "node:process";
+import fs30 from "node:fs";
+import path32 from "node:path";
+import process20 from "node:process";
 import { performance } from "node:perf_hooks";
-import { Command as Command65, InvalidArgumentError as InvalidArgumentError5 } from "commander";
-import pc5 from "picocolors";
+import { Command as Command66, InvalidArgumentError as InvalidArgumentError5 } from "commander";
+import pc7 from "picocolors";
 import PocketBase2 from "pocketbase";
 function parsePort(value) {
   const port = Number(value);
@@ -5626,38 +6604,38 @@ function parsePort(value) {
   }
   return port;
 }
-var dev = new Command65("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 = process17.cwd();
+var dev = new Command66("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 = process20.cwd();
   const startTime = performance.now();
   const { createServer, version } = await import("vite");
-  const viteMetadataDir = path29.join(cwd, "node_modules", ".vite");
-  const viteMetadataFile = path29.join(viteMetadataDir, "_pocketbase_metadata.json");
+  const viteMetadataDir = path32.join(cwd, "node_modules", ".vite");
+  const viteMetadataFile = path32.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
-  const needsStart = backend3 && !process17.env.POCKETBASE_URL;
+  const needsStart = backend3 && !process20.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
-    if (fs27.existsSync(viteMetadataFile)) fs27.rmSync(viteMetadataFile);
+    if (fs30.existsSync(viteMetadataFile)) fs30.rmSync(viteMetadataFile);
   };
   if (needsStart) {
-    const dataDir = path29.join(cwd, DATA_DIR);
+    const dataDir = path32.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path29.join(dataDir, "hooks"),
+      hooksDir: path32.join(dataDir, "hooks"),
       dev: true,
       stdio: "pipe"
     });
     pbProc = started.proc;
-    process17.env.POCKETBASE_URL = started.url;
-    pbProc.stdout?.pipe(process17.stdout);
-    pbProc.stderr?.pipe(process17.stderr);
+    process20.env.POCKETBASE_URL = started.url;
+    pbProc.stdout?.pipe(process20.stdout);
+    pbProc.stderr?.pipe(process20.stderr);
     pbProc.on("error", (err) => console.error("PocketBase error:", err));
     pbProc.on("exit", (code) => console.log(`PocketBase exited with code ${code}`));
-    process17.on("exit", cleanup);
-    process17.on("SIGINT", () => {
+    process20.on("exit", cleanup);
+    process20.on("SIGINT", () => {
       cleanup();
-      process17.exit(0);
+      process20.exit(0);
     });
   }
   const serverOptions = {};
@@ -5675,31 +6653,31 @@ var dev = new Command65("dev").description("start the development server").optio
     if (!backend3) return;
     const { address, port: vitePort } = server.httpServer.address();
     const viteHost = address === "::1" ? "localhost" : address;
-    await fs27.promises.mkdir(viteMetadataDir, { recursive: true });
-    await fs27.promises.writeFile(
+    await fs30.promises.mkdir(viteMetadataDir, { recursive: true });
+    await fs30.promises.writeFile(
       viteMetadataFile,
       JSON.stringify({
-        pocketbaseUrl: process17.env.POCKETBASE_URL,
+        pocketbaseUrl: process20.env.POCKETBASE_URL,
         vitePort,
         viteHost
       })
     );
-    const pb = new PocketBase2(process17.env.POCKETBASE_URL);
+    const pb = new PocketBase2(process20.env.POCKETBASE_URL);
     await pb.collection("_superusers").authWithPassword(
-      process17.env.POCKETBASE_SUPERUSER_EMAIL,
-      process17.env.POCKETBASE_SUPERUSER_PASSWORD
+      process20.env.POCKETBASE_SUPERUSER_EMAIL,
+      process20.env.POCKETBASE_SUPERUSER_PASSWORD
     );
     await pb.settings.update({ meta: { appURL: `http://${viteHost}:${vitePort}` } });
     await startWatchingTypes(cwd, pb);
   });
   await server.listen();
-  const hasExistingLogs = process17.stdout.bytesWritten > 0 || process17.stderr.bytesWritten > 0;
-  const startupDurationString = pc5.dim(
-    `ready in ${pc5.reset(pc5.bold(Math.ceil(performance.now() - startTime)))} ms`
+  const hasExistingLogs = process20.stdout.bytesWritten > 0 || process20.stderr.bytesWritten > 0;
+  const startupDurationString = pc7.dim(
+    `ready in ${pc7.reset(pc7.bold(Math.ceil(performance.now() - startTime)))} ms`
   );
   server.config.logger.info(
     `
-  ${pc5.green(`${pc5.bold("VITE")} v${version}`)}  ${startupDurationString}
+  ${pc7.green(`${pc7.bold("VITE")} v${version}`)}  ${startupDurationString}
 `,
     { clear: !hasExistingLogs }
   );
@@ -5708,18 +6686,18 @@ var dev = new Command65("dev").description("start the development server").optio
 });
 async function startWatchingTypes(cwd, pb) {
   const { processTypes } = await import("@velastack/pocketbase-codegen");
-  const typesDir = path29.resolve(cwd, ".svelte-kit", "types");
-  const pocketbaseDir = path29.join(typesDir, "pocketbase");
-  const pocketbaseTypes = path29.join(pocketbaseDir, "$types.d.ts");
+  const typesDir = path32.resolve(cwd, ".svelte-kit", "types");
+  const pocketbaseDir = path32.join(typesDir, "pocketbase");
+  const pocketbaseTypes = path32.join(pocketbaseDir, "$types.d.ts");
   const regenerate = () => processTypes(pb, typesDir).catch(() => {
   });
   await regenerate();
   void (async () => {
     for (; ; ) {
       try {
-        await fs27.promises.mkdir(pocketbaseDir, { recursive: true });
-        for await (const event of fs27.promises.watch(pocketbaseDir)) {
-          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs27.existsSync(pocketbaseTypes)) {
+        await fs30.promises.mkdir(pocketbaseDir, { recursive: true });
+        for await (const event of fs30.promises.watch(pocketbaseDir)) {
+          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs30.existsSync(pocketbaseTypes)) {
             setTimeout(regenerate, 100);
           }
         }
@@ -5731,117 +6709,540 @@ async function startWatchingTypes(cwd, pb) {
 }
 
 // src/commands/build.ts
-import path30 from "node:path";
-import process18 from "node:process";
-import { Command as Command66 } from "commander";
+import path33 from "node:path";
+import process21 from "node:process";
+import { Command as Command67 } from "commander";
 import { x as x3 } from "tinyexec";
 import { detect as detect5 } from "package-manager-detector";
 import { resolveCommand as resolveCommand5 } from "package-manager-detector/commands";
-var build = new Command66("build").description("build the app").configureHelp(helpConfig).action(async () => {
-  process18.env.VITE_BUILD = "true";
-  const cwd = process18.cwd();
+var build = new Command67("build").description("build the app").configureHelp(helpConfig).action(async () => {
+  process21.env.VITE_BUILD = "true";
+  const cwd = process21.cwd();
+  let pbProc;
+  const needsStart = hasBackend(cwd) && !process21.env.POCKETBASE_URL;
+  const cleanup = () => {
+    if (pbProc?.pid) pbProc.kill();
+  };
+  if (needsStart) {
+    await ensureSuperuser(cwd);
+    const dataDir = path33.join(cwd, DATA_DIR);
+    const started = await startPocketbaseServe({
+      dataDir,
+      migrationsDir: MIGRATIONS_DIR,
+      hooksDir: path33.join(dataDir, "hooks"),
+      dev: true
+    });
+    pbProc = started.proc;
+    process21.env.POCKETBASE_URL = started.url;
+    process21.on("exit", cleanup);
+    process21.on("SIGINT", () => {
+      cleanup();
+      process21.exit(0);
+    });
+  }
+  try {
+    const pm = (await detect5({ cwd }))?.name ?? "npm";
+    const resolved = resolveCommand5(pm, "execute", ["vite", "build"]);
+    const args = resolved.args.slice();
+    if (pm === "npm") args.unshift("--yes");
+    await x3(resolved.command, args, {
+      nodeOptions: { cwd, stdio: "inherit" },
+      throwOnError: true
+    });
+  } finally {
+    cleanup();
+  }
+});
+
+// src/commands/preview.ts
+import path34 from "node:path";
+import process22 from "node:process";
+import { Command as Command68 } 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 Command68("preview").description("preview the built app").configureHelp(helpConfig).action(async () => {
+  const cwd = process22.cwd();
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process18.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process22.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
-    const dataDir = path30.join(cwd, DATA_DIR);
+    const dataDir = path34.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path30.join(dataDir, "hooks"),
+      hooksDir: path34.join(dataDir, "hooks"),
       dev: true
     });
     pbProc = started.proc;
-    process18.env.POCKETBASE_URL = started.url;
-    process18.on("exit", cleanup);
-    process18.on("SIGINT", () => {
+    process22.env.POCKETBASE_URL = started.url;
+    process22.on("exit", cleanup);
+    process22.on("SIGINT", () => {
       cleanup();
-      process18.exit(0);
+      process22.exit(0);
+    });
+  }
+  try {
+    const pm = (await detect6({ cwd }))?.name ?? "npm";
+    const resolved = resolveCommand6(pm, "execute", ["vite", "preview"]);
+    const args = resolved.args.slice();
+    if (pm === "npm") args.unshift("--yes");
+    await x4(resolved.command, args, {
+      nodeOptions: { cwd, stdio: "inherit" },
+      throwOnError: true
+    });
+  } finally {
+    cleanup();
+  }
+});
+
+// src/commands/sync.ts
+import path35 from "node:path";
+import { Command as Command69 } from "commander";
+var sync = new Command69("sync").description("sync types from the database").configureHelp(helpConfig).action(
+  () => runCommand(async () => {
+    const { workspaceRootDir } = await getWorkspace();
+    const typesDir = path35.join(workspaceRootDir, ".svelte-kit", "types");
+    const { processTypes } = await import("@velastack/pocketbase-codegen");
+    await withPocketbase(workspaceRootDir, async (pb) => {
+      await processTypes(pb, typesDir);
+    });
+    console.log("types synced");
+  }, "Failed to sync types.")
+);
+
+// src/commands/provision.ts
+import { Command as Command70 } from "commander";
+import * as p30 from "@clack/prompts";
+import pc8 from "picocolors";
+import * as v6 from "valibot";
+var OptionsSchema2 = v6.object({
+  ...SSH_OPTION_SCHEMA,
+  pbVersion: v6.optional(v6.string()),
+  nodeMajor: v6.optional(v6.string())
+});
+var provision = addSshOptions(
+  new Command70("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();
+    p30.intro(pc8.bgCyan(pc8.black(" vela provision ")));
+    p30.log.info(`Target ${pc8.cyan(target)}`);
+    await withSsh(target, sshOptionsFrom(options), async (session) => {
+      await session.detectElevation();
+      const existing = await readServerInfo(session);
+      if (existing) {
+        p30.log.info(
+          `Already provisioned by vela ${existing.cliVersion} on ${existing.provisionedAt}. Bringing it up to date.`
+        );
+      }
+      p30.log.step("Uploading server scripts");
+      await syncServerScripts(session);
+      p30.log.step("Running provision");
+      const result = await runServerScript(session, "provision.sh", {
+        args: [
+          "--pb-version",
+          pbVersion,
+          "--node-major",
+          options.nodeMajor ?? "22",
+          "--cli-version",
+          package_default.version
+        ],
+        stream: true
+      });
+      p30.log.success(
+        `${target} is ready.
+
+  Node        ${result?.node ?? "installed"}
+  Caddy       ${result?.caddy ?? "installed"}
+  PocketBase  ${result?.pocketbase ?? pbVersion}`
+      );
     });
+    p30.outro(`Deploy with ${pc8.cyan(`vela deploy --server ${target}`)}`);
+  }, "Failed to provision.")
+);
+
+// src/commands/deploy.ts
+import path38 from "node:path";
+import fs33 from "node:fs";
+import { Command as Command71 } from "commander";
+import * as p31 from "@clack/prompts";
+import pc9 from "picocolors";
+import * as v7 from "valibot";
+
+// src/lib/pocketbase-settings.ts
+import fs31 from "node:fs";
+import path36 from "node:path";
+import process23 from "node:process";
+import PocketBase4 from "pocketbase";
+
+// src/lib/remote-pocketbase.ts
+import PocketBase3 from "pocketbase";
+async function openRemoteDatabase(session, instance) {
+  const [state] = await readInstanceStates(session, instance);
+  const pbPort = state?.pbPort;
+  if (!pbPort) {
+    throw new Error(
+      `${instance} has no deployed database yet.
+
+Run \`vela deploy\` first \u2014 the database is created by the first deploy.`
+    );
+  }
+  const env2 = await readRemoteEnv(session, instance);
+  const email3 = env2.POCKETBASE_SUPERUSER_EMAIL;
+  const password10 = env2.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!email3 || !password10) {
+    throw new Error(
+      `${instance} has no PocketBase superuser credentials in its environment.
+
+A deploy creates them. Deploy again to repair this instance.`
+    );
+  }
+  const localPort = await findFreePort("127.0.0.1");
+  await session.forwardLocalPort(localPort, "127.0.0.1", pbPort);
+  return {
+    url: `http://127.0.0.1:${localPort}`,
+    email: email3,
+    password: password10,
+    close: () => session.cancelForward(localPort, "127.0.0.1", pbPort)
+  };
+}
+async function withRemotePocketbase(session, instance, fn) {
+  const db = await openRemoteDatabase(session, instance);
+  try {
+    const pb = new PocketBase3(db.url);
+    await authWithRetries(pb, db.email, db.password);
+    return await fn(pb);
+  } finally {
+    await db.close();
+  }
+}
+
+// src/lib/pocketbase-settings.ts
+var COPIED_KEYS = ["appName", "senderName", "senderAddress"];
+async function readLocalMeta(cwd) {
+  const dataDir = path36.join(cwd, DATA_DIR);
+  if (!fs31.existsSync(dataDir)) return null;
+  const email3 = process23.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password10 = process23.env.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!email3 || !password10) return null;
+  let proc;
+  try {
+    const started = await startPocketbaseServe({
+      dataDir,
+      migrationsDir: MIGRATIONS_DIR,
+      hooksDir: path36.join(dataDir, "hooks")
+    });
+    proc = started.proc;
+    const pb = new PocketBase4(started.url);
+    await authWithRetries(pb, email3, password10);
+    const settings = await pb.settings.getAll();
+    return settings.meta ?? null;
+  } catch {
+    return null;
+  } finally {
+    proc?.kill();
+  }
+}
+async function seedRemoteMeta(session, instance, local, appURL) {
+  const patch = {};
+  for (const key of COPIED_KEYS) {
+    const value = local[key];
+    if (typeof value === "string" && value.trim()) patch[key] = value;
+  }
+  if (appURL) patch.appURL = appURL;
+  if (Object.keys(patch).length === 0) return [];
+  await withRemotePocketbase(session, instance, async (pb) => {
+    const settings = await pb.settings.getAll();
+    await pb.settings.update({ meta: { ...settings.meta ?? {}, ...patch } });
+  });
+  return Object.keys(patch);
+}
+
+// src/lib/artifact.ts
+import fs32 from "node:fs";
+import path37 from "node:path";
+import { detect as detect7 } from "package-manager-detector";
+import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
+var DEFAULT_OUTPUT_DIR = "build";
+var BuildError = class extends Error {
+};
+async function runBuild(cwd, buildCommand, env2) {
+  if (buildCommand) {
+    const result2 = await spawnCapture("bash", ["-lc", buildCommand], {
+      cwd,
+      stream: true,
+      streamStdout: true,
+      env: env2
+    });
+    if (result2.exitCode !== 0)
+      throw new BuildError(`\`${buildCommand}\` exited ${result2.exitCode}.`);
+    return;
+  }
+  const pm = (await detect7({ cwd }))?.name ?? "npm";
+  const resolved = resolveCommand7(pm, "run", ["build"]);
+  if (!resolved) throw new BuildError(`Could not work out how to run a build with ${pm}.`);
+  const result = await spawnCapture(resolved.command, resolved.args, {
+    cwd,
+    stream: true,
+    streamStdout: true,
+    env: env2
+  });
+  if (result.exitCode !== 0) {
+    throw new BuildError(
+      `\`${resolved.command} ${resolved.args.join(" ")}\` exited ${result.exitCode}.`
+    );
   }
+}
+function collectArtifact(cwd, config = {}) {
+  const outputDir = config.outputDir ?? DEFAULT_OUTPUT_DIR;
+  const entries = [];
+  const add2 = (rel, remoteDir = "") => {
+    const localPath = path37.join(cwd, rel);
+    if (fs32.existsSync(localPath)) entries.push({ localPath, remoteDir });
+  };
+  const buildPath = path37.join(cwd, outputDir);
+  if (!fs32.existsSync(path37.join(buildPath, "index.js"))) {
+    throw new BuildError(
+      `No ${outputDir}/index.js after the build.
+
+Deploying to a server needs @sveltejs/adapter-node. Install it and set it as
+the adapter in your Vite or Svelte config, then build again.`
+    );
+  }
+  entries.push({ localPath: buildPath, remoteDir: "" });
+  add2("package.json");
+  add2("package-lock.json");
+  add2(".npmrc");
+  add2(MIGRATIONS_DIR);
+  const hooks = path37.join(cwd, DATA_DIR, "hooks");
+  if (fs32.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
+  for (const extra of config.include ?? []) add2(extra);
+  return entries;
+}
+async function gitSha(cwd) {
+  const result = await spawnCapture("git", ["rev-parse", "HEAD"], { cwd });
+  return result.exitCode === 0 ? result.stdout.trim() : "";
+}
+
+// src/commands/deploy.ts
+var OptionsSchema3 = v7.object({
+  ...SSH_OPTION_SCHEMA,
+  env: v7.optional(v7.string()),
+  project: v7.optional(v7.string()),
+  remoteDb: v7.optional(v7.boolean()),
+  domain: v7.optional(v7.string()),
+  healthPath: v7.optional(v7.string()),
+  keep: v7.optional(v7.string()),
+  pbVersion: v7.optional(v7.string()),
+  build: v7.optional(v7.boolean())
+});
+var deploy = addTargetOptions(
+  new Command71("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").option(
+  "--remote-db",
+  "render the build against the database on the server, over an SSH tunnel \u2014 needed when pages are prerendered from data"
+).action(
+  (raw) => runCommand(async () => {
+    const options = parseOptions(OptionsSchema3, raw);
+    const backend3 = hasBackend();
+    const release = releaseId();
+    p31.intro(pc9.bgCyan(pc9.black(" vela deploy ")));
+    await withTarget(
+      raw,
+      {
+        remote: async (ctx) => {
+          const { session, instance, workspaceRootDir, config } = ctx;
+          p31.log.info(
+            `${pc9.cyan(ctx.appName)} ${pc9.dim("\u2192")} ${pc9.cyan(ctx.targetName)} ${pc9.dim(`(${ctx.server})`)}`
+          );
+          const [existing] = await readInstanceStates(session, instance);
+          const domain = options.domain ?? ctx.binding.domain ?? config.deploy?.domain ?? existing?.domain ?? "";
+          const remoteDb = options.remoteDb ?? config.deploy?.buildAgainstRemote ?? false;
+          if (options.build !== false) {
+            let buildEnv = {};
+            let tunnel = null;
+            if (backend3 && remoteDb) {
+              tunnel = await openDatabaseTunnel(session, instance, existing);
+              buildEnv = tunnel.env;
+              p31.log.info(
+                `Building against the ${pc9.cyan(ctx.targetName)} database on ${ctx.server} ${pc9.dim(`(port ${tunnel.pbPort})`)}`
+              );
+            } else if (backend3) {
+              await ensureSuperuser(workspaceRootDir);
+            }
+            p31.log.step("Building");
+            try {
+              await runBuild(workspaceRootDir, config.deploy?.buildCommand, buildEnv);
+            } finally {
+              if (tunnel) await tunnel.close();
+            }
+          }
+          const entries = collectArtifact(workspaceRootDir, config.deploy ?? {});
+          const sha = await gitSha(workspaceRootDir);
+          p31.log.step(`Uploading release ${pc9.dim(release)}`);
+          await uploadRelease(session, instance, release, entries);
+          p31.log.step("Activating");
+          const result = await runServerScript(session, "apply.sh", {
+            args: [
+              instance,
+              release,
+              "--name",
+              ctx.appName,
+              "--app-id",
+              ctx.appId,
+              "--env",
+              ctx.envTag,
+              "--domain",
+              domain,
+              "--health-path",
+              options.healthPath ?? config.deploy?.healthCheckPath ?? "/",
+              "--keep",
+              options.keep ?? String(config.deploy?.keepReleases ?? 5),
+              "--backend",
+              backend3 ? "1" : "0",
+              "--pb-version",
+              options.pbVersion ?? config.deploy?.pocketbaseVersion ?? pocketbaseVersion(),
+              "--git-sha",
+              sha
+            ],
+            stream: true
+          });
+          writeBinding(workspaceRootDir, ctx.envTag, {
+            server: ctx.server,
+            domain: domain || void 0
+          });
+          if (!existing) await reportEmptyEnvironment(session, instance, workspaceRootDir);
+          const url = result?.url ?? "";
+          p31.log.success(
+            `Deployed ${pc9.cyan(ctx.appName)} ${pc9.dim(release)}
+
+  URL   ${url}
+  Port  ${result?.webPort ?? "?"}${backend3 ? ` (PocketBase ${result?.pbPort ?? "?"})` : ""}`
+          );
+          if (result?.superuserCreated) {
+            await copyLocalBranding(
+              session,
+              instance,
+              workspaceRootDir,
+              domain ? result?.url ?? "" : ""
+            );
+            p31.log.info(
+              `Created the PocketBase superuser this app authenticates as.
+
+Its credentials are stored in the environment on the server. To use
+your own instead, ${pc9.cyan("vela env set POCKETBASE_SUPERUSER_PASSWORD")}
+and deploy again.`
+            );
+          }
+          if (!domain) {
+            p31.log.warn(
+              `No domain configured, so nothing is proxied to this app yet.
+Redeploy with ${pc9.cyan("--domain example.com")} once DNS points at ${ctx.server}.`
+            );
+          }
+        }
+      },
+      { project: options.project, askDomain: true, label: "deploy" }
+    );
+    p31.outro(`${pc9.cyan("vela status")} to see what is running`);
+  }, "Failed to deploy.")
+);
+async function copyLocalBranding(session, instance, workspaceRootDir, appURL) {
+  const local = await readLocalMeta(workspaceRootDir);
+  if (!local) return;
   try {
-    const pm = (await detect5({ cwd }))?.name ?? "npm";
-    const resolved = resolveCommand5(pm, "execute", ["vite", "build"]);
-    const args = resolved.args.slice();
-    if (pm === "npm") args.unshift("--yes");
-    await x3(resolved.command, args, {
-      nodeOptions: { cwd, stdio: "inherit" },
-      throwOnError: true
-    });
-  } finally {
-    cleanup();
+    const copied = await seedRemoteMeta(session, instance, local, appURL);
+    if (copied.length === 0) return;
+    const outcome = await restartInstance(session, instance);
+    if (outcome.deployed && !outcome.restarted) {
+      p31.log.warn(
+        `Copied ${copied.join(", ")}, but the app did not restart to pick them up.
+${pc9.dim(outcome.error ?? "")}`
+      );
+      return;
+    }
+    p31.log.success(`Copied ${copied.join(", ")} from this project's database`);
+  } catch (err) {
+    p31.log.warn(
+      `Could not copy this project's PocketBase settings across.
+Set them in the admin panel instead. ${pc9.dim(String(err))}`
+    );
   }
-});
+}
+async function openDatabaseTunnel(session, instance, state) {
+  const pbPort = state?.pbPort;
+  if (!pbPort) {
+    throw new Error(
+      `--remote-db needs an existing deployment to build against, and ${instance} has not been deployed yet.
 
-// src/commands/preview.ts
-import path31 from "node:path";
-import process19 from "node:process";
-import { Command as Command67 } 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 Command67("preview").description("preview the built app").configureHelp(helpConfig).action(async () => {
-  const cwd = process19.cwd();
-  let pbProc;
-  const needsStart = hasBackend(cwd) && !process19.env.POCKETBASE_URL;
-  const cleanup = () => {
-    if (pbProc?.pid) pbProc.kill();
+Deploy once without it, then turn it on.`
+    );
+  }
+  const remoteEnv = await readRemoteEnv(session, instance);
+  const email3 = remoteEnv.POCKETBASE_SUPERUSER_EMAIL;
+  const password10 = remoteEnv.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!email3 || !password10) {
+    throw new Error(
+      `--remote-db renders the build as the superuser of ${instance}, and that environment has no credentials for one.
+
+Set them with \`vela env set POCKETBASE_SUPERUSER_EMAIL\` and \`vela env set POCKETBASE_SUPERUSER_PASSWORD\`.`
+    );
+  }
+  const localPort = await findFreePort("127.0.0.1");
+  await session.forwardLocalPort(localPort, "127.0.0.1", pbPort);
+  return {
+    pbPort,
+    env: {
+      POCKETBASE_URL: `http://127.0.0.1:${localPort}`,
+      POCKETBASE_SUPERUSER_EMAIL: email3,
+      POCKETBASE_SUPERUSER_PASSWORD: password10
+    },
+    close: () => session.cancelForward(localPort, "127.0.0.1", pbPort)
   };
-  if (needsStart) {
-    const dataDir = path31.join(cwd, DATA_DIR);
-    const started = await startPocketbaseServe({
-      dataDir,
-      migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path31.join(dataDir, "hooks"),
-      dev: true
-    });
-    pbProc = started.proc;
-    process19.env.POCKETBASE_URL = started.url;
-    process19.on("exit", cleanup);
-    process19.on("SIGINT", () => {
-      cleanup();
-      process19.exit(0);
-    });
+}
+async function uploadRelease(session, instance, release, entries) {
+  const dir = remotePaths.release(instance, release);
+  await session.script(`mkdir -p "$1"`, { args: [dir] });
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const target = entry.remoteDir ? `${dir}/${entry.remoteDir}` : dir;
+    const source = entry.remoteDir && isDirectory(entry.localPath) ? `${entry.localPath}/` : entry.localPath;
+    byTarget.set(target, [...byTarget.get(target) ?? [], source]);
+  }
+  for (const [target, sources] of byTarget) {
+    if (target !== dir) await session.script(`mkdir -p "$1"`, { args: [target] });
+    await session.upload(sources, target);
   }
+}
+function isDirectory(target) {
   try {
-    const pm = (await detect6({ cwd }))?.name ?? "npm";
-    const resolved = resolveCommand6(pm, "execute", ["vite", "preview"]);
-    const args = resolved.args.slice();
-    if (pm === "npm") args.unshift("--yes");
-    await x4(resolved.command, args, {
-      nodeOptions: { cwd, stdio: "inherit" },
-      throwOnError: true
-    });
-  } finally {
-    cleanup();
+    return fs33.statSync(target).isDirectory();
+  } catch {
+    return false;
   }
-});
-
-// src/commands/sync.ts
-import path32 from "node:path";
-import { Command as Command68 } from "commander";
-var sync = new Command68("sync").description("sync types from the database").configureHelp(helpConfig).action(
-  () => runCommand(async () => {
-    const { workspaceRootDir } = await getWorkspace();
-    const typesDir = path32.join(workspaceRootDir, ".svelte-kit", "types");
-    const { processTypes } = await import("@velastack/pocketbase-codegen");
-    await withPocketbase(workspaceRootDir, async (pb) => {
-      await processTypes(pb, typesDir);
-    });
-    console.log("types synced");
-  }, "Failed to sync types.")
-);
+}
+async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
+  const remote = await readRemoteEnv(session, instance);
+  if (Object.keys(remote).length > 0) return;
+  if (!fs33.existsSync(path38.join(workspaceRootDir, ".env"))) return;
+  p31.log.warn(
+    `This app has no production environment variables yet.
 
-// src/commands/provision.ts
-var provision = stubCommand("provision", "provision cloud resources");
+Local ${pc9.cyan(".env")} values are not uploaded by a deploy. Set them with
+${pc9.cyan("vela env set KEY")}, or copy a file across with ${pc9.cyan("vela env import .env.production")}.`
+  );
+}
 
-// src/commands/deploy.ts
-import path33 from "node:path";
-import process20 from "node:process";
-import { Command as Command69 } from "commander";
-import * as p28 from "@clack/prompts";
+// src/commands/link.ts
+import path39 from "node:path";
+import process24 from "node:process";
+import { Command as Command72 } from "commander";
+import * as p32 from "@clack/prompts";
 
 // src/lib/velastack-api.ts
 async function apiFetch(apiKey, pathAndQuery, init) {
@@ -5890,14 +7291,14 @@ async function createProject2(apiKey, args) {
   });
 }
 
-// src/commands/deploy.ts
+// src/commands/link.ts
 var CREATE_NEW = "__new__";
-var deploy = new Command69("deploy").description("deploy the app").configureHelp(helpConfig).action(() => runCommand(linkProject, "Failed to deploy."));
+var link = new Command72("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) {
-    p28.log.success(`Linked to ${existing.projectName}.`);
+    p32.log.success(`Linked to ${existing.projectName}.`);
     return;
   }
   const apiKey = requireApiKey();
@@ -5924,10 +7325,10 @@ async function linkProject() {
     projectName = created.name;
   }
   writeProjectConfig(workspaceRootDir, { projectId, teamId, projectName });
-  p28.log.success(`Linked to ${projectName}.`);
+  p32.log.success(`Linked to ${projectName}.`);
 }
 async function pickExistingProject(projects) {
-  const choice = await p28.select({
+  const choice = await p32.select({
     message: "Select a project",
     options: [
       ...projects.map((pr) => ({
@@ -5937,79 +7338,655 @@ async function pickExistingProject(projects) {
       { value: CREATE_NEW, label: "Create a new project" }
     ]
   });
-  if (p28.isCancel(choice)) {
-    p28.cancel("Operation cancelled.");
-    process20.exit(0);
+  if (p32.isCancel(choice)) {
+    p32.cancel("Operation cancelled.");
+    process24.exit(0);
   }
   return choice;
 }
 async function pickTeam(teams3) {
   if (teams3.length === 1) return teams3[0];
-  const choice = await p28.select({
+  const choice = await p32.select({
     message: "Select a team",
     options: teams3.map((team) => ({
       value: team.id,
       label: team.is_personal ? `${team.name} (personal)` : team.name
     }))
   });
-  if (p28.isCancel(choice)) {
-    p28.cancel("Operation cancelled.");
-    process20.exit(0);
+  if (p32.isCancel(choice)) {
+    p32.cancel("Operation cancelled.");
+    process24.exit(0);
   }
   return teams3.find((team) => team.id === choice);
 }
 async function promptProjectName(workspaceRootDir) {
-  const defaultValue = defaultProjectName(workspaceRootDir);
-  const value = await p28.text({
+  const defaultValue = defaultProjectName2(workspaceRootDir);
+  const value = await p32.text({
     message: "Project name",
     defaultValue,
     initialValue: defaultValue,
     placeholder: defaultValue,
-    validate: (v4) => !v4?.trim() ? "Required" : void 0
+    validate: (v9) => !v9?.trim() ? "Required" : void 0
   });
-  if (p28.isCancel(value)) {
-    p28.cancel("Operation cancelled.");
-    process20.exit(0);
+  if (p32.isCancel(value)) {
+    p32.cancel("Operation cancelled.");
+    process24.exit(0);
   }
   return value.trim();
 }
-function defaultProjectName(workspaceRootDir) {
+function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path33.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path39.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path33.basename(workspaceRootDir);
+  return path39.basename(workspaceRootDir);
+}
+
+// src/commands/env.ts
+import { Command as Command77 } from "commander";
+
+// src/commands/env/list.ts
+import { Command as Command73 } from "commander";
+import * as p34 from "@clack/prompts";
+import pc11 from "picocolors";
+
+// src/lib/local-env.ts
+import fs34 from "node:fs";
+import * as p33 from "@clack/prompts";
+import pc10 from "picocolors";
+function readLocalEnv(envFile) {
+  if (!fs34.existsSync(envFile)) return {};
+  return readLocalEnvFile(envFile);
+}
+function editLocalEnv(envFile, edit) {
+  const before = fs34.existsSync(envFile) ? fs34.readFileSync(envFile, "utf8") : "";
+  const after = edit(before);
+  if (after !== before) fs34.writeFileSync(envFile, after);
+}
+function setLocalEnv(envFile, key, value) {
+  editLocalEnv(envFile, (content) => upsertEnvVar(content, key, value));
+}
+function unsetLocalEnv(envFile, key) {
+  editLocalEnv(envFile, (content) => removeEnvVar(content, key));
+}
+async function applyLocalEnvChange(ctx, changed) {
+  if (touchesSuperuser(changed)) {
+    const env2 = readLocalEnv(ctx.envFile);
+    const email3 = env2.POCKETBASE_SUPERUSER_EMAIL;
+    const password10 = env2.POCKETBASE_SUPERUSER_PASSWORD;
+    if (email3 && password10) {
+      process.env.POCKETBASE_SUPERUSER_EMAIL = email3;
+      process.env.POCKETBASE_SUPERUSER_PASSWORD = password10;
+      await ensureSuperuser(ctx.workspaceRootDir);
+      p33.log.success("Local superuser updated to match");
+    } else {
+      p33.log.warn(
+        `The local database still has the old superuser.
+Set both ${pc10.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc10.cyan("POCKETBASE_SUPERUSER_PASSWORD")} to reconcile it.`
+      );
+    }
+  }
+  if (getPocketbaseMetadata(ctx.workspaceRootDir)) {
+    p33.log.info(`Restart ${pc10.cyan("vela dev")} to pick this up.`);
+  }
+}
+
+// src/commands/env/list.ts
+var envList = addTargetOptions(
+  new Command73("list").description("list environment variable names").configureHelp(helpConfig),
+  "local"
+).action(
+  (raw) => runCommand(
+    () => withTarget(
+      raw,
+      {
+        local: async (ctx) => {
+          report(Object.keys(readLocalEnv(ctx.envFile)), `${ctx.appName}, local (.env)`);
+        },
+        remote: async (ctx) => {
+          const env2 = await readRemoteEnv(ctx.session, ctx.instance);
+          report(Object.keys(env2), `${ctx.appName}, ${ctx.targetName}`);
+        }
+      },
+      { label: "env list" }
+    ),
+    "Failed to read the environment."
+  )
+);
+function report(keys, where) {
+  if (keys.length === 0) {
+    p34.log.info(`No environment variables configured ${pc11.dim(`(${where})`)}.`);
+    return;
+  }
+  p34.log.info(
+    `Environment ${pc11.dim(`(${where})`)}
+
+` + keys.sort().map((key) => `  ${key}`).join("\n")
+  );
+}
+
+// src/commands/env/set.ts
+import process25 from "node:process";
+import { Command as Command74 } from "commander";
+import * as p35 from "@clack/prompts";
+import pc12 from "picocolors";
+var envSet = addTargetOptions(
+  new Command74("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(
+    () => withTarget(
+      raw,
+      {
+        local: async (ctx) => {
+          const resolved = await resolveValue(key, value);
+          setLocalEnv(ctx.envFile, key, resolved);
+          p35.log.success(`${key} updated ${pc12.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 });
+          p35.log.success(`${key} updated ${pc12.dim(`(${ctx.targetName})`)}`);
+          await applyEnvRestart(ctx, [key]);
+        }
+      },
+      { label: "env set" }
+    ),
+    "Failed to set the variable."
+  )
+);
+async function resolveValue(key, value) {
+  if (!isValidKey(key)) throw new Error(`${key} is not a valid environment variable name.`);
+  return value ?? await promptValue(key);
+}
+async function promptValue(key) {
+  const value = await p35.password({
+    message: `Value for ${pc12.cyan(key)}`,
+    validate: (input) => !input?.length ? "Required" : void 0
+  });
+  if (p35.isCancel(value)) {
+    p35.cancel("Operation cancelled.");
+    process25.exit(0);
+  }
+  return value;
+}
+
+// src/commands/env/unset.ts
+import { Command as Command75 } from "commander";
+import * as p36 from "@clack/prompts";
+import pc13 from "picocolors";
+var envUnset = addTargetOptions(
+  new Command75("unset").description("remove an environment variable").argument("<key>", "variable name").configureHelp(helpConfig),
+  "local"
+).action(
+  (key, raw) => runCommand(
+    () => withTarget(
+      raw,
+      {
+        local: async (ctx) => {
+          if (!(key in readLocalEnv(ctx.envFile))) {
+            p36.log.info(`${key} is not set \u2014 nothing to remove.`);
+            return;
+          }
+          unsetLocalEnv(ctx.envFile, key);
+          p36.log.success(`${key} removed ${pc13.dim("(local)")}`);
+          await applyLocalEnvChange(ctx, [key]);
+        },
+        remote: async (ctx) => {
+          const env2 = await readRemoteEnv(ctx.session, ctx.instance);
+          if (!(key in env2)) {
+            p36.log.info(`${key} is not set \u2014 nothing to remove.`);
+            return;
+          }
+          delete env2[key];
+          await writeRemoteEnv(ctx.session, ctx.instance, env2);
+          p36.log.success(`${key} removed ${pc13.dim(`(${ctx.targetName})`)}`);
+          await applyEnvRestart(ctx, [key]);
+        }
+      },
+      { label: "env unset" }
+    ),
+    "Failed to remove the variable."
+  )
+);
+
+// src/commands/env/import.ts
+import fs35 from "node:fs";
+import path40 from "node:path";
+import process26 from "node:process";
+import { Command as Command76 } from "commander";
+import * as p37 from "@clack/prompts";
+import pc14 from "picocolors";
+var envImport = addTargetOptions(
+  new Command76("import").description("merge a dotenv file into the environment").argument("<file>", "dotenv file to read").configureHelp(helpConfig),
+  "local"
+).action(
+  (file, raw) => runCommand(
+    () => withTarget(
+      raw,
+      {
+        local: async (ctx) => {
+          const source = resolve(file);
+          if (source === ctx.envFile) {
+            throw new Error(`${file} is the file you would be importing into.`);
+          }
+          const incoming = read(source, file);
+          const keys = Object.keys(incoming);
+          if (keys.length === 0) return;
+          p37.log.step(`Importing ${keys.length} variable(s) from ${pc14.cyan(file)}`);
+          editLocalEnv(
+            ctx.envFile,
+            (content) => keys.reduce((acc, key) => upsertEnvVar(acc, key, incoming[key]), content)
+          );
+          p37.log.success(`${keys.length} variable(s) updated ${pc14.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;
+          p37.log.step(`Importing ${keys.length} variable(s) from ${pc14.cyan(file)}`);
+          const existing = await readRemoteEnv(ctx.session, ctx.instance);
+          await writeRemoteEnv(ctx.session, ctx.instance, { ...existing, ...incoming });
+          p37.log.success(`${keys.length} variable(s) updated ${pc14.dim(`(${ctx.targetName})`)}`);
+          await applyEnvRestart(ctx, keys);
+        }
+      },
+      { label: "env import" }
+    ),
+    "Failed to import the environment."
+  )
+);
+function resolve(file) {
+  return path40.resolve(process26.cwd(), file);
+}
+function read(resolved, shown) {
+  if (!fs35.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
+  const incoming = readLocalEnvFile(resolved);
+  if (Object.keys(incoming).length === 0) p37.log.info(`${shown} has no variables to import.`);
+  return incoming;
+}
+
+// src/commands/env.ts
+var env = new Command77("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 Command78 } from "commander";
+import * as p38 from "@clack/prompts";
+import pc15 from "picocolors";
+var status = addTargetOptions(
+  new Command78("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 () => {
+    const options = raw;
+    if (options.all) {
+      await withServerSession(raw, async (session) => {
+        report2(await readInstanceStates(session), options.json);
+      });
+      return;
+    }
+    await withTarget(
+      raw,
+      {
+        remote: async (ctx) => {
+          report2(await readInstanceStates(ctx.session, ctx.instance), options.json);
+        }
+      },
+      {
+        label: "status",
+        localHint: "Nothing is deployed locally \u2014 `vela dev` reports what it is running."
+      }
+    );
+  }, "Failed to read status.")
+);
+function report2(states, json) {
+  if (json) {
+    console.log(JSON.stringify(states, null, 2));
+    return;
+  }
+  if (states.length === 0) {
+    p38.log.info("Nothing is deployed here yet.");
+    return;
+  }
+  for (const state of states) {
+    p38.log.info(describe(state));
+  }
+}
+function describe(state) {
+  const health = (value) => value === "active" ? pc15.green(value) : pc15.red(value || "inactive");
+  const rows = [
+    ["Instance", state.instance],
+    ["Environment", state.env],
+    ["Release", state.activeRelease ?? "\u2014"],
+    ["Previous", state.previousRelease || "\u2014"],
+    ["Domain", state.domain || "\u2014"],
+    ["Ports", `web ${state.webPort ?? "?"}${state.backend ? `, pb ${state.pbPort ?? "?"}` : ""}`],
+    ["App", health(state.services?.web)],
+    ...state.backend ? [["PocketBase", health(state.services?.pocketbase)]] : [],
+    ["Deployed", state.deployedAt ?? "\u2014"],
+    ...state.rolledBackAt ? [["Rolled back", state.rolledBackAt]] : [],
+    ...state.gitSha ? [["Commit", state.gitSha.slice(0, 12)]] : []
+  ];
+  const width = Math.max(...rows.map(([label]) => label.length));
+  return pc15.cyan(state.name) + "\n\n" + rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value}`).join("\n");
+}
+
+// src/commands/rollback.ts
+import { Command as Command79 } from "commander";
+import * as p39 from "@clack/prompts";
+import pc16 from "picocolors";
+var rollback = addTargetOptions(
+  new Command79("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(
+  (raw) => runCommand(async () => {
+    const options = raw;
+    await withTarget(
+      raw,
+      {
+        remote: async (ctx) => {
+          p39.log.step(
+            `Rolling back ${pc16.cyan(ctx.appName)} ${pc16.dim(`(${ctx.targetName})`)} on ${ctx.server}`
+          );
+          const result = await runServerScript(
+            ctx.session,
+            "rollback.sh",
+            {
+              args: [ctx.instance, ...options.to ? ["--to", options.to] : []],
+              stream: true
+            }
+          );
+          p39.log.success(
+            `Rolled back to ${pc16.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc16.dim(`(was ${result.from})`)}` : "")
+          );
+        }
+      },
+      {
+        label: "rollback",
+        localHint: "Nothing is released locally \u2014 `vela dev` always runs the working tree."
+      }
+    );
+  }, "Failed to roll back.")
+);
+
+// src/commands/logs.ts
+import { Command as Command80 } from "commander";
+var logs = addTargetOptions(
+  new Command80("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 () => {
+    const options = raw;
+    await withTarget(
+      raw,
+      {
+        remote: async (ctx) => {
+          const unit = options.pocketbase ? remotePaths.pbUnit(ctx.instance) : remotePaths.webUnit(ctx.instance);
+          const command = [
+            "journalctl",
+            "-u",
+            unit,
+            "-n",
+            options.lines ?? "100",
+            "--no-pager",
+            ...options.follow ? ["-f"] : []
+          ];
+          const code = await ctx.session.interactive(command);
+          if (code !== 0 && !options.follow) {
+            throw new Error(`journalctl exited ${code}.`);
+          }
+        }
+      },
+      {
+        label: "logs",
+        localHint: "There are no logs for the copy on this machine \u2014 `vela dev` prints them as it runs."
+      }
+    );
+  }, "Failed to read logs.")
+);
+
+// src/commands/admin.ts
+import { Command as Command82 } from "commander";
+
+// src/commands/admin/create.ts
+import process27 from "node:process";
+import { Command as Command81 } from "commander";
+import * as p40 from "@clack/prompts";
+import pc17 from "picocolors";
+var MIN_PASSWORD = 10;
+var adminCreate = addTargetOptions(
+  new Command81("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(
+    () => withTarget(
+      raw,
+      {
+        local: async (ctx) => {
+          const creds = readLocalEnv(ctx.envFile);
+          const address = email3 ?? await promptEmail();
+          const password10 = await promptPassword2();
+          let signIn = "";
+          await withPocketbase(
+            ctx.workspaceRootDir,
+            async (pb) => {
+              await upsertSuperuser(pb, address, password10);
+              const settings = await pb.settings.getAll();
+              signIn = settings.meta?.appURL ?? "";
+            },
+            {
+              email: creds.POCKETBASE_SUPERUSER_EMAIL,
+              password: creds.POCKETBASE_SUPERUSER_PASSWORD
+            }
+          );
+          if (!signIn) {
+            const metadata = getPocketbaseMetadata(ctx.workspaceRootDir);
+            if (metadata) signIn = `http://${metadata.viteHost}:${metadata.vitePort}`;
+          }
+          p40.log.info(
+            signIn ? `Sign in at ${pc17.cyan(`${signIn}/admin`)}` : `Sign in at ${pc17.cyan("/admin")} once ${pc17.cyan("vela dev")} is running.`
+          );
+        },
+        remote: async (ctx) => {
+          const address = email3 ?? await promptEmail();
+          const password10 = await promptPassword2();
+          const [state] = await readInstanceStates(ctx.session, ctx.instance);
+          await withRemotePocketbase(
+            ctx.session,
+            ctx.instance,
+            (pb) => upsertSuperuser(pb, address, password10)
+          );
+          const base2 = state?.domain ? `https://${state.domain.split(",")[0].trim()}` : "";
+          p40.log.info(
+            base2 ? `Sign in at ${pc17.cyan(`${base2}/admin`)}` : `Sign in at ${pc17.cyan("/admin")} once a domain is configured for this target.`
+          );
+        }
+      },
+      { label: "admin create" }
+    ),
+    "Failed to create the admin login."
+  )
+);
+async function upsertSuperuser(pb, email3, password10) {
+  const existing = await findSuperuser(pb, email3);
+  if (existing) {
+    const confirmed = await p40.confirm({
+      message: `${email3} can already sign in. Reset its password?`,
+      initialValue: false
+    });
+    if (p40.isCancel(confirmed) || !confirmed) {
+      p40.cancel("Operation cancelled.");
+      process27.exit(0);
+    }
+    await pb.collection("_superusers").update(existing, { password: password10, passwordConfirm: password10 });
+    p40.log.success(`Password reset for ${pc17.cyan(email3)}`);
+    return;
+  }
+  await pb.collection("_superusers").create({ email: email3, password: password10, passwordConfirm: password10 });
+  p40.log.success(`${pc17.cyan(email3)} can now sign in`);
+}
+async function findSuperuser(pb, email3) {
+  try {
+    const record = await pb.collection("_superusers").getFirstListItem(pb.filter("email = {:email}", { email: email3 }));
+    return record.id;
+  } catch {
+    return null;
+  }
+}
+async function promptEmail() {
+  const value = await p40.text({
+    message: "Email to sign in with",
+    validate: (input) => input?.includes("@") ? void 0 : "An email address is required"
+  });
+  if (p40.isCancel(value)) {
+    p40.cancel("Operation cancelled.");
+    process27.exit(0);
+  }
+  return value.trim();
+}
+async function promptPassword2() {
+  const value = await p40.password({
+    message: "Password",
+    validate: (input) => (input?.length ?? 0) >= MIN_PASSWORD ? void 0 : `At least ${MIN_PASSWORD} characters is required`
+  });
+  if (p40.isCancel(value)) {
+    p40.cancel("Operation cancelled.");
+    process27.exit(0);
+  }
+  const again = await p40.password({
+    message: "Password again",
+    validate: (input) => input === value ? void 0 : "The two do not match"
+  });
+  if (p40.isCancel(again)) {
+    p40.cancel("Operation cancelled.");
+    process27.exit(0);
+  }
+  return value;
+}
+
+// src/commands/admin.ts
+var admin = new Command82("admin").description("manage admin panel logins").configureHelp(helpConfig).addCommand(adminCreate);
+
+// src/commands/targets.ts
+import { Command as Command83 } from "commander";
+import * as p41 from "@clack/prompts";
+import pc18 from "picocolors";
+import * as v8 from "valibot";
+var OptionsSchema4 = v8.object({
+  ...SSH_OPTION_SCHEMA,
+  json: v8.optional(v8.boolean()),
+  offline: v8.optional(v8.boolean())
+});
+var targets = addSshOptions(
+  new Command83("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);
+    const { workspaceRootDir } = await getWorkspace();
+    const config = await loadDeployConfig(workspaceRootDir);
+    const app = readAppIdentity(workspaceRootDir, config);
+    const bindings = readBindings(workspaceRootDir);
+    const metadata = getPocketbaseMetadata(workspaceRootDir);
+    const rows = [
+      {
+        target: "local",
+        kind: "local",
+        server: "\u2014",
+        domain: metadata ? `http://${metadata.viteHost}:${metadata.vitePort}` : "\u2014",
+        release: "\u2014",
+        reachable: true
+      }
+    ];
+    const byServer = /* @__PURE__ */ new Map();
+    for (const [envTag, binding] of Object.entries(bindings)) {
+      byServer.set(binding.server, [...byServer.get(binding.server) ?? [], envTag]);
+    }
+    for (const [server, envTags] of byServer) {
+      let states = [];
+      let reachable = false;
+      if (!options.offline && app) {
+        try {
+          await withSsh(server, sshOptionsFrom(options), async (session) => {
+            await session.detectElevation();
+            states = await readInstanceStates(session);
+          });
+          reachable = true;
+        } catch {
+        }
+      }
+      for (const envTag of envTags) {
+        const binding = bindings[envTag];
+        const instance = app ? instanceId(app.appId, envTag) : "";
+        const state = states.find((candidate) => candidate.instance === instance);
+        rows.push({
+          target: envTag,
+          kind: "remote",
+          server,
+          domain: state?.domain || binding.domain || "\u2014",
+          release: state?.activeRelease ?? (reachable ? "not deployed" : "\u2014"),
+          reachable
+        });
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    report3(rows, options.offline === true);
+  }, "Failed to list targets.")
+);
+function report3(rows, offline) {
+  const width = (heading, pick) => Math.max(heading.length, ...rows.map((row) => pick(row).length));
+  const target = width("TARGET", (row) => row.target);
+  const server = width("SERVER", (row) => row.server);
+  const domain = width("DOMAIN", (row) => row.domain);
+  const header = `${"TARGET".padEnd(target)}  ${"SERVER".padEnd(server)}  ${"DOMAIN".padEnd(domain)}  RELEASE`;
+  const lines = rows.map(
+    (row) => `${row.kind === "local" ? pc18.dim(row.target.padEnd(target)) : pc18.cyan(row.target.padEnd(target))}  ${row.server.padEnd(server)}  ${row.domain.padEnd(domain)}  ${row.release}`
+  );
+  p41.log.info(`${pc18.dim(header)}
+${lines.join("\n")}`);
+  const unreachable = rows.filter((row) => row.kind === "remote" && !row.reachable);
+  if (!offline && unreachable.length > 0) {
+    p41.log.warn(
+      `Could not reach ${unreachable.map((row) => row.server).join(", ")}.
+Release and domain are shown from what this project recorded.`
+    );
+  }
 }
 
 // src/commands/test.ts
-import path34 from "node:path";
-import process21 from "node:process";
-import { Command as Command70 } from "commander";
-import PocketBase3 from "pocketbase";
-import pc6 from "picocolors";
+import path41 from "node:path";
+import process28 from "node:process";
+import { Command as Command84 } from "commander";
+import PocketBase5 from "pocketbase";
+import pc19 from "picocolors";
 import { x as x5 } from "tinyexec";
-import { detect as detect7 } from "package-manager-detector";
-import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
-import fs28 from "node:fs";
-var testServer = new Command70("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
-  const cwd = process21.cwd();
+import { detect as detect8 } from "package-manager-detector";
+import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
+import fs36 from "node:fs";
+var testServer = new Command84("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
+  const cwd = process28.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
-  const password8 = "password";
-  const testDataDir = path34.join(cwd, "test-data");
-  fs28.rmSync(testDataDir, { recursive: true, force: true });
+  const password10 = "password";
+  const testDataDir = path41.join(cwd, "test-data");
+  fs36.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path34.join(cwd, "migrations"),
+    migrationsDir: path41.join(cwd, "migrations"),
     email: email3,
-    password: password8
+    password: password10
   });
-  process21.env.POCKETBASE_URL = url;
-  process21.env.POCKETBASE_SUPERUSER_EMAIL = email3;
-  process21.env.POCKETBASE_SUPERUSER_PASSWORD = password8;
-  process21.env.TEST = "true";
-  console.log(`${pc6.greenBright("\u2713")} Created test database`);
+  process28.env.POCKETBASE_URL = url;
+  process28.env.POCKETBASE_SUPERUSER_EMAIL = email3;
+  process28.env.POCKETBASE_SUPERUSER_PASSWORD = password10;
+  process28.env.TEST = "true";
+  console.log(`${pc19.greenBright("\u2713")} Created test database`);
   const { createServer } = await import("vite");
   const vite = await createServer({
     mode: "test",
@@ -6018,29 +7995,29 @@ var testServer = new Command70("test:server").description("run server tests").al
   });
   const vitePort = await findFreePort();
   await vite.listen(vitePort);
-  process21.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
-  console.log(`${pc6.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
-  console.log(`${pc6.greenBright("\u2713")} Started PocketBase: ${url}`);
+  process28.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
+  console.log(`${pc19.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
+  console.log(`${pc19.greenBright("\u2713")} Started PocketBase: ${url}`);
   const cleanup = async () => {
     stop();
     await vite.close();
-    fs28.rmSync(testDataDir, { recursive: true, force: true });
+    fs36.rmSync(testDataDir, { recursive: true, force: true });
   };
-  const pb = new PocketBase3(url);
+  const pb = new PocketBase5(url);
   try {
-    await authWithRetries(pb, email3, password8);
+    await authWithRetries(pb, email3, password10);
   } catch (e) {
     await cleanup();
-    console.error(`${pc6.redBright("\u2717")} Auth failed: ${e.message}`);
-    process21.exit(1);
+    console.error(`${pc19.redBright("\u2717")} Auth failed: ${e.message}`);
+    process28.exit(1);
   }
   const extraArgs = (cmd.parent?.args ?? []).slice(1);
   let filter = extraArgs.find((arg) => !arg.startsWith("-"));
   const passthrough = filter ? extraArgs.filter((a) => a !== filter) : extraArgs;
   if (!filter) filter = "server";
   try {
-    const pm = (await detect7({ cwd }))?.name ?? "npm";
-    const resolved = resolveCommand7(pm, "execute", [
+    const pm = (await detect8({ cwd }))?.name ?? "npm";
+    const resolved = resolveCommand8(pm, "execute", [
       "vitest",
       "run",
       filter,
@@ -6050,7 +8027,7 @@ var testServer = new Command70("test:server").description("run server tests").al
     const resolvedArgs = resolved.args.slice();
     if (pm === "npm") resolvedArgs.unshift("--yes");
     await x5(resolved.command, resolvedArgs, {
-      nodeOptions: { cwd, stdio: "inherit", env: { ...process21.env, CI: "1" } },
+      nodeOptions: { cwd, stdio: "inherit", env: { ...process28.env, CI: "1" } },
       throwOnError: true
     });
   } catch {
@@ -6076,9 +8053,9 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs29 from "node:fs";
-import path35 from "node:path";
-import { Command as Command71 } from "commander";
+import fs37 from "node:fs";
+import path42 from "node:path";
+import { Command as Command85 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -6089,32 +8066,32 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
   "HEAD",
   "fallback"
 ]);
-var routes = new Command71("routes").description("list routes").configureHelp(helpConfig).action(async () => {
+var routes = new Command85("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path35.join(workspaceRootDir, routesDir);
+  const routesRoot = path42.join(workspaceRootDir, routesDir);
   const found = walk(routesRoot, routesRoot).filter((r) => r.methods.length > 0);
   found.sort((a, b) => a.urlPattern.localeCompare(b.urlPattern));
   printTable(found);
 });
 function walk(root, dir) {
-  const entries = fs29.readdirSync(dir, { withFileTypes: true });
+  const entries = fs37.readdirSync(dir, { withFileTypes: true });
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
-    const id = "/" + path35.relative(root, dir).split(path35.sep).filter(Boolean).join("/");
+    const id = "/" + path42.relative(root, dir).split(path42.sep).filter(Boolean).join("/");
     const urlPattern = id.replace(/\([^)]+\)\/?/g, "").replace(/\/$/, "") || "/";
     const methods = /* @__PURE__ */ new Set();
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (entry.name.endsWith("+page.svelte")) methods.add("GET");
       if (entry.name.endsWith("+server.ts") || entry.name.endsWith("+server.js") || entry.name.endsWith("+page.server.ts") || entry.name.endsWith("+page.server.js")) {
-        extractMethods(path35.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path42.join(dir, entry.name)).forEach((m) => methods.add(m));
       }
     }
     routes2.push({ id: id || "/", urlPattern, methods: [...methods] });
   }
   for (const entry of entries) {
-    if (entry.isDirectory()) routes2.push(...walk(root, path35.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path42.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -6123,7 +8100,7 @@ function isRouteFile(name) {
 }
 function extractMethods(file) {
   try {
-    const content = fs29.readFileSync(file, "utf8");
+    const content = fs37.readFileSync(file, "utf8");
     const methods = [];
     const exportRegex = /export\s+(?:const|async\s+function|function)\s+(\w+)/g;
     let match;
@@ -6164,15 +8141,15 @@ function printTable(routes2) {
 }
 
 // src/commands/i18n.ts
-import process22 from "node:process";
-import { Command as Command72 } from "commander";
+import process29 from "node:process";
+import { Command as Command86 } from "commander";
 import { x as x6 } from "tinyexec";
-import { detect as detect8 } from "package-manager-detector";
-import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
+import { detect as detect9 } from "package-manager-detector";
+import { resolveCommand as resolveCommand9 } from "package-manager-detector/commands";
 async function runWuchale(extraArgs) {
-  const cwd = process22.cwd();
-  const pm = (await detect8({ cwd }))?.name ?? "npm";
-  const resolved = resolveCommand8(pm, "execute", ["wuchale", ...extraArgs]);
+  const cwd = process29.cwd();
+  const pm = (await detect9({ cwd }))?.name ?? "npm";
+  const resolved = resolveCommand9(pm, "execute", ["wuchale", ...extraArgs]);
   const args = resolved.args.slice();
   if (pm === "npm") args.unshift("--yes");
   await x6(resolved.command, args, {
@@ -6180,11 +8157,11 @@ async function runWuchale(extraArgs) {
     throwOnError: true
   });
 }
-var extract = new Command72("extract").description("extract translatable strings").configureHelp(helpConfig).action(() => runWuchale([]));
-var watch = new Command72("watch").description("watch and extract translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--watch"]));
-var status = new Command72("status").description("show i18n status").configureHelp(helpConfig).action(() => runWuchale(["status"]));
-var clean = new Command72("clean").description("clean unused translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--clean"]));
-var i18n3 = new Command72("i18n").description("i18n utilities").configureHelp(helpConfig).addCommand(extract, { isDefault: true }).addCommand(watch).addCommand(status).addCommand(clean);
+var extract = new Command86("extract").description("extract translatable strings").configureHelp(helpConfig).action(() => runWuchale([]));
+var watch = new Command86("watch").description("watch and extract translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--watch"]));
+var status2 = new Command86("status").description("show i18n status").configureHelp(helpConfig).action(() => runWuchale(["status"]));
+var clean = new Command86("clean").description("clean unused translatable strings").configureHelp(helpConfig).action(() => runWuchale(["--clean"]));
+var i18n3 = new Command86("i18n").description("i18n utilities").configureHelp(helpConfig).addCommand(extract, { isDefault: true }).addCommand(watch).addCommand(status2).addCommand(clean);
 
 // src/commands/oauth.ts
 var oauth = stubCommand("oauth", "configure OAuth providers");
@@ -6205,42 +8182,52 @@ var NO_BACKEND_COMMMANDS = /* @__PURE__ */ new Set([
   "routes",
   "i18n",
   "generate schema",
-  "generate form"
+  "generate form",
+  // Server commands talk to a VPS over SSH, never to the local database.
+  "provision",
+  "env",
+  "status",
+  "rollback",
+  "logs",
+  "admin",
+  "targets",
+  "link"
 ]);
 var BACKEND_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["dev", "build", "preview", "deploy"]);
-var program = new Command73().name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version").configureHelp(helpConfig);
+var program = new Command87().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;
-  dotenv.config({ quiet: true });
-  const path36 = getCommandPath(actionCommand);
-  if (NO_BACKEND_COMMMANDS.has(path36)) return;
-  const top = path36.split(" ", 1)[0];
+  const envRoot = findWorkspaceRoot() ?? process30.cwd();
+  dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
+  const path43 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path43)) return;
+  const top = path43.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
-    p29.log.error(
-      `${pc7.cyan(`vela ${path36}`)} needs a backend, and this project does not have one.
+    p42.log.error(
+      `${pc20.cyan(`vela ${path43}`)} 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 ${pc7.cyan("vela bless")}.`
+To add a backend to this project, run ${pc20.cyan("vela bless")}.`
     );
-    p29.log.message();
-    p29.cancel("Operation failed.");
-    process23.exit(1);
+    p42.log.message();
+    p42.cancel("Operation failed.");
+    process30.exit(1);
   }
-  if (!process23.env.POCKETBASE_SUPERUSER_EMAIL || !process23.env.POCKETBASE_SUPERUSER_PASSWORD) {
-    p29.log.error(
+  if (!process30.env.POCKETBASE_SUPERUSER_EMAIL || !process30.env.POCKETBASE_SUPERUSER_PASSWORD) {
+    p42.log.error(
       `PocketBase superuser credentials are required.
 
-Set ${pc7.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc7.cyan("POCKETBASE_SUPERUSER_PASSWORD")} in your .env file.
+Set ${pc20.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc20.cyan("POCKETBASE_SUPERUSER_PASSWORD")} in your .env file.
 
-To set up a new project, run ${pc7.cyan("vela create")}.
-To set up an existing project, run ${pc7.cyan("vela bless")}.`
+To set up a new project, run ${pc20.cyan("vela create")}.
+To set up an existing project, run ${pc20.cyan("vela bless")}.`
     );
-    p29.log.message();
-    p29.cancel("Operation failed.");
-    process23.exit(1);
+    p42.log.message();
+    p42.cancel("Operation failed.");
+    process30.exit(1);
   }
 });
 function getCommandPath(cmd) {
@@ -6274,6 +8261,13 @@ for (const command of [
   sync,
   provision,
   deploy,
+  rollback,
+  status,
+  logs,
+  env,
+  admin,
+  targets,
+  link,
   testServer,
   routes,
   i18n3,
@@ -6284,14 +8278,14 @@ for (const command of [
 }
 
 // src/bin.ts
-var argv = normalizeArgv(process24.argv.slice(2));
+var argv = normalizeArgv(process31.argv.slice(2));
 var delegatedExitCode = delegateToLocalCli({
   argv,
   selfPath: fileURLToPath2(import.meta.url),
   selfVersion: package_default.version
 });
 if (delegatedExitCode !== null) {
-  process24.exit(delegatedExitCode);
+  process31.exit(delegatedExitCode);
 }
 program.parse(argv, { from: "user" });
 //# sourceMappingURL=bin.js.map