vela 0.11.4 → 0.11.5

package/dist/bin.js

@@ -21,7 +21,7 @@ import pc38 from "picocolors";
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.11.4",
+  version: "0.11.5",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -57,7 +57,7 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^1.7.0",
     "@faker-js/faker": "^10.6.0",
-    "@velastack/patterns": "^0.2.3",
+    "@velastack/patterns": "^0.2.4",
     "@velastack/pocketbase-codegen": "^0.1.0",
     "annotate-json-schema": "^0.1.0",
     commander: "^13.1.0",
@@ -83,10 +83,10 @@ var package_default = {
     "@types/node": "^22.0.0",
     esbuild: "^0.28.2",
     prettier: "^3.9.6",
+    shellcheck: "^4.1.0",
     typescript: "^5.6.0",
     vite: "^8.2.2",
-    vitest: "^4.1.11",
-    shellcheck: "^4.1.0"
+    vitest: "^4.1.11"
   },
   peerDependencies: {
     "@sveltejs/kit": "^2.57.1",
@@ -100,6 +100,18 @@ var package_default = {
       optional: true
     }
   },
+  overrides: {
+    "global-agent": "^4.1.3",
+    "@xhmikosr/decompress-unzip": {
+      "file-type": "^21.3.1"
+    },
+    "@xhmikosr/decompress-tar": {
+      "file-type": "^21.3.1"
+    },
+    "@felipecrs/decompress-tarxz": {
+      "file-type": "^21.3.1"
+    }
+  },
   keywords: [
     "svelte",
     "sveltekit",
@@ -291,8 +303,20 @@ function mergePackageJson(user, template) {
   }
   return { merged, added, conflicts, replaced };
 }
