evomeme 0.1.9 → 0.1.10-beta.13

package/dist/canvas-public/features/frame-editor/frame-model.js

@@ -0,0 +1,63 @@
+export const FRAME_EDITOR_WIDTH = 780
+
+export function normalizeFrameEditorFrame(value, sourceRows, sourceColumns) {
+  if (!value || typeof value !== 'object') return null
+  if (value.kind === 'source_cell') {
+    const index = Math.round(Number(value.index))
+    if (!Number.isFinite(index) || index < 0 || index >= sourceRows * sourceColumns) return null
+    return { kind: 'source_cell', index }
+  }
+  if (value.kind === 'asset') {
+    const assetId = String(value.assetId || value.asset_id || '').trim()
+    return assetId ? { kind: 'asset', assetId } : null
+  }
+  return null
+}
+
+export function normalizeFrameEditor(item) {
+  if (item?.type !== 'frame_editor') return null
+  const sourceId = String(item.sourceId || '').trim()
+  const sourceRows = Math.round(Number(item.sourceRows))
+  const sourceColumns = Math.round(Number(item.sourceColumns))
+  const rows = Math.round(Number(item.rows))
+  const columns = Math.round(Number(item.columns))
+  const fps = Number(item.fps)
+  if (
+    !sourceId ||
+    !Number.isFinite(sourceRows) ||
+    !Number.isFinite(sourceColumns) ||
+    !Number.isFinite(rows) ||
+    !Number.isFinite(columns) ||
+    !Number.isFinite(fps) ||
+    sourceRows < 1 ||
+    sourceRows > 64 ||
+    sourceColumns < 1 ||
+    sourceColumns > 64 ||
+    rows < 1 ||
+    rows > 64 ||
+    columns < 1 ||
+    columns > 64 ||
+    fps <= 0
+  ) {
+    return null
+  }
+  const frames = (Array.isArray(item.frames) ? item.frames : [])
+    .map((frame) => normalizeFrameEditorFrame(frame, sourceRows, sourceColumns))
+    .filter(Boolean)
+    .slice(0, rows * columns)
+  return { sourceId, sourceRows, sourceColumns, rows, columns, fps, frames }
+}
+
+export function frameEditorWidth(value) {
+  const width = Number(value)
+  return Number.isFinite(width) ? Math.max(FRAME_EDITOR_WIDTH, width) : FRAME_EDITOR_WIDTH
+}
+
+export function frameEditorParentIds(item) {
+  const editor = normalizeFrameEditor(item)
+  if (!editor) return []
+  return [
+    editor.sourceId,
+    ...editor.frames.filter((frame) => frame.kind === 'asset').map((frame) => frame.assetId),
+  ].filter((id, index, ids) => id && ids.indexOf(id) === index)
+}

package/dist/canvas-public/features/frame-editor/playback.js

