@goodandready/dsh-image-gen 0.10.24 → 0.10.26

package/lib/index.js

@@ -16,6 +16,18 @@ import z from '@deepseek-ai/schemastery'
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { enforceSecurePermissions } from './security.js'
+import { saveAndAttachResult } from './attachment-helper.js'
+import {
+  historyFile,
+  findCachedGeneration,
+  findCachedByPrompt,
+  findCached,
+  cachedResult,
+  pruneHistory,
+  readHistory,
+  writeHistory,
+  filterHistory,
+} from './history.js'
 import { existsSync, unlinkSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
@@ -37,6 +49,18 @@ import { registerPluginUpdater } from './updater.js'
 
 
 export { IMAGE_SIZES, OUTPUT_FORMATS, PROVIDER_KEYS, buildSidecar, normalizeMediaType, resolveConversationImage, analyzeImageWithVision }
+export { saveAndAttachResult }
+export {
+  historyFile,
+  findCachedGeneration,
+  findCachedByPrompt,
+  findCached,
+  cachedResult,
+  pruneHistory,
+  readHistory,
+  writeHistory,
+  filterHistory,
+}
 
 
 /**
@@ -45,85 +69,7 @@ export { IMAGE_SIZES, OUTPUT_FORMATS, PROVIDER_KEYS, buildSidecar, normalizeMedi
 
 
 
-export async function saveAndAttachResult(ctx, exec, cfg, {
-  bytes,
-  mediaType,
-  name,
-  stem,
-  prompt,
-  size,
-  format,
-  seed,
-  provider,
-  model,
-  cost,
-  sourceUrl,
-  deliverAs,
-  args = {},
-  action = 'generated',
-}) {
-  const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes, mediaType, name })
-
-  const sessionCwd = exec?.agent?.session?.header?.cwd
-  const targetDir = (args.output_dir && String(args.output_dir).trim()) || cfg.outputDir || 'generated/images'
-  const outDir = path.resolve(sessionCwd || process.cwd(), targetDir)
-  await mkdir(outDir, { recursive: true })
-  const filePath = path.join(outDir, name)
-  await writeFile(filePath, bytes)
-
-  await writeFile(
-    path.join(outDir, `${stem}.json`),
-    JSON.stringify(buildSidecar({
-      prompt,
-      size,
-      format,
-      seed,
-      provider,
-      deliverAs,
-      width: attachment.width,
-      height: attachment.height,
-      mediaType,
-      attachmentId: attachment.attachmentId,
-      url: deliverAs === 'image' && sourceUrl ? sourceUrl : localUrl,
-      cost,
-    }), null, 2),
-  )
-
-  const summary = buildDualOutputMarkdown({
-    action,
-    filePath,
-    width: attachment.width,
-    height: attachment.height,
-    mediaType,
-    seed,
-    provider,
-    model: model || cfg.model || cfg.customModel || 'default',
-    cost,
-    attachmentId: attachment.attachmentId,
-  })
-
-  return toLosslessJson({
-    summary,
-    path: filePath,
-    url: deliverAs === 'image' && sourceUrl ? sourceUrl : localUrl,
-    width: attachment.width,
-    height: attachment.height,
-    seed,
-    prompt,
-    cost,
-    format: mediaType.replace('image/', ''),
-    attachment: {
-      attachmentId: attachment.attachmentId,
-      mediaType: attachment.mediaType,
-      bytes: attachment.bytes,
-      width: attachment.width,
-      height: attachment.height,
-      name: attachment.name,
-    },
-  })
-}
-
-export const name = 'dsh-image-gen'
+export const name = '@goodandready/dsh-image-gen'
 
 /** Settings namespace the Web card edits. */
 const NS = 'dsh-image-gen'
@@ -394,94 +340,6 @@ function migrateLegacySettings(sctx, scope) {
 }
 
 /** History directory: persists across restarts. */
-export function historyFile() {
-  return path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'dsh-image-gen', 'history.json')
-}
-
-/** Read history from disk file (empty array if not found). */
-/** Find history entry matching seed+prompt if file exists. */
-/** Find history entry matching prompt text if file exists. */
-export function findCachedGeneration(entries, hash) {
-  if (!hash || !Array.isArray(entries)) return undefined
-  return entries.find((e) => e.cacheHash === hash)
-}
-
-export async function findCachedByPrompt(entries, prompt) {
-  return entries.find((e) => e.prompt === prompt)
-}
-
-export async function findCached(entries, seed, prompt) {
-  if (seed === undefined) return undefined
-  return entries.find((e) => e.seed === seed && e.prompt === prompt)
-}
-
-/** Return cached entry if file exists on disk, otherwise undefined. */
-export async function cachedResult(entry) {
-  if (!entry || !entry.path) return undefined
-  if (!entry.path || !existsSync(entry.path)) return undefined
-  return {
-    path: entry.path,
-    url: entry.attachmentId ? `/dsh-image-gen/image?id=${encodeURIComponent(entry.attachmentId)}` : '',
-    thumbnailUrl: entry.thumbnailUrl || (entry.attachmentId ? `/dsh-image-gen/image?id=${encodeURIComponent(entry.attachmentId)}` : ''),
-    width: entry.width || 1024,
-    height: entry.height || 1024,
-    seed: entry.seed,
-    prompt: entry.prompt,
-    cost: 0,
-    format: (entry.mediaType || 'image/png').replace('image/', ''),
-    cached: true,
-    attachment: entry.attachmentId ? {
-      attachmentId: entry.attachmentId,
-      mediaType: entry.mediaType || 'image/png',
-      bytes: entry.bytes || 0,
-      width: entry.width || 1024,
-      height: entry.height || 1024,
-      name: entry.name || '',
-    } : undefined,
-  }
-}
-
-/** Prune files and history records older than pruneDays (including sidecars). */
-export async function pruneHistory(entries, pruneDays) {
-  if (!pruneDays || pruneDays <= 0) return entries
-  const cutoff = Date.now() - pruneDays * 86400000
-  const kept = []
-  for (const e of entries) {
-    const created = e.createdAt ? Date.parse(e.createdAt) : NaN
-    if (Number.isFinite(created) && created < cutoff) {
-      try { unlinkSync(e.path) } catch (err) { /* file already deleted */ }
-      try { unlinkSync(e.path.replace(/\.[^.]+$/, '.json')) } catch (err) { /* sidecar */ }
-      continue
-    }
-    kept.push(e)
-  }
-  return kept
-}
-
-export async function readHistory() {
-  try {
-    const raw = await readFile(historyFile(), 'utf-8')
-    const parsed = JSON.parse(raw)
-    return Array.isArray(parsed) ? parsed : []
-  } catch (e) {
-    return []
-  }
-}
-
-/** Save history to disk file (atomic overwrite). */
-export async function writeHistory(entries) {
-  try {
-    await mkdir(path.dirname(historyFile()), { recursive: true })
-    await writeFile(historyFile(), JSON.stringify(entries, null, 2))
-    enforceSecurePermissions(historyFile())
-  } catch (e) { /* history write failure is non-fatal */ }
-}
-
-/** Filter entries whose files exist on disk; newest first. */
-export function filterHistory(entries, exists) {
-  return entries.filter((e) => exists(e.path)).slice(0, 50)
-}
-
 /** Collect text chunks from llm.stream iterator. */
 export async function collectText(iterable) {
   let out = ''

package/lib/pattern-helpers.js

@@ -0,0 +1,87 @@
+// Pure helpers for generate_seamless_pattern (#178)
+
+export function buildSeamlessPrompt(motif, style, density) {
+  const d = String(density || 'medium').toLowerCase()
+  const densityHint = d === 'low'
+    ? 'sparse motif spacing with generous empty background'
+    : d === 'high'
+      ? 'dense repeating motif coverage with minimal empty background'
+      : 'balanced motif spacing'
+  const styleBit = style ? ` Style: ${style}.` : ''
+  return `Seamless tileable repeating pattern of ${motif}.${styleBit} `
+    + 'Motifs must wrap continuously across left/right and top/bottom edges so the image tiles without visible seams. '
+    + `Flat even lighting, orthographic top-down view, ${densityHint}. `
+    + 'No vignette, no border frame, no watermark, no text.'
+}
+
+export function buildPatternCss({ className, sizePx, imagePath }) {
+  const name = className || 'dsh-pattern'
+  const size = sizePx || 512
+  const url = imagePath || `./${name}.png`
+  return `/* dsh-image-gen seamless pattern */
+.${name} {
+  background-image: url('${url}');
+  background-repeat: repeat;
+  background-size: ${size}px ${size}px;
+}
+`
+}
+
+export function normalizeDensity(value) {
+  const v = String(value || 'medium').toLowerCase()
+  if (v === 'low' || v === 'high') return v
+  return 'medium'
+}
+
+
+/**
+ * Score edge wrap continuity on raw RGBA (or RGB) pixel rows.
+ * Returns 0..1 (1 = identical opposite edges). Used as a seam QA helper (#178).
+ * @param {Uint8Array} pixels
+ * @param {number} width
+ * @param {number} height
+ * @param {number} [channels=4]
+ */
+export function scoreEdgeWrap(pixels, width, height, channels = 4) {
+  if (!pixels || width < 1 || height < 1) return 0
+  const stride = width * channels
+  let sum = 0
+  let n = 0
+  // left vs right columns
+  for (let y = 0; y < height; y++) {
+    const row = y * stride
+    for (let c = 0; c < channels; c++) {
+      const l = pixels[row + c]
+      const r = pixels[row + (width - 1) * channels + c]
+      sum += 1 - Math.abs(l - r) / 255
+      n++
+    }
+  }
+  // top vs bottom rows
+  for (let x = 0; x < width; x++) {
+    for (let c = 0; c < channels; c++) {
+      const top = pixels[x * channels + c]
+      const bot = pixels[(height - 1) * stride + x * channels + c]
+      sum += 1 - Math.abs(top - bot) / 255
+      n++
+    }
+  }
+  return n ? sum / n : 0
+}
+
+/** Tile RGBA image into cols x rows buffer (for 2x2 / 3x3 seam visual QA). */
+export function tilePixels(pixels, width, height, channels, cols, rows) {
+  const outW = width * cols
+  const outH = height * rows
+  const out = new Uint8Array(outW * outH * channels)
+  for (let ry = 0; ry < rows; ry++) {
+    for (let cx = 0; cx < cols; cx++) {
+      for (let y = 0; y < height; y++) {
+        const srcOff = y * width * channels
+        const dstOff = ((ry * height + y) * outW + cx * width) * channels
+        out.set(pixels.subarray(srcOff, srcOff + width * channels), dstOff)
+      }
+    }
+  }
+  return { pixels: out, width: outW, height: outH }
+}

package/lib/providers/backends/custom.js

@@ -0,0 +1,93 @@
+import {
+  normalizeMediaType,
+  buildEditForm,
+  SIZE_PIXELS,
+  formatErrorMessage,
+  buildEndpointUrl,
+} from '../shared-helpers.js'
+
+/**
+ * @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
+ */
+export function createCustomGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+
+  async function custom(seedArg = seed, promptArg = prompt) {
+    const base = String(cfg.customBaseURL || '').replace(/\/+$/, '')
+    if (!base) throw new Error('Custom image provider: base URL is not configured (Settings → Image generation)')
+    if (!cfg.customModel) throw new Error('Custom image provider: model is not configured')
+
+    // Empty key reference indicates unauthenticated gateway.
+    const key = cfg.customKeyEnv ? await resolveKey(cfg.customKeyEnv) : ''
+    const headers = { 'Content-Type': 'application/json' }
+    if (key) headers.Authorization = `Bearer ${key}`
+
+    // Omit response_format; modern models return either base64 or URL.
+    const endpoint = buildEndpointUrl(base, source ? 'images/edits' : 'images/generations')
+    const res = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers,
+      body: source
+        ? buildEditForm({ source, mask, prompt: promptArg, size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size, strength })
+        : JSON.stringify({
+            model: cfg.customModel,
+            prompt: promptArg,
+            n: 1,
+            size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
+            ...(negativePrompt !== undefined ? { negative_prompt: negativePrompt } : {}),
+            ...(guidanceScale !== undefined ? { guidance_scale: guidanceScale } : {}),
+            ...(quality && quality !== 'auto' ? { quality } : {}),
+          }),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      if (res.status === 503) {
+        const msg = (data?.error?.message || JSON.stringify(data)).toLowerCase()
+        if (msg.includes('no available channel') || msg.includes('model_not_found')) {
+          throw new Error(`Custom image API has no provisioned channel for "${cfg.customModel}" (HTTP 503); check gateway channel and routing configuration`)
+        }
+      }
+      const detail = formatErrorMessage(data?.error || data)
+      throw new Error(`Image API failed (HTTP ${res.status}): ${detail}`)
+    }
+    const item = data?.data?.[0]
+    if (!item) {
+      throw new Error(`Image API returned no images: ${JSON.stringify(data).slice(0, 600)}`)
+    }
+
+    if (item.b64_json) {
+      return {
+        bytes: Buffer.from(item.b64_json, 'base64'),
+        mediaType: normalizeMediaType(data.output_format || '', format),
+        width: 0,
+        height: 0,
+        seed: seedArg ?? 0,
+        sourceUrl: '',
+      }
+    }
+    if (!item.url) {
+      throw new Error(`Image API returned neither b64_json nor url: ${JSON.stringify(item).slice(0, 300)}`)
+    }
+    const download = await fetchImpl(item.url, { signal })
+    if (!download.ok) {
+      throw new Error(`Failed to download generated image (HTTP ${download.status})`)
+    }
+    const contentType = download.headers && typeof download.headers.get === 'function'
+      ? download.headers.get('content-type')
+      : ''
+    return {
+      bytes: Buffer.from(await download.arrayBuffer()),
+      mediaType: normalizeMediaType(contentType, format),
+      width: 0,
+      height: 0,
+      seed: seedArg ?? 0,
+      sourceUrl: item.url,
+    }
+  }
+  return custom
+}