-function readPackageJson(path46) {
-  return JSON.parse(fs.readFileSync(path46, "utf8"));
+function dropTemplateAdapters(user, template) {
+  const isAdapter = (name) => name.startsWith("@sveltejs/adapter-");
+  const userHasOne = DEP_KINDS.some((kind) => Object.keys(user[kind] ?? {}).some(isAdapter));
+  if (!userHasOne) return template;
+  const copy = { ...template };
+  for (const kind of DEP_KINDS) {
+    const deps = template[kind];
+    if (!deps) continue;
+    copy[kind] = Object.fromEntries(Object.entries(deps).filter(([name]) => !isAdapter(name)));
+  }
+  return copy;
+}
+function readPackageJson(path47) {
+  return JSON.parse(fs.readFileSync(path47, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -305,12 +329,12 @@ function fillTemplatePlaceholders(raw, values) {
 function escapeSingleQuoted(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
-function readTemplatePackageJson(path46, values) {
-  const raw = fillTemplatePlaceholders(fs.readFileSync(path46, "utf8"), values);
+function readTemplatePackageJson(path47, values) {
+  const raw = fillTemplatePlaceholders(fs.readFileSync(path47, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path46, pkg) {
-  fs.writeFileSync(path46, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path47, pkg) {
+  fs.writeFileSync(path47, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -866,7 +890,7 @@ async function packageManagerPrompt(cwd) {
   }
   return pm;
 }
-async function installDependencies(agent, cwd) {
+async function installDependencies(agent, cwd, { exitOnFailure = true } = {}) {
   const task = p2.taskLog({
     title: `Installing dependencies with ${agent}...`,
     limit: Math.ceil(process5.stdout.rows / 2),
@@ -883,14 +907,16 @@ async function installDependencies(agent, cwd) {
     proc.process?.stderr?.on("data", (data) => task.message(data.toString(), { raw: true }));
     await proc;
     task.success("Successfully installed dependencies");
+    return true;
   } catch {
     task.error("Failed to install dependencies");
+    if (!exitOnFailure) return false;
     p2.cancel("Operation failed.");
     process5.exit(2);
   }
 }
-function addPnpmBuildDependencies(cwd, packageManager, allowedPackages) {
-  if (!packageManager || packageManager !== "pnpm") return;
+function addPnpmBuildDependencies(cwd, packageManager2, allowedPackages) {
+  if (!packageManager2 || packageManager2 !== "pnpm") return;
   const pkgPath = path6.join(cwd, "package.json");
   if (!fs7.existsSync(pkgPath)) return;
   const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
@@ -1027,11 +1053,11 @@ function getPocketbaseMetadata(cwd) {
   return null;
 }
 async function execPackageBin(cwd, args, stdio = "pipe") {
-  const packageManager = (await detect2({ cwd }))?.name ?? "npm";
-  const resolved = resolveCommand(packageManager, "execute", args);
-  if (!resolved) throw new Error(`Could not resolve command for ${packageManager}`);
+  const packageManager2 = (await detect2({ cwd }))?.name ?? "npm";
+  const resolved = resolveCommand(packageManager2, "execute", args);
+  if (!resolved) throw new Error(`Could not resolve command for ${packageManager2}`);
   const { command, args: resolvedArgs } = resolved;
-  if (packageManager === "npm") resolvedArgs.unshift("--yes");
+  if (packageManager2 === "npm") resolvedArgs.unshift("--yes");
   return x(command, resolvedArgs, { nodeOptions: { cwd, stdio }, throwOnError: true });
 }
 async function withPocketbase(cwd, fn, creds) {
@@ -1479,7 +1505,14 @@ var GITIGNORE_ENTRIES = [
   "!.env.example",
   "!.env.test",
   "vite.config.js.timestamp-*",
-  "vite.config.ts.timestamp-*"
+  "vite.config.ts.timestamp-*",
+  // The local database, minus the parts that are source. Same block as the
+  // template's _gitignore; without it a blessed project commits its SQLite.
+  "/data/*",
+  "!/data/fixtures",
+  "!/data/seeds",
+  "!/data/hooks",
+  "/backups"
 ];
 function mergeGitignore(filePath) {
   const existing = fs13.existsSync(filePath) ? fs13.readFileSync(filePath, "utf8") : "";
@@ -1647,13 +1680,13 @@ async function blessProject(cwdArg, options) {
   mergeAppDts(templateDir, projectPath);
   maybeReplaceRoutes(projectPath, templateDir, options);
   p4.log.success("Vela files in place");
-  let packageManager;
+  let packageManager2;
   if (options.install !== false) {
     const pm = typeof options.install === "string" ? options.install : await packageManagerPrompt(projectPath);
     if (pm) {
       addPnpmBuildDependencies(projectPath, pm, ["esbuild", "pocketbase-server"]);
       await installDependencies(pm, projectPath);
-      packageManager = pm;
+      packageManager2 = pm;
     }
   }
   p4.log.step("Initializing PocketBase...");
@@ -1667,7 +1700,7 @@ async function blessProject(cwdArg, options) {
     ["PocketBase superuser credentials \u2014 used by `vela` commands"]
   );
   p4.log.success("PocketBase initialized");
-  printNextSteps(projectPath, packageManager);
+  printNextSteps(projectPath, packageManager2);
 }
 function ensureShadcnCss(projectPath) {
   if (ensureShadcnImport(path13.join(projectPath, "src", "app.css"))) {
@@ -1713,7 +1746,10 @@ function mergeDependencies(projectPath, templateDir) {
     appName,
     cliVersion: package_default.version
   });
-  const { merged, added, conflicts, replaced } = mergePackageJson(userPkg, templatePkg);
+  const { merged, added, conflicts, replaced } = mergePackageJson(
+    userPkg,
+    dropTemplateAdapters(userPkg, templatePkg)
+  );
   writePackageJson(userPkgPath, merged);
   if (added.length > 0) {
     p4.log.info(
@@ -1851,9 +1887,9 @@ function summarize(names) {
   if (names.length <= 4) return names.join(", ");
   return `${names.slice(0, 3).join(", ")}, and ${names.length - 3} more`;
 }
-function printNextSteps(projectPath, packageManager) {
+function printNextSteps(projectPath, packageManager2) {
   const relative = path13.relative(process7.cwd(), projectPath);
-  const pm = packageManager ?? getUserAgent() ?? "npm";
+  const pm = packageManager2 ?? getUserAgent() ?? "npm";
   const nextSteps = [];
   if (relative !== "") {
     const hasSpaces = relative.includes(" ");
@@ -1901,19 +1937,19 @@ var create = new Command3("create").description("scaffold a new velastack projec
   return runCommand(async () => {
     const listing = await listAllTemplates();
     const options = parseOptions(optionsSchema2(listing), rawOpts);
-    const { directory, packageManager, name, template } = await createProject(
+    const { directory, packageManager: packageManager2, name, template } = await createProject(
       projectPath,
       options,
       listing
     );
     const relative = path14.relative(process8.cwd(), directory);
-    const pm = packageManager ?? (await detect3({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
+    const pm = packageManager2 ?? (await detect3({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
     const nextSteps = [];
     if (relative !== "") {
       const hasSpaces = relative.includes(" ");
       nextSteps.push(`\`cd ${hasSpaces ? `"${relative}"` : relative}\``);
     }
-    if (!packageManager) {
+    if (!packageManager2) {
       const resolved = resolveCommand3(pm, "install", []);
       if (resolved) {
         nextSteps.push(
@@ -2002,14 +2038,14 @@ async function createProject(cwdArg, options, listing) {
     throw new Error(`Template ${template.name} is missing package.template.json`);
   }
   p5.log.success("Project created");
-  let packageManager;
+  let packageManager2;
   if (options.install !== false) {
     const pm = typeof options.install === "string" ? options.install : await packageManagerPrompt(projectPath);
     if (pm) {
       const builds = template.backend ? ["esbuild", "pocketbase-server"] : ["esbuild"];
       addPnpmBuildDependencies(projectPath, pm, builds);
       await installDependencies(pm, projectPath);
-      packageManager = pm;
+      packageManager2 = pm;
     }
   }
   if (credentials) {
@@ -2035,7 +2071,7 @@ async function createProject(cwdArg, options, listing) {
     );
     p5.log.success("PocketBase initialized");
   }
-  return { directory: projectPath, packageManager, name, template };
+  return { directory: projectPath, packageManager: packageManager2, name, template };
 }
 function promptCredentials(options, onCancel2) {
   return p5.group(
@@ -3523,10 +3559,11 @@ function collectArtifact(cwd, config = {}) {
   const buildPath = path20.join(cwd, outputDir);
   if (!fs21.existsSync(path20.join(buildPath, "index.js"))) {
     throw new BuildError(
-      `No ${outputDir}/index.js after the build.
+      `No ${outputDir}/index.js to deploy.
 
-Deploying to a server needs @sveltejs/adapter-node. Install it and set it as
-the adapter in your Vite or Svelte config, then build again.`
+Deploying to a server needs the output of @sveltejs/adapter-node. Check that the
+build ran with it as the adapter (and that \`outputDir\` in velastack.config
+matches where it writes), then deploy again.`
     );
   }
   entries.push({ localPath: buildPath, remoteDir: "" });
@@ -3585,6 +3622,10 @@ var VELA_USER = "vela";
 var SCRIPT_VERSIONS_DIR = `${VELA_ROOT}/script-versions`;
 var PROVISIONED_MARKER = `${VELA_ETC}/provisioned`;
 var ORIGIN_FILE = `${VELA_ETC}/origin.json`;
+function instanceHasBackend(state) {
+  if (!state) return false;
+  return state.backend ?? Boolean(state.pbPort);
+}
 function serverTemplatesDir() {
   return path21.join(templatesDir(), "server");
 }
@@ -4138,12 +4179,13 @@ Set both ${pc6.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc6.cyan("POCKETBASE_SU
 import PocketBase2 from "pocketbase";
 async function openRemoteDatabase(session, instance) {
   const [state] = await readInstanceStates(session, instance);
-  const pbPort = state?.pbPort;
+  const pbPort = instanceHasBackend(state) ? state?.pbPort : void 0;
   if (!pbPort) {
     throw new Error(
       `${instance} has no deployed database yet.
 
-Run \`vela deploy\` first \u2014 the database is created by the first deploy.`
+Run \`vela deploy\` first \u2014 the database is created by the first deploy of a
+project with a backend (\`vela bless\` adds one).`
     );
   }
   const env2 = await readRemoteEnv(session, instance);
@@ -8306,8 +8348,8 @@ var provision = addSshOptions(
 );
 
 // src/commands/deploy.ts
-import path37 from "node:path";
-import fs36 from "node:fs";
+import path38 from "node:path";
+import fs37 from "node:fs";
 import { Command as Command76, Option as Option2 } from "commander";
 import * as p42 from "@clack/prompts";
 import pc18 from "picocolors";
@@ -8371,6 +8413,272 @@ async function seedRemoteMeta(session, instance, local, appURL) {
   return Object.keys(patch);
 }
 
+// src/lib/adapter.ts
+import fs36 from "node:fs";
+import path37 from "node:path";
+import {
+  Project as Project2,
+  QuoteKind as QuoteKind2,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+import { detect as detect7 } from "package-manager-detector";
+var ADAPTER_NODE = "@sveltejs/adapter-node";
+var ADAPTER_AUTO = "@sveltejs/adapter-auto";
+var ADAPTER_STATIC = "@sveltejs/adapter-static";
+var ADAPTER_NODE_RANGE = "^5.5.7";
+var ADAPTER_SNIPPET = `import adapter from '${ADAPTER_NODE}';
+
+// ...
+adapter: adapter()`;
+var AdapterError = class extends Error {
+  constructor(message, snippet = ADAPTER_SNIPPET) {
+    super(message);
+    this.snippet = snippet;
+    this.name = "AdapterError";
+  }
+  snippet;
+};
+function newProject() {
+  return new Project2({
+    compilerOptions: { allowJs: true },
+    manipulationSettings: { quoteKind: QuoteKind2.Single }
+  });
+}
+function getDefaultExportObject(sourceFile) {
+  const exported = sourceFile.getExportAssignment((ea) => !ea.isExportEquals())?.getExpression();
+  if (exported?.getKind() === SyntaxKind2.ObjectLiteralExpression) {
+    return exported;
+  }
+  if (exported?.getKind() === SyntaxKind2.Identifier) {
+    const init = sourceFile.getVariableDeclaration(exported.getText())?.getInitializer();
+    if (init?.getKind() === SyntaxKind2.ObjectLiteralExpression) {
+      return init;
+    }
+  }
+  return null;
+}
+function resolveKitTarget(root) {
+  const vite = inspectViteSveltekit(root);
+  if (vite?.inlineArg) {
+    return {
+      sourceFile: vite.sourceFile,
+      filePath: vite.filePath,
+      container: "vite-inline",
+      kit: vite.inlineArg,
+      created: false,
+      originalText: vite.sourceFile.getFullText()
+    };
+  }
+  const sveltePath = probeFirstExisting(root, SVELTE_CONFIG_CANDIDATES);
+  if (sveltePath) {
+    const name = path37.basename(sveltePath);
+    if (sveltePath.endsWith(".cjs")) {
+      throw new AdapterError(`${name} is CommonJS, which vela does not edit.`);
+    }
+    const sourceFile = newProject().addSourceFileAtPath(sveltePath);
+    const config = getDefaultExportObject(sourceFile);
+    const kit = config && getOrCreateObjectLiteralProperty(config, "kit", "{}");
+    if (!kit) {
+      throw new AdapterError(`${name} has a shape vela does not understand.`);
+    }
+    return {
+      sourceFile,
+      filePath: sveltePath,
+      container: "svelte-config",
+      kit,
+      created: false,
+      originalText: sourceFile.getFullText()
+    };
+  }
+  if (vite?.sveltekitCall) {
+    const name = path37.basename(vite.filePath);
+    if (vite.nonObjectArg) {
+      throw new AdapterError(`${name} passes sveltekit() something other than an object literal.`);
+    }
+    const originalText = vite.sourceFile.getFullText();
+    const kit = createSveltekitArg(vite);
+    if (!kit)
+      throw new AdapterError(`${name} has a sveltekit() call vela cannot add an argument to.`);
+    return {
+      sourceFile: vite.sourceFile,
+      filePath: vite.filePath,
+      container: "vite-inline",
+      kit,
+      created: true,
+      originalText
+    };
+  }
+  throw new AdapterError(
+    `No svelte.config or vite.config with a sveltekit() plugin found in ${root}.`
+  );
+}
+function classify(specifier) {
+  if (specifier === ADAPTER_NODE) return "node";
+  if (specifier === ADAPTER_AUTO) return "auto";
+  if (specifier === ADAPTER_STATIC) return "static";
+  return "other";
+}
+function importOf(sourceFile, identifier) {
+  return sourceFile.getImportDeclarations().find((decl) => decl.getDefaultImport()?.getText() === identifier);
+}
+function inspectAdapter(target) {
+  const base2 = { file: target.filePath, container: target.container };
+  const prop = target.kit.getProperty("adapter");
+  if (!prop) return { info: { ...base2, kind: "none" } };
+  if (prop.getKind() !== SyntaxKind2.PropertyAssignment) {
+    return { info: { ...base2, kind: "other" } };
+  }
+  const init = prop.asKindOrThrow(SyntaxKind2.PropertyAssignment).getInitializer();
+  if (!init || init.getKind() !== SyntaxKind2.CallExpression) {
+    return { info: { ...base2, kind: "other" } };
+  }
+  const callee = init.asKindOrThrow(SyntaxKind2.CallExpression).getExpression();
+  if (callee.getKind() !== SyntaxKind2.Identifier) {
+    return { info: { ...base2, kind: "other" } };
+  }
+  const importDecl = importOf(target.sourceFile, callee.getText());
+  if (!importDecl) return { info: { ...base2, kind: "other" } };
+  const specifier = importDecl.getModuleSpecifierValue();
+  return { info: { ...base2, kind: classify(specifier), specifier }, importDecl };
+}
+async function ensureNodeAdapter(root, { install = true } = {}) {
+  const target = resolveKitTarget(root);
+  const { info, importDecl } = inspectAdapter(target);
+  const name = path37.basename(target.filePath);
+  const outcome = {
+    previous: info.kind,
+    removedDeps: [],
+    packageJsonChanged: false
+  };
+  switch (info.kind) {
+    case "node":
+      break;
+    case "static":
+      throw new AdapterError(
+        `This project builds a static site with ${ADAPTER_STATIC} (${name}).
+
+vela deploy runs the app as a Node server, which needs ${ADAPTER_NODE}. Switch
+the adapter to deploy it here, or host the static output elsewhere.`
+      );
+    case "other":
+      throw new AdapterError(
+        `This project's adapter${info.specifier ? ` (${info.specifier})` : ""} in ${name} is not one
+vela will change for you.
+
+vela deploy runs the app as a Node server, which needs ${ADAPTER_NODE}:`
+      );
+    case "auto":
+      switchImport(target, importDecl);
+      outcome.configFile = name;
+      break;
+    case "none":
+      addAdapter(target);
+      outcome.configFile = name;
+      break;
+  }
+  if (outcome.configFile) saveTarget(target);
+  const pkgPath = path37.join(root, "package.json");
+  if (fs36.existsSync(pkgPath)) {
+    const pkg = readPackageJson(pkgPath);
+    const { changed, removed } = adoptNodeAdapter(pkg);
+    if (changed) {
+      writePackageJson(pkgPath, pkg);
+      outcome.packageJsonChanged = true;
+      outcome.removedDeps = removed;
+    }
+  }
+  if (outcome.packageJsonChanged && install) {
+    outcome.installedWith = await installAdapterDependencies(root);
+  }
+  return outcome;
+}
+async function installAdapterDependencies(root) {
+  const agent = await packageManager(root);
+  const ok = await installDependencies(agent, root, { exitOnFailure: false });
+  if (!ok) {
+    throw new AdapterError(
+      `Installing ${ADAPTER_NODE} with ${agent} failed.
+
+The config and package.json are already updated: run \`${agent} install\`, then deploy again.`,
+      ""
+    );
+  }
+  return agent;
+}
+function switchImport(target, importDecl) {
+  importDecl.setModuleSpecifier(ADAPTER_NODE);
+  const prop = target.kit.getPropertyOrThrow("adapter").asKindOrThrow(SyntaxKind2.PropertyAssignment);
+  const call = prop.getInitializerIfKindOrThrow(SyntaxKind2.CallExpression);
+  for (let i = call.getArguments().length - 1; i >= 0; i--) call.removeArgument(i);
+  dropAdapterAutoComments(target);
+}
+var ADAPTER_AUTO_COMMENT = /adapter-auto|svelte\.dev\/docs\/kit\/adapters|switch out the adapter/;
+function dropAdapterAutoComments(target) {
+  const prop = target.kit.getPropertyOrThrow("adapter");
+  const ranges = prop.getLeadingCommentRanges();
+  if (ranges.length === 0 || !ranges.every((r) => ADAPTER_AUTO_COMMENT.test(r.getText()))) return;
+  const fullStart = prop.getFullStart();
+  const start = prop.getStart();
+  const trivia = target.sourceFile.getFullText().slice(fullStart, start);
+  const lastNewline = trivia.lastIndexOf("\n");
+  if (lastNewline === -1) return;
+  const indent = trivia.slice(lastNewline + 1);
+  target.sourceFile.replaceText([fullStart, start], `
+${indent}`);
+}
+function addAdapter(target) {
+  const taken = importOf(target.sourceFile, "adapter") ?? target.sourceFile.getVariableDeclaration("adapter");
+  if (taken) {
+    throw new AdapterError(
+      `${path37.basename(target.filePath)} already binds the name \`adapter\` to something that is not the SvelteKit adapter.`
+    );
+  }
+  target.sourceFile.addImportDeclaration({
+    defaultImport: "adapter",
+    moduleSpecifier: ADAPTER_NODE
+  });
+  target.kit.addPropertyAssignment({ name: "adapter", initializer: "adapter()" });
+}
+function saveTarget(target) {
+  if (target.created) target.sourceFile.formatText();
+  if (target.sourceFile.getFullText() === target.originalText) return;
+  target.sourceFile.saveSync();
+}
+function adoptNodeAdapter(pkg) {
+  const removed = [];
+  let changed = false;
+  for (const kind of ["dependencies", "devDependencies"]) {
+    const deps = pkg[kind];
+    if (deps && ADAPTER_AUTO in deps) {
+      delete deps[ADAPTER_AUTO];
+      removed.push(ADAPTER_AUTO);
+      changed = true;
+    }
+  }
+  if (!pkg.dependencies?.[ADAPTER_NODE] && !pkg.devDependencies?.[ADAPTER_NODE]) {
+    pkg.devDependencies = sortKeys({ ...pkg.devDependencies, [ADAPTER_NODE]: ADAPTER_NODE_RANGE });
+    changed = true;
+  }
+  return { changed, removed: [...new Set(removed)] };
+}
+function lockfileFor(agent) {
+  switch (agent) {
+    case "pnpm":
+      return "pnpm-lock.yaml";
+    case "yarn":
+      return "yarn.lock";
+    case "bun":
+      return "bun.lock";
+    case "deno":
+      return "deno.lock";
+    default:
+      return "package-lock.json";
+  }
+}
+async function packageManager(root) {
+  return (await detect7({ cwd: root }))?.name ?? getUserAgent() ?? "npm";
+}
+
 // src/commands/deploy.ts
 var OptionsSchema3 = v8.object({
   ...SSH_OPTION_SCHEMA,
@@ -8403,6 +8711,10 @@ var deploy = addLockWaitOption(
     const options = parseOptions(OptionsSchema3, raw);
     const backend3 = hasBackend();
     p42.intro(pc18.bgCyan(pc18.black(" vela deploy ")));
+    if (options.build !== false) {
+      const { workspaceRootDir } = await getWorkspace();
+      await prepareAdapter(workspaceRootDir);
+    }
     await withTarget(
       raw,
       {
@@ -8416,7 +8728,12 @@ var deploy = addLockWaitOption(
           const isPreview2 = ctx.target.kind === "preview";
           const configured = options.domain ?? (isPreview2 ? existing?.domain : ctx.binding.domain ?? config.deploy?.domain ?? existing?.domain) ?? "";
           const askedForRemoteDb = options.remoteDb ?? config.deploy?.buildAgainstRemote;
-          const remoteDb = askedForRemoteDb ?? Boolean(existing?.pbPort);
+          const remoteDb = askedForRemoteDb ?? instanceHasBackend(existing);
+          if (existing && instanceHasBackend(existing) !== backend3) {
+            p42.log.info(
+              backend3 ? `${pc18.cyan(ctx.targetName)} was deployed without a backend before. This deploy adds PocketBase.` : `${pc18.cyan(ctx.targetName)} was deployed with a backend before. This deploy removes PocketBase; its database stays on the server.`
+            );
+          }
           const sha = await gitSha(workspaceRootDir);
           const reporter = createDeployReporter(workspaceRootDir);
           const server = await reporter.identifyServer(session);
@@ -8572,6 +8889,38 @@ or ${pc18.cyan("vela link")} it to get a free velastack.app hostname.`) + `.`
     p42.outro(`${pc18.cyan("vela status")} to see what is running`);
   }, "Failed to deploy.")
 );
+async function prepareAdapter(workspaceRootDir) {
+  const rethrow = (err) => {
+    if (err instanceof AdapterError) {
+      throw new Error(err.snippet ? `${err.message}
+
+${pc18.cyan(err.snippet)}` : err.message);
+    }
+    throw err;
+  };
+  const outcome = await ensureNodeAdapter(workspaceRootDir, { install: false }).catch(rethrow);
+  if (!outcome.configFile && !outcome.packageJsonChanged) return;
+  const changed = [
+    outcome.configFile,
+    outcome.packageJsonChanged ? "package.json" : void 0
+  ].filter((f) => Boolean(f));
+  const why = outcome.previous === "auto" ? `${ADAPTER_AUTO} builds nothing for a server of your own` : outcome.previous === "none" ? "No adapter was configured" : `${ADAPTER_NODE} was configured but not in package.json`;
+  p42.log.step(`Switching the adapter to ${pc18.cyan(ADAPTER_NODE)}`);
+  p42.log.info(
+    `${why}, and vela deploy runs the app as a Node server.
+
+  Changed  ${changed.join(", ")}` + (outcome.removedDeps.length ? `
+  Removed  ${outcome.removedDeps.join(", ")}` : "")
+  );
+  if (outcome.packageJsonChanged) {
+    try {
+      changed.push(lockfileFor(await installAdapterDependencies(workspaceRootDir)));
+    } catch (err) {
+      rethrow(err);
+    }
+  }
+  p42.log.warn(`Commit ${changed.join(", ")} so every deploy builds the same way.`);
+}
 async function reportAppURLDrift(session, instance, domain) {
   const expected = normalizeOrigin(domain);
   if (!expected) return;
@@ -8607,10 +8956,10 @@ Set them in the admin panel instead. ${pc18.dim(String(err))}`
   }
 }
 async function openDatabaseTunnel(session, instance, state) {
-  const pbPort = state?.pbPort;
+  const pbPort = instanceHasBackend(state) ? state?.pbPort : void 0;
   if (!pbPort) {
     throw new Error(
-      `--remote-db needs an existing deployment to build against, and ${instance} has not been deployed yet.
+      `--remote-db needs a deployed database to build against, and ${instance} ${state ? "has no backend" : "has not been deployed yet"}.
 
 Deploy once without it, then turn it on.`
     );
@@ -8684,7 +9033,7 @@ async function uploadRelease(session, instance, release, entries) {
 }
 function isDirectory(target) {
   try {
-    return fs36.statSync(target).isDirectory();
+    return fs37.statSync(target).isDirectory();
   } catch {
     return false;
   }
@@ -8692,7 +9041,7 @@ function isDirectory(target) {
 async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
-  if (!fs36.existsSync(path37.join(workspaceRootDir, ".env"))) return;
+  if (!fs37.existsSync(path38.join(workspaceRootDir, ".env"))) return;
   p42.log.warn(
     `This app has no production environment variables yet.
 
@@ -8710,7 +9059,7 @@ async function serverTimeOrLocal(session) {
 }
 
 // src/commands/link.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import process29 from "node:process";
 import { Command as Command77 } from "commander";
 import * as p43 from "@clack/prompts";
@@ -8798,12 +9147,12 @@ async function promptProjectName(workspaceRootDir) {
 }
 function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path38.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path39.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path38.basename(workspaceRootDir);
+  return path39.basename(workspaceRootDir);
 }
 
 // src/commands/env.ts
@@ -8934,8 +9283,8 @@ var envUnset = addTargetOptions(
 );
 
 // src/commands/env/import.ts
-import fs37 from "node:fs";
-import path39 from "node:path";
+import fs38 from "node:fs";
+import path40 from "node:path";
 import process31 from "node:process";
 import { Command as Command81 } from "commander";
 import * as p47 from "@clack/prompts";
@@ -8981,10 +9330,10 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path39.resolve(process31.cwd(), file);
+  return path40.resolve(process31.cwd(), file);
 }
 function read(resolved, shown) {
-  if (!fs37.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
+  if (!fs38.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
   const incoming = readLocalEnvFile(resolved);
   if (Object.keys(incoming).length === 0) p47.log.info(`${shown} has no variables to import.`);
   return incoming;
@@ -9262,8 +9611,8 @@ var admin = new Command87("admin").description("manage admin panel logins").conf
 import { Command as Command93 } from "commander";
 
 // src/commands/backup/create.ts
-import fs38 from "node:fs";
-import path40 from "node:path";
+import fs39 from "node:fs";
+import path41 from "node:path";
 import { Command as Command88 } from "commander";
 import * as p51 from "@clack/prompts";
 import pc26 from "picocolors";
@@ -9417,12 +9766,12 @@ Your bucket's own versioning is what protects the uploaded files.`
   }, "Failed to create the backup.")
 );
 async function download(ctx, key, outputDir) {
-  const dir = path40.resolve(ctx.workspaceRootDir, outputDir);
-  fs38.mkdirSync(dir, { recursive: true });
-  const destination = path40.join(dir, key);
+  const dir = path41.resolve(ctx.workspaceRootDir, outputDir);
+  fs39.mkdirSync(dir, { recursive: true });
+  const destination = path41.join(dir, key);
   if (!ctx.session) {
-    fs38.copyFileSync(path40.join(ctx.workspaceRootDir, "data", "backups", key), destination);
-    return path40.relative(ctx.workspaceRootDir, destination);
+    fs39.copyFileSync(path41.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+    return path41.relative(ctx.workspaceRootDir, destination);
   }
   const spinner7 = p51.spinner();
   spinner7.start(`Downloading ${key}`);
@@ -9433,7 +9782,7 @@ async function download(ctx, key, outputDir) {
     throw error;
   }
   spinner7.stop(`Downloaded ${key}`);
-  return path40.relative(ctx.workspaceRootDir, destination);
+  return path41.relative(ctx.workspaceRootDir, destination);
 }
 
 // src/commands/backup/list.ts
@@ -9467,8 +9816,8 @@ Take one with ${pc27.cyan("vela backup create")}.`
 );
 
 // src/commands/backup/download.ts
-import fs39 from "node:fs";
-import path41 from "node:path";
+import fs40 from "node:fs";
+import path42 from "node:path";
 import { Command as Command90 } from "commander";
 import * as p53 from "@clack/prompts";
 import pc28 from "picocolors";
@@ -9495,11 +9844,11 @@ Run ${pc28.cyan("vela backup list")} to see what it does have.`
 Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
         );
       }
-      const dir = path41.resolve(ctx.workspaceRootDir, options.output);
-      fs39.mkdirSync(dir, { recursive: true });
-      const destination = path41.join(dir, key);
+      const dir = path42.resolve(ctx.workspaceRootDir, options.output);
+      fs40.mkdirSync(dir, { recursive: true });
+      const destination = path42.join(dir, key);
       if (!ctx.session) {
-        fs39.copyFileSync(path41.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+        fs40.copyFileSync(path42.join(ctx.workspaceRootDir, "data", "backups", key), destination);
       } else {
         const spinner7 = p53.spinner();
         spinner7.start(`Downloading ${key} (${formatBytes(found.size)})`);
@@ -9513,7 +9862,7 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
       }
       reportResult({
         summary: `Saved ${key} from ${ctx.targetName}.`,
-        filesCreated: [path41.relative(ctx.workspaceRootDir, destination)]
+        filesCreated: [path42.relative(ctx.workspaceRootDir, destination)]
       });
     });
   }, "Failed to download the backup.")
@@ -9608,8 +9957,8 @@ Set one with ${pc30.cyan('vela backup schedule "0 3 * * *"')}.`
 var backup = new Command93("backup").description("back up the database and uploads, locally or on a target").configureHelp(helpConfig).addCommand(backupCreate).addCommand(backupList).addCommand(backupDownload).addCommand(backupDelete).addCommand(backupSchedule);
 
 // src/commands/restore.ts
-import fs40 from "node:fs";
-import path42 from "node:path";
+import fs41 from "node:fs";
+import path43 from "node:path";
 import process34 from "node:process";
 import { Command as Command94 } from "commander";
 import * as p56 from "@clack/prompts";
@@ -9632,7 +9981,7 @@ var restore = addLockWaitOption(
               `${ctx.targetName} was deployed without a database, so there is nothing to restore.`
             );
           }
-          const local = source && fs40.existsSync(source) ? source : void 0;
+          const local = source && fs41.existsSync(source) ? source : void 0;
           const key = local ? void 0 : await resolveKey(ctx, source);
           if (!options.yes) {
             await confirm13(ctx.appName, ctx.targetName, ctx.envTag, local ?? key);
@@ -9655,7 +10004,7 @@ var restore = addLockWaitOption(
           });
           p56.log.success(
             `Restored ${pc31.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${pc31.cyan(
-              local ? path42.basename(local) : key
+              local ? path43.basename(local) : key
             )}.`
           );
           if (result?.storageCarriedOver) {
@@ -9721,21 +10070,21 @@ Take one with ${pc31.cyan("vela backup create")}, or pass the path to an archive
 }
 async function stage(ctx, file) {
   const dir = remotePaths.restoreStage(ctx.instance);
-  const remote = `${dir}/${path42.basename(file)}`;
+  const remote = `${dir}/${path43.basename(file)}`;
   const spinner7 = p56.spinner();
-  spinner7.start(`Uploading ${path42.basename(file)}`);
+  spinner7.start(`Uploading ${path43.basename(file)}`);
   try {
     await ctx.session.script(`mkdir -p "$1"`, { args: [dir] });
     await ctx.session.upload([file], dir);
   } catch (error) {
-    spinner7.stop(`Could not upload ${path42.basename(file)}.`);
+    spinner7.stop(`Could not upload ${path43.basename(file)}.`);
     throw error;
   }
-  spinner7.stop(`Uploaded ${path42.basename(file)}`);
+  spinner7.stop(`Uploaded ${path43.basename(file)}`);
   return remote;
 }
 async function confirm13(appName, targetName, envTag, from) {
-  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path42.basename(from))}`;
+  const what = `${pc31.cyan(`${appName} (${targetName})`)} from ${pc31.cyan(path43.basename(from))}`;
   if (isProd(envTag)) {
     const answer = await p56.text({
       message: `This replaces the database and uploads of ${what}. Type the app name to confirm`,
@@ -9846,28 +10195,28 @@ Release and domain are shown from what this project recorded.`
 }
 
 // src/commands/test.ts
-import path43 from "node:path";
+import path44 from "node:path";
 import process35 from "node:process";
 import { Command as Command96 } from "commander";
 import PocketBase6 from "pocketbase";
 import pc33 from "picocolors";
 import { x as x5 } from "tinyexec";
-import { detect as detect7 } from "package-manager-detector";
+import { detect as detect8 } from "package-manager-detector";
 import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
-import fs41 from "node:fs";
+import fs42 from "node:fs";
 var testServer = new Command96("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
   const cwd = process35.cwd();
   const email3 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password11 = "password";
-  const testDataDir = path43.join(cwd, "test-data");
-  fs41.rmSync(testDataDir, { recursive: true, force: true });
+  const testDataDir = path44.join(cwd, "test-data");
+  fs42.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path43.join(cwd, MIGRATIONS_DIR),
+    migrationsDir: path44.join(cwd, MIGRATIONS_DIR),
     // The app's PocketBase hooks (slug generation, personal teams, …) are part
     // of its behaviour; the suite runs against the same server dev and build
     // start, so it loads them from the same place.
-    hooksDir: path43.join(cwd, DATA_DIR, "hooks"),
+    hooksDir: path44.join(cwd, DATA_DIR, "hooks"),
     email: email3,
     password: password11
   });
@@ -9883,7 +10232,7 @@ var testServer = new Command96("test:server").description("run server tests").al
     if (cleanedUp) return;
     cleanedUp = true;
     stop();
-    fs41.rmSync(testDataDir, { recursive: true, force: true });
+    fs42.rmSync(testDataDir, { recursive: true, force: true });
   };
   const cleanup = async () => {
     if (cleanedUp) return;
@@ -9935,7 +10284,7 @@ var testServer = new Command96("test:server").description("run server tests").al
   const passthrough = filter ? extraArgs.filter((a) => a !== filter) : extraArgs;
   if (!filter) filter = "server";
   try {
-    const pm = (await detect7({ cwd }))?.name ?? "npm";
+    const pm = (await detect8({ cwd }))?.name ?? "npm";
     const resolved = resolveCommand7(pm, "execute", [
       "vitest",
       "run",
@@ -9982,8 +10331,8 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs42 from "node:fs";
-import path44 from "node:path";
+import fs43 from "node:fs";
+import path45 from "node:path";
 import { Command as Command97 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
@@ -9997,30 +10346,30 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
 ]);
 var routes = new Command97("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path44.join(workspaceRootDir, routesDir);
+  const routesRoot = path45.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 = fs42.readdirSync(dir, { withFileTypes: true });
+  const entries = fs43.readdirSync(dir, { withFileTypes: true });
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
-    const id = "/" + path44.relative(root, dir).split(path44.sep).filter(Boolean).join("/");
+    const id = "/" + path45.relative(root, dir).split(path45.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(path44.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path45.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, path44.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path45.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -10029,7 +10378,7 @@ function isRouteFile(name) {
 }
 function extractMethods(file) {
   try {
-    const content = fs42.readFileSync(file, "utf8");
+    const content = fs43.readFileSync(file, "utf8");
     const methods = [];
     const exportRegex = /export\s+(?:const|async\s+function|function)\s+(\w+)/g;
     let match;
@@ -10073,11 +10422,11 @@ function printTable(routes2) {
 import process36 from "node:process";
 import { Command as Command98 } from "commander";
 import { x as x6 } from "tinyexec";
-import { detect as detect8 } from "package-manager-detector";
+import { detect as detect9 } from "package-manager-detector";
 import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
 async function runWuchale(extraArgs) {
   const cwd = process36.cwd();
-  const pm = (await detect8({ cwd }))?.name ?? "npm";
+  const pm = (await detect9({ cwd }))?.name ?? "npm";
   const resolved = resolveCommand8(pm, "execute", ["wuchale", ...extraArgs]);
   const args = resolved.args.slice();
   if (pm === "npm") args.unshift("--yes");
@@ -10112,7 +10461,7 @@ import pc35 from "picocolors";
 
 // src/lib/cms-backend.ts
 import { createRequire as createRequire3 } from "node:module";
-import path45 from "node:path";
+import path46 from "node:path";
 import process37 from "node:process";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import pc34 from "picocolors";
@@ -10120,7 +10469,7 @@ var DEFAULT_PROJECT = "default";
 async function loadBackendModule(root) {
   let entry;
   try {
-    entry = createRequire3(path45.join(root, "package.json")).resolve("@velastack/cms/backend");
+    entry = createRequire3(path46.join(root, "package.json")).resolve("@velastack/cms/backend");
   } catch {
     throw new Error(
       `@velastack/cms is not installed in this project.
@@ -10138,8 +10487,8 @@ async function withCmsBackend(fn, cwd = process37.cwd()) {
   const { createCmsBackend } = await loadBackendModule(root);
   const dataDir2 = localDataDir(root);
   const backend3 = createCmsBackend({
-    dbPath: path45.join(dataDir2, "cms.sqlite"),
-    uploadDir: path45.join(dataDir2, "uploads")
+    dbPath: path46.join(dataDir2, "cms.sqlite"),
+    uploadDir: path46.join(dataDir2, "uploads")
   });
   try {
     return await fn(backend3);
@@ -10242,7 +10591,10 @@ var NO_BACKEND_COMMMANDS = /* @__PURE__ */ new Set([
   // Acts on whichever target `-t` names; the local path reads the project's
   // own credentials rather than requiring them in this process.
   "backup",
-  "restore"
+  "restore",
+  // Removes a copy from its server; the other `destroy` subcommands edit the
+  // local schema and stay gated.
+  "destroy deployment"
 ]);
 var BACKEND_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["dev", "build", "preview", "deploy"]);
 var SELF_CREDENTIALED_COMMANDS = /* @__PURE__ */ new Set(["test:server"]);
@@ -10251,14 +10603,14 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
   if (isStub(actionCommand)) return;
   const envRoot = findWorkspaceRoot() ?? process38.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
-  const path46 = getCommandPath(actionCommand);
-  if (NO_BACKEND_COMMMANDS.has(path46)) return;
-  const top = path46.split(" ", 1)[0];
+  const path47 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path47)) return;
+  const top = path47.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
     p61.log.error(
-      `${pc38.cyan(`vela ${path46}`)} needs a backend, and this project does not have one.
+      `${pc38.cyan(`vela ${path47}`)} needs a backend, and this project does not have one.
 
 Static projects have no database to talk to.
 
@@ -10268,7 +10620,7 @@ To add a backend to this project, run ${pc38.cyan("vela bless")}.`
     p61.cancel("Operation failed.");
     process38.exit(1);
   }
-  if (SELF_CREDENTIALED_COMMANDS.has(path46)) return;
+  if (SELF_CREDENTIALED_COMMANDS.has(path47)) return;
   if (!process38.env.POCKETBASE_SUPERUSER_EMAIL || !process38.env.POCKETBASE_SUPERUSER_PASSWORD) {
     p61.log.error(
       `PocketBase superuser credentials are required.