vela 0.10.4 → 0.10.5

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import process32 from "node:process";
+import process33 from "node:process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.10.4",
+  version: "0.10.5",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -168,12 +168,12 @@ function delegateToLocalCli(opts) {
 }
 
 // src/program.ts
-import process31 from "node:process";
-import * as p42 from "@clack/prompts";
+import process32 from "node:process";
+import * as p43 from "@clack/prompts";
 import { Command as Command87 } from "commander";
 import nodePath from "node:path";
 import dotenv2 from "dotenv";
-import pc21 from "picocolors";
+import pc22 from "picocolors";
 
 // src/lib/help.ts
 import pc from "picocolors";
@@ -1752,7 +1752,7 @@ async function runPattern(slug2, argv2, input, report4) {
     throw new Error(`Unknown pattern: ${slug2}`);
   }
   const { workspaceRootDir, features } = await getWorkspace();
-  const log31 = p6.taskLog({ title: report4.task.title });
+  const log32 = p6.taskLog({ title: report4.task.title });
   let result;
   try {
     result = await pattern.generate({
@@ -1772,11 +1772,11 @@ async function runPattern(slug2, argv2, input, report4) {
         });
         return collections2;
       },
-      logger: { info: (message) => log31.message(message) }
+      logger: { info: (message) => log32.message(message) }
     });
-    log31.success(report4.task.success);
+    log32.success(report4.task.success);
   } catch (e) {
-    log31.error(report4.task.error);
+    log32.error(report4.task.error);
     throw e;
   }
   const rel = (f) => toRelative(workspaceRootDir, f);
@@ -6748,17 +6748,43 @@ async function startWatchingTypes(cwd, pb) {
 }
 
 // src/commands/build.ts
+import fs31 from "node:fs";
 import path34 from "node:path";
-import process22 from "node:process";
+import process23 from "node:process";
 import { Command as Command67 } from "commander";
