@vesk/vesk-cli 0.2.67 → 0.2.68

package/dist/cli.js

@@ -35641,6 +35641,120 @@ var init_paths = __esm({
   }
 });
 
+// ../adapter/src/platform-output.ts
+import {
+  mkdirSync as mkdirSync6,
+  copyFileSync as copyFileSync2,
+  readdirSync as readdirSync3,
+  statSync as statSync6,
+  existsSync as existsSync15,
+  writeFileSync as writeFileSync7,
+  rmSync as rmSync2,
+  readFileSync as readFileSync15
+} from "node:fs";
+import { resolve as resolve13, join as join10, 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 readdirSync3(srcDir)) {
+    const srcPath = join10(srcDir, entry);
+    const destPath = join10(destDir, entry);
+    if (statSync6(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 = readFileSync15(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 readdirSync3(d)) {
+      const full = join10(d, entry);
+      const rel = prefix ? `${prefix}/${entry}` : entry;
+      if (statSync6(full).isDirectory()) {
+        walk9(full, rel);
+      } else {
+        out.push({ rel, buffer: readFileSync15(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 readFileSync17,
+  writeFileSync as writeFileSync8,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync7,
+  statSync as statSync8
 } 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 join11, 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(readFileSync17(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 = join11(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 = join11(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(readFileSync17(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) && statSync8(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) && statSync8(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) && statSync8(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(readFileSync17(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 readdirSync4, statSync as statSync9, existsSync as existsSync18, writeFileSync as writeFileSync9, readFileSync as readFileSync18 } from "node:fs";
+import { resolve as resolve16, join as join12 } 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 = readdirSync4(src2);
     for (const entry of entries) {
-      const srcPath = join11(src2, entry);
-      const destPath = join11(dest, entry);
-      const st = statSync8(srcPath);
+      const srcPath = join12(src2, entry);
+      const destPath = join12(dest, entry);
+      const st = statSync9(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 = readFileSync18(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 readFileSync19, existsSync as existsSync19, readdirSync as readdirSync5, statSync as statSync10 } 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 join13 } 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(statSync10(entry).mtimeMs);
+    return join13(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(readFileSync19(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 = readFileSync19(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, readFileSync19(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 = readdirSync5(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = resolve16(dir, entry);
-      const st = statSync9(full);
+      const full = resolve17(dir, entry);
+      const st = statSync10(full);
       if (st.isDirectory()) {
         if (entry.startsWith("."))
           continue;
         walk9(full);
       } else if (entry.endsWith(".vsk")) {
-        const src2 = readFileSync18(full, "utf-8");
+        const src2 = readFileSync19(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 readFileSync20, existsSync as existsSync20, readdirSync as readdirSync6, statSync as statSync11 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
 function walkFiles(dir) {
   const results = [];
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync6(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 = statSync11(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 = readFileSync20(pagePath, "utf-8");
+    const layoutSrc = existsSync20(layoutPath) ? readFileSync20(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 join14 } 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, join14(base, "dist")]) {
+      if (existsSync21(join14(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));
   }
 });
 
@@ -48829,7 +48829,7 @@ __export(migrate_exports, {
   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 { join as join29, 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");
@@ -48861,7 +48861,7 @@ function collectTargets(dir, root3 = dir) {
     }
     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));
     }
   }
@@ -52273,8 +52273,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 readFileSync16, existsSync as existsSync16, statSync as statSync7 } 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();
@@ -52379,12 +52379,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 +52709,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 +52770,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(readFileSync16(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 +52824,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 +52842,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 +52893,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 +52950,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) && statSync7(rootFile).isFile()) {
+      res.writeHead(200, { "Content-Type": mimeFor(rootFile) });
+      res.end(readFileSync16(rootFile));
       return;
     }
     if (url.pathname === "/ssr-data.js") {
@@ -52665,13 +52987,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(readFileSync16(clientPath));
         return;
       }
     }
@@ -52683,26 +53005,25 @@ async function startProdServer(outDir, options) {
         res.end("Forbidden");
         return;
       }
-      if (existsSync15(staticPath) && statSync6(staticPath).isFile()) {
-        const ext = extname3(staticPath);
+      if (existsSync16(staticPath) && statSync7(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(readFileSync16(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(readFileSync16(htmlPath));
           return;
         }
       }
@@ -52807,17 +53128,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 = readFileSync16(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 +53212,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 = readFileSync16(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 +53258,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})`);
   });
@@ -53352,8 +53679,8 @@ 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 { createHash as createHash3 } from "node:crypto";
+import { resolve as resolve38, extname as extname7, join as join26, dirname as dirname26 } from "node:path";
 import { createServer as createServer2 } from "node:http";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 
@@ -58831,7 +59158,7 @@ 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 { resolve as resolve26, dirname as dirname19, join as join21, 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";
@@ -59248,7 +59575,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 };
 }
@@ -65447,7 +65774,7 @@ async function startDevServer(port, projectDir, config, host) {
       parts.push(`compiler:${readFileSync38(join26(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 {
@@ -65959,7 +66286,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",
@@ -66131,8 +66458,8 @@ 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" });
+        const ext = extname7(staticPath);
+        res.writeHead(200, { "Content-Type": MIME2[ext] || "application/octet-stream" });
         res.end(readFileSync38(staticPath));
         return;
       }