@@ -0,0 +1,83 @@
+import { state } from '../../core/state.js'
+import {
+  advanceScrollPreviewOffset,
+  applyFrameSheetPreviewFrame,
+  applyScrollImagePreviewOffset,
+  frameSheetPreviewMeta,
+  scrollImagePreviewMeta,
+} from '../../elements/image.js'
+import { applyFrameEditorPreviewFrame } from './frame-editing.js'
+import { normalizeFrameEditor } from './frame-model.js'
+
+// Media playback is independent of feature parameter forms and shares one animation clock.
+export function startFramePlayback({ elements, imageUrl }) {
+  let lastFrameSheetPreviewTimestamp = 0
+
+  function tickFrameSheetPreviews(timestamp) {
+    if (!lastFrameSheetPreviewTimestamp) lastFrameSheetPreviewTimestamp = timestamp
+    const deltaSeconds = Math.min(
+      0.25,
+      Math.max(0, timestamp - lastFrameSheetPreviewTimestamp) / 1000,
+    )
+    lastFrameSheetPreviewTimestamp = timestamp
+
+    for (const preview of elements.world.querySelectorAll('.frame-sheet-preview[data-asset-id]')) {
+      const assetId = preview.dataset.assetId
+      const item = state.layoutItems.find((candidate) => candidate.id === assetId)
+      const meta = frameSheetPreviewMeta(item)
+      if (!meta || meta.frameCount < 2) continue
+      const play = state.frameSheetPlayback[assetId] || { index: 0, acc: 0 }
+      play.acc += deltaSeconds
+      const frameDuration = 1 / meta.fps
+      let changed = false
+      const elapsedFrames = Math.floor(play.acc / frameDuration)
+      if (elapsedFrames > 0) {
+        play.acc -= elapsedFrames * frameDuration
+        play.index = (play.index + elapsedFrames) % meta.frameCount
+        changed = true
+      }
+      state.frameSheetPlayback[assetId] = play
+      if (changed) applyFrameSheetPreviewFrame(preview, meta, play.index)
+    }
+
+    for (const preview of elements.world.querySelectorAll('.scroll-image-preview[data-asset-id]')) {
+      const assetId = preview.dataset.assetId
+      const item = state.layoutItems.find((candidate) => candidate.id === assetId)
+      const meta = scrollImagePreviewMeta(item)
+      if (!meta) continue
+      const play = state.scrollImagePlayback[assetId] || { offset: 0 }
+      play.offset = advanceScrollPreviewOffset(
+        play.offset,
+        meta,
+        deltaSeconds,
+        preview.clientWidth,
+      )
+      state.scrollImagePlayback[assetId] = play
+      applyScrollImagePreviewOffset(preview, play.offset)
+    }
+
+    for (const preview of elements.world.querySelectorAll(
+      '.frame-editor-preview-stage[data-editor-id]',
+    )) {
+      const editorId = preview.dataset.editorId
+      const editor = normalizeFrameEditor(
+        state.layoutItems.find((candidate) => candidate.id === editorId),
+      )
+      if (!editor || editor.frames.length < 2) continue
+      const play = state.frameSheetPlayback[editorId] || { index: 0, acc: 0 }
+      play.acc += deltaSeconds
+      const frameDuration = 1 / editor.fps
+      const elapsedFrames = Math.floor(play.acc / frameDuration)
+      if (elapsedFrames > 0) {
+        play.acc -= elapsedFrames * frameDuration
+        play.index = (play.index + elapsedFrames) % editor.frames.length
+        applyFrameEditorPreviewFrame(preview, editor, play.index, imageUrl)
+      }
+      state.frameSheetPlayback[editorId] = play
+    }
+
+    requestAnimationFrame(tickFrameSheetPreviews)
+  }
+
+  requestAnimationFrame(tickFrameSheetPreviews)
+}

package/dist/canvas-public/features/frame-editor/preview.js

