vela 0.10.3 → 0.10.5

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import process31 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.3",
+  version: "0.10.5",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -41,7 +41,7 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^1.7.0",
     "@faker-js/faker": "^10.6.0",
-    "@velastack/patterns": "^0.1.0",
+    "@velastack/patterns": "^0.1.2",
     "@velastack/pocketbase-codegen": "^0.1.0",
     "annotate-json-schema": "^0.1.0",
     commander: "^13.1.0",
@@ -168,12 +168,12 @@ function delegateToLocalCli(opts) {
 }
 
 // src/program.ts
-import process30 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 pc20 from "picocolors";
+import pc22 from "picocolors";
 
 // src/lib/help.ts
 import pc from "picocolors";
@@ -350,8 +350,8 @@ function mergePackageJson(user, template) {
   }
   return { merged, added, conflicts, replaced };
 }
-function readPackageJson(path43) {
-  return JSON.parse(fs2.readFileSync(path43, "utf8"));
+function readPackageJson(path44) {
+  return JSON.parse(fs2.readFileSync(path44, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -364,12 +364,12 @@ function fillTemplatePlaceholders(raw, values) {
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
-function readTemplatePackageJson(path43, values) {
-  const raw = fillTemplatePlaceholders(fs2.readFileSync(path43, "utf8"), values);
+function readTemplatePackageJson(path44, values) {
+  const raw = fillTemplatePlaceholders(fs2.readFileSync(path44, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path43, pkg) {
-  fs2.writeFileSync(path43, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path44, pkg) {
+  fs2.writeFileSync(path44, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -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);
@@ -6591,12 +6591,51 @@ var migrate = new Command65("migrate").description("manage database migrations")
 
 // src/commands/dev.ts
 import fs30 from "node:fs";
-import path32 from "node:path";
-import process20 from "node:process";
+import path33 from "node:path";
+import process21 from "node:process";
 import { performance } from "node:perf_hooks";
 import { Command as Command66, InvalidArgumentError as InvalidArgumentError5 } from "commander";
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 import PocketBase2 from "pocketbase";
+
+// src/lib/vite.ts
+import path32 from "node:path";
+import process20 from "node:process";
+import { createRequire as createRequire2 } from "node:module";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import pc7 from "picocolors";
+var REQUIRED_VITE_MAJOR = 8;
+function viteVersionError(version) {
+  const major = Number.parseInt(version, 10);
+  if (!Number.isFinite(major) || major >= REQUIRED_VITE_MAJOR) return null;
+  return [
+    `This project has vite ${version}, but vela needs vite ${REQUIRED_VITE_MAJOR} or newer.`,
+    "",
+    "  npm install -D vite@^8 @sveltejs/vite-plugin-svelte@^7",
+    "",
+    "Both move together: @sveltejs/vite-plugin-svelte 7 requires vite 8, and",
+    "version 6 is the last that supports vite 7."
+  ].join("\n");
+}
+function resolveProjectVite(cwd) {
+  try {
+    return createRequire2(path32.join(cwd, "package.json")).resolve("vite");
+  } catch {
+    return null;
+  }
+}
+async function loadVite(cwd = process20.cwd()) {
+  const entry = resolveProjectVite(cwd);
+  const vite = entry ? await import(pathToFileURL2(entry).href) : await import("vite");
+  const error = viteVersionError(vite.version);
+  if (error) {
+    console.error(`${pc7.redBright("\u2717")} ${error}`);
+    process20.exit(1);
+  }
+  return vite;
+}
+
+// src/commands/dev.ts
 function parsePort(value) {
   const port = Number(value);
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
@@ -6605,37 +6644,37 @@ function parsePort(value) {
   return port;
 }
 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 cwd = process21.cwd();
   const startTime = performance.now();
-  const { createServer, version } = await import("vite");
-  const viteMetadataDir = path32.join(cwd, "node_modules", ".vite");
-  const viteMetadataFile = path32.join(viteMetadataDir, "_pocketbase_metadata.json");
+  const { createServer, version } = await loadVite(cwd);
+  const viteMetadataDir = path33.join(cwd, "node_modules", ".vite");
+  const viteMetadataFile = path33.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
-  const needsStart = backend3 && !process20.env.POCKETBASE_URL;
+  const needsStart = backend3 && !process21.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
     if (fs30.existsSync(viteMetadataFile)) fs30.rmSync(viteMetadataFile);
   };
   if (needsStart) {
-    const dataDir = path32.join(cwd, DATA_DIR);
+    const dataDir = path33.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path32.join(dataDir, "hooks"),
+      hooksDir: path33.join(dataDir, "hooks"),
       dev: true,
       stdio: "pipe"
     });
     pbProc = started.proc;
-    process20.env.POCKETBASE_URL = started.url;
-    pbProc.stdout?.pipe(process20.stdout);
-    pbProc.stderr?.pipe(process20.stderr);
+    process21.env.POCKETBASE_URL = started.url;
+    pbProc.stdout?.pipe(process21.stdout);
+    pbProc.stderr?.pipe(process21.stderr);
     pbProc.on("error", (err) => console.error("PocketBase error:", err));
     pbProc.on("exit", (code) => console.log(`PocketBase exited with code ${code}`));
-    process20.on("exit", cleanup);
-    process20.on("SIGINT", () => {
+    process21.on("exit", cleanup);
+    process21.on("SIGINT", () => {
       cleanup();
-      process20.exit(0);
+      process21.exit(0);
     });
   }
   const serverOptions = {};
@@ -6657,27 +6696,27 @@ var dev = new Command66("dev").description("start the development server").optio
     await fs30.promises.writeFile(
       viteMetadataFile,
       JSON.stringify({
-        pocketbaseUrl: process20.env.POCKETBASE_URL,
+        pocketbaseUrl: process21.env.POCKETBASE_URL,
         vitePort,
         viteHost
       })
     );
-    const pb = new PocketBase2(process20.env.POCKETBASE_URL);
+    const pb = new PocketBase2(process21.env.POCKETBASE_URL);
     await pb.collection("_superusers").authWithPassword(
-      process20.env.POCKETBASE_SUPERUSER_EMAIL,
-      process20.env.POCKETBASE_SUPERUSER_PASSWORD
+      process21.env.POCKETBASE_SUPERUSER_EMAIL,
+      process21.env.POCKETBASE_SUPERUSER_PASSWORD
     );
     await pb.settings.update({ meta: { appURL: `http://${viteHost}:${vitePort}` } });
     await startWatchingTypes(cwd, pb);
   });
   await server.listen();
-  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`
+  const hasExistingLogs = process21.stdout.bytesWritten > 0 || process21.stderr.bytesWritten > 0;
+  const startupDurationString = pc8.dim(
+    `ready in ${pc8.reset(pc8.bold(Math.ceil(performance.now() - startTime)))} ms`
   );
   server.config.logger.info(
     `
-  ${pc7.green(`${pc7.bold("VITE")} v${version}`)}  ${startupDurationString}
+  ${pc8.green(`${pc8.bold("VITE")} v${version}`)}  ${startupDurationString}
 `,
     { clear: !hasExistingLogs }
   );
@@ -6686,9 +6725,9 @@ var dev = new Command66("dev").description("start the development server").optio
 });
 async function startWatchingTypes(cwd, pb) {
   const { processTypes } = await import("@velastack/pocketbase-codegen");
-  const typesDir = path32.resolve(cwd, ".svelte-kit", "types");
-  const pocketbaseDir = path32.join(typesDir, "pocketbase");
-  const pocketbaseTypes = path32.join(pocketbaseDir, "$types.d.ts");
+  const typesDir = path33.resolve(cwd, ".svelte-kit", "types");
+  const pocketbaseDir = path33.join(typesDir, "pocketbase");
+  const pocketbaseTypes = path33.join(pocketbaseDir, "$types.d.ts");
   const regenerate = () => processTypes(pb, typesDir).catch(() => {
   });
   await regenerate();
@@ -6709,35 +6748,61 @@ async function startWatchingTypes(cwd, pb) {
 }
 
 // src/commands/build.ts
-import path33 from "node:path";
-import process21 from "node:process";
+import fs31 from "node:fs";
+import path34 from "node:path";
+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 () => {
-  process21.env.VITE_BUILD = "true";
-  const cwd = process21.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) && !process21.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process23.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
     await ensureSuperuser(cwd);
-    const dataDir = path33.join(cwd, DATA_DIR);
+    const dataDir = path34.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path33.join(dataDir, "hooks"),
+      hooksDir: path34.join(dataDir, "hooks"),
       dev: true
     });
     pbProc = started.proc;
-    process21.env.POCKETBASE_URL = started.url;
-    process21.on("exit", cleanup);
-    process21.on("SIGINT", () => {
+    process23.env.POCKETBASE_URL = started.url;
+    process23.on("exit", cleanup);
+    process23.on("SIGINT", () => {
       cleanup();
-      process21.exit(0);
+      process23.exit(0);
     });
   }
   try {
@@ -6752,36 +6817,59 @@ 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 path34 from "node:path";
-import process22 from "node:process";
+import path35 from "node:path";
+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 = process22.cwd();
+  const cwd = process24.cwd();
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process22.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process24.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
-    const dataDir = path34.join(cwd, DATA_DIR);
+    const dataDir = path35.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path34.join(dataDir, "hooks"),
+      hooksDir: path35.join(dataDir, "hooks"),
       dev: true
     });
     pbProc = started.proc;
-    process22.env.POCKETBASE_URL = started.url;
-    process22.on("exit", cleanup);
-    process22.on("SIGINT", () => {
+    process24.env.POCKETBASE_URL = started.url;
+    process24.on("exit", cleanup);
+    process24.on("SIGINT", () => {
       cleanup();
-      process22.exit(0);
+      process24.exit(0);
     });
   }
   try {
@@ -6799,12 +6887,12 @@ var preview = new Command68("preview").description("preview the built app").conf
 });
 
 // src/commands/sync.ts
-import path35 from "node:path";
+import path36 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 typesDir = path36.join(workspaceRootDir, ".svelte-kit", "types");
     const { processTypes } = await import("@velastack/pocketbase-codegen");
     await withPocketbase(workspaceRootDir, async (pb) => {
       await processTypes(pb, typesDir);
@@ -6815,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 pc8 from "picocolors";
+import * as p31 from "@clack/prompts";
+import pc10 from "picocolors";
 import * as v6 from "valibot";
 var OptionsSchema2 = v6.object({
   ...SSH_OPTION_SCHEMA,
@@ -6829,19 +6917,19 @@ var provision = addSshOptions(
   (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)}`);
+    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",
@@ -6853,7 +6941,7 @@ var provision = addSshOptions(
         ],
         stream: true
       });
-      p30.log.success(
+      p31.log.success(
         `${target} is ready.
 
   Node        ${result?.node ?? "installed"}
@@ -6861,22 +6949,22 @@ var provision = addSshOptions(
   PocketBase  ${result?.pocketbase ?? pbVersion}`
       );
     });
-    p30.outro(`Deploy with ${pc8.cyan(`vela deploy --server ${target}`)}`);
+    p31.outro(`Deploy with ${pc10.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 path39 from "node:path";
+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 path36 from "node:path";
-import process23 from "node:process";
+import fs32 from "node:fs";
+import path37 from "node:path";
+import process25 from "node:process";
 import PocketBase4 from "pocketbase";
 
 // src/lib/remote-pocketbase.ts
@@ -6924,17 +7012,17 @@ async function withRemotePocketbase(session, instance, fn) {
 // 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;
+  const dataDir = path37.join(cwd, DATA_DIR);
+  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 {
     const started = await startPocketbaseServe({
       dataDir,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path36.join(dataDir, "hooks")
+      hooksDir: path37.join(dataDir, "hooks")
     });
     proc = started.proc;
     const pb = new PocketBase4(started.url);
@@ -6947,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) {
@@ -6963,8 +7064,8 @@ async function seedRemoteMeta(session, instance, local, appURL) {
 }
 
 // src/lib/artifact.ts
-import fs32 from "node:fs";
-import path37 from "node:path";
+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";
 var DEFAULT_OUTPUT_DIR = "build";
@@ -7001,11 +7102,11 @@ 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 localPath = path38.join(cwd, rel);
+    if (fs33.existsSync(localPath)) entries.push({ localPath, remoteDir });
   };
-  const buildPath = path37.join(cwd, outputDir);
-  if (!fs32.existsSync(path37.join(buildPath, "index.js"))) {
+  const buildPath = path38.join(cwd, outputDir);
+  if (!fs33.existsSync(path38.join(buildPath, "index.js"))) {
     throw new BuildError(
       `No ${outputDir}/index.js after the build.
 
@@ -7018,8 +7119,8 @@ the adapter in your Vite or Svelte config, then build again.`
   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" });
+  const hooks = path38.join(cwd, DATA_DIR, "hooks");
+  if (fs33.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
   for (const extra of config.include ?? []) add2(extra);
   return entries;
 }
@@ -7043,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(pc9.bgCyan(pc9.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(
-            `${pc9.cyan(ctx.appName)} ${pc9.dim("\u2192")} ${pc9.cyan(ctx.targetName)} ${pc9.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 ${pc9.cyan(ctx.targetName)} database on ${ctx.server} ${pc9.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 {
@@ -7084,9 +7203,9 @@ var deploy = addTargetOptions(
           }
           const entries = collectArtifact(workspaceRootDir, config.deploy ?? {});
           const sha = await gitSha(workspaceRootDir);
-          p31.log.step(`Uploading release ${pc9.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,
@@ -7118,8 +7237,8 @@ var deploy = addTargetOptions(
           });
           if (!existing) await reportEmptyEnvironment(session, instance, workspaceRootDir);
           const url = result?.url ?? "";
-          p31.log.success(
-            `Deployed ${pc9.cyan(ctx.appName)} ${pc9.dim(release)}
+          p32.log.success(
+            `Deployed ${pc11.cyan(ctx.appName)} ${pc11.dim(release)}
 
   URL   ${url}
   Port  ${result?.webPort ?? "?"}${backend3 ? ` (PocketBase ${result?.pbPort ?? "?"})` : ""}`
@@ -7131,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, ${pc9.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 ${pc9.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(`${pc9.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;
@@ -7160,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.
-${pc9.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. ${pc9.dim(String(err))}`
+Set them in the admin panel instead. ${pc11.dim(String(err))}`
     );
   }
 }
@@ -7221,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;
   }
@@ -7229,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(path38.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 ${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")}.`
+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 path39 from "node:path";
-import process24 from "node:process";
+import path40 from "node:path";
+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) {
@@ -7298,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();
@@ -7325,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) => ({
@@ -7338,50 +7471,50 @@ async function pickExistingProject(projects) {
       { value: CREATE_NEW, label: "Create a new project" }
     ]
   });
-  if (p32.isCancel(choice)) {
-    p32.cancel("Operation cancelled.");
-    process24.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.");
-    process24.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.");
-    process24.exit(0);
+  if (p33.isCancel(value)) {
+    p33.cancel("Operation cancelled.");
+    process26.exit(0);
   }
   return value.trim();
 }
 function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path39.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path40.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path39.basename(workspaceRootDir);
+  return path40.basename(workspaceRootDir);
 }
 
 // src/commands/env.ts
@@ -7389,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 pc11 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 pc10 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));
@@ -7420,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 ${pc10.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc10.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 ${pc10.cyan("vela dev")} to pick this up.`);
+    p34.log.info(`Restart ${pc12.cyan("vela dev")} to pick this up.`);
   }
 }
 
@@ -7457,21 +7590,21 @@ var envList = addTargetOptions(
 );
 function report(keys, where) {
   if (keys.length === 0) {
-    p34.log.info(`No environment variables configured ${pc11.dim(`(${where})`)}.`);
+    p35.log.info(`No environment variables configured ${pc13.dim(`(${where})`)}.`);
     return;
   }
-  p34.log.info(
-    `Environment ${pc11.dim(`(${where})`)}
+  p35.log.info(
+    `Environment ${pc13.dim(`(${where})`)}
 
 ` + keys.sort().map((key) => `  ${key}`).join("\n")
   );
 }
 
 // src/commands/env/set.ts
-import process25 from "node:process";
+import process27 from "node:process";
 import { Command as Command74 } from "commander";
-import * as p35 from "@clack/prompts";
-import pc12 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"
@@ -7483,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 ${pc12.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 ${pc12.dim(`(${ctx.targetName})`)}`);
+          p36.log.success(`${key} updated ${pc14.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -7504,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 ${pc12.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.");
-    process25.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 pc13 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"
@@ -7529,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 ${pc13.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 ${pc13.dim(`(${ctx.targetName})`)}`);
+          p37.log.success(`${key} removed ${pc15.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, [key]);
         }
       },
@@ -7555,12 +7688,12 @@ var envUnset = addTargetOptions(
 );
 
 // src/commands/env/import.ts
-import fs35 from "node:fs";
-import path40 from "node:path";
-import process26 from "node:process";
+import fs36 from "node:fs";
+import path41 from "node:path";
+import process28 from "node:process";
 import { Command as Command76 } from "commander";
-import * as p37 from "@clack/prompts";
-import pc14 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"
@@ -7577,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 ${pc14.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 ${pc14.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 ${pc14.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 ${pc14.dim(`(${ctx.targetName})`)}`);
+          p38.log.success(`${keys.length} variable(s) updated ${pc16.dim(`(${ctx.targetName})`)}`);
           await applyEnvRestart(ctx, keys);
         }
       },
@@ -7602,12 +7735,12 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path40.resolve(process26.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;
 }
 
@@ -7616,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 pc15 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"
@@ -7650,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" ? pc15.green(value) : pc15.red(value || "inactive");
+  const health = (value) => value === "active" ? pc17.green(value) : pc17.red(value || "inactive");
   const rows = [
     ["Instance", state.instance],
     ["Environment", state.env],
@@ -7673,13 +7806,13 @@ function describe(state) {
     ...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");
+  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 pc16 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"
@@ -7690,8 +7823,8 @@ var rollback = addTargetOptions(
       raw,
       {
         remote: async (ctx) => {
-          p39.log.step(
-            `Rolling back ${pc16.cyan(ctx.appName)} ${pc16.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,
@@ -7701,8 +7834,8 @@ var rollback = addTargetOptions(
               stream: true
             }
           );
-          p39.log.success(
-            `Rolled back to ${pc16.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc16.dim(`(was ${result.from})`)}` : "")
+          p40.log.success(
+            `Rolled back to ${pc18.cyan(result?.release ?? "the previous release")}` + (result?.from ? ` ${pc18.dim(`(was ${result.from})`)}` : "")
           );
         }
       },
@@ -7754,10 +7887,10 @@ var logs = addTargetOptions(
 import { Command as Command82 } from "commander";
 
 // src/commands/admin/create.ts
-import process27 from "node:process";
+import process29 from "node:process";
 import { Command as Command81 } from "commander";
-import * as p40 from "@clack/prompts";
-import pc17 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),
@@ -7788,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 ${pc17.cyan(`${signIn}/admin`)}` : `Sign in at ${pc17.cyan("/admin")} once ${pc17.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) => {
@@ -7802,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 ${pc17.cyan(`${base2}/admin`)}` : `Sign in at ${pc17.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.`
           );
         }
       },
@@ -7815,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.");
-      process27.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 ${pc17.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(`${pc17.cyan(email3)} can now sign in`);
+  p41.log.success(`${pc19.cyan(email3)} can now sign in`);
 }
 async function findSuperuser(pb, email3) {
   try {
@@ -7839,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.");
-    process27.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.");
-    process27.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.");
-    process27.exit(0);
+  if (p41.isCancel(again)) {
+    p41.cancel("Operation cancelled.");
+    process29.exit(0);
   }
   return value;
 }
@@ -7874,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 pc18 from "picocolors";
+import * as p42 from "@clack/prompts";
+import pc20 from "picocolors";
 import * as v8 from "valibot";
 var OptionsSchema4 = v8.object({
   ...SSH_OPTION_SCHEMA,
@@ -7947,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" ? pc18.dim(row.target.padEnd(target)) : pc18.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(`${pc18.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.`
     );
@@ -7961,33 +8094,33 @@ Release and domain are shown from what this project recorded.`
 }
 
 // src/commands/test.ts
-import path41 from "node:path";
-import process28 from "node:process";
+import path42 from "node:path";
+import process30 from "node:process";
 import { Command as Command84 } from "commander";
 import PocketBase5 from "pocketbase";
-import pc19 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 = process28.cwd();
+  const cwd = process30.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password10 = "password";
-  const testDataDir = path41.join(cwd, "test-data");
-  fs36.rmSync(testDataDir, { recursive: true, force: true });
+  const testDataDir = path42.join(cwd, "test-data");
+  fs37.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path41.join(cwd, "migrations"),
+    migrationsDir: path42.join(cwd, "migrations"),
     email: email3,
     password: password10
   });
-  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");
+  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",
     plugins: [stubPagesPlugin()],
@@ -7995,21 +8128,21 @@ var testServer = new Command84("test:server").description("run server tests").al
   });
   const vitePort = await findFreePort();
   await vite.listen(vitePort);
-  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}`);
+  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(`${pc19.redBright("\u2717")} Auth failed: ${e.message}`);
-    process28.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("-"));
@@ -8027,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: { ...process28.env, CI: "1" } },
+      nodeOptions: { cwd, stdio: "inherit", env: { ...process30.env, CI: "1" } },
       throwOnError: true
     });
   } catch {
@@ -8053,8 +8186,8 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs37 from "node:fs";
-import path42 from "node:path";
+import fs38 from "node:fs";
+import path43 from "node:path";
 import { Command as Command85 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
@@ -8068,30 +8201,30 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
 ]);
 var routes = new Command85("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path42.join(workspaceRootDir, routesDir);
+  const routesRoot = path43.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 = 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) {
-    const id = "/" + path42.relative(root, dir).split(path42.sep).filter(Boolean).join("/");
+    const id = "/" + path43.relative(root, dir).split(path43.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(path42.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path43.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, path42.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path43.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -8100,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;
@@ -8141,13 +8274,13 @@ function printTable(routes2) {
 }
 
 // src/commands/i18n.ts
-import process29 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 = process29.cwd();
+  const cwd = process31.cwd();
   const pm = (await detect9({ cwd }))?.name ?? "npm";
   const resolved = resolveCommand9(pm, "execute", ["wuchale", ...extraArgs]);
   const args = resolved.args.slice();
@@ -8197,37 +8330,37 @@ 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() ?? process30.cwd();
+  const envRoot = findWorkspaceRoot() ?? process32.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];
+  const path44 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path44)) return;
+  const top = path44.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
-    p42.log.error(
-      `${pc20.cyan(`vela ${path43}`)} 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 ${pc20.cyan("vela bless")}.`
+To add a backend to this project, run ${pc22.cyan("vela bless")}.`
     );
-    p42.log.message();
-    p42.cancel("Operation failed.");
-    process30.exit(1);
+    p43.log.message();
+    p43.cancel("Operation failed.");
+    process32.exit(1);
   }
-  if (!process30.env.POCKETBASE_SUPERUSER_EMAIL || !process30.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 ${pc20.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc20.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 ${pc20.cyan("vela create")}.
-To set up an existing project, run ${pc20.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.");
-    process30.exit(1);
+    p43.log.message();
+    p43.cancel("Operation failed.");
+    process32.exit(1);
   }
 });
 function getCommandPath(cmd) {
@@ -8278,14 +8411,14 @@ for (const command of [
 }
 
 // src/bin.ts
-var argv = normalizeArgv(process31.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) {
-  process31.exit(delegatedExitCode);
+  process33.exit(delegatedExitCode);
 }
 program.parse(argv, { from: "user" });
 //# sourceMappingURL=bin.js.map