/** * Detect actual image MIME type from raw bytes by checking magic bytes. * Returns undefined if format is not recognized. */export function detectImageMime(bytes: Uint8Array): string | undefined {  if (bytes.length < 4) return undefined   // PNG: 89 50 4E 47  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) return "image/png"   // JPEG: FF D8 FF  if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg"   // GIF: 47 49 46 38 (GIF8)  if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) return "image/gif"   // WebP: RIFF....WEBP  if (    bytes.length >= 12 &&    bytes[0] === 0x52 &&    bytes[1] === 0x49 &&    bytes[2] === 0x46 &&    bytes[3] === 0x46 &&    bytes[8] === 0x57 &&    bytes[9] === 0x45 &&    bytes[10] === 0x42 &&    bytes[11] === 0x50  )    return "image/webp"   // TIFF: 49 49 2A 00 (little-endian) or 4D 4D 00 2A (big-endian)  if (    (bytes[0] === 0x49 && bytes[1] === 0x49 && bytes[2] === 0x2a && bytes[3] === 0x00) ||    (bytes[0] === 0x4d && bytes[1] === 0x4d && bytes[2] === 0x00 && bytes[3] === 0x2a)  )    return "image/tiff"   // BMP: 42 4D  if (bytes[0] === 0x42 && bytes[1] === 0x4d) return "image/bmp"   return undefined} /** * Detect image MIME from a base64-encoded string. */export function detectImageMimeFromBase64(base64: string): string | undefined {  const clean = base64.replace(/\s/g, "")  const slice = clean.slice(0, 24) // enough bytes for magic detection  const bytes = Buffer.from(slice, "base64")  return detectImageMime(bytes)} /** * Given declared mime and actual image bytes, return the correct mime. * Falls back to declared if detection fails. */export function correctImageMime(declared: string, bytes: Uint8Array): string {  if (!declared.startsWith("image/")) return declared  const detected = detectImageMime(bytes)  return detected ?? declared} /** * Given declared mime and base64 data, return the correct mime. */export function correctImageMimeFromBase64(declared: string, base64: string): string {  if (!declared.startsWith("image/")) return declared  const detected = detectImageMimeFromBase64(base64)  return detected ?? declared} /** * Read image dimensions from raw header bytes without decoding the full image. * Returns undefined for unsupported formats (SVG/TIFF/BMP/unknown). * Supports PNG, JPEG, GIF, WebP (VP8/VP8L/VP8X). */export function readImageDimensions(bytes: Uint8Array): { width: number; height: number } | undefined {  if (bytes.length < 12) return undefined  const mime = detectImageMime(bytes)   if (mime === "image/png") {    // 8-byte signature, then IHDR: 4-byte length, 4-byte type "IHDR", width (BE u32) at 16, height at 20    if (bytes.length < 24) return undefined    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)    return { width: view.getUint32(16, false), height: view.getUint32(20, false) }  }   if (mime === "image/gif") {    // Logical screen width/height at offsets 6-9, little-endian u16    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)    return { width: view.getUint16(6, true), height: view.getUint16(8, true) }  }   if (mime === "image/jpeg") {    // Walk segments until we hit an SOF marker (excluding DHT/DAC/DQT/DRI/SOI/EOI/DNL/APPn/COM)    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)    let i = 2 // skip SOI (FFD8)    while (i + 9 < bytes.length) {      if (bytes[i] !== 0xff) return undefined      // Skip fill bytes      while (bytes[i] === 0xff && i < bytes.length) i++      const marker = bytes[i]      i++      // Standalone markers (no payload): RST0-7 (D0-D7), SOI (D8), EOI (D9), TEM (01)      if (marker === 0xd8 || marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) continue      if (i + 1 >= bytes.length) return undefined      const segLen = view.getUint16(i, false)      // SOF markers: C0-C3, C5-C7, C9-CB, CD-CF (C4=DHT, C8=JPG, CC=DAC are not SOF)      const isSOF =        (marker >= 0xc0 && marker <= 0xc3) ||        (marker >= 0xc5 && marker <= 0xc7) ||        (marker >= 0xc9 && marker <= 0xcb) ||        (marker >= 0xcd && marker <= 0xcf)      if (isSOF) {        // Layout after length: 1-byte precision, 2-byte height, 2-byte width        if (i + 7 >= bytes.length) return undefined        const height = view.getUint16(i + 3, false)        const width = view.getUint16(i + 5, false)        return { width, height }      }      i += segLen    }    return undefined  }   if (mime === "image/webp") {    // RIFF header: "RIFF" (0-3), file size (4-7), "WEBP" (8-11), then chunk FourCC (12-15)    if (bytes.length < 30) return undefined    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)    const chunk = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15])    if (chunk === "VP8 ") {      // Lossy: frame tag at 20, start code 9D 01 2A at 23-25, width (14 bits LE) at 26, height at 28      if (bytes[23] !== 0x9d || bytes[24] !== 0x01 || bytes[25] !== 0x2a) return undefined      const width = view.getUint16(26, true) & 0x3fff      const height = view.getUint16(28, true) & 0x3fff      return { width, height }    }    if (chunk === "VP8L") {      // Lossless: signature byte 0x2f at 20, then 14-bit width-1, 14-bit height-1 packed LE at 21-24      if (bytes[20] !== 0x2f) return undefined      const b0 = bytes[21],        b1 = bytes[22],        b2 = bytes[23],        b3 = bytes[24]      const width = 1 + (((b1 & 0x3f) << 8) | b0)      const height = 1 + (((b3 & 0x0f) << 10) | (b2 << 2) | ((b1 & 0xc0) >> 6))      return { width, height }    }    if (chunk === "VP8X") {      // Extended: canvas width-1 (3 bytes LE) at 24, canvas height-1 at 27      if (bytes.length < 30) return undefined      const width = 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16))      const height = 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16))      return { width, height }    }    return undefined  }   return undefined}