@absolutejs/absolute 0.19.0-beta.176 → 0.19.0-beta.178

package/dist/{build.js → src/build.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;
 
@@ -731,15 +741,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 image = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
+  return [...device, ...image].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 {
@@ -747,19 +995,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;
@@ -774,7 +1022,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;
@@ -817,7 +1065,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;
@@ -849,9 +1097,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);
 };
@@ -861,12 +1109,12 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve2 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const fromSource = resolve2(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync6(fromSource))
+  if (existsSync7(fromSource))
     return fromSource;
   return resolve2(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
@@ -1058,8 +1306,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 resolve4 } 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 resolve4 } from "path";
 import { createHash } from "crypto";
 var CACHE_DIR, angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
@@ -1082,10 +1330,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"
           };
         }
@@ -1100,8 +1348,8 @@ var init_angularLinkerPlugin = __esm(() => {
           linkerPlugin = mod.createEs2015LinkerPlugin({
             fileSystem: {
               dirname: dirname2,
-              exists: existsSync7,
-              readFile: readFileSync3,
+              exists: existsSync8,
+              readFile: readFileSync4,
               relative: relative2,
               resolve: resolve4
             },
@@ -1127,8 +1375,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" };
       });
     }
@@ -1159,7 +1407,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,
@@ -1167,19 +1415,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
@@ -1223,11 +1471,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 resolve7,
@@ -1238,7 +1486,7 @@ import { env } from "process";
 var {write, file, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const fromSource = resolve7(import.meta.dir, "../dev/client");
-  if (existsSync8(fromSource))
+  if (existsSync9(fromSource))
     return fromSource;
   return resolve7(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
@@ -1274,10 +1522,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 build = async (src) => {
@@ -1318,8 +1566,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, {
@@ -1363,8 +1611,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 })
@@ -1392,7 +1640,7 @@ var resolveDevClientDir2 = () => {
   await Promise.all(roots.map(async ({ client }) => {
     const relClientDir = dirname3(relative4(clientDir, client));
     const name = basename2(client, extname2(client));
-    const indexPath = join6(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join7(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative4(dirname3(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -1437,7 +1685,7 @@ if (typeof window !== "undefined") {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
       const rel = dirname3(relative4(clientDir, client));
-      return join6(indexDir, rel, basename2(client));
+      return join7(indexDir, rel, basename2(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -1445,7 +1693,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" });
@@ -1460,13 +1708,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 resolve8 } from "path";
+import { basename as basename3, dirname as dirname4, join as join8, relative as relative5, resolve as resolve8 } from "path";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const fromSource = resolve8(import.meta.dir, "../dev/client");
-  if (existsSync9(fromSource))
+  if (existsSync10(fromSource))
     return fromSource;
   return resolve8(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
@@ -1590,7 +1838,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(`
 `));
@@ -1621,8 +1869,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) => {
@@ -1651,11 +1899,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 }),
@@ -1672,8 +1920,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";`,
@@ -1783,8 +2031,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file2(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);
@@ -1801,7 +2049,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;
@@ -4091,7 +4339,7 @@ var require_typescript = __commonJS((exports, module) => {
       walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
       whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
       writeCommentRange: () => writeCommentRange,
-      writeFile: () => writeFile3,
+      writeFile: () => writeFile4,
       writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
       zipWith: () => zipWith
     });
@@ -9883,7 +10131,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile2,
+          readFile: readFile3,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -10076,7 +10324,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);
@@ -21400,7 +21648,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);
@@ -41023,7 +41271,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 = [];
@@ -41061,7 +41309,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;
@@ -41164,8 +41412,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);
@@ -41233,8 +41481,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) {
@@ -41244,14 +41492,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);
       }
@@ -103993,7 +104241,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) {
@@ -104152,14 +104400,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;
       }
@@ -108681,12 +108929,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) {
@@ -109477,7 +109725,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();
@@ -109653,7 +109901,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile2,
+        readFile: readFile3,
         directoryExists,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -160091,7 +160339,7 @@ ${options.prefix}` : `
       walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
       whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
       writeCommentRange: () => writeCommentRange,
-      writeFile: () => writeFile3,
+      writeFile: () => writeFile4,
       writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
       zipWith: () => zipWith
     });
@@ -170540,19 +170788,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 resolve9, 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 resolve9, 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 = resolve9(import.meta.dir, "../dev/client");
-  if (existsSync10(fromSource))
+  if (existsSync11(fromSource))
     return fromSource;
   return resolve9(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
@@ -170648,7 +170896,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);
@@ -170675,7 +170923,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}`;
@@ -170694,7 +170942,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);
@@ -170702,7 +170950,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}\``);
@@ -170715,7 +170963,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}\``);
@@ -170726,7 +170974,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}\`]`);
@@ -170756,15 +171004,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;
@@ -170774,7 +171022,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);
@@ -170808,13 +171056,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);
@@ -170831,8 +171079,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'`);
@@ -170926,8 +171174,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;
 });