package/lib/providers/backends/fal.js

@@ -0,0 +1,67 @@
+import {
+  falAuthHeader,
+  normalizeMediaType,
+  submitJob,
+  pollStatus,
+} from '../shared-helpers.js'
+
+/**
+ * @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
+ */
+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
+
+  async function fal(seedArg = seed, promptArg = prompt) {
+    const key = await resolveKey(cfg.apiKeyEnv)
+    const isEdit = Boolean(source && source.bytes)
+    const targetModel = isEdit
+      ? (mask && mask.bytes ? 'fal-ai/flux-pro/v1/inpaint' : 'fal-ai/flux/dev/image-to-image')
+      : cfg.model
+    const body = { prompt: promptArg, image_size: size, num_images: 1 }
+    if (seedArg !== undefined) body.seed = seedArg
+    if (negativePrompt !== undefined) body.negative_prompt = negativePrompt
+    if (guidanceScale !== undefined) body.guidance_scale = guidanceScale
+    if (format !== 'png') body.output_format = format
+    if (isEdit) {
+      body.image_url = `data:${source.mediaType || 'image/png'};base64,${Buffer.from(source.bytes).toString('base64')}`
+      if (mask && mask.bytes) {
+        body.mask_url = `data:${mask.mediaType || 'image/png'};base64,${Buffer.from(mask.bytes).toString('base64')}`
+      }
+      if (strength !== undefined) {
+        body.strength = strength
+      }
+    }
+
+    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 resultRes = await fetchImpl(statusBody.response_url, {
+      headers: { Authorization: falAuthHeader(key) },
+      signal,
+    })
+    const result = await resultRes.json().catch(() => ({}))
+    const image = result.images && result.images[0]
+    if (!image || !image.url) {
+      throw new Error(`FAL returned no images: ${JSON.stringify(result).slice(0, 600)}`)
+    }
+    const download = await fetchImpl(image.url, { signal })
+    if (!download.ok) {
+      throw new Error(`Failed to download generated image (HTTP ${download.status})`)
+    }
+    return {
+      bytes: Buffer.from(await download.arrayBuffer()),
+      mediaType: normalizeMediaType(image.content_type, format),
+      width: image.width ?? 0,
+      height: image.height ?? 0,
+      seed: result.seed ?? seedArg ?? 0,
+      sourceUrl: image.url,
+      cost: result.cost,
+    }
+  }
+  return fal
+}