+import * as p30 from "@clack/prompts";
+import pc9 from "picocolors";
 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 Command67("build").description("build the app").configureHelp(helpConfig).action(async () => {
-  process22.env.VITE_BUILD = "true";
-  const cwd = process22.cwd();
+
+// src/lib/origin.ts
+import process22 from "node:process";
+function resolveOrigin(workspaceRootDir, envTag, config = {}) {
+  return normalizeOrigin(
+    process22.env.VELA_ORIGIN ?? readBinding(workspaceRootDir, envTag)?.domain ?? config.deploy?.domain
+  );
+}
+function normalizeOrigin(value) {
+  const first = value?.split(",")[0]?.trim();
+  if (!first) return null;
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(first) ? first : `https://${first}`;
+  try {
+    const url = new URL(withScheme);
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/build.ts
+var PRERENDERED_DIR = path34.join(".svelte-kit", "output", "prerendered");
+var build = new Command67("build").description("build the app").configureHelp(helpConfig).option("-t, --target <target>", "which copy of the app to build for", PRODUCTION_TARGET).action(async (options) => {
+  const cwd = process23.cwd();
+  const origin = await originForBuild(cwd, options.target);
+  if (origin) process23.env.VELA_ORIGIN = origin;
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process22.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process23.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
@@ -6772,11 +6798,11 @@ var build = new Command67("build").description("build the app").configureHelp(he
       dev: true
     });
     pbProc = started.proc;
-    process22.env.POCKETBASE_URL = started.url;
-    process22.on("exit", cleanup);
-    process22.on("SIGINT", () => {
+    process23.env.POCKETBASE_URL = started.url;
+    process23.on("exit", cleanup);
+    process23.on("SIGINT", () => {
       cleanup();
-      process22.exit(0);
+      process23.exit(0);
     });
   }
   try {
@@ -6791,19 +6817,42 @@ var build = new Command67("build").description("build the app").configureHelp(he
   } finally {
     cleanup();
   }
+  if (!origin) warnIfPrerendered(cwd);
 });
+async function originForBuild(cwd, target) {
+  const workspaceRootDir = findWorkspaceRoot(cwd);
+  if (!workspaceRootDir) return null;
+  try {
+    const parsed = parseTarget(target, PRODUCTION_TARGET);
+    if (parsed.kind !== "remote") return null;
+    const config = await loadDeployConfig(workspaceRootDir);
+    return resolveOrigin(workspaceRootDir, parsed.envTag, config);
+  } catch {
+    return null;
+  }
+}
+function warnIfPrerendered(cwd) {
+  const dir = path34.join(cwd, PRERENDERED_DIR);
+  if (!fs31.existsSync(dir) || fs31.readdirSync(dir).length === 0) return;
+  p30.log.warn(
+    `Prerendered pages were built with no domain configured, so their canonical
+links point at SvelteKit's placeholder host rather than at this site.
+
+Set one with ${pc9.cyan("vela deploy --domain example.com")}, or pass ${pc9.cyan("VELA_ORIGIN")}.`
+  );
+}
 
 // src/commands/preview.ts
 import path35 from "node:path";
-import process23 from "node:process";
+import process24 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 = process23.cwd();
+  const cwd = process24.cwd();
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process23.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process24.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
@@ -6816,11 +6865,11 @@ var preview = new Command68("preview").description("preview the built app").conf
       dev: true
     });
     pbProc = started.proc;
-    process23.env.POCKETBASE_URL = started.url;
-    process23.on("exit", cleanup);
-    process23.on("SIGINT", () => {
+    process24.env.POCKETBASE_URL = started.url;
+    process24.on("exit", cleanup);
+    process24.on("SIGINT", () => {
       cleanup();
-      process23.exit(0);
+      process24.exit(0);
     });
   }
   try {
@@ -6854,8 +6903,8 @@ var sync = new Command69("sync").description("sync types from the database").con
 
 // src/commands/provision.ts
 import { Command as Command70 } from "commander";
-import * as p30 from "@clack/prompts";
-import pc9 from "picocolors";
+import * as p31 from "@clack/prompts";
+import pc10 from "picocolors";
 import * as v6 from "valibot";
 var OptionsSchema2 = v6.object({
   ...SSH_OPTION_SCHEMA,
@@ -6868,19 +6917,19 @@ var provision = addSshOptions(
   (target, raw) => runCommand(async () => {
     const options = parseOptions(OptionsSchema2, raw);
     const pbVersion = options.pbVersion ?? pocketbaseVersion();
-    p30.intro(pc9.bgCyan(pc9.black(" vela provision ")));
-    p30.log.info(`Target ${pc9.cyan(target)}`);
+    p31.intro(pc10.bgCyan(pc10.black(" vela provision ")));
+    p31.log.info(`Target ${pc10.cyan(target)}`);
     await withSsh(target, sshOptionsFrom(options), async (session) => {
       await session.detectElevation();
       const existing = await readServerInfo(session);
       if (existing) {
-        p30.log.info(
+        p31.log.info(
           `Already provisioned by vela ${existing.cliVersion} on ${existing.provisionedAt}. Bringing it up to date.`
         );
       }
-      p30.log.step("Uploading server scripts");
+      p31.log.step("Uploading server scripts");
       await syncServerScripts(session);
-      p30.log.step("Running provision");
+      p31.log.step("Running provision");
       const result = await runServerScript(session, "provision.sh", {
         args: [
           "--pb-version",
@@ -6892,7 +6941,7 @@ var provision = addSshOptions(
         ],
         stream: true
       });
-      p30.log.success(
+      p31.log.success(
         `${target} is ready.
 
   Node        ${result?.node ?? "installed"}
@@ -6900,22 +6949,22 @@ var provision = addSshOptions(
   PocketBase  ${result?.pocketbase ?? pbVersion}`
       );
     });
-    p30.outro(`Deploy with ${pc9.cyan(`vela deploy --server ${target}`)}`);
+    p31.outro(`Deploy with ${pc10.cyan(`vela deploy --server ${target}`)}`);
   }, "Failed to provision.")
 );
 
 // src/commands/deploy.ts
 import path39 from "node:path";
-import fs33 from "node:fs";
-import { Command as Command71 } from "commander";
-import * as p31 from "@clack/prompts";
-import pc10 from "picocolors";
+import fs34 from "node:fs";
+import { Command as Command71, Option as Option2 } from "commander";
+import * as p32 from "@clack/prompts";
+import pc11 from "picocolors";
 import * as v7 from "valibot";
 
 // src/lib/pocketbase-settings.ts
-import fs31 from "node:fs";
+import fs32 from "node:fs";
 import path37 from "node:path";
-import process24 from "node:process";
+import process25 from "node:process";
 import PocketBase4 from "pocketbase";
 
 // src/lib/remote-pocketbase.ts
@@ -6964,9 +7013,9 @@ async function withRemotePocketbase(session, instance, fn) {
 var COPIED_KEYS = ["appName", "senderName", "senderAddress"];
 async function readLocalMeta(cwd) {
   const dataDir = path37.join(cwd, DATA_DIR);
-  if (!fs31.existsSync(dataDir)) return null;
-  const email3 = process24.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password10 = process24.env.POCKETBASE_SUPERUSER_PASSWORD;
+  if (!fs32.existsSync(dataDir)) return null;
+  const email3 = process25.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password10 = process25.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email3 || !password10) return null;
   let proc;
   try {
@@ -6986,6 +7035,19 @@ async function readLocalMeta(cwd) {
     proc?.kill();
   }
 }
+async function readRemoteAppURL(session, instance) {
+  try {
+    let appURL = null;
+    await withRemotePocketbase(session, instance, async (pb) => {
+      const settings = await pb.settings.getAll();
+      const value = settings.meta?.appURL;
+      appURL = typeof value === "string" && value.trim() ? value : null;
+    });
+    return appURL;
+  } catch {
+    return null;
+  }
+}
 async function seedRemoteMeta(session, instance, local, appURL) {
   const patch = {};
   for (const key of COPIED_KEYS) {
@@ -7002,7 +7064,7 @@ async function seedRemoteMeta(session, instance, local, appURL) {
 }
 
 // src/lib/artifact.ts
-import fs32 from "node:fs";
+import fs33 from "node:fs";
 import path38 from "node:path";
 import { detect as detect7 } from "package-manager-detector";
 import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
@@ -7041,10 +7103,10 @@ function collectArtifact(cwd, config = {}) {
   const entries = [];
   const add2 = (rel, remoteDir = "") => {
     const localPath = path38.join(cwd, rel);
-    if (fs32.existsSync(localPath)) entries.push({ localPath, remoteDir });
+    if (fs33.existsSync(localPath)) entries.push({ localPath, remoteDir });
   };
   const buildPath = path38.join(cwd, outputDir);
-  if (!fs32.existsSync(path38.join(buildPath, "index.js"))) {
+  if (!fs33.existsSync(path38.join(buildPath, "index.js"))) {
     throw new BuildError(
       `No ${outputDir}/index.js after the build.
 
@@ -7058,7 +7120,7 @@ the adapter in your Vite or Svelte config, then build again.`
   add2(".npmrc");
   add2(MIGRATIONS_DIR);
   const hooks = path38.join(cwd, DATA_DIR, "hooks");
-  if (fs32.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
+  if (fs33.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
   for (const extra of config.include ?? []) add2(extra);
   return entries;
 }
@@ -7082,39 +7144,57 @@ var OptionsSchema3 = v7.object({
 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"
+).option("--project <name>", "override the project name").option("--domain <hosts>", "hostname(s) to serve on, comma separated").option("--health-path <path>", "path the health check requests").option("--keep <count>", "how many old releases to keep on the server").option("--pb-version <version>", "PocketBase version to run").option("--no-build", "deploy the existing build output without rebuilding").addOption(
+  new Option2(
+    "--remote-db",
+    "render the build against the database on the server, over an SSH tunnel \u2014 on by default once the target has been deployed to"
+  ).default(void 0)
+).addOption(
+  new Option2("--no-remote-db", "render the build against a throwaway local database").default(
+    void 0
+  )
 ).action(
   (raw) => runCommand(async () => {
     const options = parseOptions(OptionsSchema3, raw);
     const backend3 = hasBackend();
     const release = releaseId();
-    p31.intro(pc10.bgCyan(pc10.black(" vela deploy ")));
+    p32.intro(pc11.bgCyan(pc11.black(" vela deploy ")));
     await withTarget(
       raw,
       {
         remote: async (ctx) => {
           const { session, instance, workspaceRootDir, config } = ctx;
-          p31.log.info(
-            `${pc10.cyan(ctx.appName)} ${pc10.dim("\u2192")} ${pc10.cyan(ctx.targetName)} ${pc10.dim(`(${ctx.server})`)}`
+          p32.log.info(
+            `${pc11.cyan(ctx.appName)} ${pc11.dim("\u2192")} ${pc11.cyan(ctx.targetName)} ${pc11.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;
+          const askedForRemoteDb = options.remoteDb ?? config.deploy?.buildAgainstRemote;
+          const remoteDb = askedForRemoteDb ?? Boolean(existing?.pbPort);
           if (options.build !== false) {
-            let buildEnv = {};
+            const origin = normalizeOrigin(process.env.VELA_ORIGIN ?? domain);
+            let buildEnv = origin ? { VELA_ORIGIN: origin } : {};
             let tunnel = null;
             if (backend3 && remoteDb) {
-              tunnel = await openDatabaseTunnel(session, instance, existing);
-              buildEnv = tunnel.env;
-              p31.log.info(
-                `Building against the ${pc10.cyan(ctx.targetName)} database on ${ctx.server} ${pc10.dim(`(port ${tunnel.pbPort})`)}`
+              try {
+                tunnel = await openDatabaseTunnel(session, instance, existing);
+              } catch (err) {
+                if (askedForRemoteDb) throw err;
+                p32.log.warn(
+                  `Could not build against the ${pc11.cyan(ctx.targetName)} database, using a local one instead.
+${pc11.dim(String(err))}`
+                );
+              }
+            }
+            if (tunnel) {
+              buildEnv = { ...buildEnv, ...tunnel.env };
+              p32.log.info(
+                `Building against the ${pc11.cyan(ctx.targetName)} database on ${ctx.server} ${pc11.dim(`(port ${tunnel.pbPort})`)}`
               );
             } else if (backend3) {
               await ensureSuperuser(workspaceRootDir);
             }
-            p31.log.step("Building");
+            p32.log.step("Building");
             try {
               await runBuild(workspaceRootDir, config.deploy?.buildCommand, buildEnv);
             } finally {
@@ -7123,9 +7203,9 @@ var deploy = addTargetOptions(
           }
           const entries = collectArtifact(workspaceRootDir, config.deploy ?? {});
           const sha = await gitSha(workspaceRootDir);
-          p31.log.step(`Uploading release ${pc10.dim(release)}`);
+          p32.log.step(`Uploading release ${pc11.dim(release)}`);
           await uploadRelease(session, instance, release, entries);
-          p31.log.step("Activating");
+          p32.log.step("Activating");
           const result = await runServerScript(session, "apply.sh", {
             args: [
               instance,
@@ -7157,8 +7237,8 @@ var deploy = addTargetOptions(
           });
           if (!existing) await reportEmptyEnvironment(session, instance, workspaceRootDir);
           const url = result?.url ?? "";
-          p31.log.success(
-            `Deployed ${pc10.cyan(ctx.appName)} ${pc10.dim(release)}
+          p32.log.success(
+            `Deployed ${pc11.cyan(ctx.appName)} ${pc11.dim(release)}
 
   URL   ${url}
   Port  ${result?.webPort ?? "?"}${backend3 ? ` (PocketBase ${result?.pbPort ?? "?"})` : ""}`
@@ -7170,27 +7250,41 @@ var deploy = addTargetOptions(
               workspaceRootDir,
               domain ? result?.url ?? "" : ""
             );
-            p31.log.info(
+            p32.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, ${pc10.cyan("vela env set POCKETBASE_SUPERUSER_PASSWORD")}
+your own instead, ${pc11.cyan("vela env set POCKETBASE_SUPERUSER_PASSWORD")}
 and deploy again.`
             );
+          } else if (backend3 && domain) {
+            await reportAppURLDrift(session, instance, domain);
           }
           if (!domain) {
-            p31.log.warn(
+            p32.log.warn(
               `No domain configured, so nothing is proxied to this app yet.
-Redeploy with ${pc10.cyan("--domain example.com")} once DNS points at ${ctx.server}.`
+Redeploy with ${pc11.cyan("--domain example.com")} once DNS points at ${ctx.server}.`
             );
           }
         }
       },
       { project: options.project, askDomain: true, label: "deploy" }
     );
-    p31.outro(`${pc10.cyan("vela status")} to see what is running`);
+    p32.outro(`${pc11.cyan("vela status")} to see what is running`);
   }, "Failed to deploy.")
 );
+async function reportAppURLDrift(session, instance, domain) {
+  const expected = normalizeOrigin(domain);
+  if (!expected) return;
+  const current = await readRemoteAppURL(session, instance);
+  if (!current || normalizeOrigin(current) === expected) return;
+  p32.log.warn(
+    `This app's PocketBase ${pc11.cyan("appURL")} is ${pc11.dim(current)}, but it is served on ${pc11.dim(expected)}.
+
+Emails and anything else PocketBase links to will use the former. Update it in
+the admin panel if that is not deliberate.`
+  );
+}
 async function copyLocalBranding(session, instance, workspaceRootDir, appURL) {
   const local = await readLocalMeta(workspaceRootDir);
   if (!local) return;
@@ -7199,17 +7293,17 @@ async function copyLocalBranding(session, instance, workspaceRootDir, appURL) {
     if (copied.length === 0) return;
     const outcome = await restartInstance(session, instance);
     if (outcome.deployed && !outcome.restarted) {
-      p31.log.warn(
+      p32.log.warn(
         `Copied ${copied.join(", ")}, but the app did not restart to pick them up.
-${pc10.dim(outcome.error ?? "")}`
+${pc11.dim(outcome.error ?? "")}`
       );
       return;
     }
-    p31.log.success(`Copied ${copied.join(", ")} from this project's database`);
+    p32.log.success(`Copied ${copied.join(", ")} from this project's database`);
   } catch (err) {
-    p31.log.warn(
+    p32.log.warn(
       `Could not copy this project's PocketBase settings across.
-Set them in the admin panel instead. ${pc10.dim(String(err))}`
+Set them in the admin panel instead. ${pc11.dim(String(err))}`
     );
   }
 }
@@ -7260,7 +7354,7 @@ async function uploadRelease(session, instance, release, entries) {
 }
 function isDirectory(target) {
   try {
-    return fs33.statSync(target).isDirectory();
+    return fs34.statSync(target).isDirectory();
   } catch {
     return false;
   }
@@ -7268,20 +7362,20 @@ function isDirectory(target) {
 async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
-  if (!fs33.existsSync(path39.join(workspaceRootDir, ".env"))) return;
-  p31.log.warn(
+  if (!fs34.existsSync(path39.join(workspaceRootDir, ".env"))) return;
+  p32.log.warn(
     `This app has no production environment variables yet.
 
-Local ${pc10.cyan(".env")} values are not uploaded by a deploy. Set them with
-${pc10.cyan("vela env set KEY")}, or copy a file across with ${pc10.cyan("vela env import .env.production")}.`
+Local ${pc11.cyan(".env")} values are not uploaded by a deploy. Set them with
+${pc11.cyan("vela env set KEY")}, or copy a file across with ${pc11.cyan("vela env import .env.production")}.`
   );
 }
 
 // src/commands/link.ts
 import path40 from "node:path";
-import process25 from "node:process";
+import process26 from "node:process";
 import { Command as Command72 } from "commander";
-import * as p32 from "@clack/prompts";
+import * as p33 from "@clack/prompts";
 
 // src/lib/velastack-api.ts
 async function apiFetch(apiKey, pathAndQuery, init) {
@@ -7337,7 +7431,7 @@ async function linkProject() {
   const { workspaceRootDir } = await getWorkspace();
   const existing = readProjectConfig(workspaceRootDir);
   if (existing) {
-    p32.log.success(`Linked to ${existing.projectName}.`);
+    p33.log.success(`Linked to ${existing.projectName}.`);
     return;
   }
   const apiKey = requireApiKey();
@@ -7364,10 +7458,10 @@ async function linkProject() {
     projectName = created.name;
   }
   writeProjectConfig(workspaceRootDir, { projectId, teamId, projectName });
-  p32.log.success(`Linked to ${projectName}.`);
+  p33.log.success(`Linked to ${projectName}.`);
 }
 async function pickExistingProject(projects) {
-  const choice = await p32.select({
+  const choice = await p33.select({
     message: "Select a project",
     options: [
       ...projects.map((pr) => ({
@@ -7377,39 +7471,39 @@ async function pickExistingProject(projects) {
       { value: CREATE_NEW, label: "Create a new project" }
     ]
   });
-  if (p32.isCancel(choice)) {
-    p32.cancel("Operation cancelled.");
-    process25.exit(0);
+  if (p33.isCancel(choice)) {
+    p33.cancel("Operation cancelled.");
+    process26.exit(0);
   }
   return choice;
 }
 async function pickTeam(teams3) {
   if (teams3.length === 1) return teams3[0];
-  const choice = await p32.select({
+  const choice = await p33.select({
     message: "Select a team",
     options: teams3.map((team) => ({
       value: team.id,
       label: team.is_personal ? `${team.name} (personal)` : team.name
     }))
   });
-  if (p32.isCancel(choice)) {
-    p32.cancel("Operation cancelled.");
-    process25.exit(0);
+  if (p33.isCancel(choice)) {
+    p33.cancel("Operation cancelled.");
+    process26.exit(0);
   }
   return teams3.find((team) => team.id === choice);
 }
 async function promptProjectName(workspaceRootDir) {
   const defaultValue = defaultProjectName2(workspaceRootDir);
-  const value = await p32.text({
+  const value = await p33.text({
     message: "Project name",
     defaultValue,
     initialValue: defaultValue,
     placeholder: defaultValue,
     validate: (v9) => !v9?.trim() ? "Required" : void 0
   });
-  if (p32.isCancel(value)) {
-    p32.cancel("Operation cancelled.");
-    process25.exit(0);
+  if (p33.isCancel(value)) {
+    p33.cancel("Operation cancelled.");
+    process26.exit(0);
   }
   return value.trim();
 }
@@ -7428,21 +7522,21 @@ import { Command as Command77 } from "commander";
 
 // src/commands/env/list.ts
 import { Command as Command73 } from "commander";
-import * as p34 from "@clack/prompts";
-import pc12 from "picocolors";
+import * as p35 from "@clack/prompts";
+import pc13 from "picocolors";
 
 // src/lib/local-env.ts
-import fs34 from "node:fs";
-import * as p33 from "@clack/prompts";
-import pc11 from "picocolors";
+import fs35 from "node:fs";
+import * as p34 from "@clack/prompts";
+import pc12 from "picocolors";
 function readLocalEnv(envFile) {
-  if (!fs34.existsSync(envFile)) return {};
+  if (!fs35.existsSync(envFile)) return {};
   return readLocalEnvFile(envFile);
 }
 function editLocalEnv(envFile, edit) {
-  const before = fs34.existsSync(envFile) ? fs34.readFileSync(envFile, "utf8") : "";
+  const before = fs35.existsSync(envFile) ? fs35.readFileSync(envFile, "utf8") : "";
   const after = edit(before);
-  if (after !== before) fs34.writeFileSync(envFile, after);
+  if (after !== before) fs35.writeFileSync(envFile, after);
 }
 function setLocalEnv(envFile, key, value) {
   editLocalEnv(envFile, (content) => upsertEnvVar(content, key, value));
@@ -7459,16 +7553,16 @@ async function applyLocalEnvChange(ctx, changed) {
       process.env.POCKETBASE_SUPERUSER_EMAIL = email3;
       process.env.POCKETBASE_SUPERUSER_PASSWORD = password10;
       await ensureSuperuser(ctx.workspaceRootDir);
-      p33.log.success("Local superuser updated to match");
+      p34.log.success("Local superuser updated to match");
     } else {
-      p33.log.warn(
+      p34.log.warn(
         `The local database still has the old superuser.
-Set both ${pc11.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc11.cyan("POCKETBASE_SUPERUSER_PASSWORD")} to reconcile it.`
+Set both ${pc12.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc12.cyan("POCKETBASE_SUPERUSER_PASSWORD")} to reconcile it.`
       );
     }
   }
   if (getPocketbaseMetadata(ctx.workspaceRootDir)) {
-    p33.log.info(`Restart ${pc11.cyan("vela dev")} to pick this up.`);
+    p34.log.info(`Restart ${pc12.cyan("vela dev")} to pick this up.`);
   }
 }
 
@@ -7496,21 +7590,21 @@ var envList = addTargetOptions(
 );
 function report(keys, where) {
   if (keys.length === 0) {
-    p34.log.info(`No environment variables configured ${pc12.dim(`(${where})`)}.`);
+    p35.log.info(`No environment variables configured ${pc13.dim(`(${where})`)}.`);
     return;
   }
-  p34.log.info(
-    `Environment ${pc12.dim(`(${where})`)}
+  p35.log.info(
+    `Environment ${pc13.dim(`(${where})`)}
 
 ` + keys.sort().map((key) => `  ${key}`).join("\n")
   );
 }
 
 // src/commands/env/set.ts
-import process26 from "node:process";
+import process27 from "node:process";
 import { Command as Command74 } from "commander";
-import * as p35 from "@clack/prompts";
-import pc13 from "picocolors";
+import * as p36 from "@clack/prompts";
+import pc14 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"
@@ -7522,14 +7616,14 @@ var envSet = addTargetOptions(
         local: async (ctx) => {
           const resolved = await resolveValue(key, value);
           setLocalEnv(ctx.envFile, key, resolved);
-          p35.log.success(`${key} updated ${pc13.dim("(local)")}`);
+          p36.log.success(`${key} updated ${pc14.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 ${pc13.dim(`(${ctx.targetName})`)}`);
+          p36.log.success(`${key} updated ${pc14.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -7543,21 +7637,21 @@ async function resolveValue(key, value) {
   return value ?? await promptValue(key);
 }
 async function promptValue(key) {
-  const value = await p35.password({
-    message: `Value for ${pc13.cyan(key)}`,
+  const value = await p36.password({
+    message: `Value for ${pc14.cyan(key)}`,
     validate: (input) => !input?.length ? "Required" : void 0
   });
-  if (p35.isCancel(value)) {
-    p35.cancel("Operation cancelled.");
-    process26.exit(0);
+  if (p36.isCancel(value)) {
+    p36.cancel("Operation cancelled.");
+    process27.exit(0);
   }
   return value;
 }
 
 // src/commands/env/unset.ts
 import { Command as Command75 } from "commander";
-import * as p36 from "@clack/prompts";
-import pc14 from "picocolors";
+import * as p37 from "@clack/prompts";
+import pc15 from "picocolors";
 var envUnset = addTargetOptions(
   new Command75("unset").description("remove an environment variable").argument("<key>", "variable name").configureHelp(helpConfig),
   "local"
@@ -7568,22 +7662,22 @@ var envUnset = addTargetOptions(
       {
         local: async (ctx) => {
           if (!(key in readLocalEnv(ctx.envFile))) {
-            p36.log.info(`${key} is not set \u2014 nothing to remove.`);
+            p37.log.info(`${key} is not set \u2014 nothing to remove.`);
             return;
           }
           unsetLocalEnv(ctx.envFile, key);
-          p36.log.success(`${key} removed ${pc14.dim("(local)")}`);
+          p37.log.success(`${key} removed ${pc15.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.`);
+            p37.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 ${pc14.dim(`(${ctx.targetName})`)}`);
+          p37.log.success(`${key} removed ${pc15.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -7594,12 +7688,12 @@ var envUnset = addTargetOptions(
 );
 
 // src/commands/env/import.ts
-import fs35 from "node:fs";
+import fs36 from "node:fs";
 import path41 from "node:path";
-import process27 from "node:process";
+import process28 from "node:process";
 import { Command as Command76 } from "commander";
-import * as p37 from "@clack/prompts";
-import pc15 from "picocolors";
+import * as p38 from "@clack/prompts";
+import pc16 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"
@@ -7616,22 +7710,22 @@ var envImport = addTargetOptions(
           const incoming = read(source, file);
           const keys = Object.keys(incoming);
           if (keys.length === 0) return;
-          p37.log.step(`Importing ${keys.length} variable(s) from ${pc15.cyan(file)}`);
+          p38.log.step(`Importing ${keys.length} variable(s) from ${pc16.cyan(file)}`);
           editLocalEnv(
             ctx.envFile,
             (content) => keys.reduce((acc, key) => upsertEnvVar(acc, key, incoming[key]), content)
           );
-          p37.log.success(`${keys.length} variable(s) updated ${pc15.dim("(local)")}`);
+          p38.log.success(`${keys.length} variable(s) updated ${pc16.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 ${pc15.cyan(file)}`);
+          p38.log.step(`Importing ${keys.length} variable(s) from ${pc16.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 ${pc15.dim(`(${ctx.targetName})`)}`);
+          p38.log.success(`${keys.length} variable(s) updated ${pc16.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, keys);
         }
       },
@@ -7641,12 +7735,12 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path41.resolve(process27.cwd(), file);
+  return path41.resolve(process28.cwd(), file);
 }
 function read(resolved, shown) {
-  if (!fs35.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
+  if (!fs36.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
   const incoming = readLocalEnvFile(resolved);
-  if (Object.keys(incoming).length === 0) p37.log.info(`${shown} has no variables to import.`);
+  if (Object.keys(incoming).length === 0) p38.log.info(`${shown} has no variables to import.`);
   return incoming;
 }
 
@@ -7655,8 +7749,8 @@ var env = new Command77("env").description("manage environment variables, locall
 
 // src/commands/status.ts
 import { Command as Command78 } from "commander";
-import * as p38 from "@clack/prompts";
-import pc16 from "picocolors";
+import * as p39 from "@clack/prompts";
+import pc17 from "picocolors";
 var status = addTargetOptions(
   new Command78("status").description("show what is deployed").configureHelp(helpConfig),
   "production"
@@ -7689,15 +7783,15 @@ function report2(states, json) {
     return;
   }
   if (states.length === 0) {
-    p38.log.info("Nothing is deployed here yet.");
+    p39.log.info("Nothing is deployed here yet.");
     return;
   }
   for (const state of states) {
-    p38.log.info(describe(state));
+    p39.log.info(describe(state));
   }
 }
 function describe(state) {
-  const health = (value) => value === "active" ? pc16.green(value) : pc16.red(value || "inactive");
+  const health = (value) => value === "active" ? pc17.green(value) : pc17.red(value || "inactive");
   const rows = [
     ["Instance", state.instance],
     ["Environment", state.env],
@@ -7712,13 +7806,13 @@ function describe(state) {
     ...state.gitSha ? [["Commit", state.gitSha.slice(0, 12)]] : []
   ];
   const width = Math.max(...rows.map(([label]) => label.length));
-  return pc16.cyan(state.name) + "\n\n" + rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value}`).join("\n");
+  return pc17.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 pc17 from "picocolors";
+import * as p40 from "@clack/prompts";
+import pc18 from "picocolors";
 var rollback = addTargetOptions(
   new Command79("rollback").description("put the previous release back").configureHelp(helpConfig),
   "production"
@@ -7729,8 +7823,8 @@ var rollback = addTargetOptions(
       raw,
       {
         remote: async (ctx) => {
-          p39.log.step(
-            `Rolling back ${pc17.cyan(ctx.appName)} ${pc17.dim(`(${ctx.targetName})`)} on ${ctx.server}`
+          p40.log.step(
+            `Rolling back ${pc18.cyan(ctx.appName)} ${pc18.dim(`(${ctx.targetName})`)} on ${ctx.server}`
           );
           const result = await runServerScript(
             ctx.session,
@@ -7740,8 +7834,8 @@ var rollback = addTargetOptions(
               stream: true
             }
           );
-          p39.log.success(
-            `Rolled back to ${pc17.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc17.dim(`(was ${result.from})`)}` : "")
+          p40.log.success(
+            `Rolled back to ${pc18.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc18.dim(`(was ${result.from})`)}` : "")
           );
         }
       },
@@ -7793,10 +7887,10 @@ var logs = addTargetOptions(
 import { Command as Command82 } from "commander";
 
 // src/commands/admin/create.ts
-import process28 from "node:process";
+import process29 from "node:process";
 import { Command as Command81 } from "commander";
-import * as p40 from "@clack/prompts";
-import pc18 from "picocolors";
+import * as p41 from "@clack/prompts";
+import pc19 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),
@@ -7827,8 +7921,8 @@ var adminCreate = addTargetOptions(
             const metadata = getPocketbaseMetadata(ctx.workspaceRootDir);
             if (metadata) signIn = `http://${metadata.viteHost}:${metadata.vitePort}`;
           }
-          p40.log.info(
-            signIn ? `Sign in at ${pc18.cyan(`${signIn}/admin`)}` : `Sign in at ${pc18.cyan("/admin")} once ${pc18.cyan("vela dev")} is running.`
+          p41.log.info(
+            signIn ? `Sign in at ${pc19.cyan(`${signIn}/admin`)}` : `Sign in at ${pc19.cyan("/admin")} once ${pc19.cyan("vela dev")} is running.`
           );
         },
         remote: async (ctx) => {
@@ -7841,8 +7935,8 @@ var adminCreate = addTargetOptions(
             (pb) => upsertSuperuser(pb, address, password10)
           );
           const base2 = state?.domain ? `https://${state.domain.split(",")[0].trim()}` : "";
-          p40.log.info(
-            base2 ? `Sign in at ${pc18.cyan(`${base2}/admin`)}` : `Sign in at ${pc18.cyan("/admin")} once a domain is configured for this target.`
+          p41.log.info(
+            base2 ? `Sign in at ${pc19.cyan(`${base2}/admin`)}` : `Sign in at ${pc19.cyan("/admin")} once a domain is configured for this target.`
           );
         }
       },
@@ -7854,20 +7948,20 @@ var adminCreate = addTargetOptions(
 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?`,
+    const confirmed = await p41.confirm({
+      message: `${email3} already has an account, update its password?`,
       initialValue: false
     });
-    if (p40.isCancel(confirmed) || !confirmed) {
-      p40.cancel("Operation cancelled.");
-      process28.exit(0);
+    if (p41.isCancel(confirmed) || !confirmed) {
+      p41.cancel("Operation cancelled.");
+      process29.exit(0);
     }
     await pb.collection("_superusers").update(existing, { password: password10, passwordConfirm: password10 });
-    p40.log.success(`Password reset for ${pc18.cyan(email3)}`);
+    p41.log.success(`Password updated for ${pc19.cyan(email3)}, you can sign in now`);
     return;
   }
   await pb.collection("_superusers").create({ email: email3, password: password10, passwordConfirm: password10 });
-  p40.log.success(`${pc18.cyan(email3)} can now sign in`);
+  p41.log.success(`${pc19.cyan(email3)} can now sign in`);
 }
 async function findSuperuser(pb, email3) {
   try {
@@ -7878,32 +7972,32 @@ async function findSuperuser(pb, email3) {
   }
 }
 async function promptEmail() {
-  const value = await p40.text({
+  const value = await p41.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.");
-    process28.exit(0);
+  if (p41.isCancel(value)) {
+    p41.cancel("Operation cancelled.");
+    process29.exit(0);
   }
   return value.trim();
 }
 async function promptPassword2() {
-  const value = await p40.password({
+  const value = await p41.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.");
-    process28.exit(0);
+  if (p41.isCancel(value)) {
+    p41.cancel("Operation cancelled.");
+    process29.exit(0);
   }
-  const again = await p40.password({
+  const again = await p41.password({
     message: "Password again",
     validate: (input) => input === value ? void 0 : "The two do not match"
   });
-  if (p40.isCancel(again)) {
-    p40.cancel("Operation cancelled.");
-    process28.exit(0);
+  if (p41.isCancel(again)) {
+    p41.cancel("Operation cancelled.");
+    process29.exit(0);
   }
   return value;
 }
@@ -7913,8 +8007,8 @@ var admin = new Command82("admin").description("manage admin panel logins").conf
 
 // src/commands/targets.ts
 import { Command as Command83 } from "commander";
-import * as p41 from "@clack/prompts";
-import pc19 from "picocolors";
+import * as p42 from "@clack/prompts";
+import pc20 from "picocolors";
 import * as v8 from "valibot";
 var OptionsSchema4 = v8.object({
   ...SSH_OPTION_SCHEMA,
@@ -7986,13 +8080,13 @@ function report3(rows, offline) {
   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" ? pc19.dim(row.target.padEnd(target)) : pc19.cyan(row.target.padEnd(target))}  ${row.server.padEnd(server)}  ${row.domain.padEnd(domain)}  ${row.release}`
+    (row) => `${row.kind === "local" ? pc20.dim(row.target.padEnd(target)) : pc20.cyan(row.target.padEnd(target))}  ${row.server.padEnd(server)}  ${row.domain.padEnd(domain)}  ${row.release}`
   );
-  p41.log.info(`${pc19.dim(header)}
+  p42.log.info(`${pc20.dim(header)}
 ${lines.join("\n")}`);
   const unreachable = rows.filter((row) => row.kind === "remote" && !row.reachable);
   if (!offline && unreachable.length > 0) {
-    p41.log.warn(
+    p42.log.warn(
       `Could not reach ${unreachable.map((row) => row.server).join(", ")}.
 Release and domain are shown from what this project recorded.`
     );
@@ -8001,31 +8095,31 @@ Release and domain are shown from what this project recorded.`
 
 // src/commands/test.ts
 import path42 from "node:path";
-import process29 from "node:process";
+import process30 from "node:process";
 import { Command as Command84 } from "commander";
 import PocketBase5 from "pocketbase";
-import pc20 from "picocolors";
+import pc21 from "picocolors";
 import { x as x5 } from "tinyexec";
 import { detect as detect8 } from "package-manager-detector";
 import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
-import fs36 from "node:fs";
+import fs37 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 = process29.cwd();
+  const cwd = process30.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password10 = "password";
   const testDataDir = path42.join(cwd, "test-data");
-  fs36.rmSync(testDataDir, { recursive: true, force: true });
+  fs37.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
     migrationsDir: path42.join(cwd, "migrations"),
     email: email3,
     password: password10
   });
-  process29.env.POCKETBASE_URL = url;
-  process29.env.POCKETBASE_SUPERUSER_EMAIL = email3;
-  process29.env.POCKETBASE_SUPERUSER_PASSWORD = password10;
-  process29.env.TEST = "true";
-  console.log(`${pc20.greenBright("\u2713")} Created test database`);
+  process30.env.POCKETBASE_URL = url;
+  process30.env.POCKETBASE_SUPERUSER_EMAIL = email3;
+  process30.env.POCKETBASE_SUPERUSER_PASSWORD = password10;
+  process30.env.TEST = "true";
+  console.log(`${pc21.greenBright("\u2713")} Created test database`);
   const { createServer } = await loadVite(cwd);
   const vite = await createServer({
     mode: "test",
@@ -8034,21 +8128,21 @@ var testServer = new Command84("test:server").description("run server tests").al
   });
   const vitePort = await findFreePort();
   await vite.listen(vitePort);
-  process29.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
-  console.log(`${pc20.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
-  console.log(`${pc20.greenBright("\u2713")} Started PocketBase: ${url}`);
+  process30.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
+  console.log(`${pc21.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
+  console.log(`${pc21.greenBright("\u2713")} Started PocketBase: ${url}`);
   const cleanup = async () => {
     stop();
     await vite.close();
-    fs36.rmSync(testDataDir, { recursive: true, force: true });
+    fs37.rmSync(testDataDir, { recursive: true, force: true });
   };
   const pb = new PocketBase5(url);
   try {
     await authWithRetries(pb, email3, password10);
   } catch (e) {
     await cleanup();
-    console.error(`${pc20.redBright("\u2717")} Auth failed: ${e.message}`);
-    process29.exit(1);
+    console.error(`${pc21.redBright("\u2717")} Auth failed: ${e.message}`);
+    process30.exit(1);
   }
   const extraArgs = (cmd.parent?.args ?? []).slice(1);
   let filter = extraArgs.find((arg) => !arg.startsWith("-"));
@@ -8066,7 +8160,7 @@ var testServer = new Command84("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: { ...process29.env, CI: "1" } },
+      nodeOptions: { cwd, stdio: "inherit", env: { ...process30.env, CI: "1" } },
       throwOnError: true
     });
   } catch {
@@ -8092,7 +8186,7 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs37 from "node:fs";
+import fs38 from "node:fs";
 import path43 from "node:path";
 import { Command as Command85 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
@@ -8113,7 +8207,7 @@ var routes = new Command85("routes").description("list routes").configureHelp(he
   printTable(found);
 });
 function walk(root, dir) {
-  const entries = fs37.readdirSync(dir, { withFileTypes: true });
+  const entries = fs38.readdirSync(dir, { withFileTypes: true });
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
@@ -8139,7 +8233,7 @@ function isRouteFile(name) {
 }
 function extractMethods(file) {
   try {
-    const content = fs37.readFileSync(file, "utf8");
+    const content = fs38.readFileSync(file, "utf8");
     const methods = [];
     const exportRegex = /export\s+(?:const|async\s+function|function)\s+(\w+)/g;
     let match;
@@ -8180,13 +8274,13 @@ function printTable(routes2) {
 }
 
 // src/commands/i18n.ts
-import process30 from "node:process";
+import process31 from "node:process";
 import { Command as Command86 } from "commander";
 import { x as x6 } from "tinyexec";
 import { detect as detect9 } from "package-manager-detector";
 import { resolveCommand as resolveCommand9 } from "package-manager-detector/commands";
 async function runWuchale(extraArgs) {
-  const cwd = process30.cwd();
+  const cwd = process31.cwd();
   const pm = (await detect9({ cwd }))?.name ?? "npm";
   const resolved = resolveCommand9(pm, "execute", ["wuchale", ...extraArgs]);
   const args = resolved.args.slice();
@@ -8236,7 +8330,7 @@ var BACKEND_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["dev", "build", "previe
 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;
-  const envRoot = findWorkspaceRoot() ?? process31.cwd();
+  const envRoot = findWorkspaceRoot() ?? process32.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
   const path44 = getCommandPath(actionCommand);
   if (NO_BACKEND_COMMMANDS.has(path44)) return;
@@ -8244,29 +8338,29 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
-    p42.log.error(
-      `${pc21.cyan(`vela ${path44}`)} needs a backend, and this project does not have one.
+    p43.log.error(
+      `${pc22.cyan(`vela ${path44}`)} 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 ${pc21.cyan("vela bless")}.`
+To add a backend to this project, run ${pc22.cyan("vela bless")}.`
     );
-    p42.log.message();
-    p42.cancel("Operation failed.");
-    process31.exit(1);
+    p43.log.message();
+    p43.cancel("Operation failed.");
+    process32.exit(1);
   }
-  if (!process31.env.POCKETBASE_SUPERUSER_EMAIL || !process31.env.POCKETBASE_SUPERUSER_PASSWORD) {
-    p42.log.error(
+  if (!process32.env.POCKETBASE_SUPERUSER_EMAIL || !process32.env.POCKETBASE_SUPERUSER_PASSWORD) {
+    p43.log.error(
       `PocketBase superuser credentials are required.
 
-Set ${pc21.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc21.cyan("POCKETBASE_SUPERUSER_PASSWORD")} in your .env file.
+Set ${pc22.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc22.cyan("POCKETBASE_SUPERUSER_PASSWORD")} in your .env file.
 
-To set up a new project, run ${pc21.cyan("vela create")}.
-To set up an existing project, run ${pc21.cyan("vela bless")}.`
+To set up a new project, run ${pc22.cyan("vela create")}.
+To set up an existing project, run ${pc22.cyan("vela bless")}.`
     );
-    p42.log.message();
-    p42.cancel("Operation failed.");
-    process31.exit(1);
+    p43.log.message();
+    p43.cancel("Operation failed.");
+    process32.exit(1);
   }
 });
 function getCommandPath(cmd) {
@@ -8317,14 +8411,14 @@ for (const command of [
 }
 
 // src/bin.ts
-var argv = normalizeArgv(process32.argv.slice(2));
+var argv = normalizeArgv(process33.argv.slice(2));
 var delegatedExitCode = delegateToLocalCli({
   argv,
   selfPath: fileURLToPath2(import.meta.url),
   selfVersion: package_default.version
 });
 if (delegatedExitCode !== null) {
-  process32.exit(delegatedExitCode);
+  process33.exit(delegatedExitCode);
 }
 program.parse(argv, { from: "user" });
 //# sourceMappingURL=bin.js.map