@@ -0,0 +1,151 @@
+import { errorT } from '../../language/index.js'
+import { t } from '../../language/index.js'
+import { state } from '../../core/state.js'
+import {
+  frameSheetPreviewMeta,
+  normalizeFramePreviewConfig,
+  normalizeScrollPreviewConfig,
+  sourceFramePreviewConfig,
+  suggestedFramePreviewConfig,
+} from '../../elements/image.js'
+
+export async function detectFramePreviewCount(imageId, rows, columns, imageUrl) {
+  const image = new Image()
+  image.crossOrigin = 'anonymous'
+  await new Promise((resolve, reject) => {
+    image.onload = resolve
+    image.onerror = () => reject(new Error(errorT('features.frameEditor.frameEditingDialogs.text007')))
+    image.src = imageUrl(imageId)
+  })
+  const canvas = document.createElement('canvas')
+  for (let index = rows * columns - 1; index >= 0; index -= 1) {
+    const row = Math.floor(index / columns),
+      column = index % columns
+    const left = Math.floor((column * image.naturalWidth) / columns),
+      top = Math.floor((row * image.naturalHeight) / rows)
+    const width = Math.max(1, Math.floor(((column + 1) * image.naturalWidth) / columns) - left)
+    const height = Math.max(1, Math.floor(((row + 1) * image.naturalHeight) / rows) - top)
+    canvas.width = width
+    canvas.height = height
+    const context = canvas.getContext('2d', { willReadFrequently: true })
+    if (!context) return rows * columns
+    context.drawImage(image, left, top, width, height, 0, 0, width, height)
+    const pixels = context.getImageData(0, 0, width, height).data
+    for (let offset = 3; offset < pixels.length; offset += 4)
+      if (pixels[offset] !== 0) return index + 1
+  }
+  return 1
+}
+
+export async function applyFramePreview(source, params, services) {
+  const hadFramePreview = Object.prototype.hasOwnProperty.call(source, 'framePreview')
+  const previousFramePreview = source.framePreview
+  const hadScrollPreview = Object.prototype.hasOwnProperty.call(source, 'scrollPreview')
+  const previousScrollPreview = source.scrollPreview
+  const known = normalizeFramePreviewConfig(previousFramePreview) || sourceFramePreviewConfig(source)
+  const frameCount =
+    known && known.rows === params.rows && known.columns === params.columns
+      ? Math.min(known.frameCount, params.rows * params.columns)
+      : await detectFramePreviewCount(source.id, params.rows, params.columns, services.imageUrl)
+  source.framePreview = {
+    enabled: params.enabled,
+    rows: params.rows,
+    columns: params.columns,
+    fps: params.fps,
+    frameCount,
+  }
+  if (params.enabled) {
+    const scrollPreview = normalizeScrollPreviewConfig(source.scrollPreview)
+    if (scrollPreview?.enabled) source.scrollPreview = { ...scrollPreview, enabled: false }
+  }
+  try {
+    await services.saveLayout()
+  } catch (error) {
+    if (hadFramePreview) source.framePreview = previousFramePreview
+    else delete source.framePreview
+    if (hadScrollPreview) source.scrollPreview = previousScrollPreview
+    else delete source.scrollPreview
+    throw error
+  }
+  if (params.enabled) {
+    state.frameSheetPlayback[source.id] = { index: 0, acc: 0 }
+    delete state.scrollImagePlayback[source.id]
+  }
+  else delete state.frameSheetPlayback[source.id]
+  services.renderCanvasItem(source.id)
+}
+
+export default {
+  render: (ui) =>
+    ui.stack(ui.field('enabled'), ui.row(ui.field('rows'), ui.field('columns')), ui.field('fps')),
+  id: 'frame-sheet-preview',
+  title: 'inspector.framePreview.text001',
+  storage: 'parameters',
+  node: {
+    type: 'feature_dialog',
+    width: 320,
+    minWidth: 280,
+    minHeight: 220,
+    generationInput: true,
+    classNames: ['is-interactive-ui'],
+  },
+  menu: [
+    {
+      group: 'frame-sheet',
+      title: 'html.text061',
+      titleFor: (source) =>
+        frameSheetPreviewMeta(source)
+          ? 'dialogs.contextMenu.text001'
+          : 'dialogs.contextMenu.text002',
+      accepts: ['image'],
+    },
+  ],
+  fields: [
+    { path: 'enabled', type: 'boolean', default: true, label: 'inspector.framePreview.text008' },
+    {
+      path: 'rows',
+      type: 'integer',
+      default: 2,
+      min: 1,
+      max: 64,
+      required: true,
+      label: 'common.rows',
+    },
+    {
+      path: 'columns',
+      type: 'integer',
+      default: 2,
+      min: 1,
+      max: 64,
+      required: true,
+      label: 'common.columns',
+    },
+    {
+      path: 'fps',
+      type: 'number',
+      default: 8,
+      min: 0.000001,
+      step: 'any',
+      required: true,
+      label: 'common.framesPerSecond',
+    },
+  ],
+  async sourceAction(source, services) {
+    const config = frameSheetPreviewMeta(source)
+    if (!config) return false
+    await applyFramePreview(source, { ...config, enabled: false }, services)
+    services.renderChrome()
+    return true
+  },
+  prefill: (source) => ({ ...suggestedFramePreviewConfig(source), enabled: true }),
+  validate: (p) => (p.rows * p.columns >= 2 ? '' : t('inspector.framePreview.text009')),
+  submitLabel: 'html.text072',
+  async execute(p, item, services) {
+    const source = state.layoutItems.find((entry) => entry.id === item.sourceId)
+    if (!source) throw new Error(errorT('inspector.framePreview.text011'))
+    await applyFramePreview(source, p, services)
+    await services.replaceLocal(item, [])
+    services.setSelection([source.id])
+    services.renderChrome()
+  },
+}

package/dist/canvas-public/features/generation/animation.js

