@goodandready/dsh-image-gen 0.11.25 → 0.11.27

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. */

package/lib/providers/backends/custom.js

@@ -1,6 +1,7 @@
 import {
   normalizeMediaType,
   buildEditForm,
+  normalizeMaskAlpha,
   SIZE_PIXELS,
   formatErrorMessage,
   buildEndpointUrl,
@@ -32,6 +33,11 @@ export function createCustomGenerator(deps, job) {
     if (key) headers.Authorization = `Bearer ${key}`
 
     // Omit response_format; modern models return either base64 or URL.
+    let effectiveMask = mask
+    if (isEdit && mask && mask.bytes) {
+      const normBytes = await normalizeMaskAlpha(mask.bytes)
+      effectiveMask = { ...mask, bytes: normBytes, mediaType: 'image/png' }
+    }
     const endpoint = buildEndpointUrl(base, isEdit ? 'images/edits' : 'images/generations')
     const res = await fetchImpl(endpoint, {
       method: 'POST',
@@ -40,7 +46,7 @@ export function createCustomGenerator(deps, job) {
         ? buildEditForm({
             model: cfg.customModel,
             source,
-            mask,
+            mask: effectiveMask,
             prompt: promptArg,
             size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
             strength,

package/lib/providers/backends/fal.js

@@ -9,11 +9,11 @@ import {
  * @param {fetchImpl: Function, resolveKey: Function, cfg: object} deps
  * @param {prompt?: string, size?: string, format?: string, seed?: number, signal?: AbortSignal,
  *   negativePrompt?: string, guidanceScale?: number, source?: object, mask?: object, strength?: number,
- *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string} job
+ *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string, onProgress?: Function, callId?: string} job
  */
 export function createFalGenerator(deps, job) {
   const { fetchImpl, resolveKey, cfg } = deps
-  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio, onProgress } = job
 
   async function fal(seedArg = seed, promptArg = prompt) {
     const key = await resolveKey(cfg.apiKeyEnv)
@@ -36,9 +36,13 @@ export function createFalGenerator(deps, job) {
       }
     }
 
+    if (typeof onProgress === 'function') {
+      onProgress({ stage: 'Submitting job...', progress: undefined })
+    }
+
     const submit = await submitJob(fetchImpl, cfg.baseURL, targetModel, key, body, signal)
     const statusUrl = submit.status_url || `${cfg.baseURL}/${cfg.model}/requests/${submit.request_id}/status`
-    const statusBody = await pollStatus(fetchImpl, statusUrl, key, signal, cfg.pollIntervalMs, cfg.timeoutMs)
+    const statusBody = await pollStatus(fetchImpl, statusUrl, key, signal, cfg.pollIntervalMs, cfg.timeoutMs, onProgress)
 
     const resultRes = await fetchImpl(statusBody.response_url, {
       headers: { Authorization: falAuthHeader(key) },

package/lib/providers/backends/local.js

@@ -10,15 +10,24 @@ import {
   buildDefaultComfyWorkflow,
 } from '../../comfy-workflow-helpers.js'
 
+function resolveWebSocket() {
+  if (typeof window !== 'undefined' && window.WebSocket) return window.WebSocket
+  try {
+    return (new Function('return typeof WebSocket !== "undefined" ? WebSocket : undefined'))()
+  } catch (_) {
+    return undefined
+  }
+}
+
 /**
  * @param {fetchImpl: Function, resolveKey: Function, cfg: object} deps
  * @param {prompt?: string, size?: string, format?: string, seed?: number, signal?: AbortSignal,
  *   negativePrompt?: string, guidanceScale?: number, source?: object, mask?: object, strength?: number,
- *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string} job
+ *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string, onProgress?: Function, callId?: string} job
  */
 export function createLocalGenerator(deps, job) {
   const { fetchImpl, resolveKey, cfg } = deps
-  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio, onProgress } = job
 
   async function local(seedArg = seed, promptArg = prompt) {
     const base = String(cfg.localBaseURL || '').replace(/\/+$/, '')
@@ -34,6 +43,9 @@ export function createLocalGenerator(deps, job) {
     }
 
     if (kind === 'a1111') {
+      if (typeof onProgress === 'function') {
+        onProgress({ stage: 'Generating...', progress: undefined })
+      }
       const isImg2Img = Boolean(source && source.bytes)
       const endpoint = `${base}${isImg2Img ? '/sdapi/v1/img2img' : '/sdapi/v1/txt2img'}`
       const body = {
@@ -114,61 +126,138 @@ export function createLocalGenerator(deps, job) {
       }
     }
 
-    const submit = await fetchImpl(`${base}/prompt`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ prompt: workflowGraph, client_id: promptId }),
-      signal,
-    })
-    if (!submit.ok) {
-      throw new Error(`Local ComfyUI submit failed (HTTP ${submit.status}): ${String(await submit.text().catch(() => '')).slice(0, 300)}`)
+    let ws
+    let wsClosed = false
+    const closeWs = () => {
+      if (!wsClosed && ws) {
+        wsClosed = true
+        try {
+          ws.close()
+        } catch (_err) {
+          // Socket close failure ignored
+        }
+      }
     }
-    const submitData = await submit.json().catch(() => ({}))
-    const pid = submitData.prompt_id
-    if (!pid) throw new Error('Local ComfyUI did not return a prompt_id')
 
-    const deadline = Date.now() + cfg.timeoutMs
-    let attempt = 0
-    for (;;) {
-      if (signal?.aborted) throw new Error('Local ComfyUI generation cancelled')
-      if (Date.now() > deadline) throw new Error(`Local ComfyUI timed out after ${cfg.timeoutMs} ms`)
-      if (attempt > 0) {
-        const cDelay = calculateBackoff(attempt - 1, cfg.pollIntervalMs || 1000, 5000)
-        await new Promise((resolve) => {
-          const timer = setTimeout(resolve, cDelay)
+    try {
+      const WebSocketClass = resolveWebSocket()
+      if (WebSocketClass) {
+        const wsUrl = `${base.replace(/^http/, 'ws')}/ws?clientId=${encodeURIComponent(promptId)}`
+        try {
+          ws = new WebSocketClass(wsUrl)
           if (signal) {
-            signal.addEventListener('abort', () => { clearTimeout(timer); resolve() }, { once: true })
+            signal.addEventListener('abort', closeWs, { once: true })
           }
-        })
-      }
-      attempt++
-      const hist = await fetchImpl(`${base}/history/${pid}`, { signal })
-      if (!hist.ok) continue
-      const histData = await hist.json().catch(() => ({}))
-      const entry = histData[pid]
-      if (entry) {
-        const comfyErr = extractComfyNodeErrors(entry)
-        if (comfyErr) {
-          throw new Error(`Local ComfyUI execution failed: ${comfyErr}`)
+          ws.onmessage = (event) => {
+            if (wsClosed) return
+            try {
+              if (typeof event.data === 'string') {
+                const msg = JSON.parse(event.data)
+                if (msg.type === 'progress') {
+                  const { value, max } = msg.data || {}
+                  const progress = (max > 0) ? Math.min(100, Math.max(0, Math.round((value / max) * 100))) : undefined
+                  if (typeof onProgress === 'function') {
+                    onProgress({ stage: 'Rendering...', step: `${value}/${max}`, progress })
+                  }
+                } else if (msg.type === 'executing') {
+                  const node = msg.data?.node
+                  if (typeof onProgress === 'function') {
+                    onProgress({ stage: node ? `Executing node ${node}` : 'Finishing...' })
+                  }
+                } else if (msg.type === 'status') {
+                  const q = msg.data?.status?.exec_info?.queue_remaining
+                  if (q !== undefined && q > 0 && typeof onProgress === 'function') {
+                    onProgress({ stage: `In queue (${q} remaining)` })
+                  }
+                }
+              } else if (event.data) {
+                const rawBuf = Buffer.isBuffer(event.data) ? event.data : Buffer.from(event.data)
+                let imgBuf = rawBuf
+                if (rawBuf.length > 8 && (rawBuf[0] === 0 || rawBuf[0] === 1 || rawBuf[0] === 2)) {
+                  imgBuf = rawBuf.subarray(8)
+                }
+                if (imgBuf.length > 4) {
+                  const isPng = imgBuf[0] === 0x89 && imgBuf[1] === 0x50
+                  const mime = isPng ? 'image/png' : 'image/jpeg'
+                  const draftUrl = `data:${mime};base64,${imgBuf.toString('base64')}`
+                  if (typeof onProgress === 'function') {
+                    onProgress({ draftUrl })
+                  }
+                }
+              }
+            } catch (_err) {
+              // Frame parse failure ignored
+            }
+          }
+          ws.onerror = () => {}
+          ws.onclose = () => {}
+        } catch (_err) {
+          // Websocket handshake failure ignored
         }
       }
-      if (entry && entry.outputs) {
-        const outputs = entry.outputs
-        const img = Object.values(outputs).flatMap((o) => o.images || []).find((i) => i && i.filename)
-        if (img) {
-          const dl = await fetchImpl(`${base}/view?filename=${encodeURIComponent(img.filename)}&subfolder=${encodeURIComponent(img.subfolder || '')}&type=${encodeURIComponent(img.type || 'output')}`, { signal })
-          if (!dl.ok) throw new Error(`Local ComfyUI download failed (HTTP ${dl.status})`)
-          return {
-            bytes: Buffer.from(await dl.arrayBuffer()),
-            mediaType: normalizeMediaType('image/png', format),
-            width,
-            height,
-            seed: seedArg ?? 0,
-            sourceUrl: '',
+
+      if (typeof onProgress === 'function') {
+        onProgress({ stage: 'Submitting prompt...', progress: undefined })
+      }
+
+      const submit = await fetchImpl(`${base}/prompt`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ prompt: workflowGraph, client_id: promptId }),
+        signal,
+      })
+      if (!submit.ok) {
+        throw new Error(`Local ComfyUI submit failed (HTTP ${submit.status}): ${String(await submit.text().catch(() => '')).slice(0, 300)}`)
+      }
+      const submitData = await submit.json().catch(() => ({}))
+      const pid = submitData.prompt_id
+      if (!pid) throw new Error('Local ComfyUI did not return a prompt_id')
+
+      const deadline = Date.now() + cfg.timeoutMs
+      let attempt = 0
+      for (;;) {
+        if (signal?.aborted) throw new Error('Local ComfyUI generation cancelled')
+        if (Date.now() > deadline) throw new Error(`Local ComfyUI timed out after ${cfg.timeoutMs} ms`)
+        if (attempt > 0) {
+          const cDelay = calculateBackoff(attempt - 1, cfg.pollIntervalMs || 1000, 5000)
+          await new Promise((resolve) => {
+            const timer = setTimeout(resolve, cDelay)
+            if (signal) {
+              signal.addEventListener('abort', () => { clearTimeout(timer); resolve() }, { once: true })
+            }
+          })
+        }
+        attempt++
+        const hist = await fetchImpl(`${base}/history/${pid}`, { signal })
+        if (!hist.ok) continue
+        const histData = await hist.json().catch(() => ({}))
+        const entry = histData[pid]
+        if (entry) {
+          const comfyErr = extractComfyNodeErrors(entry)
+          if (comfyErr) {
+            throw new Error(`Local ComfyUI execution failed: ${comfyErr}`)
+          }
+        }
+        if (entry && entry.outputs) {
+          const outputs = entry.outputs
+          const img = Object.values(outputs).flatMap((o) => o.images || []).find((i) => i && i.filename)
+          if (img) {
+            const dl = await fetchImpl(`${base}/view?filename=${encodeURIComponent(img.filename)}&subfolder=${encodeURIComponent(img.subfolder || '')}&type=${encodeURIComponent(img.type || 'output')}`, { signal })
+            if (!dl.ok) throw new Error(`Local ComfyUI download failed (HTTP ${dl.status})`)
+            return {
+              bytes: Buffer.from(await dl.arrayBuffer()),
+              mediaType: normalizeMediaType('image/png', format),
+              width,
+              height,
+              seed: seedArg ?? 0,
+              sourceUrl: '',
+            }
           }
         }
       }
+    } finally {
+      closeWs()
     }
   }
   return local
-}
+}

package/lib/providers/shared-helpers.js

@@ -115,7 +115,7 @@ export async function submitJob(fetchImpl, baseURL, model, key, body, signal) {
   return data
 }
 
-export async function pollStatus(fetchImpl, statusUrl, key, signal, pollIntervalMs = 500, timeoutMs = 180000) {
+export async function pollStatus(fetchImpl, statusUrl, key, signal, pollIntervalMs = 500, timeoutMs = 180000, onProgress) {
   const deadline = Date.now() + timeoutMs
   let attempt = 0
   for (;;) {
@@ -138,6 +138,21 @@ export async function pollStatus(fetchImpl, statusUrl, key, signal, pollInterval
     const res = await fetchImpl(statusUrl, { headers: { Authorization: falAuthHeader(key) }, signal })
     const data = await res.json().catch(() => ({}))
     const status = data.status
+    if (typeof onProgress === 'function') {
+      if (status === 'IN_QUEUE') {
+        const pos = data.queue_position
+        onProgress({
+          stage: pos !== undefined ? `In queue (#${pos})` : 'In queue',
+          progress: undefined, // honest status: do NOT simulate fake percentage
+        })
+      } else if (status === 'IN_PROGRESS') {
+        const rawProg = typeof data.progress === 'number' ? Math.round(data.progress * 100) : undefined
+        onProgress({
+          stage: 'Generating...',
+          progress: rawProg,
+        })
+      }
+    }
     if (status === 'COMPLETED') return data
     if (status === 'ERROR' || data.error || data.detail) {
       throw new Error(`FAL generation failed: ${JSON.stringify(data).slice(0, 600)}`)
@@ -148,6 +163,53 @@ export async function pollStatus(fetchImpl, statusUrl, key, signal, pollInterval
   }
 }
 
+/**
+ * Normalizes mask bytes for OpenAI/Custom inpainting where transparent alpha (0) indicates edit region.
+ * If the incoming mask has an alpha channel with transparent areas, it is preserved.
+ * If the incoming mask is opaque black & white (e.g. from Canvas), white pixels are converted to transparent (alpha 0)
+ * and black pixels to opaque (alpha 255).
+ *
+ * @param {Buffer|Uint8Array} maskBytes
+ * @returns {Promise<Buffer>}
+ */
+export async function normalizeMaskAlpha(maskBytes) {
+  if (!maskBytes || maskBytes.length === 0) return maskBytes
+  try {
+    const img = sharp(maskBytes)
+    const { data, info } = await img.raw().ensureAlpha().toBuffer({ resolveWithObject: true })
+    const { width, height, channels } = info
+
+    let hasTransparency = false
+    for (let i = 3; i < data.length; i += channels) {
+      if (data[i] < 250) {
+        hasTransparency = true
+        break
+      }
+    }
+
+    if (hasTransparency) {
+      return await sharp(data, { raw: { width, height, channels } }).png().toBuffer()
+    }
+
+    const out = Buffer.from(data)
+    for (let i = 0; i < out.length; i += channels) {
+      const r = out[i]
+      const g = out[i + 1]
+      const b = out[i + 2]
+      const lum = 0.299 * r + 0.587 * g + 0.114 * b
+      if (lum > 128) {
+        out[i + 3] = 0
+      } else {
+        out[i + 3] = 255
+      }
+    }
+
+    return await sharp(out, { raw: { width, height, channels } }).png().toBuffer()
+  } catch (_) {
+    return maskBytes
+  }
+}
+
 export function buildEditForm({ source, mask, prompt, size, strength, model }) {
   const form = new FormData()
   if (model) form.append('model', model)