reroute-js 1.0.0-alpha.21 → 1.0.0-alpha.23

package/cli/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v1.0.0-alpha.21
+ * reroute-js v1.0.0-alpha.23
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
@@ -68,7 +68,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "1.0.0-alpha.21";
+    return "1.0.0-alpha.23";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -86,7 +86,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "4f2f6a2";
+    return "97c7664";
   }
   return "dev";
 }
@@ -962,6 +962,58 @@ var init_i18n = __esm(() => {
   init_resolve();
 });
 
+// packages/core/src/image.ts
+function uniquePositiveWidths(widths) {
+  return [...new Set(widths.filter((width) => width > 0))].sort((a, b) => a - b);
+}
+function resolveImagePreprocess(image) {
+  const preprocess = image?.preprocess;
+  if (!preprocess) {
+    return {
+      enabled: false,
+      widths: [...DEFAULT_IMAGE_DEVICE_SIZES],
+      formats: [...DEFAULT_PREPROCESS_FORMATS],
+      quality: DEFAULT_IMAGE_QUALITY,
+      qualities: [DEFAULT_IMAGE_QUALITY]
+    };
+  }
+  const options = preprocess === true ? {} : preprocess;
+  const quality = options.quality ?? DEFAULT_IMAGE_QUALITY;
+  return {
+    enabled: true,
+    widths: uniquePositiveWidths([
+      options.mobile ?? DEFAULT_PREPROCESS_SIZES.mobile,
+      options.tablet ?? DEFAULT_PREPROCESS_SIZES.tablet,
+      options.desktop ?? DEFAULT_PREPROCESS_SIZES.desktop
+    ]),
+    formats: options.formats?.length ? options.formats : [...DEFAULT_PREPROCESS_FORMATS],
+    quality,
+    qualities: uniquePositiveWidths(options.qualities ?? [quality])
+  };
+}
+function resolveImageDeviceSizes(image) {
+  return resolveImagePreprocess(image).widths;
+}
+var DEFAULT_IMAGE_DEVICE_SIZES, DEFAULT_PREPROCESS_SIZES, DEFAULT_PREPROCESS_FORMATS, DEFAULT_IMAGE_QUALITY = 75;
+var init_image = __esm(() => {
+  DEFAULT_IMAGE_DEVICE_SIZES = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840
+  ];
+  DEFAULT_PREPROCESS_SIZES = {
+    mobile: 640,
+    tablet: 1024,
+    desktop: 1920
+  };
+  DEFAULT_PREPROCESS_FORMATS = ["webp", "avif"];
+});
+
 // packages/telemetry/src/server/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var contextStorage;
