vela 0.15.0-next.0 → 0.15.0-next.1

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import process50 from "node:process";
+import process51 from "node:process";
 
 // src/lib/argv.ts
 function normalizeArgv(argv) {
@@ -11,7 +11,7 @@ function normalizeArgv(argv) {
 }
 
 // src/program.ts
-import process49 from "node:process";
+import process50 from "node:process";
 import * as p72 from "@clack/prompts";
 import { Command as Command117 } from "commander";
 import nodePath from "node:path";
@@ -21,7 +21,7 @@ import pc45 from "picocolors";
 // package.json
 var package_default = {
   name: "vela",
-  version: "0.15.0-next.0",
+  version: "0.15.0-next.1",
   type: "module",
   description: "A CLI for creating and updating SvelteKit projects",
   license: "MIT",
@@ -298,8 +298,8 @@ function dropTemplateAdapters(user, template) {
   }
   return copy;
 }
-function readPackageJson(path58) {
-  return JSON.parse(fs2.readFileSync(path58, "utf8"));
+function readPackageJson(path61) {
+  return JSON.parse(fs2.readFileSync(path61, "utf8"));
 }
 var PACKAGE_NAME_PLACEHOLDER = /~TODO~/g;
 var APP_NAME_PLACEHOLDER = /~APP_NAME~/g;
@@ -328,12 +328,12 @@ function jsString(value) {
   const quote2 = count("'") > count('"') ? '"' : "'";
   return `${quote2}${escapeFor(quote2, value)}${quote2}`;
 }
-function readTemplatePackageJson(path58, values) {
-  const raw = fillTemplatePlaceholders(fs2.readFileSync(path58, "utf8"), values);
+function readTemplatePackageJson(path61, values) {
+  const raw = fillTemplatePlaceholders(fs2.readFileSync(path61, "utf8"), values);
   return JSON.parse(raw);
 }
-function writePackageJson(path58, pkg) {
-  fs2.writeFileSync(path58, JSON.stringify(pkg, null, "	") + "\n");
+function writePackageJson(path61, pkg) {
+  fs2.writeFileSync(path61, JSON.stringify(pkg, null, "	") + "\n");
 }
 function toValidPackageName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9~.-]+/g, "-");
@@ -419,6 +419,63 @@ function parseVersionPart(text19) {
     wildcard: firstWild === 1 ? "major" : firstWild === 2 ? "minor" : void 0
   };
 }
+function rangeAdmits(range, version) {
+  const target = parseVersionPart(version)?.version;
+  if (!target) return null;
+  let unreadable = false;
+  for (const alt of range.split("||").map((a) => a.trim())) {
+    const comparators = comparatorsOf(alt);
+    if (!comparators) {
+      unreadable = true;
+      continue;
+    }
+    if (comparators.every(([op, v12]) => compare(target, op, v12))) return true;
+  }
+  return unreadable ? null : false;
+}
+function compare(target, op, v12) {
+  const c = compareVersions(target, v12);
+  return op === ">=" ? c >= 0 : op === ">" ? c > 0 : op === "<" ? c < 0 : op === "<=" ? c <= 0 : c === 0;
+}
+function comparatorsOf(set) {
+  if (set === "" || set === "*" || /^[xX]$/.test(set)) return [];
+  const hyphen = set.match(/^(\S+)\s+-\s+(\S+)$/);
+  if (hyphen) {
+    const low = parseVersionPart(hyphen[1]);
+    const high = parseVersionPart(hyphen[2]);
+    if (!low || !high) return null;
+    return [
+      [">=", low.version],
+      high.wildcard ? ["<", bump(high.version, high.wildcard)] : ["<=", high.version]
+    ];
+  }
+  const out = [];
+  for (const part of set.replace(/([<>=~^]+)\s+/g, "$1").split(/\s+/)) {
+    const match = part.match(/^(<=|>=|<|>|=|\^|~>?)?(.*)$/);
+    const op = match[1] ?? "";
+    if (/^[*xX]$/.test(match[2])) continue;
+    const parsed = parseVersionPart(match[2]);
+    if (!parsed) return null;
+    const { version: v12, wildcard } = parsed;
+    const written = wildcard === "major" ? 1 : wildcard === "minor" ? 2 : 3;
+    if (op === "^") {
+      const upper = v12.major > 0 || written === 1 ? bump(v12, "major") : v12.minor > 0 || written === 2 ? bump(v12, "minor") : bump(v12, "patch");
+      out.push([">=", v12], ["<", upper]);
+    } else if (op === "~" || op === "~>") {
+      out.push([">=", v12], ["<", bump(v12, written === 1 ? "major" : "minor")]);
+    } else if (op === "" || op === "=") {
+      if (wildcard) out.push([">=", v12], ["<", bump(v12, wildcard)]);
+      else out.push(["=", v12]);
+    } else if (op === ">") {
+      out.push(wildcard ? [">=", bump(v12, wildcard)] : [">", v12]);
+    } else if (op === "<=") {
+      out.push(wildcard ? ["<", bump(v12, wildcard)] : ["<=", v12]);
+    } else {
+      out.push([op, v12]);
+    }
+  }
+  return out;
+}
 function bump(version, part) {
   if (part === "major") return { major: version.major + 1, minor: 0, patch: 0, prerelease: [] };
   if (part === "minor") return { ...version, minor: version.minor + 1, patch: 0, prerelease: [] };
@@ -1063,17 +1120,17 @@ async function packageManagerPrompt(cwd) {
 }
 var installedCache = /* @__PURE__ */ new Map();
 function isInstalled(agent) {
-  let installed = installedCache.get(agent);
-  if (installed === void 0) {
+  let installed2 = installedCache.get(agent);
+  if (installed2 === void 0) {
     try {
       execSync(agent, ["--version"], { nodeOptions: { stdio: "ignore" } });
-      installed = true;
+      installed2 = true;
     } catch {
-      installed = false;
+      installed2 = false;
     }
-    installedCache.set(agent, installed);
+    installedCache.set(agent, installed2);
   }
-  return installed;
+  return installed2;
 }
 async function installDependencies(agent, cwd, { exitOnFailure = true } = {}) {
   if (!isInstalled(agent)) {
@@ -1546,20 +1603,20 @@ var SITE_FILE = path10.join("src", "lib", "site.ts");
 async function readSite(root) {
   const file = path10.join(root, SITE_FILE);
   if (!fs12.existsSync(file)) return null;
-  const { Project: Project2, Node: Node2 } = await import("ts-morph");
-  const project = new Project2({ useInMemoryFileSystem: true });
+  const { Project: Project4, Node: Node3 } = await import("ts-morph");
+  const project = new Project4({ useInMemoryFileSystem: true });
   const source = project.createSourceFile("site.ts", fs12.readFileSync(file, "utf8"));
   let object6 = source.getVariableDeclaration("site")?.getInitializer();
-  while (object6 && (Node2.isAsExpression(object6) || Node2.isSatisfiesExpression(object6))) {
+  while (object6 && (Node3.isAsExpression(object6) || Node3.isSatisfiesExpression(object6))) {
     object6 = object6.getExpression();
   }
-  if (!object6 || !Node2.isObjectLiteralExpression(object6)) return null;
+  if (!object6 || !Node3.isObjectLiteralExpression(object6)) return null;
   const info = {};
   for (const key of ["name", "url"]) {
     const property = object6.getProperty(key);
-    if (!property || !Node2.isPropertyAssignment(property)) continue;
+    if (!property || !Node3.isPropertyAssignment(property)) continue;
     const value = property.getInitializer();
-    if (Node2.isStringLiteral(value) || Node2.isNoSubstitutionTemplateLiteral(value)) {
+    if (Node3.isStringLiteral(value) || Node3.isNoSubstitutionTemplateLiteral(value)) {
       const text19 = value.getLiteralValue().trim();
       if (text19) info[key] = text19;
     }
@@ -1580,6 +1637,7 @@ import fs15 from "node:fs";
 import path13 from "node:path";
 import {
   Node,
+  Project as Project2,
   SyntaxKind as SyntaxKind2,
   ts
 } from "ts-morph";
@@ -1696,8 +1754,8 @@ function kitStatus(root) {
     declaredMajor: range === void 0 ? null : declaredMajor(range),
     svelteConfig: findSvelteConfig(root)
   };
-  const installed = readPkg(path12.join(root, "node_modules", KIT, "package.json"))?.version;
-  if (typeof installed === "string") status3.installedVersion = installed;
+  const installed2 = readPkg(path12.join(root, "node_modules", KIT, "package.json"))?.version;
+  if (typeof installed2 === "string") status3.installedVersion = installed2;
   return status3;
 }
 function declaredMajor(range) {
@@ -1708,8 +1766,8 @@ function declaredMajor(range) {
 }
 function assertKit3(root, label4) {
   const status3 = kitStatus(root);
-  const installed = installedMajor(status3.installedVersion);
-  const why = status3.declaredMajor !== null && status3.declaredMajor < 3 ? `package.json declares ${KIT} ${status3.declaredMajor}.x.` : status3.declaredMajor === null && installed !== null && installed < 3 ? `It has ${KIT} ${status3.installedVersion} installed.` : status3.svelteConfig ? `It still has ${path12.basename(status3.svelteConfig)}, which SvelteKit 3 no longer reads.` : null;
+  const installed2 = installedMajor(status3.installedVersion);
+  const why = status3.declaredMajor !== null && status3.declaredMajor < 3 ? `package.json declares ${KIT} ${status3.declaredMajor}.x.` : status3.declaredMajor === null && installed2 !== null && installed2 < 3 ? `It has ${KIT} ${status3.installedVersion} installed.` : status3.svelteConfig ? `It still has ${path12.basename(status3.svelteConfig)}, which SvelteKit 3 no longer reads.` : null;
   if (!why) return;
   throw new KitVersionError(
     `${label4}: SvelteKit 2 project detected. ${why}
@@ -1797,19 +1855,35 @@ function mergeRunesIntoViteArg(vite, arg) {
   return { applied: true, reason: "added runes compilerOption", file };
 }
 var ORIGIN_SPREAD = `...(process.env.VELA_ORIGIN ? { paths: { origin: process.env.VELA_ORIGIN } } : {})`;
-function mergeOriginConfig(root) {
+function mergeOriginConfig(root, options = {}) {
   const svelteConfig = findSvelteConfig(root);
   if (svelteConfig) return svelteConfigOutcome(svelteConfig);
   const vite = inspectViteSveltekit(root);
-  if (!vite?.inlineArg) {
+  const carry = options.carry;
+  let arg = vite?.inlineArg ?? null;
+  if (vite && !arg && carry && !vite.nonObjectArg) arg = createSveltekitArg(vite);
+  if (!vite || !arg) {
     return {
       applied: false,
       reason: "no sveltekit({...}) config, so no prerender.origin to move",
-      file: vite ? path13.basename(vite.filePath) : void 0
+      file: vite ? path13.basename(vite.filePath) : void 0,
+      ...carry ? { snippet: carry.text } : {}
     };
   }
   const file = path13.basename(vite.filePath);
-  const arg = vite.inlineArg;
+  let carried = false;
+  if (carry && !configSetsOrigin(arg)) {
+    if (carry.isPrerenderProperty && arg.getProperty("prerender")) {
+      return {
+        applied: false,
+        reason: `sv dropped the origin from ${carry.from}, and the config already has a \`prerender\` object to merge it into; add it to paths.origin by hand`,
+        snippet: carry.text,
+        file
+      };
+    }
+    arg.addProperty(carry.text);
+    carried = true;
+  }
   const sources = findPrerenderOrigins(arg);
   const pathsProp = arg.getProperty("paths");
   const paths = pathsProp && Node.isPropertyAssignment(pathsProp) ? pathsProp.getInitializerIfKind(SyntaxKind2.ObjectLiteralExpression) : void 0;
@@ -1843,6 +1917,9 @@ function mergeOriginConfig(root) {
   const [source] = sources;
   const replacement = source.condition ? `...(${source.condition} ? { paths: { origin: ${source.value} } } : {})` : `paths: { origin: ${source.value} }`;
   const index = arg.getProperties().indexOf(source.anchor);
+  const staleComment = sources.some((s) => mentionsPrerender(s.node));
+  const inPlace = !hasPathsOrigin && !paths && Node.isSpreadAssignment(source.anchor) ? source : void 0;
+  const orphaned = sources.filter((s) => s !== inPlace).flatMap((s) => s.node.getLeadingCommentRanges().map((c) => c.getText()));
   if (hasPathsOrigin) {
     for (const s of sources) s.remove();
   } else if (paths) {
@@ -1872,13 +1949,125 @@ function mergeOriginConfig(root) {
       });
     }
   }
+  if (staleComment && !hasPathsOrigin && !paths) {
+    const target = arg.getProperties().find((p73) => isOriginElement(p73));
+    if (target) setOriginComment(target);
+  }
+  if (orphaned.length > 0) {
+    let text19 = vite.sourceFile.getFullText();
+    for (const comment of orphaned) {
+      text19 = text19.replace(new RegExp(String.raw`\n[\t ]*${escapeRegExp2(comment)}[\t ]*(?=\n)`), "");
+    }
+    vite.sourceFile.replaceWithText(text19);
+  }
   vite.sourceFile.saveSync();
+  const moved = hasPathsOrigin ? "removed prerender.origin, which SvelteKit 3 no longer accepts; kept the existing paths.origin" : "moved prerender.origin to paths.origin";
   return {
     applied: true,
-    reason: hasPathsOrigin ? "removed prerender.origin, which SvelteKit 3 no longer accepts; kept the existing paths.origin" : "moved prerender.origin to paths.origin",
+    reason: carried ? `restored the origin sv dropped from ${carry.from}, and ${moved}` : moved,
     file
   };
 }
+function configSetsOrigin(arg) {
+  const prerender = findPrerenderOrigins(arg);
+  if (prerender === "unsupported" || prerender.length > 0) return true;
+  return arg.getProperties().some((p73) => {
+    if (Node.isPropertyAssignment(p73) && p73.getName() === "paths") {
+      const paths = p73.getInitializerIfKind(SyntaxKind2.ObjectLiteralExpression);
+      return paths !== void 0 && hasOrigin(paths);
+    }
+    const spread = conditionalSpreadOf(p73, "paths");
+    return spread !== void 0 && hasOrigin(spread.object);
+  });
+}
+function isOriginElement(element) {
+  if (Node.isPropertyAssignment(element) && element.getName() === "paths") return true;
+  return conditionalSpreadOf(element, "paths") !== void 0;
+}
+var ORIGIN_COMMENT = [
+  "The public origin, which SvelteKit checks form posts against and uses",
+  "for prerendered pages. `vela deploy` sets VELA_ORIGIN, and the value is",
+  "baked in at build time. It is left unset for a deploy that serves more",
+  "than one host, where each request's own origin is used instead."
+];
+function escapeRegExp2(text19) {
+  return text19.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function mentionsPrerender(node) {
+  return node.getLeadingCommentRanges().some((c) => /prerender/i.test(c.getText()));
+}
+function setOriginComment(node) {
+  const sourceFile = node.getSourceFile();
+  const full = sourceFile.getFullText();
+  const start = node.getStart();
+  const lineStart = full.lastIndexOf("\n", start - 1) + 1;
+  const indent = full.slice(lineStart, start).match(/^[\t ]*/)[0];
+  const comment = ORIGIN_COMMENT.map((line) => `// ${line}`).join(`
+${indent}`);
+  const ranges = node.getLeadingCommentRanges();
+  if (ranges.length > 0) {
+    sourceFile.replaceText([ranges[0].getPos(), ranges.at(-1).getEnd()], comment);
+  } else {
+    sourceFile.insertText(start, `${comment}
+${indent}`);
+  }
+}
+function captureSvelteConfig(root) {
+  const filePath = findSvelteConfig(root);
+  if (!filePath) return null;
+  const file = path13.basename(filePath);
+  const capture = { file, spreads: [] };
+  let config;
+  try {
+    const project = new Project2({ compilerOptions: { allowJs: true } });
+    config = configObject(project.addSourceFileAtPath(filePath));
+  } catch {
+    return capture;
+  }
+  if (!config) return capture;
+  const kitProp = config.getProperty("kit");
+  const kit = Node.isPropertyAssignment(kitProp) ? kitProp.getInitializerIfKind(SyntaxKind2.ObjectLiteralExpression) : void 0;
+  for (const object6 of [config, kit]) {
+    for (const element of object6?.getProperties() ?? []) {
+      if (Node.isSpreadAssignment(element)) capture.spreads.push(element.getText());
+    }
+  }
+  if (!kit) return capture;
+  for (const element of kit.getProperties()) {
+    const spread = conditionalSpreadOf(element, "prerender");
+    const isPrerender = Node.isPropertyAssignment(element) && element.getName() === "prerender";
+    if (!(spread && hasOrigin(spread.object)) && !isPrerender) continue;
+    if (isPrerender) {
+      const prerender = element.getInitializerIfKind(SyntaxKind2.ObjectLiteralExpression);
+      if (!prerender || !hasOrigin(prerender)) continue;
+    }
+    capture.origin = { from: file, text: withComments(element), isPrerenderProperty: isPrerender };
+    break;
+  }
+  return capture;
+}
+function withComments(node) {
+  const ranges = node.getLeadingCommentRanges();
+  const start = ranges[0]?.getPos() ?? node.getStart();
+  return node.getSourceFile().getFullText().slice(start, node.getEnd()).split("\n").map((line) => line.trim()).join("\n");
+}
+function configObject(sourceFile) {
+  const exported = sourceFile.getExportAssignment((e) => !e.isExportEquals())?.getExpression();
+  let node = exported;
+  for (let depth = 0; node && depth < 5; depth++) {
+    if (Node.isObjectLiteralExpression(node)) return node;
+    if (Node.isParenthesizedExpression(node) || Node.isSatisfiesExpression(node) || Node.isAsExpression(node)) {
+      node = node.getExpression();
+    } else if (Node.isCallExpression(node)) {
+      node = node.getArguments()[0];
+    } else if (Node.isIdentifier(node)) {
+      node = sourceFile.getVariableDeclaration(node.getText())?.getInitializer();
+    } else {
+      return void 0;
+    }
+  }
+  return void 0;
+}
 function unwrap(node) {
   let current = node;
   while (Node.isParenthesizedExpression(current)) current = current.getExpression();
@@ -1927,6 +2116,7 @@ function findPrerenderOrigins(arg) {
         condition: spread.condition,
         value,
         anchor: element,
+        node: element,
         remove: () => element.remove()
       });
       continue;
@@ -1947,6 +2137,7 @@ function findPrerenderOrigins(arg) {
           condition: conditional.condition,
           value,
           anchor: element,
+          node: inner,
           remove: removeFromPrerender(inner)
         });
         continue;
@@ -1957,6 +2148,7 @@ function findPrerenderOrigins(arg) {
         sources.push({
           value,
           anchor: element,
+          node: inner,
           remove: removeFromPrerender(inner)
         });
       }
@@ -2680,8 +2872,8 @@ function printNextSteps(projectPath, packageManager2) {
 }
 
 // src/commands/create.ts
-import fs24 from "node:fs";
-import path22 from "node:path";
+import fs27 from "node:fs";
+import path25 from "node:path";
 import process13 from "node:process";
 import * as v5 from "valibot";
 import { Command as Command3 } from "commander";
@@ -3119,8 +3311,8 @@ function extractApiKey(cookie) {
 }
 
 // src/lib/kit3-migrate.ts
-import fs22 from "node:fs";
-import path20 from "node:path";
+import fs25 from "node:fs";
+import path23 from "node:path";
 import process12 from "node:process";
 import { execFileSync, spawn as spawn2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
@@ -3130,24 +3322,330 @@ import { detect as detect3 } from "package-manager-detector";
 import {
   ADAPTER_NODE,
   ADAPTER_STATIC,
+  ensurePackageOverrides,
   FLASH,
-  NEGOTIATE,
   SUPERFORMS_VERSION,
   VELASTACK_CMS,
   VELASTACK_KIT,
   VELASTACK_POCKETBASE
 } from "@velastack/patterns";
 
-// src/lib/lib-rewrite.ts
+// src/lib/kit-peers.ts
 import fs20 from "node:fs";
 import path18 from "node:path";
+import { execFile } from "node:child_process";
+var LOOKUP_TIMEOUT_MS = 15e3;
+var CONCURRENCY = 8;
+var OFFLINE_AFTER = 3;
+var npmViewLookup = (name, range, cwd) => new Promise((resolve2, reject) => {
+  execFile(
+    "npm",
+    ["view", `${name}@${range}`, "--json"],
+    { cwd, timeout: LOOKUP_TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024 },
+    (error, stdout, stderr) => {
+      if (error && /\bE404\b/.test(`${stderr}${error.message}`)) return resolve2(null);
+      if (error) return reject(error);
+      const text19 = stdout.trim();
+      if (!text19) return resolve2(null);
+      try {
+        resolve2(newest(JSON.parse(text19)));
+      } catch (e) {
+        reject(e);
+      }
+    }
+  );
+});
+function newest(data) {
+  const list3 = (Array.isArray(data) ? data : [data]).filter((m) => typeof m?.version === "string");
+  let best = null;
+  for (const manifest of list3) {
+    const v12 = minVersion(manifest.version);
+    const b = best ? minVersion(best.version) : null;
+    if (v12 && (!b || compareVersions(v12, b) > 0)) best = manifest;
+  }
+  return best;
+}
+function installed(root, name) {
+  try {
+    const data = JSON.parse(
+      fs20.readFileSync(path18.join(root, "node_modules", name, "package.json"), "utf8")
+    );
+    return typeof data.version === "string" ? data : null;
+  } catch {
+    return null;
+  }
+}
+async function findKit2Peers(root, pkg, skip, lookup = npmViewLookup) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const kind of ["dependencies", "devDependencies"]) {
+    for (const [name, range] of Object.entries(pkg[kind] ?? {})) {
+      if (!skip(name)) deps.set(name, range);
+    }
+  }
+  const kit2 = [];
+  const unchecked = [];
+  const check2 = (name, manifest) => {
+    const peer = manifest.peerDependencies?.["@sveltejs/kit"];
+    if (peer && rangeAdmits(peer, "3.0.0") === false) {
+      kit2.push({ name, version: manifest.version, peer });
+    }
+  };
+  const remote = [];
+  for (const [name, range] of deps) {
+    const local = installed(root, name);
+    if (local) check2(name, local);
+    else if (!range.includes(":") && !range.includes("/")) remote.push([name, range]);
+  }
+  let answered = 0;
+  let failed = 0;
+  const queue = [...remote];
+  const worker = async () => {
+    for (let next = queue.shift(); next; next = queue.shift()) {
+      const [name, range] = next;
+      if (answered === 0 && failed >= OFFLINE_AFTER) {
+        unchecked.push(name);
+        continue;
+      }
+      try {
+        const manifest = await lookup(name, range, root);
+        answered++;
+        if (manifest) check2(name, manifest);
+        else unchecked.push(name);
+      } catch {
+        failed++;
+        unchecked.push(name);
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(CONCURRENCY, remote.length) }, worker));
+  const order = [...deps.keys()];
+  const byOrder = (a, b) => order.indexOf(a) - order.indexOf(b);
+  kit2.sort((a, b) => byOrder(a.name, b.name));
+  unchecked.sort(byOrder);
+  return { kit2, unchecked };
+}
+
+// src/lib/locales-alias.ts
+import fs21 from "node:fs";
+import path19 from "node:path";
+import { Node as Node2, SyntaxKind as SyntaxKind3 } from "ts-morph";
+import { ensurePackageImports } from "@velastack/patterns";
+var LOCALES_IMPORTS = { "#locales/*": "./src/locales/*" };
+var LOCALES_DIR = "src/locales";
+function keyName(node) {
+  if (!Node2.isPropertyAssignment(node)) return void 0;
+  return node.getNameNode().getText().replace(/^['"`]|['"`]$/g, "");
+}
+function localesProperty(alias) {
+  return alias.getProperties().find((p73) => keyName(p73) === "$locales");
+}
+function localesSpecifier(root, rest) {
+  if (/\.(?:js|mjs|cjs|json)$/.test(rest)) return `#locales/${rest}`;
+  const dir = path19.join(root, LOCALES_DIR);
+  const exists = (name) => fs21.existsSync(path19.join(dir, name));
+  if (!exists(`${rest}.js`) && (exists(`${rest}.svelte.js`) || exists(`${rest}.svelte.ts`))) {
+    return `#locales/${rest}.svelte.js`;
+  }
+  return `#locales/${rest}.js`;
+}
+var LOCALES_SPECIFIER = /(['"])\$locales\/([^'"\n]+)\1/g;
+function rewriteLocalesSource(root, source) {
+  const changes = [];
+  const code2 = source.replace(LOCALES_SPECIFIER, (_whole, quote2, rest) => {
+    const next = localesSpecifier(root, rest);
+    changes.push(`$locales/${rest} \u2192 ${next}`);
+    return `${quote2}${next}${quote2}`;
+  });
+  return { code: code2, changes };
+}
+async function migrateLocalesAlias(root) {
+  const outcome = { changed: false, details: [], warnings: [] };
+  const vite = inspectViteSveltekit(root);
+  const aliasProp = vite?.inlineArg?.getProperty("alias");
+  if (!vite || !aliasProp || !Node2.isPropertyAssignment(aliasProp)) return outcome;
+  const alias = aliasProp.getInitializerIfKind(SyntaxKind3.ObjectLiteralExpression);
+  const entry = alias && localesProperty(alias);
+  if (!alias || !entry || !Node2.isPropertyAssignment(entry)) return outcome;
+  const target = entry.getInitializerIfKind(SyntaxKind3.StringLiteral)?.getLiteralValue();
+  const normalized = target?.replace(/^\.\//, "").replace(/\/$/, "");
+  if (normalized !== LOCALES_DIR) return outcome;
+  const imports = await ensurePackageImports(root, LOCALES_IMPORTS);
+  if (imports.outcome.status !== "success") {
+    outcome.warnings.push(
+      `alias.$locales was left in place: ${imports.outcome.message ?? "package.json imports could not be updated"}`
+    );
+    return outcome;
+  }
+  if (imports.outcome.changed) {
+    outcome.changed = true;
+    outcome.details.push("package.json imports #locales/*");
+  }
+  const files = [...sourceFiles(path19.join(root, "src")), ...sourceFiles(path19.join(root, "test"))];
+  let rewritten = 0;
+  for (const file of files) {
+    const source = fs21.readFileSync(file, "utf8");
+    if (!source.includes("$locales/")) continue;
+    const { code: code2, changes } = rewriteLocalesSource(root, source);
+    if (code2 === source) continue;
+    fs21.writeFileSync(file, code2);
+    rewritten += changes.length;
+    outcome.details.push(`${path19.relative(root, file)}: ${[...new Set(changes)].join(", ")}`);
+  }
+  entry.remove();
+  if (alias.getProperties().length === 0) aliasProp.remove();
+  vite.sourceFile.saveSync();
+  outcome.changed = true;
+  outcome.details.push(
+    `${path19.basename(vite.filePath)}: removed alias.$locales${rewritten ? ` (${rewritten} specifier${rewritten === 1 ? "" : "s"} now #locales)` : ""}`
+  );
+  return outcome;
+}
+
+// src/lib/params-native.ts
+import fs22 from "node:fs";
+import path20 from "node:path";
+import { Project as Project3, QuoteKind as QuoteKind2 } from "ts-morph";
+var PARAMS_FILES = ["src/params.ts", "src/params.js"];
+var PARAMS_DIR = "src/params";
+var IMPORT_SPECIFIERS = /import\s+(type\s+)?([^'";]*?)\s*from\s*(['"])([^'"]+)\3/g;
+function captureParamTypeImports(root) {
+  const names = /* @__PURE__ */ new Set();
+  const dir = path20.join(root, PARAMS_DIR);
+  if (!fs22.existsSync(dir)) return names;
+  for (const entry of fs22.readdirSync(dir)) {
+    if (!/\.(ts|js)$/.test(entry)) continue;
+    const source = fs22.readFileSync(path20.join(dir, entry), "utf8");
+    for (const match of source.matchAll(IMPORT_SPECIFIERS)) {
+      const clause = match[2];
+      const braces = clause.match(/\{([^}]*)\}/)?.[1];
+      if (!braces) continue;
+      for (const raw of braces.split(",")) {
+        const spec = raw.trim();
+        const inline = /^type\s+/.test(spec);
+        if (!spec || !match[1] && !inline) continue;
+        const [, local] = spec.replace(/^type\s+/, "").match(/^(?:[\w$]+\s+as\s+)?([\w$]+)$/) ?? [];
+        if (local) names.add(local);
+      }
+    }
+  }
+  return names;
+}
+function resolveLocal(root, fromDir, spec) {
+  let base2;
+  if (spec.startsWith("#lib/") || spec.startsWith("$lib/")) {
+    base2 = path20.join(root, "src", "lib", spec.slice(5));
+  } else if (spec.startsWith("./") || spec.startsWith("../")) {
+    base2 = path20.resolve(fromDir, spec);
+  } else {
+    return null;
+  }
+  const stem = base2.replace(/\.js$/, "");
+  const candidates = /\.js$/.test(base2) ? [base2, `${stem}.ts`] : [base2, `${base2}.ts`, `${base2}.js`, path20.join(base2, "index.ts"), path20.join(base2, "index.js")];
+  return candidates.find((c) => fs22.existsSync(c) && fs22.statSync(c).isFile()) ?? null;
+}
+function declaresTypeOnly(file, name) {
+  const source = fs22.readFileSync(file, "utf8");
+  const n = name.replace(/[$]/g, "\\$");
+  const asValue = new RegExp(
+    String.raw`\bexport\s+(?:declare\s+)?(?:const|let|var|function|class|enum|async\s+function)\s+${n}\b|\bexport\s*\{[^}]*\b${n}\b`
+  );
+  if (asValue.test(source)) return false;
+  return new RegExp(
+    String.raw`\bexport\s+(?:declare\s+)?(?:type|interface)\s+${n}\b|@(?:typedef|callback)\s+(?:\{[\s\S]*?\}\s+)?${n}\b`
+  ).test(source);
+}
+function relativeSpecifier(root, target) {
+  const rel = path20.relative(path20.join(root, "src"), target).split(path20.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function fixParamsImports(root, typeNames = /* @__PURE__ */ new Set()) {
+  const rel = PARAMS_FILES.find((f) => fs22.existsSync(path20.join(root, f)));
+  if (!rel) return { changes: [], viteOnly: [] };
+  const file = path20.join(root, rel);
+  const outcome = { file: rel, changes: [], viteOnly: [] };
+  const project = new Project3({
+    compilerOptions: { allowJs: true },
+    manipulationSettings: { quoteKind: QuoteKind2.Single }
+  });
+  const sourceFile = project.addSourceFileAtPath(file);
+  const srcDir = path20.join(root, "src");
+  const loaded = [];
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const spec = decl.getModuleSpecifierValue();
+    const target = resolveLocal(root, srcDir, spec);
+    if (!target) continue;
+    if (!decl.isTypeOnly()) restoreTypes(decl, target, typeNames, outcome);
+    if (decl.isTypeOnly()) continue;
+    loaded.push(target);
+    const nodeResolves = spec.startsWith("#lib/") && /\.js$/.test(spec) ? fs22.existsSync(path20.join(root, "src", "lib", spec.slice(5))) : spec.startsWith(".") && path20.resolve(srcDir, spec) === target;
+    if (nodeResolves) continue;
+    const next = relativeSpecifier(root, target);
+    decl.setModuleSpecifier(next);
+    outcome.changes.push(`${spec} \u2192 ${next}`);
+  }
+  if (outcome.changes.length > 0) sourceFile.saveSync();
+  outcome.viteOnly = viteOnlyImports(root, loaded);
+  return outcome;
+}
+function restoreTypes(decl, target, typeNames, outcome) {
+  const named = decl.getNamedImports();
+  const restored = [];
+  for (const specifier of named) {
+    if (specifier.isTypeOnly()) continue;
+    const local = specifier.getAliasNode()?.getText() ?? specifier.getName();
+    if (!typeNames.has(local) && !declaresTypeOnly(target, specifier.getName())) continue;
+    specifier.setIsTypeOnly(true);
+    restored.push(local);
+  }
+  if (restored.length === 0) return;
+  if (named.every((s) => s.isTypeOnly()) && !decl.getDefaultImport() && !decl.getNamespaceImport()) {
+    for (const s of named) s.setIsTypeOnly(false);
+    decl.setIsTypeOnly(true);
+  }
+  outcome.changes.push(`type ${restored.join(", ")} (from ${decl.getModuleSpecifierValue()})`);
+}
+function viteOnlyImports(root, start) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...start];
+  for (let file = queue.shift(); file; file = queue.shift()) {
+    if (seen.has(file) || !file.startsWith(path20.join(root, "src"))) continue;
+    seen.add(file);
+    const source = fs22.readFileSync(file, "utf8");
+    const rel = path20.relative(root, file).split(path20.sep).join("/");
+    for (const match of source.matchAll(IMPORT_SPECIFIERS)) {
+      const clause = match[2];
+      const spec = match[4];
+      if (match[1] || /^\{\s*(?:type\s+[\w$]+(?:\s+as\s+[\w$]+)?\s*,?\s*)+\}$/.test(clause))
+        continue;
+      if (/^\$(?:lib|app|env|locales|service-worker)\b/.test(spec)) {
+        found.push(`${rel}: ${spec}`);
+        continue;
+      }
+      const target = resolveLocal(root, path20.dirname(file), spec);
+      if (spec.startsWith("#lib/")) {
+        if (!fs22.existsSync(path20.join(root, "src", "lib", spec.slice(5)))) {
+          found.push(`${rel}: ${spec}`);
+        }
+      } else if (spec.startsWith(".") && target && path20.resolve(path20.dirname(file), spec) !== target) {
+        found.push(`${rel}: ${spec}`);
+      }
+      if (target) queue.push(target);
+    }
+  }
+  return found;
+}
+
+// src/lib/lib-rewrite.ts
+import fs23 from "node:fs";
+import path21 from "node:path";
 import { libSpecifier } from "@velastack/patterns";
 var KEPT_EXTENSIONS = /\.(svelte|svg|svx|css|json)$/;
 var MODULE_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
 function resolveLibPath(root, rel) {
-  const lib = path18.join(root, "src", "lib");
-  const isFile = (p73) => fs20.existsSync(path18.join(lib, p73)) && fs20.statSync(path18.join(lib, p73)).isFile();
-  const isDir = (p73) => fs20.existsSync(path18.join(lib, p73)) && fs20.statSync(path18.join(lib, p73)).isDirectory();
+  const lib = path21.join(root, "src", "lib");
+  const isFile = (p73) => fs23.existsSync(path21.join(lib, p73)) && fs23.statSync(path21.join(lib, p73)).isFile();
+  const isDir = (p73) => fs23.existsSync(path21.join(lib, p73)) && fs23.statSync(path21.join(lib, p73)).isDirectory();
   if (rel === "") return "";
   if (KEPT_EXTENSIONS.test(rel)) {
     if (isFile(rel)) return rel;
@@ -3187,40 +3685,40 @@ function rewriteLibSpecifiers(root, source) {
 }
 function filesOutsideSrc(root) {
   const files = [];
-  const test = path18.join(root, "test");
-  if (fs20.existsSync(test)) {
-    for (const rel of fs20.globSync("**/*.{ts,js,mts,mjs,svelte}", {
+  const test = path21.join(root, "test");
+  if (fs23.existsSync(test)) {
+    for (const rel of fs23.globSync("**/*.{ts,js,mts,mjs,svelte}", {
       cwd: test,
       exclude: (name) => name === "node_modules"
     })) {
-      files.push(path18.join(test, rel));
+      files.push(path21.join(test, rel));
     }
   }
-  for (const entry of fs20.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs23.readdirSync(root, { withFileTypes: true })) {
     if (entry.isFile() && /\.(ts|js|mts|mjs|cts|cjs)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
-      files.push(path18.join(root, entry.name));
+      files.push(path21.join(root, entry.name));
     }
   }
-  return files.filter((f) => fs20.statSync(f).isFile()).sort();
+  return files.filter((f) => fs23.statSync(f).isFile()).sort();
 }
 function rewriteLibOutsideSrc(root) {
   const result = { rewritten: [], unresolved: [] };
   for (const file of filesOutsideSrc(root)) {
-    const source = fs20.readFileSync(file, "utf8");
+    const source = fs23.readFileSync(file, "utf8");
     if (!source.includes("$lib")) continue;
-    const rel = path18.relative(root, file);
+    const rel = path21.relative(root, file);
     const { code: code2, changes, unresolved } = rewriteLibSpecifiers(root, source);
     result.unresolved.push(...unresolved.map((spec) => `${rel}: ${spec}`));
     if (code2 === source) continue;
-    fs20.writeFileSync(file, code2);
+    fs23.writeFileSync(file, code2);
     result.rewritten.push({ file: rel, changes });
   }
   return result;
 }
 function rewriteComponentsJsonAliases(root) {
-  const file = path18.join(root, "components.json");
-  if (!fs20.existsSync(file)) return null;
-  const source = fs20.readFileSync(file, "utf8");
+  const file = path21.join(root, "components.json");
+  if (!fs23.existsSync(file)) return null;
+  const source = fs23.readFileSync(file, "utf8");
   let data;
   try {
     data = JSON.parse(source);
@@ -3238,13 +3736,13 @@ function rewriteComponentsJsonAliases(root) {
     changes.push(`${value} \u2192 ${next}`);
   }
   if (code2 === source) return null;
-  fs20.writeFileSync(file, code2);
+  fs23.writeFileSync(file, code2);
   return { file: "components.json", changes };
 }
 
 // src/lib/kit3-rewrites.ts
-import fs21 from "node:fs";
-import path19 from "node:path";
+import fs24 from "node:fs";
+import path22 from "node:path";
 var MIGRATION_TASK_MARKER = "@migration-task";
 var NAVIGATION_IMPORT = /import\s*\{([^}]*)\}\s*from\s*['"]\$app\/navigation['"]\s*;?/g;
 function navigationBindings(source) {
@@ -3337,7 +3835,7 @@ function lineOf(source, index) {
 function rewriteGotoCalls(source, gotoNames) {
   const outcome = { edits: [], changes: [], tasks: [] };
   for (const local of gotoNames) {
-    const call = new RegExp(String.raw`(?<![\w$.])${escapeRegExp2(local)}\s*\(`, "g");
+    const call = new RegExp(String.raw`(?<![\w$.])${escapeRegExp3(local)}\s*\(`, "g");
     for (const match of source.matchAll(call)) {
       if (inComment(source, match.index)) continue;
       const open = match.index + match[0].length - 1;
@@ -3444,7 +3942,7 @@ function rewriteGotoOptions(inner) {
   if (!joined.startsWith(lead)) joined = lead + joined.trimStart();
   return { inner: joined + tail, summary: summary.join("; ") };
 }
-function escapeRegExp2(text19) {
+function escapeRegExp3(text19) {
   return text19.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function rewriteInvalidateAll(source) {
@@ -3561,7 +4059,37 @@ function insideScript(source, index) {
   return open !== -1 && open > close;
 }
 var MOCK_ENVIRONMENT = /(\bvi\.(?:mock|doMock|unmock|doUnmock|importActual|importMock)\s*\(\s*)(['"])\$app\/environment\2/g;
+var MOCK_ENV = /(\bvi\.(mock|doMock|unmock|doUnmock|importActual|importMock)\s*\(\s*)(['"])\$env\/(dynamic|static)\/(private|public)\3/g;
 var NEW_URL_PAGE_URL = /\bnew\s+URL\(\s*(\$?page\.url)\s*\)/g;
+function rewriteEnvMocks(source) {
+  const changes = [];
+  const tasks = [];
+  let code2 = "";
+  let last = 0;
+  for (const match of source.matchAll(MOCK_ENV)) {
+    const [whole, lead, method, quote2, kind, visibility] = match;
+    const start = match.index;
+    const target = `$app/env/${visibility}`;
+    code2 += source.slice(last, start);
+    const at = code2.length;
+    code2 += `${lead}${quote2}${target}${quote2}`;
+    last = start + whole.length;
+    changes.push(`line ${lineOf(source, start)}: mock of $env/${kind}/${visibility} \u2192 ${target}`);
+    if (kind !== "dynamic" || method !== "mock" && method !== "doMock") continue;
+    const open = start + lead.lastIndexOf("(");
+    const close = matchBracket(source, open);
+    if (close === -1) continue;
+    const factory = splitTopLevel(source.slice(open + 1, close - 1))[1]?.text ?? "";
+    if (/(?<![\w$.])env\s*[:,}]/.test(factory)) {
+      tasks.push([
+        at,
+        `\`${target}\` exports each variable by name, but this mock returns Kit 2's \`{ env: {...} }\`. Return the variables themselves, e.g. \`() => ({ TEST: 'true' })\`.`
+      ]);
+    }
+  }
+  code2 += source.slice(last);
+  return { code: code2, changes, tasks };
+}
 function rewriteKit3Source(file, source) {
   const changes = [];
   let code2 = source;
@@ -3573,13 +4101,17 @@ function rewriteKit3Source(file, source) {
     changes.push(`line ${lineOf(code2, offset)}: new URL(${url}) \u2192 new URL(${url}.href)`);
     return `new URL(${url}.href)`;
   });
-  let tasks = [];
+  const envMocks = rewriteEnvMocks(code2);
+  code2 = envMocks.code;
+  changes.push(...envMocks.changes);
+  let tasks = [...envMocks.tasks];
   const bindings = navigationBindings(code2);
   const gotoNames = [...bindings].filter(([, name]) => name === "goto").map(([local]) => local);
   if (gotoNames.length > 0) {
     const goto = rewriteGotoCalls(code2, gotoNames);
     code2 = applyEdits(code2, goto.edits);
     changes.push(...goto.changes);
+    tasks = tasks.map(([i, m]) => [mapIndex(goto.edits, i), m]);
     tasks.push(...goto.tasks.map(([i, m]) => [mapIndex(goto.edits, i), m]));
   }
   if ([...bindings.values()].includes("invalidateAll")) {
@@ -3596,15 +4128,15 @@ function rewriteKit3Source(file, source) {
 }
 function rewriteKit3Code(root) {
   const results = [];
-  const files = [...sourceFiles(path19.join(root, "src")), ...sourceFiles(path19.join(root, "test"))];
+  const files = [...sourceFiles(path22.join(root, "src")), ...sourceFiles(path22.join(root, "test"))];
   for (const file of files) {
-    const source = fs21.readFileSync(file, "utf8");
-    if (!/\$app\/navigation|\$app\/environment|new\s+URL\(\s*\$?page\.url\s*\)/.test(source))
+    const source = fs24.readFileSync(file, "utf8");
+    if (!/\$app\/navigation|\$app\/environment|\$env\/|new\s+URL\(\s*\$?page\.url\s*\)/.test(source))
       continue;
-    const rel = path19.relative(root, file);
+    const rel = path22.relative(root, file);
     const { code: code2, changes, tasks } = rewriteKit3Source(rel, source);
     if (code2 === source) continue;
-    fs21.writeFileSync(file, code2);
+    fs24.writeFileSync(file, code2);
     results.push({ file: rel, changes, tasks });
   }
   return results;
@@ -3629,7 +4161,7 @@ function rewriteVelaEnvDefaultsSource(source) {
   const changes = [];
   if (locals.length === 0) return { code: source, changes };
   const pattern = new RegExp(
-    String.raw`(?<![\w$.])(${locals.map(escapeRegExp2).join("|")})(\s*)\?\?(?!=)(?!\s*(?:''|""|\`\`))`,
+    String.raw`(?<![\w$.])(${locals.map(escapeRegExp3).join("|")})(\s*)\?\?(?!=)(?!\s*(?:''|""|\`\`))`,
     "g"
   );
   const edits = [];
@@ -3650,13 +4182,13 @@ function rewriteVelaEnvDefaultsSource(source) {
 }
 function rewriteVelaEnvDefaults(root) {
   const results = [];
-  for (const file of sourceFiles(path19.join(root, "src"))) {
-    const source = fs21.readFileSync(file, "utf8");
+  for (const file of sourceFiles(path22.join(root, "src"))) {
+    const source = fs24.readFileSync(file, "utf8");
     if (!source.includes("$app/env/") || !source.includes("??")) continue;
     const { code: code2, changes } = rewriteVelaEnvDefaultsSource(source);
     if (code2 === source) continue;
-    fs21.writeFileSync(file, code2);
-    results.push({ file: path19.relative(root, file), changes, tasks: [] });
+    fs24.writeFileSync(file, code2);
+    results.push({ file: path22.relative(root, file), changes, tasks: [] });
   }
   return results;
 }
@@ -3695,7 +4227,9 @@ async function runKit3Migration(root, options = {}) {
   } } : base2;
   const mode = await preflight(root, options);
   const dirtyBefore = new Set(gitDirty(root) ?? []);
-  const sv = { ran: false, failures: [], excluded: [], cleared: [] };
+  const sv = { ran: false, failures: [], excluded: [], cleared: [], dropped: [] };
+  let svelteConfig = null;
+  let paramTypes = /* @__PURE__ */ new Set();
   if (mode === "repair") {
     sv.skipped = "SvelteKit 3 already, with no svelte.config: running only the vela steps";
     log55.info("Already on SvelteKit 3: skipping sv and re-checking the vela steps.");
@@ -3705,41 +4239,47 @@ async function runKit3Migration(root, options = {}) {
   } else {
     log55.step("Running sv migrate sveltekit-3...");
     sv.cleared = clearOutputDirs(root, log55);
+    svelteConfig = captureSvelteConfig(root);
+    paramTypes = captureParamTypeImports(root);
     await runSv(root, options.runSv ?? defaultSvRunner, quiet, sv, log55);
     sv.ran = true;
   }
   log55.step("Applying the vela steps...");
   const cliVersion = options.cliVersion ?? package_default.version;
   const fixups = [
-    originFixup(root),
+    originFixup(root, svelteConfig, sv),
     await envFixup(root),
     libFixup(root, sv.excluded),
+    await localesFixup(root),
+    paramsFixup(root, paramTypes),
     codeFixup(root),
     tsconfigFixup(root),
     packageFixup(root, cliVersion),
+    await peersFixup(root, options.peerLookup),
     lockfileFixup(root)
   ];
   for (const fixup2 of fixups) {
     if (fixup2.changed) log55.info(`${fixup2.name}: ${fixup2.details.join("; ")}`);
     for (const warning of fixup2.warnings) log55.warn(`${fixup2.name}: ${warning}`);
   }
-  let installed = null;
+  let installed2 = null;
   let formatted = [];
   if (options.install !== false) {
-    installed = options.installer ? await options.installer(root) : await install(root);
-    if (installed) formatted = await formatChanged(root, dirtyBefore);
+    installed2 = options.installer ? await options.installer(root) : await install(root);
+    if (installed2) formatted = await formatChanged(root, dirtyBefore);
   }
-  const followUps = collectFollowUps(root, sv);
-  if (!sv.ran) followUps.unshift(...previousSvFollowUps(root));
+  const found = [...collectFollowUps(root, sv), ...fixups.flatMap((f) => f.followUps ?? [])];
+  if (!sv.ran) found.unshift(...previousSvFollowUps(root));
+  const followUps = [...new Set(found)];
   const genericFollowUps = depRange(
-    readJson(path20.join(root, "package.json")).data,
+    readJson(path23.join(root, "package.json")).data,
     "@sveltejs/adapter-node"
   ) ? [
     "Servers need Node 22.17 or later: run `vela provision` on each before the first SvelteKit 3 deploy."
   ] : [];
   writeFollowUps(root, followUps, genericFollowUps);
   const tasks = summarizeMigrationTasks(root);
-  return { mode, sv, fixups, followUps, genericFollowUps, tasks, installed, formatted };
+  return { mode, sv, fixups, followUps, genericFollowUps, tasks, installed: installed2, formatted };
 }
 async function preflight(root, options) {
   const node = minVersion(options.nodeVersion ?? process12.versions.node);
@@ -3748,9 +4288,9 @@ async function preflight(root, options) {
       `SvelteKit 3 needs Node ${NODE_FLOOR} or later; this is Node ${options.nodeVersion ?? process12.versions.node}.`
     );
   }
-  const pkgPath = path20.join(root, "package.json");
-  if (!fs22.existsSync(pkgPath)) throw new Kit3MigrationError(`No package.json found in ${root}.`);
-  const project = JSON.parse(fs22.readFileSync(pkgPath, "utf8"));
+  const pkgPath = path23.join(root, "package.json");
+  if (!fs25.existsSync(pkgPath)) throw new Kit3MigrationError(`No package.json found in ${root}.`);
+  const project = JSON.parse(fs25.readFileSync(pkgPath, "utf8"));
   if (!project.devDependencies?.["@sveltejs/kit"]) {
     throw new Kit3MigrationError(
       project.dependencies?.["@sveltejs/kit"] ? "@sveltejs/kit is in dependencies; sv migrates it only from devDependencies. Move it there and run this again." : `@sveltejs/kit is not a devDependency in ${pkgPath}: this does not look like a SvelteKit project.`
@@ -3807,14 +4347,14 @@ function clearOutputDirs(root, log55) {
   const cleared = [];
   const inGit = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], root) !== null;
   const walk2 = (dir, depth) => {
-    for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = path20.join(dir, entry.name);
-      const rel = path20.relative(root, full);
+      const full = path23.join(dir, entry.name);
+      const rel = path23.relative(root, full);
       if (OUTPUT_DIRS.has(entry.name)) {
         const ignored = inGit ? spawnSync("git", ["check-ignore", "-q", rel], root) !== null : entry.name === ".svelte-kit";
         if (ignored) {
-          fs22.rmSync(full, { recursive: true, force: true });
+          fs25.rmSync(full, { recursive: true, force: true });
           cleared.push(rel);
         } else if (entry.name !== ".svelte-kit") {
           log55.warn(
@@ -3833,18 +4373,18 @@ function clearOutputDirs(root, log55) {
 }
 function svBin() {
   const entry = require_.resolve("sv");
-  let dir = path20.dirname(entry);
-  while (dir !== path20.dirname(dir)) {
-    const manifest = path20.join(dir, "package.json");
-    if (fs22.existsSync(manifest)) {
-      const data = JSON.parse(fs22.readFileSync(manifest, "utf8"));
+  let dir = path23.dirname(entry);
+  while (dir !== path23.dirname(dir)) {
+    const manifest = path23.join(dir, "package.json");
+    if (fs25.existsSync(manifest)) {
+      const data = JSON.parse(fs25.readFileSync(manifest, "utf8"));
       if (data.name === "sv") {
         const bin = typeof data.bin === "string" ? data.bin : data.bin?.sv;
         if (!bin) throw new Kit3MigrationError("The installed sv package has no bin.");
-        return path20.join(dir, bin);
+        return path23.join(dir, bin);
       }
     }
-    dir = path20.dirname(dir);
+    dir = path23.dirname(dir);
   }
   throw new Kit3MigrationError("Could not find the sv package vela depends on. Reinstall vela.");
 }
@@ -3962,9 +4502,10 @@ async function runSv(root, runner, quiet, summary, log55) {
 function fixup(name) {
   return { name, changed: false, details: [], warnings: [] };
 }
-function originFixup(root) {
+function originFixup(root, capture, sv) {
   const f = fixup("origin");
-  const outcome = mergeOriginConfig(root);
+  const carry = capture?.origin;
+  const outcome = mergeOriginConfig(root, { carry });
   if (outcome.applied) {
     f.changed = true;
     f.details.push(`${outcome.file}: ${outcome.reason}`);
@@ -3972,6 +4513,11 @@ function originFixup(root) {
     f.warnings.push(`${outcome.file ?? "vite.config"}: ${outcome.reason}
 ${outcome.snippet}`);
   }
+  const lost = Boolean(carry && !outcome.applied && outcome.snippet);
+  for (const text19 of capture?.spreads ?? []) {
+    if (carry && !lost && carry.text.endsWith(text19)) continue;
+    sv.dropped.push({ file: capture.file, text: text19 });
+  }
   return f;
 }
 async function envFixup(root) {
@@ -3988,7 +4534,7 @@ async function envFixup(root) {
 }
 function libFixup(root, skippedBySv) {
   const f = fixup("#lib");
-  const pkgPath = path20.join(root, "package.json");
+  const pkgPath = path23.join(root, "package.json");
   const { data, indent } = readJson(pkgPath);
   if (ensureLibImports(data)) {
     writeJson(pkgPath, data, indent);
@@ -4001,14 +4547,14 @@ function libFixup(root, skippedBySv) {
     f.details.push(`components.json aliases ${components.changes.join(", ")}`);
   }
   for (const rel of skippedBySv) {
-    const file = path20.join(root, rel);
-    if (!fs22.existsSync(file)) continue;
-    const source = fs22.readFileSync(file, "utf8");
+    const file = path23.join(root, rel);
+    if (!fs25.existsSync(file)) continue;
+    const source = fs25.readFileSync(file, "utf8");
     const { code: code2, changes, unresolved } = rewriteLibSpecifiers(root, source);
     for (const u of unresolved)
       f.warnings.push(`${rel}: ${u} names nothing under src/lib; change it by hand`);
     if (code2 === source) continue;
-    fs22.writeFileSync(file, code2);
+    fs25.writeFileSync(file, code2);
     f.changed = true;
     f.details.push(`${rel} (skipped by sv): ${changes.join(", ")}`);
   }
@@ -4021,6 +4567,29 @@ function libFixup(root, skippedBySv) {
     f.warnings.push(`${u} names nothing under src/lib; change it by hand`);
   return f;
 }
+async function localesFixup(root) {
+  const f = fixup("#locales");
+  const outcome = await migrateLocalesAlias(root);
+  f.changed = outcome.changed;
+  f.details.push(...outcome.details);
+  f.warnings.push(...outcome.warnings);
+  return f;
+}
+function paramsFixup(root, typeNames) {
+  const f = fixup("params");
+  const outcome = fixParamsImports(root, typeNames);
+  if (!outcome.file) return f;
+  if (outcome.changes.length > 0) {
+    f.changed = true;
+    f.details.push(`${outcome.file}: ${outcome.changes.join(", ")}`);
+  }
+  const typescript = outcome.file.endsWith(".ts");
+  const viteOnly = outcome.viteOnly.length ? ` These imports it loads do not: ${outcome.viteOnly.map(code).join(", ")}.` : "";
+  f.followUps = [
+    `${code(outcome.file)} is loaded by Node directly (SvelteKit's build imports it with \`import()\`, not through Vite), so everything it imports has to resolve without Vite: relative paths with real file names, no \`$lib\` or other aliases, \`type\` on type-only imports.${viteOnly}${typescript ? " A TypeScript params.ts needs Node 22.18 or later (native type stripping) wherever the app is built." : ""}`
+  ];
+  return f;
+}
 function codeFixup(root) {
   const f = fixup("code");
   for (const r of rewriteKit3Code(root)) {
@@ -4066,7 +4635,10 @@ var FLOORS = [
   splitSpec(VELASTACK_KIT),
   splitSpec(VELASTACK_POCKETBASE),
   splitSpec(VELASTACK_CMS),
-  splitSpec(NEGOTIATE)
+  // 0.3.0's package lost the `type="text/plain"` its prerender test relies on.
+  ["sveltekit-negotiate", "^0.3.1"],
+  // 0.3 peers @velastack/pocketbase ^0.3, which the floor above moves past.
+  ["@velastack/patterns", package_default.dependencies["@velastack/patterns"]]
 ];
 var EXACT_PINS = [
   ["sveltekit-superforms", SUPERFORMS_VERSION],
@@ -4075,7 +4647,7 @@ var EXACT_PINS = [
 var ENGINES_FLOOR = ">=22.17";
 function packageFixup(root, cliVersion) {
   const f = fixup("package.json");
-  const pkgPath = path20.join(root, "package.json");
+  const pkgPath = path23.join(root, "package.json");
   const { data, indent } = readJson(pkgPath);
   const changed = [];
   for (const [name, range] of [...FLOORS, ["vela", `^${cliVersion}`]]) {
@@ -4121,16 +4693,72 @@ function packageFixup(root, cliVersion) {
   }
   return f;
 }
+function bumpedHere(name) {
+  return name === "vela" || name.startsWith("@sveltejs/") || name.startsWith("@velastack/") || name.startsWith("@types/") || FLOORS.some(([floor]) => floor === name) || EXACT_PINS.some(([pin]) => pin === name);
+}
+async function peersFixup(root, lookup) {
+  const f = fixup("SvelteKit 2 peers");
+  f.followUps = [];
+  const data = readJson(path23.join(root, "package.json")).data;
+  const kit = depRange(data, "@sveltejs/kit") ?? "^3.0.0";
+  const overrides = data.overrides ?? {};
+  const overridden = (name) => {
+    const entry = overrides[name];
+    return typeof entry === "object" && entry !== null && "@sveltejs/kit" in entry;
+  };
+  const scan = await findKit2Peers(
+    root,
+    data,
+    (name) => bumpedHere(name) || overridden(name),
+    lookup
+  );
+  const wanted = {};
+  for (const peer of scan.kit2) wanted[peer.name] = { "@sveltejs/kit": kit };
+  if (scan.kit2.length > 0) {
+    const result = await ensurePackageOverrides(root, wanted);
+    if (result.outcome.status === "success") {
+      if (result.outcome.changed) {
+        f.changed = true;
+        for (const peer of scan.kit2) {
+          f.details.push(
+            `overrides ${peer.name} \u2192 @sveltejs/kit ${kit} (${peer.name}@${peer.version} peers @sveltejs/kit ${peer.peer})`
+          );
+        }
+      }
+    } else {
+      f.warnings.push(result.outcome.message ?? "could not write package.json overrides");
+    }
+  }
+  const names = [
+    ...Object.keys(data.dependencies ?? {}),
+    ...Object.keys(data.devDependencies ?? {})
+  ].filter((name, i, all) => all.indexOf(name) === i);
+  const after = readJson(path23.join(root, "package.json")).data.overrides ?? {};
+  for (const name of names) {
+    const entry = after[name];
+    if (bumpedHere(name) || typeof entry !== "object" || entry === null) continue;
+    if (!("@sveltejs/kit" in entry)) continue;
+    f.followUps.push(
+      `${code(name)} declares a SvelteKit 2 peer; overridden (\`overrides\` in package.json). Check it works and watch for an update that supports SvelteKit 3.`
+    );
+  }
+  if (scan.unchecked.length > 0) {
+    f.followUps.push(
+      `Could not ask the npm registry whether these declare a SvelteKit 2 peer: ${scan.unchecked.map(code).join(", ")}. If the install fails with an ERESOLVE naming one, add \`"overrides": { "<package>": { "@sveltejs/kit": "${kit}" } }\` to package.json.`
+    );
+  }
+  return f;
+}
 function depRange(data, name) {
   return data.devDependencies?.[name] ?? data.dependencies?.[name];
 }
 var STALE_LOCK_ENTRY = /(^|\/)node_modules\/(@sveltejs\/[^/]+|sveltekit-superforms|sveltekit-flash-message|formsnap|@velastack\/[^/]+|sveltekit-negotiate)$/;
 function lockfileFixup(root) {
   const f = fixup("package-lock.json");
-  const lockPath = path20.join(root, "package-lock.json");
-  if (!fs22.existsSync(lockPath)) {
+  const lockPath = path23.join(root, "package-lock.json");
+  if (!fs25.existsSync(lockPath)) {
     for (const other of ["pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"]) {
-      if (fs22.existsSync(path20.join(root, other))) {
+      if (fs25.existsSync(path23.join(root, other))) {
         f.warnings.push(
           `${other} still pins SvelteKit 2 packages; if the install fails, update @sveltejs/* with your package manager`
         );
@@ -4140,7 +4768,7 @@ function lockfileFixup(root) {
   }
   const { data, indent } = readJson(lockPath);
   const packages = data.packages;
-  const project = readJson(path20.join(root, "package.json")).data;
+  const project = readJson(path23.join(root, "package.json")).data;
   const lockedKit = packages?.["node_modules/@sveltejs/kit"]?.version;
   const kit2Lock = lockedKit !== void 0 && (minVersion(lockedKit)?.major ?? 0) < 3;
   const removed = [];
@@ -4172,19 +4800,24 @@ function belowFloor(project, key, entry) {
   return Boolean(floor && locked && compareVersions(locked, floor) < 0);
 }
 function readJson(file) {
-  const text19 = fs22.readFileSync(file, "utf8");
+  const text19 = fs25.readFileSync(file, "utf8");
   return {
     data: JSON.parse(text19),
     indent: text19.match(/^[{[]\s*\n([\t ]+)/)?.[1] ?? "	"
   };
 }
 function writeJson(file, data, indent) {
-  fs22.writeFileSync(file, `${JSON.stringify(data, null, indent)}
+  fs25.writeFileSync(file, `${JSON.stringify(data, null, indent)}
 `);
 }
 function collectFollowUps(root, sv) {
   const items = [];
-  const files = [...sourceFiles(path20.join(root, "src")), ...sourceFiles(path20.join(root, "test"))];
+  const files = [...sourceFiles(path23.join(root, "src")), ...sourceFiles(path23.join(root, "test"))];
+  for (const spread of sv.dropped) {
+    items.push(
+      `${code(spread.file)}: sv dropped ${code(spread.text)} when it moved the config into \`sveltekit({...})\` (it skips spread properties). Add it back there if it is still needed.`
+    );
+  }
   for (const failure of sv.failures) {
     if (failure.file) {
       items.push(
@@ -4197,8 +4830,8 @@ function collectFollowUps(root, sv) {
     }
   }
   for (const file of files) {
-    const source = fs22.readFileSync(file, "utf8");
-    const rel = path20.relative(root, file).split(path20.sep).join("/");
+    const source = fs25.readFileSync(file, "utf8");
+    const rel = path23.relative(root, file).split(path23.sep).join("/");
     const lines = source.split("\n");
     const locals = envImports(source).filter((i) => !i.local.includes(".")).map((i) => i.local);
     if (locals.length > 0) {
@@ -4212,23 +4845,36 @@ function collectFollowUps(root, sv) {
         );
       }
     }
-    for (const line of lines) {
+    lines.forEach((line, i) => {
+      const at = code(`${rel}:${i + 1}`);
       if (/data-sveltekit-(?:noscroll|keepfocus)\b|data-sveltekit-reset=["']false["']/.test(line)) {
         items.push(
-          `${code(rel)}: ${code(line.trim())}. \`data-sveltekit-noscroll\` and \`data-sveltekit-keepfocus\` are now one \`data-sveltekit-reset\` attribute; write \`data-sveltekit-reset={false}\`: svelte-check rejects the string \`"false"\`.`
+          `${at}: ${code(line.trim())}. \`data-sveltekit-noscroll\` and \`data-sveltekit-keepfocus\` are now one \`data-sveltekit-reset\` attribute; write \`data-sveltekit-reset={false}\`: svelte-check rejects the string \`"false"\`.`
         );
       }
       if (/(?<![\w$])ORIGIN(?![\w$])/.test(line) && !line.includes(MIGRATION_TASK_MARKER)) {
         items.push(
-          `${code(rel)}: ${code(line.trim())}. adapter-node 6 no longer reads \`ORIGIN\`; the origin comes from \`paths.origin\` (baked in at build time) or the request.`
+          `${at}: ${code(line.trim())}. adapter-node 6 no longer reads \`ORIGIN\`; the origin comes from \`paths.origin\` (baked in at build time) or the request.`
         );
       }
-    }
+    });
+  }
+  for (const file of textFiles(path23.join(root, "src"))) {
+    const rel = path23.relative(root, file).split(path23.sep).join("/");
+    const source = fs25.readFileSync(file, "utf8");
+    if (!source.includes("svelte.config.js")) continue;
+    source.split("\n").forEach((line, i) => {
+      if (!line.includes("svelte.config.js")) return;
+      const excerpt = line.trim().length > 100 ? `${line.trim().slice(0, 97)}...` : line.trim();
+      items.push(
+        `${code(`${rel}:${i + 1}`)}: ${code(excerpt)}. It names \`svelte.config.js\`, which a SvelteKit 3 project no longer has: the config is the \`sveltekit({...})\` argument in vite.config.`
+      );
+    });
   }
   const vite = inspectViteSveltekit(root);
   if (vite?.inlineArg) {
     const config = vite.inlineArg.getText();
-    const rel = path20.basename(vite.filePath);
+    const rel = path23.basename(vite.filePath);
     if (/\borigin\s*:\s*['"`]/.test(config)) {
       items.push(
         `\`${rel}\`: \`paths.origin\` is a literal. It is baked into the build, so every host serving this app gets that origin; leave it unset for a multi-host deploy (vela sets it from VELA_ORIGIN on single-host deploys).`
@@ -4242,11 +4888,22 @@ function collectFollowUps(root, sv) {
   }
   return items;
 }
-var SV_FAILURE_ITEM = /sv's `[^`]+` task (could not parse it|failed)/;
+var BINARY_EXTENSIONS = /\.(?:png|jpe?g|gif|webp|avif|ico|bmp|tiff?|woff2?|ttf|otf|eot|pdf|zip|gz|tgz|mp[34]|webm|mov|wav|ogg|wasm|db|sqlite3?)$/i;
+function textFiles(dir) {
+  if (!fs25.existsSync(dir)) return [];
+  return fs25.globSync("**/*", {
+    cwd: dir,
+    exclude: (name) => name === "node_modules" || name === ".svelte-kit"
+  }).filter((rel) => !BINARY_EXTENSIONS.test(rel)).map((rel) => path23.join(dir, rel)).filter((file) => {
+    const stat = fs25.statSync(file);
+    return stat.isFile() && stat.size < 2e6;
+  });
+}
+var SV_FAILURE_ITEM = /sv's `[^`]+` task (could not parse it|failed)|: sv dropped `/;
 function previousSvFollowUps(root) {
-  const file = path20.join(root, MIGRATION_TASKS_FILE);
-  if (!fs22.existsSync(file)) return [];
-  const content = fs22.readFileSync(file, "utf8");
+  const file = path23.join(root, MIGRATION_TASKS_FILE);
+  if (!fs25.existsSync(file)) return [];
+  const content = fs25.readFileSync(file, "utf8");
   const start = content.indexOf(FOLLOW_UPS_HEADING);
   if (start === -1) return [];
   const end = content.indexOf("\n## ", start + FOLLOW_UPS_HEADING.length);
@@ -4261,11 +4918,11 @@ function escape(text19) {
   return text19.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function writeFollowUps(root, items, generic) {
-  const file = path20.join(root, MIGRATION_TASKS_FILE);
-  const exists = fs22.existsSync(file);
+  const file = path23.join(root, MIGRATION_TASKS_FILE);
+  const exists = fs25.existsSync(file);
   const all = [...items, ...generic];
   if (!exists && items.length === 0) return;
-  const original = exists ? fs22.readFileSync(file, "utf8") : "# SvelteKit 3 migration tasks\n";
+  const original = exists ? fs25.readFileSync(file, "utf8") : "# SvelteKit 3 migration tasks\n";
   let content = original;
   const start = content.indexOf(FOLLOW_UPS_HEADING);
   if (start !== -1) {
@@ -4287,17 +4944,17 @@ function writeFollowUps(root, items, generic) {
 ${body}` : `${content.slice(0, final)}${body}
 ${content.slice(final)}`;
   }
-  if (content !== original) fs22.writeFileSync(file, content);
+  if (content !== original) fs25.writeFileSync(file, content);
 }
 function summarizeMigrationTasks(root) {
-  const file = path20.join(root, MIGRATION_TASKS_FILE);
+  const file = path23.join(root, MIGRATION_TASKS_FILE);
   const markerComments = countMarkers(root);
-  if (!fs22.existsSync(file))
+  if (!fs25.existsSync(file))
     return markerComments > 0 ? { sections: [], filesToReview: 0, markerComments } : null;
   const sections = [];
   let current = null;
   let inFiles = false;
-  for (const line of fs22.readFileSync(file, "utf8").split("\n")) {
+  for (const line of fs25.readFileSync(file, "utf8").split("\n")) {
     if (line.startsWith("## ")) {
       current = null;
       inFiles = false;
@@ -4317,13 +4974,13 @@ function summarizeMigrationTasks(root) {
 }
 function countMarkers(root) {
   let count = 0;
-  const files = [...sourceFiles(path20.join(root, "src")), ...sourceFiles(path20.join(root, "test"))];
-  for (const entry of fs22.readdirSync(root, { withFileTypes: true })) {
+  const files = [...sourceFiles(path23.join(root, "src")), ...sourceFiles(path23.join(root, "test"))];
+  for (const entry of fs25.readdirSync(root, { withFileTypes: true })) {
     if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name))
-      files.push(path20.join(root, entry.name));
+      files.push(path23.join(root, entry.name));
   }
   for (const file of files) {
-    count += fs22.readFileSync(file, "utf8").split(MIGRATION_TASK_MARKER).length - 1;
+    count += fs25.readFileSync(file, "utf8").split(MIGRATION_TASK_MARKER).length - 1;
   }
   return count;
 }
@@ -4332,18 +4989,18 @@ async function install(root) {
   return installDependencies(agent, root, { exitOnFailure: false });
 }
 async function formatProject(root) {
-  const bin = path20.join(root, "node_modules", ".bin", "prettier");
-  if (!fs22.existsSync(bin)) return;
+  const bin = path23.join(root, "node_modules", ".bin", "prettier");
+  if (!fs25.existsSync(bin)) return;
   await x2(bin, ["--write", "--ignore-unknown", "."], {
     nodeOptions: { cwd: root, stdio: "ignore" }
   });
 }
 async function formatChanged(root, dirtyBefore) {
-  const bin = path20.join(root, "node_modules", ".bin", "prettier");
+  const bin = path23.join(root, "node_modules", ".bin", "prettier");
   const changed = gitDirty(root);
-  if (!changed || !fs22.existsSync(bin)) return [];
+  if (!changed || !fs25.existsSync(bin)) return [];
   const files = changed.filter(
-    (f) => !dirtyBefore.has(f) && fs22.existsSync(path20.join(root, f)) && fs22.statSync(path20.join(root, f)).isFile()
+    (f) => !dirtyBefore.has(f) && fs25.existsSync(path23.join(root, f)) && fs25.statSync(path23.join(root, f)).isFile()
   );
   if (files.length === 0) return [];
   const result = await x2(bin, ["--write", "--ignore-unknown", ...files], {
@@ -4353,8 +5010,8 @@ async function formatChanged(root, dirtyBefore) {
 }
 
 // src/lib/kit3-template-support.ts
-import fs23 from "node:fs";
-import path21 from "node:path";
+import fs26 from "node:fs";
+import path24 from "node:path";
 var CMS = "@velastack/cms";
 var REPEATER_REMOVED_IN = { major: 0, minor: 5, patch: 0, prerelease: [] };
 var SOURCE_FILE = /\.(svelte|svx|md|[cm]?[jt]s)$/;
@@ -4381,11 +5038,11 @@ Pick another template, or create the SvelteKit 2 version with
 }
 function cmsRange(dir) {
   for (const file of ["package.template.json", "package.json"]) {
-    const pkgPath = path21.join(dir, file);
-    if (!fs23.existsSync(pkgPath)) continue;
+    const pkgPath = path24.join(dir, file);
+    if (!fs26.existsSync(pkgPath)) continue;
     let pkg;
     try {
-      pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf8"));
+      pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf8"));
     } catch {
       return void 0;
     }
@@ -4394,15 +5051,15 @@ function cmsRange(dir) {
   return void 0;
 }
 function findRepeaterImport(dir) {
-  const src = path21.join(dir, "src");
-  if (!fs23.existsSync(src)) return void 0;
-  const entries = fs23.readdirSync(src, { recursive: true, withFileTypes: true });
+  const src = path24.join(dir, "src");
+  if (!fs26.existsSync(src)) return void 0;
+  const entries = fs26.readdirSync(src, { recursive: true, withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile() || !SOURCE_FILE.test(entry.name)) continue;
-    const file = path21.join(entry.parentPath, entry.name);
-    const text19 = fs23.readFileSync(file, "utf8");
+    const file = path24.join(entry.parentPath, entry.name);
+    const text19 = fs26.readFileSync(file, "utf8");
     if (text19.includes("CmsRepeater") && REPEATER_IMPORT.test(text19)) {
-      return path21.relative(dir, file);
+      return path24.relative(dir, file);
     }
   }
   return void 0;
@@ -4461,15 +5118,15 @@ 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: packageManager2, installed, migrated, name, template, link: link2 } = await createProject2(projectPath, options, listing);
-    const relative = path22.relative(process13.cwd(), directory);
+    const { directory, packageManager: packageManager2, installed: installed2, migrated, name, template, link: link2 } = await createProject2(projectPath, options, listing);
+    const relative = path25.relative(process13.cwd(), directory);
     const pm = packageManager2 ?? (await detect4({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
     const nextSteps = [];
     if (relative !== "") {
       const hasSpaces = relative.includes(" ");
       nextSteps.push(`\`cd ${hasSpaces ? `"${relative}"` : relative}\``);
     }
-    if (!installed) {
+    if (!installed2) {
       const resolved = resolveCommand3(pm, "install", []);
       if (resolved) {
         nextSteps.push(
@@ -4524,7 +5181,7 @@ async function createProject2(cwdArg, options, listing) {
     resolved.cleanup();
   }
   const { directory: projectPath, name, credentials, link: link2 } = scaffolded;
-  if (!fs24.existsSync(path22.join(projectPath, "package.json"))) {
+  if (!fs27.existsSync(path25.join(projectPath, "package.json"))) {
     throw new Error(`Template ${template.name} is missing package.template.json`);
   }
   if (link2.linked) {
@@ -4534,14 +5191,14 @@ async function createProject2(cwdArg, options, listing) {
   const migrated = await migrateKit2Template(projectPath, template.name);
   p10.log.success("Project created");
   let packageManager2;
-  let installed = false;
+  let installed2 = false;
   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);
-      installed = await installDependencies(pm, projectPath);
-      if (migrated && installed) await formatProject(projectPath);
+      installed2 = await installDependencies(pm, projectPath);
+      if (migrated && installed2) await formatProject(projectPath);
       packageManager2 = pm;
     }
   }
@@ -4568,7 +5225,7 @@ async function createProject2(cwdArg, options, listing) {
     );
     p10.log.success("PocketBase initialized");
   }
-  return { directory: projectPath, packageManager: packageManager2, installed, migrated, name, template, link: link2 };
+  return { directory: projectPath, packageManager: packageManager2, installed: installed2, migrated, name, template, link: link2 };
 }
 async function resolveCreatableTemplate(template) {
   if (template.source === "remote") p10.log.step(`Downloading template ${template.name}...`);
@@ -4583,7 +5240,7 @@ async function resolveCreatableTemplate(template) {
 async function scaffoldProject(cwdArg, options, template, resolved, onCancel2) {
   let directory;
   if (cwdArg) {
-    directory = path22.resolve(cwdArg);
+    directory = path25.resolve(cwdArg);
   } else {
     const answer = await p10.text({
       message: "Where would you like your project to be created?",
@@ -4591,16 +5248,16 @@ async function scaffoldProject(cwdArg, options, template, resolved, onCancel2) {
       defaultValue: "./"
     });
     if (p10.isCancel(answer)) onCancel2();
-    directory = path22.resolve(answer);
+    directory = path25.resolve(answer);
   }
-  if (fs24.existsSync(directory) && fs24.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
+  if (fs27.existsSync(directory) && fs27.readdirSync(directory).filter((f) => !f.startsWith(".git")).length > 0) {
     const force = await p10.confirm({
       message: "Directory not empty. Continue?",
       initialValue: false
     });
     if (p10.isCancel(force) || !force) onCancel2();
   }
-  const dirName = path22.basename(directory);
+  const dirName = path25.basename(directory);
   const { name } = await p10.group(
     {
       name: () => {
@@ -4634,7 +5291,7 @@ async function migrateKit2Template(projectPath, templateName2) {
   try {
     result = await runKit3Migration(projectPath, { gitCheck: false, install: false, quiet: true });
   } catch (e) {
-    const relative = path22.relative(process13.cwd(), projectPath) || ".";
+    const relative = path25.relative(process13.cwd(), projectPath) || ".";
     throw new Error(
       `Could not migrate template ${templateName2} to SvelteKit 3: ${e.message}
 
@@ -4645,11 +5302,11 @@ The project is in ${projectPath}. Finish the migration by hand with
     );
   }
   const tasks = result.tasks;
-  const tasksFile = path22.join(projectPath, MIGRATION_TASKS_FILE);
-  if (fs24.existsSync(tasksFile) && !tasks?.filesToReview && result.followUps.length === 0) {
-    fs24.rmSync(tasksFile);
+  const tasksFile = path25.join(projectPath, MIGRATION_TASKS_FILE);
+  if (fs27.existsSync(tasksFile) && !tasks?.filesToReview && result.followUps.length === 0) {
+    fs27.rmSync(tasksFile);
   }
-  const left = fs24.existsSync(tasksFile);
+  const left = fs27.existsSync(tasksFile);
   p10.log.success(
     `Migrated to SvelteKit 3${left ? `; ${MIGRATION_TASKS_FILE} lists what to check by hand` : ""}.`
   );
@@ -4743,7 +5400,7 @@ ${FREE_CMS_HINT}.`, "CMS");
 }
 function hasScript(directory, name) {
   try {
-    const pkg = JSON.parse(fs24.readFileSync(path22.join(directory, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs27.readFileSync(path25.join(directory, "package.json"), "utf8"));
     return typeof pkg.scripts?.[name] === "string";
   } catch {
     return false;
@@ -4758,7 +5415,7 @@ import { Command as Command4 } from "commander";
 import * as p16 from "@clack/prompts";
 
 // src/lib/pattern-runner.ts
-import path23 from "node:path";
+import path26 from "node:path";
 import * as p11 from "@clack/prompts";
 import { bySlug as bySlug2 } from "@velastack/patterns";
 
@@ -4777,7 +5434,7 @@ Then run this again.`
 
 // src/lib/pattern-runner.ts
 function toRelative(root, filePath) {
-  return path23.isAbsolute(filePath) ? path23.relative(root, filePath) : filePath;
+  return path26.isAbsolute(filePath) ? path26.relative(root, filePath) : filePath;
 }
 var isSuccess = (f) => (f.status ?? "success") === "success";
 async function runPattern(slug2, argv, input, report4, after) {
@@ -4859,10 +5516,10 @@ async function runPattern(slug2, argv, input, report4, after) {
 }
 
 // src/lib/form-ui.ts
-import path24 from "node:path";
+import path27 from "node:path";
 var UIS = ["shadcn", "plain"];
 function detectFormInput(root) {
-  const pkg = readPackageJson(path24.join(root, "package.json"));
+  const pkg = readPackageJson(path27.join(root, "package.json"));
   const hasDep = (name) => Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
   return {
     flash: hasDep("sveltekit-flash-message"),
@@ -4884,8 +5541,8 @@ function resolveFormInput(root, detectedUi, requested) {
 }
 
 // src/lib/ai-flow.ts
-import fs25 from "node:fs";
-import path25 from "node:path";
+import fs28 from "node:fs";
+import path28 from "node:path";
 import * as p15 from "@clack/prompts";
 import pc4 from "picocolors";
 
@@ -5160,15 +5817,15 @@ function specToArgv(spec) {
   return collectionSpecToArgv(spec);
 }
 function writeLayoutSidecar(workspaceRootDir, modelName, layout) {
-  const dir = path25.join(
+  const dir = path28.join(
     workspaceRootDir,
     hasBackend(workspaceRootDir) ? DATA_DIR : ".vela",
     "ai-form-layouts"
   );
-  fs25.mkdirSync(dir, { recursive: true });
-  const file = path25.join(dir, `${modelName}.json`);
-  fs25.writeFileSync(file, JSON.stringify(layout, null, 2) + "\n");
-  return path25.relative(workspaceRootDir, file);
+  fs28.mkdirSync(dir, { recursive: true });
+  const file = path28.join(dir, `${modelName}.json`);
+  fs28.writeFileSync(file, JSON.stringify(layout, null, 2) + "\n");
+  return path28.relative(workspaceRootDir, file);
 }
 
 // src/commands/generate/form.ts
@@ -5890,8 +6547,8 @@ import * as p21 from "@clack/prompts";
 import pc6 from "picocolors";
 
 // src/lib/deploy-config.ts
-import fs26 from "node:fs";
-import path26 from "node:path";
+import fs29 from "node:fs";
+import path29 from "node:path";
 import crypto from "node:crypto";
 import { pathToFileURL } from "node:url";
 var CONFIG_BASENAMES = [
@@ -5902,8 +6559,8 @@ var CONFIG_BASENAMES = [
 ];
 function findConfigFile(workspaceRootDir) {
   for (const name of CONFIG_BASENAMES) {
-    const file = path26.join(workspaceRootDir, name);
-    if (fs26.existsSync(file)) return file;
+    const file = path29.join(workspaceRootDir, name);
+    if (fs29.existsSync(file)) return file;
   }
   return null;
 }
@@ -5911,49 +6568,49 @@ async function loadDeployConfig(workspaceRootDir) {
   const file = findConfigFile(workspaceRootDir);
   if (!file) return {};
   if (file.endsWith(".json")) {
-    return JSON.parse(fs26.readFileSync(file, "utf8"));
+    return JSON.parse(fs29.readFileSync(file, "utf8"));
   }
   const url = file.endsWith(".ts") ? await transpileToTemp(file) : pathToFileURL(file).href;
   try {
     const mod = await import(url);
     const config = mod.default;
     if (!config || typeof config !== "object") {
-      throw new Error(`${path26.basename(file)} must export a config object as its default export.`);
+      throw new Error(`${path29.basename(file)} must export a config object as its default export.`);
     }
     return config;
   } finally {
-    if (url !== pathToFileURL(file).href) fs26.rmSync(new URL(url), { force: true });
+    if (url !== pathToFileURL(file).href) fs29.rmSync(new URL(url), { force: true });
   }
 }
 async function transpileToTemp(file) {
   const { ts: ts2 } = await import("ts-morph");
-  const source = fs26.readFileSync(file, "utf8");
+  const source = fs29.readFileSync(file, "utf8");
   const { outputText } = ts2.transpileModule(source, {
     compilerOptions: { module: ts2.ModuleKind.ESNext, target: ts2.ScriptTarget.ES2022 }
   });
-  const temp = path26.join(
-    path26.dirname(file),
+  const temp = path29.join(
+    path29.dirname(file),
     `.velastack.config.${crypto.randomBytes(4).toString("hex")}.mjs`
   );
-  fs26.writeFileSync(temp, outputText);
+  fs29.writeFileSync(temp, outputText);
   return pathToFileURL(temp).href;
 }
 function projectFilePath(workspaceRootDir) {
-  return path26.join(workspaceRootDir, ".vela", "project.json");
+  return path29.join(workspaceRootDir, ".vela", "project.json");
 }
 function readProjectFile(workspaceRootDir) {
   const file = projectFilePath(workspaceRootDir);
-  if (!fs26.existsSync(file)) return {};
+  if (!fs29.existsSync(file)) return {};
   try {
-    return JSON.parse(fs26.readFileSync(file, "utf8"));
+    return JSON.parse(fs29.readFileSync(file, "utf8"));
   } catch {
     return {};
   }
 }
 function writeProjectFile(workspaceRootDir, data) {
   const file = projectFilePath(workspaceRootDir);
-  fs26.mkdirSync(path26.dirname(file), { recursive: true });
-  fs26.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+  fs29.mkdirSync(path29.dirname(file), { recursive: true });
+  fs29.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
 }
 function resolveAppIdentity(workspaceRootDir, config = {}) {
   const project = readProjectFile(workspaceRootDir);
@@ -5978,11 +6635,11 @@ function readAppIdentity(workspaceRootDir, config = {}) {
 }
 function defaultProjectName(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path26.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path29.join(workspaceRootDir, "package.json"));
     if (typeof pkg.name === "string" && pkg.name.trim()) return pkg.name.trim();
   } catch {
   }
-  return path26.basename(workspaceRootDir);
+  return path29.basename(workspaceRootDir);
 }
 function slug(value) {
   return value.toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "app";
@@ -6053,15 +6710,15 @@ function randomSuffix() {
 }
 
 // src/lib/artifact.ts
-import fs28 from "node:fs";
-import path28 from "node:path";
+import fs31 from "node:fs";
+import path31 from "node:path";
 import { detect as detect5 } from "package-manager-detector";
 import { resolveCommand as resolveCommand4 } from "package-manager-detector/commands";
 
 // src/lib/ssh.ts
-import fs27 from "node:fs";
+import fs30 from "node:fs";
 import os4 from "node:os";
-import path27 from "node:path";
+import path30 from "node:path";
 import crypto3 from "node:crypto";
 import process16 from "node:process";
 import { spawn as spawn3 } from "node:child_process";
@@ -6104,9 +6761,9 @@ var SshSession = class {
   }
   async open() {
     if (this.controlPath) return;
-    const dir = path27.join(os4.tmpdir(), "vela-ssh");
-    fs27.mkdirSync(dir, { recursive: true, mode: 448 });
-    const socket = path27.join(dir, `${crypto3.randomBytes(6).toString("hex")}.sock`);
+    const dir = path30.join(os4.tmpdir(), "vela-ssh");
+    fs30.mkdirSync(dir, { recursive: true, mode: 448 });
+    const socket = path30.join(dir, `${crypto3.randomBytes(6).toString("hex")}.sock`);
     this.controlPath = socket;
     const args = [
       ...this.sshArgs(),
@@ -6396,11 +7053,11 @@ function collectArtifact(cwd, config = {}) {
   const outputDir = config.outputDir ?? DEFAULT_OUTPUT_DIR;
   const entries = [];
   const add2 = (rel, remoteDir = "") => {
-    const localPath = path28.join(cwd, rel);
-    if (fs28.existsSync(localPath)) entries.push({ localPath, remoteDir });
+    const localPath = path31.join(cwd, rel);
+    if (fs31.existsSync(localPath)) entries.push({ localPath, remoteDir });
   };
-  const buildPath = path28.join(cwd, outputDir);
-  if (!fs28.existsSync(path28.join(buildPath, "index.js"))) {
+  const buildPath = path31.join(cwd, outputDir);
+  if (!fs31.existsSync(path31.join(buildPath, "index.js"))) {
     throw new BuildError(
       `No ${outputDir}/index.js to deploy.
 
@@ -6414,19 +7071,19 @@ matches where it writes), then deploy again.`
   for (const lockfile of [NPM_LOCKFILE, ...FOREIGN_LOCKFILES]) add2(lockfile);
   add2(".npmrc");
   add2(MIGRATIONS_DIR);
-  const hooks = path28.join(cwd, DATA_DIR, "hooks");
-  if (fs28.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
+  const hooks = path31.join(cwd, DATA_DIR, "hooks");
+  if (fs31.existsSync(hooks)) entries.push({ localPath: hooks, remoteDir: "hooks" });
   for (const extra of config.include ?? []) add2(extra);
   return entries;
 }
 var NPM_LOCKFILE = "package-lock.json";
 var FOREIGN_LOCKFILES = ["pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
 function hasLockfile(cwd) {
-  return fs28.existsSync(path28.join(cwd, NPM_LOCKFILE));
+  return fs31.existsSync(path31.join(cwd, NPM_LOCKFILE));
 }
 function foreignLockfile(cwd) {
   if (hasLockfile(cwd)) return void 0;
-  return FOREIGN_LOCKFILES.find((name) => fs28.existsSync(path28.join(cwd, name)));
+  return FOREIGN_LOCKFILES.find((name) => fs31.existsSync(path31.join(cwd, name)));
 }
 async function gitSha(cwd) {
   const result = await spawnCapture("git", ["rev-parse", "HEAD"], { cwd });
@@ -6465,8 +7122,8 @@ function sshOptionsFrom(options) {
 
 // src/lib/remote.ts
 import crypto4 from "node:crypto";
-import fs29 from "node:fs";
-import path29 from "node:path";
+import fs32 from "node:fs";
+import path32 from "node:path";
 import process17 from "node:process";
 var VELA_ROOT = "/var/lib/vela";
 var VELA_ETC = "/etc/vela";
@@ -6479,19 +7136,19 @@ function instanceHasBackend(state) {
   return state.backend ?? Boolean(state.pbPort);
 }
 function serverTemplatesDir() {
-  return path29.join(templatesDir(), "server");
+  return path32.join(templatesDir(), "server");
 }
 var DIGEST_LENGTH = 12;
 function serverScriptsDigest(dir = serverTemplatesDir()) {
   const hash = crypto4.createHash("sha256");
   for (const file of listFiles(dir).sort()) {
-    hash.update(file).update("\0").update(fs29.readFileSync(path29.join(dir, file))).update("\0");
+    hash.update(file).update("\0").update(fs32.readFileSync(path32.join(dir, file))).update("\0");
   }
   return hash.digest("hex").slice(0, DIGEST_LENGTH);
 }
 function listFiles(root, prefix = "") {
   const files = [];
-  for (const entry of fs29.readdirSync(path29.join(root, prefix), { withFileTypes: true })) {
+  for (const entry of fs32.readdirSync(path32.join(root, prefix), { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) files.push(...listFiles(root, rel));
     else if (entry.isFile()) files.push(rel);
@@ -6610,7 +7267,7 @@ var remotePaths = {
 };
 
 // src/lib/remote-env.ts
-import fs30 from "node:fs";
+import fs33 from "node:fs";
 import dotenv from "dotenv";
 var KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function isValidKey(key) {
@@ -6658,7 +7315,7 @@ function quote(value) {
   return `"${escaped}"`;
 }
 function readLocalEnvFile(file) {
-  const parsed = dotenv.parse(fs30.readFileSync(file));
+  const parsed = dotenv.parse(fs33.readFileSync(file));
   const result = {};
   for (const [key, value] of Object.entries(parsed)) {
     if (isValidKey(key)) result[key] = value;
@@ -6984,17 +7641,17 @@ function envFilePath(workspaceRootDir) {
 import pc8 from "picocolors";
 
 // src/lib/local-env.ts
-import fs31 from "node:fs";
+import fs34 from "node:fs";
 import * as p22 from "@clack/prompts";
 import pc7 from "picocolors";
 function readLocalEnv(envFile) {
-  if (!fs31.existsSync(envFile)) return {};
+  if (!fs34.existsSync(envFile)) return {};
   return readLocalEnvFile(envFile);
 }
 function editLocalEnv(envFile, edit) {
-  const before = fs31.existsSync(envFile) ? fs31.readFileSync(envFile, "utf8") : "";
+  const before = fs34.existsSync(envFile) ? fs34.readFileSync(envFile, "utf8") : "";
   const after = edit(before);
-  if (after !== before) fs31.writeFileSync(envFile, after);
+  if (after !== before) fs34.writeFileSync(envFile, after);
 }
 function setLocalEnv(envFile, key, value) {
   editLocalEnv(envFile, (content) => upsertEnvVar(content, key, value));
@@ -7131,8 +7788,8 @@ Set ${pc8.cyan("POCKETBASE_SUPERUSER_EMAIL")} and ${pc8.cyan("POCKETBASE_SUPERUS
 }
 
 // src/lib/s3-settings.ts
-import fs32 from "node:fs";
-import path30 from "node:path";
+import fs35 from "node:fs";
+import path33 from "node:path";
 var VIRTUAL_HOSTED = [/\.amazonaws\.com$/i, /\.r2\.cloudflarestorage\.com$/i];
 function defaultForcePathStyle(endpoint) {
   let host;
@@ -7170,18 +7827,18 @@ async function hasLocalUploads(session, instance, workspaceRootDir) {
     });
     return result.stdout.trim().length > 0;
   }
-  return hasFile(path30.join(workspaceRootDir, DATA_DIR, "storage"));
+  return hasFile(path33.join(workspaceRootDir, DATA_DIR, "storage"));
 }
 function hasFile(dir) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir, { withFileTypes: true });
+    entries = fs35.readdirSync(dir, { withFileTypes: true });
   } catch {
     return false;
   }
   for (const entry of entries) {
     if (entry.isFile()) return true;
-    if (entry.isDirectory() && hasFile(path30.join(dir, entry.name))) return true;
+    if (entry.isDirectory() && hasFile(path33.join(dir, entry.name))) return true;
   }
   return false;
 }
@@ -7356,10 +8013,10 @@ import * as p25 from "@clack/prompts";
 import pc10 from "picocolors";
 
 // src/lib/adapter.ts
-import fs33 from "node:fs";
-import path31 from "node:path";
+import fs36 from "node:fs";
+import path34 from "node:path";
 import {
-  SyntaxKind as SyntaxKind3
+  SyntaxKind as SyntaxKind4
 } from "ts-morph";
 import { detect as detect6 } from "package-manager-detector";
 var ADAPTER_NODE2 = "@sveltejs/adapter-node";
@@ -7382,7 +8039,7 @@ function resolveKitTarget(root) {
   const svelteConfig = findSvelteConfig(root);
   if (svelteConfig) {
     throw new AdapterError(
-      `${path31.basename(svelteConfig)} found: this looks like a SvelteKit 2 project, and
+      `${path34.basename(svelteConfig)} found: this looks like a SvelteKit 2 project, and
 SvelteKit 3 reads its config only from sveltekit({...}) in vite.config.
 
 Migrate it first:`,
@@ -7400,7 +8057,7 @@ Migrate it first:`,
     };
   }
   if (vite?.sveltekitCall) {
-    const name = path31.basename(vite.filePath);
+    const name = path34.basename(vite.filePath);
     if (vite.nonObjectArg) {
       throw new AdapterError(`${name} passes sveltekit() something other than an object literal.`);
     }
@@ -7431,15 +8088,15 @@ function inspectAdapter(target) {
   const base2 = { file: target.filePath };
   const prop = target.kit.getProperty("adapter");
   if (!prop) return { info: { ...base2, kind: "none" } };
-  if (prop.getKind() !== SyntaxKind3.PropertyAssignment) {
+  if (prop.getKind() !== SyntaxKind4.PropertyAssignment) {
     return { info: { ...base2, kind: "other" } };
   }
-  const init = prop.asKindOrThrow(SyntaxKind3.PropertyAssignment).getInitializer();
-  if (!init || init.getKind() !== SyntaxKind3.CallExpression) {
+  const init = prop.asKindOrThrow(SyntaxKind4.PropertyAssignment).getInitializer();
+  if (!init || init.getKind() !== SyntaxKind4.CallExpression) {
     return { info: { ...base2, kind: "other" } };
   }
-  const callee = init.asKindOrThrow(SyntaxKind3.CallExpression).getExpression();
-  if (callee.getKind() !== SyntaxKind3.Identifier) {
+  const callee = init.asKindOrThrow(SyntaxKind4.CallExpression).getExpression();
+  if (callee.getKind() !== SyntaxKind4.Identifier) {
     return { info: { ...base2, kind: "other" } };
   }
   const importDecl = importOf(target.sourceFile, callee.getText());
@@ -7453,7 +8110,7 @@ function detectAdapter(root) {
 async function ensureNodeAdapter(root, { install: install2 = true } = {}) {
   const target = resolveKitTarget(root);
   const { info, importDecl } = inspectAdapter(target);
-  const name = path31.basename(target.filePath);
+  const name = path34.basename(target.filePath);
   const outcome = {
     previous: info.kind,
     removedDeps: [],
@@ -7486,8 +8143,8 @@ vela deploy runs the app as a Node server, which needs ${ADAPTER_NODE2}:`
       break;
   }
   if (outcome.configFile) saveTarget(target);
-  const pkgPath = path31.join(root, "package.json");
-  if (fs33.existsSync(pkgPath)) {
+  const pkgPath = path34.join(root, "package.json");
+  if (fs36.existsSync(pkgPath)) {
     const pkg = readPackageJson(pkgPath);
     const { changed, removed } = adoptNodeAdapter(pkg);
     if (changed) {
@@ -7524,8 +8181,8 @@ The config and package.json are already updated: run \`${agent} install\`, then
 }
 function switchImport(target, importDecl) {
   importDecl.setModuleSpecifier(ADAPTER_NODE2);
-  const prop = target.kit.getPropertyOrThrow("adapter").asKindOrThrow(SyntaxKind3.PropertyAssignment);
-  const call = prop.getInitializerIfKindOrThrow(SyntaxKind3.CallExpression);
+  const prop = target.kit.getPropertyOrThrow("adapter").asKindOrThrow(SyntaxKind4.PropertyAssignment);
+  const call = prop.getInitializerIfKindOrThrow(SyntaxKind4.CallExpression);
   for (let i = call.getArguments().length - 1; i >= 0; i--) call.removeArgument(i);
   dropAdapterAutoComments(target);
 }
@@ -7547,7 +8204,7 @@ function addAdapter(target) {
   const taken = importOf(target.sourceFile, "adapter") ?? target.sourceFile.getVariableDeclaration("adapter");
   if (taken) {
     throw new AdapterError(
-      `${path31.basename(target.filePath)} already binds the name \`adapter\` to something that is not the SvelteKit adapter.`
+      `${path34.basename(target.filePath)} already binds the name \`adapter\` to something that is not the SvelteKit adapter.`
     );
   }
   target.sourceFile.addImportDeclaration({
@@ -8531,10 +9188,10 @@ var NEXT_STEPS = [
   `Run \`vela ui base <color>\` to change the palette (${BASE_COLORS.join(", ")}), or \`vela ui list\` to see what else is available.`
 ];
 function uiAddReport(requested, outcome) {
-  const { installed, skipped, packages } = outcome;
+  const { installed: installed2, skipped, packages } = outcome;
   const report4 = {
-    summary: installed.length > 0 ? `Added ${installed.length} UI component(s).` : `All ${new Set(requested).size} requested component(s) are already present.`,
-    componentsAdded: installed,
+    summary: installed2.length > 0 ? `Added ${installed2.length} UI component(s).` : `All ${new Set(requested).size} requested component(s) are already present.`,
+    componentsAdded: installed2,
     packagesInstalled: packages,
     nextSteps: [...NEXT_STEPS]
   };
@@ -8606,13 +9263,13 @@ import { listComponents } from "@velastack/patterns";
 
 // src/lib/ui-list.ts
 function uiListReport(result) {
-  const installed = new Set(result.installed);
+  const installed2 = new Set(result.installed);
   const registryUi = result.registry.filter((item) => item.type === "registry:ui").map((item) => item.name).sort();
   const sections = [
     { label: `Installed (${result.installed.length})`, items: result.installed },
     {
       label: "Vela components",
-      items: result.custom.map((name) => installed.has(name) ? `${name} (installed)` : name)
+      items: result.custom.map((name) => installed2.has(name) ? `${name} (installed)` : name)
     }
   ];
   if (!result.registryUnavailable) {
@@ -8776,14 +9433,14 @@ var ui = new Command55("ui").description("generate ui components").configureHelp
 import { Command as Command58 } from "commander";
 
 // src/commands/legal/terms.ts
-import path33 from "node:path";
+import path36 from "node:path";
 import { Command as Command56 } from "commander";
 import * as p38 from "@clack/prompts";
 
 // src/commands/legal/shared.ts
 import process26 from "node:process";
-import fs34 from "node:fs";
-import path32 from "node:path";
+import fs37 from "node:fs";
+import path35 from "node:path";
 import * as p37 from "@clack/prompts";
 function siteFields(site) {
   const url = site?.url && !isLocalUrl(site.url) ? site.url : void 0;
@@ -9065,16 +9722,16 @@ function writeLegalPage(root, dir, page) {
 
 ${html}`;
   }
-  const pagePath = path32.join(root, dir, "+page.svelte");
-  fs34.mkdirSync(path32.dirname(pagePath), { recursive: true });
-  fs34.writeFileSync(pagePath, html);
+  const pagePath = path35.join(root, dir, "+page.svelte");
+  fs37.mkdirSync(path35.dirname(pagePath), { recursive: true });
+  fs37.writeFileSync(pagePath, html);
   const written = [pagePath];
   if (metaTags) {
-    const loaderPath = path32.join(root, dir, "+page.ts");
-    fs34.writeFileSync(loaderPath, pageMetaTagsLoader(page.title, page.description));
+    const loaderPath = path35.join(root, dir, "+page.ts");
+    fs37.writeFileSync(loaderPath, pageMetaTagsLoader(page.title, page.description));
     written.push(loaderPath);
   }
-  return written.map((file) => path32.relative(root, file));
+  return written.map((file) => path35.relative(root, file));
 }
 
 // src/commands/legal/terms.ts
@@ -9471,7 +10128,7 @@ async function termsAction() {
   });
   const [relativeTermsPage, ...rest] = writeLegalPage(
     workspaceRootDir,
-    path33.join(publicRoutesDir, LEGAL_DIR, "terms"),
+    path36.join(publicRoutesDir, LEGAL_DIR, "terms"),
     {
       html,
       title: "Terms of Service",
@@ -9491,7 +10148,7 @@ async function termsAction() {
 var terms = new Command56("terms").description("generate placeholder terms and conditions").configureHelp(helpConfig).action(() => runCommand(termsAction, "Failed to generate terms and conditions."));
 
 // src/commands/legal/privacy.ts
-import path34 from "node:path";
+import path37 from "node:path";
 import { Command as Command57 } from "commander";
 import * as p39 from "@clack/prompts";
 var mapLabels = {
@@ -10207,7 +10864,7 @@ async function privacyAction() {
   });
   const [relativePrivacyPage, ...rest] = writeLegalPage(
     workspaceRootDir,
-    path34.join(publicRoutesDir, LEGAL_DIR, "privacy"),
+    path37.join(publicRoutesDir, LEGAL_DIR, "privacy"),
     {
       html,
       title: "Privacy Policy",
@@ -10236,8 +10893,8 @@ import { Command as Command64 } from "commander";
 import { Command as Command59 } from "commander";
 
 // src/lib/data.ts
-import fs35 from "node:fs";
-import path35 from "node:path";
+import fs38 from "node:fs";
+import path38 from "node:path";
 import { ClientResponseError } from "pocketbase";
 
 // src/lib/collections.ts
@@ -10274,14 +10931,14 @@ function dependencyOrder(collections2, startingCollectionId) {
 
 // src/lib/data.ts
 function dataDir(cwd, kind) {
-  return path35.join(cwd, DATA_DIR, kind);
+  return path38.join(cwd, DATA_DIR, kind);
 }
 function getDataFiles(cwd, kind) {
   const dir = dataDir(cwd, kind);
-  if (!fs35.existsSync(dir)) return [];
-  return fs35.readdirSync(dir).filter((file) => file.endsWith(".json")).sort((a, b) => a.localeCompare(b)).map((file) => ({
+  if (!fs38.existsSync(dir)) return [];
+  return fs38.readdirSync(dir).filter((file) => file.endsWith(".json")).sort((a, b) => a.localeCompare(b)).map((file) => ({
     collectionName: file.replace(/\.json$/i, "").replace(/^\d+[-_]?/, ""),
-    filePath: path35.join(dir, file)
+    filePath: path38.join(dir, file)
   }));
 }
 function getSeedFiles(cwd) {
@@ -10291,7 +10948,7 @@ function getFixtureFiles(cwd) {
   return getDataFiles(cwd, "fixtures");
 }
 function readRecords(filePath) {
-  return JSON.parse(fs35.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs38.readFileSync(filePath, "utf8"));
 }
 function readSeedIds(cwd) {
   const ids = /* @__PURE__ */ new Map();
@@ -10328,7 +10985,7 @@ function describeError(e) {
   return e instanceof Error ? e.message : String(e);
 }
 function label3(cwd, filePath, count) {
-  return `${path35.relative(cwd, filePath)} (${count} records)`;
+  return `${path38.relative(cwd, filePath)} (${count} records)`;
 }
 async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
   const records = readRecords(filePath);
@@ -10336,7 +10993,7 @@ async function createRecords(pb, kind, cwd, { collectionName, filePath }) {
     try {
       await pb.collection(collectionName).create(record);
     } catch (e) {
-      throw new DataLoadError(kind, path35.relative(cwd, filePath), index, e);
+      throw new DataLoadError(kind, path38.relative(cwd, filePath), index, e);
     }
   }
   return records.length;
@@ -10510,8 +11167,8 @@ var reset = new Command61("reset").description("clear and reload fixtures").conf
 );
 
 // src/commands/fixtures/generate.ts
-import fs36 from "node:fs";
-import path36 from "node:path";
+import fs39 from "node:fs";
+import path39 from "node:path";
 import { Command as Command62, InvalidArgumentError } from "commander";
 import * as p40 from "@clack/prompts";
 import { annotate } from "annotate-json-schema";
@@ -10548,9 +11205,9 @@ async function loadCollections(pb) {
 }
 async function generateFixtureFiles(pb, workspaceRootDir, opts) {
   const fixturesDir = dataDir(workspaceRootDir, "fixtures");
-  fs36.mkdirSync(fixturesDir, { recursive: true });
-  for (const file of fs36.readdirSync(fixturesDir)) {
-    if (file.endsWith(".json")) fs36.unlinkSync(path36.join(fixturesDir, file));
+  fs39.mkdirSync(fixturesDir, { recursive: true });
+  for (const file of fs39.readdirSync(fixturesDir)) {
+    if (file.endsWith(".json")) fs39.unlinkSync(path39.join(fixturesDir, file));
   }
   if (opts.seed !== void 0) faker.seed(opts.seed);
   const generator = createGenerator({
@@ -10617,8 +11274,8 @@ async function generateFixtureFiles(pb, workspaceRootDir, opts) {
       items.push(record);
     }
     const filename = `${padZeros(fileIndex, 2)}-${collection.name}.json`;
-    fs36.writeFileSync(path36.join(fixturesDir, filename), JSON.stringify(items, null, 2));
-    writtenFiles.push(`${path36.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
+    fs39.writeFileSync(path39.join(fixturesDir, filename), JSON.stringify(items, null, 2));
+    writtenFiles.push(`${path39.join(DATA_DIR, "fixtures", filename)} (${items.length} records)`);
     fileIndex++;
   }
   return { writtenFiles, warnings };
@@ -10765,8 +11422,8 @@ var load2 = new Command65("load").description("load seeds into the database").op
 );
 
 // src/commands/seeds/save.ts
-import fs37 from "node:fs";
-import path37 from "node:path";
+import fs40 from "node:fs";
+import path40 from "node:path";
 import { Command as Command66 } from "commander";
 var padZeros2 = (num, length) => num.toString().padStart(length, "0");
 function filterSystemFields(record, systemFieldNames) {
@@ -10786,10 +11443,10 @@ var save = new Command66("save").description("save the current data as seeds").o
     if (existing.length > 0 && !opts.force) {
       throw new Error("Existing seed files found in data/seeds. Pass --force to overwrite.");
     }
-    fs37.mkdirSync(seedsPath, { recursive: true });
+    fs40.mkdirSync(seedsPath, { recursive: true });
     if (opts.force) {
-      for (const file of fs37.readdirSync(seedsPath)) {
-        if (file.endsWith(".json")) fs37.unlinkSync(path37.join(seedsPath, file));
+      for (const file of fs40.readdirSync(seedsPath)) {
+        if (file.endsWith(".json")) fs40.unlinkSync(path40.join(seedsPath, file));
       }
     }
     const saved = [];
@@ -10818,13 +11475,13 @@ var save = new Command66("save").description("save the current data as seeds").o
         const filtered = records.map(
           (r) => filterSystemFields(r, systemFieldNames)
         );
-        const relativeSeedPath = path37.join(
+        const relativeSeedPath = path40.join(
           DATA_DIR,
           "seeds",
           `${padZeros2(count, 2)}-${collectionName}.json`
         );
-        const seedPath = path37.join(workspaceRootDir, relativeSeedPath);
-        fs37.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
+        const seedPath = path40.join(workspaceRootDir, relativeSeedPath);
+        fs40.writeFileSync(seedPath, JSON.stringify(filtered, null, 2));
         saved.push(`${relativeSeedPath} (${filtered.length} records)`);
         count++;
       }
@@ -10962,7 +11619,7 @@ import { Command as Command78 } from "commander";
 import { Command as Command72 } from "commander";
 
 // src/lib/migrate.ts
-import path38 from "node:path";
+import path41 from "node:path";
 import process27 from "node:process";
 import { x as x3 } from "tinyexec";
 function migrateRoot() {
@@ -10976,9 +11633,9 @@ async function runPocketbaseMigrate(args) {
     binaryPath,
     [
       "--dir",
-      path38.join(cwd, DATA_DIR),
+      path41.join(cwd, DATA_DIR),
       "--migrationsDir",
-      path38.join(cwd, MIGRATIONS_DIR),
+      path41.join(cwd, MIGRATIONS_DIR),
       "migrate",
       ...args
     ],
@@ -11026,8 +11683,8 @@ var down = new Command73("down").alias("rollback").description("revert the last
 );
 
 // src/commands/migrate/create.ts
-import fs38 from "node:fs";
-import path39 from "node:path";
+import fs41 from "node:fs";
+import path42 from "node:path";
 import { Command as Command74 } from "commander";
 var create2 = new Command74("create").alias("new").description("create a new blank migration").argument("<name>", "migration name (snake_case)").configureHelp(helpConfig).action(
   (name) => runCommand(async () => {
@@ -11038,7 +11695,7 @@ var create2 = new Command74("create").alias("new").description("create a new bla
     const added = [...after].filter((f) => !before.has(f));
     reportResult({
       summary: `Created blank migration ${name}.`,
-      filesCreated: added.map((f) => path39.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path42.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Open the new file in ${MIGRATIONS_DIR}/ and fill in the up/down handlers.`,
         "Run `vela migrate up` to apply the migration once the handlers are written."
@@ -11047,14 +11704,14 @@ var create2 = new Command74("create").alias("new").description("create a new bla
   }, "Failed to create migration.")
 );
 function listMigrationFiles(cwd) {
-  const dir = path39.join(cwd, MIGRATIONS_DIR);
-  if (!fs38.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs38.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  const dir = path42.join(cwd, MIGRATIONS_DIR);
+  if (!fs41.existsSync(dir)) return /* @__PURE__ */ new Set();
+  return new Set(fs41.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/collections.ts
-import fs39 from "node:fs";
-import path40 from "node:path";
+import fs42 from "node:fs";
+import path43 from "node:path";
 import { Command as Command75 } from "commander";
 var collections = new Command75("collections").alias("snapshot").description("snapshot local collections into a new migration").configureHelp(helpConfig).action(
   () => runCommand(async () => {
@@ -11071,7 +11728,7 @@ var collections = new Command75("collections").alias("snapshot").description("sn
     }
     reportResult({
       summary: "Snapshotted local collections into a new migration.",
-      filesCreated: added.map((f) => path40.join(MIGRATIONS_DIR, f)),
+      filesCreated: added.map((f) => path43.join(MIGRATIONS_DIR, f)),
       nextSteps: [
         `Review the generated snapshot in ${MIGRATIONS_DIR}/.`,
         "Commit the snapshot so teammates pick up the new schema.",
@@ -11081,9 +11738,9 @@ var collections = new Command75("collections").alias("snapshot").description("sn
   }, "Failed to snapshot collections.")
 );
 function listMigrationFiles2(cwd) {
-  const dir = path40.join(cwd, MIGRATIONS_DIR);
-  if (!fs39.existsSync(dir)) return /* @__PURE__ */ new Set();
-  return new Set(fs39.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
+  const dir = path43.join(cwd, MIGRATIONS_DIR);
+  if (!fs42.existsSync(dir)) return /* @__PURE__ */ new Set();
+  return new Set(fs42.readdirSync(dir).filter((f) => /\.[jt]s$/.test(f)));
 }
 
 // src/commands/migrate/history-sync.ts
@@ -11099,14 +11756,14 @@ var historySync = new Command76("history-sync").description("drop _migrations ro
 );
 
 // src/commands/migrate/sveltekit-3.ts
-import path41 from "node:path";
+import path44 from "node:path";
 import process28 from "node:process";
 import { Command as Command77 } from "commander";
 import * as p45 from "@clack/prompts";
 import pc15 from "picocolors";
 var sveltekit3 = new Command77("sveltekit-3").description("upgrade a SvelteKit 2 project to SvelteKit 3 (sv migrate, then the vela steps)").option("--cwd <path>", "the project to migrate (default: the current project)").option("--no-install", "skip installing dependencies").option("--force", "run even when the git working tree has uncommitted changes").option("--skip-sv", "only run the vela steps (sv has already been run)").configureHelp(helpConfig).action(
   (options) => runCommand(async () => {
-    const root = options.cwd ? path41.resolve(options.cwd) : findWorkspaceRoot() ?? process28.cwd();
+    const root = options.cwd ? path44.resolve(options.cwd) : findWorkspaceRoot() ?? process28.cwd();
     p45.intro(pc15.bgCyan(pc15.black(" vela migrate sveltekit-3 ")));
     const result = await runKit3Migration(root, {
       install: options.install,
@@ -11123,7 +11780,7 @@ function printReport(root, result) {
     sections.push({ label: "Build output removed first", items: result.sv.cleared });
   }
   for (const fixup2 of changed) sections.push({ label: fixup2.name, items: fixup2.details });
-  const summary = result.mode === "repair" ? changed.length > 0 ? "Already on SvelteKit 3; brought the vela setup up to date." : "Already on SvelteKit 3; nothing left to change." : `Migrated ${path41.basename(root)} to SvelteKit 3.`;
+  const summary = result.mode === "repair" ? changed.length > 0 ? "Already on SvelteKit 3; brought the vela setup up to date." : "Already on SvelteKit 3; nothing left to change." : `Migrated ${path44.basename(root)} to SvelteKit 3.`;
   reportResult({ summary, sections });
   const tasks = result.tasks;
   if (tasks && (tasks.sections.length > 0 || tasks.markerComments > 0)) {
@@ -11141,16 +11798,31 @@ function printReport(root, result) {
       format: (line) => line
     });
   }
-  const nextSteps = [];
+  p45.note(
+    nextStepsFor(result).map((s) => `- ${s}`).join("\n"),
+    "Next steps",
+    {
+      format: (line) => line
+    }
+  );
+}
+function nextStepsFor(result) {
+  const tasks = result.tasks;
+  const open = [];
   if (tasks && (tasks.sections.length > 0 || result.followUps.length > 0)) {
-    nextSteps.push(`Work through ${MIGRATION_TASKS_FILE}, then delete it.`);
+    open.push(`Work through ${MIGRATION_TASKS_FILE}, then delete it.`);
   }
   if (tasks?.markerComments) {
-    nextSteps.push("Search the code for `@migration-task` and resolve each comment.");
+    open.push("Search the code for `@migration-task` and resolve each comment.");
   }
+  const changed = result.fixups.some((f) => f.changed);
+  if (!result.sv.ran && !changed) {
+    return ["Nothing left to change.", ...open];
+  }
+  const nextSteps = [...open];
   if (result.installed === null) {
     nextSteps.push(
-      "Install dependencies (`npm install`), then format what changed (`npx prettier --write .`): sv could not format without node_modules."
+      result.sv.ran ? "Install dependencies (`npm install`), then format what changed (`npx prettier --write .`): sv could not format without node_modules." : "Install dependencies (`npm install`), then format what changed (`npx prettier --write .`)."
     );
   }
   if (result.installed === false) {
@@ -11159,21 +11831,35 @@ function printReport(root, result) {
   nextSteps.push("Run `npm run check`, `vela test:server` and `npm run build`.");
   nextSteps.push(...result.genericFollowUps);
   nextSteps.push("Review the diff and commit it.");
-  p45.note(nextSteps.map((s) => `- ${s}`).join("\n"), "Next steps", { format: (line) => line });
+  return nextSteps;
 }
 
 // src/commands/migrate.ts
 var migrate = new Command78("migrate").description("manage database migrations (and `migrate sveltekit-3` to upgrade SvelteKit)").configureHelp(helpConfig).action(() => runCommand(runMigrateUp, "Failed to run migrations.")).addCommand(up).addCommand(down).addCommand(create2).addCommand(collections).addCommand(historySync).addCommand(sveltekit3);
 
 // src/commands/dev.ts
-import fs40 from "node:fs";
-import path43 from "node:path";
-import process30 from "node:process";
+import fs43 from "node:fs";
+import path46 from "node:path";
+import process31 from "node:process";
 import { performance } from "node:perf_hooks";
 import { Command as Command79, InvalidArgumentError as InvalidArgumentError4 } from "commander";
 import pc17 from "picocolors";
 import PocketBase4 from "pocketbase";
 
+// src/lib/terminate.ts
+import process29 from "node:process";
+var TERMINATING_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var EXIT_CODES = { SIGINT: 0, SIGTERM: 143, SIGHUP: 129 };
+function onTerminate(cleanup, proc = process29) {
+  proc.on("exit", cleanup);
+  for (const signal of TERMINATING_SIGNALS) {
+    proc.on(signal, () => {
+      cleanup();
+      proc.exit(EXIT_CODES[signal]);
+    });
+  }
+}
+
 // src/lib/pocketbase-log-filter.ts
 import { Transform } from "node:stream";
 var ANSI2 = /\x1b\[[0-9;]*m/g;
@@ -11199,8 +11885,8 @@ function createPocketbaseLogFilter() {
 }
 
 // src/lib/vite.ts
-import path42 from "node:path";
-import process29 from "node:process";
+import path45 from "node:path";
+import process30 from "node:process";
 import { createRequire as createRequire3 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import pc16 from "picocolors";
@@ -11219,18 +11905,18 @@ function viteVersionError(version) {
 }
 function resolveProjectVite(cwd) {
   try {
-    return createRequire3(path42.join(cwd, "package.json")).resolve("vite");
+    return createRequire3(path45.join(cwd, "package.json")).resolve("vite");
   } catch {
     return null;
   }
 }
-async function loadVite(cwd = process29.cwd()) {
+async function loadVite(cwd = process30.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(`${pc16.redBright("\u2717")} ${error}`);
-    process29.exit(1);
+    process30.exit(1);
   }
   return vite;
 }
@@ -11244,41 +11930,37 @@ function parsePort(value) {
   return port;
 }
 var dev = new Command79("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").option("--all-sql", "also print the auth lookup PocketBase runs on every request").configureHelp(helpConfig).action(async (options) => {
-  const cwd = process30.cwd();
+  const cwd = process31.cwd();
   warnIfKit2(findWorkspaceRoot(cwd) ?? cwd, (m) => console.warn(pc17.yellow(`\u25B2 ${m}`)));
-  process30.env.VELA_DATA_DIR ??= localDataDir(cwd);
+  process31.env.VELA_DATA_DIR ??= localDataDir(cwd);
   const startTime = performance.now();
   const { createServer, version } = await loadVite(cwd);
-  const viteMetadataDir = path43.join(cwd, "node_modules", ".vite");
-  const viteMetadataFile = path43.join(viteMetadataDir, "_pocketbase_metadata.json");
+  const viteMetadataDir = path46.join(cwd, "node_modules", ".vite");
+  const viteMetadataFile = path46.join(viteMetadataDir, "_pocketbase_metadata.json");
   let pbProc;
   const backend3 = hasBackend(cwd);
-  const needsStart = backend3 && !process30.env.POCKETBASE_URL;
+  const needsStart = backend3 && !process31.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
-    if (fs40.existsSync(viteMetadataFile)) fs40.rmSync(viteMetadataFile);
+    if (fs43.existsSync(viteMetadataFile)) fs43.rmSync(viteMetadataFile);
   };
   if (needsStart) {
-    const dataDir2 = path43.join(cwd, DATA_DIR);
+    const dataDir2 = path46.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path43.join(dataDir2, "hooks"),
+      hooksDir: path46.join(dataDir2, "hooks"),
       dev: true,
       stdio: "pipe"
     });
     pbProc = started.proc;
-    process30.env.POCKETBASE_URL = started.url;
-    if (options.allSql) pbProc.stdout?.pipe(process30.stdout);
-    else pbProc.stdout?.pipe(createPocketbaseLogFilter()).pipe(process30.stdout);
-    pbProc.stderr?.pipe(process30.stderr);
+    process31.env.POCKETBASE_URL = started.url;
+    if (options.allSql) pbProc.stdout?.pipe(process31.stdout);
+    else pbProc.stdout?.pipe(createPocketbaseLogFilter()).pipe(process31.stdout);
+    pbProc.stderr?.pipe(process31.stderr);
     pbProc.on("error", (err) => console.error("PocketBase error:", err));
     pbProc.on("exit", (code2) => console.log(`PocketBase exited with code ${code2}`));
-    process30.on("exit", cleanup);
-    process30.on("SIGINT", () => {
-      cleanup();
-      process30.exit(0);
-    });
+    onTerminate(cleanup);
   }
   const serverOptions = {};
   if (options.open !== void 0) serverOptions.open = options.open;
@@ -11295,19 +11977,19 @@ var dev = new Command79("dev").description("start the development server").optio
     if (!backend3) return;
     const { address, port: vitePort } = server.httpServer.address();
     const viteHost = address === "::1" ? "localhost" : address;
-    await fs40.promises.mkdir(viteMetadataDir, { recursive: true });
-    await fs40.promises.writeFile(
+    await fs43.promises.mkdir(viteMetadataDir, { recursive: true });
+    await fs43.promises.writeFile(
       viteMetadataFile,
       JSON.stringify({
-        pocketbaseUrl: process30.env.POCKETBASE_URL,
+        pocketbaseUrl: process31.env.POCKETBASE_URL,
         vitePort,
         viteHost
       })
     );
-    const pb = new PocketBase4(process30.env.POCKETBASE_URL);
+    const pb = new PocketBase4(process31.env.POCKETBASE_URL);
     await pb.collection("_superusers").authWithPassword(
-      process30.env.POCKETBASE_SUPERUSER_EMAIL,
-      process30.env.POCKETBASE_SUPERUSER_PASSWORD
+      process31.env.POCKETBASE_SUPERUSER_EMAIL,
+      process31.env.POCKETBASE_SUPERUSER_PASSWORD
     );
     const site = await readSite(cwd);
     await pb.settings.update({
@@ -11326,7 +12008,7 @@ var dev = new Command79("dev").description("start the development server").optio
     await startWatchingTypes(cwd, pb);
   });
   await server.listen();
-  const hasExistingLogs = process30.stdout.bytesWritten > 0 || process30.stderr.bytesWritten > 0;
+  const hasExistingLogs = process31.stdout.bytesWritten > 0 || process31.stderr.bytesWritten > 0;
   const startupDurationString = pc17.dim(
     `ready in ${pc17.reset(pc17.bold(Math.ceil(performance.now() - startTime)))} ms`
   );
@@ -11341,18 +12023,18 @@ var dev = new Command79("dev").description("start the development server").optio
 });
 async function startWatchingTypes(cwd, pb) {
   const { processTypes } = await import("@velastack/pocketbase-codegen");
-  const typesDir = path43.resolve(cwd, ".svelte-kit", "types");
-  const pocketbaseDir = path43.join(typesDir, "pocketbase");
-  const pocketbaseTypes = path43.join(pocketbaseDir, "$types.d.ts");
+  const typesDir = path46.resolve(cwd, ".svelte-kit", "types");
+  const pocketbaseDir = path46.join(typesDir, "pocketbase");
+  const pocketbaseTypes = path46.join(pocketbaseDir, "$types.d.ts");
   const regenerate = () => processTypes(pb, typesDir).catch(() => {
   });
   await regenerate();
   void (async () => {
     for (; ; ) {
       try {
-        await fs40.promises.mkdir(pocketbaseDir, { recursive: true });
-        for await (const event of fs40.promises.watch(pocketbaseDir)) {
-          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs40.existsSync(pocketbaseTypes)) {
+        await fs43.promises.mkdir(pocketbaseDir, { recursive: true });
+        for await (const event of fs43.promises.watch(pocketbaseDir)) {
+          if (event.eventType === "rename" && event.filename === "$types.d.ts" && !fs43.existsSync(pocketbaseTypes)) {
             setTimeout(regenerate, 100);
           }
         }
@@ -11364,9 +12046,9 @@ async function startWatchingTypes(cwd, pb) {
 }
 
 // src/commands/build.ts
-import fs41 from "node:fs";
-import path44 from "node:path";
-import process32 from "node:process";
+import fs44 from "node:fs";
+import path47 from "node:path";
+import process33 from "node:process";
 import { Command as Command80 } from "commander";
 import * as p46 from "@clack/prompts";
 import pc18 from "picocolors";
@@ -11381,10 +12063,10 @@ function applyBuildEnv(cwd, env2 = process.env) {
 }
 
 // src/lib/origin.ts
-import process31 from "node:process";
+import process32 from "node:process";
 function resolveOrigin(workspaceRootDir, envTag, config = {}) {
   const domain = readBinding(workspaceRootDir, envTag)?.domain ?? config.deploy?.domain;
-  return buildOrigin(splitHosts(domain), domain, process31.env.VELA_ORIGIN);
+  return buildOrigin(splitHosts(domain), domain, process32.env.VELA_ORIGIN);
 }
 function buildOrigin(directHosts, primaryUrl, envOverride) {
   if (envOverride !== void 0) return normalizeOrigin(envOverride);
@@ -11407,34 +12089,30 @@ function splitHosts(value) {
 }
 
 // src/commands/build.ts
-var PRERENDERED_DIR = path44.join(".svelte-kit", "output", "prerendered");
+var PRERENDERED_DIR = path47.join(".svelte-kit", "output", "prerendered");
 var build = new Command80("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 = process32.cwd();
+  const cwd = process33.cwd();
   warnIfKit2(findWorkspaceRoot(cwd) ?? cwd, (m) => p46.log.warn(m));
   applyBuildEnv(cwd);
   const origin = await originForBuild(cwd, options.target);
-  if (origin) process32.env.VELA_ORIGIN = origin;
+  if (origin) process33.env.VELA_ORIGIN = origin;
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process32.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process33.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
     await ensureSuperuser(cwd);
-    const dataDir2 = path44.join(cwd, DATA_DIR);
+    const dataDir2 = path47.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path44.join(dataDir2, "hooks"),
+      hooksDir: path47.join(dataDir2, "hooks"),
       dev: true
     });
     pbProc = started.proc;
-    process32.env.POCKETBASE_URL = started.url;
-    process32.on("exit", cleanup);
-    process32.on("SIGINT", () => {
-      cleanup();
-      process32.exit(0);
-    });
+    process33.env.POCKETBASE_URL = started.url;
+    onTerminate(cleanup);
   }
   try {
     const pm = (await detect7({ cwd }))?.name ?? "npm";
@@ -11464,9 +12142,9 @@ async function originForBuild(cwd, target) {
   }
 }
 function warnIfPrerendered(cwd) {
-  const dir = path44.join(cwd, PRERENDERED_DIR);
-  if (!fs41.existsSync(dir) || fs41.readdirSync(dir).length === 0) return;
-  if (process32.env.VELA_ORIGIN === "") {
+  const dir = path47.join(cwd, PRERENDERED_DIR);
+  if (!fs44.existsSync(dir) || fs44.readdirSync(dir).length === 0) return;
+  if (process33.env.VELA_ORIGIN === "") {
     p46.log.warn(
       `Prerendered pages were built with no origin, on purpose: this app is served on
 several hosts (or on none yet), and baking one in would make the others render
@@ -11488,41 +12166,37 @@ Set one with ${pc18.cyan("vela deploy --domain example.com")}, or pass ${pc18.cy
 }
 
 // src/commands/preview.ts
-import fs42 from "node:fs";
-import path45 from "node:path";
-import process33 from "node:process";
+import fs45 from "node:fs";
+import path48 from "node:path";
+import process34 from "node:process";
 import { Command as Command81 } from "commander";
 import * as p47 from "@clack/prompts";
 import pc19 from "picocolors";
 import { x as x5 } from "tinyexec";
 import { detect as detect8 } from "package-manager-detector";
 import { resolveCommand as resolveCommand6 } from "package-manager-detector/commands";
-var ADAPTER_NODE_MODULE = path45.join("build", "adapter-node.js");
+var ADAPTER_NODE_MODULE = path48.join("build", "adapter-node.js");
 var preview = new Command81("preview").description("preview the built app").configureHelp(helpConfig).action(async () => {
-  const cwd = process33.cwd();
-  process33.env.VELA_DATA_DIR ??= localDataDir(cwd);
+  const cwd = process34.cwd();
+  process34.env.VELA_DATA_DIR ??= localDataDir(cwd);
   warnIfKit2(findWorkspaceRoot(cwd) ?? cwd, (m) => p47.log.warn(m));
   warnIfOriginBaked(cwd);
   let pbProc;
-  const needsStart = hasBackend(cwd) && !process33.env.POCKETBASE_URL;
+  const needsStart = hasBackend(cwd) && !process34.env.POCKETBASE_URL;
   const cleanup = () => {
     if (pbProc?.pid) pbProc.kill();
   };
   if (needsStart) {
-    const dataDir2 = path45.join(cwd, DATA_DIR);
+    const dataDir2 = path48.join(cwd, DATA_DIR);
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path45.join(dataDir2, "hooks"),
+      hooksDir: path48.join(dataDir2, "hooks"),
       dev: true
     });
     pbProc = started.proc;
-    process33.env.POCKETBASE_URL = started.url;
-    process33.on("exit", cleanup);
-    process33.on("SIGINT", () => {
-      cleanup();
-      process33.exit(0);
-    });
+    process34.env.POCKETBASE_URL = started.url;
+    onTerminate(cleanup);
   }
   try {
     const pm = (await detect8({ cwd }))?.name ?? "npm";
@@ -11550,7 +12224,7 @@ function bakedOrigin(source) {
 function warnIfOriginBaked(cwd) {
   let source;
   try {
-    source = fs42.readFileSync(path45.join(cwd, ADAPTER_NODE_MODULE), "utf8");
+    source = fs45.readFileSync(path48.join(cwd, ADAPTER_NODE_MODULE), "utf8");
   } catch {
     return;
   }
@@ -11566,12 +12240,12 @@ set empty so no domain is baked in.`
 }
 
 // src/commands/sync.ts
-import path46 from "node:path";
+import path49 from "node:path";
 import { Command as Command82 } from "commander";
 var sync = new Command82("sync").description("sync types from the database").configureHelp(helpConfig).action(
   () => runCommand(async () => {
     const { workspaceRootDir } = await getWorkspace();
-    const typesDir = path46.join(workspaceRootDir, ".svelte-kit", "types");
+    const typesDir = path49.join(workspaceRootDir, ".svelte-kit", "types");
     const { processTypes } = await import("@velastack/pocketbase-codegen");
     await withPocketbase(workspaceRootDir, async (pb) => {
       await processTypes(pb, typesDir);
@@ -11638,32 +12312,32 @@ var provision = addSshOptions(
 );
 
 // src/commands/deploy.ts
-import path48 from "node:path";
-import fs44 from "node:fs";
-import process35 from "node:process";
+import path51 from "node:path";
+import fs47 from "node:fs";
+import process36 from "node:process";
 import { Command as Command84, Option as Option2 } from "commander";
 import * as p49 from "@clack/prompts";
 import pc21 from "picocolors";
 import * as v10 from "valibot";
 
 // src/lib/pocketbase-settings.ts
-import fs43 from "node:fs";
-import path47 from "node:path";
-import process34 from "node:process";
+import fs46 from "node:fs";
+import path50 from "node:path";
+import process35 from "node:process";
 import PocketBase5 from "pocketbase";
 var COPIED_KEYS = ["senderName", "senderAddress"];
 async function readLocalMeta(cwd) {
-  const dataDir2 = path47.join(cwd, DATA_DIR);
-  if (!fs43.existsSync(dataDir2)) return null;
-  const email2 = process34.env.POCKETBASE_SUPERUSER_EMAIL;
-  const password11 = process34.env.POCKETBASE_SUPERUSER_PASSWORD;
+  const dataDir2 = path50.join(cwd, DATA_DIR);
+  if (!fs46.existsSync(dataDir2)) return null;
+  const email2 = process35.env.POCKETBASE_SUPERUSER_EMAIL;
+  const password11 = process35.env.POCKETBASE_SUPERUSER_PASSWORD;
   if (!email2 || !password11) return null;
   let proc;
   try {
     const started = await startPocketbaseServe({
       dataDir: dataDir2,
       migrationsDir: MIGRATIONS_DIR,
-      hooksDir: path47.join(dataDir2, "hooks")
+      hooksDir: path50.join(dataDir2, "hooks")
     });
     proc = started.proc;
     const pb = new PocketBase5(started.url);
@@ -11738,7 +12412,7 @@ var deploy = addLockWaitOption(
     const options = parseOptions(OptionsSchema3, raw);
     const backend3 = hasBackend();
     p49.intro(pc21.bgCyan(pc21.black(" vela deploy ")));
-    assertKit3(findWorkspaceRoot() ?? process35.cwd(), "vela deploy");
+    assertKit3(findWorkspaceRoot() ?? process36.cwd(), "vela deploy");
     if (options.build !== false) {
       const { workspaceRootDir } = await getWorkspace();
       await prepareAdapter(workspaceRootDir);
@@ -11802,7 +12476,7 @@ with DNS of your own pointing at ${ctx.server}.`
               );
             }
             if (options.build !== false) {
-              const origin = buildOrigin(directHosts, primaryUrl, process35.env.VELA_ORIGIN);
+              const origin = buildOrigin(directHosts, primaryUrl, process36.env.VELA_ORIGIN);
               let buildEnv = {
                 VELA_ORIGIN: origin ?? ""
               };
@@ -11949,11 +12623,11 @@ ${pc21.cyan(err.snippet)}` : err.message);
     const has = current.kind === "auto" ? `is on ${ADAPTER_AUTO}` : "has no SvelteKit adapter configured";
     const confirmed = await p49.confirm({
       message: `This project ${has}, and vela deploy runs the app as a Node server.
-Switch it to ${ADAPTER_NODE2}? This edits ${path48.basename(current.file)} and package.json.`
+Switch it to ${ADAPTER_NODE2}? This edits ${path51.basename(current.file)} and package.json.`
     });
     if (p49.isCancel(confirmed) || !confirmed) {
       p49.cancel("Nothing was changed, and nothing was deployed.");
-      process35.exit(0);
+      process36.exit(0);
     }
   }
   const outcome = await ensureNodeAdapter(workspaceRootDir, { install: false }).catch(rethrow);
@@ -12116,7 +12790,7 @@ async function uploadRelease(session, instance, release, entries) {
 }
 function isDirectory(target) {
   try {
-    return fs44.statSync(target).isDirectory();
+    return fs47.statSync(target).isDirectory();
   } catch {
     return false;
   }
@@ -12124,7 +12798,7 @@ function isDirectory(target) {
 async function reportEmptyEnvironment(session, instance, workspaceRootDir) {
   const remote = await readRemoteEnv(session, instance);
   if (Object.keys(remote).length > 0) return;
-  if (!fs44.existsSync(path48.join(workspaceRootDir, ".env"))) return;
+  if (!fs47.existsSync(path51.join(workspaceRootDir, ".env"))) return;
   p49.log.warn(
     `This app has no production environment variables yet.
 
@@ -12161,8 +12835,8 @@ async function serverTimeOrLocal(session) {
 }
 
 // src/commands/link.ts
-import path49 from "node:path";
-import process36 from "node:process";
+import path52 from "node:path";
+import process37 from "node:process";
 import { Command as Command85 } from "commander";
 import * as p50 from "@clack/prompts";
 var CREATE_NEW = "__new__";
@@ -12203,7 +12877,7 @@ async function pickExistingProject(projects) {
   });
   if (p50.isCancel(choice)) {
     p50.cancel("Operation cancelled.");
-    process36.exit(0);
+    process37.exit(0);
   }
   return choice;
 }
@@ -12218,18 +12892,18 @@ async function promptProjectName(workspaceRootDir) {
   });
   if (p50.isCancel(value)) {
     p50.cancel("Operation cancelled.");
-    process36.exit(0);
+    process37.exit(0);
   }
   return value.trim();
 }
 function defaultProjectName2(workspaceRootDir) {
   try {
-    const pkg = readPackageJson(path49.join(workspaceRootDir, "package.json"));
+    const pkg = readPackageJson(path52.join(workspaceRootDir, "package.json"));
     const name = pkg.name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
   }
-  return path49.basename(workspaceRootDir);
+  return path52.basename(workspaceRootDir);
 }
 
 // src/commands/env.ts
@@ -12273,7 +12947,7 @@ function report(keys, where) {
 }
 
 // src/commands/env/set.ts
-import process37 from "node:process";
+import process38 from "node:process";
 import { Command as Command87 } from "commander";
 import * as p52 from "@clack/prompts";
 import pc23 from "picocolors";
@@ -12315,7 +12989,7 @@ async function promptValue(key) {
   });
   if (p52.isCancel(value)) {
     p52.cancel("Operation cancelled.");
-    process37.exit(0);
+    process38.exit(0);
   }
   return value;
 }
@@ -12360,9 +13034,9 @@ var envUnset = addTargetOptions(
 );
 
 // src/commands/env/import.ts
-import fs45 from "node:fs";
-import path50 from "node:path";
-import process38 from "node:process";
+import fs48 from "node:fs";
+import path53 from "node:path";
+import process39 from "node:process";
 import { Command as Command89 } from "commander";
 import * as p54 from "@clack/prompts";
 import pc25 from "picocolors";
@@ -12407,10 +13081,10 @@ var envImport = addTargetOptions(
   )
 );
 function resolve(file) {
-  return path50.resolve(process38.cwd(), file);
+  return path53.resolve(process39.cwd(), file);
 }
 function read(resolved, shown) {
-  if (!fs45.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
+  if (!fs48.existsSync(resolved)) throw new Error(`${shown} does not exist.`);
   const incoming = readLocalEnvFile(resolved);
   if (Object.keys(incoming).length === 0) p54.log.info(`${shown} has no variables to import.`);
   return incoming;
@@ -12567,7 +13241,7 @@ var logs = addTargetOptions(
 import { Command as Command95 } from "commander";
 
 // src/commands/admin/create.ts
-import process39 from "node:process";
+import process40 from "node:process";
 import { Command as Command94 } from "commander";
 import * as p57 from "@clack/prompts";
 import pc28 from "picocolors";
@@ -12642,7 +13316,7 @@ async function upsertSuperuser2(pb, email2, password11) {
     });
     if (p57.isCancel(confirmed) || !confirmed) {
       p57.cancel("Operation cancelled.");
-      process39.exit(0);
+      process40.exit(0);
     }
     await pb.collection("_superusers").update(existing, { password: password11, passwordConfirm: password11 });
     p57.log.success(`Password updated for ${pc28.cyan(email2)}, you can sign in now`);
@@ -12666,7 +13340,7 @@ async function promptEmail() {
   });
   if (p57.isCancel(value)) {
     p57.cancel("Operation cancelled.");
-    process39.exit(0);
+    process40.exit(0);
   }
   return value.trim();
 }
@@ -12677,7 +13351,7 @@ async function promptPassword2() {
   });
   if (p57.isCancel(value)) {
     p57.cancel("Operation cancelled.");
-    process39.exit(0);
+    process40.exit(0);
   }
   const again = await p57.password({
     message: "Password again",
@@ -12685,7 +13359,7 @@ async function promptPassword2() {
   });
   if (p57.isCancel(again)) {
     p57.cancel("Operation cancelled.");
-    process39.exit(0);
+    process40.exit(0);
   }
   return value;
 }
@@ -12697,8 +13371,8 @@ var admin = new Command95("admin").description("manage admin panel logins").conf
 import { Command as Command101 } from "commander";
 
 // src/commands/backup/create.ts
-import fs46 from "node:fs";
-import path51 from "node:path";
+import fs49 from "node:fs";
+import path54 from "node:path";
 import { Command as Command96 } from "commander";
 import * as p58 from "@clack/prompts";
 import pc29 from "picocolors";
@@ -12852,12 +13526,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 = path51.resolve(ctx.workspaceRootDir, outputDir);
-  fs46.mkdirSync(dir, { recursive: true });
-  const destination = path51.join(dir, key);
+  const dir = path54.resolve(ctx.workspaceRootDir, outputDir);
+  fs49.mkdirSync(dir, { recursive: true });
+  const destination = path54.join(dir, key);
   if (!ctx.session) {
-    fs46.copyFileSync(path51.join(ctx.workspaceRootDir, "data", "backups", key), destination);
-    return path51.relative(ctx.workspaceRootDir, destination);
+    fs49.copyFileSync(path54.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+    return path54.relative(ctx.workspaceRootDir, destination);
   }
   const spinner8 = p58.spinner();
   spinner8.start(`Downloading ${key}`);
@@ -12868,7 +13542,7 @@ async function download(ctx, key, outputDir) {
     throw error;
   }
   spinner8.stop(`Downloaded ${key}`);
-  return path51.relative(ctx.workspaceRootDir, destination);
+  return path54.relative(ctx.workspaceRootDir, destination);
 }
 
 // src/commands/backup/list.ts
@@ -12902,8 +13576,8 @@ Take one with ${pc30.cyan("vela backup create")}.`
 );
 
 // src/commands/backup/download.ts
-import fs47 from "node:fs";
-import path52 from "node:path";
+import fs50 from "node:fs";
+import path55 from "node:path";
 import { Command as Command98 } from "commander";
 import * as p60 from "@clack/prompts";
 import pc31 from "picocolors";
@@ -12930,11 +13604,11 @@ Run ${pc31.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 = path52.resolve(ctx.workspaceRootDir, options.output);
-      fs47.mkdirSync(dir, { recursive: true });
-      const destination = path52.join(dir, key);
+      const dir = path55.resolve(ctx.workspaceRootDir, options.output);
+      fs50.mkdirSync(dir, { recursive: true });
+      const destination = path55.join(dir, key);
       if (!ctx.session) {
-        fs47.copyFileSync(path52.join(ctx.workspaceRootDir, "data", "backups", key), destination);
+        fs50.copyFileSync(path55.join(ctx.workspaceRootDir, "data", "backups", key), destination);
       } else {
         const spinner8 = p60.spinner();
         spinner8.start(`Downloading ${key} (${formatBytes(found.size)})`);
@@ -12948,14 +13622,14 @@ Fetch it from the bucket directly \u2014 vela does not hold its credentials.`
       }
       reportResult({
         summary: `Saved ${key} from ${ctx.targetName}.`,
-        filesCreated: [path52.relative(ctx.workspaceRootDir, destination)]
+        filesCreated: [path55.relative(ctx.workspaceRootDir, destination)]
       });
     });
   }, "Failed to download the backup.")
 );
 
 // src/commands/backup/delete.ts
-import process40 from "node:process";
+import process41 from "node:process";
 import { Command as Command99 } from "commander";
 import * as p61 from "@clack/prompts";
 import pc32 from "picocolors";
@@ -12981,7 +13655,7 @@ Run ${pc32.cyan("vela backup list")} to see what it does have.`
         });
         if (p61.isCancel(confirmed) || !confirmed) {
           p61.cancel("Operation cancelled.");
-          process40.exit(0);
+          process41.exit(0);
         }
       }
       await ctx.pb.backups.delete(key);
@@ -13043,9 +13717,9 @@ Set one with ${pc33.cyan('vela backup schedule "0 3 * * *"')}.`
 var backup = new Command101("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 fs48 from "node:fs";
-import path53 from "node:path";
-import process41 from "node:process";
+import fs51 from "node:fs";
+import path56 from "node:path";
+import process42 from "node:process";
 import { Command as Command102 } from "commander";
 import * as p63 from "@clack/prompts";
 import pc34 from "picocolors";
@@ -13074,7 +13748,7 @@ Run \`vela deploy\` first, then restore.`
               `${ctx.targetName} was deployed without a database, so there is nothing to restore.`
             );
           }
-          const local = source && fs48.existsSync(source) ? source : void 0;
+          const local = source && fs51.existsSync(source) ? source : void 0;
           const key = local ? void 0 : await resolveKey(ctx, source);
           if (!options.yes) {
             await confirm14(ctx.appName, ctx.targetName, ctx.envTag, local ?? key);
@@ -13097,7 +13771,7 @@ Run \`vela deploy\` first, then restore.`
           });
           p63.log.success(
             `Restored ${pc34.cyan(`${ctx.appName} (${ctx.targetName})`)} from ${pc34.cyan(
-              local ? path53.basename(local) : key
+              local ? path56.basename(local) : key
             )}.`
           );
           if (result?.storageCarriedOver) {
@@ -13157,27 +13831,27 @@ Take one with ${pc34.cyan("vela backup create")}, or pass the path to an archive
   });
   if (p63.isCancel(chosen)) {
     p63.cancel("Operation cancelled.");
-    process41.exit(0);
+    process42.exit(0);
   }
   return chosen;
 }
 async function stage(ctx, file) {
   const dir = remotePaths.restoreStage(ctx.instance);
-  const remote = `${dir}/${path53.basename(file)}`;
+  const remote = `${dir}/${path56.basename(file)}`;
   const spinner8 = p63.spinner();
-  spinner8.start(`Uploading ${path53.basename(file)}`);
+  spinner8.start(`Uploading ${path56.basename(file)}`);
   try {
     await ctx.session.script(`mkdir -p "$1"`, { args: [dir] });
     await ctx.session.upload([file], dir);
   } catch (error) {
-    spinner8.stop(`Could not upload ${path53.basename(file)}.`);
+    spinner8.stop(`Could not upload ${path56.basename(file)}.`);
     throw error;
   }
-  spinner8.stop(`Uploaded ${path53.basename(file)}`);
+  spinner8.stop(`Uploaded ${path56.basename(file)}`);
   return remote;
 }
 async function confirm14(appName, targetName, envTag, from) {
-  const what = `${pc34.cyan(`${appName} (${targetName})`)} from ${pc34.cyan(path53.basename(from))}`;
+  const what = `${pc34.cyan(`${appName} (${targetName})`)} from ${pc34.cyan(path56.basename(from))}`;
   if (isProd(envTag)) {
     const answer = await p63.text({
       message: `This replaces the database and uploads of ${what}. Type the app name to confirm`,
@@ -13185,7 +13859,7 @@ async function confirm14(appName, targetName, envTag, from) {
     });
     if (p63.isCancel(answer)) {
       p63.cancel("Operation cancelled.");
-      process41.exit(0);
+      process42.exit(0);
     }
     return;
   }
@@ -13195,7 +13869,7 @@ async function confirm14(appName, targetName, envTag, from) {
   });
   if (p63.isCancel(ok) || !ok) {
     p63.cancel("Operation cancelled.");
-    process41.exit(0);
+    process42.exit(0);
   }
 }
 
@@ -13288,37 +13962,37 @@ Release and domain are shown from what this project recorded.`
 }
 
 // src/commands/test.ts
-import path54 from "node:path";
-import process42 from "node:process";
+import path57 from "node:path";
+import process43 from "node:process";
 import { Command as Command104 } from "commander";
 import PocketBase6 from "pocketbase";
 import pc36 from "picocolors";
 import { x as x6 } from "tinyexec";
 import { detect as detect9 } from "package-manager-detector";
 import { resolveCommand as resolveCommand7 } from "package-manager-detector/commands";
-import fs49 from "node:fs";
+import fs52 from "node:fs";
 var testServer = new Command104("test:server").description("run server tests").allowUnknownOption(true).allowExcessArguments(true).configureHelp(helpConfig).action(async (_opts, cmd) => {
-  const cwd = process42.cwd();
+  const cwd = process43.cwd();
   warnIfKit2(cwd, (m) => console.warn(pc36.yellow(`\u25B2 ${m}`)));
   const email2 = `test-${Math.random().toString(36).slice(2)}@example.com`;
   const password11 = "password";
-  const testDataDir = path54.join(cwd, "test-data");
-  fs49.rmSync(testDataDir, { recursive: true, force: true });
+  const testDataDir = path57.join(cwd, "test-data");
+  fs52.rmSync(testDataDir, { recursive: true, force: true });
   const { stop, url } = await launchPocketbase(cwd, {
     dir: testDataDir,
-    migrationsDir: path54.join(cwd, MIGRATIONS_DIR),
+    migrationsDir: path57.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: path54.join(cwd, DATA_DIR, "hooks"),
+    hooksDir: path57.join(cwd, DATA_DIR, "hooks"),
     email: email2,
     password: password11
   });
-  process42.env.POCKETBASE_URL = url;
-  process42.env.POCKETBASE_SUPERUSER_EMAIL = email2;
-  process42.env.POCKETBASE_SUPERUSER_PASSWORD = password11;
-  process42.env.VELA_DATA_DIR = testDataDir;
-  process42.env.TEST = "true";
+  process43.env.POCKETBASE_URL = url;
+  process43.env.POCKETBASE_SUPERUSER_EMAIL = email2;
+  process43.env.POCKETBASE_SUPERUSER_PASSWORD = password11;
+  process43.env.VELA_DATA_DIR = testDataDir;
+  process43.env.TEST = "true";
   console.log(`${pc36.greenBright("\u2713")} Created test database`);
   let vite;
   let cleanedUp = false;
@@ -13326,11 +14000,11 @@ var testServer = new Command104("test:server").description("run server tests").a
     if (cleanedUp) return;
     cleanedUp = true;
     stop();
-    fs49.rmSync(testDataDir, { recursive: true, force: true });
+    fs52.rmSync(testDataDir, { recursive: true, force: true });
   };
   const cleanup = async () => {
     if (cleanedUp) return;
-    process42.emit("sveltekit:shutdown", 0);
+    process43.emit("sveltekit:shutdown", 0);
     await vite?.close().catch(() => {
     });
     cleanupSync();
@@ -13338,13 +14012,19 @@ var testServer = new Command104("test:server").description("run server tests").a
   const fail = async (message) => {
     console.error(`${pc36.redBright("\u2717")} ${message}`);
     await cleanup();
-    process42.exit(1);
+    process43.exit(1);
   };
-  process42.on("exit", cleanupSync);
-  process42.on("SIGINT", () => {
-    cleanupSync();
-    process42.exit(130);
-  });
+  process43.on("exit", cleanupSync);
+  for (const [signal, code2] of [
+    ["SIGINT", 130],
+    ["SIGTERM", 143],
+    ["SIGHUP", 129]
+  ]) {
+    process43.on(signal, () => {
+      cleanupSync();
+      process43.exit(code2);
+    });
+  }
   const pb = new PocketBase6(url);
   try {
     await authWithRetries(pb, email2, password11);
@@ -13371,7 +14051,7 @@ var testServer = new Command104("test:server").description("run server tests").a
   });
   const vitePort = await findFreePort();
   await vite.listen(vitePort);
-  process42.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
+  process43.env.VITE_TEST_URL = `http://localhost:${vitePort}`;
   console.log(`${pc36.greenBright("\u2713")} Started Vite: http://localhost:${vitePort}`);
   console.log(`${pc36.greenBright("\u2713")} Started PocketBase: ${url}`);
   const extraArgs = (cmd.parent?.args ?? []).slice(1);
@@ -13392,15 +14072,15 @@ var testServer = new Command104("test:server").description("run server tests").a
     const resolvedArgs = resolved.args.slice();
     if (pm === "npm") resolvedArgs.unshift("--yes");
     const result = await x6(resolved.command, resolvedArgs, {
-      nodeOptions: { cwd, stdio: "inherit", env: { ...process42.env, CI: "1" } }
+      nodeOptions: { cwd, stdio: "inherit", env: { ...process43.env, CI: "1" } }
     });
-    process42.exitCode = result.exitCode ?? 1;
+    process43.exitCode = result.exitCode ?? 1;
   } catch (e) {
     console.error(`${pc36.redBright("\u2717")} ${e.message}`);
-    process42.exitCode = 1;
+    process43.exitCode = 1;
   } finally {
     await cleanup();
-    process42.exit(process42.exitCode ?? 0);
+    process43.exit(process43.exitCode ?? 0);
   }
 });
 function describeLoadFailure(e) {
@@ -13429,8 +14109,8 @@ function stubPagesPlugin() {
 }
 
 // src/commands/routes.ts
-import fs50 from "node:fs";
-import path55 from "node:path";
+import fs53 from "node:fs";
+import path58 from "node:path";
 import { Command as Command105 } from "commander";
 var HTTP_METHODS = /* @__PURE__ */ new Set([
   "GET",
@@ -13444,30 +14124,30 @@ var HTTP_METHODS = /* @__PURE__ */ new Set([
 ]);
 var routes = new Command105("routes").description("list routes").configureHelp(helpConfig).action(async () => {
   const { workspaceRootDir, routesDir } = await getWorkspace();
-  const routesRoot = path55.join(workspaceRootDir, routesDir);
+  const routesRoot = path58.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 = fs50.readdirSync(dir, { withFileTypes: true });
+  const entries = fs53.readdirSync(dir, { withFileTypes: true });
   const routes2 = [];
   const hasLeaf = entries.some((e) => e.isFile() && isRouteFile(e.name));
   if (hasLeaf) {
-    const id = "/" + path55.relative(root, dir).split(path55.sep).filter(Boolean).join("/");
+    const id = "/" + path58.relative(root, dir).split(path58.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(path55.join(dir, entry.name)).forEach((m) => methods.add(m));
+        extractMethods(path58.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, path55.join(dir, entry.name)));
+    if (entry.isDirectory()) routes2.push(...walk(root, path58.join(dir, entry.name)));
   }
   return routes2;
 }
@@ -13476,7 +14156,7 @@ function isRouteFile(name) {
 }
 function extractMethods(file) {
   try {
-    const content = fs50.readFileSync(file, "utf8");
+    const content = fs53.readFileSync(file, "utf8");
     const methods = [];
     const exportRegex = /export\s+(?:const|async\s+function|function)\s+(\w+)/g;
     let match;
@@ -13517,17 +14197,17 @@ function printTable(routes2) {
 }
 
 // src/commands/i18n.ts
-import fs51 from "node:fs";
-import path56 from "node:path";
-import process43 from "node:process";
+import fs54 from "node:fs";
+import path59 from "node:path";
+import process44 from "node:process";
 import { Command as Command106 } from "commander";
 import { x as x7 } from "tinyexec";
 import { detect as detect10 } from "package-manager-detector";
 import { resolveCommand as resolveCommand8 } from "package-manager-detector/commands";
 var WUCHALE_CONFIG_NAMES = ["js", "mjs", "ts", "mts"].map((ext) => `wuchale.config.${ext}`);
 async function runWuchale(extraArgs) {
-  const cwd = findWorkspaceRoot() ?? process43.cwd();
-  if (!WUCHALE_CONFIG_NAMES.some((name) => fs51.existsSync(path56.join(cwd, name)))) {
+  const cwd = findWorkspaceRoot() ?? process44.cwd();
+  if (!WUCHALE_CONFIG_NAMES.some((name) => fs54.existsSync(path59.join(cwd, name)))) {
     throw new Error("No wuchale config found. Run `vela enable i18n` to set up i18n.");
   }
   const pm = (await detect10({ cwd }))?.name ?? "npm";
@@ -13549,7 +14229,7 @@ var i18n3 = new Command106("i18n").description("i18n utilities").configureHelp(h
 import { Command as Command112 } from "commander";
 
 // src/commands/cms/deploy.ts
-import process44 from "node:process";
+import process45 from "node:process";
 import { Command as Command107 } from "commander";
 import * as p65 from "@clack/prompts";
 import pc37 from "picocolors";
@@ -13615,7 +14295,7 @@ function resolveProjectId(explicit) {
     }
     return explicit;
   }
-  const root = findWorkspaceRoot(process44.cwd());
+  const root = findWorkspaceRoot(process45.cwd());
   const link2 = root ? readProjectConfig(root) : null;
   if (!link2) {
     throw new Error(
@@ -13655,15 +14335,15 @@ import pc39 from "picocolors";
 
 // src/lib/cms-backend.ts
 import { createRequire as createRequire4 } from "node:module";
-import path57 from "node:path";
-import process45 from "node:process";
+import path60 from "node:path";
+import process46 from "node:process";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import pc38 from "picocolors";
 var DEFAULT_PROJECT = "default";
 async function loadBackendModule(root) {
   let entry;
   try {
-    entry = createRequire4(path57.join(root, "package.json")).resolve("@velastack/cms/backend");
+    entry = createRequire4(path60.join(root, "package.json")).resolve("@velastack/cms/backend");
   } catch {
     throw new Error(
       `@velastack/cms is not installed in this project.
@@ -13673,7 +14353,7 @@ Run ${pc38.cyan("vela enable cms")} first.`
   }
   return await import(pathToFileURL3(entry).href);
 }
-async function withCmsBackend(fn, cwd = process45.cwd()) {
+async function withCmsBackend(fn, cwd = process46.cwd()) {
   const root = findWorkspaceRoot(cwd);
   if (!root) {
     throw new Error("Could not find workspace root (no package.json found)");
@@ -13681,8 +14361,8 @@ async function withCmsBackend(fn, cwd = process45.cwd()) {
   const { createCmsBackend } = await loadBackendModule(root);
   const dataDir2 = localDataDir(root);
   const backend3 = createCmsBackend({
-    dbPath: path57.join(dataDir2, "cms.sqlite"),
-    uploadDir: path57.join(dataDir2, "uploads")
+    dbPath: path60.join(dataDir2, "cms.sqlite"),
+    uploadDir: path60.join(dataDir2, "uploads")
   });
   try {
     return await fn(backend3);
@@ -13760,7 +14440,7 @@ var cms2 = new Command112("cms").description("manage the CMS").configureHelp(hel
 import { Command as Command116 } from "commander";
 
 // src/commands/workflows/list.ts
-import process46 from "node:process";
+import process47 from "node:process";
 import { Command as Command113, InvalidArgumentError as InvalidArgumentError5 } from "commander";
 import * as p69 from "@clack/prompts";
 import pc42 from "picocolors";
@@ -13838,7 +14518,7 @@ function formatRun(run, nameWidth) {
 }
 var workflowsList = new Command113("list").description("list recent workflow runs").option("--status <status>", `only runs in this state (${STATUSES.join(", ")})`, parseStatus).option("--name <workflow>", "only runs of this workflow").option("--limit <n>", "how many to show", parseLimit, 50).configureHelp(helpConfig).action(
   (options) => runCommand(async () => {
-    await withPocketbase(process46.cwd(), async (pb) => {
+    await withPocketbase(process47.cwd(), async (pb) => {
       const runs = await listRuns(pb, {
         status: options.status,
         workflowName: options.name,
@@ -13859,7 +14539,7 @@ Start one from server code with ${pc42.cyan("<workflow>.run(input)")}, or with $
 );
 
 // src/commands/workflows/run.ts
-import process47 from "node:process";
+import process48 from "node:process";
 import { Command as Command114, InvalidArgumentError as InvalidArgumentError6 } from "commander";
 import * as p70 from "@clack/prompts";
 import pc43 from "picocolors";
@@ -13872,7 +14552,7 @@ function parseInput(value) {
 }
 var workflowsRun = new Command114("run").description("start a run of a workflow; the running app picks it up").argument("<name>", "the workflow name, as in its defineWorkflow spec").argument("[input]", "the run input as JSON", parseInput).configureHelp(helpConfig).action(
   (name, input) => runCommand(async () => {
-    await withPocketbase(process47.cwd(), async (pb) => {
+    await withPocketbase(process48.cwd(), async (pb) => {
       const run = await createRun(pb, name, input);
       p70.log.success(
         `Queued ${pc43.cyan(name)} as run ${pc43.bold(run.id)}.
@@ -13884,13 +14564,13 @@ It runs once the app is up (${pc43.cyan("vela dev")}); ${pc43.cyan("vela workflo
 );
 
 // src/commands/workflows/cancel.ts
-import process48 from "node:process";
+import process49 from "node:process";
 import { Command as Command115 } from "commander";
 import * as p71 from "@clack/prompts";
 import pc44 from "picocolors";
 var workflowsCancel = new Command115("cancel").description("cancel a pending or running workflow run").argument("<run-id>", "the run id from `vela workflows list`").configureHelp(helpConfig).action(
   (id) => runCommand(async () => {
-    await withPocketbase(process48.cwd(), async (pb) => {
+    await withPocketbase(process49.cwd(), async (pb) => {
       const run = await cancelRun(pb, id);
       p71.log.success(`Canceled run ${pc44.bold(run.id)} of ${pc44.cyan(run.workflowName)}.`);
     });
@@ -13962,16 +14642,16 @@ var BACKEND_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set(["dev", "build", "previe
 var SELF_CREDENTIALED_COMMANDS = /* @__PURE__ */ new Set(["test:server"]);
 var program = new Command117().name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version").configureHelp(helpConfig);
 program.hook("preAction", (_thisCommand, actionCommand) => {
-  const envRoot = findWorkspaceRoot() ?? process49.cwd();
+  const envRoot = findWorkspaceRoot() ?? process50.cwd();
   dotenv2.config({ path: nodePath.join(envRoot, ".env"), quiet: true });
-  const path58 = getCommandPath(actionCommand);
-  if (NO_BACKEND_COMMMANDS.has(path58)) return;
-  const top = path58.split(" ", 1)[0];
+  const path61 = getCommandPath(actionCommand);
+  if (NO_BACKEND_COMMMANDS.has(path61)) return;
+  const top = path61.split(" ", 1)[0];
   if (NO_BACKEND_COMMMANDS.has(top)) return;
   if (!hasBackend()) {
     if (BACKEND_OPTIONAL_COMMANDS.has(top)) return;
     p72.log.error(
-      `${pc45.cyan(`vela ${path58}`)} needs a backend, and this project does not have one.
+      `${pc45.cyan(`vela ${path61}`)} needs a backend, and this project does not have one.
 
 There is no PocketBase database here for it to talk to.
 
@@ -13979,10 +14659,10 @@ To add one, run ${pc45.cyan("vela enable backend")}.`
     );
     p72.log.message();
     p72.cancel("Operation failed.");
-    process49.exit(1);
+    process50.exit(1);
   }
-  if (SELF_CREDENTIALED_COMMANDS.has(path58)) return;
-  if (!process49.env.POCKETBASE_SUPERUSER_EMAIL || !process49.env.POCKETBASE_SUPERUSER_PASSWORD) {
+  if (SELF_CREDENTIALED_COMMANDS.has(path61)) return;
+  if (!process50.env.POCKETBASE_SUPERUSER_EMAIL || !process50.env.POCKETBASE_SUPERUSER_PASSWORD) {
     p72.log.error(
       `PocketBase superuser credentials are required.
 
@@ -13993,7 +14673,7 @@ To set up an existing project, run ${pc45.cyan("vela bless")}.`
     );
     p72.log.message();
     p72.cancel("Operation failed.");
-    process49.exit(1);
+    process50.exit(1);
   }
 });
 function getCommandPath(cmd) {
@@ -14046,5 +14726,5 @@ for (const command of [
 }
 
 // src/bin.ts
-program.parse(normalizeArgv(process50.argv.slice(2)), { from: "user" });
+program.parse(normalizeArgv(process51.argv.slice(2)), { from: "user" });
 //# sourceMappingURL=bin.js.map