@goodandready/dsh-image-gen 0.11.24 → 0.11.26

package/lib/provider-utils.js

@@ -1,3 +1,4 @@
+import sharp from 'sharp'
 import { sanitizeErrorAndLogs } from './security.js'
 // lib/provider-utils.js
 // Shared provider utilities and size/format constants extracted from providers.js (#239)
@@ -48,27 +49,88 @@ export function createAbortError(message = 'Image generation cancelled') {
 }
 
 
-/** Fast Laplacian-like sharpness and entropy estimator across image scanlines. */
-export function estimateSharpnessAndVariance(bytes) {
+/** Decodes image to raw grayscale pixel buffer and computes sharpness and entropy (#371). */
+export async function estimateSharpnessAndVariance(bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes || [])
-  if (!buf || buf.length < 64) {
+  if (!buf || buf.length < 8) {
     return { score: 0, passed: false, isBlank: true, reason: 'Empty or corrupt image buffer' }
   }
+
+  let data, width, height
+  try {
+    const decoded = await sharp(buf).grayscale().raw().toBuffer({ resolveWithObject: true })
+    data = decoded.data
+    width = decoded.info.width
+    height = decoded.info.height
+  } catch (err) {
+    return { score: 0, passed: false, isBlank: true, reason: 'Unsupported or corrupt image data' }
+  }
+
+  if (!data || data.length === 0) {
+    return { score: 0, passed: false, isBlank: true, reason: 'Empty or corrupt image buffer' }
+  }
+
+  let sum = 0
+  let sumSq = 0
+  let min = 255
+  let max = 0
+  const totalPixels = data.length
+  for (let i = 0; i < totalPixels; i++) {
+    const v = data[i]
+    sum += v
+    sumSq += v * v
+    if (v < min) min = v
+    if (v > max) max = v
+  }
+  const mean = sum / totalPixels
+  const variance = Math.max(0, (sumSq / totalPixels) - (mean * mean))
+
+  // If pixel variance is negligible, image is blank or solid monochrome
+  if (max === min || variance < 2) {
+    return {
+      score: 0.1,
+      passed: false,
+      isBlank: true,
+      reason: 'Image appears blank or solid monochrome',
+      variance: +variance.toFixed(2),
+      width,
+      height,
+    }
+  }
+
   let diffSum = 0
-  const sampleStep = Math.max(1, Math.floor(buf.length / 4096))
-  let count = 0
-  for (let i = 8; i < buf.length - sampleStep; i += sampleStep) {
-    const v = buf[i]
-    const nextV = buf[i + sampleStep]
-    diffSum += Math.abs(v - nextV)
-    count++
+  let diffCount = 0
+  if (width > 1) {
+    for (let y = 0; y < height; y++) {
+      const row = y * width
+      for (let x = 0; x < width - 1; x++) {
+        diffSum += Math.abs(data[row + x] - data[row + x + 1])
+        diffCount++
+      }
+    }
+  }
+  if (height > 1) {
+    for (let y = 0; y < height - 1; y++) {
+      const row = y * width
+      const nextRow = (y + 1) * width
+      for (let x = 0; x < width; x++) {
+        diffSum += Math.abs(data[row + x] - data[nextRow + x])
+        diffCount++
+      }
+    }
   }
-  const avgDiff = count > 0 ? diffSum / count : 0
-  if (avgDiff < 2) {
-    return { score: 0.1, passed: false, isBlank: true, reason: 'Image appears blank or solid monochrome' }
+  const avgDiff = diffCount > 0 ? diffSum / diffCount : 0
+  const score = Math.min(0.98, Math.max(0.3, +(0.5 + Math.min(1, avgDiff / 32) * 0.48).toFixed(2)))
+
+  return {
+    score,
+    passed: score >= 0.5 && variance >= 2,
+    isBlank: false,
+    avgDiff: +avgDiff.toFixed(2),
+    variance: +variance.toFixed(2),
+    width,
+    height,
   }
-  const score = Math.min(0.98, Math.max(0.3, +(0.5 + (avgDiff / 255) * 0.5).toFixed(2)))
-  return { score, passed: score >= 0.5, isBlank: false, avgDiff: +avgDiff.toFixed(2) }
 }
 
 /** Adaptive color palette quantizer for SVG vectorization. */
@@ -117,6 +179,7 @@ export function computeGenerationHash({
   seed,
   size,
   style,
+  stylePreset,
   format,
   aspectRatio,
   negativePrompt,
@@ -144,6 +207,7 @@ export function computeGenerationHash({
     String(seed ?? ''),
     String(size || '').trim().toLowerCase(),
     String(style || '').trim().toLowerCase(),
+    String(stylePreset || '').trim().toLowerCase(),
     String(format || '').trim().toLowerCase(),
     String(aspectRatio || '').trim().toLowerCase(),
     String(negativePrompt || '').trim(),

package/lib/providers/backends/custom.js

@@ -4,6 +4,7 @@ import {
   SIZE_PIXELS,
   formatErrorMessage,
   buildEndpointUrl,
+  ensureImageFormat,
 } from '../shared-helpers.js'
 
 /**
@@ -49,6 +50,7 @@ export function createCustomGenerator(deps, job) {
             prompt: promptArg,
             n: 1,
             size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
+            ...(format ? { output_format: format } : {}),
             ...(negativePrompt !== undefined ? { negative_prompt: negativePrompt } : {}),
             ...(guidanceScale !== undefined ? { guidance_scale: guidanceScale } : {}),
             ...(quality && quality !== 'auto' ? { quality } : {}),
@@ -72,9 +74,14 @@ export function createCustomGenerator(deps, job) {
     }
 
     if (item.b64_json) {
+      const rawBytes = Buffer.from(item.b64_json, 'base64')
+      const targetFormat = format || data.output_format
+      const formatted = await ensureImageFormat(rawBytes, targetFormat, {
+        fallbackMime: normalizeMediaType(data.output_format || '', format, rawBytes),
+      })
       return {
-        bytes: Buffer.from(item.b64_json, 'base64'),
-        mediaType: normalizeMediaType(data.output_format || '', format),
+        bytes: formatted.bytes,
+        mediaType: formatted.mediaType,
         width: 0,
         height: 0,
         seed: seedArg ?? 0,
@@ -91,9 +98,15 @@ export function createCustomGenerator(deps, job) {
     const contentType = download.headers && typeof download.headers.get === 'function'
       ? download.headers.get('content-type')
       : ''
+    const rawBytes = Buffer.from(await download.arrayBuffer())
+    const downloadFormat = contentType ? contentType.replace('image/', '').trim().toLowerCase() : undefined
+    const targetFormat = (format && format !== 'png') ? format : (downloadFormat || format)
+    const formatted = await ensureImageFormat(rawBytes, targetFormat, {
+      fallbackMime: normalizeMediaType(contentType, format),
+    })
     return {
-      bytes: Buffer.from(await download.arrayBuffer()),
-      mediaType: normalizeMediaType(contentType, format),
+      bytes: formatted.bytes,
+      mediaType: formatted.mediaType,
       width: 0,
       height: 0,
       seed: seedArg ?? 0,

package/lib/providers/backends/gemini.js

@@ -1,5 +1,6 @@
 import {
   normalizeMediaType,
+  ensureImageFormat,
 } from '../shared-helpers.js'
 
 /**
@@ -14,19 +15,49 @@ export function createGeminiGenerator(deps, job) {
 
   async function gemini(seedArg = seed, promptArg = prompt) {
     const key = await resolveKey(cfg.geminiKeyEnv)
-    const model = cfg.geminiModel || 'gemini-2.0-flash-exp-image-generation'
+    let model = cfg.geminiModel || 'gemini-2.0-flash-exp-image-generation'
+    // #364: Transparently migrate deprecated Imagen 3/4 IDs to Gemini multimodal model
+    if (model.startsWith('imagen-') || model === 'imagen-3.0-generate-002') {
+      model = 'gemini-2.0-flash-exp-image-generation'
+    }
+
     const timeoutSignal = typeof AbortSignal !== 'undefined' && AbortSignal.timeout
       ? AbortSignal.timeout(cfg.timeoutMs || 120000)
       : undefined
     const effectiveSignal = signal && timeoutSignal && AbortSignal.any
       ? AbortSignal.any([signal, timeoutSignal])
       : (signal || timeoutSignal)
+
+    const parts = []
+    if (source && source.bytes) {
+      const sourceMime = source.mediaType || 'image/png'
+      const sourceBase64 = Buffer.isBuffer(source.bytes) ? source.bytes.toString('base64') : Buffer.from(source.bytes).toString('base64')
+      parts.push({
+        inlineData: {
+          mimeType: sourceMime,
+          data: sourceBase64,
+        },
+      })
+    }
+    parts.push({ text: promptArg })
+
+    // Build unified imageConfig without quality/style overwrite collisions (#364)
+    const imageConfig = {}
+    if (aspectRatio) imageConfig.aspectRatio = aspectRatio
+    if (quality && quality !== 'auto') imageConfig.imageQuality = quality
+    if (style && style !== 'none') imageConfig.imageStyle = style
+
+    const generationConfig = {
+      responseModalities: ['IMAGE'],
+      ...(Object.keys(imageConfig).length > 0 ? { imageConfig } : {}),
+    }
+
     const res = await fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${encodeURIComponent(key)}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        contents: [{ parts: [{ text: promptArg }] }],
-        generationConfig: { responseModalities: ['IMAGE'], ...(quality !== undefined ? { imageConfig: { imageQuality: quality } } : {}), ...(style !== undefined ? { imageConfig: { imageStyle: style } } : {}) },
+        contents: [{ parts }],
+        generationConfig,
       }),
       signal: effectiveSignal,
     })
@@ -37,7 +68,17 @@ export function createGeminiGenerator(deps, job) {
     }
     const part = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData?.data)
     if (!part) throw new Error('Gemini returned no image')
-    return { bytes: Buffer.from(part.inlineData.data, 'base64'), mediaType: normalizeMediaType(part.inlineData.mimeType || 'image/png', format), width: 0, height: 0, seed: seedArg ?? 0, sourceUrl: '' }
+
+    const rawBytes = Buffer.from(part.inlineData.data, 'base64')
+    const formatted = await ensureImageFormat(rawBytes, format || part.inlineData.mimeType)
+    return {
+      bytes: formatted.bytes,
+      mediaType: formatted.mediaType,
+      width: 0,
+      height: 0,
+      seed: seedArg ?? 0,
+      sourceUrl: '',
+    }
   }
   return gemini
 }

package/lib/providers/shared-helpers.js

@@ -1,3 +1,4 @@
+import sharp from 'sharp'
 /**
  * Shared provider HTTP/auth helpers used by per-backend factories.
  * Extracted from providers.js for #218 modularization.
@@ -25,16 +26,77 @@ export function falAuthHeader(key) {
     : `Key ${trimmed}`
 }
 
-export function normalizeMediaType(contentType, fallbackFormat) {
+export function detectImageMediaType(buf) {
+  if (!buf || (!Buffer.isBuffer(buf) && !(buf instanceof Uint8Array))) return undefined
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf)
+  if (b.length < 4) return undefined
+  if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) return 'image/png'
+  if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return 'image/jpeg'
+  if (b.length >= 12 && b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46 &&
+      b[8] === 0x57 && b[9] === 0x45 && b[10] === 0x42 && b[11] === 0x50) {
+    return 'image/webp'
+  }
+  if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38) return 'image/gif'
+  if (b.length > 5) {
+    const head = b.subarray(0, Math.min(256, b.length)).toString('utf8').trimStart()
+    if (head.startsWith('<svg') || (head.startsWith('<?xml') && head.includes('<svg'))) {
+      return 'image/svg+xml'
+    }
+  }
+  return undefined
+}
+
+export function normalizeMediaType(contentType, fallbackFormat, bytes) {
+  if (bytes) {
+    const detected = detectImageMediaType(bytes)
+    if (detected) return detected
+  }
   const raw = String(contentType ?? '').toLowerCase()
   if (raw.includes('jpeg') || raw.includes('jpg')) return 'image/jpeg'
   if (raw.includes('webp')) return 'image/webp'
   if (raw.includes('png')) return 'image/png'
-  if (fallbackFormat === 'jpeg') return 'image/jpeg'
+  if (fallbackFormat === 'jpeg' || fallbackFormat === 'jpg') return 'image/jpeg'
   if (fallbackFormat === 'webp') return 'image/webp'
+  if (fallbackFormat === 'png') return 'image/png'
   return 'image/png'
 }
 
+/**
+ * Ensures image bytes match the requested target format ('png', 'jpeg', 'webp').
+ * If bytes already match target format, returns them with truthful mediaType.
+ * If bytes differ (e.g. provider returned PNG for a webp request), transcodes via Sharp (#386).
+ */
+export async function ensureImageFormat(bytes, targetFormat, { fallbackMime } = {}) {
+  if (!bytes) return { bytes: Buffer.alloc(0), mediaType: fallbackMime || 'image/png' }
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)
+  const actualMime = detectImageMediaType(buf)
+  if (!targetFormat && !fallbackMime) return { bytes: buf, mediaType: actualMime || 'image/png' }
+
+  const rawFormat = String(targetFormat || '').trim().toLowerCase()
+  const canonical = rawFormat === 'jpg' ? 'jpeg' : rawFormat
+
+  if (canonical && !['png', 'jpeg', 'webp'].includes(canonical)) {
+    throw new Error(`Unsupported output format "${targetFormat}". Supported formats: png, jpeg, webp`)
+  }
+
+  const targetMime = canonical ? `image/${canonical}` : fallbackMime
+  if (actualMime === targetMime) {
+    return { bytes: buf, mediaType: targetMime }
+  }
+
+  try {
+    if (!canonical) return { bytes: buf, mediaType: fallbackMime || actualMime || 'image/png' }
+    const transcoded = await sharp(buf).toFormat(canonical).toBuffer()
+    const verified = detectImageMediaType(transcoded) || targetMime
+    return { bytes: transcoded, mediaType: verified }
+  } catch (err) {
+    if (buf.length < 64) {
+      return { bytes: buf, mediaType: fallbackMime || targetMime || actualMime || 'image/png' }
+    }
+    throw new Error(`Failed to encode image to ${canonical}: ${err.message}`)
+  }
+}
+
 export async function submitJob(fetchImpl, baseURL, model, key, body, signal) {
   const res = await fetchImpl(`${baseURL}/${model}`, {
     method: 'POST',