@absolutejs/absolute 0.19.0-beta.175 → 0.19.0-beta.177

package/dist/{index.js → src/index.js}

@@ -61,6 +61,16 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
@@ -853,15 +863,253 @@ var scanCssEntryPoints = async (dir, ignore) => {
 };
 var init_scanCssEntryPoints = () => {};
 
-// src/cli/scripts/telemetry.ts
+// src/utils/imageProcessing.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join as join2 } from "path";
+var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
+  for (const size of sizes) {
+    if (size >= target)
+      return size;
+  }
+  return sizes[sizes.length - 1] ?? target;
+}, matchHostname = (actual, pattern) => {
+  if (pattern === actual)
+    return true;
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    return actual.endsWith(suffix) && actual.length > suffix.length;
+  }
+  return false;
+}, matchPathname = (actual, pattern) => {
+  if (pattern.endsWith("/**")) {
+    const prefix = pattern.slice(0, -2);
+    return actual.startsWith(prefix);
+  }
+  return actual === pattern;
+}, MIME_MAP, callSharp = (sharpRef, input) => {
+  const factory = sharpRef;
+  return factory(input);
+}, toBuffer = (input) => {
+  if (Buffer.isBuffer(input))
+    return input;
+  return Buffer.from(input);
+}, buildOptimizedUrl = (src, width, quality, basePath = OPTIMIZATION_ENDPOINT) => `${basePath}?url=${encodeURIComponent(src)}&w=${width}&q=${quality}`, formatToMime = (format) => MIME_MAP[format], generateBlurSvg = (base64Thumbnail) => {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><filter id="b" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="${BLUR_DEVIATION}"/><feColorMatrix values="1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1"/></filter><image filter="url(#b)" x="0" y="0" width="100%" height="100%" href="${base64Thumbnail}"/></svg>`;
+  const encoded = encodeURIComponent(svg);
+  return `url("data:image/svg+xml,${encoded}")`;
+}, generateSrcSet = (src, width, sizes, config, loader) => {
+  const quality = config?.quality ?? DEFAULT_QUALITY;
+  const basePath = config?.path ?? OPTIMIZATION_ENDPOINT;
+  const buildUrl = loader ?? ((params) => buildOptimizedUrl(params.src, params.width, params.quality, basePath));
+  if (sizes) {
+    const allSizes = getAllSizes(config);
+    return allSizes.map((sizeWidth) => `${buildUrl({ quality, src, width: sizeWidth })} ${sizeWidth}w`).join(", ");
+  }
+  if (width) {
+    const allSizes = getAllSizes(config);
+    const w1x = snapToSize(width, allSizes);
+    const w2x = snapToSize(width * 2, allSizes);
+    return `${buildUrl({ quality, src, width: w1x })} 1x, ${buildUrl({ quality, src, width: w2x })} 2x`;
+  }
+  const deviceSizes = config?.deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  return deviceSizes.map((sizeWidth) => `${buildUrl({ quality, src, width: sizeWidth })} ${sizeWidth}w`).join(", ");
+}, getAllSizes = (config) => {
+  const device = config?.deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  const image2 = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
+  return [...device, ...image2].sort((left, right) => left - right);
+}, getCacheDir = (buildDir) => {
+  const dir = join2(buildDir, ".cache", "images");
+  if (!existsSync4(dir))
+    mkdirSync2(dir, { recursive: true });
+  return dir;
+}, getCacheKey = (url, width, quality, format) => {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(`${url}|${width}|${quality}|${format}`);
+  return hasher.digest("hex");
+}, isCacheStale = (meta) => Date.now() > meta.expireAt, matchRemotePattern = (urlString, patterns) => {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    return false;
+  }
+  return patterns.some((pattern) => {
+    if (pattern.protocol && parsed.protocol !== `${pattern.protocol}:`)
+      return false;
+    if (!matchHostname(parsed.hostname, pattern.hostname))
+      return false;
+    if (pattern.port && parsed.port !== pattern.port)
+      return false;
+    if (pattern.pathname && !matchPathname(parsed.pathname, pattern.pathname))
+      return false;
+    return true;
+  });
+}, negotiateFormat = (acceptHeader, configuredFormats) => {
+  for (const format of configuredFormats) {
+    const mime = MIME_MAP[format];
+    if (mime && acceptHeader.includes(mime))
+      return format;
+  }
+  if (configuredFormats.includes("webp") && acceptHeader.includes("image/webp")) {
+    return "webp";
+  }
+  return "jpeg";
+}, AVIF_QUALITY_OFFSET = 20, AVIF_EFFORT = 3, optimizeImage = async (buffer, width, quality, format) => {
+  const sharp = await tryLoadSharp();
+  if (!sharp)
+    return toBuffer(buffer);
+  const pipeline = callSharp(sharp, toBuffer(buffer)).rotate().resize(width, undefined, { withoutEnlargement: true });
+  switch (format) {
+    case "avif":
+      return pipeline.avif({ effort: AVIF_EFFORT, quality: Math.max(1, quality - AVIF_QUALITY_OFFSET) }).toBuffer();
+    case "jpeg":
+      return pipeline.jpeg({ mozjpeg: true, quality }).toBuffer();
+    case "png":
+      return pipeline.png({ quality }).toBuffer();
+    case "webp":
+      return pipeline.webp({ quality }).toBuffer();
+    default:
+      return toBuffer(buffer);
+  }
+}, readFromCache = (cacheDir, cacheKey) => {
+  const metaPath = join2(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join2(cacheDir, `${cacheKey}.data`);
+  if (!existsSync4(metaPath) || !existsSync4(dataPath))
+    return null;
+  try {
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const buffer = readFileSync(dataPath);
+    return { buffer, meta };
+  } catch {
+    return null;
+  }
+}, tryLoadSharp = async () => {
+  if (sharpLoaded)
+    return sharpModule;
+  sharpLoaded = true;
+  try {
+    const name = "sharp";
+    const mod = await import(name);
+    sharpModule = mod.default ?? mod;
+    return sharpModule;
+  } catch {
+    if (sharpWarned)
+      return null;
+    sharpWarned = true;
+    console.warn("[image] sharp not installed \u2014 serving unoptimized images. Install with: bun add sharp");
+    return null;
+  }
+}, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
+  const metaPath = join2(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join2(cacheDir, `${cacheKey}.data`);
+  writeFileSync(dataPath, buffer);
+  writeFileSync(metaPath, JSON.stringify(meta));
+};
+var init_imageProcessing = __esm(() => {
+  DEFAULT_DEVICE_SIZES = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840
+  ];
+  DEFAULT_IMAGE_SIZES = [
+    16,
+    32,
+    48,
+    64,
+    96,
+    128,
+    256,
+    384
+  ];
+  MIME_MAP = {
+    avif: "image/avif",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    webp: "image/webp"
+  };
+});
+
+// src/build/optimizeHtmlImages.ts
+var exports_optimizeHtmlImages = {};
+__export(exports_optimizeHtmlImages, {
+  optimizeHtmlImages: () => optimizeHtmlImages
+});
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+var IMG_REGEX, getAttr = (attrs, name) => {
+  const regex = new RegExp(`${name}\\s*=\\s*["']([^"']*)["']`, "i");
+  const match = regex.exec(attrs);
+  return match ? match[1] : undefined;
+}, removeAttr = (attrs, name) => attrs.replace(new RegExp(`\\s*${name}\\s*=\\s*["'][^"']*["']`, "gi"), ""), transformImgTag = (fullMatch, before, after, config) => {
+  const attrs = before + after;
+  const src = getAttr(attrs, "src");
+  if (!src)
+    return fullMatch;
+  const widthStr = getAttr(attrs, "width");
+  const sizes = getAttr(attrs, "sizes");
+  const quality = config?.quality ?? DEFAULT_QUALITY;
+  const basePath = config?.path ?? OPTIMIZATION_ENDPOINT;
+  const width = widthStr ? parseInt(widthStr, 10) : undefined;
+  const optimizedSrc = buildOptimizedUrl(src, width ?? 0, quality, basePath);
+  let srcset;
+  if (sizes) {
+    const allSizes = getAllSizes(config);
+    srcset = allSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality, basePath)} ${sizeWidth}w`).join(", ");
+  } else if (width) {
+    const allSizes = getAllSizes(config);
+    const w1x = snapUp(width, allSizes);
+    const w2x = snapUp(width * 2, allSizes);
+    srcset = `${buildOptimizedUrl(src, w1x, quality, basePath)} 1x, ${buildOptimizedUrl(src, w2x, quality, basePath)} 2x`;
+  } else {
+    const deviceSizes = config?.deviceSizes ?? [640, 750, 828, 1080, 1200, 1920, 2048, 3840];
+    srcset = deviceSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality, basePath)} ${sizeWidth}w`).join(", ");
+  }
+  let cleanAttrs = removeAttr(attrs, "data-optimized");
+  cleanAttrs = removeAttr(cleanAttrs, "src");
+  cleanAttrs = removeAttr(cleanAttrs, "loading");
+  cleanAttrs = removeAttr(cleanAttrs, "decoding");
+  cleanAttrs = cleanAttrs.trim();
+  const resolvedSizes = sizes ?? (width ? undefined : "100vw");
+  const sizesAttr = resolvedSizes ? ` sizes="${resolvedSizes}"` : "";
+  return `<img src="${optimizedSrc}" srcset="${srcset}"${sizesAttr} ${cleanAttrs} loading="lazy" decoding="async">`;
+}, snapUp = (target, sizes) => {
+  for (const size of sizes) {
+    if (size >= target)
+      return size;
+  }
+  return sizes[sizes.length - 1] ?? target;
+}, optimizeHtmlImages = async (directory, config) => {
+  const htmlFiles = await scanEntryPoints(directory, "*.html");
+  const tasks = htmlFiles.map(async (filePath) => {
+    const original = await readFile(filePath, "utf8");
+    if (!original.includes("data-optimized"))
+      return;
+    const updated = original.replace(IMG_REGEX, (match, before, after) => transformImgTag(match, before, after, config));
+    if (updated !== original) {
+      await writeFile2(filePath, updated, "utf8");
+    }
+  });
+  await Promise.all(tasks);
+};
+var init_optimizeHtmlImages = __esm(() => {
+  init_imageProcessing();
+  init_scanEntryPoints();
+  IMG_REGEX = /<img\s+([^>]*?)data-optimized([^>]*?)\/?>/gi;
+});
+
+// src/cli/scripts/telemetry.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
-    if (!existsSync4(configPath))
+    if (!existsSync5(configPath))
       return null;
-    const raw = readFileSync(configPath, "utf-8");
+    const raw = readFileSync2(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config;
   } catch {
@@ -869,19 +1117,19 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join2(homedir(), ".absolutejs");
-  configPath = join2(configDir, "telemetry.json");
+  configDir = join3(homedir(), ".absolutejs");
+  configPath = join3(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 import { arch, platform } from "os";
-import { dirname, join as join3, parse } from "path";
+import { dirname, join as join4, parse } from "path";
 var checkCandidate = (candidate) => {
-  if (!existsSync5(candidate)) {
+  if (!existsSync6(candidate)) {
     return null;
   }
-  const pkg = JSON.parse(readFileSync2(candidate, "utf-8"));
+  const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
   if (pkg.name === "@absolutejs/absolute") {
     const ver = pkg.version;
     return ver;
@@ -896,7 +1144,7 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join3(dir, "package.json");
+    const candidate = join4(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
@@ -939,7 +1187,7 @@ var exports_updateAssetPaths = {};
 __export(exports_updateAssetPaths, {
   updateAssetPaths: () => updateAssetPaths
 });
-import { readFile, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
 var replaceAssetRef = (match, prefix, dir, name, ext, suffix, manifest, filePath) => {
   const pascal = toPascal(name);
   let key;
@@ -971,9 +1219,9 @@ var replaceAssetRef = (match, prefix, dir, name, ext, suffix, manifest, filePath
   const htmlFiles = await scanEntryPoints(directory, "*.html");
   const assetRegex = /((?:<script[^>]+src=|<link[^>]*?rel=["']stylesheet["'][^>]*?href=)["'])(?!\/?(?:.*\/)?htmx\.min\.js)(\/?(?:.*\/)?)([^./"']+)(?:\.[^."'/]+)?(\.(?:js|ts|css))(["'][^>]*>)/g;
   const tasks = htmlFiles.map(async (filePath) => {
-    const original = await readFile(filePath, "utf8");
+    const original = await readFile2(filePath, "utf8");
     const updated = original.replace(assetRegex, (match, prefix, dir, name, ext, suffix) => replaceAssetRef(match, prefix, dir, name, ext, suffix, manifest, filePath));
-    await writeFile2(filePath, updated, "utf8");
+    await writeFile3(filePath, updated, "utf8");
   });
   await Promise.all(tasks);
 };
@@ -983,12 +1231,12 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve3 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const fromSource = resolve3(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync6(fromSource))
+  if (existsSync7(fromSource))
     return fromSource;
   return resolve3(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
@@ -1180,8 +1428,8 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 };
 
 // src/build/angularLinkerPlugin.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve5 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join5, relative as relative2, resolve as resolve5 } from "path";
 import { createHash } from "crypto";
 var CACHE_DIR, angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
@@ -1204,10 +1452,10 @@ var init_angularLinkerPlugin = __esm(() => {
           return;
         }
         const hash = createHash("md5").update(source).digest("hex");
-        const cachePath = join4(CACHE_DIR, `${hash}.js`);
-        if (existsSync7(cachePath)) {
+        const cachePath = join5(CACHE_DIR, `${hash}.js`);
+        if (existsSync8(cachePath)) {
           return {
-            contents: readFileSync3(cachePath, "utf-8"),
+            contents: readFileSync4(cachePath, "utf-8"),
             loader: "js"
           };
         }
@@ -1222,8 +1470,8 @@ var init_angularLinkerPlugin = __esm(() => {
           linkerPlugin = mod.createEs2015LinkerPlugin({
             fileSystem: {
               dirname: dirname2,
-              exists: existsSync7,
-              readFile: readFileSync3,
+              exists: existsSync8,
+              readFile: readFileSync4,
               relative: relative2,
               resolve: resolve5
             },
@@ -1249,8 +1497,8 @@ var init_angularLinkerPlugin = __esm(() => {
           sourceMaps: false
         });
         const linked = result?.code ?? source;
-        mkdirSync3(CACHE_DIR, { recursive: true });
-        writeFileSync2(cachePath, linked, "utf-8");
+        mkdirSync4(CACHE_DIR, { recursive: true });
+        writeFileSync3(cachePath, linked, "utf-8");
         return { contents: linked, loader: "js" };
       });
     }
@@ -1281,7 +1529,7 @@ var init_cleanStaleOutputs = __esm(() => {
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var cleanup = async ({
   angularDir,
   reactDir,
@@ -1289,19 +1537,19 @@ var cleanup = async ({
   vueDir
 }) => {
   await Promise.all([
-    angularDir ? rm3(join5(angularDir, "generated"), {
+    angularDir ? rm3(join6(angularDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    reactDir ? rm3(join5(reactDir, "generated"), {
+    reactDir ? rm3(join6(reactDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    svelteDir ? rm3(join5(svelteDir, "generated"), {
+    svelteDir ? rm3(join6(svelteDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    vueDir ? rm3(join5(vueDir, "generated"), {
+    vueDir ? rm3(join6(vueDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined
@@ -1345,11 +1593,11 @@ __export(exports_compileSvelte, {
   compileSvelte: () => compileSvelte,
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir, stat } from "fs/promises";
 import {
   dirname as dirname3,
-  join as join6,
+  join as join7,
   basename as basename2,
   extname as extname2,
   resolve as resolve8,
@@ -1360,7 +1608,7 @@ import { env } from "process";
 var {write, file: file2, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const fromSource = resolve8(import.meta.dir, "../dev/client");
-  if (existsSync8(fromSource))
+  if (existsSync9(fromSource))
     return fromSource;
   return resolve8(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
@@ -1396,10 +1644,10 @@ var resolveDevClientDir2 = () => {
   return null;
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
-  const generatedDir = join6(svelteRoot, "generated");
-  const clientDir = join6(generatedDir, "client");
-  const indexDir = join6(generatedDir, "indexes");
-  const serverDir = join6(generatedDir, "server");
+  const generatedDir = join7(svelteRoot, "generated");
+  const clientDir = join7(generatedDir, "client");
+  const indexDir = join7(generatedDir, "indexes");
+  const serverDir = join7(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build2 = async (src) => {
@@ -1440,8 +1688,8 @@ var resolveDevClientDir2 = () => {
       if (!rawSpec)
         continue;
       const origSpec = rawSpec.replace(/\.svelte(?:\.(?:ts|js))?$/, ".js");
-      const ssrOutputDir = dirname3(join6(serverDir, relDir, `${baseName}.js`));
-      const clientOutputDir = dirname3(join6(clientDir, relDir, `${baseName}.js`));
+      const ssrOutputDir = dirname3(join7(serverDir, relDir, `${baseName}.js`));
+      const clientOutputDir = dirname3(join7(clientDir, relDir, `${baseName}.js`));
       const toServer = relative4(ssrOutputDir, childBuilt.ssr).replace(/\\/g, "/");
       const toClient = relative4(clientOutputDir, childBuilt.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
@@ -1485,8 +1733,8 @@ var resolveDevClientDir2 = () => {
         return `${prefix}${dots}`;
       return `${prefix}../../${dots}`;
     });
-    const ssrPath = join6(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join6(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join7(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join7(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
       mkdir(dirname3(ssrPath), { recursive: true }),
       mkdir(dirname3(clientPath), { recursive: true })
@@ -1514,7 +1762,7 @@ var resolveDevClientDir2 = () => {
   await Promise.all(roots.map(async ({ client: client2 }) => {
     const relClientDir = dirname3(relative4(clientDir, client2));
     const name = basename2(client2, extname2(client2));
-    const indexPath = join6(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join7(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative4(dirname3(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -1559,7 +1807,7 @@ if (typeof window !== "undefined") {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
       const rel = dirname3(relative4(clientDir, client2));
-      return join6(indexDir, rel, basename2(client2));
+      return join7(indexDir, rel, basename2(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -1567,7 +1815,7 @@ if (typeof window !== "undefined") {
 var init_compileSvelte = __esm(() => {
   init_constants();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join6(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join7(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler = new Transpiler({ loader: "ts", target: "browser" });
@@ -1582,13 +1830,13 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename3, dirname as dirname4, join as join7, relative as relative5, resolve as resolve9 } from "path";
+import { basename as basename3, dirname as dirname4, join as join8, relative as relative5, resolve as resolve9 } from "path";
 var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const fromSource = resolve9(import.meta.dir, "../dev/client");
-  if (existsSync9(fromSource))
+  if (existsSync10(fromSource))
     return fromSource;
   return resolve9(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
@@ -1712,7 +1960,7 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join7(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    const cssOutputFile = join8(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
     await mkdir2(dirname4(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
@@ -1743,8 +1991,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true);
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false);
-  const clientOutputPath = join7(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join7(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join8(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join8(outputDirs.server, `${relativeWithoutExtension}.js`);
   const relDir = dirname4(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_, prefix, dots) => {
@@ -1773,11 +2021,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev = false) => {
   const compiler = await import("@vue/compiler-sfc");
-  const generatedDir = join7(vueRootDir, "generated");
-  const clientOutputDir = join7(generatedDir, "client");
-  const indexOutputDir = join7(generatedDir, "indexes");
-  const serverOutputDir = join7(generatedDir, "server");
-  const cssOutputDir = join7(generatedDir, "compiled");
+  const generatedDir = join8(vueRootDir, "generated");
+  const clientOutputDir = join8(generatedDir, "client");
+  const indexOutputDir = join8(generatedDir, "indexes");
+  const serverOutputDir = join8(generatedDir, "server");
+  const cssOutputDir = join8(generatedDir, "compiled");
   await Promise.all([
     mkdir2(clientOutputDir, { recursive: true }),
     mkdir2(indexOutputDir, { recursive: true }),
@@ -1794,8 +2042,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }, buildCache, true, vueRootDir, compiler);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename3(entryPath, ".vue");
-    const indexOutputFile = join7(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join7(clientOutputDir, relative5(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join8(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join8(clientOutputDir, relative5(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir2(dirname4(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -1905,8 +2153,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler2.transformSync(sourceCode);
     const relativeJsPath = relative5(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join7(clientOutputDir, relativeJsPath);
-    const outServerPath = join7(serverOutputDir, relativeJsPath);
+    const outClientPath = join8(clientOutputDir, relativeJsPath);
+    const outServerPath = join8(serverOutputDir, relativeJsPath);
     await mkdir2(dirname4(outClientPath), { recursive: true });
     await mkdir2(dirname4(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
@@ -1923,7 +2171,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 var init_compileVue = __esm(() => {
   init_constants();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join7(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join8(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -4213,7 +4461,7 @@ var require_typescript = __commonJS((exports, module) => {
       walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
       whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
       writeCommentRange: () => writeCommentRange,
-      writeFile: () => writeFile3,
+      writeFile: () => writeFile4,
       writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
       zipWith: () => zipWith
     });
@@ -10005,7 +10253,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile2,
+          readFile: readFile3,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -10198,7 +10446,7 @@ ${lanes.join(`
         function fsWatchWorker(fileOrDirectory, recursive, callback) {
           return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
         }
