@stacksjs/stx 0.2.95 → 0.2.97

package/dist/image-optimization/directive.js

@@ -1,2 +1,203 @@
-// @bun
-import{am as a,bm as b,cm as c}from"../chunk-5f43yz6z.js";import"../chunk-4d2y57k7.js";import"../chunk-h5jxydqq.js";import"../chunk-xv34zbp4.js";export{c as imageDirective,b as createImageDirective,a as clearImageCache};
+import { defineDirective } from "../directive-api.js";
+import {
+  DEFAULT_FORMATS,
+  DEFAULT_QUALITY,
+  DEFAULT_WIDTHS,
+  processImage,
+  generateSrcSet,
+  getMimeType,
+  isImageFile,
+  isImageBackendAvailable
+} from "./processor.js";
+const imageCache = new Map;
+export function clearImageCache() {
+  imageCache.clear();
+}
+async function getCachedImage(src, options) {
+  const cacheKey = `${src}:${JSON.stringify(options)}`;
+  if (imageCache.has(cacheKey))
+    return imageCache.get(cacheKey);
+  try {
+    const processed = await processImage(src, options);
+    imageCache.set(cacheKey, processed);
+    return processed;
+  } catch {
+    return null;
+  }
+}
+export function createImageDirective() {
+  return defineDirective({
+    name: "image",
+    hasEndTag: !1,
+    description: "Render an optimized image with responsive variants",
+    transform: async (content, params, context) => {
+      const { src, alt, options } = parseImageArgs(content, params, context);
+      if (!src) {
+        console.warn("@image directive: missing src argument");
+        return "<!-- @image: missing src -->";
+      }
+      const imageOptions = {
+        widths: options.widths || (options.width ? [options.width] : DEFAULT_WIDTHS),
+        formats: options.formats || DEFAULT_FORMATS,
+        quality: options.quality || DEFAULT_QUALITY,
+        placeholder: (options.placeholder === "color" ? "dominant-color" : options.placeholder) || "none"
+      };
+      if (!await isImageBackendAvailable())
+        return renderSimpleImage(src, alt || "", options);
+      const processed = await getCachedImage(src, imageOptions);
+      if (!processed)
+        return renderSimpleImage(src, alt || "", options);
+      return renderOptimizedImage(processed, alt || "", options);
+    }
+  });
+}
+function parseImageArgs(content, params, context) {
+  if (params.src)
+    return {
+      src: String(params.src),
+      alt: String(params.alt || ""),
+      options: params.options || {}
+    };
+  let args = content.trim();
+  if (args.startsWith("@image(") || args.startsWith("("))
+    args = args.replace(/^@image\(/, "").replace(/^\(/, "").replace(/\)$/, "");
+  const parsed = parseArguments(args);
+  let src = parsed[0] || "", alt = parsed[1] || "", options = {};
+  if (src && !src.startsWith("/") && !src.startsWith(".") && !src.startsWith("http")) {
+    const contextValue = context[src];
+    if (typeof contextValue === "string")
+      src = contextValue;
+  }
+  if (parsed[2])
+    try {
+      if (typeof parsed[2] === "string")
+        options = JSON.parse(parsed[2]);
+      else
+        options = parsed[2];
+    } catch {}
+  return { src, alt, options };
+}
+function parseArguments(argsStr) {
+  const args = [];
+  let current = "", inString = !1, stringChar = "", braceDepth = 0, bracketDepth = 0;
+  for (let i = 0;i < argsStr.length; i++) {
+    const char = argsStr[i], prevChar = i > 0 ? argsStr[i - 1] : "";
+    if ((char === '"' || char === "'") && prevChar !== "\\") {
+      if (!inString) {
+        inString = !0;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = !1;
+        stringChar = "";
+      } else
+        current += char;
+      continue;
+    }
+    if (!inString) {
+      if (char === "{")
+        braceDepth++;
+      if (char === "}")
+        braceDepth--;
+      if (char === "[")
+        bracketDepth++;
+      if (char === "]")
+        bracketDepth--;
+      if (char === "," && braceDepth === 0 && bracketDepth === 0) {
+        args.push(current.trim());
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.trim())
+    args.push(current.trim());
+  return args;
+}
+function renderSimpleImage(src, alt, options) {
+  const attrs = [`src="${escapeAttr(src)}"`];
+  if (alt)
+    attrs.push(`alt="${escapeAttr(alt)}"`);
+  if (options.width)
+    attrs.push(`width="${options.width}"`);
+  if (options.height)
+    attrs.push(`height="${options.height}"`);
+  if (options.class)
+    attrs.push(`class="${escapeAttr(options.class)}"`);
+  if (options.style)
+    attrs.push(`style="${escapeAttr(options.style)}"`);
+  if (options.lazy !== !1)
+    attrs.push('loading="lazy"');
+  attrs.push('decoding="async"');
+  return `<img ${attrs.join(" ")} />`;
+}
+function renderOptimizedImage(processed, alt, options) {
+  const { variants, placeholder, width, height, aspectRatio } = processed, byFormat = new Map;
+  for (const variant of variants) {
+    const existing = byFormat.get(variant.format) || [];
+    existing.push(variant);
+    byFormat.set(variant.format, existing);
+  }
+  const formatOrder = ["avif", "webp", "jpeg", "png"], sources = [];
+  for (const format of formatOrder) {
+    const formatVariants = byFormat.get(format);
+    if (formatVariants && formatVariants.length > 0) {
+      const srcset = generateSrcSet(formatVariants), mimeType = getMimeType(format), sizes = options.sizes || "100vw";
+      sources.push(`  <source type="${mimeType}" srcset="${escapeAttr(srcset)}" sizes="${escapeAttr(sizes)}" />`);
+    }
+  }
+  const jpegs = byFormat.get("jpeg") || [], fallback = jpegs.length > 0 ? jpegs[Math.floor(jpegs.length / 2)] : variants[Math.floor(variants.length / 2)], imgAttrs = [
+    `src="${fallback?.url || processed.src}"`,
+    `alt="${escapeAttr(alt)}"`
+  ];
+  if (options.width || width)
+    imgAttrs.push(`width="${options.width || width}"`);
+  if (options.height || height)
+    imgAttrs.push(`height="${options.height || height}"`);
+  if (options.class)
+    imgAttrs.push(`class="${escapeAttr(options.class)}"`);
+  const styles = [];
+  if (aspectRatio)
+    styles.push(`aspect-ratio: ${aspectRatio.toFixed(4)}`);
+  if (options.style)
+    styles.push(options.style);
+  if (styles.length > 0)
+    imgAttrs.push(`style="${styles.join("; ")}"`);
+  if (options.lazy !== !1 && !options.priority)
+    imgAttrs.push('loading="lazy"');
+  imgAttrs.push('decoding="async"');
+  if (options.priority)
+    imgAttrs.push('fetchpriority="high"');
+  let html = `<picture>
+`;
+  html += sources.join(`
+`) + `
+`;
+  html += `  <img ${imgAttrs.join(" ")} />
+`;
+  html += "</picture>";
+  if (options.placeholder && placeholder) {
+    const wrapperId = `stx-img-${Math.random().toString(36).slice(2, 8)}`;
+    if (options.placeholder === "blur" || options.placeholder === "thumbhash") {
+      const safeUrl = placeholder.replace(/'/g, "%27").replace(/"/g, "%22");
+      html = `<div id="${wrapperId}" class="stx-image-placeholder" style="background-image: url('${safeUrl}'); background-size: cover;">
+${html}
+</div>`;
+    } else if (options.placeholder === "color") {
+      const safeColor = placeholder.replace(/[^a-zA-Z0-9#(),.\s%-]/g, "");
+      html = `<div id="${wrapperId}" class="stx-image-placeholder" style="background-color: ${safeColor};">
+${html}
+</div>`;
+    }
+  }
+  if (options.priority && fallback) {
+    const preloadMime = getMimeType(fallback.format);
+    html = `<link rel="preload" as="image" href="${escapeAttr(fallback.url)}" type="${preloadMime}" />
+` + html;
+  }
+  return html;
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#039;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export const imageDirective = createImageDirective();

package/dist/image-optimization/index.js

@@ -1,2 +1,54 @@
-// @bun
-import{$l as E}from"../chunk-wfg2gm11.js";import{am as w,bm as x,cm as y}from"../chunk-5f43yz6z.js";import{dm as r,em as s}from"../chunk-yrsb6j3z.js";import{Dm as q}from"../chunk-zf2pek72.js";import{Em as z,Fm as A,Gm as B,Hm as C,Im as D}from"../chunk-p1h8065h.js";import{Jm as t,Km as u,Lm as v}from"../chunk-p3e0cqtt.js";import{$m as o,Mm as a,Nm as b,Om as c,Pm as d,Qm as e,Rm as f,Sm as g,Um as h,Vm as i,Wm as j,Xm as k,Ym as l,Zm as m,_m as n,an as p}from"../chunk-4d2y57k7.js";import"../chunk-h5jxydqq.js";import"../chunk-xv34zbp4.js";export{D as writeImageManifest,q as rewriteImagesWithSiblings,t as renderImageComponent,v as processImageComponents,f as processImage,u as parseImageComponent,A as optimizeImage,B as optimizeDirectory,d as isSharpAvailable,l as isImageFile,e as isImageBackendAvailable,y as imageDirective,r as handleImageRequest,k as groupVariantsByFormat,n as getTotalSize,m as getMimeType,g as getImageMetadata,j as getFallbackVariant,h as generateSrcSet,i as generateSizes,C as generateImageManifest,o as formatSize,E as defaultImageConfig,z as createImagePlugin,s as createImageHandler,x as createImageDirective,w as clearImageCache,p as ImageProcessingError,a as DEFAULT_WIDTHS,c as DEFAULT_QUALITY,b as DEFAULT_FORMATS};
+export {
+  processImage,
+  getImageMetadata,
+  isSharpAvailable,
+  isImageBackendAvailable,
+  generateSrcSet,
+  generateSizes,
+  getFallbackVariant,
+  groupVariantsByFormat,
+  isImageFile,
+  getMimeType,
+  getTotalSize,
+  formatSize,
+  ImageProcessingError,
+  DEFAULT_WIDTHS,
+  DEFAULT_FORMATS,
+  DEFAULT_QUALITY
+} from "./processor.js";
+export {
+  rewriteImagesWithSiblings
+} from "./auto-sibling.js";
+export {
+  createImageHandler,
+  handleImageRequest
+} from "./serve.js";
+export {
+  renderImageComponent,
+  parseImageComponent,
+  processImageComponents
+} from "./component.js";
+export {
+  imageDirective,
+  createImageDirective,
+  clearImageCache
+} from "./directive.js";
+export {
+  createImagePlugin,
+  optimizeImage,
+  optimizeDirectory,
+  generateImageManifest,
+  writeImageManifest
+} from "./build-plugin.js";
+export const defaultImageConfig = {
+  enabled: !0,
+  widths: [320, 640, 768, 1024, 1280, 1536, 1920],
+  formats: ["webp", "jpeg"],
+  quality: 80,
+  devOptimize: !1,
+  cacheDir: ".stx/image-cache",
+  placeholder: "none",
+  inputDirs: ["public", "src/assets", "assets"],
+  outputDir: "dist/images",
+  baseUrl: "/images"
+};

package/dist/image-optimization/processor.js

@@ -1,2 +1,262 @@
-// @bun
-import{$m as p,Mm as a,Nm as b,Om as c,Pm as d,Qm as e,Rm as f,Sm as g,Tm as h,Um as i,Vm as j,Wm as k,Xm as l,Ym as m,Zm as n,_m as o,an as q}from"../chunk-4d2y57k7.js";import"../chunk-xv34zbp4.js";export{h as resizeAndConvert,f as processImage,d as isSharpAvailable,m as isImageFile,e as isImageBackendAvailable,l as groupVariantsByFormat,o as getTotalSize,n as getMimeType,g as getImageMetadata,k as getFallbackVariant,i as generateSrcSet,j as generateSizes,p as formatSize,q as ImageProcessingError,a as DEFAULT_WIDTHS,c as DEFAULT_QUALITY,b as DEFAULT_FORMATS};
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { generatePlaceholder as tsGeneratePlaceholder, processImage as tsProcessImage } from "ts-images";
+export const DEFAULT_WIDTHS = [320, 640, 768, 1024, 1280, 1536, 1920], DEFAULT_FORMATS = ["webp", "jpeg"], DEFAULT_QUALITY = 80;
+const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif", ".svg"], MIME_TYPES = {
+  webp: "image/webp",
+  avif: "image/avif",
+  jpeg: "image/jpeg",
+  png: "image/png"
+};
+let sharp = null, sharpLoadAttempted = !1;
+async function loadSharp() {
+  if (sharpLoadAttempted)
+    return sharp;
+  sharpLoadAttempted = !0;
+  try {
+    const sharpModule = await import("sharp");
+    sharp = sharpModule.default || sharpModule;
+    return sharp;
+  } catch {
+    return null;
+  }
+}
+export async function isSharpAvailable() {
+  return await loadSharp() !== null;
+}
+export async function isImageBackendAvailable() {
+  return !0;
+}
+export async function processImage(input, options = {}) {
+  const {
+    widths = DEFAULT_WIDTHS,
+    formats = DEFAULT_FORMATS,
+    quality = DEFAULT_QUALITY,
+    fit = "cover",
+    placeholder = "none",
+    outputDir = ".stx/images",
+    baseUrl = "/images"
+  } = options;
+  let buffer, srcPath;
+  if (typeof input === "string") {
+    srcPath = input;
+    if (!await Bun.file(input).exists())
+      throw new ImageProcessingError(`Image not found: ${input}`, "NOT_FOUND");
+    buffer = await Bun.file(input).arrayBuffer().then((ab) => Buffer.from(ab));
+  } else {
+    srcPath = "buffer-input";
+    buffer = input;
+  }
+  const hash = crypto.createHash("sha256").update(buffer).digest("hex").slice(0, 12), metadata = await getImageMetadata(buffer), { width: originalWidth, height: originalHeight } = metadata, aspectRatio = originalWidth / originalHeight;
+  await fs.promises.mkdir(outputDir, { recursive: !0 });
+  const variants = [], baseName = path.basename(srcPath, path.extname(srcPath)), validWidths = widths.filter((w) => w <= originalWidth);
+  if (!validWidths.includes(originalWidth) && originalWidth <= Math.max(...widths))
+    validWidths.push(originalWidth);
+  validWidths.sort((a, b) => a - b);
+  for (const targetWidth of validWidths) {
+    const targetHeight = Math.round(targetWidth / aspectRatio);
+    for (const format of formats) {
+      const fileName = `${baseName}-${targetWidth}w-${hash}.${format}`, outputPath = path.join(outputDir, fileName), urlPath = `${baseUrl}/${fileName}`, processedBuffer = await resizeAndConvert(buffer, {
+        width: targetWidth,
+        height: targetHeight,
+        format,
+        quality,
+        fit
+      });
+      await Bun.write(outputPath, processedBuffer);
+      variants.push({
+        path: outputPath,
+        url: urlPath,
+        width: targetWidth,
+        height: targetHeight,
+        format,
+        size: processedBuffer.length
+      });
+    }
+  }
+  let placeholderData;
+  if (placeholder !== "none")
+    placeholderData = await generatePlaceholder(buffer, placeholder);
+  return {
+    src: srcPath,
+    variants,
+    placeholder: placeholderData,
+    width: originalWidth,
+    height: originalHeight,
+    aspectRatio,
+    hash
+  };
+}
+export async function getImageMetadata(input) {
+  const buffer = typeof input === "string" ? Buffer.from(await Bun.file(input).arrayBuffer()) : input, s = await loadSharp();
+  if (s) {
+    const meta = await s(buffer).metadata();
+    return {
+      width: meta.width || 0,
+      height: meta.height || 0,
+      format: meta.format || "unknown",
+      hasAlpha: meta.hasAlpha
+    };
+  }
+  return parseImageHeaders(buffer);
+}
+function parseImageHeaders(buffer) {
+  if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+    const width = buffer.readUInt32BE(16), height = buffer.readUInt32BE(20);
+    return { width, height, format: "png", hasAlpha: !0 };
+  }
+  if (buffer[0] === 255 && buffer[1] === 216) {
+    let offset = 2;
+    while (offset < buffer.length) {
+      if (buffer[offset] !== 255)
+        break;
+      const marker = buffer[offset + 1];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        const height = buffer.readUInt16BE(offset + 5);
+        return { width: buffer.readUInt16BE(offset + 7), height, format: "jpeg", hasAlpha: !1 };
+      }
+      const length = buffer.readUInt16BE(offset + 2);
+      offset += 2 + length;
+    }
+  }
+  if (buffer.toString("utf8", 0, 4) === "RIFF" && buffer.toString("utf8", 8, 12) === "WEBP") {
+    const chunk = buffer.toString("utf8", 12, 16);
+    if (chunk === "VP8 ") {
+      const width = buffer.readUInt16LE(26) & 16383, height = buffer.readUInt16LE(28) & 16383;
+      return { width, height, format: "webp", hasAlpha: !1 };
+    }
+    if (chunk === "VP8L") {
+      const bits = buffer.readUInt32LE(21), width = (bits & 16383) + 1, height = (bits >> 14 & 16383) + 1;
+      return { width, height, format: "webp", hasAlpha: !0 };
+    }
+  }
+  if (buffer.toString("utf8", 0, 3) === "GIF") {
+    const width = buffer.readUInt16LE(6), height = buffer.readUInt16LE(8);
+    return { width, height, format: "gif", hasAlpha: !0 };
+  }
+  throw new ImageProcessingError("Unable to parse image dimensions", "PARSE_ERROR");
+}
+export async function resizeAndConvert(buffer, options) {
+  const s = await loadSharp();
+  if (s) {
+    let instance = s(buffer).resize(options.width, options.height, { fit: options.fit });
+    switch (options.format) {
+      case "webp":
+        instance = instance.webp({ quality: options.quality });
+        break;
+      case "avif":
+        instance = instance.avif({ quality: options.quality });
+        break;
+      case "jpeg":
+        instance = instance.jpeg({ quality: options.quality });
+        break;
+      case "png":
+        instance = instance.png({ quality: options.quality });
+        break;
+    }
+    return instance.toBuffer();
+  }
+  const tempOut = path.join(os.tmpdir(), `stx-img-${crypto.randomBytes(8).toString("hex")}.${options.format}`);
+  try {
+    await tsProcessImage({
+      input: buffer,
+      output: tempOut,
+      format: options.format,
+      quality: options.quality,
+      resize: {
+        width: options.width,
+        height: options.height,
+        fit: options.fit
+      }
+    });
+    return Buffer.from(await Bun.file(tempOut).arrayBuffer());
+  } finally {
+    await fs.promises.unlink(tempOut).catch(() => {});
+  }
+}
+async function generatePlaceholder(buffer, type) {
+  const s = await loadSharp();
+  if (type === "blur" && s) {
+    const base64 = (await s(buffer).resize(20).blur(10).toBuffer()).toString("base64"), meta = await getImageMetadata(buffer);
+    return `data:${MIME_TYPES[meta.format] || "image/jpeg"};base64,${base64}`;
+  }
+  if (type === "dominant-color" && s) {
+    const { dominant } = await s(buffer).resize(1, 1).toBuffer().then(async (b) => {
+      const meta = await s(b).metadata();
+      return { dominant: { r: 128, g: 128, b: 128 } };
+    }).catch(() => ({ dominant: { r: 128, g: 128, b: 128 } }));
+    return `rgb(${dominant.r}, ${dominant.g}, ${dominant.b})`;
+  }
+  const meta = await getImageMetadata(buffer), tempIn = path.join(os.tmpdir(), `stx-ph-${crypto.randomBytes(8).toString("hex")}.${meta.format === "unknown" ? "bin" : meta.format}`);
+  try {
+    await Bun.write(tempIn, buffer);
+    const tsStrategy = type === "blur" ? "blur" : type === "thumbhash" ? "thumbhash" : "dominant-color", ph = await tsGeneratePlaceholder(tempIn, {
+      strategy: tsStrategy,
+      width: tsStrategy === "thumbhash" ? void 0 : 32
+    });
+    if (type === "dominant-color" && ph.dominantColor)
+      return ph.dominantColor;
+    if (ph.dataURL)
+      return ph.dataURL;
+    return "rgb(128, 128, 128)";
+  } catch {
+    return "rgb(128, 128, 128)";
+  } finally {
+    await fs.promises.unlink(tempIn).catch(() => {});
+  }
+}
+export function generateSrcSet(variants, format) {
+  return (format ? variants.filter((v) => v.format === format) : variants).sort((a, b) => a.width - b.width).map((v) => `${v.url} ${v.width}w`).join(", ");
+}
+export function generateSizes(breakpoints) {
+  if (!breakpoints || Object.keys(breakpoints).length === 0)
+    return "100vw";
+  return Object.entries(breakpoints).sort((a, b) => {
+    const aVal = Number.parseInt(a[0].replace(/\D/g, "")) || 0;
+    return (Number.parseInt(b[0].replace(/\D/g, "")) || 0) - aVal;
+  }).map(([bp, size]) => `(max-width: ${bp}) ${size}`).join(", ") + ", 100vw";
+}
+export function getFallbackVariant(variants) {
+  const jpegs = variants.filter((v) => v.format === "jpeg");
+  if (jpegs.length === 0)
+    return variants[Math.floor(variants.length / 2)];
+  const sorted = jpegs.sort((a, b) => a.width - b.width);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+export function groupVariantsByFormat(variants) {
+  const grouped = new Map;
+  for (const variant of variants) {
+    const existing = grouped.get(variant.format) || [];
+    existing.push(variant);
+    grouped.set(variant.format, existing);
+  }
+  return grouped;
+}
+export function isImageFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return IMAGE_EXTENSIONS.includes(ext);
+}
+export function getMimeType(format) {
+  return MIME_TYPES[format] || "application/octet-stream";
+}
+export function getTotalSize(variants) {
+  return variants.reduce((sum, v) => sum + v.size, 0);
+}
+export function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+
+export class ImageProcessingError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "ImageProcessingError";
+    this.code = code;
+  }
+}

package/dist/image-optimization/serve.js

@@ -1,2 +1,102 @@
-// @bun
-import{dm as a,em as b}from"../chunk-yrsb6j3z.js";import"../chunk-4d2y57k7.js";import"../chunk-xv34zbp4.js";export{a as handleImageRequest,b as createImageHandler};
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { getMimeType } from "./processor.js";
+const VALID_FORMATS = new Set(["webp", "avif", "jpeg", "png"]), VALID_FITS = new Set(["cover", "contain", "fill", "inside", "outside"]), SOURCE_EXTS = new Set([".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif"]), DEFAULT_MAX_DIMENSION = 4096, DEFAULT_QUALITY = 80, DEFAULT_FIT = "cover";
+export async function handleImageRequest(request, options) {
+  const routePath = options.routePath ?? "/_stx/img", url = new URL(request.url);
+  if (url.pathname !== routePath)
+    return null;
+  const parsed = parseRequest(url, options);
+  if (!parsed.ok)
+    return new Response(parsed.error, { status: parsed.status, headers: { "Content-Type": "text/plain" } });
+  const { srcFsPath, srcUrl, width, height, format, quality, fit } = parsed;
+  let srcStat;
+  try {
+    srcStat = fs.statSync(srcFsPath);
+  } catch {
+    return new Response(`Source image not found: ${srcUrl}`, {
+      status: 404,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+  if (!srcStat.isFile())
+    return new Response("Not a file", { status: 404, headers: { "Content-Type": "text/plain" } });
+  const cacheDir = options.cacheDir ?? ".stx/cache/img";
+  await fs.promises.mkdir(cacheDir, { recursive: !0 });
+  const fingerprint = `${srcFsPath}:${srcStat.mtimeMs}:${srcStat.size}`, paramKey = `${width}x${height}:${format}:${quality}:${fit}`, cacheKey = crypto.createHash("sha256").update(`${fingerprint}|${paramKey}`).digest("hex").slice(0, 16), cachePath = path.join(cacheDir, `${cacheKey}.${format}`), headers = {
+    "Content-Type": getMimeType(format),
+    "Cache-Control": "public, max-age=31536000, immutable",
+    ETag: `"${cacheKey}"`,
+    "X-Stx-Image-Cache": "HIT"
+  };
+  if (request.headers.get("if-none-match") === `"${cacheKey}"`)
+    return new Response(null, { status: 304, headers });
+  const cached = Bun.file(cachePath);
+  if (await cached.exists())
+    return new Response(cached, { headers });
+  try {
+    const sourceBuffer = Buffer.from(await Bun.file(srcFsPath).arrayBuffer()), { resizeAndConvert } = await loadResize(), outputBuffer = await resizeAndConvert(sourceBuffer, { width, height, format, quality, fit });
+    await Bun.write(cachePath, outputBuffer);
+    headers["X-Stx-Image-Cache"] = "MISS";
+    return new Response(new Uint8Array(outputBuffer), { headers });
+  } catch (err) {
+    const msg = err.message;
+    return new Response(`Image processing failed: ${msg}`, {
+      status: 500,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+}
+export function createImageHandler(options) {
+  return async (request) => {
+    return await handleImageRequest(request, options) ?? new Response("Not Found", {
+      status: 404,
+      headers: { "Content-Type": "text/plain" }
+    });
+  };
+}
+function parseRequest(url, options) {
+  const srcUrl = url.searchParams.get("src");
+  if (!srcUrl)
+    return { ok: !1, error: "Missing required param: src", status: 400 };
+  if (!srcUrl.startsWith("/"))
+    return { ok: !1, error: "src must be an absolute URL path (start with /)", status: 400 };
+  if (srcUrl.startsWith("//"))
+    return { ok: !1, error: "src must be a local path", status: 400 };
+  const srcExt = path.extname(srcUrl).toLowerCase();
+  if (!SOURCE_EXTS.has(srcExt))
+    return { ok: !1, error: `Unsupported source extension: ${srcExt}`, status: 400 };
+  const publicDir = path.resolve(options.publicDir), candidate = path.resolve(publicDir, srcUrl.slice(1));
+  if (!candidate.startsWith(`${publicDir}${path.sep}`) && candidate !== publicDir)
+    return { ok: !1, error: "src is outside publicDir", status: 400 };
+  const maxWidth = options.maxWidth ?? DEFAULT_MAX_DIMENSION, maxHeight = options.maxHeight ?? DEFAULT_MAX_DIMENSION, widthParam = url.searchParams.get("w"), heightParam = url.searchParams.get("h"), width = widthParam ? Number.parseInt(widthParam, 10) : 0, height = heightParam ? Number.parseInt(heightParam, 10) : 0;
+  if (widthParam && (!Number.isFinite(width) || width <= 0))
+    return { ok: !1, error: "Invalid w (must be positive integer)", status: 400 };
+  if (heightParam && (!Number.isFinite(height) || height <= 0))
+    return { ok: !1, error: "Invalid h (must be positive integer)", status: 400 };
+  if (!widthParam && !heightParam)
+    return { ok: !1, error: "At least one of w or h is required", status: 400 };
+  const clampedWidth = Math.min(width || maxWidth, maxWidth), clampedHeight = Math.min(height || maxHeight, maxHeight), formatParam = url.searchParams.get("f") || "webp";
+  if (!VALID_FORMATS.has(formatParam))
+    return { ok: !1, error: `Invalid f (must be one of: ${[...VALID_FORMATS].join(", ")})`, status: 400 };
+  const format = formatParam, qualityParam = url.searchParams.get("q"), quality = qualityParam ? Number.parseInt(qualityParam, 10) : options.defaultQuality ?? DEFAULT_QUALITY;
+  if (!Number.isFinite(quality) || quality < 1 || quality > 100)
+    return { ok: !1, error: "Invalid q (must be 1-100)", status: 400 };
+  const fitParam = url.searchParams.get("fit") || options.defaultFit || DEFAULT_FIT;
+  if (!VALID_FITS.has(fitParam))
+    return { ok: !1, error: `Invalid fit (must be one of: ${[...VALID_FITS].join(", ")})`, status: 400 };
+  return {
+    ok: !0,
+    srcFsPath: candidate,
+    srcUrl,
+    width: clampedWidth,
+    height: clampedHeight,
+    format,
+    quality,
+    fit: fitParam
+  };
+}
+async function loadResize() {
+  return await import("./processor.js");
+}