@vesk/vesk-cli 0.2.67 → 0.2.69

package/dist/cli.js

@@ -35609,7 +35609,7 @@ var init_default_pages = __esm({
 
 // ../adapter/src/paths.ts
 import { resolve as resolve11, sep as sep2 } from "node:path";
-import { existsSync as existsSync12, statSync as statSync4, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync12, statSync as statSync5, readFileSync as readFileSync14 } from "node:fs";
 function resolveWithin(baseDir, relPath) {
   const base = resolve11(baseDir);
   const target = resolve11(baseDir, relPath);
@@ -35628,7 +35628,7 @@ function installMdReadHook(publicDirs) {
         if (!abs) continue;
         const lower2 = abs.toLowerCase();
         if (!lower2.endsWith(".md") && !lower2.endsWith(".markdown")) continue;
-        if (existsSync12(abs) && statSync4(abs).isFile()) return readFileSync12(abs, "utf8");
+        if (existsSync12(abs) && statSync5(abs).isFile()) return readFileSync14(abs, "utf8");
       } catch {
       }
     }
@@ -35641,6 +35641,120 @@ var init_paths = __esm({
   }
 });
 
+// ../adapter/src/platform-output.ts
+import {
+  mkdirSync as mkdirSync6,
+  copyFileSync as copyFileSync2,
+  readdirSync as readdirSync4,
+  statSync as statSync7,
+  existsSync as existsSync15,
+  writeFileSync as writeFileSync7,
+  rmSync as rmSync2,
+  readFileSync as readFileSync17
+} from "node:fs";
+import { resolve as resolve13, join as join11, extname as extname3, dirname as dirname10 } from "node:path";
+function ensureCleanDir(dir) {
+  rmSync2(dir, { recursive: true, force: true });
+  mkdirSync6(dir, { recursive: true });
+}
+function copyDirContents(srcDir, destDir) {
+  if (!existsSync15(srcDir)) return;
+  mkdirSync6(destDir, { recursive: true });
+  for (const entry of readdirSync4(srcDir)) {
+    const srcPath = join11(srcDir, entry);
+    const destPath = join11(destDir, entry);
+    if (statSync7(srcPath).isDirectory()) {
+      copyDirContents(srcPath, destPath);
+    } else {
+      mkdirSync6(dirname10(destPath), { recursive: true });
+      copyFileSync2(srcPath, destPath);
+    }
+  }
+}
+function writeFile(path, content) {
+  mkdirSync6(dirname10(path), { recursive: true });
+  writeFileSync7(path, content, "utf-8");
+}
+function writePlatformStatic(buildStaticDir, platformStaticDir) {
+  mkdirSync6(platformStaticDir, { recursive: true });
+  const publicDir = resolve13(buildStaticDir, "public");
+  if (existsSync15(publicDir)) {
+    copyDirContents(publicDir, platformStaticDir);
+  }
+  const assetsDir = resolve13(platformStaticDir, "_vesk", "static");
+  copyDirContents(buildStaticDir, assetsDir);
+  const runtimeAlias = resolve13(platformStaticDir, "_vesk", "runtime.js");
+  const clientPath = resolve13(buildStaticDir, "client.js");
+  if (existsSync15(clientPath)) {
+    mkdirSync6(dirname10(runtimeAlias), { recursive: true });
+    copyFileSync2(clientPath, runtimeAlias);
+  }
+}
+function writePrerenderedStatic(prerenderedRoutes, platformStaticDir) {
+  for (const route of prerenderedRoutes) {
+    if (!existsSync15(route.html)) continue;
+    const content = readFileSync17(route.html);
+    const htmlRel = route.path === "/" ? "index.html" : `${route.path.replace(/^\//, "")}.html`;
+    const target = resolve13(platformStaticDir, "_vesk", "static", "public", htmlRel);
+    writeFile(target, content);
+    if (route.path !== "/" && route.path.endsWith("/")) {
+      const dirIndex = resolve13(platformStaticDir, "_vesk", "static", "public", `${route.path.replace(/^\//, "")}index.html`);
+      writeFile(dirIndex, content);
+    }
+  }
+}
+function listStaticDir(dir) {
+  const out = [];
+  if (!existsSync15(dir)) return out;
+  function walk9(d, prefix) {
+    for (const entry of readdirSync4(d)) {
+      const full = join11(d, entry);
+      const rel = prefix ? `${prefix}/${entry}` : entry;
+      if (statSync7(full).isDirectory()) {
+        walk9(full, rel);
+      } else {
+        out.push({ rel, buffer: readFileSync17(full) });
+      }
+    }
+  }
+  walk9(dir, "");
+  return out;
+}
+function mimeFor(path) {
+  return MIME[extname3(path).toLowerCase()] || "application/octet-stream";
+}
+var MIME;
+var init_platform_output = __esm({
+  "../adapter/src/platform-output.ts"() {
+    "use strict";
+    MIME = {
+      ".html": "text/html; charset=utf-8",
+      ".htm": "text/html; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".mjs": "application/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".avif": "image/avif",
+      ".ico": "image/x-icon",
+      ".txt": "text/plain; charset=utf-8",
+      ".xml": "application/xml",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".wasm": "application/wasm",
+      ".map": "application/json",
+      ".webmanifest": "application/manifest+json"
+    };
+  }
+});
+
 // ../adapter/src/plugins.ts
 var plugins_exports = {};
 __export(plugins_exports, {
@@ -35661,13 +35775,13 @@ __export(plugins_exports, {
   writePluginState: () => writePluginState
 });
 import {
-  readFileSync as readFileSync16,
-  writeFileSync as writeFileSync7,
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync6,
-  statSync as statSync7
+  readFileSync as readFileSync19,
+  writeFileSync as writeFileSync8,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync7,
+  statSync as statSync9
 } from "node:fs";
-import { resolve as resolve14, dirname as dirname11, join as join10, extname as extname4, basename as basename2 } from "node:path";
+import { resolve as resolve15, dirname as dirname12, join as join12, extname as extname4, basename as basename2 } from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { spawn } from "node:child_process";
 function defaultState() {
@@ -35677,14 +35791,14 @@ function eqIgnoreCase(a, b) {
   return String(a || "").toLowerCase() === String(b || "").toLowerCase();
 }
 function stateFilePath(veskDir) {
-  return resolve14(veskDir, PLUGIN_STATE_FILENAME);
+  return resolve15(veskDir, PLUGIN_STATE_FILENAME);
 }
 function readPluginState(veskDir) {
   const file = stateFilePath(veskDir);
-  if (!existsSync16(file)) return defaultState();
+  if (!existsSync17(file)) return defaultState();
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync16(file, "utf-8"));
+    raw2 = JSON.parse(readFileSync19(file, "utf-8"));
   } catch {
     return defaultState();
   }
@@ -35701,12 +35815,12 @@ function readPluginState(veskDir) {
 }
 function writePluginState(veskDir, state) {
   const file = stateFilePath(veskDir);
-  const dir = dirname11(file);
-  if (!existsSync16(dir)) mkdirSync6(dir, { recursive: true });
-  writeFileSync7(file, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  const dir = dirname12(file);
+  if (!existsSync17(dir)) mkdirSync7(dir, { recursive: true });
+  writeFileSync8(file, JSON.stringify(state, null, 2) + "\n", "utf-8");
 }
 function resolvePackage(appDir, pkg) {
-  const require3 = createRequire4(resolve14(appDir, "package.json"));
+  const require3 = createRequire4(resolve15(appDir, "package.json"));
   let entryPath = null;
   let pkgJsonPath = null;
   let pkgJson = null;
@@ -35715,31 +35829,31 @@ function resolvePackage(appDir, pkg) {
   } catch {
     try {
       entryPath = require3.resolve(pkg);
-      let cur = dirname11(entryPath);
+      let cur = dirname12(entryPath);
       const seen = /* @__PURE__ */ new Set();
-      while (cur && cur !== dirname11(cur) && !seen.has(cur)) {
+      while (cur && cur !== dirname12(cur) && !seen.has(cur)) {
         seen.add(cur);
-        const candidate = join10(cur, "package.json");
-        if (existsSync16(candidate)) {
+        const candidate = join12(cur, "package.json");
+        if (existsSync17(candidate)) {
           pkgJsonPath = candidate;
           break;
         }
-        const parent = dirname11(cur);
+        const parent = dirname12(cur);
         if (parent !== cur && basename2(cur) === "node_modules") break;
         cur = parent;
       }
     } catch {
     }
   }
-  if (pkgJsonPath && existsSync16(pkgJsonPath)) {
+  if (pkgJsonPath && existsSync17(pkgJsonPath)) {
     pkgJson = readJsonFile(pkgJsonPath);
     const main = pkgJson?.main || pkgJson?.module || "index.js";
-    entryPath = resolve14(dirname11(pkgJsonPath), main);
+    entryPath = resolve15(dirname12(pkgJsonPath), main);
   }
   let localPath = localDir(appDir, pkg);
   if (!localPath) {
     for (const sub of ["src/plugins", "plugins", "lib/plugins"]) {
-      const candidate = localDir(resolve14(appDir, sub), pkg);
+      const candidate = localDir(resolve15(appDir, sub), pkg);
       if (candidate) {
         localPath = candidate;
         break;
@@ -35747,30 +35861,30 @@ function resolvePackage(appDir, pkg) {
     }
   }
   if (localPath) {
-    const localJson = join10(localPath, "package.json");
+    const localJson = join12(localPath, "package.json");
     let json = null;
-    if (existsSync16(localJson)) {
+    if (existsSync17(localJson)) {
       json = readJsonFile(localJson);
     }
     return { installed: true, path: localPath, dir: localPath, packageJson: json ?? pkgJson };
   }
-  const installed2 = !!pkgJsonPath && existsSync16(pkgJsonPath);
-  return { installed: installed2, path: entryPath, dir: installed2 ? dirname11(pkgJsonPath) : null, packageJson: pkgJson };
+  const installed2 = !!pkgJsonPath && existsSync17(pkgJsonPath);
+  return { installed: installed2, path: entryPath, dir: installed2 ? dirname12(pkgJsonPath) : null, packageJson: pkgJson };
 }
 function localDir(base, pkg) {
   if (pkg.startsWith("@")) {
     const parts = pkg.split("/");
-    const p2 = resolve14(base, parts[0], parts[1] ?? "");
-    if (existsSync16(p2)) return p2;
+    const p2 = resolve15(base, parts[0], parts[1] ?? "");
+    if (existsSync17(p2)) return p2;
     return null;
   }
-  const p = resolve14(base, pkg);
-  if (existsSync16(p)) return p;
+  const p = resolve15(base, pkg);
+  if (existsSync17(p)) return p;
   return null;
 }
 function readJsonFile(file) {
   try {
-    if (existsSync16(file)) return JSON.parse(readFileSync16(file, "utf-8"));
+    if (existsSync17(file)) return JSON.parse(readFileSync19(file, "utf-8"));
   } catch {
   }
   return null;
@@ -35810,7 +35924,7 @@ function repositoryToString(r) {
 function assemblePluginMeta(probe) {
   const pkgJson = probe.packageJson || {};
   const dir = probe.dir;
-  const meta = dir ? readJsonFile(resolve14(dir, "vesk.meta.json")) : null;
+  const meta = dir ? readJsonFile(resolve15(dir, "vesk.meta.json")) : null;
   const hasMeta = !!meta && Object.keys(meta).length > 0;
   const m = meta || {};
   const metaSource = hasMeta ? "vesk.meta.json" : probe.packageJson ? "package.json" : "none";
@@ -36049,11 +36163,11 @@ function findIconFile(dir, meta) {
   const explicit = str(meta?.icon);
   if (explicit) {
     const p = resolveWithin(dir, explicit);
-    if (p && existsSync16(p) && statSync7(p).isFile()) return p;
+    if (p && existsSync17(p) && statSync9(p).isFile()) return p;
   }
   for (const name of ["icon.png", "icon.ico"]) {
-    const p = resolve14(dir, name);
-    if (existsSync16(p) && statSync7(p).isFile()) return p;
+    const p = resolve15(dir, name);
+    if (existsSync17(p) && statSync9(p).isFile()) return p;
   }
   return null;
 }
@@ -36061,7 +36175,7 @@ function findPluginIcon(appDir, name) {
   const probe = resolvePackage(appDir, name);
   const dir = probe.dir;
   if (!dir) return null;
-  const meta = readJsonFile(resolve14(dir, "vesk.meta.json"));
+  const meta = readJsonFile(resolve15(dir, "vesk.meta.json"));
   const iconPath = findIconFile(dir, meta);
   if (!iconPath) return null;
   const ext = extname4(iconPath).toLowerCase();
@@ -36124,7 +36238,7 @@ function resolveDtsPath(probe, pkgJson) {
   for (const rel of candidates) {
     if (!rel) continue;
     const abs = resolveWithin(dir, rel);
-    if (abs && existsSync16(abs) && statSync7(abs).isFile()) return abs;
+    if (abs && existsSync17(abs) && statSync9(abs).isFile()) return abs;
   }
   return null;
 }
@@ -36440,7 +36554,7 @@ function introspectPlugin(appDir, name) {
   const pkgName = str(pkgJson.name) ?? name;
   const exportsMap = flattenPackageExports(pkgJson.exports);
   const dtsPath = resolveDtsPath(probe, pkgJson);
-  const dtsExports = dtsPath ? parseDtsExports(readFileSync16(dtsPath, "utf-8")) : [];
+  const dtsExports = dtsPath ? parseDtsExports(readFileSync19(dtsPath, "utf-8")) : [];
   return {
     ok: true,
     name: pkgName,
@@ -36581,24 +36695,24 @@ __export(static_exports, {
   generateSitemap: () => generateSitemap,
   generateSsgRoutes: () => generateSsgRoutes
 });
-import { mkdirSync as mkdirSync7, copyFileSync as copyFileSync2, readdirSync as readdirSync3, statSync as statSync8, existsSync as existsSync17, writeFileSync as writeFileSync8, readFileSync as readFileSync17 } from "node:fs";
-import { resolve as resolve15, join as join11 } from "node:path";
+import { mkdirSync as mkdirSync8, copyFileSync as copyFileSync3, readdirSync as readdirSync5, statSync as statSync10, existsSync as existsSync18, writeFileSync as writeFileSync9, readFileSync as readFileSync20 } from "node:fs";
+import { resolve as resolve16, join as join13 } from "node:path";
 function copyStaticAssets2(publicDir, outDir) {
-  const targetDir = resolve15(outDir, "static", "public");
-  mkdirSync7(targetDir, { recursive: true });
-  if (!existsSync17(publicDir))
+  const targetDir = resolve16(outDir, "static", "public");
+  mkdirSync8(targetDir, { recursive: true });
+  if (!existsSync18(publicDir))
     return;
   function copyDir(src2, dest) {
-    mkdirSync7(dest, { recursive: true });
-    const entries = readdirSync3(src2);
+    mkdirSync8(dest, { recursive: true });
+    const entries = readdirSync5(src2);
     for (const entry of entries) {
-      const srcPath = join11(src2, entry);
-      const destPath = join11(dest, entry);
-      const st = statSync8(srcPath);
+      const srcPath = join13(src2, entry);
+      const destPath = join13(dest, entry);
+      const st = statSync10(srcPath);
       if (st.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
-        copyFileSync2(srcPath, destPath);
+        copyFileSync3(srcPath, destPath);
       }
     }
   }
@@ -36606,8 +36720,8 @@ function copyStaticAssets2(publicDir, outDir) {
 }
 async function generateSsgRoutes(routeTree, appDir, outDir, plugins, headExtra, cssUrls) {
   const { ssg: ssg2 } = await Promise.resolve().then(() => (init_server_render(), server_render_exports));
-  const prerenderDir = resolve15(outDir, "prerendered");
-  mkdirSync7(prerenderDir, { recursive: true });
+  const prerenderDir = resolve16(outDir, "prerendered");
+  mkdirSync8(prerenderDir, { recursive: true });
   const ssgOptions = { plugins, headExtra, cssUrls };
   const results = [];
   async function evaluateExport(src2, exportName) {
@@ -36626,8 +36740,8 @@ async function generateSsgRoutes(routeTree, appDir, outDir, plugins, headExtra,
   async function walk9(nodes) {
     for (const node of nodes) {
       if (node.page) {
-        const pagePath = resolve15(appDir, node.sourceDir, "page.vsk");
-        const src2 = readFileSync17(pagePath, "utf-8");
+        const pagePath = resolve16(appDir, node.sourceDir, "page.vsk");
+        const src2 = readFileSync20(pagePath, "utf-8");
         const hasStaticProps = src2.includes("getStaticProps");
         const hasStaticPaths = src2.includes("getStaticPaths");
         if (hasStaticPaths) {
@@ -36644,8 +36758,8 @@ async function generateSsgRoutes(routeTree, appDir, outDir, plugins, headExtra,
                   console.error(`vesk: SSG path escaped output dir \u2014 skipping ${pagePath} (path: ${urlPath})`);
                   continue;
                 }
-                mkdirSync7(resolve15(htmlPath, ".."), { recursive: true });
-                writeFileSync8(htmlPath, result.html);
+                mkdirSync8(resolve16(htmlPath, ".."), { recursive: true });
+                writeFileSync9(htmlPath, result.html);
                 results.push({ path: urlPath, html: htmlPath, static: result.static, params });
               } catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
@@ -36656,9 +36770,9 @@ async function generateSsgRoutes(routeTree, appDir, outDir, plugins, headExtra,
         } else if (hasStaticProps) {
           try {
             const result = await ssg2(src2, null, void 0, ssgOptions);
-            const htmlPath = resolve15(prerenderDir, node.fullPath === "/" ? "index.html" : `${node.fullPath.slice(1)}.html`);
-            mkdirSync7(resolve15(htmlPath, ".."), { recursive: true });
-            writeFileSync8(htmlPath, result.html);
+            const htmlPath = resolve16(prerenderDir, node.fullPath === "/" ? "index.html" : `${node.fullPath.slice(1)}.html`);
+            mkdirSync8(resolve16(htmlPath, ".."), { recursive: true });
+            writeFileSync9(htmlPath, result.html);
             results.push({ path: node.fullPath, html: htmlPath, static: result.static });
           } catch (e) {
             const message = e instanceof Error ? e.message : String(e);
@@ -36728,17 +36842,17 @@ __export(image_pipeline_exports, {
   collectImageRefs: () => collectImageRefs,
   optimizeImages: () => optimizeImages
 });
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readFileSync as readFileSync18, existsSync as existsSync18, readdirSync as readdirSync4, statSync as statSync9 } from "node:fs";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync21, existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync11 } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { resolve as resolve16, extname as extname5, dirname as dirname12, join as join12 } from "node:path";
+import { resolve as resolve17, extname as extname5, dirname as dirname13, join as join14 } from "node:path";
 import { createRequire as createRequire5 } from "node:module";
 import { tmpdir as tmpdir2 } from "node:os";
 function probeMemoPath() {
   try {
     const req = createRequire5(import.meta.url);
     const entry = req.resolve("sharp");
-    const stamp = Math.round(statSync9(entry).mtimeMs);
-    return join12(tmpdir2(), `vesk-sharp-probe-${process.platform}-${process.arch}-${stamp}.json`);
+    const stamp = Math.round(statSync11(entry).mtimeMs);
+    return join14(tmpdir2(), `vesk-sharp-probe-${process.platform}-${process.arch}-${stamp}.json`);
   } catch {
     return null;
   }
@@ -36748,7 +36862,7 @@ function readProbeMemo() {
   if (path === null)
     return null;
   try {
-    return JSON.parse(readFileSync18(path, "utf-8"))?.usable === true;
+    return JSON.parse(readFileSync21(path, "utf-8"))?.usable === true;
   } catch {
     return null;
   }
@@ -36758,7 +36872,7 @@ function writeProbeMemo(usable) {
   if (path === null)
     return;
   try {
-    writeFileSync9(path, JSON.stringify({ usable, at: Date.now() }), "utf-8");
+    writeFileSync10(path, JSON.stringify({ usable, at: Date.now() }), "utf-8");
   } catch {
   }
 }
@@ -36791,13 +36905,13 @@ async function ensureSharp() {
 async function processImage(srcPath, outDir, baseName) {
   const image = sharpFn ? sharpFn(srcPath) : null;
   if (!image) {
-    const original = readFileSync18(srcPath);
+    const original = readFileSync21(srcPath);
     const ext = extname5(srcPath);
     const written = [];
     for (const w of OUTPUT_WIDTHS) {
-      const outputPath = resolve16(outDir, `${baseName}-${w}w${ext}`);
-      mkdirSync8(dirname12(outputPath), { recursive: true });
-      writeFileSync9(outputPath, original);
+      const outputPath = resolve17(outDir, `${baseName}-${w}w${ext}`);
+      mkdirSync9(dirname13(outputPath), { recursive: true });
+      writeFileSync10(outputPath, original);
       written.push(outputPath);
     }
     return written;
@@ -36808,19 +36922,19 @@ async function processImage(srcPath, outDir, baseName) {
   for (const w of OUTPUT_WIDTHS) {
     const base = `${baseName}-${w}w`;
     if (w >= originalWidth) {
-      const copyPath = resolve16(outDir, `${base}${extname5(srcPath)}`);
-      mkdirSync8(dirname12(copyPath), { recursive: true });
-      writeFileSync9(copyPath, readFileSync18(srcPath));
+      const copyPath = resolve17(outDir, `${base}${extname5(srcPath)}`);
+      mkdirSync9(dirname13(copyPath), { recursive: true });
+      writeFileSync10(copyPath, readFileSync21(srcPath));
       generated.push(copyPath);
       continue;
     }
     const resized = image.clone().resize({ width: w, withoutEnlargement: true });
-    const jpgPath = resolve16(outDir, `${base}${extname5(srcPath)}`);
-    mkdirSync8(dirname12(jpgPath), { recursive: true });
+    const jpgPath = resolve17(outDir, `${base}${extname5(srcPath)}`);
+    mkdirSync9(dirname13(jpgPath), { recursive: true });
     await resized.toFile(jpgPath);
     generated.push(jpgPath);
     for (const fmt of FORMATS) {
-      const fmtPath = resolve16(outDir, `${base}.${fmt}`);
+      const fmtPath = resolve17(outDir, `${base}.${fmt}`);
       await resized.toFormat(fmt, { quality: 80 }).toFile(fmtPath);
       generated.push(fmtPath);
     }
@@ -36832,19 +36946,19 @@ function collectImageRefs(appDir) {
   function walk9(dir) {
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync6(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = resolve16(dir, entry);
-      const st = statSync9(full);
+      const full = resolve17(dir, entry);
+      const st = statSync11(full);
       if (st.isDirectory()) {
         if (entry.startsWith("."))
           continue;
         walk9(full);
       } else if (entry.endsWith(".vsk")) {
-        const src2 = readFileSync18(full, "utf-8");
+        const src2 = readFileSync21(full, "utf-8");
         const imgRegex = /<Image\s[^>]*src=["']([^"']+)["']/g;
         let m;
         while ((m = imgRegex.exec(src2)) !== null) {
@@ -36857,7 +36971,7 @@ function collectImageRefs(appDir) {
   return refs;
 }
 async function optimizeImages(appDir, outDir) {
-  mkdirSync8(resolve16(outDir, "static", "public"), { recursive: true });
+  mkdirSync9(resolve17(outDir, "static", "public"), { recursive: true });
   const refs = collectImageRefs(appDir);
   if (refs.length === 0) {
     console.error("vesk images: no <Image> refs found");
@@ -36868,14 +36982,14 @@ async function optimizeImages(appDir, outDir) {
   for (const ref2 of refs) {
     const rel = ref2.src.replace(/^\//, "");
     const possiblePaths = [
-      resolve16(appDir, rel),
-      resolve16(appDir, "..", "public", rel),
-      resolve16(appDir, "..", "src", rel),
-      resolve16(outDir, "static", "public", rel)
+      resolve17(appDir, rel),
+      resolve17(appDir, "..", "public", rel),
+      resolve17(appDir, "..", "src", rel),
+      resolve17(outDir, "static", "public", rel)
     ];
     let srcPath = null;
     for (const p of possiblePaths) {
-      if (existsSync18(p)) {
+      if (existsSync19(p)) {
         srcPath = p;
         break;
       }
@@ -36890,8 +37004,8 @@ async function optimizeImages(appDir, outDir) {
       continue;
     }
     const baseName = ref2.src.replace(/^\//, "").replace(extname5(ref2.src), "");
-    const imageOutDir = resolve16(outDir, "static", "public");
-    mkdirSync8(imageOutDir, { recursive: true });
+    const imageOutDir = resolve17(outDir, "static", "public");
+    mkdirSync9(imageOutDir, { recursive: true });
     const files = await processImage(srcPath, imageOutDir, baseName);
     results.push({ src: ref2.src, baseName, files, widths: OUTPUT_WIDTHS });
     console.error(`vesk images: ${ref2.src} \u2192 ${files.length} variants`);
@@ -36920,19 +37034,19 @@ var seo_audit_exports = {};
 __export(seo_audit_exports, {
   runSeoAudit: () => runSeoAudit
 });
-import { readFileSync as readFileSync19, existsSync as existsSync19, readdirSync as readdirSync5, statSync as statSync10 } from "node:fs";
-import { resolve as resolve17 } from "node:path";
+import { readFileSync as readFileSync22, existsSync as existsSync20, readdirSync as readdirSync7, statSync as statSync12 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
 function walkFiles(dir) {
   const results = [];
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync7(dir);
   } catch {
     return results;
   }
   for (const entry of entries) {
-    const full = resolve17(dir, entry);
-    const st = statSync10(full);
+    const full = resolve18(dir, entry);
+    const st = statSync12(full);
     if (st.isDirectory()) {
       if (!entry.startsWith("."))
         results.push(...walkFiles(full));
@@ -36946,10 +37060,10 @@ function collectCombinedSource(appDir) {
   const pages = files.filter((f) => f.endsWith("/page.vsk") || f.endsWith("\\page.vsk"));
   const combined = [];
   for (const pagePath of pages) {
-    const dir = resolve17(pagePath, "..");
-    const layoutPath = resolve17(dir, "layout.vsk");
-    const pageSrc = readFileSync19(pagePath, "utf-8");
-    const layoutSrc = existsSync19(layoutPath) ? readFileSync19(layoutPath, "utf-8") : "";
+    const dir = resolve18(pagePath, "..");
+    const layoutPath = resolve18(dir, "layout.vsk");
+    const pageSrc = readFileSync22(pagePath, "utf-8");
+    const layoutSrc = existsSync20(layoutPath) ? readFileSync22(layoutPath, "utf-8") : "";
     const combinedSrc = layoutSrc ? layoutSrc + "\n" + pageSrc : pageSrc;
     combined.push({
       path: pagePath,
@@ -37144,8 +37258,8 @@ var init_platform = __esm({
 });
 
 // ../adapter/src/platform-handler.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { resolve as resolve18, dirname as dirname13, join as join13 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { resolve as resolve19, dirname as dirname14, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function routeName2(segments) {
   const parts = segments.filter(Boolean).map((s) => {
@@ -37163,13 +37277,13 @@ function toId(s) {
 }
 function findCompilerSrc2(appDir) {
   const candidates = [
-    resolve18(__dirname5, "..", "..", "..", "packages", "compiler", "dist"),
-    resolve18(appDir, "..", "node_modules", "@vesk/compiler"),
-    resolve18(appDir, "node_modules", "@vesk/compiler")
+    resolve19(__dirname5, "..", "..", "..", "packages", "compiler", "dist"),
+    resolve19(appDir, "..", "node_modules", "@vesk/compiler"),
+    resolve19(appDir, "node_modules", "@vesk/compiler")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join13(base, "dist")]) {
-      if (existsSync20(join13(dir, "server-cookies.js"))) return dir;
+    for (const dir of [base, join15(base, "dist")]) {
+      if (existsSync21(join15(dir, "server-cookies.js"))) return dir;
     }
   }
   throw new Error('@vesk/compiler/dist not found \u2014 run "npm run build" first');
@@ -37209,7 +37323,7 @@ function generatePlatformHandlerSource(input) {
   const eventsRequestLine = hasEvents ? "  await __eventsRequest(mwCtx);" : "";
   const localsSeed = hasEvents ? "Object.assign({}, __serverStore)" : "{}";
   const compilerSrc = findCompilerSrc2(appDir);
-  const parseCookiesImport = hasMiddleware ? `import { parseCookies } from ${JSON.stringify(resolve18(compilerSrc, "server-cookies.js"))};` : "";
+  const parseCookiesImport = hasMiddleware ? `import { parseCookies } from ${JSON.stringify(resolve19(compilerSrc, "server-cookies.js"))};` : "";
   return `
 ${imports}
 ${parseCookiesImport}
@@ -37459,121 +37573,7 @@ var init_platform_handler = __esm({
   "../adapter/src/platform-handler.ts"() {
     "use strict";
     init_default_pages();
-    __dirname5 = dirname13(fileURLToPath4(import.meta.url));
-  }
-});
-
-// ../adapter/src/platform-output.ts
-import {
-  mkdirSync as mkdirSync9,
-  copyFileSync as copyFileSync3,
-  readdirSync as readdirSync6,
-  statSync as statSync11,
-  existsSync as existsSync21,
-  writeFileSync as writeFileSync10,
-  rmSync as rmSync2,
-  readFileSync as readFileSync20
-} from "node:fs";
-import { resolve as resolve19, join as join14, extname as extname6, dirname as dirname14 } from "node:path";
-function ensureCleanDir(dir) {
-  rmSync2(dir, { recursive: true, force: true });
-  mkdirSync9(dir, { recursive: true });
-}
-function copyDirContents(srcDir, destDir) {
-  if (!existsSync21(srcDir)) return;
-  mkdirSync9(destDir, { recursive: true });
-  for (const entry of readdirSync6(srcDir)) {
-    const srcPath = join14(srcDir, entry);
-    const destPath = join14(destDir, entry);
-    if (statSync11(srcPath).isDirectory()) {
-      copyDirContents(srcPath, destPath);
-    } else {
-      mkdirSync9(dirname14(destPath), { recursive: true });
-      copyFileSync3(srcPath, destPath);
-    }
-  }
-}
-function writeFile(path, content) {
-  mkdirSync9(dirname14(path), { recursive: true });
-  writeFileSync10(path, content, "utf-8");
-}
-function writePlatformStatic(buildStaticDir, platformStaticDir) {
-  mkdirSync9(platformStaticDir, { recursive: true });
-  const publicDir = resolve19(buildStaticDir, "public");
-  if (existsSync21(publicDir)) {
-    copyDirContents(publicDir, platformStaticDir);
-  }
-  const assetsDir = resolve19(platformStaticDir, "_vesk", "static");
-  copyDirContents(buildStaticDir, assetsDir);
-  const runtimeAlias = resolve19(platformStaticDir, "_vesk", "runtime.js");
-  const clientPath = resolve19(buildStaticDir, "client.js");
-  if (existsSync21(clientPath)) {
-    mkdirSync9(dirname14(runtimeAlias), { recursive: true });
-    copyFileSync3(clientPath, runtimeAlias);
-  }
-}
-function writePrerenderedStatic(prerenderedRoutes, platformStaticDir) {
-  for (const route of prerenderedRoutes) {
-    if (!existsSync21(route.html)) continue;
-    const content = readFileSync20(route.html);
-    const htmlRel = route.path === "/" ? "index.html" : `${route.path.replace(/^\//, "")}.html`;
-    const target = resolve19(platformStaticDir, "_vesk", "static", "public", htmlRel);
-    writeFile(target, content);
-    if (route.path !== "/" && route.path.endsWith("/")) {
-      const dirIndex = resolve19(platformStaticDir, "_vesk", "static", "public", `${route.path.replace(/^\//, "")}index.html`);
-      writeFile(dirIndex, content);
-    }
-  }
-}
-function listStaticDir(dir) {
-  const out = [];
-  if (!existsSync21(dir)) return out;
-  function walk9(d, prefix) {
-    for (const entry of readdirSync6(d)) {
-      const full = join14(d, entry);
-      const rel = prefix ? `${prefix}/${entry}` : entry;
-      if (statSync11(full).isDirectory()) {
-        walk9(full, rel);
-      } else {
-        out.push({ rel, buffer: readFileSync20(full) });
-      }
-    }
-  }
-  walk9(dir, "");
-  return out;
-}
-function mimeFor(path) {
-  return MIME2[extname6(path).toLowerCase()] || "application/octet-stream";
-}
-var MIME2;
-var init_platform_output = __esm({
-  "../adapter/src/platform-output.ts"() {
-    "use strict";
-    MIME2 = {
-      ".html": "text/html; charset=utf-8",
-      ".htm": "text/html; charset=utf-8",
-      ".js": "application/javascript; charset=utf-8",
-      ".mjs": "application/javascript; charset=utf-8",
-      ".css": "text/css; charset=utf-8",
-      ".json": "application/json; charset=utf-8",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".webp": "image/webp",
-      ".avif": "image/avif",
-      ".ico": "image/x-icon",
-      ".txt": "text/plain; charset=utf-8",
-      ".xml": "application/xml",
-      ".woff": "font/woff",
-      ".woff2": "font/woff2",
-      ".ttf": "font/ttf",
-      ".otf": "font/otf",
-      ".wasm": "application/wasm",
-      ".map": "application/json",
-      ".webmanifest": "application/manifest+json"
-    };
+    __dirname5 = dirname14(fileURLToPath4(import.meta.url));
   }
 });
 
@@ -42307,8 +42307,8 @@ __export(typecheck_exports, {
   formatTypecheckWarnings: () => formatTypecheckWarnings,
   typecheckProject: () => typecheckProject
 });
-import { readFileSync as readFileSync39, readdirSync as readdirSync14, statSync as statSync22 } from "node:fs";
-import { join as join27, dirname as dirname27, normalize, relative as relative8, resolve as resolve39, sep as sep7 } from "node:path";
+import { readFileSync as readFileSync41, readdirSync as readdirSync15, statSync as statSync23 } from "node:fs";
+import { join as join28, dirname as dirname27, normalize, relative as relative8, resolve as resolve39, sep as sep7 } from "node:path";
 import * as ts8 from "typescript";
 function walkProjectFiles(projectRoot) {
   const code = [];
@@ -42316,15 +42316,15 @@ function walkProjectFiles(projectRoot) {
   const walk9 = (dir) => {
     let entries = [];
     try {
-      entries = readdirSync14(dir);
+      entries = readdirSync15(dir);
     } catch {
       return;
     }
     for (const e of entries) {
-      const p = join27(dir, e);
+      const p = join28(dir, e);
       let st;
       try {
-        st = statSync22(p);
+        st = statSync23(p);
       } catch {
         continue;
       }
@@ -42376,8 +42376,8 @@ function checkStructureFile(appDir, file) {
   return null;
 }
 function createTypecheckHost(projectRoot, appDir, vskFiles) {
-  const ambientPath = join27(appDir, "__vesk_ambient.d.ts");
-  const overridePath = join27(appDir, "__vesk_runtime_override.d.ts");
+  const ambientPath = join28(appDir, "__vesk_ambient.d.ts");
+  const overridePath = join28(appDir, "__vesk_runtime_override.d.ts");
   const cached = /* @__PURE__ */ new Map();
   const scriptKindFor = (file) => file.endsWith(".vsk") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS;
   const host = {
@@ -42447,7 +42447,7 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
     directoryExists: (dir) => ts8.sys.directoryExists(dir),
     getDirectories: (dir) => {
       try {
-        return readdirSync14(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join27(dir, d.name));
+        return readdirSync15(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join28(dir, d.name));
       } catch {
         return [];
       }
@@ -42459,7 +42459,7 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
       return moduleLiterals.map(({ text }) => {
         if (text.endsWith(".vsk")) {
           const aliased = text.startsWith(".") ? null : resolveAliasModule(text, dirname27(containingFile));
-          const abs = normalize(aliased ?? join27(dirname27(containingFile), text));
+          const abs = normalize(aliased ?? join28(dirname27(containingFile), text));
           return {
             resolvedModule: {
               resolvedFileName: abs + ".d.ts",
@@ -42470,7 +42470,7 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
           };
         }
         if (text.endsWith(".css")) {
-          const abs = normalize(join27(dirname27(containingFile), text));
+          const abs = normalize(join28(dirname27(containingFile), text));
           return {
             resolvedModule: {
               resolvedFileName: abs + ".d.ts",
@@ -42517,7 +42517,7 @@ function sourcePosition(source, offset2) {
   return { line, character: bounded - lineStart + 1 };
 }
 function typecheckProject(projectRoot, opts = {}) {
-  const appDir = opts.appDir ?? join27(projectRoot, "app");
+  const appDir = opts.appDir ?? join28(projectRoot, "app");
   const vskFiles = /* @__PURE__ */ new Map();
   const parseErrors = [];
   const warnings = [];
@@ -42539,7 +42539,7 @@ function typecheckProject(projectRoot, opts = {}) {
       }
     }
     if (f.endsWith(".vsk")) {
-      const src2 = readFileSync39(f, "utf-8");
+      const src2 = readFileSync41(f, "utf-8");
       try {
         parse4(src2);
       } catch (e) {
@@ -42556,8 +42556,8 @@ function typecheckProject(projectRoot, opts = {}) {
     }
     rootNames.push(f);
   }
-  const ambientPath = join27(appDir, "__vesk_ambient.d.ts");
-  const overridePath = join27(appDir, "__vesk_runtime_override.d.ts");
+  const ambientPath = join28(appDir, "__vesk_ambient.d.ts");
+  const overridePath = join28(appDir, "__vesk_runtime_override.d.ts");
   rootNames.push(ambientPath);
   rootNames.push(overridePath);
   const options = {
@@ -48678,8 +48678,8 @@ __export(codemods_exports, {
   applicableCodemods: () => applicableCodemods,
   compareCore: () => compareCore
 });
-import { readFileSync as readFileSync40, existsSync as existsSync43 } from "node:fs";
-import { join as join28 } from "node:path";
+import { readFileSync as readFileSync42, existsSync as existsSync43 } from "node:fs";
+import { join as join29 } from "node:path";
 import { walk as walk8 } from "zimmerframe";
 function safeParse(source, filePath) {
   try {
@@ -48699,12 +48699,12 @@ function isVskFile(filePath) {
 }
 function typesPackageExports(projectDir) {
   const candidates = [
-    projectDir ? join28(projectDir, "node_modules", "@vesk", "types", "dist", "index.d.ts") : null,
+    projectDir ? join29(projectDir, "node_modules", "@vesk", "types", "dist", "index.d.ts") : null,
     new URL("../../types/dist/index.d.ts", import.meta.url).pathname
   ].filter((p) => typeof p === "string" && existsSync43(p));
   for (const path of candidates) {
     try {
-      const src2 = readFileSync40(path, "utf-8");
+      const src2 = readFileSync42(path, "utf-8");
       const names = /* @__PURE__ */ new Set();
       for (const line of src2.split("\n")) {
         const m = /^export\s+(?:declare\s+)?(?:abstract\s+)?(?:interface|class|type|enum|const|function|let|var|namespace)\s+([A-Za-z_$][\w$]*)/.exec(line);
@@ -48828,14 +48828,14 @@ __export(migrate_exports, {
   detectInstalledVersion: () => detectInstalledVersion,
   runMigrate: () => runMigrate
 });
-import { readFileSync as readFileSync41, writeFileSync as writeFileSync22, existsSync as existsSync44, statSync as statSync23, readdirSync as readdirSync15 } from "node:fs";
-import { join as join29, relative as relative9, extname as extname9 } from "node:path";
+import { readFileSync as readFileSync43, writeFileSync as writeFileSync22, existsSync as existsSync44, statSync as statSync24, readdirSync as readdirSync16 } from "node:fs";
+import { join as join30, relative as relative9, extname as extname8 } from "node:path";
 function detectInstalledVersion(projectDir, cliVersion) {
   for (const pkg of ["@vesk/vesk-cli", "@vesk/adapter", "@vesk/compiler"]) {
-    const p = join29(projectDir, "node_modules", pkg, "package.json");
+    const p = join30(projectDir, "node_modules", pkg, "package.json");
     if (!existsSync44(p)) continue;
     try {
-      const version2 = JSON.parse(readFileSync41(p, "utf-8")).version;
+      const version2 = JSON.parse(readFileSync43(p, "utf-8")).version;
       if (typeof version2 === "string" && version2) return { version: version2, source: pkg };
     } catch {
     }
@@ -48846,22 +48846,22 @@ function collectTargets(dir, root3 = dir) {
   const out = [];
   let entries;
   try {
-    entries = readdirSync15(dir);
+    entries = readdirSync16(dir);
   } catch {
     return out;
   }
   for (const entry of entries.sort()) {
     if (SKIP_DIRS2.has(entry)) continue;
-    const full = join29(dir, entry);
+    const full = join30(dir, entry);
     let st;
     try {
-      st = statSync23(full);
+      st = statSync24(full);
     } catch {
       continue;
     }
     if (st.isDirectory()) {
       out.push(...collectTargets(full, root3));
-    } else if (SCAN_EXTENSIONS.has(extname9(entry))) {
+    } else if (SCAN_EXTENSIONS.has(extname8(entry))) {
       out.push(relative9(root3, full));
     }
   }
@@ -48887,12 +48887,12 @@ function runMigrate(options) {
     return report;
   }
   for (const relPath of collectTargets(options.projectDir)) {
-    const abs = join29(options.projectDir, relPath);
+    const abs = join30(options.projectDir, relPath);
     const ctx2 = { filePath: abs, displayPath: relPath, projectDir: options.projectDir };
     if (!existsSync44(abs)) continue;
     let source;
     try {
-      source = readFileSync41(abs, "utf-8");
+      source = readFileSync43(abs, "utf-8");
     } catch (e) {
       report.skipped.push(`${relPath}: unreadable (${e.message})`);
       continue;
@@ -48932,8 +48932,8 @@ var init_migrate = __esm({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync42, writeFileSync as writeFileSync23, mkdirSync as mkdirSync20, existsSync as existsSync45 } from "fs";
-import { resolve as resolve40, join as join30 } from "path";
+import { readFileSync as readFileSync44, writeFileSync as writeFileSync23, mkdirSync as mkdirSync20, existsSync as existsSync45 } from "fs";
+import { resolve as resolve40, join as join31 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // ../adapter/dist/load-config.js
@@ -49511,8 +49511,8 @@ function setRuntimeModule2(mod) {
 }
 
 // ../adapter/dist/index.js
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync12, existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
-import { resolve as resolve21, dirname as dirname16, relative as relative4, basename as basename3, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync12, existsSync as existsSync22, readFileSync as readFileSync23 } from "node:fs";
+import { resolve as resolve21, dirname as dirname16, relative as relative4, basename as basename3, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../adapter/src/runtime-bundle.ts
@@ -51013,8 +51013,8 @@ async function compileEvents(appDir, outDir) {
 
 // ../adapter/src/client-bundle.ts
 init_esbuild_fallback();
-import { readFileSync as readFileSync11, existsSync as existsSync11, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, statSync as statSync3, rmSync, mkdtempSync, mkdirSync as mkdirSync3 } from "node:fs";
-import { resolve as resolve10, join as join7, dirname as dirname8, relative as relative2, sep } from "node:path";
+import { readFileSync as readFileSync13, existsSync as existsSync11, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, statSync as statSync4, rmSync, mkdtempSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { resolve as resolve10, join as join8, dirname as dirname8, relative as relative2, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { tmpdir } from "node:os";
 init_strip_ts();
@@ -51024,6 +51024,267 @@ init_vsk_collision();
 init_vsk_imports();
 init_md_inline();
 init_module_imports();
+
+// ../adapter/src/server-only-plugin.ts
+init_parser();
+import { readFileSync as readFileSync12 } from "node:fs";
+
+// ../adapter/src/server-only.ts
+init_parser();
+import { readFileSync as readFileSync11, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+var SERVER_ONLY_EXACT = /* @__PURE__ */ new Set([
+  "slintorm",
+  "@vesk/adapter"
+]);
+var TCP_DRIVERS = /* @__PURE__ */ new Set([
+  "pg",
+  "mysql2",
+  "mongodb",
+  "node:sqlite",
+  "node:net",
+  "node:tls"
+]);
+function classifySpecifier(spec) {
+  if (typeof spec !== "string" || spec.length === 0) return null;
+  if (TCP_DRIVERS.has(spec)) return "tcp-driver";
+  if (spec.startsWith("node:")) return "tcp-driver";
+  if (SERVER_ONLY_EXACT.has(spec)) return "server-only-package";
+  return null;
+}
+var REMEDY = {
+  "server-only-package": "import it from an API route (app/api/**/route.ts) or a server action instead of a component, or use the package's browser/edge entry point if it ships one.",
+  "tcp-driver": 'this driver opens a TCP socket, which no edge runtime provides. Use the driver\'s HTTP/HTTPS transport (for SlintORM: `driver: "postgrest"`), or build for a Node target.'
+};
+function scanServerOnlyImports(files) {
+  const out = [];
+  for (const file of files) {
+    let ast;
+    try {
+      ast = parse4(file.code);
+    } catch {
+      continue;
+    }
+    for (const node of ast.body ?? []) {
+      if (node?.type !== "ImportDeclaration" && node?.type !== "ExportNamedDeclaration" && node?.type !== "ExportAllDeclaration") continue;
+      const spec = node.source?.value;
+      if (typeof spec !== "string") continue;
+      const kind = classifySpecifier(spec);
+      if (!kind) continue;
+      out.push({
+        kind,
+        specifier: spec,
+        file: file.path,
+        line: lineOf(file.code, node.start),
+        remedy: REMEDY[kind]
+      });
+    }
+  }
+  return out;
+}
+function lineOf(code, offset2) {
+  if (typeof offset2 !== "number" || offset2 < 0 || offset2 > code.length) return null;
+  let line = 1;
+  for (let i = 0; i < offset2; i++) {
+    if (code.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+function edgeDriverBuildError(violations) {
+  const detail = violations.map((v) => `  ${v.file}${v.line ? `:${v.line}` : ""} \u2014 import "${v.specifier}"
+    ${v.remedy}`).join("\n");
+  return new Error(
+    `[vesk] edge-targeted build cannot include a TCP-only driver (${violations.length} found).
+${detail}
+
+This was a build error rather than a runtime one because an edge runtime has no socket: the deployed function would fail on its first query.`
+  );
+}
+var SOCKETLESS_PLATFORMS = /* @__PURE__ */ new Set(["edge", "cloudflare", "deno", "coxmos"]);
+function isSocketlessTarget(platform, target) {
+  if (target === "edge") return true;
+  return typeof platform === "string" && SOCKETLESS_PLATFORMS.has(platform);
+}
+var SOURCE_EXTENSIONS = [".vsk", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var SKIPPED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".vesk", ".git", "dist", ".next", ".output", "coverage"]);
+function collectAppSources(dir, out = []) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (SKIPPED_DIRS.has(entry) || entry.startsWith(".")) continue;
+    const full = join7(dir, entry);
+    let st;
+    try {
+      st = statSync3(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) collectAppSources(full, out);
+    else if (st.isFile()) {
+      const dot = entry.lastIndexOf(".");
+      if (dot === -1) continue;
+      if (SOURCE_EXTENSIONS.includes(entry.slice(dot).toLowerCase())) out.push(full);
+    }
+  }
+  return out;
+}
+function tcpDriverViolations(appDir) {
+  const files = [];
+  for (const path of collectAppSources(appDir)) {
+    try {
+      files.push({ path, code: readFileSync11(path, "utf-8") });
+    } catch {
+    }
+  }
+  return scanServerOnlyImports(files).filter((v) => v.kind === "tcp-driver");
+}
+
+// ../adapter/src/server-only-plugin.ts
+var STUB_NAMESPACE = "vesk-server-only";
+var stubCounter = 0;
+function importedNamesFor(code, specifier) {
+  let ast;
+  try {
+    ast = parse4(code);
+  } catch {
+    return [];
+  }
+  const names = [];
+  const sourceOf = (node) => {
+    const src2 = node.source;
+    if (typeof src2 === "string") return src2;
+    const v = src2?.value;
+    return typeof v === "string" ? v : null;
+  };
+  for (const node of ast.body ?? []) {
+    if (node?.type === "ImportDeclaration") {
+      if (sourceOf(node) !== specifier) continue;
+      for (const spec of node.specifiers ?? []) {
+        if (spec.type === "ImportNamespaceSpecifier") continue;
+        const local = spec.local?.name;
+        if (typeof local === "string" && !names.includes(local)) names.push(local);
+      }
+      continue;
+    }
+    if (node?.type === "ExportAllDeclaration" || node?.type === "ExportNamedDeclaration") {
+      if (sourceOf(node) !== specifier) continue;
+      for (const spec of node.specifiers ?? []) {
+        const imported = spec.imported?.name ?? spec.imported?.value ?? spec.local?.name;
+        if (typeof imported === "string" && !names.includes(imported)) names.push(imported);
+      }
+    }
+  }
+  return names;
+}
+function stubFactorySource(specifier) {
+  const template2 = '"$1" comes from "$0", which is server-only. It reached the browser bundle because a component (or a module one imports) imported it \u2014 component code runs in the browser, where this module cannot work. Move the server-only work into an API route (app/api/**/route.ts) or a server action and call it over HTTP, or import the edge/browser-safe entry if the package ships one.';
+  return [
+    "function __vesk_stub(binding) {",
+    "  var message = " + JSON.stringify(template2) + ";",
+    '  message = message.replace("$0", ' + JSON.stringify(specifier) + ').replace("$1", String(binding));',
+    "  var thrower = function () { throw Object.assign(new Error(message), { __veskServerOnly: " + JSON.stringify(specifier) + " }); };",
+    "  return new Proxy(function () {}, {",
+    "    get: thrower,",
+    "    apply: thrower,",
+    "    construct: thrower",
+    "  });",
+    "}"
+  ].join("\n");
+}
+function referencedAtTopLevel(code, name) {
+  let ast;
+  try {
+    ast = parse4(code);
+  } catch {
+    return true;
+  }
+  let found = false;
+  const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "ArrowFunctionExpression",
+    "ClassMethod",
+    "ObjectMethod",
+    "ClassDeclaration",
+    "ClassExpression"
+  ]);
+  const SKIP_KEYS = /* @__PURE__ */ new Set(["type", "start", "end", "loc", "range", "raw", "regex"]);
+  const SKIP_EXPORT_NAMED_KEYS = /* @__PURE__ */ new Set([...SKIP_KEYS, "source", "specifiers", "exportKind", "attributes"]);
+  const visit = (node, parentKey, fnDepth) => {
+    if (found || node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child, parentKey, fnDepth);
+      return;
+    }
+    const n = node;
+    if (n.type === "MemberExpression" || n.type === "Property" || n.type === "PropertyDefinition" || n.type === "MethodDefinition") {
+      const prop = n.property ?? n.key;
+      if (prop && typeof prop === "object" && prop.name === name && n.computed !== true) return;
+    }
+    if (n.type === "ImportDeclaration" || n.type === "ExportAllDeclaration" || n.type === "ImportExpression") return;
+    if (n.type === "Identifier" && n.name === name) {
+      if (parentKey === "local" || parentKey === "id" || parentKey === "params" || parentKey === "key") return;
+      if (fnDepth === 0) found = true;
+      return;
+    }
+    const skip = n.type === "ExportNamedDeclaration" ? SKIP_EXPORT_NAMED_KEYS : SKIP_KEYS;
+    const nextDepth = FUNCTION_TYPES.has(String(n.type)) ? fnDepth + 1 : fnDepth;
+    for (const [key, value] of Object.entries(n)) {
+      if (skip.has(key)) continue;
+      visit(value, key, nextDepth);
+    }
+  };
+  visit(ast.body, void 0, 0);
+  return found;
+}
+function serverOnlyPlugin(options = {}) {
+  const stubs = /* @__PURE__ */ new Map();
+  return {
+    name: "vesk-server-only",
+    setup(build4) {
+      build4.onResolve({ filter: /.*/ }, (args2) => {
+        const kind = classifySpecifier(args2.path);
+        if (!kind) return null;
+        if (kind === "tcp-driver") {
+          options.onDriver?.({ specifier: args2.path, importer: args2.importer });
+          return null;
+        }
+        let names = [];
+        let importerCode = "";
+        try {
+          importerCode = readFileSync12(args2.importer, "utf-8");
+          names = importedNamesFor(importerCode, args2.path);
+        } catch {
+        }
+        const eager = names.filter((n) => referencedAtTopLevel(importerCode, n));
+        if (eager.length > 0) {
+          options.onEager?.({ specifier: args2.path, bindings: eager, importer: args2.importer });
+          return null;
+        }
+        const id = `vesk-stub-${stubCounter++}`;
+        stubs.set(id, [
+          stubFactorySource(args2.path),
+          'export default __vesk_stub("default");',
+          ...names.map((n) => `export const ${n} = __vesk_stub(${JSON.stringify(n)});`)
+        ].join("\n"));
+        for (const binding of names) {
+          options.onStub?.({ specifier: args2.path, binding, importer: args2.importer });
+        }
+        return { path: id, namespace: STUB_NAMESPACE };
+      });
+      build4.onLoad({ filter: /.*/, namespace: STUB_NAMESPACE }, (args2) => ({
+        contents: stubs.get(args2.path) ?? stubFactorySource("unknown"),
+        loader: "js"
+      }));
+    }
+  };
+}
+
+// ../adapter/src/client-bundle.ts
 import { availableParallelism } from "node:os";
 async function mapWithConcurrency(items, limit, fn) {
   const out = new Array(items.length);
@@ -51051,7 +51312,7 @@ async function mapWithConcurrency(items, limit, fn) {
 var __dirname3 = dirname8(fileURLToPath2(import.meta.url));
 function fileUnchanged(filePath, cached) {
   try {
-    const st = statSync3(filePath);
+    const st = statSync4(filePath);
     return st.mtimeMs === cached.mtimeMs && st.size === cached.size;
   } catch {
     return false;
@@ -51072,8 +51333,8 @@ function findRuntimeSrc2(appDir) {
     resolve10(appDir, "node_modules", "@vesk/runtime")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join7(base, "dist")]) {
-      if (existsSync11(join7(dir, "index-client.js"))) return dir;
+    for (const dir of [base, join8(base, "dist")]) {
+      if (existsSync11(join8(dir, "index-client.js"))) return dir;
     }
   }
   throw new Error('@vesk/runtime/dist not found \u2014 run "npm run build" first');
@@ -51179,6 +51440,17 @@ function nativeLibraryImportStubs(code) {
   });
   return lines.join("\n") + "\n\n";
 }
+function reportServerOnlyImports(chunkName, hits, strict) {
+  const detail = [...new Set(hits.map((h) => `"${h.binding}" from "${h.specifier}"`))].join(", ");
+  if (strict) {
+    throw new Error(
+      `[vesk] ${chunkName} imports a server-only package in client code: ${detail}. Move that work into an API route (app/api/**/route.ts) or a server action. Pass without --strict to allow it (the binding is replaced by a throwing stub).`
+    );
+  }
+  console.error(
+    `[vesk] ${chunkName}: removed server-only import from client code (${detail}). It is replaced by a stub that throws if the component calls it at runtime \u2014 server-only work belongs in an API route or a server action.`
+  );
+}
 function demoteExports(code) {
   let ast;
   try {
@@ -51209,7 +51481,7 @@ function chunkHasImports(headLen, mergeAborted) {
 function runtimeImportsOf(filePath) {
   let text;
   try {
-    text = readFileSync11(filePath, "utf8");
+    text = readFileSync13(filePath, "utf8");
   } catch {
     return [];
   }
@@ -51502,11 +51774,11 @@ async function generateClientBundle(routeTree, appDir, componentMap, options) {
     return removeCompiledNodes(code, isVskImport);
   }
   function resolveVskImports(filePath, compile) {
-    const src2 = readFileSync11(filePath, "utf-8");
+    const src2 = readFileSync13(filePath, "utf-8");
     const resolved = [];
     for (const importPath of collectVskImportPaths(vskImportLines(src2), filePath)) {
       try {
-        readFileSync11(importPath);
+        readFileSync13(importPath);
       } catch {
         continue;
       }
@@ -51564,7 +51836,7 @@ async function generateClientBundle(routeTree, appDir, componentMap, options) {
     compiledFiles++;
     __stats.compiled++;
     __stats.distinct.add(filePath);
-    let src2 = readFileSync11(filePath, "utf-8");
+    let src2 = readFileSync13(filePath, "utf-8");
     if (/content=["'][^"']*\.md["']/i.test(src2)) {
       src2 = inlineMdContentAttrs(src2, dirname8(filePath), guessProjectRoots(appDir));
     }
@@ -51599,7 +51871,7 @@ async function generateClientBundle(routeTree, appDir, componentMap, options) {
     }
     for (const reexportPath of reexportPaths || []) compileFile2(reexportPath, null, output, imports);
     if (cache2 && namesBefore) {
-      const st = statSync3(filePath);
+      const st = statSync4(filePath);
       cache2.files.set(filePath, {
         mtimeMs: st.mtimeMs,
         size: st.size,
@@ -51725,9 +51997,9 @@ ${body}
     let sharedBundleCode = "";
     const sharedRuntimeNames = /* @__PURE__ */ new Set();
     if (sharedSources.length > 0) {
-      const tmpBase = mkdtempSync(join7(resolve10(appDir, ".."), "tmp-vesk-shared-"));
+      const tmpBase = mkdtempSync(join8(resolve10(appDir, ".."), "tmp-vesk-shared-"));
       try {
-        const sharedEntry = join7(tmpBase, "shared-entry.js");
+        const sharedEntry = join8(tmpBase, "shared-entry.js");
         const lines = [];
         const members = [];
         sharedSources.forEach((source, i) => {
@@ -51737,7 +52009,7 @@ ${body}
         lines.push(`globalThis.__veskShared = { ${members.join("\n")} };`);
         writeFileSync4(sharedEntry, lines.join("\n"));
         const appTsconfig = findTsconfigPath(appDir);
-        const runtimeShim = join7(tmpBase, "runtime-shim.js");
+        const runtimeShim = join8(tmpBase, "runtime-shim.js");
         const runtimeLines = [
           "// ONE runtime instance: the entry bundle publishes these on globalThis,",
           "// and route chunks import the same functions. A second bundled copy",
@@ -51777,7 +52049,7 @@ ${body}
             bindings.named.forEach((n) => named.add(n));
             hasDefault = hasDefault || bindings.hasDefault;
           }
-          const shim = join7(tmpBase, `shim-${i}.js`);
+          const shim = join8(tmpBase, `shim-${i}.js`);
           const shimLines = [`const m = globalThis.__veskShared[${JSON.stringify(source)}];`];
           if (hasDefault) shimLines.push(`export default m;`);
           for (const name of [...named].sort()) {
@@ -51805,13 +52077,21 @@ ${body}
       if (!entry.code.trim()) return null;
       let finalCode;
       if (entry.imports) {
-        const tmpBase = mkdtempSync(join7(resolve10(appDir, ".."), "tmp-vesk-chunk-"));
-        const tmpFile = join7(tmpBase, "entry.js");
+        const tmpBase = mkdtempSync(join8(resolve10(appDir, ".."), "tmp-vesk-chunk-"));
+        const tmpFile = join8(tmpBase, "entry.js");
         const toBundle = `const __components = globalThis.__components || (globalThis.__components = {});
 const __hydrators = globalThis.__hydrators || (globalThis.__hydrators = {});
 ${entry.code}
 `;
         writeFileSync4(tmpFile, toBundle);
+        const serverOnlyHits = [];
+        const driverHits = [];
+        const eagerHits = [];
+        const serverOnlyGuard = serverOnlyPlugin({
+          onStub: (hit) => serverOnlyHits.push(hit),
+          onDriver: (hit) => driverHits.push(hit),
+          onEager: (hit) => eagerHits.push(hit)
+        });
         try {
           const appTsconfig = findTsconfigPath(appDir);
           const result = await build({
@@ -51835,7 +52115,7 @@ ${entry.code}
             // shared-modules.js serves every route chunk. (esbuild's `alias`
             // option only accepts bare package names, so this is a resolver
             // rather than a map.)
-            ...sharedRedirectPlugin ? { plugins: [sharedRedirectPlugin] } : {},
+            ...sharedRedirectPlugin ? { plugins: [sharedRedirectPlugin, serverOnlyGuard] } : { plugins: [serverOnlyGuard] },
             ...appTsconfig ? { tsconfig: appTsconfig } : {}
           });
           finalCode = result.outputFiles[0].text;
@@ -51857,6 +52137,24 @@ ${entry.code}
           } catch {
           }
         }
+        if (eagerHits.length > 0) {
+          const detail = eagerHits.map((h) => `${h.importer} uses ${h.bindings.map((b) => `"${b}"`).join(", ")} from "${h.specifier}" at module scope`).join("; ");
+          console.error("[vesk] server-only package used at module scope in client code", entry.name + ":", detail);
+          throw new Error(
+            `[vesk] ${entry.name}: ${detail}.
+A module-scope statement runs the moment the browser evaluates the chunk, so a server-only package cannot be substituted there. Move that work into an API route (app/api/**/route.ts) or a server action \u2014 if the binding is only used from inside a function, this build already handles it.`
+          );
+        }
+        if (driverHits.length > 0) {
+          const detail = [...new Set(driverHits.map((h) => `${h.specifier} (from ${h.importer})`))].join(", ");
+          console.error("[vesk] chunk bundle contains a TCP-only driver", entry.name + ":", detail);
+          throw new Error(
+            `[vesk] ${entry.name} pulls a TCP-only driver into the browser bundle: ${detail}. A browser cannot open a socket. Import the package's edge/browser-safe entry if it ships one, or keep database access in an API route (app/api/**/route.ts) or a server action.`
+          );
+        }
+        if (serverOnlyHits.length > 0) {
+          reportServerOnlyImports(entry.name, serverOnlyHits, options?.strict);
+        }
       } else {
         finalCode = chunkIIFE(demoteExports(entry.code));
       }
@@ -51891,7 +52189,7 @@ ${entry.code}
     let compileFileMono2 = function(filePath, resolvedName) {
       if (seen.has(filePath)) return;
       seen.add(filePath);
-      const src2 = readFileSync11(filePath, "utf-8");
+      const src2 = readFileSync13(filePath, "utf-8");
       resolveVskImports(filePath, (p, n) => compileFileMono2(p, n || ""));
       for (const cn of vskComponentNames(src2, filePath)) componentOwners.claim(cn, filePath);
       const monoAlloc = nameAllocFor(filePath);
@@ -51973,9 +52271,9 @@ function buildRuntimeCode(runtimeDir) {
   ];
   let code = "";
   for (const f of runtimeFiles) {
-    const p = join7(runtimeDir, f);
+    const p = join8(runtimeDir, f);
     if (existsSync11(p)) {
-      let src2 = readFileSync11(p, "utf-8");
+      let src2 = readFileSync13(p, "utf-8");
       src2 = stripTypes(src2);
       src2 = src2.replace(/^import\s+[\s\S]*?from\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
       src2 = src2.replace(/^import\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
@@ -51987,7 +52285,7 @@ ${src2}
 `;
     }
   }
-  const indexSrc = readFileSync11(join7(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync13(join8(runtimeDir, "index-client.js"), "utf-8");
   const exportNames = stripTypes(indexSrc).match(/export\s*\{\s*([^}]+)\s*\}\s*from/g)?.flatMap((m) => m.replace(/export\s*\{\s*|\s*\}\s*from/g, "").split(",").map((s) => s.trim())) || [];
   code += "// --- exports ---\n";
   for (const name of [...new Set(exportNames)]) {
@@ -51997,7 +52295,7 @@ ${src2}
   return code;
 }
 function runtimeExportNames(runtimeDir) {
-  const indexSrc = readFileSync11(join7(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync13(join8(runtimeDir, "index-client.js"), "utf-8");
   const names = /* @__PURE__ */ new Set();
   for (const m of indexSrc.matchAll(/export\s*\{([^}]+)\}\s*from/g)) {
     for (const raw2 of m[1].split(",")) {
@@ -52012,7 +52310,7 @@ function esbuildPath(p) {
   return sep === "/" ? p : p.split(sep).join("/");
 }
 function runtimeTreeShakeEntry() {
-  return join7(tmpdir(), "vesk-runtime-tree-shake", RUNTIME_ENTRY);
+  return join8(tmpdir(), "vesk-runtime-tree-shake", RUNTIME_ENTRY);
 }
 var treeShakeQueue = Promise.resolve();
 function buildTreeShakenRuntime(runtimeDir, usedNames) {
@@ -52035,7 +52333,7 @@ async function buildTreeShakenRuntimeNow(runtimeDir, usedNames) {
 async function bundleRuntimeNames(runtimeDir, names, strict = false) {
   if (names.length === 0) return null;
   const entry = runtimeTreeShakeEntry();
-  const indexClient = esbuildPath(join7(runtimeDir, "index-client.js"));
+  const indexClient = esbuildPath(join8(runtimeDir, "index-client.js"));
   const unique = [...new Set(names)];
   try {
     try {
@@ -52249,19 +52547,19 @@ function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middleware
 
 // ../adapter/src/static.ts
 init_paths();
-import { mkdirSync as mkdirSync4, copyFileSync, readdirSync as readdirSync2, statSync as statSync5, existsSync as existsSync13, writeFileSync as writeFileSync5, readFileSync as readFileSync13 } from "node:fs";
-import { resolve as resolve12, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync4, copyFileSync, readdirSync as readdirSync3, statSync as statSync6, existsSync as existsSync13, writeFileSync as writeFileSync5, readFileSync as readFileSync15 } from "node:fs";
+import { resolve as resolve12, join as join9 } from "node:path";
 function copyStaticAssets(publicDir, outDir) {
   const targetDir = resolve12(outDir, "static", "public");
   mkdirSync4(targetDir, { recursive: true });
   if (!existsSync13(publicDir)) return;
   function copyDir(src2, dest) {
     mkdirSync4(dest, { recursive: true });
-    const entries = readdirSync2(src2);
+    const entries = readdirSync3(src2);
     for (const entry of entries) {
-      const srcPath = join8(src2, entry);
-      const destPath = join8(dest, entry);
-      const st = statSync5(srcPath);
+      const srcPath = join9(src2, entry);
+      const destPath = join9(dest, entry);
+      const st = statSync6(srcPath);
       if (st.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
@@ -52273,8 +52571,8 @@ function copyStaticAssets(publicDir, outDir) {
 }
 
 // ../adapter/src/prod-server.ts
-import { readFileSync as readFileSync15, existsSync as existsSync15, statSync as statSync6 } from "node:fs";
-import { resolve as resolve13, extname as extname3, dirname as dirname10, basename } from "node:path";
+import { readFileSync as readFileSync18, existsSync as existsSync16, statSync as statSync8 } from "node:fs";
+import { resolve as resolve14, dirname as dirname11, basename } from "node:path";
 import { createServer } from "node:http";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_server_utils();
@@ -52313,13 +52611,13 @@ async function reportServerError(err, options) {
 init_paths();
 
 // ../adapter/src/load-config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join9, dirname as dirname9 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync16, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join10, dirname as dirname9 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { createRequire as createRequire3 } from "node:module";
 async function loadVeskConfig2(projectDir) {
-  const jsPath = join9(projectDir, "vesk.config.js");
-  const tsPath = join9(projectDir, "vesk.config.ts");
+  const jsPath = join10(projectDir, "vesk.config.js");
+  const tsPath = join10(projectDir, "vesk.config.ts");
   let configPath2 = null;
   if (existsSync14(jsPath)) configPath2 = jsPath;
   else if (existsSync14(tsPath)) configPath2 = tsPath;
@@ -52327,10 +52625,10 @@ async function loadVeskConfig2(projectDir) {
   let raw2;
   if (configPath2.endsWith(".ts")) {
     const { transpile } = await import("typescript");
-    const src2 = readFileSync14(configPath2, "utf-8");
+    const src2 = readFileSync16(configPath2, "utf-8");
     let js = transpile(src2, { module: 99, target: 99 });
     const inject = { defineConfig, definePlugin, preset };
-    const projectRequire = createRequire3(join9(projectDir, "package.json"));
+    const projectRequire = createRequire3(join10(projectDir, "package.json"));
     const importRe = /import\s+(?:(?:\*\s*as\s+([\w$]+))|([\w$]+(?:\s*,\s*\{[^}]*\})?)|(\{[^}]*\}))\s+from\s+['"]([^'"]+)['"]\s*;?/g;
     let m;
     while ((m = importRe.exec(js)) !== null) {
@@ -52357,7 +52655,7 @@ async function loadVeskConfig2(projectDir) {
     const injectKeys = Object.keys(inject);
     js = `const {${injectKeys.join(",")}} = globalThis.__vesk_inject;
 ` + js;
-    const tmpFile = join9(projectDir, ".vesk", "config.loader.tmp.mjs");
+    const tmpFile = join10(projectDir, ".vesk", "config.loader.tmp.mjs");
     mkdirSync5(dirname9(tmpFile), { recursive: true });
     writeFileSync6(tmpFile, js, "utf-8");
     globalThis.__vesk_inject = inject;
@@ -52379,12 +52677,327 @@ async function loadVeskConfig2(projectDir) {
 
 // ../adapter/src/prod-server.ts
 init_default_pages();
-var __dirname4 = dirname10(fileURLToPath3(import.meta.url));
+
+// ../adapter/src/response-pipeline.ts
+import { createHash as createHash2 } from "node:crypto";
+import {
+  brotliCompress,
+  constants as zlibConstants,
+  createBrotliCompress,
+  createGzip,
+  gzip
+} from "node:zlib";
+import { promisify } from "node:util";
+var brotliCompressAsync = promisify(brotliCompress);
+var gzipAsync = promisify(gzip);
+function negotiateEncoding(header) {
+  if (!header) return null;
+  const value = Array.isArray(header) ? header.join(",") : header;
+  const q = {};
+  for (const part of value.split(",")) {
+    const seg = part.trim();
+    if (!seg) continue;
+    const semi = seg.indexOf(";");
+    const token = (semi === -1 ? seg : seg.slice(0, semi)).trim().toLowerCase();
+    if (!token) continue;
+    let weight = 1;
+    if (semi !== -1) {
+      for (const param of seg.slice(semi + 1).split(";")) {
+        const eq = param.indexOf("=");
+        if (eq === -1) continue;
+        if (param.slice(0, eq).trim().toLowerCase() !== "q") continue;
+        const parsed = Number.parseFloat(param.slice(eq + 1).trim());
+        if (Number.isFinite(parsed)) weight = parsed;
+      }
+    }
+    if (!(token in q)) q[token] = weight;
+  }
+  const star = q["*"];
+  const br = q["br"] !== void 0 ? q["br"] : star;
+  const gz = q["gzip"] !== void 0 ? q["gzip"] : star;
+  if (br !== void 0 && br > 0 && (gz === void 0 || gz <= 0 || br >= gz)) return "br";
+  if (gz !== void 0 && gz > 0) return "gzip";
+  return null;
+}
+function isCompressibleType(contentType) {
+  if (!contentType) return false;
+  const type = (contentType.split(";")[0] || "").trim().toLowerCase();
+  if (!type) return false;
+  if (type.startsWith("text/")) return true;
+  if (type === "image/svg+xml" || type === "image/x-icon" || type === "image/bmp") return true;
+  if (type.endsWith("+json") || type.endsWith("+xml")) return true;
+  switch (type) {
+    case "application/javascript":
+    case "application/x-javascript":
+    case "application/ecmascript":
+    case "application/json":
+    case "application/manifest+json":
+    case "application/ld+json":
+    case "application/graphql":
+    case "application/x-ndjson":
+    case "application/xml":
+    case "application/xhtml+xml":
+    case "application/rss+xml":
+    case "application/atom+xml":
+      return true;
+    default:
+      return false;
+  }
+}
+function etagFor(body) {
+  return `"${createHash2("sha1").update(body).digest("base64").slice(0, 27)}"`;
+}
+function ifNoneMatchSatisfied(header, etag) {
+  if (!header) return false;
+  const value = Array.isArray(header) ? header.join(",") : header;
+  const candidates = value.split(",").map((s) => s.trim()).filter(Boolean);
+  if (candidates.includes("*")) return true;
+  const strip = (s) => (s.startsWith("W/") ? s.slice(2) : s).trim();
+  const target = strip(etag);
+  for (const candidate of candidates) {
+    if (strip(candidate) === target) return true;
+  }
+  return false;
+}
+function getHeader(headers2, name) {
+  const wanted = name.toLowerCase();
+  for (const key of Object.keys(headers2)) {
+    if (key.toLowerCase() === wanted) {
+      const v = headers2[key];
+      if (v === void 0) return void 0;
+      return Array.isArray(v) ? v.join(", ") : String(v);
+    }
+  }
+  return void 0;
+}
+function hasNoStore(cacheControl) {
+  if (!cacheControl) return false;
+  return cacheControl.split(",").some((part) => part.trim().toLowerCase() === "no-store");
+}
+function withVary(current3, value) {
+  if (!current3) return value;
+  const existing2 = current3.split(",").map((s) => s.trim().toLowerCase());
+  if (existing2.includes(value.toLowerCase())) return current3;
+  if (existing2.includes("*")) return current3;
+  return `${current3}, ${value}`;
+}
+function installResponsePipeline(res, req, options = {}) {
+  const compressEnabled = options.compress !== false;
+  const etagEnabled = options.etag !== false;
+  const threshold = options.compressThreshold ?? 1024;
+  const brotliQuality = options.brotliQuality ?? 5;
+  const gzipLevel = options.gzipLevel ?? 6;
+  const realWriteHead = res.writeHead.bind(res);
+  const realWrite = res.write.bind(res);
+  const realEnd = res.end.bind(res);
+  const realFlushHeaders = res.flushHeaders.bind(res);
+  let pendingStatus = 200;
+  let pendingHeaders = {};
+  let flushed = false;
+  let streaming = false;
+  let streamCompressor = null;
+  function flush(extra) {
+    if (flushed) return;
+    flushed = true;
+    const headers2 = {};
+    for (const [key, value] of Object.entries(pendingHeaders)) {
+      if (value !== void 0) headers2[key] = value;
+    }
+    for (const [key, value] of Object.entries(extra || {})) {
+      if (value === void 0) delete headers2[key];
+      else headers2[key] = value;
+    }
+    realWriteHead(pendingStatus, headers2);
+  }
+  res.writeHead = ((statusCode, headers2) => {
+    if (flushed || streaming) return realWriteHead(statusCode, headers2);
+    pendingStatus = statusCode;
+    pendingHeaders = { ...headers2 || {} };
+    return res;
+  });
+  function encodingIsVariable() {
+    return compressEnabled && !getHeader(pendingHeaders, "content-encoding") && isCompressibleType(getHeader(pendingHeaders, "content-type"));
+  }
+  function startStreamCompression(encoding) {
+    const compressor = encoding === "br" ? createBrotliCompress({ params: { [zlibConstants.BROTLI_PARAM_QUALITY]: brotliQuality } }) : createGzip({ level: gzipLevel });
+    compressor.on("data", (chunk) => {
+      realWrite(chunk);
+    });
+    compressor.on("end", () => {
+      realEnd();
+    });
+    compressor.on("error", () => {
+      try {
+        realEnd();
+      } catch {
+      }
+    });
+    streamCompressor = compressor;
+  }
+  res.write = ((chunk, encoding) => {
+    if (!flushed && !streaming) {
+      streaming = true;
+      const vary = withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding");
+      const encodingChosen = encodingIsVariable() ? negotiateEncoding(req.headers["accept-encoding"]) : null;
+      if (encodingChosen) {
+        startStreamCompression(encodingChosen);
+        flush({ "Content-Encoding": encodingChosen, Vary: vary, "Content-Length": void 0 });
+      } else {
+        flush({ Vary: encodingIsVariable() ? vary : void 0 });
+      }
+    }
+    if (streamCompressor) {
+      streamCompressor.write(toBuffer(chunk, encoding) || Buffer.alloc(0));
+      return true;
+    }
+    return typeof encoding === "undefined" ? realWrite(chunk) : realWrite(chunk, encoding);
+  });
+  res.flushHeaders = (() => {
+    if (!flushed) {
+      streaming = true;
+      flush();
+    }
+    realFlushHeaders.call(res);
+  });
+  function toBuffer(chunk, encoding) {
+    if (chunk === void 0 || chunk === null) return null;
+    if (Buffer.isBuffer(chunk)) return chunk;
+    if (typeof chunk === "string") {
+      return Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+    }
+    if (chunk instanceof Uint8Array) return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    return null;
+  }
+  function finish(body, endArgs) {
+    const method = (req.method || "GET").toUpperCase();
+    if (!body || body.length === 0 || streaming || flushed) {
+      flush();
+      realEnd(...endArgs);
+      return;
+    }
+    const cacheable = method === "GET" || method === "HEAD";
+    const existingEtag = getHeader(pendingHeaders, "etag");
+    const canValidate = cacheable && pendingStatus === 200 && !hasNoStore(getHeader(pendingHeaders, "cache-control"));
+    if (!canValidate) {
+      maybeCompress(body, endArgs);
+      return;
+    }
+    const etag = existingEtag || (etagEnabled ? etagFor(body) : void 0);
+    if (etag && ifNoneMatchSatisfied(req.headers["if-none-match"], etag)) {
+      const headers304 = { ETag: etag };
+      const cc = getHeader(pendingHeaders, "cache-control");
+      if (cc) headers304["Cache-Control"] = cc;
+      headers304.Vary = withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding");
+      flushed = true;
+      realWriteHead(304, headers304);
+      realEnd();
+      return;
+    }
+    if (etag && !existingEtag) {
+      pendingHeaders = { ...pendingHeaders, ETag: etag };
+    }
+    maybeCompress(body, endArgs);
+  }
+  function maybeCompress(body, endArgs) {
+    if (compressEnabled && body.length < threshold || !encodingIsVariable()) {
+      flush();
+      realEnd(...endArgs);
+      return;
+    }
+    const encoding = negotiateEncoding(req.headers["accept-encoding"]);
+    if (!encoding) {
+      flush({ Vary: withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding") });
+      realEnd(...endArgs);
+      return;
+    }
+    const compress = encoding === "br" ? brotliCompressAsync : gzipAsync;
+    const params = encoding === "br" ? { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: brotliQuality } } : { level: gzipLevel };
+    void Promise.resolve().then(() => compress(body, params)).then((encoded) => {
+      if (flushed || streaming) {
+        flush();
+        realEnd(...endArgs);
+        return;
+      }
+      if (encoded.length >= body.length) {
+        flush({ Vary: withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding") });
+        realEnd(...endArgs);
+        return;
+      }
+      flush({
+        "Content-Encoding": encoding,
+        Vary: withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding"),
+        "Content-Length": String(encoded.length)
+      });
+      realEnd(encoded);
+    }).catch(() => {
+      flush({ Vary: withVary(getHeader(pendingHeaders, "vary"), "Accept-Encoding") });
+      realEnd(...endArgs);
+    });
+  }
+  res.end = ((chunk, encoding, callback) => {
+    if (streamCompressor) {
+      if (typeof callback === "function") res.once("finish", callback);
+      const tail = toBuffer(chunk, encoding);
+      if (tail) streamCompressor.end(tail);
+      else streamCompressor.end();
+      return res;
+    }
+    if (streaming || flushed) {
+      return realEnd(chunk, encoding, callback);
+    }
+    const endArgs = chunk === void 0 ? callback === void 0 ? [] : [callback] : encoding === void 0 ? callback === void 0 ? [chunk] : [chunk, callback] : callback === void 0 ? [chunk, encoding] : [chunk, encoding, callback];
+    const body = toBuffer(chunk, encoding);
+    finish(body, endArgs);
+    return res;
+  });
+}
+
+// ../adapter/src/prod-server.ts
+init_platform_output();
+var __dirname4 = dirname11(fileURLToPath3(import.meta.url));
+var STREAMING_TYPES = /* @__PURE__ */ new Set(["text/event-stream", "application/x-ndjson"]);
+var DELIVER_BUFFER_LIMIT = 1024 * 1024;
 async function deliverResponse(res, response) {
-  res.writeHead(response.status, Object.fromEntries(response.headers));
+  const headers2 = Object.fromEntries(response.headers);
   const body = response.body;
-  if (body && typeof body.getReader === "function") {
-    const reader = body.getReader();
+  if (!body || typeof body.getReader !== "function") {
+    res.writeHead(response.status, headers2);
+    res.end(await response.text());
+    return;
+  }
+  const contentType = String(response.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
+  const reader = body.getReader();
+  if (STREAMING_TYPES.has(contentType)) {
+    res.writeHead(response.status, headers2);
+    pumpRemaining(res, reader);
+    return;
+  }
+  const chunks = [];
+  let size = 0;
+  let overflow = false;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(Buffer.from(value));
+      size += value.byteLength;
+      if (size > DELIVER_BUFFER_LIMIT) {
+        overflow = true;
+        break;
+      }
+    }
+  } catch {
+  }
+  res.writeHead(response.status, headers2);
+  if (overflow) {
+    for (const chunk of chunks) res.write(chunk);
+    pumpRemaining(res, reader);
+    return;
+  }
+  res.end(Buffer.concat(chunks));
+}
+function pumpRemaining(res, reader) {
+  void (async () => {
     try {
       for (; ; ) {
         const { done, value } = await reader.read();
@@ -52394,9 +53007,7 @@ async function deliverResponse(res, response) {
     } catch {
     }
     res.end();
-    return;
-  }
-  res.end(await response.text());
+  })();
 }
 function bodyTooLarge(maxBytes) {
   const err = new Error(`Request body exceeds limit (${maxBytes} bytes)`);
@@ -52457,49 +53068,42 @@ function makeWebRequest(nodeReq, url, maxBodyBytes = DEFAULT_MAX_BODY_BYTES) {
   webRequest.query = query;
   return webRequest;
 }
-var MIME = {
-  ".svg": "image/svg+xml",
-  ".css": "text/css",
-  ".js": "application/javascript",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".ico": "image/x-icon",
-  ".html": "text/html",
-  ".json": "application/json",
-  ".webmanifest": "application/manifest+json",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".wasm": "application/wasm"
-};
 async function startProdServer(outDir, options) {
   const port = options?.port || 3e3;
   const host = options?.host || "127.0.0.1";
   const maxBodyBytes = options?.maxBodyBytes || DEFAULT_MAX_BODY_BYTES;
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
-  const staticDir = resolve13(outDir, "static");
-  const configPath2 = resolve13(outDir, "config.json");
-  installMdReadHook([resolve13(staticDir, "public")]);
-  if (!existsSync15(configPath2)) {
+  const staticDir = resolve14(outDir, "static");
+  const configPath2 = resolve14(outDir, "config.json");
+  installMdReadHook([resolve14(staticDir, "public")]);
+  if (!existsSync16(configPath2)) {
     console.error(`vesk start: no build found at ${outDir}`);
     console.error('Run "vesk build" first');
     process.exit(1);
   }
-  const buildConfig = JSON.parse(readFileSync15(configPath2, "utf-8"));
+  const buildConfig = JSON.parse(readFileSync18(configPath2, "utf-8"));
   const bakedHeadExtra = buildConfig.headExtra || "";
   console.error(`vesk start: serving from ${outDir}`);
-  const projectDir = resolve13(outDir, "..");
+  const projectDir = resolve14(outDir, "..");
   let securityConfig = {};
   let mdConfig;
+  let compressionConfig = {};
+  let healthCheckEnabled = true;
   try {
     const config = await loadVeskConfig2(projectDir);
     if (config) {
       securityConfig = { security: config.security };
       mdConfig = config.md;
+      compressionConfig = config.compression === false ? { enabled: false } : config.compression || {};
+      healthCheckEnabled = config.healthCheck !== false;
     }
   } catch (e) {
     console.error("vesk start: failed to load vesk.config \u2014 falling back to secure defaults:", e instanceof Error ? e.message : e);
   }
+  if (options?.compression !== void 0) {
+    compressionConfig = options.compression === false ? { enabled: false } : options.compression;
+  }
+  if (options?.healthCheck !== void 0) healthCheckEnabled = options.healthCheck !== false;
   if (mdConfig) {
     try {
       const { configureMd: configureMd3 } = await Promise.resolve().then(() => (init_md(), md_exports));
@@ -52518,16 +53122,16 @@ async function startProdServer(outDir, options) {
   } catch {
   }
   let middlewareMod = null;
-  const mwPath = resolve13(outDir, "server", "middleware.js");
-  if (existsSync15(mwPath)) {
+  const mwPath = resolve14(outDir, "server", "middleware.js");
+  if (existsSync16(mwPath)) {
     try {
       middlewareMod = await import(`${mwPath}?t=${Date.now()}`);
     } catch {
     }
   }
   let eventsMod = null;
-  const eventsPath = resolve13(outDir, "server", "events.js");
-  if (existsSync15(eventsPath)) {
+  const eventsPath = resolve14(outDir, "server", "events.js");
+  if (existsSync16(eventsPath)) {
     try {
       eventsMod = await import(`${eventsPath}?t=${Date.now()}`);
     } catch {
@@ -52536,8 +53140,8 @@ async function startProdServer(outDir, options) {
   const functionCache = /* @__PURE__ */ new Map();
   async function loadFunction(funcPath) {
     if (functionCache.has(funcPath)) return functionCache.get(funcPath);
-    const fullPath = resolve13(outDir, funcPath);
-    if (!existsSync15(fullPath)) return null;
+    const fullPath = resolve14(outDir, funcPath);
+    if (!existsSync16(fullPath)) return null;
     try {
       const mod = await import(`${fullPath}?t=${Date.now()}`);
       functionCache.set(funcPath, mod);
@@ -52587,6 +53191,16 @@ async function startProdServer(outDir, options) {
     const reqHost = req.headers.host || `localhost:${port}`;
     const proto = req.socket.encrypted ? "https" : getClientProtocol({ headers: req.headers }, !!securityConfig?.trustProxy);
     globalThis.__vesk_ssr_base_url = `${proto}://${reqHost}`;
+    if (healthCheckEnabled && (url.pathname === "/healthz" || url.pathname === "/_vesk/healthz")) {
+      const probe = JSON.stringify({ status: "ok", uptime: Math.floor(process.uptime()) });
+      res.writeHead(200, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": String(Buffer.byteLength(probe)),
+        "Cache-Control": "no-store"
+      });
+      res.end(probe);
+      return;
+    }
     if (rateLimiter) {
       const clientIp = getClientIpFromReq(req);
       if (!rateLimiter.check(clientIp)) {
@@ -52634,12 +53248,18 @@ async function startProdServer(outDir, options) {
       }
       return origWriteHead2(statusCode, headers2);
     });
-    const publicDir = resolve13(staticDir, "public");
+    installResponsePipeline(res, req, {
+      compress: compressionConfig.enabled !== false,
+      compressThreshold: compressionConfig.threshold,
+      brotliQuality: compressionConfig.brotliQuality,
+      gzipLevel: compressionConfig.gzipLevel,
+      etag: compressionConfig.etag !== false
+    });
+    const publicDir = resolve14(staticDir, "public");
     const rootFile = url.pathname.length > 1 ? resolveWithin(publicDir, url.pathname.slice(1)) : null;
-    if (rootFile && existsSync15(rootFile) && statSync6(rootFile).isFile()) {
-      const ext = extname3(rootFile);
-      res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
-      res.end(readFileSync15(rootFile));
+    if (rootFile && existsSync16(rootFile) && statSync8(rootFile).isFile()) {
+      res.writeHead(200, { "Content-Type": mimeFor(rootFile) });
+      res.end(readFileSync18(rootFile));
       return;
     }
     if (url.pathname === "/ssr-data.js") {
@@ -52665,13 +53285,13 @@ async function startProdServer(outDir, options) {
     }
     if (url.pathname === "/_vesk/runtime.js") {
       const clientFile = buildConfig?.assets?.client?.file || "client.js";
-      const clientPath = resolve13(staticDir, clientFile);
-      if (existsSync15(clientPath)) {
+      const clientPath = resolve14(staticDir, clientFile);
+      if (existsSync16(clientPath)) {
         res.writeHead(200, {
           "Content-Type": "application/javascript",
           "Cache-Control": cacheControlFor(clientFile, false)
         });
-        res.end(readFileSync15(clientPath));
+        res.end(readFileSync18(clientPath));
         return;
       }
     }
@@ -52683,26 +53303,25 @@ async function startProdServer(outDir, options) {
         res.end("Forbidden");
         return;
       }
-      if (existsSync15(staticPath) && statSync6(staticPath).isFile()) {
-        const ext = extname3(staticPath);
+      if (existsSync16(staticPath) && statSync8(staticPath).isFile()) {
         res.writeHead(200, {
-          "Content-Type": MIME[ext] || "application/octet-stream",
+          "Content-Type": mimeFor(staticPath),
           // A content-hashed name can never change meaning, so it is immutable
           // for a year; anything unhashed must be revalidated or a deploy would
           // serve stale JS forever.
           "Cache-Control": cacheControlFor(basename(staticPath), false)
         });
-        res.end(readFileSync15(staticPath));
+        res.end(readFileSync18(staticPath));
         return;
       }
     }
     if (buildConfig.prerendered) {
       const prerendered = buildConfig.prerendered.find((r) => r.path === url.pathname);
       if (prerendered) {
-        const htmlPath = resolve13(outDir, prerendered.file);
-        if (existsSync15(htmlPath)) {
+        const htmlPath = resolve14(outDir, prerendered.file);
+        if (existsSync16(htmlPath)) {
           res.writeHead(200, { "Content-Type": "text/html" });
-          res.end(readFileSync15(htmlPath));
+          res.end(readFileSync18(htmlPath));
           return;
         }
       }
@@ -52807,17 +53426,17 @@ async function startProdServer(outDir, options) {
         }
       }
     }
-    const appDir = resolve13(projectDir, "app");
+    const appDir = resolve14(projectDir, "app");
     const pageCssUrls = resolveCssUrls({
       enabled: hasBuiltGlobalCss(outDir)
     });
-    const nfPath = resolve13(appDir, "not-found.vsk");
+    const nfPath = resolve14(appDir, "not-found.vsk");
     let notFoundHtml = null;
-    if (existsSync15(nfPath)) {
+    if (existsSync16(nfPath)) {
       try {
-        const runtimePath = resolve13(outDir, "server", "runtime.js");
+        const runtimePath = resolve14(outDir, "server", "runtime.js");
         const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-        const src2 = readFileSync15(nfPath, "utf-8");
+        const src2 = readFileSync18(nfPath, "utf-8");
         const compName = resolveComponentName(src2) || "NotFound";
         notFoundHtml = await renderFullPage2(src2, compName, { params: {}, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: pageCssUrls, security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: nfPath, headExtra: bakedHeadExtra });
       } catch {
@@ -52891,13 +53510,13 @@ async function startProdServer(outDir, options) {
               if (eventsMod) {
                 await executeError(err, { url: url.href, routePath: route.path, target: "node", status: 500 }, eventsMod);
               }
-              const errPath = resolve13(appDir, "error.vsk");
+              const errPath = resolve14(appDir, "error.vsk");
               let errorHtml = null;
-              if (existsSync15(errPath)) {
+              if (existsSync16(errPath)) {
                 try {
-                  const runtimePath = resolve13(outDir, "server", "runtime.js");
+                  const runtimePath = resolve14(outDir, "server", "runtime.js");
                   const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-                  const src2 = readFileSync15(errPath, "utf-8");
+                  const src2 = readFileSync18(errPath, "utf-8");
                   const compName = resolveComponentName(src2) || "Error";
                   const expose = process.env.NODE_ENV !== "production";
                   errorHtml = await renderFullPage2(src2, compName, { error: expose ? err.message : "Internal Server Error", stack: expose ? err.stack : "", statusCode: 500, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: pageCssUrls, clientScriptUrl: buildConfig?.assets?.client?.url || "/_vesk/static/client.js", clientScriptIntegrity: buildConfig?.assets?.client?.integrity, security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: errPath, headExtra: bakedHeadExtra });
@@ -52937,8 +53556,14 @@ async function startProdServer(outDir, options) {
     server.close(() => process.exit(0));
     setTimeout(() => process.exit(0), 3e3).unref();
   }
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  const onSigint = () => shutdown("SIGINT");
+  const onSigterm = () => shutdown("SIGTERM");
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  server.once("close", () => {
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+  });
   server.listen(port, host, () => {
     console.error(`vesk production server at http://localhost:${port} (listening on ${host})`);
   });
@@ -52976,7 +53601,7 @@ function findRouteConflicts(routeTree, appDir) {
   const walk9 = (nodes) => {
     for (const node of nodes) {
       if (node.page) {
-        const pageFile = join15(node.sourceDir, "page.vsk");
+        const pageFile = join16(node.sourceDir, "page.vsk");
         const files = byPath.get(node.fullPath) ?? [];
         files.push(relative4(projectRoot, pageFile));
         byPath.set(node.fullPath, files);
@@ -53085,6 +53710,11 @@ async function build2(appDir, options) {
   if (pluginHeadExtra)
     console.error("vesk build: baked plugin head \u2192 config.json + SSR functions");
   console.error(`vesk build: output \u2192 ${outDir}`);
+  if (isSocketlessTarget(options?.platform, options?.target)) {
+    const driverHits = tcpDriverViolations(appDir);
+    if (driverHits.length > 0)
+      throw edgeDriverBuildError(driverHits);
+  }
   const dirs = [
     resolve21(outDir, "server", "functions"),
     resolve21(outDir, "server", "api"),
@@ -53096,7 +53726,7 @@ async function build2(appDir, options) {
   markPhase("config+dirs");
   const cssSourcePath = resolveUserCssPath(appDir);
   if (cssSourcePath !== null) {
-    const cssContent = readFileSync21(cssSourcePath, "utf-8");
+    const cssContent = readFileSync23(cssSourcePath, "utf-8");
     const cssTarget = resolve21(outDir, "static", "global.css");
     const tailwindActive = isTailwindPlugin(pluginsPipelines);
     let finalCss = cssContent;
@@ -53189,7 +53819,7 @@ async function build2(appDir, options) {
         const mwChain2 = collectMiddlewareChain2(routeTree, node.fullPath, appDir);
         let mwCode = null;
         if (mwChain2.length > 0) {
-          const mwSources = mwChain2.map((m) => readFileSync21(m.sourcePath, "utf-8"));
+          const mwSources = mwChain2.map((m) => readFileSync23(m.sourcePath, "utf-8"));
           mwCode = compileMiddlewareCode(mwSources);
         }
         const ssrAncestorLayouts = isStandalone ? [] : ancestorLayouts;
@@ -53197,14 +53827,14 @@ async function build2(appDir, options) {
         writeFileSync12(funcPath, funcCode, "utf-8");
         const pagePath = resolve21(appDir, node.sourceDir, "page.vsk");
         if (existsSync22(pagePath)) {
-          const src2 = readFileSync21(pagePath, "utf-8");
+          const src2 = readFileSync23(pagePath, "utf-8");
           const actionIds = collectActionIds(src2);
           if (node.layout) {
-            const layoutSrc = readFileSync21(resolve21(appDir, node.sourceDir, "layout.vsk"), "utf-8");
+            const layoutSrc = readFileSync23(resolve21(appDir, node.sourceDir, "layout.vsk"), "utf-8");
             actionIds.push(...collectActionIds(layoutSrc));
           }
           for (const a of ssrAncestorLayouts) {
-            const ancestorSrc = readFileSync21(resolve21(appDir, a.sourceDir, "layout.vsk"), "utf-8");
+            const ancestorSrc = readFileSync23(resolve21(appDir, a.sourceDir, "layout.vsk"), "utf-8");
             actionIds.push(...collectActionIds(ancestorSrc));
           }
           for (const id of actionIds) {
@@ -53297,7 +53927,7 @@ async function build2(appDir, options) {
   const manifest = generateManifest(routeTree, ssrRoutes, apiRoutes, prerenderedRoutes, middlewareEnabled, actionMap, pluginHeadExtra, hasEvents);
   const buildId3 = emittedAssets.map((a) => a.hash).join("-");
   manifest.buildId = buildId3.slice(0, 32);
-  manifest.veskVersion = JSON.parse(readFileSync21(join15(PACKAGES_DIR_SELF(), "package.json"), "utf-8")).version;
+  manifest.veskVersion = JSON.parse(readFileSync23(join16(PACKAGES_DIR_SELF(), "package.json"), "utf-8")).version;
   manifest.assets = {
     hashed,
     client: { file: clientFileName, url: clientUrl, hash: clientAsset.hash, bytes: clientAsset.bytes, integrity: clientAsset.integrity },
@@ -53351,9 +53981,9 @@ vesk build: done (${outDir})`);
 init_seo_audit();
 
 // src/dev-server.ts
-import { readFileSync as readFileSync38, watch, statSync as statSync21, existsSync as existsSync42, mkdirSync as mkdirSync19, readdirSync as readdirSync13, writeFileSync as writeFileSync21, renameSync as renameSync2 } from "node:fs";
-import { createHash as createHash2 } from "node:crypto";
-import { resolve as resolve38, extname as extname8, join as join26, dirname as dirname26 } from "node:path";
+import { readFileSync as readFileSync40, watch, statSync as statSync22, existsSync as existsSync42, mkdirSync as mkdirSync19, readdirSync as readdirSync14, writeFileSync as writeFileSync21, renameSync as renameSync2 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { resolve as resolve38, extname as extname7, join as join27, dirname as dirname26 } from "node:path";
 import { createServer as createServer2 } from "node:http";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 
@@ -56242,8 +56872,8 @@ init_parser();
 init_tokens();
 init_scan();
 init_strip_ts();
-import { readdirSync as readdirSync7, statSync as statSync12, existsSync as existsSync23, readFileSync as readFileSync22 } from "fs";
-import { join as join16, relative as relative5, basename as basename4 } from "path";
+import { readdirSync as readdirSync8, statSync as statSync13, existsSync as existsSync23, readFileSync as readFileSync24 } from "fs";
+import { join as join17, relative as relative5, basename as basename4 } from "path";
 function collapseSlashes2(p) {
   let out = "";
   let prevSlash = false;
@@ -56263,7 +56893,7 @@ function isStandaloneLayoutFile(layoutPath) {
   try {
     if (!existsSync23(layoutPath))
       return false;
-    const src2 = readFileSync22(layoutPath, "utf-8");
+    const src2 = readFileSync24(layoutPath, "utf-8");
     if (!src2.includes("standalone"))
       return false;
     try {
@@ -56341,15 +56971,15 @@ function scanComponents(componentsDir) {
   function walk9(dir, prefix) {
     let entries;
     try {
-      entries = readdirSync7(dir);
+      entries = readdirSync8(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join16(dir, entry);
+      const full = join17(dir, entry);
       let stat;
       try {
-        stat = statSync12(full);
+        stat = statSync13(full);
       } catch {
         continue;
       }
@@ -56372,7 +57002,7 @@ function scanDirectory(rootDir, dir, parentPath, options) {
   const nodes = [];
   let entries;
   try {
-    entries = readdirSync7(dir);
+    entries = readdirSync8(dir);
   } catch {
     return nodes;
   }
@@ -56447,7 +57077,7 @@ function scanDirectory(rootDir, dir, parentPath, options) {
     seg = segName;
   }
   const fullPath = seg ? (parentPath === "/" ? "/" : parentPath + "/") + seg : parentPath || "/";
-  const isStandalone = hasLayout ? isStandaloneLayoutFile(join16(dir, "layout.vsk")) : false;
+  const isStandalone = hasLayout ? isStandaloneLayoutFile(join17(dir, "layout.vsk")) : false;
   const node = {
     path: seg,
     fullPath: collapseSlashes2(fullPath) || "/",
@@ -56468,10 +57098,10 @@ function scanDirectory(rootDir, dir, parentPath, options) {
     standalone: isStandalone ? true : void 0
   };
   for (const entry of entries) {
-    const entryPath = join16(dir, entry);
+    const entryPath = join17(dir, entry);
     let entryStat;
     try {
-      entryStat = statSync12(entryPath);
+      entryStat = statSync13(entryPath);
     } catch {
       continue;
     }
@@ -56520,19 +57150,19 @@ function collectSources(tree) {
   function walk9(nodes) {
     for (const node of nodes) {
       if (node.page)
-        map.set(node.page, join16(node.sourceDir, "page.vsk"));
+        map.set(node.page, join17(node.sourceDir, "page.vsk"));
       if (node.layout)
-        map.set(node.layout, join16(node.sourceDir, "layout.vsk"));
+        map.set(node.layout, join17(node.sourceDir, "layout.vsk"));
       if (node.loading)
-        map.set(node.loading, join16(node.sourceDir, "loading.vsk"));
+        map.set(node.loading, join17(node.sourceDir, "loading.vsk"));
       if (node.error)
-        map.set(node.error, join16(node.sourceDir, "error.vsk"));
+        map.set(node.error, join17(node.sourceDir, "error.vsk"));
       if (node.notFound)
-        map.set(node.notFound, join16(node.sourceDir, "not-found.vsk"));
+        map.set(node.notFound, join17(node.sourceDir, "not-found.vsk"));
       if (node.offline)
-        map.set(node.offline, join16(node.sourceDir, "offline.vsk"));
+        map.set(node.offline, join17(node.sourceDir, "offline.vsk"));
       if (node.network)
-        map.set(node.network, join16(node.sourceDir, "network.vsk"));
+        map.set(node.network, join17(node.sourceDir, "network.vsk"));
       walk9(node.children);
     }
   }
@@ -56652,8 +57282,8 @@ function matchUrl(tree, pathname) {
 }
 
 // ../compiler/dist/api-routes.js
-import { readdirSync as readdirSync8, statSync as statSync13, existsSync as existsSync24 } from "fs";
-import { join as join17 } from "path";
+import { readdirSync as readdirSync9, statSync as statSync14, existsSync as existsSync24 } from "fs";
+import { join as join18 } from "path";
 init_server_utils();
 function basename5(p) {
   const idx = p.lastIndexOf("/");
@@ -56668,7 +57298,7 @@ function scanApiDir(rootDir, dir, parentPath) {
   const nodes = [];
   let entries;
   try {
-    entries = readdirSync8(dir);
+    entries = readdirSync9(dir);
   } catch {
     return nodes;
   }
@@ -56690,10 +57320,10 @@ function scanApiDir(rootDir, dir, parentPath) {
     return nodes;
   if (isRouteGroup) {
     for (const entry of entries) {
-      const entryPath = join17(dir, entry);
+      const entryPath = join18(dir, entry);
       let entryStat;
       try {
-        entryStat = statSync13(entryPath);
+        entryStat = statSync14(entryPath);
       } catch {
         continue;
       }
@@ -56720,14 +57350,14 @@ function scanApiDir(rootDir, dir, parentPath) {
     fullPath: collapseSlashes(fullPath) || "/",
     isDynamic,
     isCatchAll,
-    filePath: hasRoute && routeFileName ? join17(dir, routeFileName) : null,
+    filePath: hasRoute && routeFileName ? join18(dir, routeFileName) : null,
     children: []
   };
   for (const entry of entries) {
-    const entryPath = join17(dir, entry);
+    const entryPath = join18(dir, entry);
     let entryStat;
     try {
-      entryStat = statSync13(entryPath);
+      entryStat = statSync14(entryPath);
     } catch {
       continue;
     }
@@ -57281,11 +57911,11 @@ async function executeMiddlewareChain(chain, request, params, options = {}) {
 
 // ../compiler/dist/events.js
 import { existsSync as existsSync26 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var EVENTS_FILE_NAMES2 = ["_events.ts", "_events.js"];
 function collectEventsFile2(appDir) {
   for (const name of EVENTS_FILE_NAMES2) {
-    const candidate = join18(appDir, name);
+    const candidate = join19(appDir, name);
     if (existsSync26(candidate))
       return candidate;
   }
@@ -57316,8 +57946,8 @@ async function runEventHandlers(handlers, name, ctx2) {
 }
 
 // ../compiler/dist/md-inline.js
-import { readFileSync as readFileSync23, existsSync as existsSync27 } from "node:fs";
-import { dirname as dirname17, join as join19, resolve as resolve23 } from "node:path";
+import { readFileSync as readFileSync25, existsSync as existsSync27 } from "node:fs";
+import { dirname as dirname17, join as join20, resolve as resolve23 } from "node:path";
 var MD_EXT_MARKER2 = ".md";
 function looksLikeMarkdownPath2(value) {
   const v = value.trim();
@@ -57360,7 +57990,7 @@ function inlineMdContentAttrs2(source, importerDir, mdRoots = []) {
               if (abs !== null) {
                 let contents;
                 try {
-                  contents = readFileSync23(abs, "utf-8");
+                  contents = readFileSync25(abs, "utf-8");
                 } catch {
                   out += source[i];
                   i++;
@@ -57394,10 +58024,10 @@ function resolveMdPath2(specifier, importerDir, roots) {
   }
   if (spec.startsWith("/")) {
     for (const root3 of roots) {
-      const pub = join19(root3, "public", spec);
+      const pub = join20(root3, "public", spec);
       if (existsSync27(pub))
         return pub;
-      const direct = join19(root3, spec);
+      const direct = join20(root3, spec);
       if (existsSync27(direct))
         return direct;
     }
@@ -57411,7 +58041,7 @@ function guessProjectRoots2(dir) {
   let cur = dir;
   for (let i = 0; i < 6; i++) {
     roots.push(cur);
-    if (existsSync27(join19(cur, "package.json")))
+    if (existsSync27(join20(cur, "package.json")))
       break;
     const parent = dirname17(cur);
     if (parent === cur)
@@ -57422,8 +58052,8 @@ function guessProjectRoots2(dir) {
 }
 
 // ../adapter/dist/client-bundle.js
-import { readFileSync as readFileSync24, existsSync as existsSync28, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, statSync as statSync14, rmSync as rmSync4, mkdtempSync as mkdtempSync2, mkdirSync as mkdirSync12 } from "node:fs";
-import { resolve as resolve24, join as join20, dirname as dirname18, relative as relative6, sep as sep3 } from "node:path";
+import { readFileSync as readFileSync26, existsSync as existsSync28, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, statSync as statSync15, rmSync as rmSync4, mkdtempSync as mkdtempSync2, mkdirSync as mkdirSync12 } from "node:fs";
+import { resolve as resolve24, join as join21, dirname as dirname18, relative as relative6, sep as sep3 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { tmpdir as tmpdir3 } from "node:os";
 
@@ -57514,7 +58144,7 @@ async function mapWithConcurrency2(items, limit, fn) {
 var __dirname7 = dirname18(fileURLToPath6(import.meta.url));
 function fileUnchanged2(filePath, cached) {
   try {
-    const st = statSync14(filePath);
+    const st = statSync15(filePath);
     return st.mtimeMs === cached.mtimeMs && st.size === cached.size;
   } catch {
     return false;
@@ -57535,8 +58165,8 @@ function findRuntimeSrc3(appDir) {
     resolve24(appDir, "node_modules", "@vesk/runtime")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join20(base, "dist")]) {
-      if (existsSync28(join20(dir, "index-client.js")))
+    for (const dir of [base, join21(base, "dist")]) {
+      if (existsSync28(join21(dir, "index-client.js")))
         return dir;
     }
   }
@@ -57656,6 +58286,13 @@ function nativeLibraryImportStubs2(code) {
   });
   return lines.join("\n") + "\n\n";
 }
+function reportServerOnlyImports2(chunkName, hits, strict) {
+  const detail = [...new Set(hits.map((h) => `"${h.binding}" from "${h.specifier}"`))].join(", ");
+  if (strict) {
+    throw new Error(`[vesk] ${chunkName} imports a server-only package in client code: ${detail}. Move that work into an API route (app/api/**/route.ts) or a server action. Pass without --strict to allow it (the binding is replaced by a throwing stub).`);
+  }
+  console.error(`[vesk] ${chunkName}: removed server-only import from client code (${detail}). It is replaced by a stub that throws if the component calls it at runtime \u2014 server-only work belongs in an API route or a server action.`);
+}
 function demoteExports2(code) {
   let ast;
   try {
@@ -57689,7 +58326,7 @@ function chunkHasImports2(headLen, mergeAborted) {
 function runtimeImportsOf2(filePath) {
   let text;
   try {
-    text = readFileSync24(filePath, "utf8");
+    text = readFileSync26(filePath, "utf8");
   } catch {
     return [];
   }
@@ -58016,11 +58653,11 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options) {
     return removeCompiledNodes2(code, isVskImport2);
   }
   function resolveVskImports(filePath, compile) {
-    const src2 = readFileSync24(filePath, "utf-8");
+    const src2 = readFileSync26(filePath, "utf-8");
     const resolved = [];
     for (const importPath of collectVskImportPaths(vskImportLines(src2), filePath)) {
       try {
-        readFileSync24(importPath);
+        readFileSync26(importPath);
       } catch {
         continue;
       }
@@ -58082,7 +58719,7 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options) {
     compiledFiles++;
     __stats.compiled++;
     __stats.distinct.add(filePath);
-    let src2 = readFileSync24(filePath, "utf-8");
+    let src2 = readFileSync26(filePath, "utf-8");
     if (/content=["'][^"']*\.md["']/i.test(src2)) {
       src2 = inlineMdContentAttrs(src2, dirname18(filePath), guessProjectRoots(appDir));
     }
@@ -58122,7 +58759,7 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options) {
     for (const reexportPath of reexportPaths || [])
       compileFile2(reexportPath, null, output, imports);
     if (cache2 && namesBefore) {
-      const st = statSync14(filePath);
+      const st = statSync15(filePath);
       cache2.files.set(filePath, {
         mtimeMs: st.mtimeMs,
         size: st.size,
@@ -58252,9 +58889,9 @@ ${body}
     let sharedBundleCode = "";
     const sharedRuntimeNames = /* @__PURE__ */ new Set();
     if (sharedSources.length > 0) {
-      const tmpBase = mkdtempSync2(join20(resolve24(appDir, ".."), "tmp-vesk-shared-"));
+      const tmpBase = mkdtempSync2(join21(resolve24(appDir, ".."), "tmp-vesk-shared-"));
       try {
-        const sharedEntry = join20(tmpBase, "shared-entry.js");
+        const sharedEntry = join21(tmpBase, "shared-entry.js");
         const lines = [];
         const members = [];
         sharedSources.forEach((source, i) => {
@@ -58264,7 +58901,7 @@ ${body}
         lines.push(`globalThis.__veskShared = { ${members.join("\n")} };`);
         writeFileSync13(sharedEntry, lines.join("\n"));
         const appTsconfig = findTsconfigPath(appDir);
-        const runtimeShim = join20(tmpBase, "runtime-shim.js");
+        const runtimeShim = join21(tmpBase, "runtime-shim.js");
         const runtimeLines = [
           "// ONE runtime instance: the entry bundle publishes these on globalThis,",
           "// and route chunks import the same functions. A second bundled copy",
@@ -58305,7 +58942,7 @@ ${body}
             bindings.named.forEach((n) => named.add(n));
             hasDefault = hasDefault || bindings.hasDefault;
           }
-          const shim = join20(tmpBase, `shim-${i}.js`);
+          const shim = join21(tmpBase, `shim-${i}.js`);
           const shimLines = [`const m = globalThis.__veskShared[${JSON.stringify(source)}];`];
           if (hasDefault)
             shimLines.push(`export default m;`);
@@ -58336,13 +58973,21 @@ ${body}
         return null;
       let finalCode;
       if (entry.imports) {
-        const tmpBase = mkdtempSync2(join20(resolve24(appDir, ".."), "tmp-vesk-chunk-"));
-        const tmpFile = join20(tmpBase, "entry.js");
+        const tmpBase = mkdtempSync2(join21(resolve24(appDir, ".."), "tmp-vesk-chunk-"));
+        const tmpFile = join21(tmpBase, "entry.js");
         const toBundle = `const __components = globalThis.__components || (globalThis.__components = {});
 const __hydrators = globalThis.__hydrators || (globalThis.__hydrators = {});
 ${entry.code}
 `;
         writeFileSync13(tmpFile, toBundle);
+        const serverOnlyHits = [];
+        const driverHits = [];
+        const eagerHits = [];
+        const serverOnlyGuard = serverOnlyPlugin({
+          onStub: (hit) => serverOnlyHits.push(hit),
+          onDriver: (hit) => driverHits.push(hit),
+          onEager: (hit) => eagerHits.push(hit)
+        });
         try {
           const appTsconfig = findTsconfigPath(appDir);
           const result = await build3({
@@ -58366,7 +59011,7 @@ ${entry.code}
             // shared-modules.js serves every route chunk. (esbuild's `alias`
             // option only accepts bare package names, so this is a resolver
             // rather than a map.)
-            ...sharedRedirectPlugin ? { plugins: [sharedRedirectPlugin] } : {},
+            ...sharedRedirectPlugin ? { plugins: [sharedRedirectPlugin, serverOnlyGuard] } : { plugins: [serverOnlyGuard] },
             ...appTsconfig ? { tsconfig: appTsconfig } : {}
           });
           finalCode = result.outputFiles[0].text;
@@ -58388,6 +59033,20 @@ ${entry.code}
           } catch {
           }
         }
+        if (eagerHits.length > 0) {
+          const detail = eagerHits.map((h) => `${h.importer} uses ${h.bindings.map((b) => `"${b}"`).join(", ")} from "${h.specifier}" at module scope`).join("; ");
+          console.error("[vesk] server-only package used at module scope in client code", entry.name + ":", detail);
+          throw new Error(`[vesk] ${entry.name}: ${detail}.
+A module-scope statement runs the moment the browser evaluates the chunk, so a server-only package cannot be substituted there. Move that work into an API route (app/api/**/route.ts) or a server action \u2014 if the binding is only used from inside a function, this build already handles it.`);
+        }
+        if (driverHits.length > 0) {
+          const detail = [...new Set(driverHits.map((h) => `${h.specifier} (from ${h.importer})`))].join(", ");
+          console.error("[vesk] chunk bundle contains a TCP-only driver", entry.name + ":", detail);
+          throw new Error(`[vesk] ${entry.name} pulls a TCP-only driver into the browser bundle: ${detail}. A browser cannot open a socket. Import the package's edge/browser-safe entry if it ships one, or keep database access in an API route (app/api/**/route.ts) or a server action.`);
+        }
+        if (serverOnlyHits.length > 0) {
+          reportServerOnlyImports2(entry.name, serverOnlyHits, options?.strict);
+        }
       } else {
         finalCode = chunkIIFE(demoteExports2(entry.code));
       }
@@ -58427,7 +59086,7 @@ ${entry.code}
       if (seen.has(filePath))
         return;
       seen.add(filePath);
-      const src2 = readFileSync24(filePath, "utf-8");
+      const src2 = readFileSync26(filePath, "utf-8");
       resolveVskImports(filePath, (p, n) => compileFileMono2(p, n || ""));
       for (const cn of vskComponentNames(src2, filePath))
         componentOwners.claim(cn, filePath);
@@ -58520,9 +59179,9 @@ function buildRuntimeCode2(runtimeDir) {
   ];
   let code = "";
   for (const f of runtimeFiles) {
-    const p = join20(runtimeDir, f);
+    const p = join21(runtimeDir, f);
     if (existsSync28(p)) {
-      let src2 = readFileSync24(p, "utf-8");
+      let src2 = readFileSync26(p, "utf-8");
       src2 = stripTypes2(src2);
       src2 = src2.replace(/^import\s+[\s\S]*?from\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
       src2 = src2.replace(/^import\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
@@ -58534,7 +59193,7 @@ ${src2}
 `;
     }
   }
-  const indexSrc = readFileSync24(join20(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync26(join21(runtimeDir, "index-client.js"), "utf-8");
   const exportNames = stripTypes2(indexSrc).match(/export\s*\{\s*([^}]+)\s*\}\s*from/g)?.flatMap((m) => m.replace(/export\s*\{\s*|\s*\}\s*from/g, "").split(",").map((s) => s.trim())) || [];
   code += "// --- exports ---\n";
   for (const name of [...new Set(exportNames)]) {
@@ -58545,7 +59204,7 @@ ${src2}
   return code;
 }
 function runtimeExportNames2(runtimeDir) {
-  const indexSrc = readFileSync24(join20(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync26(join21(runtimeDir, "index-client.js"), "utf-8");
   const names = /* @__PURE__ */ new Set();
   for (const m of indexSrc.matchAll(/export\s*\{([^}]+)\}\s*from/g)) {
     for (const raw2 of m[1].split(",")) {
@@ -58561,7 +59220,7 @@ function esbuildPath2(p) {
   return sep3 === "/" ? p : p.split(sep3).join("/");
 }
 function runtimeTreeShakeEntry2() {
-  return join20(tmpdir3(), "vesk-runtime-tree-shake", RUNTIME_ENTRY2);
+  return join21(tmpdir3(), "vesk-runtime-tree-shake", RUNTIME_ENTRY2);
 }
 var treeShakeQueue2 = Promise.resolve();
 function buildTreeShakenRuntime2(runtimeDir, usedNames) {
@@ -58586,7 +59245,7 @@ async function bundleRuntimeNames2(runtimeDir, names, strict = false) {
   if (names.length === 0)
     return null;
   const entry = runtimeTreeShakeEntry2();
-  const indexClient = esbuildPath2(join20(runtimeDir, "index-client.js"));
+  const indexClient = esbuildPath2(join21(runtimeDir, "index-client.js"));
   const unique = [...new Set(names)];
   try {
     try {
@@ -58734,7 +59393,7 @@ if (typeof document !== 'undefined') __router.start();
 
 // ../adapter/dist/paths.js
 import { resolve as resolve25, sep as sep4 } from "node:path";
-import { existsSync as existsSync29, statSync as statSync15, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync29, statSync as statSync16, readFileSync as readFileSync27 } from "node:fs";
 function resolveWithin2(baseDir, relPath) {
   const base = resolve25(baseDir);
   const target = resolve25(baseDir, relPath);
@@ -58757,8 +59416,8 @@ function installMdReadHook2(publicDirs) {
         const lower2 = abs.toLowerCase();
         if (!lower2.endsWith(".md") && !lower2.endsWith(".markdown"))
           continue;
-        if (existsSync29(abs) && statSync15(abs).isFile())
-          return readFileSync25(abs, "utf8");
+        if (existsSync29(abs) && statSync16(abs).isFile())
+          return readFileSync27(abs, "utf8");
       } catch {
       }
     }
@@ -58825,13 +59484,13 @@ function urlAuthority3(url) {
 }
 
 // ../adapter/dist/dev-api.js
-import { readFileSync as readFileSync28, statSync as statSync17, existsSync as existsSync32, readdirSync as readdirSync9 } from "node:fs";
+import { readFileSync as readFileSync30, statSync as statSync18, existsSync as existsSync32, readdirSync as readdirSync10 } from "node:fs";
 import { resolve as resolve28 } from "node:path";
 
 // ../adapter/dist/plugins.js
 init_paths();
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync14, existsSync as existsSync30, mkdirSync as mkdirSync13, statSync as statSync16 } from "node:fs";
-import { resolve as resolve26, dirname as dirname19, join as join21, extname as extname7, basename as basename6 } from "node:path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync14, existsSync as existsSync30, mkdirSync as mkdirSync13, statSync as statSync17 } from "node:fs";
+import { resolve as resolve26, dirname as dirname19, join as join22, extname as extname6, basename as basename6 } from "node:path";
 import { createRequire as createRequire6 } from "node:module";
 import { spawn as spawn2 } from "node:child_process";
 var PLUGIN_STATE_FILENAME2 = "plugins.json";
@@ -58854,7 +59513,7 @@ function readPluginState2(veskDir) {
     return defaultState2();
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync26(file, "utf-8"));
+    raw2 = JSON.parse(readFileSync28(file, "utf-8"));
   } catch {
     return defaultState2();
   }
@@ -58891,7 +59550,7 @@ function resolvePackage2(appDir, pkg) {
       const seen = /* @__PURE__ */ new Set();
       while (cur && cur !== dirname19(cur) && !seen.has(cur)) {
         seen.add(cur);
-        const candidate = join21(cur, "package.json");
+        const candidate = join22(cur, "package.json");
         if (existsSync30(candidate)) {
           pkgJsonPath = candidate;
           break;
@@ -58920,7 +59579,7 @@ function resolvePackage2(appDir, pkg) {
     }
   }
   if (localPath) {
-    const localJson = join21(localPath, "package.json");
+    const localJson = join22(localPath, "package.json");
     let json = null;
     if (existsSync30(localJson)) {
       json = readJsonFile2(localJson);
@@ -58946,7 +59605,7 @@ function localDir2(base, pkg) {
 function readJsonFile2(file) {
   try {
     if (existsSync30(file))
-      return JSON.parse(readFileSync26(file, "utf-8"));
+      return JSON.parse(readFileSync28(file, "utf-8"));
   } catch {
   }
   return null;
@@ -59229,12 +59888,12 @@ function findIconFile2(dir, meta) {
   const explicit = str2(meta?.icon);
   if (explicit) {
     const p = resolveWithin(dir, explicit);
-    if (p && existsSync30(p) && statSync16(p).isFile())
+    if (p && existsSync30(p) && statSync17(p).isFile())
       return p;
   }
   for (const name of ["icon.png", "icon.ico"]) {
     const p = resolve26(dir, name);
-    if (existsSync30(p) && statSync16(p).isFile())
+    if (existsSync30(p) && statSync17(p).isFile())
       return p;
   }
   return null;
@@ -59248,7 +59907,7 @@ function findPluginIcon2(appDir, name) {
   const iconPath = findIconFile2(dir, meta);
   if (!iconPath)
     return null;
-  const ext = extname7(iconPath).toLowerCase();
+  const ext = extname6(iconPath).toLowerCase();
   const mime = ext === ".png" ? "image/png" : ext === ".ico" ? "image/x-icon" : "application/octet-stream";
   return { file: iconPath, mime };
 }
@@ -59319,7 +59978,7 @@ function resolveDtsPath2(probe, pkgJson) {
     if (!rel)
       continue;
     const abs = resolveWithin(dir, rel);
-    if (abs && existsSync30(abs) && statSync16(abs).isFile())
+    if (abs && existsSync30(abs) && statSync17(abs).isFile())
       return abs;
   }
   return null;
@@ -59668,7 +60327,7 @@ function introspectPlugin2(appDir, name) {
   const pkgName = str2(pkgJson.name) ?? name;
   const exportsMap = flattenPackageExports2(pkgJson.exports);
   const dtsPath = resolveDtsPath2(probe, pkgJson);
-  const dtsExports = dtsPath ? parseDtsExports2(readFileSync26(dtsPath, "utf-8")) : [];
+  const dtsExports = dtsPath ? parseDtsExports2(readFileSync28(dtsPath, "utf-8")) : [];
   return {
     ok: true,
     name: pkgName,
@@ -59806,9 +60465,9 @@ var __internals2 = {
 };
 
 // ../adapter/dist/dev-config.js
-import { existsSync as existsSync31, readFileSync as readFileSync27, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync3, rmSync as rmSync5 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync3, rmSync as rmSync5 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { resolve as resolve27, dirname as dirname20, join as join22 } from "node:path";
+import { resolve as resolve27, dirname as dirname20, join as join23 } from "node:path";
 init_parser();
 function findConfigFile2(projectDir) {
   const ts9 = resolve27(projectDir, "vesk.config.ts");
@@ -59836,9 +60495,9 @@ async function parseConfigSource(source, isTs, projectDir) {
     js = `const { defineConfig, definePlugin, preset } = globalThis.__vesk_inject;
 ` + js;
   }
-  const base = projectDir ? (mkdirSync14(join22(projectDir, ".vesk"), { recursive: true }), join22(projectDir, ".vesk")) : void 0;
-  const dir = base ? mkdtempSync3(join22(base, "cfg-")) : mkdtempSync3(join22(tmpdir4(), "vesk-cfg-"));
-  const tmpFile = join22(dir, "config.mjs");
+  const base = projectDir ? (mkdirSync14(join23(projectDir, ".vesk"), { recursive: true }), join23(projectDir, ".vesk")) : void 0;
+  const dir = base ? mkdtempSync3(join23(base, "cfg-")) : mkdtempSync3(join23(tmpdir4(), "vesk-cfg-"));
+  const tmpFile = join23(dir, "config.mjs");
   try {
     writeFileSync15(tmpFile, js, "utf-8");
     globalThis.__vesk_inject = {
@@ -59865,7 +60524,7 @@ async function readConfig2(projectDir) {
   const { path, isTs } = findConfigFile2(projectDir);
   if (!path)
     return { path: null, exists: false, source: "", config: {} };
-  const source = readFileSync27(path, "utf-8");
+  const source = readFileSync29(path, "utf-8");
   const config = await parseConfigSource(source, isTs, projectDir);
   return { path, exists: true, source, config };
 }
@@ -60707,7 +61366,7 @@ export default defineConfig({
     await writeConfigSource2(projectDir, source);
     return;
   }
-  source = readFileSync27(path, "utf-8");
+  source = readFileSync29(path, "utf-8");
   const existingImport = findPluginImportAst(source, pkg);
   let importName;
   if (existingImport) {
@@ -60787,7 +61446,7 @@ async function removePluginFromConfig2(projectDir, pkg) {
   const { path } = findConfigFile2(projectDir);
   if (!path)
     return false;
-  let source = readFileSync27(path, "utf-8");
+  let source = readFileSync29(path, "utf-8");
   const original = source;
   const existingImport = findPluginImportAst(source, pkg);
   let importName = existingImport ? existingImport.name : null;
@@ -60908,7 +61567,7 @@ function createDevApiRouter2(opts) {
             return badRequest2("no vesk.config file to edit");
           if (!isTs)
             return badRequest2("single-key toggle edits only apply to vesk.config.ts (use the source editor for .js)");
-          const patched = applyConfigToggle2(readFileSync28(path, "utf-8"), b.key, b.value);
+          const patched = applyConfigToggle2(readFileSync30(path, "utf-8"), b.key, b.value);
           if (patched === null)
             return badRequest2("could not safely edit the config object; use the source editor");
           const cfg = await writeConfigSource2(projectDir, patched);
@@ -60949,12 +61608,12 @@ function createDevApiRouter2(opts) {
           return jsonStatus(403, { error: "path escapes project root" });
         if (!existsSync32(resolved))
           return jsonStatus(404, { error: "not found" });
-        if (statSync17(resolved).isDirectory()) {
-          const entries = readdirSync9(resolved, { withFileTypes: true }).map((e) => e.name);
+        if (statSync18(resolved).isDirectory()) {
+          const entries = readdirSync10(resolved, { withFileTypes: true }).map((e) => e.name);
           return jsonStatus(200, { ok: true, path: target, directory: true, entries });
         }
-        if (statSync17(resolved).isFile()) {
-          return jsonStatus(200, { ok: true, path: target, directory: false, content: readFileSync28(resolved, "utf-8") });
+        if (statSync18(resolved).isFile()) {
+          return jsonStatus(200, { ok: true, path: target, directory: false, content: readFileSync30(resolved, "utf-8") });
         }
         return badRequest2("unsupported file type");
       } catch (e) {
@@ -61090,7 +61749,7 @@ function createDevApiRouter2(opts) {
         return {
           status: 200,
           headers: { "Content-Type": icon.mime, "Cache-Control": "private, max-age=60" },
-          body: readFileSync28(icon.file).toString("base64"),
+          body: readFileSync30(icon.file).toString("base64"),
           encoding: "base64"
         };
       }
@@ -61147,8 +61806,8 @@ function produceDiagnostics(input) {
 }
 
 // ../agentic/dist/checkpoints.js
-import { existsSync as existsSync33, mkdirSync as mkdirSync15, readFileSync as readFileSync29, writeFileSync as writeFileSync16, statSync as statSync18, unlinkSync as unlinkSync5, rmSync as rmSync6, renameSync } from "node:fs";
-import { join as join23, resolve as resolve29, dirname as dirname21, sep as sep5 } from "node:path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync15, readFileSync as readFileSync31, writeFileSync as writeFileSync16, statSync as statSync19, unlinkSync as unlinkSync5, rmSync as rmSync6, renameSync } from "node:fs";
+import { join as join24, resolve as resolve29, dirname as dirname21, sep as sep5 } from "node:path";
 import { randomUUID as nodeRandomUUID } from "node:crypto";
 function generateId() {
   try {
@@ -61281,16 +61940,16 @@ var CheckpointManager = class {
   }
 };
 function getAgenticDir(projectDir) {
-  return join23(resolve29(projectDir), ".vesk", "agentic");
+  return join24(resolve29(projectDir), ".vesk", "agentic");
 }
 function getHistoryPath(projectDir) {
-  return join23(getAgenticDir(projectDir), "history.json");
+  return join24(getAgenticDir(projectDir), "history.json");
 }
 function getCheckpointDir(projectDir, id) {
-  return join23(getAgenticDir(projectDir), "checkpoints", id);
+  return join24(getAgenticDir(projectDir), "checkpoints", id);
 }
 function getCheckpointPath(projectDir, id) {
-  return join23(getCheckpointDir(projectDir, id), "checkpoint.json");
+  return join24(getCheckpointDir(projectDir, id), "checkpoint.json");
 }
 function ensureDir(dir) {
   mkdirSync15(dir, { recursive: true });
@@ -61299,7 +61958,7 @@ function readJson(filePath, fallback) {
   try {
     if (!existsSync33(filePath))
       return fallback;
-    const raw2 = readFileSync29(filePath, "utf-8");
+    const raw2 = readFileSync31(filePath, "utf-8");
     if (raw2.trim() === "")
       return fallback;
     return JSON.parse(raw2);
@@ -61370,7 +62029,7 @@ function createCheckpoint(projectDir, message, changes = {}, buildResult) {
   };
   const agenticDir = getAgenticDir(projectDir);
   ensureDir(agenticDir);
-  ensureDir(join23(agenticDir, "checkpoints"));
+  ensureDir(join24(agenticDir, "checkpoints"));
   const cpDir = getCheckpointDir(projectDir, id);
   ensureDir(cpDir);
   writeJsonAtomic(getCheckpointPath(projectDir, id), checkpoint);
@@ -61399,7 +62058,7 @@ function rollback(projectDir, id) {
     if (f.before === null) {
       try {
         if (existsSync33(abs)) {
-          const s = statSync18(abs);
+          const s = statSync19(abs);
           if (s.isDirectory())
             rmSync6(abs, { recursive: true, force: true });
           else
@@ -61419,7 +62078,7 @@ function rollback(projectDir, id) {
 }
 
 // ../agentic/dist/config.js
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync17, existsSync as existsSync34, mkdirSync as mkdirSync16, chmodSync } from "node:fs";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync17, existsSync as existsSync34, mkdirSync as mkdirSync16, chmodSync } from "node:fs";
 import { resolve as resolve30, dirname as dirname22 } from "node:path";
 var DEFAULT_CONFIG = {
   provider: "openai",
@@ -61468,7 +62127,7 @@ function readDotenvValue(projectDir, key, def = null) {
     const p = dotenvPath(projectDir);
     if (!existsSync34(p))
       return def;
-    const content = readFileSync30(p, "utf-8");
+    const content = readFileSync32(p, "utf-8");
     for (const rawLine of content.split("\n")) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#"))
@@ -61496,7 +62155,7 @@ function writeDotenvValue(projectDir, key, value) {
     let out = "";
     let replaced = false;
     if (existsSync34(p)) {
-      const lines = readFileSync30(p, "utf-8").split("\n");
+      const lines = readFileSync32(p, "utf-8").split("\n");
       for (const rawLine of lines) {
         const trimmed = rawLine.trim();
         const eq = trimmed.indexOf("=");
@@ -61526,7 +62185,7 @@ function loadAgenticConfig(projectDir) {
   let cfg = { ...DEFAULT_CONFIG };
   try {
     if (existsSync34(p))
-      cfg = { ...cfg, ...JSON.parse(readFileSync30(p, "utf-8")) };
+      cfg = { ...cfg, ...JSON.parse(readFileSync32(p, "utf-8")) };
   } catch {
   }
   let hasKey = false;
@@ -61569,7 +62228,7 @@ function getProviderSpecificKey(projectDir, provider) {
   try {
     const pp2 = providerKeyPath(projectDir, prov);
     if (existsSync34(pp2)) {
-      const v = readFileSync30(pp2, "utf-8").trim();
+      const v = readFileSync32(pp2, "utf-8").trim();
       if (v)
         return v;
     }
@@ -61617,7 +62276,7 @@ function getApiKey(projectDir, provider) {
     try {
       const pp2 = providerKeyPath(projectDir, prov);
       if (existsSync34(pp2)) {
-        const v = readFileSync30(pp2, "utf-8").trim();
+        const v = readFileSync32(pp2, "utf-8").trim();
         if (v)
           return v;
       }
@@ -61640,7 +62299,7 @@ function getApiKey(projectDir, provider) {
 }
 
 // ../agentic/dist/dev-api.js
-import { existsSync as existsSync35, readFileSync as readFileSync31 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync33 } from "node:fs";
 import { resolve as resolve31 } from "node:path";
 
 // ../agentic/dist/providers/openai.js
@@ -62013,7 +62672,7 @@ function getPerProviderKeyRaw(projectDir, provider) {
   try {
     const p = resolve31(projectDir, ".vesk", "agentic", "keys", `${sanitizeProviderName(prov)}.key`);
     if (existsSync35(p)) {
-      const v = readFileSync31(p, "utf-8").trim();
+      const v = readFileSync33(p, "utf-8").trim();
       if (v)
         return v;
     }
@@ -62874,8 +63533,8 @@ var Agent = class {
 };
 
 // ../agentic/dist/tools/vesk.js
-import { existsSync as existsSync36, readFileSync as readFileSync32, writeFileSync as writeFileSync18, mkdirSync as mkdirSync17, readdirSync as readdirSync10, statSync as statSync19 } from "node:fs";
-import { resolve as resolve32, join as join24, dirname as dirname23, sep as sep6 } from "node:path";
+import { existsSync as existsSync36, readFileSync as readFileSync34, writeFileSync as writeFileSync18, mkdirSync as mkdirSync17, readdirSync as readdirSync11, statSync as statSync20 } from "node:fs";
+import { resolve as resolve32, join as join25, dirname as dirname23, sep as sep6 } from "node:path";
 function resolveWithin3(baseDir, relPath) {
   const base = resolve32(baseDir);
   const target = resolve32(baseDir, relPath);
@@ -62893,7 +63552,7 @@ function readPluginState3(veskDir) {
   if (!existsSync36(file))
     return { version: 1, plugins: [] };
   try {
-    const raw2 = JSON.parse(readFileSync32(file, "utf-8"));
+    const raw2 = JSON.parse(readFileSync34(file, "utf-8"));
     if (!raw2 || typeof raw2 !== "object")
       return { version: 1, plugins: [] };
     if (raw2.version !== 1)
@@ -62937,7 +63596,7 @@ function findConfigFile3(projectDir) {
   return { path: null, isTs: false };
 }
 function checkpointDir(veskDir) {
-  return join24(resolve32(veskDir), "checkpoints");
+  return join25(resolve32(veskDir), "checkpoints");
 }
 function findMatchingBrace2(src2, openIdx) {
   let inStr = null;
@@ -63082,18 +63741,18 @@ function createVeskTools(deps) {
       async execute(_args) {
         try {
           const projExists = existsSync36(projectDir);
-          const projEntries = projExists ? readdirSync10(projectDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
+          const projEntries = projExists ? readdirSync11(projectDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
           const appExists = existsSync36(appDir);
-          const appEntries = appExists ? readdirSync10(appDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
+          const appEntries = appExists ? readdirSync11(appDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
           const veskExists = existsSync36(veskDir);
-          const veskEntries = veskExists ? readdirSync10(veskDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
+          const veskEntries = veskExists ? readdirSync11(veskDir, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name) : [];
           const cfgInfo = findConfigFile3(projectDir);
           let configSource = null;
           let configExists = false;
           if (cfgInfo.path && existsSync36(cfgInfo.path)) {
             configExists = true;
             try {
-              configSource = readFileSync32(cfgInfo.path, "utf-8").slice(0, 8e3);
+              configSource = readFileSync34(cfgInfo.path, "utf-8").slice(0, 8e3);
             } catch {
               configSource = null;
             }
@@ -63102,7 +63761,7 @@ function createVeskTools(deps) {
           const pkgPath = resolve32(projectDir, "package.json");
           if (existsSync36(pkgPath)) {
             try {
-              packageJson = JSON.parse(readFileSync32(pkgPath, "utf-8"));
+              packageJson = JSON.parse(readFileSync34(pkgPath, "utf-8"));
             } catch {
               packageJson = null;
             }
@@ -63184,13 +63843,13 @@ function createVeskTools(deps) {
             return jsonError("path escapes project root", { path: rel });
           if (!existsSync36(resolved))
             return jsonError("not found", { path: rel });
-          const st = statSync19(resolved);
+          const st = statSync20(resolved);
           if (st.isDirectory()) {
-            const entries = readdirSync10(resolved, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name);
+            const entries = readdirSync11(resolved, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + "/" : e.name);
             return jsonOk({ ok: true, path: rel, directory: true, entries: entries.slice(0, 200) });
           }
           if (st.isFile()) {
-            const content = readFileSync32(resolved, "utf-8");
+            const content = readFileSync34(resolved, "utf-8");
             const capped = content.length > 2e4 ? content.slice(0, 2e4) + "\n/* truncated */" : content;
             return jsonOk({ ok: true, path: rel, directory: false, content: capped, size: content.length });
           }
@@ -63226,7 +63885,7 @@ function createVeskTools(deps) {
           if (!info.path || !existsSync36(info.path)) {
             return jsonOk({ ok: true, path: null, exists: false, source: "", config: {} });
           }
-          const source = readFileSync32(info.path, "utf-8");
+          const source = readFileSync34(info.path, "utf-8");
           return jsonOk({ ok: true, path: info.path, exists: true, source, config: null });
         } catch (e) {
           return jsonError(e instanceof Error ? e.message : String(e));
@@ -63284,7 +63943,7 @@ function createVeskTools(deps) {
             const contained = resolveWithin3(projectDir, info.path.slice(projectDir.length + 1));
             if (!contained)
               return jsonError("path escapes project root");
-            const current3 = readFileSync32(info.path, "utf-8");
+            const current3 = readFileSync34(info.path, "utf-8");
             const patched = applySimpleConfigToggle(current3, key, a.value);
             if (patched === null)
               return jsonError("could not safely edit the config object; use the source editor");
@@ -63552,7 +64211,7 @@ function createVeskTools(deps) {
           const dir = checkpointDir(veskDir);
           mkdirSync17(dir, { recursive: true });
           const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-          const file = join24(dir, `${id}.json`);
+          const file = join25(dir, `${id}.json`);
           const check = resolveWithin3(dir, `${id}.json`);
           if (!check)
             return jsonError("path escapes project root");
@@ -63601,13 +64260,13 @@ function createVeskTools(deps) {
           } catch {
           }
           const dir = checkpointDir(veskDir);
-          const file = join24(dir, `${checkpointId}.json`);
+          const file = join25(dir, `${checkpointId}.json`);
           const contained = resolveWithin3(dir, `${checkpointId}.json`);
           if (!contained)
             return jsonError("path escapes project root");
           if (!existsSync36(file))
             return jsonError(`checkpoint not found: ${checkpointId}`, { checkpointId });
-          const raw2 = readFileSync32(file, "utf-8");
+          const raw2 = readFileSync34(file, "utf-8");
           let data2;
           try {
             data2 = JSON.parse(raw2);
@@ -63690,7 +64349,7 @@ function renderDefaultNotFoundPage2(opts = {}) {
 }
 
 // ../adapter/dist/css.js
-import { readFileSync as readFileSync33, existsSync as existsSync37 } from "node:fs";
+import { readFileSync as readFileSync35, existsSync as existsSync37 } from "node:fs";
 import { resolve as resolve33 } from "node:path";
 var GLOBAL_CSS_URL2 = "/_vesk/static/global.css";
 function resolveUserCssPath2(appDir) {
@@ -63717,7 +64376,7 @@ function resolveCssUrls2(opts) {
 // ../adapter/dist/hmr.js
 init_client_codegen();
 import { WebSocketServer } from "ws";
-import { readFileSync as readFileSync34, existsSync as existsSync38, writeFileSync as writeFileSync19 } from "node:fs";
+import { readFileSync as readFileSync36, existsSync as existsSync38, writeFileSync as writeFileSync19 } from "node:fs";
 import { resolve as resolve34, dirname as dirname24 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 init_default_pages();
@@ -63961,7 +64620,7 @@ function buildErrorPayload(error, filename, opts = {}) {
     for (const absPath of candidates) {
       try {
         if (existsSync38(absPath)) {
-          src2 = readFileSync34(absPath, "utf-8");
+          src2 = readFileSync36(absPath, "utf-8");
           resolvedAbsPath = absPath;
           break;
         }
@@ -64009,7 +64668,7 @@ function buildErrorPayload(error, filename, opts = {}) {
 }
 
 // ../adapter/dist/ssr-error.js
-import { existsSync as existsSync39, readFileSync as readFileSync35 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync37 } from "node:fs";
 import { relative as relative7, resolve as resolve35 } from "node:path";
 
 // ../adapter/dist/error-codeframe.js
@@ -64106,7 +64765,7 @@ function extractComponentNames(stack) {
   }
   return names;
 }
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".vsk"]);
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".vsk"]);
 function scanFrameLocation(seg) {
   if (!seg)
     return null;
@@ -64187,7 +64846,7 @@ function firstSourceFileFrame(stack, projectRoot) {
     if (!p.startsWith("/"))
       continue;
     const ext = p.slice(p.lastIndexOf(".")).split(":")[0].toLowerCase();
-    if (!SOURCE_EXTENSIONS.has(ext))
+    if (!SOURCE_EXTENSIONS2.has(ext))
       continue;
     if (isGeneratedPath(p))
       continue;
@@ -64240,7 +64899,7 @@ function readIfFile(absPath) {
   try {
     if (!existsSync39(absPath))
       return null;
-    return readFileSync35(absPath, "utf-8");
+    return readFileSync37(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -64388,9 +65047,9 @@ function renderDevErrorPage(payload, opts) {
 
 // src/build-packages.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { cpSync as cpSync2, existsSync as existsSync40, mkdirSync as mkdirSync18, readFileSync as readFileSync36, readdirSync as readdirSync11, statSync as statSync20, writeFileSync as writeFileSync20 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync40, mkdirSync as mkdirSync18, readFileSync as readFileSync38, readdirSync as readdirSync12, statSync as statSync21, writeFileSync as writeFileSync20 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { dirname as dirname25, join as join25, resolve as resolve36 } from "node:path";
+import { dirname as dirname25, join as join26, resolve as resolve36 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 var require2 = createRequire7(import.meta.url);
 var __dirname9 = dirname25(fileURLToPath8(import.meta.url));
@@ -64420,9 +65079,9 @@ var PACKAGES = {
 };
 function newestSourceMtime(srcDir) {
   let newest = 0;
-  for (const name of readdirSync11(srcDir)) {
-    const p = join25(srcDir, name);
-    const st = statSync20(p);
+  for (const name of readdirSync12(srcDir)) {
+    const p = join26(srcDir, name);
+    const st = statSync21(p);
     if (st.isDirectory()) {
       newest = Math.max(newest, newestSourceMtime(p));
     } else if (st.isFile() && /\.ts$/.test(name) && !name.endsWith(".test.ts")) {
@@ -64432,11 +65091,11 @@ function newestSourceMtime(srcDir) {
   return newest;
 }
 function distStale(pkgDir, entry) {
-  const distIndex = join25(pkgDir, "dist", `${entry}.js`);
+  const distIndex = join26(pkgDir, "dist", `${entry}.js`);
   if (!existsSync40(distIndex)) return true;
-  const distPkg = join25(pkgDir, "dist", "package.json");
-  const distStamp = Math.max(statSync20(distIndex).mtimeMs, existsSync40(distPkg) ? statSync20(distPkg).mtimeMs : 0);
-  return newestSourceMtime(join25(pkgDir, "src")) > distStamp;
+  const distPkg = join26(pkgDir, "dist", "package.json");
+  const distStamp = Math.max(statSync21(distIndex).mtimeMs, existsSync40(distPkg) ? statSync21(distPkg).mtimeMs : 0);
+  return newestSourceMtime(join26(pkgDir, "src")) > distStamp;
 }
 function distPackageJson(pkgName, entry, serverEntry, version2) {
   const exports = {
@@ -64460,23 +65119,23 @@ function distPackageJson(pkgName, entry, serverEntry, version2) {
 function buildPackages(force = false) {
   for (const [pkg, cfg] of Object.entries(PACKAGES)) {
     const pkgDir = resolve36(root2, "packages", pkg);
-    if (!existsSync40(join25(pkgDir, "src"))) continue;
+    if (!existsSync40(join26(pkgDir, "src"))) continue;
     if (!force && !distStale(pkgDir, cfg.entry)) continue;
     console.log(`[build] ${cfg.name} -> tsc`);
     const tscBin = require2.resolve("typescript/bin/tsc");
-    const result = spawnSync2(process.execPath, [tscBin, "-p", join25(pkgDir, "tsconfig.build.json")], {
+    const result = spawnSync2(process.execPath, [tscBin, "-p", join26(pkgDir, "tsconfig.build.json")], {
       stdio: "inherit"
     });
     if (result.status !== 0) {
       throw new Error(`tsc failed for ${cfg.name}`);
     }
-    const distDir = join25(pkgDir, "dist");
+    const distDir = join26(pkgDir, "dist");
     for (const c of cfg.copy || []) {
-      const to = join25(distDir, c.to);
+      const to = join26(distDir, c.to);
       mkdirSync18(dirname25(to), { recursive: true });
-      cpSync2(join25(pkgDir, c.from), to, { recursive: true });
+      cpSync2(join26(pkgDir, c.from), to, { recursive: true });
     }
-    const srcPkg = JSON.parse(readFileSync36(join25(pkgDir, "package.json"), "utf-8"));
+    const srcPkg = JSON.parse(readFileSync38(join26(pkgDir, "package.json"), "utf-8"));
     if (pkg === "lucide-vesk") {
       const lucideDistPkg = {
         name: srcPkg.name,
@@ -64490,9 +65149,9 @@ function buildPackages(force = false) {
           "./package.json": "./package.json"
         }
       };
-      writeFileSync20(join25(distDir, "package.json"), JSON.stringify(lucideDistPkg, null, 2) + "\n");
+      writeFileSync20(join26(distDir, "package.json"), JSON.stringify(lucideDistPkg, null, 2) + "\n");
     } else {
-      writeFileSync20(join25(distDir, "package.json"), distPackageJson(cfg.name, cfg.entry, cfg.serverEntry, srcPkg.version || "1.0.0"));
+      writeFileSync20(join26(distDir, "package.json"), distPackageJson(cfg.name, cfg.entry, cfg.serverEntry, srcPkg.version || "1.0.0"));
     }
     console.log(`[build] ${cfg.name} -> dist`);
   }
@@ -64505,7 +65164,7 @@ if (process.argv[1] && resolve36(process.argv[1]) === fileURLToPath8(import.meta
 }
 
 // src/action-handler.ts
-import { existsSync as existsSync41, readFileSync as readFileSync37, readdirSync as readdirSync12 } from "node:fs";
+import { existsSync as existsSync41, readFileSync as readFileSync39, readdirSync as readdirSync13 } from "node:fs";
 import { resolve as resolve37 } from "node:path";
 
 // ../compiler/dist/server-cookies.js
@@ -64601,7 +65260,7 @@ function walkVskFiles(dir, out, seen) {
   if (!existsSync41(dir)) return;
   let entries;
   try {
-    entries = readdirSync12(dir, { withFileTypes: true });
+    entries = readdirSync13(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -64635,7 +65294,7 @@ function candidateSources(appDirPath, routeTree) {
 function registerSource(sourcePath2) {
   if (!existsSync41(sourcePath2)) return;
   try {
-    compileFile(readFileSync37(sourcePath2, "utf-8"), { sourcePath: sourcePath2 });
+    compileFile(readFileSync39(sourcePath2, "utf-8"), { sourcePath: sourcePath2 });
   } catch {
   }
 }
@@ -64674,14 +65333,14 @@ async function renderPageHtml(pagePathname, params, ctx2) {
     const pageFilePath = resolve37(ctx2.appDirPath, node.sourceDir, "page.vsk");
     const layoutFilePath = resolve37(ctx2.appDirPath, node.sourceDir, "layout.vsk");
     if (i === chain.length - 1 && node.page && existsSync41(pageFilePath)) {
-      const src3 = readFileSync37(pageFilePath, "utf-8");
+      const src3 = readFileSync39(pageFilePath, "utf-8");
       const compName2 = resolveComponentName(src3) || node.page;
       const result = await renderPage(src3, compName2, { params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath });
       body = result.body;
       head = result.head || "";
     }
     if (node.layout && existsSync41(layoutFilePath)) {
-      const src3 = readFileSync37(layoutFilePath, "utf-8");
+      const src3 = readFileSync39(layoutFilePath, "utf-8");
       const compName2 = resolveComponentName(src3) || node.layout;
       const result = await renderPage(src3, compName2, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath });
       body = result.body;
@@ -64712,7 +65371,7 @@ ${prettifyHtml(body)}
   }
   const leaf2 = chain.find((n) => n.page);
   if (!leaf2) return null;
-  const src2 = readFileSync37(resolve37(ctx2.appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
+  const src2 = readFileSync39(resolve37(ctx2.appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
   const compName = resolveComponentName(src2) || leaf2.page;
   const html = await renderFullPage(src2, compName, { params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: actionCssUrls(ctx2.appDirPath), security: ctx2.security, sourcePath: resolve37(ctx2.appDirPath, leaf2.sourceDir, "page.vsk"), plugins: ctx2.plugins });
   return applyHtmlPlugins(html.replace("</body>", '	<script type="module" src="/_vesk/hmr.js"></script>\n</body>'), ctx2.plugins, { sourcePath: ctx2.url.pathname });
@@ -64879,7 +65538,7 @@ function buildDevErrorPayload(input) {
       payload.column = colMatch ? parseInt(colMatch[1], 10) : 1;
       if (fileExists && payload.line > 0) {
         try {
-          const src2 = readFileSync38(fullPath, "utf-8");
+          const src2 = readFileSync40(fullPath, "utf-8");
           const cf = buildCodeframe2(src2, payload.line, payload.column);
           if (cf) {
             cf.file = payload.file || filename;
@@ -64969,9 +65628,9 @@ function resolveRuntimeDir(projectDir) {
     resolve38(import.meta.dirname ?? ".", "..", "..", "runtime", "dist")
   ];
   for (const dir of candidates) {
-    if (existsSync42(join26(dir, "ripple-runtime.js"))) return dir;
-    const distDir = join26(dir, "dist");
-    if (existsSync42(join26(distDir, "ripple-runtime.js"))) return distDir;
+    if (existsSync42(join27(dir, "ripple-runtime.js"))) return dir;
+    const distDir = join27(dir, "dist");
+    if (existsSync42(join27(distDir, "ripple-runtime.js"))) return distDir;
   }
   return null;
 }
@@ -65210,8 +65869,8 @@ function collectRoutePaths(nodes, out = []) {
 function countFilesNamed(dir, name) {
   if (!existsSync42(dir)) return 0;
   let n = 0;
-  for (const entry of readdirSync13(dir, { withFileTypes: true })) {
-    const p = join26(dir, entry.name);
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
+    const p = join27(dir, entry.name);
     if (entry.isDirectory()) n += countFilesNamed(p, name);
     else if (entry.name === name) n++;
   }
@@ -65222,7 +65881,7 @@ function cachedSsrCompile(cache2, src2, filePath) {
     resetVskState(true);
     return compileFile(source, { sourcePath: filePath });
   };
-  const st = statSync21(filePath, { throwIfNoEntry: false });
+  const st = statSync22(filePath, { throwIfNoEntry: false });
   if (st) {
     const cur = cache2.get(filePath);
     if (cur && cur.mtimeMs === st.mtimeMs && cur.size === st.size) return cur.result;
@@ -65254,7 +65913,7 @@ async function startDevServer(port, projectDir, config, host) {
     process.exit(1);
   }
   const runtimeDir = runtimeDirUnchecked;
-  const veskStateDir = join26(projectDir, ".vesk");
+  const veskStateDir = join27(projectDir, ".vesk");
   const configPluginsRaw = config.plugins || [];
   const configPluginNames = configPluginsRaw.map((p) => typeof p === "string" ? p : p?.name).filter((n) => !!n);
   const rawDevPlugins = config.plugins || [];
@@ -65353,21 +66012,21 @@ async function startDevServer(port, projectDir, config, host) {
   }
   let devGlobalCssContent = "";
   let lastServedCssGlobal = "";
-  const appCssPath = join26(appDirPath, "global.css");
-  const srcDir = join26(projectDir, "src");
-  const cssPath = join26(srcDir, "global.css");
-  const altCssPath = join26(srcDir, "app.css");
+  const appCssPath = join27(appDirPath, "global.css");
+  const srcDir = join27(projectDir, "src");
+  const cssPath = join27(srcDir, "global.css");
+  const altCssPath = join27(srcDir, "app.css");
   let rawCss = "";
   let devCssSource = "";
   if (existsSync42(appCssPath)) {
     devCssSource = appCssPath;
-    rawCss = readFileSync38(appCssPath, "utf-8");
+    rawCss = readFileSync40(appCssPath, "utf-8");
   } else if (existsSync42(cssPath)) {
     devCssSource = cssPath;
-    rawCss = readFileSync38(cssPath, "utf-8");
+    rawCss = readFileSync40(cssPath, "utf-8");
   } else if (existsSync42(altCssPath)) {
     devCssSource = altCssPath;
-    rawCss = readFileSync38(altCssPath, "utf-8");
+    rawCss = readFileSync40(altCssPath, "utf-8");
   }
   if (rawCss) {
     const activeAtStart = getActiveDevPlugins();
@@ -65415,22 +66074,22 @@ async function startDevServer(port, projectDir, config, host) {
   }
   const routeChunksBuilt = /* @__PURE__ */ new Set();
   let clientGeneration = 0;
-  const devCacheDir = () => join26(projectDir, "node_modules", ".vesk", "dev-cache");
+  const devCacheDir = () => join27(projectDir, "node_modules", ".vesk", "dev-cache");
   function devCacheKey() {
     const parts = [`flags:${!!config.routeDataCache}`];
     const walk9 = (dir) => {
       let entries = [];
       try {
-        entries = readdirSync13(dir);
+        entries = readdirSync14(dir);
       } catch {
         return;
       }
       for (const name of entries.sort()) {
         if (name === "node_modules" || name.startsWith(".")) continue;
-        const p = join26(dir, name);
+        const p = join27(dir, name);
         let st;
         try {
-          st = statSync21(p);
+          st = statSync22(p);
         } catch {
           continue;
         }
@@ -65444,15 +66103,15 @@ async function startDevServer(port, projectDir, config, host) {
     };
     walk9(appDirPath);
     try {
-      parts.push(`compiler:${readFileSync38(join26(process.cwd(), "node_modules", "@vesk", "compiler", "package.json"), "utf8")}`);
+      parts.push(`compiler:${readFileSync40(join27(process.cwd(), "node_modules", "@vesk", "compiler", "package.json"), "utf8")}`);
     } catch {
     }
-    return createHash2("sha256").update(parts.join("\n")).digest("hex").slice(0, 32);
+    return createHash3("sha256").update(parts.join("\n")).digest("hex").slice(0, 32);
   }
   function readDevBundleCache() {
     try {
-      const file = join26(devCacheDir(), "client-bundle.json");
-      const parsed = JSON.parse(readFileSync38(file, "utf8"));
+      const file = join27(devCacheDir(), "client-bundle.json");
+      const parsed = JSON.parse(readFileSync40(file, "utf8"));
       if (parsed.key !== devCacheKey() || typeof parsed.main !== "string" || !Array.isArray(parsed.chunks)) return null;
       return { main: parsed.main, chunks: parsed.chunks };
     } catch {
@@ -65463,8 +66122,8 @@ async function startDevServer(port, projectDir, config, host) {
     try {
       const dir = devCacheDir();
       mkdirSync19(dir, { recursive: true });
-      const file = join26(dir, "client-bundle.json");
-      const tmp = join26(dir, `client-bundle.${process.pid}.tmp`);
+      const file = join27(dir, "client-bundle.json");
+      const tmp = join27(dir, `client-bundle.${process.pid}.tmp`);
       writeFileSync21(tmp, JSON.stringify({ key: devCacheKey(), main, chunks }), "utf8");
       renameSync2(tmp, file);
     } catch {
@@ -65757,7 +66416,7 @@ async function startDevServer(port, projectDir, config, host) {
       if (!filename) return;
       const kind = classifyHmrWatchPath(filename);
       if (kind === "ignored") return;
-      const fullPath = filename.startsWith("/") ? filename : join26(watchDir, filename);
+      const fullPath = filename.startsWith("/") ? filename : join27(watchDir, filename);
       const fileExists = existsSync42(fullPath);
       const bcast = (msg) => {
         const f = globalThis.__vesk_broadcastHmr;
@@ -65782,7 +66441,7 @@ async function startDevServer(port, projectDir, config, host) {
         debounceTimer = setTimeout(async () => {
           const t0 = Date.now();
           try {
-            const current3 = fileExists ? readFileSync38(fullPath, "utf-8") : null;
+            const current3 = fileExists ? readFileSync40(fullPath, "utf-8") : null;
             if (eventType !== "rename" && current3 !== null && lastSeenContent.get(fullPath) === current3) {
               LOG.info(`skipped unchanged (${filename})`);
               return;
@@ -65841,7 +66500,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
                   if (compCode.trim()) fnSources = { _raw: compCode };
                 } else if (fileExists && !bundleError) {
                   try {
-                    const src2 = readFileSync38(fullPath, "utf-8");
+                    const src2 = readFileSync40(fullPath, "utf-8");
                     let compCode = buildHmrEvalSnippet2(
                       compileClient2(src2, null, { forceClient: true, sourcePath: fullPath, mdRoots: [projectDir] })
                     );
@@ -65925,7 +66584,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
         cssDebounceTimer = setTimeout(async () => {
           try {
             if (fileExists) {
-              rawCss = readFileSync38(fullPath, "utf-8");
+              rawCss = readFileSync40(fullPath, "utf-8");
             }
             const cssChanged = await rebuildTailwindCss();
             if (cssChanged && typeof globalThis.__vesk_broadcastHmr === "function") {
@@ -65959,7 +66618,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
   } catch (e) {
     LOG.warn("file watching unavailable, serving without auto-rebuild");
   }
-  const MIME3 = {
+  const MIME2 = {
     ".svg": "image/svg+xml",
     ".css": "text/css",
     "": "application/javascript",
@@ -65972,8 +66631,8 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     ".json": "application/json",
     ".webmanifest": "application/manifest+json"
   };
-  const hmrJsPath = join26(runtimeDir, "hmr-client.js");
-  const hmrTsPath = join26(runtimeDir, "hmr-client.ts");
+  const hmrJsPath = join27(runtimeDir, "hmr-client.js");
+  const hmrTsPath = join27(runtimeDir, "hmr-client.ts");
   const hmrClientPath = existsSync42(hmrJsPath) ? hmrJsPath : existsSync42(hmrTsPath) ? hmrTsPath : null;
   function extractCompName2(src2) {
     return resolveComponentName(src2);
@@ -66082,7 +66741,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     }
     if (url.pathname === "/_vesk/hmr" || url.pathname === "/_vesk/hmr.js") {
       if (hmrClientPath) {
-        let hmrContent = readFileSync38(hmrClientPath, "utf-8");
+        let hmrContent = readFileSync40(hmrClientPath, "utf-8");
         if (hmrClientPath.endsWith(".ts")) {
           hmrContent = stripCodeTypes2(hmrContent);
         }
@@ -66130,10 +66789,10 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     }
     if (url.pathname !== "/") {
       const staticPath = url.pathname.length > 1 ? resolveWithin2(publicDir, url.pathname.slice(1)) : null;
-      if (staticPath && existsSync42(staticPath) && statSync21(staticPath).isFile()) {
-        const ext = extname8(staticPath);
-        res.writeHead(200, { "Content-Type": MIME3[ext] || "application/octet-stream" });
-        res.end(readFileSync38(staticPath));
+      if (staticPath && existsSync42(staticPath) && statSync22(staticPath).isFile()) {
+        const ext = extname7(staticPath);
+        res.writeHead(200, { "Content-Type": MIME2[ext] || "application/octet-stream" });
+        res.end(readFileSync40(staticPath));
         return;
       }
     }
@@ -66157,7 +66816,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
       return;
     }
     const mwChain = collectMiddlewareChain(routeTree, url.pathname, appDirPath);
-    const apiDirPath = join26(appDirPath, "api");
+    const apiDirPath = join27(appDirPath, "api");
     if (url.pathname.startsWith("/api") && existsSync42(apiDirPath)) {
       const apiRoutes = await scanApiRoutes(apiDirPath);
       const apiMatch = matchApiUrl(apiRoutes, req.url || url.pathname);
@@ -66236,7 +66895,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
         const nfPath = resolve38(appDirPath, rootNode.sourceDir, "not-found.vsk");
         if (existsSync42(nfPath)) {
           try {
-            const nfSrc = readFileSync38(nfPath, "utf-8");
+            const nfSrc = readFileSync40(nfPath, "utf-8");
             const nfCompName = extractCompName2(nfSrc) || rootNode.notFound;
             notFoundHtml = await renderFullPage(nfSrc, nfCompName, { params: {}, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: activeCssUrls(), security, externalDataScript: storeDataScript, sourcePath: nfPath, cached: cachedSsrCompile(ssrCompileCache, nfSrc, nfPath), plugins: getActiveDevPlugins() });
           } catch {
@@ -66291,7 +66950,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
             const pageFilePath = resolve38(appDirPath, node.sourceDir, "page.vsk");
             const layoutFilePath = resolve38(appDirPath, node.sourceDir, "layout.vsk");
             if (i === chain.length - 1 && node.page && existsSync42(pageFilePath)) {
-              const src2 = readFileSync38(pageFilePath, "utf-8");
+              const src2 = readFileSync40(pageFilePath, "utf-8");
               const compName = extractCompName2(src2) || node.page;
               const result = await renderPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath, cached: cachedSsrCompile(ssrCompileCache, src2, pageFilePath) });
               body = result.body;
@@ -66299,7 +66958,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
               props = result.props;
             }
             if (node.layout && existsSync42(layoutFilePath)) {
-              const src2 = readFileSync38(layoutFilePath, "utf-8");
+              const src2 = readFileSync40(layoutFilePath, "utf-8");
               const compName = extractCompName2(src2) || node.layout;
               const result = await renderPage(src2, compName, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath, cached: cachedSsrCompile(ssrCompileCache, src2, layoutFilePath) });
               body = result.body;
@@ -66344,7 +67003,7 @@ ${prettifyHtml(body)}
           } else {
             const leaf2 = chain.find((n) => n.page);
             if (leaf2) {
-              const src2 = readFileSync38(resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
+              const src2 = readFileSync40(resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
               const compName = extractCompName2(src2) || leaf2.page;
               html = await renderFullPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: activeCssUrls(), security, externalDataScript: storeDataScript, sourcePath: resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), cached: cachedSsrCompile(ssrCompileCache, src2, resolve38(appDirPath, leaf2.sourceDir, "page.vsk")), plugins: getActiveDevPlugins() });
               html = html.replace("</body>", '	<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
@@ -66373,7 +67032,7 @@ ${prettifyHtml(body)}
         if (!hasLayout) {
           const leaf2 = chain.find((n) => n.page);
           if (leaf2) {
-            const src2 = readFileSync38(resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
+            const src2 = readFileSync40(resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), "utf-8");
             const compName = extractCompName2(src2) || leaf2.page;
             yield* renderPageStream(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: activeCssUrls(), security, externalDataScript: storeDataScript, sourcePath: resolve38(appDirPath, leaf2.sourceDir, "page.vsk"), cached: cachedSsrCompile(ssrCompileCache, src2, resolve38(appDirPath, leaf2.sourceDir, "page.vsk")), plugins: getActiveDevPlugins() });
           } else {
@@ -66389,7 +67048,7 @@ ${prettifyHtml(body)}
           const pageFilePath = resolve38(appDirPath, node.sourceDir, "page.vsk");
           const layoutFilePath = resolve38(appDirPath, node.sourceDir, "layout.vsk");
           if (i === chain.length - 1 && node.page && existsSync42(pageFilePath)) {
-            const src2 = readFileSync38(pageFilePath, "utf-8");
+            const src2 = readFileSync40(pageFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.page;
             const result = await renderPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath, cached: cachedSsrCompile(ssrCompileCache, src2, pageFilePath) });
             body = result.body;
@@ -66397,7 +67056,7 @@ ${prettifyHtml(body)}
             props = result.props;
           }
           if (node.layout && existsSync42(layoutFilePath)) {
-            const src2 = readFileSync38(layoutFilePath, "utf-8");
+            const src2 = readFileSync40(layoutFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.layout;
             const result = await renderPage(src2, compName, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath, cached: cachedSsrCompile(ssrCompileCache, src2, layoutFilePath) });
             body = result.body;
@@ -66541,7 +67200,7 @@ ${prettifyHtml(body)}
               const nfPath = resolve38(appDirPath, node.sourceDir, "not-found.vsk");
               if (existsSync42(nfPath)) {
                 try {
-                  const nfSrc = readFileSync38(nfPath, "utf-8");
+                  const nfSrc = readFileSync40(nfPath, "utf-8");
                   const nfCompName = extractCompName2(nfSrc) || node.notFound;
                   const html = await renderFullPage(nfSrc, nfCompName, { params: match.params, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: activeCssUrls(), security, externalDataScript: storeDataScript, sourcePath: nfPath, cached: cachedSsrCompile(ssrCompileCache, nfSrc, nfPath), plugins: getActiveDevPlugins() });
                   notFoundHtml = injectDevScripts(html);
@@ -66587,7 +67246,7 @@ ${prettifyHtml(body)}
               const errPath = resolve38(appDirPath, node.sourceDir, "error.vsk");
               if (existsSync42(errPath)) {
                 try {
-                  const errSrc = readFileSync38(errPath, "utf-8");
+                  const errSrc = readFileSync40(errPath, "utf-8");
                   const errCompName = extractCompName2(errSrc) || node.error;
                   const errProps = {
                     error: err.message,
@@ -66659,7 +67318,7 @@ ${prettifyHtml(body)}
     LOG.ok(`dev server at http://localhost:${port} (listening on ${bindHost})`);
     const routes = collectRoutePaths(routeTree);
     const pageCount = countPages(routeTree);
-    const apiCount = countFilesNamed(join26(appDirPath, "api"), "route.ts");
+    const apiCount = countFilesNamed(join27(appDirPath, "api"), "route.ts");
     LOG.info(`${projectDir}`);
     LOG.info(`${pageCount} page${pageCount === 1 ? "" : "s"}: ${routes.join(", ") || "(none)"}`);
     if (apiCount > 0) LOG.info(`${apiCount} api route${apiCount === 1 ? "" : "s"} (app/api)`);
@@ -66986,12 +67645,12 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
 }
 function loadEnvFiles(projectDir) {
   const files = [
-    join30(projectDir, ".env"),
-    join30(projectDir, ".env.local")
+    join31(projectDir, ".env"),
+    join31(projectDir, ".env.local")
   ];
   for (const filePath of files) {
     if (!existsSync45(filePath)) continue;
-    const content = readFileSync42(filePath, "utf-8");
+    const content = readFileSync44(filePath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -67160,7 +67819,7 @@ if (cmd === "start") {
 if (cmd === "init") {
   const projectDir = process.cwd();
   const { appDir: appDirPath } = resolveProjectDirs(projectDir, await loadConfig(projectDir) || {});
-  const target = join30(appDirPath, "global.css");
+  const target = join31(appDirPath, "global.css");
   if (existsSync45(target)) {
     console.error(`vesk init: ${target} already exists \u2014 skipping`);
     process.exit(0);
@@ -67181,7 +67840,7 @@ if (cmd === "migrate") {
   const projectDir = process.cwd();
   const { runMigrate: runMigrate2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   const { CODEMODS: CODEMODS2 } = await Promise.resolve().then(() => (init_codemods(), codemods_exports));
-  const { version: cliVersion } = JSON.parse(readFileSync42(join30(__dirname10, "..", "package.json"), "utf-8"));
+  const { version: cliVersion } = JSON.parse(readFileSync44(join31(__dirname10, "..", "package.json"), "utf-8"));
   if (args.includes("--list")) {
     console.error("vesk migrate: available codemods");
     for (const c of CODEMODS2) {