@goodandready/dsh-image-gen 0.11.24 → 0.11.26

package/lib/attachment-helper.js

@@ -1,6 +1,6 @@
 import path from 'node:path'
 import { mkdir, writeFile } from 'node:fs/promises'
-import { saveAttachmentSafe, buildSidecar, toLosslessJson } from './providers.js'
+import { saveAttachmentSafe, buildSidecar, toLosslessJson, ensureImageFormat } from './providers.js'
 import { recordSpend } from './cost-meter.js'
 import { buildDualOutputMarkdown } from './resolve-image.js'
 
@@ -21,6 +21,10 @@ export async function saveAndAttachResult(ctx, exec, cfg, {
   args = {},
   action = 'generated',
 }) {
+  const targetFormat = format || (mediaType ? mediaType.replace('image/', '') : undefined)
+  const formatted = await ensureImageFormat(bytes, targetFormat, { fallbackMime: mediaType })
+  bytes = formatted.bytes
+  mediaType = formatted.mediaType
   const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes, mediaType, name })
 
   const sessionCwd = exec?.agent?.session?.header?.cwd

package/lib/commands.js

@@ -85,11 +85,14 @@ export function registerImageCommand(ctx, deps) {
       const size = flags.size || cfg.defaultSize || 'square'
       const format = flags.format || cfg.defaultFormat || 'png'
       const aspectRatio = flags.aspect || flags.aspect_ratio || cfg.defaultAspectRatio
-      const effectiveStyle = flags.style || cfg.stylePreset
+      const effectivePreset = (flags.style_preset !== undefined && flags.style_preset !== null && flags.style_preset !== '')
+        ? flags.style_preset
+        : (flags.style || cfg.stylePreset || cfg.defaultStylePreset)
       const seed = flags.seed ? Number(flags.seed) : Math.floor(Math.random() * 2147483647)
 
-      const styleInfo = resolveStylePreset(effectiveStyle, flags.negative_prompt, flags.guidance_scale)
-      const effectivePrompt = applyStylePreset(prompt, effectiveStyle)
+      const styleInfo = resolveStylePreset(effectivePreset, flags.negative_prompt, flags.guidance_scale)
+      const effectivePrompt = styleInfo.promptSuffix ? `${prompt}, ${styleInfo.promptSuffix}` : prompt
+      const effectiveNegative = styleInfo.negativePrompt || flags.negative_prompt || cfg.negativePrompt
 
       const job = {
         prompt: effectivePrompt,
@@ -99,6 +102,9 @@ export function registerImageCommand(ctx, deps) {
         aspectPixels: aspectRatio ? ASPECT_RATIOS[aspectRatio] : undefined,
         seed,
         signal: invocation?.signal,
+        negativePrompt: effectiveNegative,
+        guidanceScale: styleInfo.guidanceScale ?? flags.guidance_scale,
+        style: flags.style,
       }
 
       const pdeps = {

package/lib/config-schema.js

@@ -176,8 +176,8 @@ export const Config = z.object({
     .volatile(),
   geminiModel: z
     .string()
-    .description('Google Gemini Imagen model identifier.')
-    .default('imagen-3.0-generate-002')
+    .description('Google Gemini image generation model identifier.')
+    .default('gemini-2.0-flash-exp-image-generation')
     .volatile(),
   geminiKeyEnv: z
     .string()

package/lib/frontend-assets.js

@@ -1,3 +1,4 @@
+import sharp from 'sharp'
 // @ts-check
 import path from 'node:path'
 import fs from 'node:fs/promises'
@@ -64,13 +65,12 @@ export function getContrastRatio(hex1, hex2) {
 }
 
 /**
- * Extract palette sample colors from raw image bytes.
- * Scans byte frequencies and samples color anchors across buffer.
- * @param {Buffer} buffer
- * @returns {string[]} Hex colors
+ * Extract dominant palette colors from decoded image pixels with alpha awareness (#372).
+ * @param {Buffer|Uint8Array} buffer
+ * @returns {Promise<string[]>} Hex colors
  */
-export function extractSampleColorsFromBuffer(buffer) {
-  if (!buffer || buffer.length < 16) {
+export async function extractSampleColorsFromBuffer(buffer) {
+  if (!buffer || buffer.length < 8) {
     return ['#0f172a', '#3b82f6', '#10b981', '#f59e0b', '#ef4444', '#f8fafc']
   }
 
@@ -95,42 +95,80 @@ export function extractSampleColorsFromBuffer(buffer) {
     }
   }
 
-  // Sample bytes from buffer chunks
-  const step = Math.max(4, Math.floor(buffer.length / 500))
-  const samples = []
-  for (let i = 64; i < buffer.length - 8; i += step) {
-    const r = buffer[i]
-    const g = buffer[i + 1]
-    const b = buffer[i + 2]
-    samples.push({ r, g, b })
-  }
-
-  if (samples.length === 0) {
-    return ['#0f172a', '#3b82f6', '#10b981', '#f59e0b', '#ef4444', '#f8fafc']
-  }
+  // Decode raster container to raw RGBA pixels via Sharp
+  try {
+    const { data, info } = await sharp(buffer)
+      .raw()
+      .ensureAlpha()
+      .toBuffer({ resolveWithObject: true })
+
+    const totalPixels = info.width * info.height
+    const step = Math.max(1, Math.floor(totalPixels / 2048))
+    const colorBuckets = new Map()
+
+    for (let i = 0; i < totalPixels; i += step) {
+      const off = i * 4
+      const r = data[off]
+      const g = data[off + 1]
+      const b = data[off + 2]
+      const a = data[off + 3]
+
+      // Ignore fully or mostly transparent pixels
+      if (a < 128) continue
+
+      // Quantize to 16-level RGB bins to cluster nearby nuances
+      const qr = Math.round(r / 16) * 16
+      const qg = Math.round(g / 16) * 16
+      const qb = Math.round(b / 16) * 16
+      const key = `${qr},${qg},${qb}`
+
+      let bucket = colorBuckets.get(key)
+      if (!bucket) {
+        bucket = { count: 0, rSum: 0, gSum: 0, bSum: 0 }
+        colorBuckets.set(key, bucket)
+      }
+      bucket.count++
+      bucket.rSum += r
+      bucket.gSum += g
+      bucket.bSum += b
+    }
 
-  samples.sort((a, b) => (a.r * 299 + a.g * 587 + a.b * 114) - (b.r * 299 + b.g * 587 + b.b * 114))
-
-  const anchors = []
-  const bucketSize = Math.floor(samples.length / 6)
-  for (let b = 0; b < 6; b++) {
-    const start = b * bucketSize
-    const end = b === 5 ? samples.length : start + bucketSize
-    let sumR = 0, sumG = 0, sumB = 0
-    for (let j = start; j < end; j++) {
-      sumR += samples[j].r
-      sumG += samples[j].g
-      sumB += samples[j].b
+    if (colorBuckets.size > 0) {
+      const sorted = Array.from(colorBuckets.values()).sort((a, b) => b.count - a.count)
+      const dominant = sorted.slice(0, 6).map((b) => {
+        return rgbToHex(b.rSum / b.count, b.gSum / b.count, b.bSum / b.count)
+      })
+
+      const result = [...dominant]
+      if (result.length < 5) {
+        const primaryRgb = hexToRgb(result[0])
+        const isNearBlack = primaryRgb.r === 0 && primaryRgb.g === 0 && primaryRgb.b === 0
+        if (isNearBlack) {
+          const darkShades = ['#1a1a1a', '#333333', '#4d4d4d', '#666666', '#808080']
+          for (const s of darkShades) {
+            if (result.length >= 6) break
+            if (!result.includes(s)) result.push(s)
+          }
+        } else {
+          const factors = [0.2, 0.4, 0.6, 0.8, 1.2, 1.4]
+          for (const factor of factors) {
+            if (result.length >= 6) break
+            const shade = rgbToHex(
+              Math.min(255, Math.round(primaryRgb.r * factor)),
+              Math.min(255, Math.round(primaryRgb.g * factor)),
+              Math.min(255, Math.round(primaryRgb.b * factor)),
+            )
+            if (!result.includes(shade)) result.push(shade)
+          }
+        }
+      }
+      return result.slice(0, 6)
     }
-    const count = Math.max(1, end - start)
-    anchors.push(rgbToHex(sumR / count, sumG / count, sumB / count))
+  } catch (_err) {
+    // If sharp cannot decode or buffer is non-image, fallback
   }
 
-  const unique = Array.from(new Set(anchors))
-  while (unique.length < 5) {
-    unique.push('#3b82f6')
-  }
-  return unique
+  return ['#0f172a', '#3b82f6', '#10b981', '#f59e0b', '#ef4444', '#f8fafc']
 }
 
 /**
@@ -394,9 +432,57 @@ export const ${componentName}: React.FC<${componentName}Props> = ({ size = 24, c
   }
 }
 
+export function buildIcoBuffer(pngFrames) {
+  const count = pngFrames.length
+  const headerLen = 6 + count * 16
+  let currentOffset = headerLen
+
+  const entries = []
+  for (const item of pngFrames) {
+    entries.push({
+      width: item.width >= 256 ? 0 : item.width,
+      height: item.height >= 256 ? 0 : item.height,
+      size: item.buffer.length,
+      offset: currentOffset,
+      buffer: item.buffer,
+    })
+    currentOffset += item.buffer.length
+  }
+
+  const out = Buffer.alloc(currentOffset)
+  // Header: reserved 0, type 1 (icon), count
+  out.writeUInt16LE(0, 0)
+  out.writeUInt16LE(1, 2)
+  out.writeUInt16LE(count, 4)
+
+  let entryPos = 6
+  for (const entry of entries) {
+    out.writeUInt8(entry.width, entryPos)
+    out.writeUInt8(entry.height, entryPos + 1)
+    out.writeUInt8(0, entryPos + 2) // color count
+    out.writeUInt8(0, entryPos + 3) // reserved
+    out.writeUInt16LE(1, entryPos + 4) // planes
+    out.writeUInt16LE(32, entryPos + 6) // bpp
+    out.writeUInt32LE(entry.size, entryPos + 8) // size
+    out.writeUInt32LE(entry.offset, entryPos + 12) // offset
+    entry.buffer.copy(out, entry.offset)
+    entryPos += 16
+  }
+  return out
+}
+
+async function getDefaultIconBytes(name, themeColor) {
+  const initial = (name || 'A').trim().charAt(0).toUpperCase() || 'A'
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 512 512">
+    <rect width="512" height="512" rx="100" fill="${themeColor || '#0f172a'}"/>
+    <text x="50%" y="54%" font-family="system-ui, -apple-system, sans-serif" font-size="280" font-weight="bold" fill="#ffffff" dominant-baseline="middle" text-anchor="middle">${initial}</text>
+  </svg>`
+  return sharp(Buffer.from(svg)).png().toBuffer()
+}
+
 /**
- * Issue #190: generate_pwa_icon_suite
- * Generates standard PWA icon suite metadata, web app manifest.json, and icon configuration.
+ * Issue #190 & #387: generate_pwa_icon_suite
+ * Generates standard PWA icon suite, web app manifest.json, multi-resolution favicon.ico, and HTML snippet.
  */
 export async function generatePwaIconSuite({
   name = 'App',
@@ -405,7 +491,20 @@ export async function generatePwaIconSuite({
   backgroundColor = '#ffffff',
   iconsDir = 'icons',
   sourcePath = null,
+  imageBytes = null,
+  outDir = null,
 } = {}) {
+  // 1. Resolve source image buffer
+  let source = imageBytes
+  if (!source && sourcePath) {
+    try {
+      source = await fs.readFile(sourcePath)
+    } catch (_err) { source = null }
+  }
+  if (!source) {
+    source = await getDefaultIconBytes(name, themeColor)
+  }
+
   const iconSizes = [
     { size: 16, rel: 'icon', filename: `${iconsDir}/favicon-16x16.png`, purpose: 'any' },
     { size: 32, rel: 'icon', filename: `${iconsDir}/favicon-32x32.png`, purpose: 'any' },
@@ -416,6 +515,53 @@ export async function generatePwaIconSuite({
     { size: 512, rel: 'manifest', filename: `${iconsDir}/icon-512x512-maskable.png`, purpose: 'maskable' },
   ]
 
+  // 2. Render all PNG icons via Sharp
+  const generatedIcons = []
+  const icoFrames = []
+
+  for (const item of iconSizes) {
+    let pngBuf
+    if (item.purpose === 'maskable') {
+      // Safe zone requires 10% padding on each side -> inner icon is 80% of canvas (#387)
+      const innerSize = Math.max(1, Math.round(item.size * 0.8))
+      const inner = await sharp(source)
+        .resize(innerSize, innerSize, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+        .png()
+        .toBuffer()
+
+      pngBuf = await sharp({
+        create: {
+          width: item.size,
+          height: item.size,
+          channels: 4,
+          background: backgroundColor || '#ffffff',
+        },
+      })
+        .composite([{ input: inner, gravity: 'center' }])
+        .png()
+        .toBuffer()
+    } else {
+      pngBuf = await sharp(source)
+        .resize(item.size, item.size, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+        .png()
+        .toBuffer()
+    }
+
+    generatedIcons.push({
+      ...item,
+      bytes: pngBuf,
+    })
+
+    if ([16, 32, 48].includes(item.size) && item.rel === 'icon') {
+      icoFrames.push({ width: item.size, height: item.size, buffer: pngBuf })
+    }
+  }
+
+  // 3. Multi-resolution favicon.ico containing 16, 32, 48 px PNG frames (#387)
+  const faviconIcoBuffer = buildIcoBuffer(icoFrames)
+  const faviconIcoFilename = `${iconsDir}/favicon.ico`
+
+  // 4. Manifest JSON
   const manifest = {
     name,
     short_name: shortName,
@@ -423,7 +569,7 @@ export async function generatePwaIconSuite({
     display: 'standalone',
     background_color: backgroundColor,
     theme_color: themeColor,
-    icons: iconSizes
+    icons: generatedIcons
       .filter((i) => i.rel === 'manifest')
       .map((i) => ({
         src: i.filename,
@@ -432,8 +578,11 @@ export async function generatePwaIconSuite({
         purpose: i.purpose,
       })),
   }
+  const manifestJson = JSON.stringify(manifest, null, 2)
 
+  // 5. HTML snippet
   const htmlHeadSnippet = [
+    `<link rel="icon" href="/${faviconIcoFilename}" sizes="any">`,
     `<link rel="icon" type="image/png" sizes="16x16" href="/${iconsDir}/favicon-16x16.png">`,
     `<link rel="icon" type="image/png" sizes="32x32" href="/${iconsDir}/favicon-32x32.png">`,
     `<link rel="apple-touch-icon" sizes="180x180" href="/${iconsDir}/apple-touch-icon.png">`,
@@ -441,13 +590,39 @@ export async function generatePwaIconSuite({
     `<meta name="theme-color" content="${themeColor}">`,
   ].join('\n')
 
+  // 6. Write files to outDir if provided
+  const exportedFiles = []
+  if (outDir) {
+    const fullIconsDir = path.resolve(outDir, iconsDir)
+    await fs.mkdir(fullIconsDir, { recursive: true })
+
+    for (const item of generatedIcons) {
+      const filePath = path.resolve(outDir, item.filename)
+      await fs.writeFile(filePath, item.bytes)
+      exportedFiles.push(filePath)
+    }
+
+    const icoPath = path.resolve(outDir, faviconIcoFilename)
+    await fs.writeFile(icoPath, faviconIcoBuffer)
+    exportedFiles.push(icoPath)
+
+    const manifestPath = path.resolve(outDir, 'manifest.json')
+    await fs.writeFile(manifestPath, manifestJson)
+    exportedFiles.push(manifestPath)
+  }
+
+  // Strip internal bytes property from public icons list to avoid huge JSON serialization
+  const cleanIcons = generatedIcons.map(({ bytes, ...rest }) => rest)
+
   return {
     name,
     shortName,
     themeColor,
     backgroundColor,
-    icons: iconSizes,
-    manifestJson: JSON.stringify(manifest, null, 2),
+    icons: cleanIcons,
+    faviconIco: faviconIcoFilename,
+    manifestJson,
     htmlHeadSnippet,
+    exportedFiles,
   }
 }

package/lib/generation-helpers.js

@@ -13,6 +13,7 @@ import {
   embedPngMetadata,
   resolveStylePreset,
   saveAttachmentSafe,
+  ensureImageFormat,
 } from './providers.js'
 import { enhancePrompt } from './prompt-enhancer.js'
 import { buildFaceConsistencyPrompt, getSessionAnchor, applyAnchorPromptHints } from './anchor-helpers.js'
@@ -23,6 +24,7 @@ import {
   readHistory,
   writeHistory,
   pruneHistory,
+  appendHistoryEntry,
 } from './history.js'
 
 /** Run an array of async task functions with a concurrency cap */
@@ -62,8 +64,10 @@ export function validateGenerationParams(cfg, args) {
 /** Prepares enhanced prompt, style hints, facial identity, anchors, and sanitized negative prompt */
 export async function prepareGenerationPrompt({ ctx, cfg, args, exec, sessionId, provider, resolveSource }) {
   const enhanced = await enhancePrompt(ctx, cfg, args.prompt, exec.signal, provider)
-  const effectiveStyle = args.style || cfg.stylePreset
-  const styleInfo = resolveStylePreset(effectiveStyle, args.negative_prompt, args.guidance_scale)
+  const candidatePreset = (args.style_preset !== undefined && args.style_preset !== null && args.style_preset !== '')
+    ? args.style_preset
+    : (cfg.stylePreset || cfg.defaultStylePreset)
+  const styleInfo = resolveStylePreset(candidatePreset, args.negative_prompt, args.guidance_scale)
   let effectivePrompt = styleInfo.promptSuffix ? `${enhanced.prompt}, ${styleInfo.promptSuffix}` : enhanced.prompt
   let effectiveNegative = styleInfo.negativePrompt
   const activeAnchor = getSessionAnchor(sessionId)
@@ -132,8 +136,10 @@ export async function saveGeneratedImageArtifact({
   estimatedCost,
   totalCount,
 }) {
-  const mediaType = gen.mediaType || 'image/png'
-  let bytes = gen.bytes
+  const targetFormat = format || (args.output_format || cfg.defaultFormat)
+  const formatted = await ensureImageFormat(gen.bytes, targetFormat, { fallbackMime: gen.mediaType })
+  let bytes = formatted.bytes
+  const mediaType = formatted.mediaType || 'image/png'
   if (mediaType === 'image/png') {
     bytes = embedPngMetadata(bytes, {
       prompt: promptArg,
@@ -189,7 +195,10 @@ export async function saveGeneratedImageArtifact({
     prompt: promptArg,
     seed: gen.seed,
     size: args.aspect_ratio ? 'custom' : (args.image_size || cfg.defaultSize),
-    style: args.style || cfg.stylePreset,
+    style: args.style,
+    stylePreset: (args.style_preset !== undefined && args.style_preset !== null && args.style_preset !== '')
+      ? args.style_preset
+      : (cfg.stylePreset || cfg.defaultStylePreset),
     format: format || args.output_format || cfg.defaultFormat || 'png',
     aspectRatio: args.aspect_ratio || cfg.defaultAspectRatio,
     negativePrompt: args.negative_prompt || cfg.negativePrompt,
@@ -229,13 +238,10 @@ export async function saveGeneratedImageArtifact({
     attachmentId: attachment.attachmentId,
   }
   // Save to history (#385: historyLimit=0 skips history retention; bounds guard against negative values)
+  // #365: Atomic transaction with file lock prevents read-modify-write race during concurrent batches
   const historyLimit = typeof cfg.historyLimit === 'number' ? Math.max(0, Math.floor(cfg.historyLimit)) : 50
   if (historyLimit > 0) {
-    let current = await readHistory()
-    current = await pruneHistory(current, cfg.pruneDays)
-    current.unshift(entry)
-    if (current.length > historyLimit) current.length = historyLimit
-    await writeHistory(current)
+    await appendHistoryEntry(entry, { pruneDays: cfg.pruneDays, historyLimit })
   }
 
   // #167: Record spend in cost meter

package/lib/history.js

@@ -1,9 +1,30 @@
 import path from 'node:path'
 import os from 'node:os'
 import { existsSync, unlinkSync, chmodSync, readdirSync, statSync } from 'node:fs'
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { readFile, mkdir } from 'node:fs/promises'
+import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
 import { enforceSecurePermissions } from './security.js'
 
+let inMemoryLockQueue = Promise.resolve()
+
+/** Execute an operation with in-process queue + cross-process file lock (#365) */
+export async function withHistoryLock(operation, options = { waitMs: 5000 }) {
+  const file = historyFile()
+  const dir = path.dirname(file)
+  try {
+    await mkdir(dir, { recursive: true, mode: 0o700 })
+    try { chmodSync(dir, 0o700) } catch (_err) { /* non-fatal permission repair */ }
+  } catch (_err) { /* non-fatal mkdir */ }
+
+  const runWithLocks = async () => {
+    return await withFileLock(file, operation, options)
+  }
+
+  const next = inMemoryLockQueue.then(runWithLocks, runWithLocks)
+  inMemoryLockQueue = next.catch(() => {})
+  return await next
+}
+
 export function historyFile() {
   return path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'dsh-image-gen', 'history.json')
 }
@@ -104,21 +125,50 @@ export async function readHistory() {
     const raw = await readFile(historyFile(), 'utf-8')
     const parsed = JSON.parse(raw)
     return Array.isArray(parsed) ? parsed : []
-  } catch (e) {
+  } catch (_e) {
     return []
   }
 }
 
-/** Save history to disk file (atomic overwrite). */
+/** Save history to disk file (atomic overwrite with 0600 mode via dsh-atomic-write). */
 export async function writeHistory(entries) {
   try {
     const file = historyFile()
     const dir = path.dirname(file)
     await mkdir(dir, { recursive: true, mode: 0o700 })
     try { chmodSync(dir, 0o700) } catch (_err) { /* non-fatal permission repair */ }
-    await writeFile(file, JSON.stringify(entries, null, 2), { mode: 0o600 })
+    await writeFileAtomic(file, JSON.stringify(entries, null, 2), {
+      mode: 0o600,
+      dirMode: 0o700,
+    })
     enforceSecurePermissions(file)
-  } catch (e) { /* history write failure is non-fatal */ }
+  } catch (_e) { /* history write failure is non-fatal */ }
+}
+
+/**
+ * Atomically append an entry to history, running read -> prune -> unshift -> write
+ * under an exclusive lock transaction (#365).
+ */
+export async function appendHistoryEntry(entry, { pruneDays = 0, historyLimit = 50 } = {}) {
+  if (!entry || historyLimit <= 0) return []
+  return await withHistoryLock(async () => {
+    let current = await readHistory()
+    if (pruneDays > 0) {
+      current = await pruneHistory(current, pruneDays)
+    }
+    const existingIdx = current.findIndex(
+      (e) => (entry.attachmentId && e.attachmentId === entry.attachmentId) || (entry.path && e.path === entry.path)
+    )
+    if (existingIdx !== -1) {
+      current.splice(existingIdx, 1)
+    }
+    current.unshift(entry)
+    if (current.length > historyLimit) {
+      current.length = historyLimit
+    }
+    await writeHistory(current)
+    return current
+  })
 }
 
 /** Filter entries whose files exist on disk; newest first. */

package/lib/pattern-helpers.js

@@ -1,3 +1,4 @@
+import sharp from 'sharp'
 // Pure helpers for generate_seamless_pattern (#178)
 
 export function buildSeamlessPrompt(motif, style, density) {
@@ -85,3 +86,19 @@ export function tilePixels(pixels, width, height, channels, cols, rows) {
   }
   return { pixels: out, width: outW, height: outH }
 }
+
+/**
+ * Decodes image container to raw RGBA pixels and scores edge wrap continuity (#371).
+ * Returns 0..1 (1 = identical opposite edges).
+ * @param {Buffer|Uint8Array} imageBytes
+ * @returns {Promise<number>}
+ */
+export async function scoreImageEdgeWrap(imageBytes) {
+  if (!imageBytes || imageBytes.length === 0) return 0
+  try {
+    const { data, info } = await sharp(imageBytes).raw().ensureAlpha().toBuffer({ resolveWithObject: true })
+    return scoreEdgeWrap(data, info.width, info.height, info.channels)
+  } catch {
+    return 0
+  }
+}