@@ -0,0 +1,272 @@
+import { state } from '../../core/state.js'
+import { t } from '../../language/index.js'
+import { featureDefaults } from '../../core/feature-state.js'
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  booleanField,
+  colorField,
+} from './fields.js'
+
+const key = (n) => `features.generation.animationGeneration.text${String(n).padStart(3, '0')}`
+const enabled = (path, value = true) => ({ path, type: 'hidden', default: value })
+const number = (path, label, value, min, max, extra = {}) => ({
+  path,
+  type: 'number',
+  label,
+  default: value,
+  min,
+  max,
+  step: 0.1,
+  ...extra,
+})
+const size = (value) =>
+  String(value || '')
+    .trim()
+    .replace(/[×*X]/g, 'x')
+    .replace(/\s+/g, '')
+
+const animationFeature = {
+  styles:
+    '[data-feature-form="animation"][data-surface="canvas"] .feature-form-content { max-height: 600px; }',
+  render(ui, { inspector }) {
+    const first = ui.section(
+      'firstFrameEnabled',
+      ui.field('firstFrameRefs'),
+      ui.prompt('firstFramePrompt'),
+      ui.row(ui.field('imageModel'), ui.field('imageSize')),
+      ui.field('backgroundColor'),
+      ui.field('expandImage'),
+    )
+    const video = ui.section(
+      'video',
+      ui.field('reuseFirstFrameAsLast'),
+      ui.row(ui.field('videoFirstFrameRef'), ui.field('videoLastFrameRef')),
+      ui.prompt('videoPrompt'),
+      ui.row(ui.field('duration'), ui.field('videoResolution')),
+    )
+    const keying = ui.section(
+      'colorKeyEnabled',
+      ui.field('keyBackgroundColor'),
+      ui.field('colorKeyStrength'),
+      ui.field('colorKeyContiguousOnly'),
+      ui.field('colorKeyDespill'),
+    )
+    const cycle = ui.section('cycleEnabled')
+    const extraction = ui.section('frameExtractionEnabled')
+    const modules = inspector
+      ? ui.stack(first, video, cycle, extraction, keying)
+      : ui.row(ui.stack(first, keying), ui.stack(video, cycle, extraction))
+    modules.style.setProperty('--field-min', '330px')
+    return ui.stack(ui.field('animationPreset'), modules)
+  },
+  toolbar: [
+    { id: 'tool-animation-gen', group: 'video', label: 'html.text043', title: 'html.text014' },
+  ],
+  id: 'animation',
+  title: 'features.generation.generationDialog.text001',
+  node: generationNode('animation_dialog', 900, {
+    minWidth: 400,
+    minHeight: 360,
+    classNames: ['is-interactive-ui', 'is-gen-dialog', 'is-animation-dialog'],
+  }),
+  storage: 'animationGeneration',
+  submitLabel: key(46),
+  fields: [
+    {
+      path: 'animationPreset',
+      type: 'enum',
+      default: 'custom',
+      label: key(14),
+      options: ['walk', 'run', 'attack', 'jump', 'custom'].map((value, index) => ({
+        value,
+        labelKey: key(15 + index),
+      })),
+    },
+    {
+      label: key(21),
+      enablePath: 'firstFrameEnabled',
+      fields: [
+        enabled('firstFrameEnabled'),
+        refsField({
+          path: 'firstFrameRefs',
+          required: true,
+          label: 'features.generation.directionGeneration.text012',
+        }),
+        promptField({ path: 'firstFramePrompt', label: key(23), placeholder: key(22) }),
+        colorField(),
+        modelField({ path: 'imageModel', default: 'asset-pro' }),
+        { path: 'imageSize', type: 'text', default: '2048x2048', label: key(26) },
+        booleanField('expandImage', key(27), true),
+      ],
+    },
+    {
+      id: 'video',
+      label: key(28),
+      fields: [
+        booleanField('reuseFirstFrameAsLast', key(29), false, {
+          visible: (p) => p.firstFrameEnabled,
+        }),
+        refsField({
+          path: 'videoFirstFrameRef',
+          default: null,
+          multiple: false,
+          required: true,
+          label: key(30),
+          visible: (p) => !p.firstFrameEnabled,
+        }),
+        refsField({
+          path: 'videoLastFrameRef',
+          default: null,
+          multiple: false,
+          label: key(31),
+          visible: (p) => !p.firstFrameEnabled,
+        }),
+        promptField({ path: 'videoPrompt', label: key(23), required: true, placeholder: key(32) }),
+        number('duration', key(33), 4, 4, 15, { type: 'integer', step: 1 }),
+        {
+          path: 'videoResolution',
+          type: 'enum',
+          default: '720p',
+          label: key(34),
+          options: () => state.meta?.video?.resolutions || ['480p', '720p', '1080p'],
+        },
+      ],
+    },
+    {
+      label: key(35),
+      enablePath: 'cycleEnabled',
+      fields: [enabled('cycleEnabled'), number('cycleSimilarity', key(36), 95, 0, 100)],
+    },
+    {
+      label: key(37),
+      enablePath: 'frameExtractionEnabled',
+      fields: [
+        enabled('frameExtractionEnabled'),
+        number('fps', 'common.framesPerSecond', 8, 0.1, 60),
+      ],
+    },
+    {
+      label: key(38),
+      enablePath: 'colorKeyEnabled',
+      disabled: (p) => !p.frameExtractionEnabled,
+      fields: [
+        enabled('colorKeyEnabled'),
+        colorField('backgroundColor', {
+          id: 'keyBackgroundColor',
+          visible: (p) => !p.firstFrameEnabled,
+        }),
+        number('colorKeyStrength', key(39), 80, 0, 100, { step: 1 }),
+        booleanField('colorKeyContiguousOnly', key(40)),
+        booleanField('colorKeyDespill', key(41)),
+      ],
+    },
+  ],
+  migrate(saved) {
+    if (!saved.firstFrameRefs && saved.firstFrameRef?.id)
+      saved.firstFrameRefs = [saved.firstFrameRef]
+    return saved
+  },
+  changed(p, path) {
+    if (path === 'animationPreset') applyAnimationPreset(p, p.animationPreset)
+  },
+  validate(p) {
+    if (p.firstFrameEnabled && !/^([1-9]\d*)x([1-9]\d*)$/.test(size(p.imageSize))) return t(key(50))
+    const durations = state.meta?.video?.durations || [4, 5, 6, 8, 10, 12, 15]
+    return durations.includes(Number(p.duration))
+      ? ''
+      : t(key(51)) + durations.filter((v) => v >= 4).join('、') + t(`${key(51)}.part1`)
+  },
+  task(p) {
+    const references = (
+      p.firstFrameEnabled ? p.firstFrameRefs : [p.videoFirstFrameRef, p.videoLastFrameRef]
+    )
+      .filter(Boolean)
+      .map((r) => ({ id: r.id, role: 'source', kind: 'image' }))
+    return {
+      endpoint: '/api/generate-animation',
+      options: { allowExternalSync: true, retainUntilSettled: true },
+      wait: {
+        name: t(key(52)),
+        width: 360,
+        height: 240,
+        prompt: p.videoPrompt.trim(),
+        media: p.frameExtractionEnabled ? 'image' : 'video',
+        ratio: 'adaptive',
+        model: 'animation-pipeline',
+        size: `${p.videoResolution} · ${p.duration}s · ${p.fps} FPS`,
+        references,
+      },
+      body: {
+        first_frame_enabled: p.firstFrameEnabled,
+        first_frame_prompt: p.firstFramePrompt,
+        first_frame_reference_ids: p.firstFrameRefs.map((r) => r.id),
+        background_color: p.backgroundColor,
+        expand_image: p.expandImage,
+        image_model: p.imageModel,
+        image_size: size(p.imageSize),
+        video_first_frame_id: p.videoFirstFrameRef?.id || null,
+        video_last_frame_id: p.videoLastFrameRef?.id || null,
+        reuse_first_frame_as_last: p.reuseFirstFrameAsLast,
+        video_prompt: p.videoPrompt.trim(),
+        duration: Number(p.duration),
+        video_resolution: p.videoResolution,
+        cycle_enabled: p.cycleEnabled,
+        cycle_similarity: p.cycleSimilarity,
+        frame_extraction_enabled: p.frameExtractionEnabled,
+        fps: p.fps,
+        color_key_enabled: p.colorKeyEnabled && p.frameExtractionEnabled,
+        color_key_strength: p.colorKeyStrength,
+        color_key_contiguous_only: p.colorKeyContiguousOnly,
+        color_key_despill: p.colorKeyDespill,
+        place: false,
+      },
+    }
+  },
+}
+
+export default animationFeature
+
+export function applyAnimationPreset(dialog, preset) {
+  dialog.animationPreset = preset
+  if (!['walk', 'run', 'attack', 'jump'].includes(preset)) return
+  const defaults = featureDefaults(animationFeature)
+  const firstFrameRefs = dialog.firstFrameRefs || []
+  const videoFirstFrameRef = dialog.videoFirstFrameRef || null
+  const videoLastFrameRef = dialog.videoLastFrameRef || null
+  const messages = dialog.messages || []
+  const busy = dialog.busy === true
+  Object.assign(dialog, defaults, {
+    animationPreset: preset,
+    firstFrameRefs,
+    ...(preset === 'attack' ? { videoFirstFrameRef, videoLastFrameRef } : {}),
+    messages,
+    busy,
+    firstFrameEnabled: preset !== 'attack',
+    firstFramePrompt:
+      preset === 'attack'
+        ? ''
+        : preset === 'jump'
+          ? t('features.generation.animationState.text001')
+          : preset === 'run'
+            ? t('features.generation.animationState.text002')
+            : t('features.generation.animationState.text003'),
+    imageSize: '2048x2048',
+    expandImage: true,
+    reuseFirstFrameAsLast: preset !== 'attack',
+    videoPrompt:
+      preset === 'attack'
+        ? t('features.generation.animationState.text004')
+        : preset === 'jump'
+          ? t('features.generation.animationState.text005')
+          : preset === 'run'
+            ? t('features.generation.animationState.text006')
+            : t('features.generation.animationState.text007'),
+    duration: 4,
+    videoResolution: '480p',
+    cycleEnabled: !['attack', 'jump'].includes(preset),
+    fps: ['attack', 'jump'].includes(preset) ? 4 : defaults.fps,
+  })
+}