package/lib/providers/backends/gemini.js

@@ -0,0 +1,37 @@
+import {
+  normalizeMediaType,
+} from '../shared-helpers.js'
+
+/**
+ * @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
+ */
+export function createGeminiGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = 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'
+    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 } } : {}) },
+      }),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      const detail = data?.error?.message || JSON.stringify(data).slice(0, 600)
+      throw new Error(`Gemini failed (HTTP ${res.status}): ${detail}`)
+    }
+    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: '' }
+  }
+  return gemini
+}

package/lib/providers/backends/local.js

@@ -0,0 +1,136 @@
+import {
+  normalizeMediaType,
+  pxSize,
+  calculateBackoff,
+  extractComfyNodeErrors,
+} from '../shared-helpers.js'
+
+/**
+ * @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
+ */
+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
+
+  async function local(seedArg = seed, promptArg = prompt) {
+    const base = String(cfg.localBaseURL || '').replace(/\/+$/, '')
+    if (!base) throw new Error('Local image provider: server address is not configured (Settings → Image generation)')
+    const [width, height] = pxSize(aspectPixels, size)
+    const kind = cfg.localKind === 'a1111' ? 'a1111' : 'comfyui'
+
+    if (kind === 'a1111') {
+      const isImg2Img = Boolean(source && source.bytes)
+      const endpoint = `${base}${isImg2Img ? '/sdapi/v1/img2img' : '/sdapi/v1/txt2img'}`
+      const body = {
+        prompt: promptArg,
+        negative_prompt: negativePrompt,
+        width,
+        height,
+        steps: cfg.localSteps ?? 20,
+        cfg_scale: cfg.localCfg ?? 7,
+        seed: seedArg ?? -1,
+      }
+      if (isImg2Img) {
+        body.init_images = [Buffer.from(source.bytes).toString('base64')]
+        body.denoising_strength = strength ?? (mask ? 0.75 : 0.35)
+        if (mask && mask.bytes) {
+          body.mask = Buffer.from(mask.bytes).toString('base64')
+        }
+      }
+      if (cfg.localModel) body.override_settings = { sd_model_checkpoint: cfg.localModel }
+      const res = await fetchImpl(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        signal,
+      })
+      if (!res.ok) {
+        throw new Error(`Local A1111 failed (HTTP ${res.status}): ${String(await res.text().catch(() => '')).slice(0, 300)}`)
+      }
+      const data = await res.json().catch(() => ({}))
+      const b64 = data.images && data.images[0]
+      if (!b64) throw new Error('Local A1111 returned no images')
+      return {
+        bytes: Buffer.from(b64, 'base64'),
+        mediaType: normalizeMediaType('image/png', format),
+        width,
+        height,
+        seed: seedArg ?? 0,
+        sourceUrl: '',
+      }
+    }
+
+    // ComfyUI: submit via /prompt, poll /history/{prompt_id} until completed.
+    const promptId = `dsh-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+    const workflow = {
+      prompt: {
+        '3': { class_type: 'KSampler', inputs: { seed: seedArg ?? 0, steps: cfg.localSteps ?? 20, cfg: cfg.localCfg ?? 7, sampler_name: 'euler', scheduler: 'normal', denoise: 1, model: ['4', 0], positive: ['6', 0], negative: ['7', 0], latent_image: ['5', 0] } },
+        '4': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: cfg.localModel || 'v1-5-pruned-emaonly.safetensors' } },
+        '5': { class_type: 'EmptyLatentImage', inputs: { width, height, batch_size: 1 } },
+        '6': { class_type: 'CLIPTextEncode', inputs: { text: promptArg, clip: ['4', 1] } },
+        '7': { class_type: 'CLIPTextEncode', inputs: { text: negativePrompt || '', clip: ['4', 1] } },
+        '8': { class_type: 'VAEDecode', inputs: { samples: ['3', 0], vae: ['4', 2] } },
+        '9': { class_type: 'SaveImage', inputs: { filename_prefix: 'dsh', images: ['8', 0] } },
+      },
+    }
+    const submit = await fetchImpl(`${base}/prompt`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ prompt: workflow, 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: '',
+          }
+        }
+      }
+    }
+  }
+  return local
+}