@@ -6931,6 +6983,7 @@ var init_src = __esm(() => {
   init_config();
   init_content();
   init_i18n();
+  init_image();
   init_llms();
   init_og();
   init_robots();
@@ -6946,8 +6999,12 @@ __export(exports_core, {
   DEFAULT_APP_SERVER: () => DEFAULT_APP_SERVER,
   DEFAULT_APP_SRC: () => DEFAULT_APP_SRC,
   DEFAULT_COOKIE: () => DEFAULT_COOKIE,
+  DEFAULT_IMAGE_DEVICE_SIZES: () => DEFAULT_IMAGE_DEVICE_SIZES,
+  DEFAULT_IMAGE_QUALITY: () => DEFAULT_IMAGE_QUALITY,
   DEFAULT_LOCALE: () => DEFAULT_LOCALE,
   DEFAULT_LOCALES_DIR: () => DEFAULT_LOCALES_DIR,
+  DEFAULT_PREPROCESS_FORMATS: () => DEFAULT_PREPROCESS_FORMATS,
+  DEFAULT_PREPROCESS_SIZES: () => DEFAULT_PREPROCESS_SIZES,
   DefaultOGTemplate: () => DefaultOGTemplate,
   LRUCache: () => LRUCache,
   SEARCH_CRAWLERS: () => SEARCH_CRAWLERS,
@@ -7075,6 +7132,8 @@ __export(exports_core, {
   resetSSRAccessTracking: () => resetSSRAccessTracking,
   resetSSRContentResults: () => resetSSRContentResults,
   resolveAppPaths: () => resolveAppPaths,
+  resolveImageDeviceSizes: () => resolveImageDeviceSizes,
+  resolveImagePreprocess: () => resolveImagePreprocess,
   resolveLocale: () => resolveLocale,
   seedSSRModuleForPath: () => seedSSRModuleForPath,
   setGlobalCollections: () => setGlobalCollections,
@@ -7188,14 +7247,318 @@ function envToDefineObject(env) {
 var envLoadedLog = false;
 var init_env = () => {};
 
+// packages/elysia/src/libs/image.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
+import { cpus } from "node:os";
+import { join as join6 } from "node:path";
+import sharp from "sharp";
+function initImageCache(cacheDir) {
+  diskCacheDir = cacheDir;
+}
+function imageCacheIdentity(imagePath) {
+  const normalized = imagePath.replace(/\\/g, "/");
+  const marker = "/assets/";
+  const index = normalized.lastIndexOf(marker);
+  if (index !== -1) {
+    return normalized.slice(index);
+  }
+  return normalized;
+}
+function getCacheKey(imagePath, options) {
+  const optionsString = JSON.stringify(options);
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(`${imageCacheIdentity(imagePath)}:${optionsString}`);
+  const hash2 = hasher.digest("hex");
+  return hash2;
+}
+function getContentType(format) {
+  const contentTypes = {
+    webp: "image/webp",
+    avif: "image/avif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif"
+  };
+  return contentTypes[format] || "image/jpeg";
+}
+function negotiateFormat(acceptHeader, requestedFormat) {
+  if (requestedFormat && ["webp", "avif", "jpeg", "png"].includes(requestedFormat)) {
+    return requestedFormat;
+  }
+  const accept = acceptHeader?.toLowerCase() || "";
+  if (accept.includes("image/avif")) {
+    return "avif";
+  }
+  if (accept.includes("image/webp")) {
+    return "webp";
+  }
+  return "jpeg";
+}
+async function loadFromDiskCache(cacheKey) {
+  if (!diskCacheDir)
+    return null;
+  try {
+    const cachePath = join6(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join6(diskCacheDir, `${cacheKey}.img`);
+    if (!(existsSync3(cachePath) && existsSync3(imagePath))) {
+      return null;
+    }
+    const metadata3 = JSON.parse(await Bun.file(cachePath).text());
+    const buffer = Buffer.from(await Bun.file(imagePath).arrayBuffer());
+    return {
+      buffer,
+      contentType: metadata3.contentType,
+      format: metadata3.format,
+      width: metadata3.width,
+      height: metadata3.height,
+      size: metadata3.size
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveToDiskCache(cacheKey, result) {
+  if (!diskCacheDir)
+    return;
+  try {
+    const cachePath = join6(diskCacheDir, `${cacheKey}.json`);
+    const imagePath = join6(diskCacheDir, `${cacheKey}.img`);
+    await Bun.write(cachePath, JSON.stringify({
+      contentType: result.contentType,
+      format: result.format,
+      width: result.width,
+      height: result.height,
+      size: result.size
+    }));
+    await Bun.write(imagePath, result.buffer);
+  } catch (error) {
+    console.error("Failed to save image to disk cache:", error);
+  }
+}
+async function fetchImageBuffer(imagePath) {
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    const response = await fetch(imagePath);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  return Buffer.from(await Bun.file(imagePath).arrayBuffer());
+}
+function applyFormatTransform(transformer, format, quality) {
+  switch (format) {
+    case "webp":
+      return transformer.webp({ quality, effort: 4 });
+    case "avif":
+      return transformer.avif({ quality, effort: 4 });
+    case "png":
+      return transformer.png({
+        quality,
+        compressionLevel: 9,
+        adaptiveFiltering: true
+      });
+    default:
+      return transformer.jpeg({ quality, mozjpeg: true });
+  }
+}
+function addToMemoryCache(cacheKey, result) {
+  if (imageCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = imageCache.keys().next().value;
+    if (firstKey) {
+      imageCache.delete(firstKey);
+    }
+  }
+  imageCache.set(cacheKey, result);
+}
+async function optimizeImage(imagePath, options, acceptHeader) {
+  const cacheKey = getCacheKey(imagePath, options);
+  const memCached = imageCache.get(cacheKey);
+  if (memCached) {
+    return memCached;
+  }
+  const diskCached = await loadFromDiskCache(cacheKey);
+  if (diskCached) {
+    addToMemoryCache(cacheKey, diskCached);
+    return diskCached;
+  }
+  const sourceBuffer = await fetchImageBuffer(imagePath);
+  const format = options.format === "auto" || !options.format ? negotiateFormat(acceptHeader, undefined) : options.format;
+  let transformer = sharp(sourceBuffer);
+  const metadata3 = await transformer.metadata();
+  if (options.width || options.height) {
+    const resizeOptions = {
+      width: options.width,
+      height: options.height,
+      fit: options.fit || "cover",
+      withoutEnlargement: true
+    };
+    transformer = transformer.resize(resizeOptions);
+  }
+  const quality = options.quality ?? 75;
+  transformer = applyFormatTransform(transformer, format, quality);
+  const buffer = await transformer.toBuffer();
+  const info = await sharp(buffer).metadata();
+  const result = {
+    buffer,
+    contentType: getContentType(format),
+    format,
+    width: info.width || metadata3.width || options.width || 0,
+    height: info.height || metadata3.height || options.height || 0,
+    size: buffer.length
+  };
+  await saveToDiskCache(cacheKey, result);
+  if (imageCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = imageCache.keys().next().value;
+    if (firstKey) {
+      imageCache.delete(firstKey);
+    }
+  }
+  imageCache.set(cacheKey, result);
+  return result;
+}
+function isImageFile(path3) {
+  const imageExtensions = [".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif"];
+  const ext = path3.toLowerCase().split(".").pop();
+  return ext ? imageExtensions.includes(`.${ext}`) : false;
+}
+function isPreprocessSource(path3) {
+  return isImageFile(path3) && !path3.toLowerCase().endsWith(".gif");
+}
+function walkImageFiles(dir) {
+  if (!existsSync3(dir)) {
+    return [];
+  }
+  const files = [];
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkImageFiles(fullPath));
+    } else if (isPreprocessSource(fullPath)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function bakeVariant(cacheDir, imagePath, width, quality, format) {
+  const transform = {
+    width,
+    quality,
+    format,
+    fit: "cover"
+  };
+  const cacheKey = getCacheKey(imagePath, transform);
+  const existed = existsSync3(join6(cacheDir, `${cacheKey}.img`)) && existsSync3(join6(cacheDir, `${cacheKey}.json`));
+  await optimizeImage(imagePath, transform, format === "auto" ? "image/webp" : undefined);
+  return existed ? "cached" : "generated";
+}
+function preprocessJobs(options) {
+  const sources = walkImageFiles(options.assetsDir);
+  const formats = [
+    ...options.formats,
+    "auto"
+  ];
+  const qualities = options.qualities?.length ? options.qualities : [options.quality];
+  return sources.flatMap((imagePath) => options.widths.flatMap((width) => qualities.flatMap((quality) => formats.map((format) => ({ imagePath, width, quality, format })))));
+}
+async function mapPool(items, concurrency, fn) {
+  if (items.length === 0) {
+    return [];
+  }
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Math.min(Math.max(1, concurrency), items.length);
+  await Promise.all(Array.from({ length: workers }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await fn(items[index]);
+    }
+  }));
+  return results;
+}
+function preprocessConcurrency(override) {
+  if (override && override > 0) {
+    return override;
+  }
+  return Math.max(1, cpus().length);
+}
+async function preprocessImages(options) {
+  initImageCache(options.cacheDir);
+  const jobs = preprocessJobs(options);
+  const concurrency = preprocessConcurrency(options.concurrency);
+  if (jobs.length > 0) {
+    console.log(`[reroute] Preprocessing ${jobs.length} image variants (${concurrency} at a time)...`);
+  }
+  const previousSharpThreads = sharp.concurrency();
+  sharp.concurrency(1);
+  const results = await mapPool(jobs, concurrency, (job) => bakeVariant(options.cacheDir, job.imagePath, job.width, job.quality, job.format)).finally(() => {
+    sharp.concurrency(previousSharpThreads);
+  });
+  let generated = 0;
+  let cached = 0;
+  for (const result of results) {
+    if (result === "cached") {
+      cached++;
+    } else {
+      generated++;
+    }
+  }
+  const sources = new Set(jobs.map((job) => job.imagePath)).size;
+  return { sources, generated, cached, jobs: jobs.length, concurrency };
+}
+var imageCache, MAX_CACHE_SIZE = 100, diskCacheDir = null;
+var init_image2 = __esm(() => {
+  imageCache = new Map;
+});
+
+// packages/cli/src/commands/lib/images.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+function resolvePreprocessAssetsDir(cwd, config2) {
+  const builtAssets = join7(cwd, ".reroute", "assets");
+  if (existsSync4(builtAssets)) {
+    return builtAssets;
+  }
+  return join7(cwd, resolveAppPaths(config2).assetsDir);
+}
+async function runImagePreprocess(cwd, config2) {
+  const preprocess = resolveImagePreprocess(config2.image);
+  if (!preprocess.enabled) {
+    return;
+  }
+  const assetsDir = resolvePreprocessAssetsDir(cwd, config2);
+  if (!existsSync4(assetsDir)) {
+    console.log("[reroute] Image preprocess skipped (no assets directory)");
+    return;
+  }
+  const started = performance.now();
+  const result = await preprocessImages({
+    assetsDir,
+    cacheDir: join7(cwd, ".reroute", "image-cache"),
+    widths: preprocess.widths,
+    formats: preprocess.formats,
+    quality: preprocess.quality,
+    qualities: preprocess.qualities
+  });
+  const elapsed = ((performance.now() - started) / 1000).toFixed(2);
+  console.log(`[reroute] Preprocessed ${result.sources} images → ${result.jobs} variants (${result.concurrency} at a time): ${result.generated} new, ${result.cached} cached (${elapsed}s)`);
+}
+var init_images = __esm(() => {
+  init_core();
+  init_image2();
+});
+
 // packages/cli/src/commands/lib/markdown/availability.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join8 } from "node:path";
 function isPackageAvailable(cwd, packageName) {
   let currentDir = cwd;
   for (let i = 0;i < 5; i++) {
-    const packageJsonPath = join6(currentDir, "package.json");
-    if (existsSync3(packageJsonPath)) {
+    const packageJsonPath = join8(currentDir, "package.json");
+    if (existsSync5(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
         const deps = {
@@ -7265,8 +7628,8 @@ function checkMarkdownIfConfigured(cwd) {
 var init_availability = () => {};
 
 // packages/cli/src/commands/lib/markdown/processor.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname3, extname as extname3, join as join7, relative, resolve } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname3, extname as extname3, join as join9, relative, resolve } from "node:path";
 import matter from "gray-matter";
 function convertPropertiesToJsx(properties) {
   const newProperties = {};
@@ -7325,8 +7688,8 @@ function processMarkdownFile(filePath) {
 function isMdxAvailable2(cwd) {
   let currentDir = cwd;
   for (let i = 0;i < 5; i++) {
-    const packageJsonPath = join7(currentDir, "package.json");
-    if (existsSync4(packageJsonPath)) {
+    const packageJsonPath = join9(currentDir, "package.json");
+    if (existsSync6(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
         const deps = {
@@ -7349,10 +7712,10 @@ function isMdxAvailable2(cwd) {
 }
 function tryLoadModule(cwd, moduleName) {
   const pathsToTry = [
-    join7(cwd, `node_modules/${moduleName}`),
-    join7(cwd, `../node_modules/${moduleName}`),
-    join7(cwd, `../../node_modules/${moduleName}`),
-    join7(cwd, `../../../node_modules/${moduleName}`)
+    join9(cwd, `node_modules/${moduleName}`),
+    join9(cwd, `../node_modules/${moduleName}`),
+    join9(cwd, `../../node_modules/${moduleName}`),
+    join9(cwd, `../../../node_modules/${moduleName}`)
   ];
   for (const modulePath of pathsToTry) {
     try {
@@ -7677,12 +8040,15 @@ var init_markdown = __esm(() => {
 });
 
 // packages/cli/src/commands/lib/production.ts
+function hasProdFlag(args = []) {
+  return args.includes("--prod") || args.includes("--production");
+}
 function isProductionMode(args = []) {
-  return args.includes("--prod");
+  return hasProdFlag(args);
 }
 
 // packages/cli/src/commands/lib/streaming/analyzer.ts
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname4, join as join10 } from "node:path";
 function hasSSRDataExport(source) {
   if (SSR_DATA_INLINE_EXPORT_REGEX.test(source)) {
     return true;
@@ -7710,10 +8076,10 @@ async function analyzeRouteForStreaming(options) {
 }
 async function findSkeletonForTarget(routesDir, relativePath, type) {
   const dirName = normalizeRelativePath(dirname4(relativePath));
-  const baseDir = dirName === "." ? routesDir : join8(routesDir, dirName).replace(/\\/g, "/");
+  const baseDir = dirName === "." ? routesDir : join10(routesDir, dirName).replace(/\\/g, "/");
   const candidates = type === "layout" ? ["[layout+skeleton].tsx", "[layout+skeleton].ts"] : ["[skeleton].tsx", "[skeleton].ts"];
   for (const candidate of candidates) {
-    const candidatePath = join8(baseDir, candidate);
+    const candidatePath = join10(baseDir, candidate);
     try {
       const file = Bun.file(candidatePath);
       if (await file.exists()) {
@@ -7734,12 +8100,12 @@ var init_analyzer = __esm(() => {
 });
 
 // packages/cli/src/commands/lib/streaming/suspense.ts
-import { dirname as dirname5, join as join9, relative as relative2 } from "node:path";
+import { dirname as dirname5, join as join11, relative as relative2 } from "node:path";
 async function generateStreamingWrapper(options) {
   const { cwd, relativeFilePath, analysis, config: config2 } = options;
-  const streamingModulePath = join9(cwd, ".reroute", "streaming", relativeFilePath).replace(/\.(tsx|ts)$/, ".tsx");
+  const streamingModulePath = join11(cwd, ".reroute", "streaming", relativeFilePath).replace(/\.(tsx|ts)$/, ".tsx");
   const wrapperDir = dirname5(streamingModulePath);
-  const originalModuleWithoutExt = removeExtension(join9(cwd, resolveAppPaths(config2).routesDir, relativeFilePath));
+  const originalModuleWithoutExt = removeExtension(join11(cwd, resolveAppPaths(config2).routesDir, relativeFilePath));
   const originalImportPath = toImportPath(wrapperDir, originalModuleWithoutExt);
   const skeletonImportBlock = await resolveSkeletonBlock({
     analysis,
@@ -7781,7 +8147,7 @@ async function resolveSkeletonBlock(args) {
 }
 function resolveConfiguredSkeletonPath(value, cwd) {
   if (typeof value === "string" && value.trim().length > 0) {
-    return value.startsWith("/") ? value : join9(cwd, value);
+    return value.startsWith("/") ? value : join11(cwd, value);
   }
   if (value && !warnedSkeletonType) {
     console.warn("[reroute/streaming] default skeletons must be provided as string module paths in reroute.config.ts");
@@ -7819,13 +8185,13 @@ var init_suspense = __esm(() => {
 
 // packages/cli/src/commands/lib/theme.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir7, unlink as unlink2, writeFile } from "node:fs/promises";
-import { dirname as dirname6, isAbsolute, join as join10, resolve as resolve2 } from "node:path";
+import { dirname as dirname6, isAbsolute, join as join12, resolve as resolve2 } from "node:path";
 async function getCssPaths(cwd) {
   const paths = resolveAppPaths(await loadConfig(cwd));
-  const input = join10(cwd, paths.cssEntry);
-  const bundlesDir = join10(cwd, ".reroute/bundles");
+  const input = join12(cwd, paths.cssEntry);
+  const bundlesDir = join12(cwd, ".reroute/bundles");
   return { input, bundlesDir };
 }
 function themeCssFileName2(css) {
@@ -7850,7 +8216,7 @@ function bundleCssEntrypoint(entryPath) {
     if (stack.has(absPath)) {
       throw new Error(`[reroute/theme] Circular @import detected: ${absPath}`);
     }
-    if (!existsSync5(absPath)) {
+    if (!existsSync7(absPath)) {
       throw new Error(`[reroute/theme] Missing CSS import: ${absPath}`);
     }
     stack.add(absPath);
@@ -7877,21 +8243,21 @@ async function pruneStaleThemeCss(bundlesDir, keep) {
   const files = await readdir7(bundlesDir);
   for (const file of files) {
     if (HASHED_THEME_RE2.test(file) && file !== keep) {
-      await unlink2(join10(bundlesDir, file));
+      await unlink2(join12(bundlesDir, file));
     }
   }
 }
 async function syncThemeCss(cwd) {
   const { input, bundlesDir } = await getCssPaths(cwd);
-  if (!existsSync5(input)) {
+  if (!existsSync7(input)) {
     return false;
   }
   await mkdir2(bundlesDir, { recursive: true });
   try {
     const css = bundleCssEntrypoint(input);
     const hashedName = themeCssFileName2(css);
-    await writeFile(join10(bundlesDir, "index.css"), css, "utf-8");
-    await writeFile(join10(bundlesDir, hashedName), css, "utf-8");
+    await writeFile(join12(bundlesDir, "index.css"), css, "utf-8");
+    await writeFile(join12(bundlesDir, hashedName), css, "utf-8");
     await pruneStaleThemeCss(bundlesDir, hashedName);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -7914,7 +8280,7 @@ var init_theme = __esm(() => {
 // packages/cli/src/commands/lib/watch.ts
 import { createHash as createHash3 } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 function isWatchNoise(name) {
   return name.split(/[/\\]/).some((part) => part.startsWith(".")) || /\.bust-[^/\\]+$/.test(name);
 }
@@ -7948,7 +8314,7 @@ function createContentFingerprint(options) {
 async function retainChangedFiles(root, names, fingerprint) {
   const changed = [];
   for (const name of names) {
-    if (await fingerprint.changed(join11(root, name))) {
+    if (await fingerprint.changed(join13(root, name))) {
       changed.push(name);
     }
   }
@@ -7964,11 +8330,11 @@ __export(exports_gen, {
 });
 import { watch } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir3, readdir as readdir8, rm, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname7, extname as extname4, join as join12 } from "node:path";
+import { dirname as dirname7, extname as extname4, join as join14 } from "node:path";
 import { pathToFileURL as pathToFileURL8 } from "node:url";
 async function bundleThemeCssIntoArtifacts(cwd) {
-  const cssPath = join12(cwd, ".reroute", "bundles", "index.css");
-  const artifactsPath = join12(cwd, OUTPUT_ARTIFACTS);
+  const cssPath = join14(cwd, ".reroute", "bundles", "index.css");
+  const artifactsPath = join14(cwd, OUTPUT_ARTIFACTS);
   try {
     const cssContent = await Bun.file(cssPath).text();
     if (!cssContent)
@@ -7994,7 +8360,7 @@ async function bundleThemeCssIntoArtifacts(cwd) {
 async function ensureOutputDir(cwd, options = {}) {
   const { clean = true } = options;
   try {
-    const outputPath = join12(cwd, OUTPUT_DIR);
+    const outputPath = join14(cwd, OUTPUT_DIR);
     if (clean) {
       let needsCleanup = false;
       try {
@@ -8007,9 +8373,9 @@ async function ensureOutputDir(cwd, options = {}) {
       }
     }
     await mkdir3(outputPath, { recursive: true });
-    await mkdir3(join12(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
-    await mkdir3(join12(cwd, ".reroute/bundles"), { recursive: true });
-    await mkdir3(join12(cwd, ".reroute/streaming"), { recursive: true });
+    await mkdir3(join14(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+    await mkdir3(join14(cwd, ".reroute/bundles"), { recursive: true });
+    await mkdir3(join14(cwd, ".reroute/streaming"), { recursive: true });
   } catch {}
 }
 async function writeStubFiles(cwd, serverImport) {
@@ -8087,14 +8453,14 @@ import './artifacts';
 import './routes'; // Import routes (bundles all route components)
 import '${serverImport}';
 `;
-  await Bun.write(join12(cwd, OUTPUT_ROUTES), STUB_ROUTES);
-  await Bun.write(join12(cwd, OUTPUT_ROUTES_CLIENT), STUB_ROUTES);
-  await Bun.write(join12(cwd, OUTPUT_CONTENT_TS), STUB_CONTENT);
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS), STUB_ARTIFACTS);
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS_CLIENT), STUB_ARTIFACTS_CLIENT);
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS_SERVER), STUB_ARTIFACTS_SERVER);
-  await Bun.write(join12(cwd, OUTPUT_INDEX), STUB_INDEX);
-  await Bun.write(join12(cwd, ".reroute/entry.ts"), stubEntry);
+  await Bun.write(join14(cwd, OUTPUT_ROUTES), STUB_ROUTES);
+  await Bun.write(join14(cwd, OUTPUT_ROUTES_CLIENT), STUB_ROUTES);
+  await Bun.write(join14(cwd, OUTPUT_CONTENT_TS), STUB_CONTENT);
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS), STUB_ARTIFACTS);
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS_CLIENT), STUB_ARTIFACTS_CLIENT);
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS_SERVER), STUB_ARTIFACTS_SERVER);
+  await Bun.write(join14(cwd, OUTPUT_INDEX), STUB_INDEX);
+  await Bun.write(join14(cwd, ".reroute/entry.ts"), stubEntry);
   console.log("[reroute/gen] Initialized stub files");
 }
 function shouldSkipFile(relativePath, entryName) {
@@ -8116,8 +8482,8 @@ async function scanDirectory(dir, base = "") {
   const files = [];
   const entries = await readdir8(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join12(dir, entry.name);
-    const relativePath = join12(base, entry.name);
+    const fullPath = join14(dir, entry.name);
+    const relativePath = join14(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
@@ -8135,8 +8501,8 @@ async function scan404Files(dir, base = "") {
   const files = [];
   const entries = await readdir8(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join12(dir, entry.name);
-    const relativePath = join12(base, entry.name);
+    const fullPath = join14(dir, entry.name);
+    const relativePath = join14(base, entry.name);
     if (entry.isDirectory()) {
       const nested = await scan404Files(fullPath, relativePath);
       files.push(...nested);
@@ -8151,8 +8517,8 @@ async function scanOgFiles(dir, base = "") {
   const files = [];
   const entries = await readdir8(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join12(dir, entry.name);
-    const relativePath = join12(base, entry.name);
+    const fullPath = join14(dir, entry.name);
+    const relativePath = join14(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
@@ -8242,8 +8608,17 @@ function getImportPath(filePath, streamingMap, routesImportBase) {
   const pathWithoutExt = filePath.replace(/\.(tsx|ts)$/, "");
   return `${routesImportBase}/${pathWithoutExt}`;
 }
-function generateTypeScript(tree, streamingMap, client, routesImportBase) {
-  const helperImport = "import { createLazyRoute } from 'reroute-js/react';";
+function lazyRouteFallbackImport(config2) {
+  const value = config2.streaming?.defaultSkeleton;
+  if (typeof value !== "string" || value.trim().length === 0)
+    return;
+  return importFromReroute(value);
+}
+function generateTypeScript(tree, streamingMap, client, routesImportBase, fallbackImport) {
+  const helperImport = fallbackImport ? `import { createLazyRoute } from 'reroute-js/react';
+import LazyRouteFallback from '${fallbackImport}';` : "import { createLazyRoute } from 'reroute-js/react';";
+  const clientFallbackArgs = fallbackImport ? ", undefined, LazyRouteFallback" : "";
+  const serverFallbackArgs = fallbackImport ? ", LazyRouteFallback" : "";
   const ssrHelper = "const _ssr = (m: any) => m.ssr;";
   const metaHelper = "const _meta = (m: any) => m.meta;";
   const metaImports = [
@@ -8267,23 +8642,23 @@ const Layout${i}Meta = _meta(Layout${i}Module);`)
     ...tree.routes.map((r, i) => {
       const importPath = getImportPath(r.filePath, streamingMap, routesImportBase);
       if (client) {
-        return `const Route${i} = createLazyRoute(() => import('${importPath}'), "${r.pattern}");`;
+        return `const Route${i} = createLazyRoute(() => import('${importPath}'), "${r.pattern}"${clientFallbackArgs});`;
       }
-      return `const Route${i} = createLazyRoute(() => import('${importPath}'), "${r.pattern}", Route${i}Eager);`;
+      return `const Route${i} = createLazyRoute(() => import('${importPath}'), "${r.pattern}", Route${i}Eager${serverFallbackArgs});`;
     }),
     ...tree.layouts.map((l, i) => {
       const importPath = getImportPath(l.filePath, streamingMap, routesImportBase);
       if (client) {
-        return `const Layout${i} = createLazyRoute(() => import('${importPath}'), "${l.pattern}");`;
+        return `const Layout${i} = createLazyRoute(() => import('${importPath}'), "${l.pattern}"${clientFallbackArgs});`;
       }
-      return `const Layout${i} = createLazyRoute(() => import('${importPath}'), "${l.pattern}", Layout${i}Eager);`;
+      return `const Layout${i} = createLazyRoute(() => import('${importPath}'), "${l.pattern}", Layout${i}Eager${serverFallbackArgs});`;
     }),
     ...tree.notFoundRoutes.map((nf, i) => {
       const importPath = getImportPath(nf.filePath, streamingMap, routesImportBase);
       if (client) {
-        return `const NotFound${i} = createLazyRoute(() => import('${importPath}'), "${nf.notFoundBasePattern || "/"}");`;
+        return `const NotFound${i} = createLazyRoute(() => import('${importPath}'), "${nf.notFoundBasePattern || "/"}"${clientFallbackArgs});`;
       }
-      return `const NotFound${i} = createLazyRoute(() => import('${importPath}'), "${nf.notFoundBasePattern || "/"}", NotFound${i}Eager);`;
+      return `const NotFound${i} = createLazyRoute(() => import('${importPath}'), "${nf.notFoundBasePattern || "/"}", NotFound${i}Eager${serverFallbackArgs});`;
     })
   ].join(`
 `);
@@ -8420,7 +8795,7 @@ ${client ? "" : `// Set globals for compiled binary support (sitemap/RSS/robots
 `;
 }
 async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
-  const streamingDir = join12(cwd, ".reroute", "streaming");
+  const streamingDir = join14(cwd, ".reroute", "streaming");
   const analyses = new Map;
   const candidates = [
     ...tree.routes.map((route) => ({
@@ -8439,7 +8814,7 @@ async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
   for (const candidate of candidates) {
     if (!/\.(tsx|ts)$/.test(candidate.filePath))
       continue;
-    const absolutePath = join12(routesPath, candidate.filePath);
+    const absolutePath = join14(routesPath, candidate.filePath);
     const analysis = await analyzeRouteForStreaming({
       absolutePath,
       relativePath: candidate.filePath,
@@ -8448,7 +8823,7 @@ async function buildStreamingWrappersForTree(cwd, routesPath, tree, config2) {
     });
     if (!analysis.needsStreaming)
       continue;
-    const wrapperPath = join12(streamingDir, candidate.filePath).replace(/\.(tsx|ts)$/, ".tsx");
+    const wrapperPath = join14(streamingDir, candidate.filePath).replace(/\.(tsx|ts)$/, ".tsx");
     await mkdir3(dirname7(wrapperPath), { recursive: true });
     const code = await generateStreamingWrapper({
       cwd,
@@ -8473,13 +8848,13 @@ function isContentFileName(name) {
 }
 async function listLocaleContentFiles(collectionDir, locale) {
   try {
-    const nested = await readdir8(join12(collectionDir, locale), {
+    const nested = await readdir8(join14(collectionDir, locale), {
       withFileTypes: true
     });
     const files = [];
     for (const n of nested) {
       if (n.isFile() && isContentFileName(n.name)) {
-        files.push({ relativePath: join12(locale, n.name), locale });
+        files.push({ relativePath: join14(locale, n.name), locale });
       }
     }
     return files;
@@ -8517,7 +8892,7 @@ async function loadContentMeta(absSrc, buildSrc, isMarkdown) {
   if (isMarkdown) {
     return processMarkdownFile(absSrc).frontmatter || {};
   }
-  const tmp = join12(dirname7(buildSrc), `.meta-${Date.now()}-${Math.random().toString(36).slice(2)}${extname4(buildSrc)}`);
+  const tmp = join14(dirname7(buildSrc), `.meta-${Date.now()}-${Math.random().toString(36).slice(2)}${extname4(buildSrc)}`);
   try {
     await copyFile2(buildSrc, tmp);
     const m = await import(pathToFileURL8(tmp).href);
@@ -8570,14 +8945,24 @@ ${spaces}}`;
   }
   return serializeValue(config2);
 }
+function imageRuntimeSnippet(config2) {
+  const preprocess = resolveImagePreprocess(config2.image);
+  if (!preprocess.enabled) {
+    return null;
+  }
+  return `(globalThis as any).__REROUTE_IMAGE__ = ${JSON.stringify({
+    sizes: preprocess.widths,
+    quality: preprocess.quality
+  })};`;
+}
 async function buildSingleContentChunk(cwd, collection, fileRef, contentDir, args, defaultLocale) {
   const file = fileRef.relativePath;
   const locale = fileRef.locale || defaultLocale;
   const baseName = file.split("/").pop() || file;
   const name = baseName.replace(/\.(tsx|ts|md|mdx)$/, "");
-  const absSrc = join12(contentDir, file);
+  const absSrc = join14(contentDir, file);
   const isMarkdown = /\.(md|mdx)$/.test(file);
-  const buildSrc = isMarkdown ? join12(cwd, ".reroute", "markdown", collection, "content", file.replace(/\.(md|mdx)$/, ".tsx")) : absSrc;
+  const buildSrc = isMarkdown ? join14(cwd, ".reroute", "markdown", collection, "content", file.replace(/\.(md|mdx)$/, ".tsx")) : absSrc;
   if (isMarkdown) {
     try {
       const exists = await Bun.file(buildSrc).exists();
@@ -8623,11 +9008,11 @@ async function buildSingleContentChunk(cwd, collection, fileRef, contentDir, arg
     return null;
   }
   const hash2 = await sha8(code);
-  const chunkRelDir = join12(".reroute", "bundles");
-  const chunkAbsDir = join12(cwd, chunkRelDir);
+  const chunkRelDir = join14(".reroute", "bundles");
+  const chunkAbsDir = join14(cwd, chunkRelDir);
   const localeSuffix = locale !== defaultLocale ? `${locale}-` : "";
   const outFile = `${collection}-${localeSuffix}${name}.${hash2}.js`;
-  const absOut = join12(chunkAbsDir, outFile);
+  const absOut = join14(chunkAbsDir, outFile);
   if (sourcemapContent) {
     code = code.replace(/\/\/# sourceMappingURL=.*\.js\.map/, `//# sourceMappingURL=${outFile}.map`);
   }
@@ -8660,7 +9045,7 @@ async function buildSingleContentChunk(cwd, collection, fileRef, contentDir, arg
   };
 }
 async function buildContentChunks(cwd, args = [], defaultLocale = "en-US", routesDir) {
-  const routesRoot = join12(cwd, routesDir);
+  const routesRoot = join14(cwd, routesDir);
   console.log(`[reroute/content] scan ${routesRoot}`);
   const collections2 = await readdir8(routesRoot, { withFileTypes: true });
   const results = [];
@@ -8668,7 +9053,7 @@ async function buildContentChunks(cwd, args = [], defaultLocale = "en-US", route
     if (!c.isDirectory())
       continue;
     const collection = c.name;
-    const contentDir = join12(routesRoot, collection, "content");
+    const contentDir = join14(routesRoot, collection, "content");
     console.log(`[reroute/content] collection ${collection} dir ${contentDir}`);
     const files = await listContentFiles2(contentDir);
     console.log(`[reroute/content] files ${files.length}`);
@@ -8720,7 +9105,7 @@ async function buildContentChunks(cwd, args = [], defaultLocale = "en-US", route
   lines.push("");
   const writes = [];
   writes.push({
-    path: join12(cwd, OUTPUT_CONTENT_TS),
+    path: join14(cwd, OUTPUT_CONTENT_TS),
     content: lines.join(`
 `)
   });
@@ -8754,7 +9139,7 @@ async function buildContentChunks(cwd, args = [], defaultLocale = "en-US", route
     js.push("}");
     js.push("");
     writes.push({
-      path: join12(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`),
+      path: join14(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`),
       content: js.join(`
 `)
     });
@@ -8778,7 +9163,7 @@ async function buildSearchIndex(cwd, config2, args = []) {
     minHeadingLevel = 1,
     maxHeadingLevel = 6
   } = searchConfig;
-  const routesRoot = join12(cwd, resolveAppPaths(config2).routesDir);
+  const routesRoot = join14(cwd, resolveAppPaths(config2).routesDir);
   const collections2 = await readdir8(routesRoot, { withFileTypes: true });
   const i18n2 = await discoverI18n(cwd, config2.i18n);
   const defaultLocale = i18n2.defaultLocale;
@@ -8790,7 +9175,7 @@ async function buildSearchIndex(cwd, config2, args = []) {
     if (targetCollections.length > 0 && !targetCollections.includes(collection)) {
       continue;
     }
-    const contentDir = join12(routesRoot, collection, "content");
+    const contentDir = join14(routesRoot, collection, "content");
     try {
       const files = await listContentFiles2(contentDir);
       for (const fileRef of files) {
@@ -8800,7 +9185,7 @@ async function buildSearchIndex(cwd, config2, args = []) {
         const baseName = file.split("/").pop() || file;
         const name = baseName.replace(/\.(md|mdx)$/, "");
         const locale = fileRef.locale || defaultLocale;
-        const filePath = join12(contentDir, file);
+        const filePath = join14(contentDir, file);
         try {
           const processed = processMarkdownFile(filePath);
           const { frontmatter, content: content2 } = processed;
@@ -8848,13 +9233,13 @@ async function buildSearchIndex(cwd, config2, args = []) {
     generated: new Date().toISOString(),
     entries: searchIndex
   };
-  await Bun.write(join12(cwd, OUTPUT_SEARCH_INDEX), JSON.stringify(indexData, null, 2));
-  console.log(`[reroute/search] Generated search index with ${searchIndex.length} entries: ${join12(cwd, OUTPUT_SEARCH_INDEX)}`);
+  await Bun.write(join14(cwd, OUTPUT_SEARCH_INDEX), JSON.stringify(indexData, null, 2));
+  console.log(`[reroute/search] Generated search index with ${searchIndex.length} entries: ${join14(cwd, OUTPUT_SEARCH_INDEX)}`);
 }
 async function preprocessMarkdownFiles(cwd, config2) {
   console.log("[reroute/markdown] Starting markdown preprocessing...");
-  const routesPath = join12(cwd, resolveAppPaths(config2).routesDir);
-  const markdownDir = join12(cwd, ".reroute", "markdown");
+  const routesPath = join14(cwd, resolveAppPaths(config2).routesDir);
+  const markdownDir = join14(cwd, ".reroute", "markdown");
   try {
     await rm(markdownDir, { force: true, recursive: true });
   } catch {}
@@ -8864,8 +9249,8 @@ async function preprocessMarkdownFiles(cwd, config2) {
     try {
       const entries = await readdir8(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join12(dir, entry.name);
-        const relativePath = join12(base, entry.name);
+        const fullPath = join14(dir, entry.name);
+        const relativePath = join14(base, entry.name);
         if (entry.isDirectory()) {
           const nested = await scanMarkdown(fullPath, relativePath);
           files.push(...nested);
@@ -8887,8 +9272,8 @@ async function preprocessMarkdownFiles(cwd, config2) {
   }
   console.log(`[reroute/markdown] Found ${markdownFiles.length} markdown file(s)`);
   for (const file of markdownFiles) {
-    const sourcePath = join12(routesPath, file);
-    const targetPath = join12(markdownDir, file.replace(/\.mdx?$/, ".tsx"));
+    const sourcePath = join14(routesPath, file);
+    const targetPath = join14(markdownDir, file.replace(/\.mdx?$/, ".tsx"));
     try {
       const processed = processMarkdownFile(sourcePath);
       const isMdx = file.endsWith(".mdx");
@@ -8915,9 +9300,9 @@ async function preprocessMarkdownFiles(cwd, config2) {
 async function buildEntrypointBundle(cwd, args = []) {
   const buildStartTime = performance.now();
   const paths = resolveAppPaths(await loadConfig(cwd));
-  const clientDir = join12(cwd, paths.clientDir);
-  const userEntrypoint = join12(clientDir, "index.tsx");
-  const entrypoint = join12(cwd, OUTPUT_CLIENT_ENTRY);
+  const clientDir = join14(cwd, paths.clientDir);
+  const userEntrypoint = join14(clientDir, "index.tsx");
+  const entrypoint = join14(cwd, OUTPUT_CLIENT_ENTRY);
   const exists = await Bun.file(userEntrypoint).exists();
   if (!exists) {
     console.log("[reroute/gen] No index.tsx found, skipping bundle build");
@@ -8929,8 +9314,8 @@ async function buildEntrypointBundle(cwd, args = []) {
     return;
   }
   console.log("[reroute/gen] Building entrypoint bundle...");
-  const isProd = args.includes("--prod");
-  const bundlesDir = join12(cwd, ".reroute", "bundles");
+  const isProd = isProductionMode(args);
+  const bundlesDir = join14(cwd, ".reroute", "bundles");
   await mkdir3(bundlesDir, { recursive: true });
   const mode = isProd ? "production" : "development";
   const publicEnv = getPublicEnvVars(cwd, mode);
@@ -9032,7 +9417,7 @@ async function buildEntrypointBundle(cwd, args = []) {
     const existingFiles = await readdir8(bundlesDir);
     for (const file of existingFiles) {
       if (/^(index|chunk|asset)\.[a-z0-9]+\.(js|css|js\.map|css\.map)(\.gz|\.br)?$/i.test(file) && !newFiles.has(file.replace(/\.(gz|br)$/, ""))) {
-        await rm(join12(bundlesDir, file), { force: true });
+        await rm(join14(bundlesDir, file), { force: true });
       }
     }
   } catch (_error) {}
@@ -9048,7 +9433,7 @@ async function buildEntrypointBundle(cwd, args = []) {
     }
   }
   await Promise.all(outputs.map(async (output) => {
-    const destPath = join12(bundlesDir, output.fileName);
+    const destPath = join14(bundlesDir, output.fileName);
     await Bun.write(destPath, output.content);
     if (shouldPreCompress) {
       const shouldCompress = /\.(js|css)$/i.test(output.fileName) && !output.fileName.endsWith(".map");
@@ -9119,7 +9504,7 @@ async function generate(cwd, args = [], options = {}) {
     await writeStubFiles(cwd, importFromReroute(paths.server));
   }
   await perfTrack("Markdown preprocessing", () => preprocessMarkdownFiles(cwd, config2));
-  const routesPath = join12(cwd, paths.routesDir);
+  const routesPath = join14(cwd, paths.routesDir);
   try {
     await perfTrack("Routes generation", async () => {
       const files = await scanDirectory(routesPath);
@@ -9127,13 +9512,14 @@ async function generate(cwd, args = [], options = {}) {
       const all = Array.from(new Set([...files, ...nfFiles]));
       const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
       const streamingAnalyses = streamingEnabled ? await buildStreamingWrappersForTree(cwd, routesPath, tree, config2) : new Map;
-      const serverRoutes = generateTypeScript(tree, streamingAnalyses, false, routesImportBase);
-      const clientRoutes = generateTypeScript(tree, streamingAnalyses, true, routesImportBase);
-      await Bun.write(join12(cwd, OUTPUT_ROUTES), serverRoutes);
-      await Bun.write(join12(cwd, OUTPUT_ROUTES_CLIENT), clientRoutes);
+      const fallbackImport = lazyRouteFallbackImport(config2);
+      const serverRoutes = generateTypeScript(tree, streamingAnalyses, false, routesImportBase, fallbackImport);
+      const clientRoutes = generateTypeScript(tree, streamingAnalyses, true, routesImportBase, fallbackImport);
+      await Bun.write(join14(cwd, OUTPUT_ROUTES), serverRoutes);
+      await Bun.write(join14(cwd, OUTPUT_ROUTES_CLIENT), clientRoutes);
     });
     if (!showPerformance) {
-      console.log(`[reroute/gen] Generated routes: ${join12(cwd, OUTPUT_ROUTES)} + ${OUTPUT_ROUTES_CLIENT}`);
+      console.log(`[reroute/gen] Generated routes: ${join14(cwd, OUTPUT_ROUTES)} + ${OUTPUT_ROUTES_CLIENT}`);
     }
   } catch (error) {
     console.error("[reroute/gen] Failed to generate routes:", error);
@@ -9142,7 +9528,7 @@ async function generate(cwd, args = [], options = {}) {
   const i18n2 = await discoverI18n(cwd, config2.i18n);
   const defaultLocale = i18n2.defaultLocale;
   try {
-    await Bun.write(join12(cwd, ".reroute", "i18n.json"), JSON.stringify({
+    await Bun.write(join14(cwd, ".reroute", "i18n.json"), JSON.stringify({
       enabled: i18n2.enabled,
       defaultLocale: i18n2.defaultLocale,
       locales: i18n2.locales,
@@ -9159,7 +9545,7 @@ async function generate(cwd, args = [], options = {}) {
   try {
     await perfTrack("Content building", () => buildContentChunks(cwd, args, defaultLocale, paths.routesDir));
     if (!showPerformance) {
-      console.log(`[reroute/gen] Generated content: ${join12(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
+      console.log(`[reroute/gen] Generated content: ${join14(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
     }
   } catch (error) {
     console.error("[reroute/gen] Failed to generate content:", error);
@@ -9167,17 +9553,17 @@ async function generate(cwd, args = [], options = {}) {
   }
   try {
     await perfTrack("Manifest generation", async () => {
-      const routesPath2 = join12(cwd, OUTPUT_ROUTES);
+      const routesPath2 = join14(cwd, OUTPUT_ROUTES);
       const routesModule = await import(`file://${routesPath2}?t=${Date.now()}`);
       const routes = routesModule.routes || [];
       const staticRoutes = routes.filter((r) => !r.params || r.params.length === 0).map((r) => r.pattern);
       const contentRoutes = [];
-      const collectionsDir = join12(cwd, ".reroute", "collections");
+      const collectionsDir = join14(cwd, ".reroute", "collections");
       try {
         const collectionFiles = await readdir8(collectionsDir);
         for (const file of collectionFiles) {
           if (file.endsWith(".js")) {
-            const collectionPath = join12(collectionsDir, file);
+            const collectionPath = join14(collectionsDir, file);
             const collectionModule = await import(`file://${collectionPath}?t=${Date.now()}`);
             const items = collectionModule.items || [];
             for (const item of items) {
@@ -9202,7 +9588,7 @@ async function generate(cwd, args = [], options = {}) {
         dynamicRoutes,
         version: 1
       };
-      await Bun.write(join12(cwd, ".reroute", "manifest.json"), JSON.stringify(manifest, null, 2));
+      await Bun.write(join14(cwd, ".reroute", "manifest.json"), JSON.stringify(manifest, null, 2));
     });
   } catch (error) {
     console.error("[reroute/gen] Failed to generate manifest:", error);
@@ -9223,7 +9609,7 @@ async function generate(cwd, args = [], options = {}) {
     mdComponentsLines.push("");
     mdComponentsLines.push(`import markdownComponents from '${componentsPath}';`);
     mdComponentsLines.push("export { markdownComponents };");
-    await Bun.write(join12(cwd, ".reroute/markdown-components.ts"), mdComponentsLines.join(`
+    await Bun.write(join14(cwd, ".reroute/markdown-components.ts"), mdComponentsLines.join(`
 `));
   }
   const buildArtifactsLines = (routesModule) => {
@@ -9249,7 +9635,7 @@ async function generate(cwd, args = [], options = {}) {
     const ogTemplatePath = config2.ogImage.defaultTemplate.startsWith(".") ? `../${config2.ogImage.defaultTemplate}` : config2.ogImage.defaultTemplate;
     indexLines.push(`import OGTemplate from '${ogTemplatePath}';`);
   }
-  const ogFiles = await scanOgFiles(join12(cwd, paths.routesDir));
+  const ogFiles = await scanOgFiles(join14(cwd, paths.routesDir));
   const ogImports = [];
   for (let i = 0;i < ogFiles.length; i++) {
     const ogFile = ogFiles[i];
@@ -9295,7 +9681,7 @@ async function generate(cwd, args = [], options = {}) {
     }
     indexLines.push("};");
   }
-  const templatePath = join12(cwd, paths.clientDir, "index.html");
+  const templatePath = join14(cwd, paths.clientDir, "index.html");
   try {
     const templateContent = await Bun.file(templatePath).text();
     indexLines.push("");
@@ -9305,6 +9691,10 @@ async function generate(cwd, args = [], options = {}) {
   indexLines.push("");
   indexLines.push("// Bundled config for compiled binary support");
   indexLines.push(`(globalThis as any).__REROUTE_CONFIG__ = ${serializeConfig(config2)};`);
+  const imageRuntime = imageRuntimeSnippet(config2);
+  if (imageRuntime) {
+    indexLines.push(imageRuntime);
+  }
   indexLines.push("");
   indexLines.push("export type RerouteBundle = typeof bundle;");
   indexLines.push("");
@@ -9326,6 +9716,9 @@ async function generate(cwd, args = [], options = {}) {
   clientLines.push("export type RerouteBundle = typeof bundle;");
   clientLines.push("");
   clientLines.push("(globalThis as any).__REROUTE_CLIENT_BUNDLE__ = bundle;");
+  if (imageRuntime) {
+    clientLines.push(imageRuntime);
+  }
   const barrelArtifacts = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
     "// Client bundle entry — lazy routes only",
@@ -9335,11 +9728,11 @@ async function generate(cwd, args = [], options = {}) {
     "export * from './artifacts.client';"
   ].join(`
 `);
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS_SERVER), indexLines.join(`
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS_SERVER), indexLines.join(`
 `));
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS_CLIENT), clientLines.join(`
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS_CLIENT), clientLines.join(`
 `));
-  await Bun.write(join12(cwd, OUTPUT_ARTIFACTS), barrelArtifacts);
+  await Bun.write(join14(cwd, OUTPUT_ARTIFACTS), barrelArtifacts);
   const barrelLines = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
     "// Barrel export for client imports",
@@ -9348,7 +9741,7 @@ async function generate(cwd, args = [], options = {}) {
     "",
     "export * from './artifacts';"
   ];
-  await Bun.write(join12(cwd, OUTPUT_INDEX), barrelLines.join(`
+  await Bun.write(join14(cwd, OUTPUT_INDEX), barrelLines.join(`
 `));
   const entryLines = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
@@ -9364,7 +9757,7 @@ async function generate(cwd, args = [], options = {}) {
     "import './routes'; // Route metadata for compiled binary discovery",
     `import '${importFromReroute(paths.server)}'; // Import user's server entry`
   ];
-  await Bun.write(join12(cwd, ".reroute/entry.ts"), entryLines.join(`
+  await Bun.write(join14(cwd, ".reroute/entry.ts"), entryLines.join(`
 `));
   const clientEntryLines = [
     "// \uD83D\uDEA8 Auto-generated by Reroute - DO NOT EDIT \uD83D\uDEA8",
@@ -9373,14 +9766,17 @@ async function generate(cwd, args = [], options = {}) {
     "// @ts-nocheck",
     "",
     "import './artifacts.client'; // Client bundle (lazy routes)",
-    `import '${importFromReroute(join12(paths.clientDir, "index.tsx"))}'; // User hydration entry`
+    `import '${importFromReroute(join14(paths.clientDir, "index.tsx"))}'; // User hydration entry`
   ];
-  await Bun.write(join12(cwd, OUTPUT_CLIENT_ENTRY), clientEntryLines.join(`
+  await Bun.write(join14(cwd, OUTPUT_CLIENT_ENTRY), clientEntryLines.join(`
 `));
   if (!showPerformance) {
-    console.log(`[reroute/gen] Generated artifacts: ${join12(cwd, OUTPUT_ARTIFACTS)}`);
+    console.log(`[reroute/gen] Generated artifacts: ${join14(cwd, OUTPUT_ARTIFACTS)}`);
   }
   await perfTrack("Bundle building", () => buildEntrypointBundle(cwd, args));
+  if (isProductionMode(args)) {
+    await perfTrack("Image preprocessing", () => runImagePreprocess(cwd, config2));
+  }
   const endTime = performance.now();
   const duration = ((endTime - startTime) / 1000).toFixed(2);
   if (showPerformance) {
@@ -9500,7 +9896,7 @@ async function startGenWatch(cwd, args) {
   const slowDebounce = createDebouncer(300);
   const fingerprint = createContentFingerprint();
   const loadedConfig = await loadConfig(cwd);
-  const configPath = join12(cwd, "reroute.config.ts");
+  const configPath = join14(cwd, "reroute.config.ts");
   let configWatcher = null;
   try {
     configWatcher = watch(configPath, () => {
@@ -9526,7 +9922,7 @@ async function startGenWatch(cwd, args) {
   ];
   const envWatchers = [];
   for (const envFile of envFiles) {
-    const envPath = join12(cwd, envFile);
+    const envPath = join14(cwd, envFile);
     try {
       const envWatcher = watch(envPath, () => {
         mediumDebounce(() => {
@@ -9549,15 +9945,15 @@ async function startGenWatch(cwd, args) {
   let packagesWatcher = null;
   const isRerouteWorkspace = async () => {
     try {
-      const packagesPath = join12(cwd, "..", "..", "packages");
-      const exists = await Bun.file(join12(packagesPath, "core", "index.ts")).exists();
+      const packagesPath = join14(cwd, "..", "..", "packages");
+      const exists = await Bun.file(join14(packagesPath, "core", "index.ts")).exists();
       return exists;
     } catch {
       return false;
     }
   };
   if (await isRerouteWorkspace()) {
-    const packagesPath = join12(cwd, "..", "..", "packages");
+    const packagesPath = join14(cwd, "..", "..", "packages");
     console.log("[reroute/watch] \uD83D\uDD27 Workspace development mode enabled");
     console.log(`[reroute/watch] \uD83D\uDD27 Watching ${packagesPath}...`);
     packagesWatcher = watch(packagesPath, { recursive: true }, (_ev, filename) => {
@@ -9571,7 +9967,7 @@ async function startGenWatch(cwd, args) {
       if (!/\.(tsx|ts|jsx|js)$/.test(name))
         return;
       slowDebounce(() => {
-        fingerprint.changed(join12(packagesPath, name)).then((changed) => {
+        fingerprint.changed(join14(packagesPath, name)).then((changed) => {
           if (!changed)
             return;
           scheduleBuild(async () => {
@@ -9587,7 +9983,7 @@ async function startGenWatch(cwd, args) {
     });
   }
   const watchPaths = resolveAppPaths(loadedConfig);
-  const routesPath = join12(cwd, watchPaths.routesDir);
+  const routesPath = join14(cwd, watchPaths.routesDir);
   console.log(`[reroute/watch] \uD83D\uDCC1 Watching ${routesPath}...`);
   const routesWatcher = watch(routesPath, { recursive: true }, (_ev, filename) => {
     if (!filename)
@@ -9596,7 +9992,7 @@ async function startGenWatch(cwd, args) {
     if (isWatchNoise(name))
       return;
     quickDebounce(() => {
-      fingerprint.changed(join12(routesPath, name)).then((changed) => {
+      fingerprint.changed(join14(routesPath, name)).then((changed) => {
         if (!changed)
           return;
         scheduleBuild(async () => {
@@ -9615,7 +10011,7 @@ async function startGenWatch(cwd, args) {
             console.log("[reroute/watch]   ├─ Building content chunks...");
             const contentStart = performance.now();
             const watchI18n = await discoverI18n(cwd, loadedConfig.i18n);
-            await Bun.write(join12(cwd, ".reroute", "i18n.json"), JSON.stringify({
+            await Bun.write(join14(cwd, ".reroute", "i18n.json"), JSON.stringify({
               enabled: watchI18n.enabled,
               defaultLocale: watchI18n.defaultLocale,
               locales: watchI18n.locales,
@@ -9653,7 +10049,7 @@ async function startGenWatch(cwd, args) {
       });
     });
   });
-  const clientPath = join12(cwd, watchPaths.clientDir);
+  const clientPath = join14(cwd, watchPaths.clientDir);
   console.log(`[reroute/watch] \uD83D\uDCE6 Watching ${clientPath}...`);
   async function rebuildWatchedClient(changed) {
     const label = changed.length === 1 ? changed[0] : `${changed.length} files`;
@@ -9750,6 +10146,7 @@ var OUTPUT_DIR = ".reroute", OUTPUT_ROUTES = ".reroute/routes.ts", OUTPUT_ROUTES
 var init_gen = __esm(() => {
   init_core();
   init_env();
+  init_images();
   init_markdown();
   init_analyzer();
   init_suspense();
@@ -9762,23 +10159,23 @@ var exports_command = {};
 __export(exports_command, {
   getRerouteCommand: () => getRerouteCommand
 });
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join15 } from "node:path";
 function getRerouteCommand() {
-  const binPath = join13(import.meta.dir, "..", "..", "bin.ts");
-  const isBunDev = existsSync6(binPath);
+  const binPath = join15(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync8(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join13(cwd, "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join13(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join15(cwd, "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join15(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
-    if (existsSync6(binPath2)) {
+    if (existsSync8(binPath2)) {
       return binPath2;
     }
   }
@@ -88671,7 +89068,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       out += ">" + text + "</a>";
       return out;
     };
-    _proto.image = function image(href, title, text) {
+    _proto.image = function image2(href, title, text) {
       href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
       if (href === null) {
         return text;
@@ -88712,7 +89109,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     _proto.link = function link(href, title, text) {
       return "" + text;
     };
-    _proto.image = function image(href, title, text) {
+    _proto.image = function image2(href, title, text) {
       return "" + text;
     };
     _proto.br = function br() {
@@ -101853,7 +102250,7 @@ var require_lodash = __commonJS(function(exports, module) {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
       });
-      function join14(array, separator) {
+      function join16(array, separator) {
         return array == null ? "" : nativeJoin.call(array, separator);
       }
       function last(array) {
@@ -103785,7 +104182,7 @@ __p += '`;
       lodash.isUndefined = isUndefined;
       lodash.isWeakMap = isWeakMap;
       lodash.isWeakSet = isWeakSet;
-      lodash.join = join14;
+      lodash.join = join16;
       lodash.kebabCase = kebabCase;
       lodash.last = last;
       lodash.lastIndexOf = lastIndexOf;
@@ -104466,8 +104863,8 @@ __export(exports_dev, {
   default: () => dev
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join16 } from "node:path";
 import { pathToFileURL as pathToFileURL9 } from "node:url";
 function parsePort(args) {
   const portIndex = args.findIndex((arg) => arg === "--port" || arg === "-p");
@@ -104499,11 +104896,12 @@ async function waitForInitialBuild(genProcess) {
   console.log("[reroute/dev] Initial build complete!");
   return outputBuffer;
 }
-async function startTui(port) {
+async function startTui(port, args) {
   const rerouteCmd = getRerouteCommand();
   const useShell = rerouteCmd.includes(" ");
-  const genCommand = useShell ? `${rerouteCmd} gen --watch` : rerouteCmd;
-  const genArgs = useShell ? [] : ["gen", "--watch"];
+  const prodArgs = isProductionMode(args) ? ["--prod"] : [];
+  const genCommand = useShell ? `${rerouteCmd} gen --watch ${prodArgs.join(" ")}`.trim() : rerouteCmd;
+  const genArgs = useShell ? [] : ["gen", "--watch", ...prodArgs];
   const genProcess = spawn(genCommand, genArgs, {
     stdio: ["ignore", "pipe", "pipe"],
     shell: useShell,
@@ -104552,13 +104950,13 @@ async function startTui(port) {
   const { setupTerminalUIHandlers: setupTerminalUIHandlers2 } = await Promise.resolve().then(() => exports_terminal_ui);
   setupTerminalUIHandlers2(screen, grid, genProcess, serverProcess, outputBuffer, blessed, colorizeLogPrefix, server2);
 }
-async function startDefault(port) {
+async function startDefault(port, args) {
   process.env.PORT = String(port);
   process.env.REROUTE_DEV = "1";
-  const session = await startGenWatch(process.cwd(), ["--watch"]);
+  const session = await startGenWatch(process.cwd(), genWatchArgs(args));
   const { server: server2 } = resolveAppPaths(await loadConfig(process.cwd()));
-  const entry = join14(process.cwd(), server2);
-  if (!existsSync7(entry)) {
+  const entry = join16(process.cwd(), server2);
+  if (!existsSync9(entry)) {
     session.close();
     throw new Error(`[reroute/dev] Missing ${entry}`);
   }
@@ -104582,6 +104980,9 @@ async function startDefault(port) {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
+function genWatchArgs(args) {
+  return isProductionMode(args) ? ["--watch", "--prod"] : ["--watch"];
+}
 async function dev(args) {
   const terminalUI = args.includes("--tui") || args.includes("-t");
   const port = parsePort(args);
@@ -104596,10 +104997,10 @@ async function dev(args) {
     console.log(`[reroute/dev] Press Ctrl+C to stop
 `);
     if (terminalUI) {
-      await startTui(port);
+      await startTui(port, args);
       return;
     }
-    await startDefault(port);
+    await startDefault(port, args);
   } catch (error) {
     if (error.code === "SIGINT") {
       console.log(`
@@ -104623,23 +105024,23 @@ __export(exports_start, {
   default: () => start
 });
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join17 } from "node:path";
 function getRerouteCommand2() {
-  const binPath = join15(import.meta.dir, "..", "..", "bin.ts");
-  const isBunDev = existsSync8(binPath);
+  const binPath = join17(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync10(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join15(cwd, "node_modules", ".bin", "reroute"),
-    join15(cwd, "..", "node_modules", ".bin", "reroute"),
-    join15(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join15(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join17(cwd, "node_modules", ".bin", "reroute"),
+    join17(cwd, "..", "node_modules", ".bin", "reroute"),
+    join17(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join17(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
-    if (existsSync8(binPath2)) {
+    if (existsSync10(binPath2)) {
       return binPath2;
     }
   }
@@ -104762,17 +105163,17 @@ var init_start = __esm(() => {
 // packages/cli/src/commands/lib/assets.ts
 import {
   cpSync,
-  existsSync as existsSync9,
+  existsSync as existsSync11,
   mkdirSync,
-  readdirSync as readdirSync2
+  readdirSync as readdirSync3
 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join18 } from "node:path";
 function copyAssetsToReroute(cwd, sourceAssetsDir, rerouteAssetsDir) {
-  if (!existsSync9(sourceAssetsDir)) {
+  if (!existsSync11(sourceAssetsDir)) {
     return 0;
   }
-  const rerouteDir = join16(cwd, ".reroute");
-  if (!existsSync9(rerouteDir)) {
+  const rerouteDir = join18(cwd, ".reroute");
+  if (!existsSync11(rerouteDir)) {
     mkdirSync(rerouteDir, { recursive: true });
   }
   cpSync(sourceAssetsDir, rerouteAssetsDir, { recursive: true });
@@ -104780,10 +105181,10 @@ function copyAssetsToReroute(cwd, sourceAssetsDir, rerouteAssetsDir) {
 }
 function countFiles(dir) {
   let count = 0;
-  const entries = readdirSync2(dir, { withFileTypes: true });
+  const entries = readdirSync3(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      count += countFiles(join16(dir, entry.name));
+      count += countFiles(join18(dir, entry.name));
     } else {
       count++;
     }
@@ -104798,23 +105199,23 @@ __export(exports_build, {
   default: () => build
 });
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync5, rmSync, unlinkSync } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync5, rmSync, unlinkSync } from "node:fs";
+import { join as join19 } from "node:path";
 function getRerouteCommand3() {
-  const binPath = join17(import.meta.dir, "..", "..", "bin.ts");
-  const isBunDev = existsSync10(binPath);
+  const binPath = join19(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync12(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join17(cwd, "node_modules", ".bin", "reroute"),
-    join17(cwd, "..", "node_modules", ".bin", "reroute"),
-    join17(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join17(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join19(cwd, "node_modules", ".bin", "reroute"),
+    join19(cwd, "..", "node_modules", ".bin", "reroute"),
+    join19(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join19(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
-    if (existsSync10(binPath2)) {
+    if (existsSync12(binPath2)) {
       return binPath2;
     }
   }
@@ -104822,8 +105223,8 @@ function getRerouteCommand3() {
 }
 function getOutputName() {
   const cwd = process.cwd();
-  const packageJsonPath = join17(cwd, "package.json");
-  if (existsSync10(packageJsonPath)) {
+  const packageJsonPath = join19(cwd, "package.json");
+  if (existsSync12(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
       const name = packageJson.name;
@@ -104854,16 +105255,16 @@ function parseBuildArgs(args) {
   return { outfile, compileBinary, noCompression, externalArgs };
 }
 function cleanDistFolder(cwd) {
-  const distDir = join17(cwd, "dist");
-  if (existsSync10(distDir)) {
+  const distDir = join19(cwd, "dist");
+  if (existsSync12(distDir)) {
     process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Cleaning dist folder...
 `));
     rmSync(distDir, { recursive: true });
   }
 }
 async function cleanRerouteFolder(cwd) {
-  const rerouteDir = join17(cwd, ".reroute");
-  if (existsSync10(rerouteDir)) {
+  const rerouteDir = join19(cwd, ".reroute");
+  if (existsSync12(rerouteDir)) {
     process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Cleaning .reroute folder...
 `));
     rmSync(rerouteDir, { recursive: true, force: true });
@@ -104917,8 +105318,8 @@ async function runGenCommand(rerouteCmd, useShell, noCompression) {
 async function copyAssets(cwd) {
   const config2 = await loadConfig(cwd);
   const { assetsDir } = resolveAppPaths(config2);
-  const sourceAssetsDir = join17(cwd, assetsDir);
-  const rerouteAssetsDir = join17(cwd, ".reroute", "assets");
+  const sourceAssetsDir = join19(cwd, assetsDir);
+  const rerouteAssetsDir = join19(cwd, ".reroute", "assets");
   process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Copying assets...
 `));
   const fileCount = copyAssetsToReroute(cwd, sourceAssetsDir, rerouteAssetsDir);
@@ -104933,9 +105334,9 @@ async function copyAssets(cwd) {
 async function buildBundle(cwd, buildArgs) {
   const external = [...buildArgs.externalArgs, "sharp", "@vercel/og"];
   const buildResult = await Bun.build({
-    entrypoints: [join17(cwd, ".reroute/entry.ts")],
+    entrypoints: [join19(cwd, ".reroute/entry.ts")],
     target: "bun",
-    outdir: join17(cwd, "dist"),
+    outdir: join19(cwd, "dist"),
     sourcemap: "external",
     ...getCommonBuildOptions(),
     external,
@@ -104982,8 +105383,8 @@ function cleanupBundledFiles(rerouteDir) {
     "markdown-components.ts"
   ];
   for (const file of tsFilesToRemove) {
-    const filePath = join17(rerouteDir, file);
-    if (existsSync10(filePath)) {
+    const filePath = join19(rerouteDir, file);
+    if (existsSync12(filePath)) {
       try {
         unlinkSync(filePath);
         cleanupCount++;
@@ -104992,8 +105393,8 @@ function cleanupBundledFiles(rerouteDir) {
   }
   const dirsToRemove = ["markdown", "streaming"];
   for (const dir of dirsToRemove) {
-    const dirPath = join17(rerouteDir, dir);
-    if (existsSync10(dirPath)) {
+    const dirPath = join19(rerouteDir, dir);
+    if (existsSync12(dirPath)) {
       try {
         rmSync(dirPath, { recursive: true });
         cleanupCount++;
@@ -105025,8 +105426,9 @@ async function build(args) {
     const useShell = rerouteCmd.includes(" ");
     await runGenCommand(rerouteCmd, useShell, buildArgs.noCompression);
     await copyAssets(cwd);
+    await runImagePreprocess(cwd, await loadConfig(cwd));
     await buildBundle(cwd, buildArgs);
-    const rerouteDir = join17(cwd, ".reroute");
+    const rerouteDir = join19(cwd, ".reroute");
     cleanupBundledFiles(rerouteDir);
     logBuildComplete(buildStartTime, buildArgs);
     process.exit(0);
@@ -105039,6 +105441,7 @@ async function build(args) {
 var init_build = __esm(() => {
   init_core();
   init_assets();
+  init_images();
   init_log();
 });
 
@@ -105047,25 +105450,25 @@ var exports_analyze = {};
 __export(exports_analyze, {
   default: () => analyze
 });
-import { existsSync as existsSync11, statSync } from "node:fs";
+import { existsSync as existsSync13, statSync } from "node:fs";
 import { readdir as readdir9, readFile as readFile2, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename4, join as join18, relative as relative3 } from "node:path";
+import { basename as basename4, join as join20, relative as relative3 } from "node:path";
 import Table from "cli-table3";
 async function findChunkBundles(cwd) {
   const bundles = [];
-  const chunksDir = join18(cwd, ".reroute", "chunks");
-  if (!existsSync11(chunksDir))
+  const chunksDir = join20(cwd, ".reroute", "chunks");
+  if (!existsSync13(chunksDir))
     return bundles;
   const collections2 = await readdir9(chunksDir, { withFileTypes: true });
   for (const collection of collections2) {
     if (!collection.isDirectory())
       continue;
-    const collectionDir = join18(chunksDir, collection.name);
+    const collectionDir = join20(chunksDir, collection.name);
     const files = await readdir9(collectionDir);
     for (const file of files) {
       if (!file.endsWith(".js"))
         continue;
-      const filePath = join18(collectionDir, file);
+      const filePath = join20(collectionDir, file);
       const stats = await stat6(filePath);
       const content2 = await Bun.file(filePath).arrayBuffer();
       const gzippedSize = Bun.gzipSync(new Uint8Array(content2)).length;
@@ -105083,12 +105486,12 @@ async function findChunkBundles(cwd) {
 }
 async function findDistBundles(cwd) {
   const bundles = [];
-  const distDir = join18(cwd, "dist");
-  if (!existsSync11(distDir))
+  const distDir = join20(cwd, "dist");
+  if (!existsSync13(distDir))
     return bundles;
   const files = await readdir9(distDir);
   for (const file of files) {
-    const filePath = join18(distDir, file);
+    const filePath = join20(distDir, file);
     const stats = statSync(filePath);
     if (stats.isFile() && !file.endsWith(".map") && !file.endsWith(".d.ts")) {
       const content2 = await Bun.file(filePath).arrayBuffer();
@@ -105114,13 +105517,13 @@ async function findBundles(cwd) {
 }
 async function findBrowserEntry(cwd) {
   try {
-    const clientDir = join18(cwd, resolveAppPaths(await loadConfig(cwd)).clientDir);
-    const tsxEntry = join18(clientDir, "index.tsx");
-    const tsEntry = join18(clientDir, "index.ts");
+    const clientDir = join20(cwd, resolveAppPaths(await loadConfig(cwd)).clientDir);
+    const tsxEntry = join20(clientDir, "index.tsx");
+    const tsEntry = join20(clientDir, "index.ts");
     let sourceEntry = null;
-    if (existsSync11(tsxEntry)) {
+    if (existsSync13(tsxEntry)) {
       sourceEntry = tsxEntry;
-    } else if (existsSync11(tsEntry)) {
+    } else if (existsSync13(tsEntry)) {
       sourceEntry = tsEntry;
     }
     if (!sourceEntry)
@@ -105149,12 +105552,12 @@ async function findBrowserEntry(cwd) {
       console.warn("[reroute/analyze] Browser build produced no outputs");
       return null;
     }
-    const tempDir = join18(cwd, ".reroute", "browser");
+    const tempDir = join20(cwd, ".reroute", "browser");
     await import("node:fs/promises").then((fs) => fs.mkdir(tempDir, { recursive: true }));
     const output = result.outputs[0];
     const code = await output.text();
     const actualHash = await generateContentHash2(code);
-    const bundlePath = join18(tempDir, `index.${actualHash}.js`);
+    const bundlePath = join20(tempDir, `index.${actualHash}.js`);
     await writeFile2(bundlePath, code, "utf-8");
     const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
     if (mapOutput) {
@@ -105206,8 +105609,8 @@ function calculateStats(bundles) {
 }
 async function getInstalledPackageSizes(cwd) {
   const packageSizes = new Map;
-  const nodeModulesDir = join18(cwd, "node_modules");
-  if (!existsSync11(nodeModulesDir))
+  const nodeModulesDir = join20(cwd, "node_modules");
+  if (!existsSync13(nodeModulesDir))
     return packageSizes;
   try {
     const { execSync } = await import("node:child_process");
@@ -105245,7 +105648,7 @@ async function getInstalledPackageSizes(cwd) {
 }
 async function buildDependencyTree(entryPath, cwd) {
   try {
-    if (!existsSync11(entryPath))
+    if (!existsSync13(entryPath))
       return null;
     const root = {
       name: basename4(entryPath),
@@ -105262,7 +105665,7 @@ async function buildDependencyTree(entryPath, cwd) {
         if (!pkgNode) {
           pkgNode = {
             name: pkgName || "unknown",
-            path: join18(cwd, "node_modules", pkgName || ""),
+            path: join20(cwd, "node_modules", pkgName || ""),
             size: 0,
             children: []
           };
@@ -105283,7 +105686,7 @@ async function buildDependencyTree(entryPath, cwd) {
           if (!child) {
             child = {
               name: part,
-              path: join18(cwd, ...parts.slice(0, i + 1)),
+              path: join20(cwd, ...parts.slice(0, i + 1)),
               size: 0,
               children: []
             };
@@ -105314,7 +105717,7 @@ async function buildDependencyTree(entryPath, cwd) {
       const modulePattern = /\/\/\s*(.+?\.(?:ts|tsx|js|jsx|mjs|cjs))\s*$/gm;
       const nodeModulesNode = {
         name: "node_modules",
-        path: join18(cwd, "node_modules"),
+        path: join20(cwd, "node_modules"),
         size: 0,
         children: []
       };
@@ -105380,7 +105783,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
       if (sourcePath.startsWith("/") || sourcePath.match(/^[A-Za-z]:\\/))
         return sourcePath;
       const bundleDir = bundlePath.substring(0, bundlePath.lastIndexOf("/"));
-      return join18(bundleDir, sourceRoot || "", sourcePath);
+      return join20(bundleDir, sourceRoot || "", sourcePath);
     }, computeSizes = function(node) {
       if (node.children && node.children.length > 0) {
         node.size = node.children.reduce((s, c) => s + computeSizes(c), 0);
@@ -105388,7 +105791,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
       return node.size;
     };
     const mapPath = `${bundlePath}.map`;
-    if (!existsSync11(mapPath))
+    if (!existsSync13(mapPath))
       return null;
     const [bundle, mapJson] = await Promise.all([
       readFile2(bundlePath, "utf-8"),
@@ -105452,7 +105855,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
     };
     const nodeModulesNode = {
       name: "node_modules",
-      path: join18(cwd, "node_modules"),
+      path: join20(cwd, "node_modules"),
       size: 0,
       children: []
     };
@@ -105492,7 +105895,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
         if (!pkgNode) {
           pkgNode = {
             name: pkgName || "unknown",
-            path: join18(cwd, "node_modules", pkgName || ""),
+            path: join20(cwd, "node_modules", pkgName || ""),
             size: 0,
             children: []
           };
@@ -105513,7 +105916,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
           if (!child) {
             child = {
               name: part,
-              path: join18(cwd, ...parts.slice(0, i2 + 1)),
+              path: join20(cwd, ...parts.slice(0, i2 + 1)),
               size: 0,
               children: []
             };
@@ -105543,11 +105946,11 @@ async function generateHTMLReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join18(process.cwd(), "dist");
-    if (existsSync11(distDir)) {
+    const distDir = join20(process.cwd(), "dist");
+    if (existsSync13(distDir)) {
       const files = await readdir9(distDir);
       for (const file of files) {
-        const filePath = join18(distDir, file);
+        const filePath = join20(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
@@ -107029,11 +107432,11 @@ async function printConsoleReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join18(process.cwd(), "dist");
-    if (existsSync11(distDir)) {
+    const distDir = join20(process.cwd(), "dist");
+    if (existsSync13(distDir)) {
       const files = await readdir9(distDir);
       for (const file of files) {
-        const filePath = join18(distDir, file);
+        const filePath = join20(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
@@ -107067,8 +107470,8 @@ async function analyze(args) {
     const isProd = isProductionMode(args);
     const searchIndex = args.indexOf("--search");
     const initialSearch = searchIndex !== -1 && args[searchIndex + 1] ? args[searchIndex + 1] : "";
-    const rerouteIndexPath = join18(cwd, ".reroute", "index.ts");
-    if (!existsSync11(rerouteIndexPath)) {
+    const rerouteIndexPath = join20(cwd, ".reroute", "index.ts");
+    if (!existsSync13(rerouteIndexPath)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] .reroute artifacts not found, running build...
 `));
       const { spawn: spawn4 } = await import("node:child_process");
@@ -107130,12 +107533,12 @@ async function analyze(args) {
     let entry = null;
     let depTree = null;
     let mainInfo = null;
-    const srcEntry = join18(cwd, resolveAppPaths(await loadConfig(cwd)).server);
-    if (existsSync11(srcEntry)) {
+    const srcEntry = join20(cwd, resolveAppPaths(await loadConfig(cwd)).server);
+    if (existsSync13(srcEntry)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building server binary for analysis...
 `));
       const { mkdir: mkdir4 } = await import("node:fs/promises");
-      const serverAnalysisDir = join18(cwd, ".reroute", "server");
+      const serverAnalysisDir = join20(cwd, ".reroute", "server");
       await mkdir4(serverAnalysisDir, { recursive: true });
       const result = await Bun.build({
         entrypoints: [srcEntry],
@@ -107148,7 +107551,7 @@ async function analyze(args) {
       if (result.success && result.outputs.length > 0) {
         const output = result.outputs[0];
         const code = await output.text();
-        const analysisEntry = join18(serverAnalysisDir, "index.js");
+        const analysisEntry = join20(serverAnalysisDir, "index.js");
         await writeFile2(analysisEntry, code, "utf-8");
         const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
         if (mapOutput) {
@@ -107166,8 +107569,8 @@ async function analyze(args) {
 `));
       const installedSizes = await getInstalledPackageSizes(cwd);
       if (depTree) {
-        const packageJsonPath = join18(cwd, "package.json");
-        if (existsSync11(packageJsonPath)) {
+        const packageJsonPath = join20(cwd, "package.json");
+        if (existsSync13(packageJsonPath)) {
           try {
             const packageJson = JSON.parse(await readFile2(packageJsonPath, "utf-8"));
             const runtimeDeps = packageJson.dependencies || {};
@@ -107178,7 +107581,7 @@ async function analyze(args) {
                 if (!trackedPkgs.has(pkgName) && installedSizes.has(pkgName)) {
                   nodeModulesNode.children?.push({
                     name: pkgName,
-                    path: join18(cwd, "node_modules", pkgName),
+                    path: join20(cwd, "node_modules", pkgName),
                     size: installedSizes.get(pkgName) || 0
                   });
                 }
@@ -107209,10 +107612,10 @@ async function analyze(args) {
     const fullOutput = args.includes("--full");
     await printConsoleReport(stats, depTree, mainInfo, browserDepTree, browserInfo, fullOutput);
     if (outputHtml || openBrowser) {
-      const htmlPath = join18(cwd, ".reroute", "analysis.html");
+      const htmlPath = join20(cwd, ".reroute", "analysis.html");
       const html2 = await generateHTMLReport(stats, depTree, mainInfo, browserDepTree, browserInfo, initialSearch);
       const { mkdir: mkdir4 } = await import("node:fs/promises");
-      await mkdir4(join18(cwd, ".reroute"), { recursive: true });
+      await mkdir4(join20(cwd, ".reroute"), { recursive: true });
       await writeFile2(htmlPath, html2, "utf-8");
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] HTML report generated: ${relative3(cwd, htmlPath)}
 `));
@@ -107277,7 +107680,7 @@ __export(exports_og, {
 });
 import { spawn as spawn4 } from "node:child_process";
 import { readdir as readdir10 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 function getPortFromConfig(baseUrl) {
   if (!baseUrl)
     return 3000;
@@ -107356,8 +107759,8 @@ async function scanForOgTemplates(dir, base, routes) {
   try {
     const entries = await readdir10(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join19(dir, entry.name);
-      const relativePath = join19(base, entry.name);
+      const fullPath = join21(dir, entry.name);
+      const relativePath = join21(base, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "content")
           continue;
@@ -107378,7 +107781,7 @@ async function addContentRoutes(routesPath, routes) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const contentDir = join19(routesPath, entry.name, "content");
+      const contentDir = join21(routesPath, entry.name, "content");
       try {
         const contentFiles = await readdir10(contentDir);
         if (contentFiles.length === 0)
@@ -107395,7 +107798,7 @@ async function addContentRoutes(routesPath, routes) {
 async function findRoutesWithOG(cwd) {
   const routes = [];
   try {
-    const manifestPath = join19(cwd, ".reroute", "manifest.json");
+    const manifestPath = join21(cwd, ".reroute", "manifest.json");
     const manifestFile = Bun.file(manifestPath);
     const manifest = await manifestFile.json();
     if (manifest.staticRoutes && Array.isArray(manifest.staticRoutes)) {
@@ -107406,7 +107809,7 @@ async function findRoutesWithOG(cwd) {
     }
   } catch {
     console.warn("⚠️  .reroute/manifest.json not found, scanning routes directory...");
-    const routesPath = join19(cwd, resolveAppPaths(await loadConfig(cwd)).routesDir);
+    const routesPath = join21(cwd, resolveAppPaths(await loadConfig(cwd)).routesDir);
     await scanForOgTemplates(routesPath, "", routes);
     await addContentRoutes(routesPath, routes);
   }
@@ -107584,7 +107987,7 @@ async function main() {
   }
   try {
     const commandArgs = args.slice(1);
-    if (commandArgs.includes("--prod")) {
+    if (commandArgs.includes("--prod") || commandArgs.includes("--production")) {
       process.env.NODE_ENV = "production";
       if (typeof Bun !== "undefined") {
         Bun.env.NODE_ENV = "production";
@@ -107657,7 +108060,7 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "1.0.0-alpha.21";
+    return "1.0.0-alpha.23";
   }
   const possiblePaths = [
     path3.join(import.meta.dir, "../../../package.json"),
@@ -107674,10 +108077,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "4f2f6a2";
+    return "97c7664";
   }
   return "dev";
 }
 main();
 
-//# debugId=7B5C9322E7E8806B64756E2164756E21
+//# debugId=03F389A2271BD14D64756E2164756E21