@@ -170938,8 +171186,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) => {
@@ -170974,14 +171222,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;
@@ -171017,18 +171265,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;
@@ -171070,18 +171318,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;
@@ -171106,17 +171354,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 file3 of files) {
-    const filePath = join11(vendorDir, file3);
-    const content = readFileSync5(filePath, "utf-8");
+    const filePath = join12(vendorDir, file3);
+    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 = {};
@@ -171135,8 +171383,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) => {
@@ -171150,13 +171398,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;
@@ -171231,14 +171479,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 resolve10 } from "path";
+import { basename as basename5, join as join14, relative as relative7, resolve as resolve10 } 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) => {
@@ -171260,11 +171508,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;
   }
@@ -171304,7 +171552,7 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
     addWorkerPathIfExists(file3, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file3, patterns, workerPaths) => {
-  const content = readFileSync5(file3, "utf-8");
+  const content = readFileSync6(file3, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file3, workerPaths);
   }
@@ -171337,8 +171585,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);
   }
@@ -171352,35 +171600,35 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
   const indexFiles = readDir(reactIndexesPath).filter((file3) => file3.endsWith(".tsx"));
   const pagesRel = relative7(process.cwd(), resolve10(reactPagesPath)).replace(/\\/g, "/");
   for (const file3 of indexFiles) {
-    let content = readFileSync5(join13(reactIndexesPath, file3), "utf-8");
+    let content = readFileSync6(join14(reactIndexesPath, file3), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync3(join13(devIndexDir, file3), content);
+    writeFileSync4(join14(devIndexDir, file3), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join13(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join14(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file3) => resolve10(file3).startsWith(resolve10(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(), resolve10(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((file3) => resolve10(file3).startsWith(resolve10(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(), resolve10(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} =`);
@@ -171428,7 +171676,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;
@@ -171449,7 +171697,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) {
@@ -171478,7 +171726,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);
@@ -171489,7 +171737,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync3(outputPath, content);
+      writeFileSync4(outputPath, content);
   }
 }, vueFeatureFlags, build = async ({
   buildDirectory = "build",
@@ -171525,14 +171773,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,
@@ -171568,12 +171816,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" });
@@ -171583,14 +171831,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) => {
@@ -171612,7 +171860,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
     });
@@ -171626,7 +171874,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((file3) => file3.endsWith(".css"))) ? compileTailwind(tailwind.input, tailwind.output) : undefined;
@@ -171651,7 +171899,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve10(reactIndexesPath))) {
       const pageName = basename5(entry, ".tsx");
-      return join13(reactPagesPath, `${pageName}.tsx`);
+      return join14(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -171742,7 +171990,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);
   }
@@ -171785,13 +172033,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
     });
@@ -171853,7 +172101,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
@@ -171861,7 +172109,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
@@ -171956,20 +172204,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
@@ -171977,6 +172225,7 @@ ${content.slice(firstUseIdx)}`;
     }
     if (shouldUpdateHtmlAssetPaths) {
       await updateAssetPaths(manifest, outputHtmlPages);
+      await optimizeHtmlImages(outputHtmlPages);
     }
     const htmlPageFiles = await scanEntryPoints(outputHtmlPages, "*.html");
     for (const htmlFile of htmlPageFiles) {
@@ -171989,20 +172238,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) {
@@ -172049,7 +172299,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;
 };
@@ -172061,6 +172311,7 @@ var init_build = __esm(() => {
   init_outputLogs();
   init_scanEntryPoints();
   init_scanCssEntryPoints();
+  init_optimizeHtmlImages();
   init_updateAssetPaths();
   init_buildHMRClient();
   init_rewriteReactImports();
@@ -172108,7 +172359,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 resolve11 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -172138,10 +172389,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) => {
@@ -172156,7 +172407,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
 }, addFileToGraph = (graph, filePath) => {
   const normalizedPath = resolve11(filePath);
-  if (!existsSync12(normalizedPath))
+  if (!existsSync13(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -172172,7 +172423,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) => resolve11(dir)).filter((dir) => existsSync12(dir));
+  const resolvedDirs = directories.map((dir) => resolve11(dir)).filter((dir) => existsSync13(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file3 of allFiles) {
     const fullPath = resolve11(file3);
@@ -172269,15 +172520,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 [];
@@ -172563,8 +172814,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 resolve13 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15, resolve as resolve13 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -172591,16 +172842,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);
     }
@@ -172610,7 +172861,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
     const absolutePath = resolve13(path).replace(/\\/g, "/");
-    if (!existsSync13(absolutePath)) {
+    if (!existsSync14(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -172621,7 +172872,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
     const absolutePath = resolve13(path).replace(/\\/g, "/");
-    if (!existsSync13(absolutePath)) {
+    if (!existsSync14(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -172742,10 +172993,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;
@@ -173132,8 +173383,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;
@@ -173167,12 +173418,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 resolve17, 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(resolve17(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync15(resolve17(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 resolve20 } 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((file3) => existsSync15(file3));
+    const dependentFiles = Array.from(dependents).filter((file3) => existsSync16(file3));
     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 = resolve20(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 = resolve20(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 file3 of files) {
-    const filePath = join16(vendorDir, file3);
-    const original = readFileSync10(filePath, "utf-8");
+    const filePath = join17(vendorDir, file3);
+    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;
@@ -205561,5 +205814,5 @@ export {
   build
 };
 
-//# debugId=7684D0C3AAA8F5A164756E2164756E21
+//# debugId=1D13B3CA347CB6EE64756E2164756E21
 //# sourceMappingURL=build.js.map