-        function readFile2(fileName, _encoding) {
+        function readFile3(fileName, _encoding) {
           let buffer;
           try {
             buffer = _fs.readFileSync(fileName);
@@ -21522,7 +21770,7 @@ ${lanes.join(`
       sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath;
       return combinePaths(newDirPath, sourceFilePath);
     }
-    function writeFile3(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) {
+    function writeFile4(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) {
       host.writeFile(fileName, text, writeByteOrderMark, (hostErrorMessage) => {
         diagnostics.add(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
       }, sourceFiles, data);
@@ -41145,7 +41393,7 @@ ${lanes.join(`
       const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
       return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
     }
-    function parseCommandLineWorker(diagnostics, commandLine, readFile2) {
+    function parseCommandLineWorker(diagnostics, commandLine, readFile3) {
       const options = {};
       let watchOptions;
       const fileNames = [];
@@ -41183,7 +41431,7 @@ ${lanes.join(`
         }
       }
       function parseResponseFile(fileName) {
-        const text = tryReadFile(fileName, readFile2 || ((fileName2) => sys.readFile(fileName2)));
+        const text = tryReadFile(fileName, readFile3 || ((fileName2) => sys.readFile(fileName2)));
         if (!isString(text)) {
           errors.push(text);
           return;
@@ -41286,8 +41534,8 @@ ${lanes.join(`
       unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
       optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
     };
-    function parseCommandLine(commandLine, readFile2) {
-      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile2);
+    function parseCommandLine(commandLine, readFile3) {
+      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile3);
     }
     function getOptionFromName(optionName, allowShort) {
       return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -41355,8 +41603,8 @@ ${lanes.join(`
       result.originalFileName = result.fileName;
       return parseJsonSourceFileConfigFileContent(result, host, getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd), optionsToExtend, getNormalizedAbsolutePath(configFileName, cwd), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
     }
-    function readConfigFile(fileName, readFile2) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile2);
+    function readConfigFile(fileName, readFile3) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile3);
       return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
     function parseConfigFileTextToJson(fileName, jsonText) {
@@ -41366,14 +41614,14 @@ ${lanes.join(`
         error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
       };
     }
-    function readJsonConfigFile(fileName, readFile2) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile2);
+    function readJsonConfigFile(fileName, readFile3) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile3);
       return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
     }
-    function tryReadFile(fileName, readFile2) {
+    function tryReadFile(fileName, readFile3) {
       let text;
       try {
-        text = readFile2(fileName);
+        text = readFile3(fileName);
       } catch (e) {
         return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
       }
@@ -104115,7 +104363,7 @@ ${lanes.join(`
           return;
         }
         const buildInfo = host.getBuildInfo() || { version };
-        writeFile3(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), false, undefined, { buildInfo });
+        writeFile4(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), false, undefined, { buildInfo });
         emittedFilesList == null || emittedFilesList.push(buildInfoPath);
       }
       function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath) {
@@ -104274,14 +104522,14 @@ ${lanes.join(`
           }
           if (sourceMapFilePath) {
             const sourceMap = sourceMapGenerator.toString();
-            writeFile3(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
+            writeFile4(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
           }
         } else {
           writer.writeLine();
         }
         const text = writer.getText();
         const data = { sourceMapUrlPos, diagnostics: transform2.diagnostics };
-        writeFile3(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, data);
+        writeFile4(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, data);
         writer.clear();
         return !data.skippedDtsWrite;
       }
@@ -108803,12 +109051,12 @@ ${lanes.join(`
     function createCompilerHost(options, setParentNodes) {
       return createCompilerHostWorker(options, setParentNodes);
     }
-    function createGetSourceFile(readFile2, setParentNodes) {
+    function createGetSourceFile(readFile3, setParentNodes) {
       return (fileName, languageVersionOrOptions, onError) => {
         let text;
         try {
           mark("beforeIORead");
-          text = readFile2(fileName);
+          text = readFile3(fileName);
           mark("afterIORead");
           measure("I/O Read", "beforeIORead", "afterIORead");
         } catch (e) {
@@ -109599,7 +109847,7 @@ ${lanes.join(`
         getRedirectFromOutput,
         forEachResolvedProjectReference: forEachResolvedProjectReference2
       });
-      const readFile2 = host.readFile.bind(host);
+      const readFile3 = host.readFile.bind(host);
       (_e = tracing) == null || _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
       const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
       (_f = tracing) == null || _f.pop();
@@ -109775,7 +110023,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile2,
+        readFile: readFile3,
         directoryExists,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -160213,7 +160461,7 @@ ${options.prefix}` : `
       walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
       whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
       writeCommentRange: () => writeCommentRange,
-      writeFile: () => writeFile3,
+      writeFile: () => writeFile4,
       writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
       zipWith: () => zipWith
     });
@@ -170662,19 +170910,19 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync10, readFileSync as readFileSync4, promises as fs } from "fs";
-import { join as join8, basename as basename4, sep as sep3, dirname as dirname5, resolve as resolve10, relative as relative6 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync5, promises as fs } from "fs";
+import { join as join9, basename as basename4, sep as sep3, dirname as dirname5, resolve as resolve10, relative as relative6 } from "path";
 import { createHash as createHash2 } from "crypto";
 var import_typescript, computeConfigHash = () => {
   try {
-    const content = readFileSync4("./tsconfig.json", "utf-8");
+    const content = readFileSync5("./tsconfig.json", "utf-8");
     return createHash2("md5").update(content).digest("hex");
   } catch {
     return "";
   }
 }, resolveDevClientDir4 = () => {
   const fromSource = resolve10(import.meta.dir, "../dev/client");
-  if (existsSync10(fromSource))
+  if (existsSync11(fromSource))
     return fromSource;
   return resolve10(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
@@ -170770,7 +171018,7 @@ ${registrations}
     const originalGetSourceFile = host.getSourceFile;
     host.getSourceFile = (fileName, languageVersion, onError) => {
       if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-        const resolvedPath = join8(tsLibDir, fileName);
+        const resolvedPath = join9(tsLibDir, fileName);
         return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
       }
       return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -170797,7 +171045,7 @@ ${registrations}
   });
   throwOnCompilationErrors(diagnostics);
   const entries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => {
-    const target = join8(outDir, fileName);
+    const target = join9(outDir, fileName);
     let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
       if (!path.match(/\.(js|ts|mjs|cjs)$/)) {
         return `from ${quote}${path}.js${quote}`;
@@ -170816,7 +171064,7 @@ ${registrations}
   await Promise.all(entries.map(({ target, content }) => fs.writeFile(target, content, "utf-8")));
   return entries.map(({ target }) => target);
 }, jitContentCache, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), readAndEscapeFile = async (filePath) => {
-  if (!existsSync10(filePath))
+  if (!existsSync11(filePath))
     return null;
   const content = await fs.readFile(filePath, "utf-8");
   return escapeTemplateContent(content);
@@ -170824,7 +171072,7 @@ ${registrations}
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!templateUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join8(fileDir, templateUrlMatch[1]));
+  const escaped = await readAndEscapeFile(join9(fileDir, templateUrlMatch[1]));
   if (!escaped)
     return source;
   return source.replace(/templateUrl\s*:\s*['"][^'"]+['"]/, `template: \`${escaped}\``);
@@ -170837,7 +171085,7 @@ ${registrations}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join8(fileDir, styleUrl));
+    return readAndEscapeFile(join9(fileDir, styleUrl));
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -170848,7 +171096,7 @@ ${registrations}
   const styleUrlMatch = source.match(/styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join8(fileDir, styleUrlMatch[1]));
+  const escaped = await readAndEscapeFile(join9(fileDir, styleUrlMatch[1]));
   if (!escaped)
     return source;
   return source.replace(/styleUrl\s*:\s*['"][^'"]+['"]/, `styles: [\`${escaped}\`]`);
@@ -170878,15 +171126,15 @@ ${registrations}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync10(actualPath))
+    if (!existsSync11(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
     sourceCode = await inlineResources(sourceCode, dirname5(actualPath));
     const inputDir = dirname5(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename4(actualPath).replace(/\.ts$/, ".js");
-    const targetDir = join8(outDir, relativeDir);
-    const targetPath = join8(targetDir, fileBase);
+    const targetDir = join9(outDir, relativeDir);
+    const targetPath = join9(targetDir, fileBase);
     const importRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
     const localImports = [];
     let importMatch;
@@ -170896,7 +171144,7 @@ ${registrations}
     }
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    if (jitContentCache.get(cacheKey2) === contentHash && existsSync10(targetPath)) {
+    if (jitContentCache.get(cacheKey2) === contentHash && existsSync11(targetPath)) {
       allOutputs.push(targetPath);
     } else {
       let processedContent = angularTranspiler.transformSync(sourceCode);
@@ -170930,13 +171178,13 @@ ${registrations}
   await transpileFile(inputPath);
   return allOutputs;
 }, compileAngular = async (entryPoints, outRoot, hmr = false) => {
-  const compiledParent = join8(outRoot, "generated");
+  const compiledParent = join9(outRoot, "generated");
   if (entryPoints.length === 0) {
     const emptyPaths = [];
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join8(compiledParent, "indexes");
+  const indexesDir = join9(compiledParent, "indexes");
   await fs.mkdir(indexesDir, { recursive: true });
   const compileTasks = entryPoints.map(async (entry) => {
     const outputs = hmr ? await compileAngularFileJIT(entry, compiledRoot, outRoot) : await compileAngularFile(entry, compiledRoot);
@@ -170953,8 +171201,8 @@ ${registrations}
     const componentClassName = `${toPascal(fileBase)}Component`;
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(entry);
-    const clientFile = join8(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync10(clientFile)) {
+    const clientFile = join9(indexesDir, jsName);
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync11(clientFile)) {
       return { clientPath: clientFile, indexUnchanged: true, serverPath: rawServerFile };
     }
     let rewritten = original.replace(new RegExp(`templateUrl:\\s*['"]\\.\\/${fileBase}\\.html['"]`), `templateUrl: '../../pages/${fileBase}.html'`);
@@ -171048,8 +171296,8 @@ var init_compileAngular = __esm(() => {
   init_constants();
   import_typescript = __toESM(require_typescript(), 1);
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join8(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join8(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join9(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrRuntimePath = join9(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -171060,8 +171308,8 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { mkdirSync as mkdirSync4 } from "fs";
-import { join as join9 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { join as join10 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
 var reactSpecifiers, isResolvable = (specifier) => {
@@ -171096,14 +171344,14 @@ var reactSpecifiers, isResolvable = (specifier) => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join9(buildDir, "react", "vendor");
-  mkdirSync4(vendorDir, { recursive: true });
-  const tmpDir = join9(buildDir, "_vendor_tmp");
-  mkdirSync4(tmpDir, { recursive: true });
+  const vendorDir = join10(buildDir, "react", "vendor");
+  mkdirSync5(vendorDir, { recursive: true });
+  const tmpDir = join10(buildDir, "_vendor_tmp");
+  mkdirSync5(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join9(tmpDir, `${safeName}.ts`);
+    const entryPath = join10(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -171139,18 +171387,18 @@ __export(exports_buildAngularVendor, {
   computeAngularVendorPaths: () => computeAngularVendorPaths,
   buildAngularVendor: () => buildAngularVendor
 });
-import { mkdirSync as mkdirSync5 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var angularSpecifiers, toSafeFileName2 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), buildAngularVendor = async (buildDir) => {
-  const vendorDir = join10(buildDir, "angular", "vendor");
-  mkdirSync5(vendorDir, { recursive: true });
-  const tmpDir = join10(buildDir, "_angular_vendor_tmp");
-  mkdirSync5(tmpDir, { recursive: true });
+  const vendorDir = join11(buildDir, "angular", "vendor");
+  mkdirSync6(vendorDir, { recursive: true });
+  const tmpDir = join11(buildDir, "_angular_vendor_tmp");
+  mkdirSync6(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(angularSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join10(tmpDir, `${safeName}.ts`);
+    const entryPath = join11(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -171192,18 +171440,18 @@ __export(exports_buildVueVendor, {
   computeVueVendorPaths: () => computeVueVendorPaths,
   buildVueVendor: () => buildVueVendor
 });
-import { mkdirSync as mkdirSync6 } from "fs";
-import { join as join11 } from "path";
+import { mkdirSync as mkdirSync7 } from "fs";
+import { join as join12 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join11(buildDir, "vue", "vendor");
-  mkdirSync6(vendorDir, { recursive: true });
-  const tmpDir = join11(buildDir, "_vue_vendor_tmp");
-  mkdirSync6(tmpDir, { recursive: true });
+  const vendorDir = join12(buildDir, "vue", "vendor");
+  mkdirSync7(vendorDir, { recursive: true });
+  const tmpDir = join12(buildDir, "_vue_vendor_tmp");
+  mkdirSync7(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join11(tmpDir, `${safeName}.ts`);
+    const entryPath = join12(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -171228,17 +171476,17 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync5, writeFileSync: writeFileSync3, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync6, writeFileSync: writeFileSync4, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join11(vendorDir, file4);
-    const content = readFileSync5(filePath, "utf-8");
+    const filePath = join12(vendorDir, file4);
+    const content = readFileSync6(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
     if (patched === content)
       continue;
-    writeFileSync3(filePath, patched);
+    writeFileSync4(filePath, patched);
   }
 }, computeVueVendorPaths = () => {
   const paths = {};
@@ -171257,8 +171505,8 @@ __export(exports_buildSvelteVendor, {
   computeSvelteVendorPaths: () => computeSvelteVendorPaths,
   buildSvelteVendor: () => buildSvelteVendor
 });
-import { mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync8 } from "fs";
+import { join as join13 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
@@ -171272,13 +171520,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join12(buildDir, "svelte", "vendor");
-  mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join12(buildDir, "_svelte_vendor_tmp");
-  mkdirSync7(tmpDir, { recursive: true });
+  const vendorDir = join13(buildDir, "svelte", "vendor");
+  mkdirSync8(vendorDir, { recursive: true });
+  const tmpDir = join13(buildDir, "_svelte_vendor_tmp");
+  mkdirSync8(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join12(tmpDir, `${safeName}.ts`);
+    const entryPath = join13(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -171353,14 +171601,14 @@ var init_rewriteImports = __esm(() => {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync5,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync6,
   rmSync,
   statSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename5, join as join13, relative as relative7, resolve as resolve11 } from "path";
+import { basename as basename5, join as join14, relative as relative7, resolve as resolve11 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild6, Glob: Glob5 } = globalThis.Bun;
 var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental, throwOnError) => {
@@ -171382,11 +171630,11 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
     throw err;
   exit(1);
 }, copyHtmxVendor = (htmxDir, htmxDestDir) => {
-  mkdirSync8(htmxDestDir, { recursive: true });
+  mkdirSync9(htmxDestDir, { recursive: true });
   const glob = new Glob5("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join13(htmxDir, relPath);
-    const dest = join13(htmxDestDir, "htmx.min.js");
+    const src = join14(htmxDir, relPath);
+    const dest = join14(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -171426,7 +171674,7 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync5(file4, "utf-8");
+  const content = readFileSync6(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -171459,8 +171707,8 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join13(buildPath, "_src_indexes");
-  mkdirSync8(devIndexDir, { recursive: true });
+  const devIndexDir = join14(buildPath, "_src_indexes");
+  mkdirSync9(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
   }
@@ -171474,35 +171722,35 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative7(process.cwd(), resolve11(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync5(join13(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync6(join14(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync3(join13(devIndexDir, file4), content);
+    writeFileSync4(join14(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join13(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join14(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve11(file4).startsWith(resolve11(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename5(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join13(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync11(indexFile))
+    const indexFile = join14(svelteIndexDir, "pages", `${name}.js`);
+    if (!existsSync12(indexFile))
       continue;
-    let content = readFileSync5(indexFile, "utf-8");
+    let content = readFileSync6(indexFile, "utf-8");
     const srcRel = relative7(process.cwd(), resolve11(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync3(join13(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync4(join14(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join13(vueDir, "generated", "indexes");
+  const vueIndexDir = join14(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve11(file4).startsWith(resolve11(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename5(entry, ".vue");
-    const indexFile = join13(vueIndexDir, `${name}.js`);
-    if (!existsSync11(indexFile))
+    const indexFile = join14(vueIndexDir, `${name}.js`);
+    if (!existsSync12(indexFile))
       continue;
-    let content = readFileSync5(indexFile, "utf-8");
+    let content = readFileSync6(indexFile, "utf-8");
     const srcRel = relative7(process.cwd(), resolve11(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
-    writeFileSync3(join13(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync4(join14(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -171550,7 +171798,7 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync5(outputPath, "utf-8");
+  let content = readFileSync6(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -171571,7 +171819,7 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
   content = `${content.slice(0, firstUseIdx) + runtime}
 ${content.slice(firstUseIdx)}`;
   content = wrapUseFunctions(content, useNames);
-  writeFileSync3(outputPath, content);
+  writeFileSync4(outputPath, content);
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
@@ -171600,7 +171848,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync5(outputPath, "utf-8");
+    let content = readFileSync6(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename5(relPath);
@@ -171611,7 +171859,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync3(outputPath, content);
+      writeFileSync4(outputPath, content);
   }
 }, vueFeatureFlags, build2 = async ({
   buildDirectory = "build",
@@ -171647,14 +171895,14 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join13(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join13(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join13(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join13(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join13(svelteDir, "pages");
-  const vuePagesPath = vueDir && join13(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join13(htmxDir, "pages");
-  const angularPagesPath = angularDir && join13(angularDir, "pages");
+  const reactIndexesPath = reactDir && join14(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join14(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join14(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join14(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join14(svelteDir, "pages");
+  const vuePagesPath = vueDir && join14(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join14(htmxDir, "pages");
+  const angularPagesPath = angularDir && join14(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -171690,12 +171938,12 @@ ${content.slice(firstUseIdx)}`;
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join13("generated", "server")
+      subdir: join14("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join13("generated", "server")
+      subdir: join14("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -171705,14 +171953,14 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join13(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join13(buildPath, basename5(firstEntry.dir));
+    serverRoot = join14(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join14(buildPath, basename5(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
   }
   const publicPath = publicDirectory && validateSafePath(publicDirectory, projectRoot);
-  mkdirSync8(buildPath, { recursive: true });
+  mkdirSync9(buildPath, { recursive: true });
   if (publicPath)
     cpSync(publicPath, buildPath, { force: true, recursive: true });
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
@@ -171734,7 +171982,7 @@ ${content.slice(firstUseIdx)}`;
     await generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr);
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
-    cpSync(assetsPath, join13(buildPath, "assets"), {
+    cpSync(assetsPath, join14(buildPath, "assets"), {
       force: true,
       recursive: true
     });
@@ -171748,7 +171996,7 @@ ${content.slice(firstUseIdx)}`;
     } catch {
       binPath = "tailwindcss";
     }
-    const proc = Bun.spawn(["bun", binPath, "-i", input, "-o", join13(buildPath, output)], { stderr: "pipe", stdout: "pipe" });
+    const proc = Bun.spawn(["bun", binPath, "-i", input, "-o", join14(buildPath, output)], { stderr: "pipe", stdout: "pipe" });
     await proc.exited;
   };
   const tailwindPromise = tailwind && (!isIncremental || normalizedIncrementalFiles?.some((file4) => file4.endsWith(".css"))) ? compileTailwind(tailwind.input, tailwind.output) : undefined;
@@ -171773,7 +172021,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve11(reactIndexesPath))) {
       const pageName = basename5(entry, ".tsx");
-      return join13(reactPagesPath, `${pageName}.tsx`);
+      return join14(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -171864,7 +172112,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join13(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join14(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -171907,13 +172155,13 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   } : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync(join13(buildPath, "react", "indexes"), {
+    rmSync(join14(buildPath, "react", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync(join13(buildPath, "angular", "indexes"), {
+    rmSync(join14(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
@@ -171975,7 +172223,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? bunBuild6({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join13(buildPath, basename5(stylesDir)) : buildPath,
+      outdir: stylesDir ? join14(buildPath, basename5(stylesDir)) : buildPath,
       root: stylesDir || clientRoot,
       target: "browser",
       throw: false
@@ -171983,7 +172231,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? bunBuild6({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join13(buildPath, assetsPath ? basename5(assetsPath) : "assets", "css"),
+      outdir: join14(buildPath, assetsPath ? basename5(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }) : undefined
@@ -172078,20 +172326,20 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync5(filePath, "utf-8");
+    let html = readFileSync6(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
     const bodyClose = /<\/body\s*>/i.exec(html);
     html = bodyClose ? html.slice(0, bodyClose.index) + tag + html.slice(bodyClose.index) : html + tag;
-    writeFileSync3(filePath, html);
+    writeFileSync4(filePath, html);
   };
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join13(buildPath, "pages") : join13(buildPath, basename5(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join14(buildPath, "pages") : join14(buildPath, basename5(htmlDir), "pages");
     if (shouldCopyHtml) {
-      mkdirSync8(outputHtmlPages, { recursive: true });
+      mkdirSync9(outputHtmlPages, { recursive: true });
       cpSync(htmlPagesPath, outputHtmlPages, {
         force: true,
         recursive: true
@@ -172099,6 +172347,7 @@ ${content.slice(firstUseIdx)}`;
     }
     if (shouldUpdateHtmlAssetPaths) {
       await updateAssetPaths(manifest, outputHtmlPages);
+      await optimizeHtmlImages(outputHtmlPages);
     }
     const htmlPageFiles = await scanEntryPoints(outputHtmlPages, "*.html");
     for (const htmlFile of htmlPageFiles) {
@@ -172111,20 +172360,21 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join13(buildPath, "pages") : join13(buildPath, basename5(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join14(buildPath, "pages") : join14(buildPath, basename5(htmxDir), "pages");
     if (shouldCopyHtmx) {
-      mkdirSync8(outputHtmxPages, { recursive: true });
+      mkdirSync9(outputHtmxPages, { recursive: true });
       cpSync(htmxPagesPath, outputHtmxPages, {
         force: true,
         recursive: true
       });
     }
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join13(buildPath, basename5(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join14(buildPath, basename5(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
       await updateAssetPaths(manifest, outputHtmxPages);
+      await optimizeHtmlImages(outputHtmxPages);
     }
     const htmxPageFiles = await scanEntryPoints(outputHtmxPages, "*.html");
     for (const htmxFile of htmxPageFiles) {
@@ -172171,7 +172421,7 @@ ${content.slice(firstUseIdx)}`;
     mode: mode ?? (isDev ? "development" : "production")
   });
   if (!isIncremental) {
-    writeFileSync3(join13(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+    writeFileSync4(join14(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   }
   return manifest;
 };
@@ -172183,6 +172433,7 @@ var init_build = __esm(() => {
   init_outputLogs();
   init_scanEntryPoints();
   init_scanCssEntryPoints();
+  init_optimizeHtmlImages();
   init_updateAssetPaths();
   init_buildHMRClient();
   init_rewriteReactImports();
@@ -172230,7 +172481,7 @@ var init_build = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
 var {Glob: Glob6 } = globalThis.Bun;
 import { resolve as resolve12 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -172260,10 +172511,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   ];
   for (const ext of extensions) {
     const withExt = normalized + ext;
-    if (existsSync12(withExt))
+    if (existsSync13(withExt))
       return withExt;
   }
-  if (existsSync12(normalized))
+  if (existsSync13(normalized))
     return normalized;
   return null;
 }, clearExistingDependents = (graph, normalizedPath) => {
@@ -172278,7 +172529,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
 }, addFileToGraph = (graph, filePath) => {
   const normalizedPath = resolve12(filePath);
-  if (!existsSync12(normalizedPath))
+  if (!existsSync13(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -172294,7 +172545,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob6("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve12(dir)).filter((dir) => existsSync12(dir));
+  const resolvedDirs = directories.map((dir) => resolve12(dir)).filter((dir) => existsSync13(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
     const fullPath = resolve12(file4);
@@ -172391,15 +172642,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -172685,8 +172936,8 @@ var init_pathUtils = __esm(() => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync13 } from "fs";
-import { join as join14, resolve as resolve14 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15, resolve as resolve14 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -172713,16 +172964,16 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join14(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join15(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync13(fullPath)) {
+    if (event === "rename" && !existsSync14(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync13(fullPath)) {
+    if (existsSync14(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -172732,7 +172983,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
     const absolutePath = resolve14(path).replace(/\\/g, "/");
-    if (!existsSync13(absolutePath)) {
+    if (!existsSync14(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -172743,7 +172994,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
     const absolutePath = resolve14(path).replace(/\\/g, "/");
-    if (!existsSync13(absolutePath)) {
+    if (!existsSync14(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -172864,10 +173115,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync7(filePath);
+    const fileContent = readFileSync8(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -173175,8 +173426,8 @@ var init_registerClientScript = __esm(() => {
 });
 
 // src/angular/injectorPatch.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname6, join as join15 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
 var applyInjectorPatch = (chunkPath, content) => {
   if (content.includes('Symbol.for("angular.currentInjector")')) {
     return;
@@ -173210,12 +173461,12 @@ var applyInjectorPatch = (chunkPath, content) => {
   if (patched === content) {
     return;
   }
-  writeFileSync4(chunkPath, patched, "utf-8");
+  writeFileSync5(chunkPath, patched, "utf-8");
 }, patchAngularInjectorSingleton = () => {
   try {
     const coreDir = dirname6(__require.resolve("@angular/core/package.json"));
-    const chunkPath = join15(coreDir, "fesm2022", "_not_found-chunk.mjs");
-    const content = readFileSync8(chunkPath, "utf-8");
+    const chunkPath = join16(coreDir, "fesm2022", "_not_found-chunk.mjs");
+    const content = readFileSync9(chunkPath, "utf-8");
     applyInjectorPatch(chunkPath, content);
   } catch {}
 };
@@ -202959,7 +203210,7 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync14, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
 import { basename as basename7, dirname as dirname7, extname as extname3, resolve as resolve18, relative as relative8 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
@@ -202980,7 +203231,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync14(resolve18(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync15(resolve18(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b]) => b.length - a.length);
@@ -203082,7 +203333,7 @@ ${stubs}
 `)}
 ${code}`;
 }, reactTranspilerOptions, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync9(filePath, "utf-8");
+  const raw = readFileSync10(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -203097,7 +203348,7 @@ ${transpiled}`;
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync9(filePath, "utf-8");
+  const raw = readFileSync10(filePath, "utf-8");
   const ext = extname3(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -203250,7 +203501,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync9(filePath, "utf-8");
+  const raw = readFileSync10(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -203304,7 +203555,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync9(filePath, "utf-8");
+  const raw = readFileSync10(filePath, "utf-8");
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
@@ -203336,11 +203587,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync14(path))
+  if (existsSync15(path))
     return path;
-  if (existsSync14(`${path}.ts`))
+  if (existsSync15(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync14(`${path}.js`))
+  if (existsSync15(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -203353,7 +203604,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync9(filePath, "utf-8");
+  const raw = readFileSync10(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -203485,7 +203736,7 @@ export default {};
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync14(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync15(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -203679,7 +203930,7 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { rm as rm8 } from "fs/promises";
 import { basename as basename8, relative as relative9, resolve as resolve21 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseErrorLocationFromMessage = (msg) => {
@@ -203749,7 +204000,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync15(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync16(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
@@ -203767,7 +204018,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync15(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync16(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -203783,7 +204034,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync15(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync16(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -203808,7 +204059,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync15(filePathInSet)) {
+    if (!existsSync16(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -203916,7 +204167,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync15(tsCounterpart)) {
+  if (existsSync16(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
@@ -204053,7 +204304,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
 }, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
   const pageName = basename8(normalized, ".tsx");
   const indexPath = resolve21(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync15(indexPath)) {
+  if (!existsSync16(indexPath)) {
     return;
   }
   return indexPath;
@@ -204065,7 +204316,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     }
     const pageName = basename8(dep, ".tsx");
     const indexPath = resolve21(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync15(indexPath) && !reactEntries.includes(indexPath)) {
+    if (existsSync16(indexPath) && !reactEntries.includes(indexPath)) {
       reactEntries.push(indexPath);
     }
   });
@@ -204929,6 +205180,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
   await updateAssetPaths2(state.manifest, outputDir);
+  const { optimizeHtmlImages: optimizeHtmlImages2 } = await Promise.resolve().then(() => (init_optimizeHtmlImages(), exports_optimizeHtmlImages));
+  await optimizeHtmlImages2(outputDir);
   injectHmrScript(destPath, hmrScript, readFs, writeFs);
   const newHTML = await handleUpdate(destPath);
   if (!newHTML)
@@ -205147,8 +205400,8 @@ __export(exports_buildDepVendor, {
   computeDepVendorPaths: () => computeDepVendorPaths,
   buildDepVendor: () => buildDepVendor
 });
-import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join16 } from "path";
+import { mkdirSync as mkdirSync10 } from "fs";
+import { join as join17 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g, "").replace(/-/g, "_"), isResolvable3 = (specifier) => {
@@ -205188,7 +205441,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   return Array.from(specifiers).filter(isResolvable3);
 }, generateEntrySource2 = (specifier) => `export * from '${specifier}';
 `, rewriteVendorFiles = async (vendorDir) => {
-  const { readdirSync: readdirSync2, readFileSync: readFileSync10, writeFileSync: writeFileSync5 } = await import("fs");
+  const { readdirSync: readdirSync2, readFileSync: readFileSync11, writeFileSync: writeFileSync6 } = await import("fs");
   const { computeVendorPaths: computeVendorPaths2 } = await Promise.resolve().then(() => (init_buildReactVendor(), exports_buildReactVendor));
   const reactPaths = Object.entries(computeVendorPaths2());
   const rewriteContent = (content) => reactPaths.reduce((acc, [specifier, webPath]) => {
@@ -205198,23 +205451,23 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   }, content);
   const files = readdirSync2(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join16(vendorDir, file4);
-    const original = readFileSync10(filePath, "utf-8");
+    const filePath = join17(vendorDir, file4);
+    const original = readFileSync11(filePath, "utf-8");
     const rewritten = rewriteContent(original);
     if (rewritten !== original)
-      writeFileSync5(filePath, rewritten);
+      writeFileSync6(filePath, rewritten);
   }
 }, buildDepVendor = async (buildDir, directories) => {
   const specifiers = await scanBareImports(directories);
   if (specifiers.length === 0)
     return {};
-  const vendorDir = join16(buildDir, "vendor");
-  mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join16(buildDir, "_dep_vendor_tmp");
-  mkdirSync9(tmpDir, { recursive: true });
+  const vendorDir = join17(buildDir, "vendor");
+  mkdirSync10(vendorDir, { recursive: true });
+  const tmpDir = join17(buildDir, "_dep_vendor_tmp");
+  mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName5(specifier);
-    const entryPath = join16(tmpDir, `${safeName}.ts`);
+    const entryPath = join17(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource2(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -205663,6 +205916,220 @@ var init_hmr = __esm(() => {
   init_webSocket();
 });
 
+// src/plugins/imageOptimizer.ts
+var exports_imageOptimizer = {};
+__export(exports_imageOptimizer, {
+  imageOptimizer: () => imageOptimizer
+});
+import { existsSync as existsSync17 } from "fs";
+import { resolve as resolve23 } from "path";
+import { Elysia } from "elysia";
+var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
+  try {
+    const resolved = validateSafePath(path, baseDir);
+    if (existsSync17(resolved))
+      return resolved;
+    return null;
+  } catch {
+    return null;
+  }
+}, resolveLocalImage = (url, buildDir) => {
+  const cleanPath = url.startsWith("/") ? url.slice(1) : url;
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve23(process.cwd()));
+}, parseQueryParams = (query, allowedSizes, defaultQuality) => {
+  const url = typeof query["url"] === "string" ? query["url"] : undefined;
+  const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
+  const qParam = typeof query["q"] === "string" ? query["q"] : undefined;
+  if (!url || !wParam) {
+    return {
+      error: new Response("Missing required params: url, w", {
+        status: 400
+      })
+    };
+  }
+  const width = parseInt(wParam, 10);
+  if (isNaN(width) || !allowedSizes.has(width)) {
+    return {
+      error: new Response(`Invalid width: ${wParam}. Must be one of: ${[...allowedSizes].sort((left, right) => left - right).join(", ")}`, { status: 400 })
+    };
+  }
+  const quality = qParam ? parseInt(qParam, 10) : defaultQuality;
+  if (isNaN(quality) || quality < 1 || quality > MAX_QUALITY) {
+    return {
+      error: new Response("Invalid quality: must be 1-100", {
+        status: 400
+      })
+    };
+  }
+  return { params: { quality, url, width } };
+}, validateImageSecurity = (url, remotePatterns, buildDir) => {
+  const isRemote = url.startsWith("http://") || url.startsWith("https://");
+  if (isRemote) {
+    if (remotePatterns.length === 0 || !matchRemotePattern(url, remotePatterns)) {
+      return {
+        error: new Response("Remote image not allowed. Configure remotePatterns in images config.", { status: 400 }),
+        isRemote
+      };
+    }
+    return { isRemote, resolvedPath: null };
+  }
+  const resolvedPath = resolveLocalImage(url, buildDir);
+  if (!resolvedPath) {
+    return {
+      error: new Response(`Image not found: ${url}`, { status: 404 }),
+      isRemote
+    };
+  }
+  return { isRemote, resolvedPath };
+}, fetchSourceImage = async (url, isRemote, resolvedPath) => {
+  if (isRemote) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return {
+        error: new Response(`Failed to fetch remote image: ${response.status}`, { status: 502 })
+      };
+    }
+    return {
+      buffer: Buffer.from(await response.arrayBuffer()),
+      upstreamEtag: response.headers.get("ETag") ?? undefined
+    };
+  }
+  if (!resolvedPath) {
+    return {
+      error: new Response(`Image not found: ${url}`, { status: 404 })
+    };
+  }
+  const file4 = Bun.file(resolvedPath);
+  if (!await file4.exists()) {
+    return {
+      error: new Response(`Image not found: ${url}`, { status: 404 })
+    };
+  }
+  return {
+    buffer: Buffer.from(await file4.arrayBuffer()),
+    upstreamEtag: undefined
+  };
+}, scheduleAvifPregen = (url, width, quality, sourceBuffer, configuredFormats, format, cacheDir, minimumCacheTTL, upstreamEtag) => {
+  if (!configuredFormats.includes("avif") || format === "avif") {
+    return;
+  }
+  const avifKey = `${url}|${width}|${quality}`;
+  if (avifInProgress.has(avifKey))
+    return;
+  const avifCacheKey = getCacheKey(url, width, quality, "avif");
+  const avifCached = readFromCache(cacheDir, avifCacheKey);
+  if (avifCached && !isCacheStale(avifCached.meta))
+    return;
+  avifInProgress.add(avifKey);
+  queueMicrotask(async () => {
+    try {
+      const avifBuffer = await optimizeImage(sourceBuffer, width, quality, "avif");
+      const avifMeta = {
+        contentType: "image/avif",
+        etag: `"${avifCacheKey}"`,
+        expireAt: Date.now() + minimumCacheTTL,
+        upstreamEtag
+      };
+      writeToCache(cacheDir, avifCacheKey, avifBuffer, avifMeta);
+    } catch {} finally {
+      avifInProgress.delete(avifKey);
+    }
+  });
+}, imageOptimizer = (config, buildDir) => (app) => {
+  if (!config && config !== undefined)
+    return app;
+  if (config?.unoptimized)
+    return app;
+  const endpointPath = config?.path ?? OPTIMIZATION_ENDPOINT;
+  const allowedSizes = new Set([
+    ...config?.deviceSizes ?? DEFAULT_DEVICE_SIZES,
+    ...config?.imageSizes ?? DEFAULT_IMAGE_SIZES
+  ]);
+  const defaultQuality = config?.quality ?? DEFAULT_QUALITY;
+  const minimumCacheTTL = (config?.minimumCacheTTL ?? DEFAULT_CACHE_TTL_SECONDS) * MS_PER_SECOND;
+  const configuredFormats = config?.formats ?? ["webp"];
+  const remotePatterns = config?.remotePatterns ?? [];
+  const cacheDir = getCacheDir(buildDir);
+  const plugin = new Elysia({ name: "image-optimizer" }).get(endpointPath, async ({ query, request }) => {
+    const parsed = parseQueryParams(query, allowedSizes, defaultQuality);
+    if ("error" in parsed)
+      return parsed.error;
+    const { quality, url, width } = parsed.params;
+    const security = validateImageSecurity(url, remotePatterns, buildDir);
+    if ("error" in security)
+      return security.error;
+    const { isRemote, resolvedPath } = security;
+    const acceptHeader = request.headers.get("Accept") ?? "";
+    const format = negotiateFormat(acceptHeader, configuredFormats);
+    const mime = formatToMime(format);
+    const cacheKey2 = getCacheKey(url, width, quality, format);
+    const cached = readFromCache(cacheDir, cacheKey2);
+    if (cached && !isCacheStale(cached.meta)) {
+      const ifNoneMatch = request.headers.get("If-None-Match");
+      if (ifNoneMatch && ifNoneMatch === cached.meta.etag) {
+        return new Response(null, {
+          headers: {
+            "Cache-Control": `public, max-age=${Math.ceil(minimumCacheTTL / MS_PER_SECOND)}, must-revalidate`,
+            ETag: cached.meta.etag,
+            Vary: "Accept"
+          },
+          status: 304
+        });
+      }
+      return new Response(new Uint8Array(cached.buffer), {
+        headers: {
+          "Cache-Control": `public, max-age=${Math.ceil(minimumCacheTTL / MS_PER_SECOND)}, must-revalidate`,
+          "Content-Type": cached.meta.contentType,
+          ETag: cached.meta.etag,
+          Vary: "Accept"
+        }
+      });
+    }
+    let sourceBuffer;
+    let upstreamEtag;
+    try {
+      const source = await fetchSourceImage(url, isRemote, resolvedPath ?? null);
+      if ("error" in source)
+        return source.error;
+      sourceBuffer = source.buffer;
+      ({ upstreamEtag } = source);
+    } catch (err) {
+      return new Response(`Failed to load image: ${err instanceof Error ? err.message : "unknown error"}`, { status: 500 });
+    }
+    let optimizedBuffer;
+    try {
+      optimizedBuffer = await optimizeImage(sourceBuffer, width, quality, format);
+    } catch {
+      optimizedBuffer = sourceBuffer;
+    }
+    const etag = `"${cacheKey2}"`;
+    const meta = {
+      contentType: mime,
+      etag,
+      expireAt: Date.now() + minimumCacheTTL,
+      upstreamEtag
+    };
+    try {
+      writeToCache(cacheDir, cacheKey2, optimizedBuffer, meta);
+    } catch {}
+    scheduleAvifPregen(url, width, quality, sourceBuffer, configuredFormats, format, cacheDir, minimumCacheTTL, upstreamEtag);
+    return new Response(new Uint8Array(optimizedBuffer), {
+      headers: {
+        "Cache-Control": `public, max-age=${Math.ceil(minimumCacheTTL / MS_PER_SECOND)}, must-revalidate`,
+        "Content-Type": mime,
+        ETag: etag,
+        Vary: "Accept"
+      }
+    });
+  });
+  return app.use(plugin);
+};
+var init_imageOptimizer = __esm(() => {
+  init_imageProcessing();
+  init_validateSafePath();
+  avifInProgress = new Set;
+});
+
 // src/utils/generateSitemap.ts
 var exports_generateSitemap = {};
 __export(exports_generateSitemap, {
@@ -205755,8 +206222,8 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join17 } from "path";
+import { mkdirSync as mkdirSync11 } from "fs";
+import { join as join18 } from "path";
 var PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -205806,7 +206273,7 @@ var PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join17(prerenderDir, fileName);
+    const filePath = join18(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -205814,8 +206281,8 @@ var PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (
     return false;
   }
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join17(outDir, "_prerendered");
-  mkdirSync10(prerenderDir, { recursive: true });
+  const prerenderDir = join18(outDir, "_prerendered");
+  mkdirSync11(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
   if (staticConfig.routes === "all") {
@@ -205837,7 +206304,7 @@ var PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (
       }
       const html = await res.text();
       const fileName = routeToFilename(route);
-      const filePath = join17(prerenderDir, fileName);
+      const filePath = join18(prerenderDir, fileName);
       await Bun.write(filePath, html);
       await writeTimestamp(filePath);
       result.routes.set(route, filePath);
@@ -205885,12 +206352,12 @@ __export(exports_devCert, {
   hasCert: () => hasCert,
   ensureDevCert: () => ensureDevCert
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, readFileSync as readFileSync11, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync12, rmSync as rmSync2 } from "fs";
 import { platform as platform3 } from "os";
-import { join as join19 } from "path";
-var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync17(CERT_PATH) && existsSync17(KEY_PATH), isCertExpired = () => {
+import { join as join20 } from "path";
+var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync19(CERT_PATH) && existsSync19(KEY_PATH), isCertExpired = () => {
   try {
-    const certPem = readFileSync11(CERT_PATH, "utf-8");
+    const certPem = readFileSync12(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -205959,7 +206426,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
     generateSelfSigned();
   }
 }, ensureDevCert = () => {
-  mkdirSync11(CERT_DIR, { recursive: true });
+  mkdirSync12(CERT_DIR, { recursive: true });
   if (hasCert()) {
     return { cert: CERT_PATH, key: KEY_PATH };
   }
@@ -205979,8 +206446,8 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
     return null;
   try {
     return {
-      cert: readFileSync11(paths.cert, "utf-8"),
-      key: readFileSync11(paths.key, "utf-8")
+      cert: readFileSync12(paths.cert, "utf-8"),
+      key: readFileSync12(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -206086,16 +206553,16 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
   }
   rmSync2(CERT_PATH, { force: true });
   rmSync2(KEY_PATH, { force: true });
-  mkdirSync11(CERT_DIR, { recursive: true });
+  mkdirSync12(CERT_DIR, { recursive: true });
   generateWithMkcert();
   console.log("");
   devLog("mkcert installed \u2014 HTTPS certificates are now locally trusted");
   return true;
 };
 var init_devCert = __esm(() => {
-  CERT_DIR = join19(process.cwd(), ".absolutejs");
-  CERT_PATH = join19(CERT_DIR, "cert.pem");
-  KEY_PATH = join19(CERT_DIR, "key.pem");
+  CERT_DIR = join20(process.cwd(), ".absolutejs");
+  CERT_PATH = join20(CERT_DIR, "cert.pem");
+  KEY_PATH = join20(CERT_DIR, "key.pem");
 });
 // types/client.ts
 var hmrState = {
@@ -206122,8 +206589,8 @@ var {file } = globalThis.Bun;
 var handleHTMLPageRequest = (pagePath) => file(pagePath);
 var handleHTMXPageRequest = (pagePath) => file(pagePath);
 // src/core/prepare.ts
-import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
-import { basename as basename9, join as join18, relative as relative10, resolve as resolve23 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { basename as basename9, join as join19, relative as relative10, resolve as resolve24 } from "path";
 
 // src/utils/loadConfig.ts
 import { resolve } from "path";
@@ -206164,7 +206631,7 @@ var collectPrewarmFiles = async (prewarmDirs) => {
   for (const { dir, pattern } of prewarmDirs) {
     const glob = new Glob8(pattern);
     const matches = [
-      ...glob.scanSync({ absolute: true, cwd: resolve23(dir) })
+      ...glob.scanSync({ absolute: true, cwd: resolve24(dir) })
     ];
     files.push(...matches);
   }
@@ -206200,8 +206667,8 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const fileName = resolveDevIndexFileName(manifest[key], baseName);
     if (!fileName)
       continue;
-    const srcPath = resolve23(devIndexDir, fileName);
-    if (!existsSync16(srcPath))
+    const srcPath = resolve24(devIndexDir, fileName);
+    if (!existsSync18(srcPath))
       continue;
     const rel = relative10(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
@@ -206244,16 +206711,17 @@ var prepareDev = async (config, buildDir) => {
     };
   }
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
-  const devIndexDir = resolve23(buildDir, "_src_indexes");
+  const devIndexDir = resolve24(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
+  const { imageOptimizer: imageOptimizer2 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
   return {
     manifest: result.manifest,
-    absolutejs: (app) => addSitemapHook(hmrPlugin(app.use(staticPlugin({ assets: buildDir, prefix: "" }))), buildDir, config.sitemap)
+    absolutejs: (app) => addSitemapHook(hmrPlugin(app.use(imageOptimizer2(config.images, buildDir)).use(staticPlugin({ assets: buildDir, prefix: "" }))), buildDir, config.sitemap)
   };
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync16(prerenderDir))
+  if (!existsSync18(prerenderDir))
     return map;
   try {
     for (const entry of readdirSync2(prerenderDir)) {
@@ -206261,40 +206729,36 @@ var loadPrerenderMap = (prerenderDir) => {
         continue;
       const name = basename9(entry, ".html");
       const route = name === "index" ? "/" : `/${name}`;
-      map.set(route, join18(prerenderDir, entry));
+      map.set(route, join19(prerenderDir, entry));
     }
   } catch {}
   return map;
 };
-var addSitemapHook = (app, publicDir, sitemapConfig) => {
-  if (!publicDir)
-    return app;
-  return app.onStart((started) => {
-    const { server: server2 } = started;
-    if (!server2)
-      return;
-    Promise.resolve().then(() => (init_generateSitemap(), exports_generateSitemap)).then(({ generateSitemap: generateSitemap2 }) => generateSitemap2(started.routes, server2.url.origin, publicDir, sitemapConfig)).catch((err) => console.error("[sitemap] Generation failed:", err));
-  });
-};
+var addSitemapHook = (app, buildDir, sitemapConfig) => app.onStart((started) => {
+  const { server: server2 } = started;
+  if (!server2)
+    return;
+  Promise.resolve().then(() => (init_generateSitemap(), exports_generateSitemap)).then(({ generateSitemap: generateSitemap2 }) => generateSitemap2(started.routes, server2.url.origin, buildDir, sitemapConfig)).catch((err) => console.error("[sitemap] Generation failed:", err));
+});
 var prepare = async (configOrPath) => {
   const config = await loadConfig(configOrPath);
   const nodeEnv = process.env["NODE_ENV"];
   const isDev2 = nodeEnv === "development";
-  const buildDir = resolve23(isDev2 ? config.buildDirectory ?? "build" : process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
+  const buildDir = resolve24(isDev2 ? config.buildDirectory ?? "build" : process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
   if (isDev2)
     return prepareDev(config, buildDir);
-  const manifest = JSON.parse(readFileSync10(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync11(`${buildDir}/manifest.json`, "utf-8"));
   const { staticPlugin } = await import("@elysiajs/static");
   const staticFiles = staticPlugin({ assets: buildDir, prefix: "" });
-  const prerenderDir = join18(buildDir, "_prerendered");
+  const prerenderDir = join19(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   if (prerenderMap.size > 0) {
-    const { Elysia } = await import("elysia");
+    const { Elysia: Elysia2 } = await import("elysia");
     const { PRERENDER_BYPASS_HEADER: PRERENDER_BYPASS_HEADER2, readTimestamp: readTimestamp2, rerenderRoute: rerenderRoute2 } = await Promise.resolve().then(() => (init_prerender(), exports_prerender));
     const revalidateMs = config.static?.revalidate ? config.static.revalidate * 1000 : 0;
     const port = Number(process.env.PORT) || 3000;
     const rerendering = new Set;
-    const prerenderPlugin = new Elysia({
+    const prerenderPlugin = new Elysia2({
       name: "prerendered-pages"
     }).onRequest(({ request }) => {
       const url = new URL(request.url);
@@ -206315,10 +206779,12 @@ var prepare = async (configOrPath) => {
         headers: { "content-type": "text/html; charset=utf-8" }
       });
     });
-    const absolutejs2 = (app) => addSitemapHook(app.use(prerenderPlugin).use(staticFiles), buildDir, config.sitemap);
+    const { imageOptimizer: imageOptimizer3 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
+    const absolutejs2 = (app) => addSitemapHook(app.use(imageOptimizer3(config.images, buildDir)).use(prerenderPlugin).use(staticFiles), buildDir, config.sitemap);
     return { absolutejs: absolutejs2, manifest };
   }
-  const absolutejs = (app) => addSitemapHook(app.use(staticFiles), buildDir, config.sitemap);
+  const { imageOptimizer: imageOptimizer2 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
+  const absolutejs = (app) => addSitemapHook(app.use(imageOptimizer2(config.images, buildDir)).use(staticFiles), buildDir, config.sitemap);
   return { absolutejs, manifest };
 };
 // src/plugins/networking.ts
@@ -206618,5 +207084,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=131C329B7ED8ED0164756E2164756E21
+//# debugId=E998A8E80C0F65EC64756E2164756E21
 //# sourceMappingURL=index.js.map