package/dist/canvas-public/features/generation/asset-batch.js

@@ -0,0 +1,102 @@
+import { state } from '../../core/state.js'
+import { t } from '../../language/index.js'
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  transparentField,
+  colorField,
+  clearUnsupportedTransparency,
+  imageWait,
+} from './fields.js'
+
+const key = (name) => `features.generation.assetBatch.${name}`
+
+export default {
+  render: (ui) =>
+    ui.stack(
+      ui.field('assetType'),
+      ui.field('customAssetType'),
+      ui.prompt('prompt', 'refs'),
+      ui.row(ui.field('model'), ui.field('size')),
+      ui.field('transparentBackground'),
+      ui.field('backgroundColor'),
+    ),
+  toolbar: [
+    {
+      id: 'tool-asset-batch-gen',
+      group: 'image',
+      label: key('toolbar'),
+      title: key('toolbarTitle'),
+    },
+  ],
+  id: 'asset-batch',
+  title: key('title'),
+  node: generationNode('asset_batch_dialog', 460, { minWidth: 340, minHeight: 360 }),
+  storage: 'assetBatch',
+  submitLabel: key('submit'),
+  fields: [
+    {
+      path: 'assetType',
+      type: 'enum',
+      default: 'top-down',
+      label: key('assetType'),
+      options: [
+        { value: 'top-down', labelKey: key('topDown') },
+        { value: 'isometric', labelKey: key('isometric') },
+        { value: 'side-view', labelKey: key('sideView') },
+        { value: 'custom', labelKey: key('custom') },
+      ],
+    },
+    {
+      path: 'customAssetType',
+      type: 'text',
+      default: '',
+      required: true,
+      visible: (p) => p.assetType === 'custom',
+      label: key('customAssetType'),
+      placeholder: key('customAssetTypePlaceholder'),
+    },
+    promptField({
+      required: true,
+      label: key('prompt'),
+      placeholder: key('promptPlaceholder'),
+    }),
+    refsField({ label: key('references') }),
+    modelField({ default: 'asset-max' }),
+    {
+      path: 'size',
+      type: 'enum',
+      default: '1664x2496',
+      label: key('size'),
+      options: () => [...new Set(['1664x2496', ...(state.meta?.size_presets || [])])],
+    },
+    transparentField({ label: key('transparentBackground') }),
+    colorField('backgroundColor', {
+      label: key('backgroundColor'),
+      visible: (p) => !p.transparentBackground,
+    }),
+  ],
+  changed: clearUnsupportedTransparency,
+  validate: (p) => (p.refs.length > 14 ? t(key('tooManyReferences')) : ''),
+  task(p, services) {
+    return {
+      endpoint: '/api/generate-asset-batch',
+      options: { allowExternalSync: true },
+      wait: imageWait(p, services, p.size, key('generating')),
+      body: {
+        asset_type: p.assetType,
+        ...(p.assetType === 'custom'
+          ? { custom_asset_type: p.customAssetType.trim() }
+          : {}),
+        prompt: p.prompt.trim(),
+        size: p.size,
+        model: p.model,
+        background_color: p.backgroundColor,
+        transparent_background: p.model === 'asset-max' && p.transparentBackground,
+        reference_ids: p.refs.map((reference) => reference.id),
+      },
+    }
+  },
+}