evomeme 0.1.9 → 0.1.10

package/dist/canvas-public/map/export.js

@@ -0,0 +1,9 @@
+import { t } from '../language/index.js'
+import { getMountedTileMapView } from './tile-map-editor.js'
+
+export async function exportTileMapPng(id) {
+  const view = getMountedTileMapView(id)
+  if (!view) throw new Error(t("map.export.text001"))
+  await view.exportPng()
+  if (view.selectedStatus) view.selectedStatus.textContent = t("map.export.text002")
+}

package/dist/canvas-public/map/inspector.js

@@ -0,0 +1,8 @@
+import { getMountedTileMapView } from './tile-map-editor.js'
+
+export function mountTileMapInspector(container, item) {
+  const view = getMountedTileMapView(item.id)
+  if (!view) return false
+  view.mountInspector(container)
+  return true
+}

package/dist/canvas-public/map/model.js

@@ -0,0 +1,409 @@
+import { t } from '../language/index.js'
+export const TILE_MAP_NODE_WIDTH = 820
+export const TILE_MAP_FOOTER_HEIGHT = 22
+export const TILE_MAP_NODE_HEIGHT = 637
+export const TILE_MAP_NODE_MIN_WIDTH = 620
+export const TILE_MAP_NODE_MIN_HEIGHT = 487
+
+export const MAP_VERSION = 1
+export const DEFAULT_COLUMNS = 16
+export const DEFAULT_ROWS = 12
+export const DEFAULT_CELL_SIZE = 128
+export const MAX_GRID_SIDE = 256
+export const MAX_EXPORT_SIDE = 16384
+export const GRID_BLOCK_SIZE = 4
+export const MIN_MINOR_GRID_CELL_SCREEN_SIZE = 8
+export const MINOR_GRID_SCREEN_WIDTH = 1.25
+export const MAJOR_GRID_SCREEN_WIDTH = 2.5
+export const ATLAS_COLUMNS = 8
+export const ATLAS_MIN_ROWS = 8
+// Keep every atlas tile at 128px internally so the 8-column preview remains sharp when zoomed.
+export const ATLAS_CELL_SIZE = 128
+export const MIN_ATLAS_ZOOM = 0.5
+export const MAX_ATLAS_ZOOM = 4
+export const TILE_DRAG_TYPE = 'application/x-canvas-image'
+export const AUTO_TERRAIN_ATLAS_SIDE = 4
+// SVG atlas order for the four quarter-cells: top-left, top-right, bottom-left, bottom-right.
+export const AUTO_TERRAIN_TILE_INDEX_BY_MASK = [12, 13, 0, 3, 8, 1, 14, 5, 15, 4, 11, 2, 9, 10, 7, 6]
+export function reorderLayersByVisualDrop(layers, draggedLayerId, targetLayerId, placeAfter = false) {
+  const original = Array.isArray(layers) ? layers : []
+  if (!draggedLayerId || !targetLayerId || draggedLayerId === targetLayerId) return original
+
+  // Layers are painted bottom-to-top, while the inspector lists them top-to-bottom.
+  const visualOrder = [...original].reverse()
+  const draggedIndex = visualOrder.findIndex((layer) => layer.id === draggedLayerId)
+  const targetExists = visualOrder.some((layer) => layer.id === targetLayerId)
+  if (draggedIndex < 0 || !targetExists) return original
+
+  const [draggedLayer] = visualOrder.splice(draggedIndex, 1)
+  const targetIndex = visualOrder.findIndex((layer) => layer.id === targetLayerId)
+  visualOrder.splice(targetIndex + (placeAfter ? 1 : 0), 0, draggedLayer)
+  return visualOrder.reverse()
+}
+
+export function clampInteger(value, minimum, maximum, fallback) {
+  const parsed = Math.round(Number(value))
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(maximum, Math.max(minimum, parsed))
+}
+
+export function safeName(value, fallback) {
+  const text = String(value || '').trim()
+  return text || fallback
+}
+
+export function normalizeSource(value) {
+  if (!value || typeof value !== 'object') return null
+  const assetId = String(value.assetId || '').trim()
+  const id = String(value.id || '').trim()
+  if (!assetId || !id) return null
+  const naturalWidth = clampInteger(value.naturalWidth, 1, 32768, 1)
+  const naturalHeight = clampInteger(value.naturalHeight, 1, 32768, 1)
+  const columns = clampInteger(value.columns, 1, 256, 1)
+  const rows = clampInteger(value.rows, 1, 256, 1)
+  const marginX = clampInteger(value.marginX, 0, naturalWidth - 1, 0)
+  const marginY = clampInteger(value.marginY, 0, naturalHeight - 1, 0)
+  const spacingX = clampInteger(value.spacingX, 0, naturalWidth - 1, 0)
+  const spacingY = clampInteger(value.spacingY, 0, naturalHeight - 1, 0)
+  const availableWidth = naturalWidth - marginX * 2 - spacingX * (columns - 1)
+  const availableHeight = naturalHeight - marginY * 2 - spacingY * (rows - 1)
+  const tileWidth = clampInteger(value.tileWidth, 1, naturalWidth, Math.max(1, Math.floor(availableWidth / columns)))
+  const tileHeight = clampInteger(value.tileHeight, 1, naturalHeight, Math.max(1, Math.floor(availableHeight / rows)))
+  return {
+    id,
+    assetId,
+    name: safeName(value.name, t("map.model.text001")),
+    naturalWidth,
+    naturalHeight,
+    columns,
+    rows,
+    marginX,
+    marginY,
+    spacingX,
+    spacingY,
+    tileWidth,
+    tileHeight,
+    paletteHidden: value.paletteHidden === true,
+  }
+}
+
+function normalizeBrush(value, sources) {
+  if (!value || typeof value !== 'object') return null
+  if (Array.isArray(value.tiles) && value.tiles.length) {
+    const sourceMap = new Map(sources.map((source) => [source.id, source]))
+    const columns = clampInteger(value.columns, 1, ATLAS_COLUMNS, 1)
+    const rows = clampInteger(value.rows, 1, MAX_GRID_SIDE, 1)
+    const tiles = value.tiles.slice(0, columns * rows).map((tile) => {
+      if (!tile || typeof tile !== 'object') return null
+      const source = sourceMap.get(String(tile.sourceId || ''))
+      if (!source) return null
+      return {
+        sourceId: source.id,
+        tileIndex: clampInteger(tile.tileIndex, 0, source.columns * source.rows - 1, 0),
+      }
+    })
+    while (tiles.length < columns * rows) tiles.push(null)
+    const firstTile = tiles.find(Boolean)
+    if (firstTile) {
+      return {
+        sourceId: firstTile.sourceId,
+        tileIndex: firstTile.tileIndex,
+        columns,
+        rows,
+        atlasIndex: Number.isFinite(Number(value.atlasIndex))
+          ? clampInteger(value.atlasIndex, 0, Number.MAX_SAFE_INTEGER, 0)
+          : null,
+        tiles,
+      }
+    }
+  }
+  const source = sources.find((candidate) => candidate.id === value.sourceId)
+  if (!source) return null
+  const tileIndex = clampInteger(value.tileIndex, 0, source.columns * source.rows - 1, 0)
+  const startColumn = tileIndex % source.columns
+  const startRow = Math.floor(tileIndex / source.columns)
+  const columns = clampInteger(value.columns, 1, source.columns - startColumn, 1)
+  const rows = clampInteger(value.rows, 1, source.rows - startRow, 1)
+  return { sourceId: source.id, tileIndex, columns, rows }
+}
+
+export function normalizeCells(value, columns, rows, sources) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const sourceMap = new Map(sources.map((source) => [source.id, source]))
+  const cells = {}
+  for (const [key, cell] of Object.entries(value)) {
+    const match = /^(\d+),(\d+)$/.exec(key)
+    if (!match || !cell || typeof cell !== 'object') continue
+    const x = Number(match[1])
+    const y = Number(match[2])
+    if (x < 0 || y < 0 || x >= columns || y >= rows) continue
+    const source = sourceMap.get(String(cell.sourceId || ''))
+    if (!source) continue
+    const tileIndex = clampInteger(cell.tileIndex, 0, source.columns * source.rows - 1, 0)
+    cells[`${x},${y}`] = { sourceId: source.id, tileIndex }
+  }
+  return cells
+}
+
+export function autoTerrainTileIndex(mask) {
+  return AUTO_TERRAIN_TILE_INDEX_BY_MASK[clampInteger(mask, 0, 15, 0)]
+}
+
+export function autoTerrainMaskAt(occupiedCells, x, y) {
+  const matches = (cellX, cellY) => occupiedCells?.has?.(`${cellX},${cellY}`) || occupiedCells?.[`${cellX},${cellY}`] === true
+  if (matches(x, y)) return 15
+  const north = matches(x, y - 1)
+  const east = matches(x + 1, y)
+  const south = matches(x, y + 1)
+  const west = matches(x - 1, y)
+  return (north || west || matches(x - 1, y - 1) ? 8 : 0) |
+    (north || east || matches(x + 1, y - 1) ? 4 : 0) |
+    (south || west || matches(x - 1, y + 1) ? 2 : 0) |
+    (south || east || matches(x + 1, y + 1) ? 1 : 0)
+}
+
+export function createLayerId() {
+  return `layer_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`
+}
+
+function normalizeLayers(value, legacyCells, columns, rows, sources) {
+  const rawLayers = Array.isArray(value) ? value : []
+  const seenIds = new Set()
+  const layers = rawLayers.map((rawLayer, index) => {
+    if (!rawLayer || typeof rawLayer !== 'object') return null
+    let id = String(rawLayer.id || `layer-${index + 1}`).trim()
+    if (!id || seenIds.has(id)) id = createLayerId()
+    seenIds.add(id)
+    return {
+      id,
+      name: safeName(rawLayer.name, `${t("map.model.text002")}${index + 1}`),
+      cells: normalizeCells(rawLayer.cells, columns, rows, sources),
+    }
+  }).filter(Boolean)
+  if (layers.length) return layers
+  return [{
+    id: 'layer-1',
+    name: t("map.model.text003"),
+    cells: normalizeCells(legacyCells, columns, rows, sources),
+  }]
+}
+
+function paintedCellCount(map) {
+  return map.layers.reduce((count, layer) => count + Object.keys(layer.cells).length, 0)
+}
+
+export function createPaletteFromSources(sources, brushImages = [], cellSize = DEFAULT_CELL_SIZE) {
+  const cells = {}
+  const sourceMap = new Map(sources.map((source) => [source.id, source]))
+  const placedSourceIds = new Set()
+  let cursorX = 0
+  let cursorY = 0
+  let shelfHeight = 0
+
+  const placeRectangle = (columns, rows, tiles) => {
+    if (cursorX > 0 && cursorX + columns > ATLAS_COLUMNS) {
+      cursorX = 0
+      cursorY += shelfHeight
+      shelfHeight = 0
+    }
+    for (let row = 0; row < rows; row += 1) {
+      for (let column = 0; column < columns; column += 1) {
+        const tile = tiles[row * columns + column]
+        if (!tile) continue
+        cells[`${cursorX + column},${cursorY + row}`] = tile
+      }
+    }
+    cursorX += columns
+    shelfHeight = Math.max(shelfHeight, rows)
+  }
+
+  for (const brushImage of brushImages) {
+    const tiles = brushImage.tileSourceIds.map((sourceId) => {
+      const source = sourceMap.get(sourceId)
+      placedSourceIds.add(sourceId)
+      if (!source || source.paletteHidden) return null
+      return { sourceId, tileIndex: 0 }
+    })
+    placeRectangle(brushImage.columns, brushImage.rows, tiles)
+  }
+
+  for (const source of sources) {
+    if (placedSourceIds.has(source.id) || source.paletteHidden) continue
+    const tiles = []
+    for (let tileIndex = 0; tileIndex < source.columns * source.rows; tileIndex += 1) {
+      tiles.push({ sourceId: source.id, tileIndex })
+    }
+    placeRectangle(Math.min(source.columns, ATLAS_COLUMNS), source.rows, tiles)
+  }
+  return {
+    version: 1,
+    layout: 'brush-images',
+    columns: ATLAS_COLUMNS,
+    rows: Math.max(ATLAS_MIN_ROWS, cursorY + shelfHeight),
+    cellSize,
+    cells,
+  }
+}
+
+export function normalizePalette(value, sources, brushImages, cellSize) {
+  if (!value || typeof value !== 'object' || value.layout !== 'brush-images') {
+    return createPaletteFromSources(sources, brushImages, cellSize)
+  }
+  const rows = clampInteger(value.rows, ATLAS_MIN_ROWS, 65535, ATLAS_MIN_ROWS)
+  return {
+    version: 1,
+    layout: 'brush-images',
+    columns: ATLAS_COLUMNS,
+    rows,
+    cellSize,
+    cells: normalizeCells(value.cells, ATLAS_COLUMNS, rows, sources),
+  }
+}
+
+function normalizeBrushImage(value) {
+  if (!value || typeof value !== 'object') return null
+  const assetId = String(value.assetId || '').trim()
+  const sourceAssetId = String(value.sourceAssetId || '').trim()
+  const tileSourceIds = Array.isArray(value.tileSourceIds)
+    ? value.tileSourceIds.map(String).filter(Boolean)
+    : []
+  if (!assetId || !tileSourceIds.length) return null
+  return {
+    type: 'map_brush_image',
+    id: String(value.id || assetId),
+    assetId,
+    sourceAssetId,
+    name: safeName(value.name, t("map.model.text004")),
+    columns: clampInteger(value.columns, 1, 8, 1),
+    rows: clampInteger(value.rows, 1, 8, 1),
+    marginX: clampInteger(value.marginX, 0, 32767, 0),
+    marginY: clampInteger(value.marginY, 0, 32767, 0),
+    spacingX: clampInteger(value.spacingX, 0, 32767, 0),
+    spacingY: clampInteger(value.spacingY, 0, 32767, 0),
+    tileSourceIds,
+  }
+}
+
+export function normalizeTileMapData(value) {
+  const source = value && typeof value === 'object' ? value : {}
+  const columns = clampInteger(source.columns, 1, MAX_GRID_SIDE, DEFAULT_COLUMNS)
+  const rows = clampInteger(source.rows, 1, MAX_GRID_SIDE, DEFAULT_ROWS)
+  const cellSize = clampInteger(source.cellSize, 8, 512, DEFAULT_CELL_SIZE)
+  const sources = Array.isArray(source.sources)
+    ? source.sources.map(normalizeSource).filter(Boolean)
+    : []
+  const rawBrushImages = Array.isArray(source.brushImages) && source.brushImages.length
+    ? source.brushImages
+    : source.tilesets
+  const brushImages = Array.isArray(rawBrushImages)
+    ? rawBrushImages.map(normalizeBrushImage).filter(Boolean)
+    : []
+  const activeBrush = normalizeBrush(source.activeBrush, sources)
+  const layers = normalizeLayers(source.layers, source.cells, columns, rows, sources)
+  const requestedLayerId = String(source.activeLayerId || '')
+  const activeLayerId = layers.some((layer) => layer.id === requestedLayerId)
+    ? requestedLayerId
+    : layers[layers.length - 1].id
+  return {
+    version: MAP_VERSION,
+    columns,
+    rows,
+    cellSize,
+    activeTool: ['brush', 'terrain', 'eraser'].includes(source.activeTool) ? source.activeTool : 'brush',
+    activeBrush: activeBrush || (sources[0] ? { sourceId: sources[0].id, tileIndex: 0 } : null),
+    activeTerrainBrushId: brushImages.some((brushImage) => (
+      brushImage.id === source.activeTerrainBrushId &&
+      brushImage.columns === AUTO_TERRAIN_ATLAS_SIDE &&
+      brushImage.rows === AUTO_TERRAIN_ATLAS_SIDE
+    )) ? source.activeTerrainBrushId : null,
+    sources,
+    brushImages,
+    palette: normalizePalette(source.palette, sources, brushImages, cellSize),
+    layers,
+    activeLayerId,
+  }
+}
+
+export function createTileMapItem({ id, x, y, name = t("map.model.text005"), folderName = t("map.model.text005"), cellSize = DEFAULT_CELL_SIZE }) {
+  return {
+    id,
+    type: 'tile_map',
+    name: safeName(name, t("map.model.text005")),
+    folderName: safeName(folderName, t("map.model.text005")),
+    x: Number(x) - TILE_MAP_NODE_WIDTH / 2,
+    y: Number(y) - 18,
+    width: TILE_MAP_NODE_WIDTH,
+    height: TILE_MAP_NODE_HEIGHT,
+    tileMap: normalizeTileMapData({ cellSize }),
+  }
+}
+
+export function tileMapContentAspectRatio(item) {
+  const map = item?.tileMap || item || {}
+  const columns = clampInteger(map.columns, 1, MAX_GRID_SIDE, DEFAULT_COLUMNS)
+  const rows = clampInteger(map.rows, 1, MAX_GRID_SIDE, DEFAULT_ROWS)
+  return columns / rows
+}
+
+export function tileMapNodeHeightForWidth(item, width) {
+  const safeWidth = Math.max(1, Number(width) || TILE_MAP_NODE_WIDTH)
+  return Math.round(safeWidth / tileMapContentAspectRatio(item) + TILE_MAP_FOOTER_HEIGHT)
+}
+
+export function isTileMapItem(item) {
+  return Boolean(item && item.type === 'tile_map')
+}
+
+export function normalizeTileMapItem(item, index = 0) {
+  const fileParts = String(item?.tileMapFile || '').replace(/\\/g, '/').split('/').filter(Boolean)
+  const fileFolderName = fileParts.length > 1 ? fileParts[fileParts.length - 2] : ''
+  const tileMap = normalizeTileMapData(item?.tileMap)
+  const width = Math.max(TILE_MAP_NODE_MIN_WIDTH, Number(item?.width) || TILE_MAP_NODE_WIDTH)
+  return {
+    ...item,
+    type: 'tile_map',
+    name: safeName(item?.name, t("map.model.text005")),
+    folderName: safeName(item?.folderName || fileFolderName, t("map.model.text005")),
+    x: Number.isFinite(Number(item?.x)) ? Number(item.x) : 60 + (index % 3) * 860,
+    y: Number.isFinite(Number(item?.y)) ? Number(item.y) : 60 + Math.floor(index / 3) * 660,
+    width,
+    height: tileMapNodeHeightForWidth(tileMap, width),
+    tileMap,
+  }
+}
+
+export function serializeTileMapItem(item) {
+  const normalized = normalizeTileMapItem(item)
+  return {
+    id: normalized.id,
+    type: 'tile_map',
+    name: normalized.name,
+    x: normalized.x,
+    y: normalized.y,
+    width: normalized.width,
+    height: normalized.height,
+    ...(normalized.tileMapFile ? { tileMapFile: normalized.tileMapFile } : {}),
+    ...(normalized.tileMapMetaFile ? { tileMapMetaFile: normalized.tileMapMetaFile } : {}),
+    folderName: normalized.folderName,
+    references: (
+      normalized.tileMap.brushImages.length
+        ? normalized.tileMap.brushImages.map((brushImage) => brushImage.sourceAssetId)
+        : normalized.tileMap.sources.map((source) => source.assetId)
+    ).filter((id, index, ids) => id && ids.indexOf(id) === index).map((id) => ({
+      id,
+      role: 'map-brush-image',
+    })),
+    tileMap: normalized.tileMap,
+  }
+}
+
+export function tileMapSummary(item) {
+  const map = normalizeTileMapData(item?.tileMap)
+  return {
+    dimensions: `${map.columns}${t("map.model.text006.part1")}${map.rows}${t("map.model.text006.part2")}`,
+    outputSize: `${map.columns * map.cellSize} × ${map.rows * map.cellSize} px`,
+    sources: String(map.sources.length),
+    paintedCells: String(paintedCellCount(map)),
+  }
+}
+

package/dist/canvas-public/map/tile-map-editor.js

@@ -0,0 +1,2 @@
+// Stable map-view facade for the canvas lifecycle; business UI lives in features/map.
+export * from '../features/map/tile-map-editor.js'

package/dist/canvas-public/media/metadata.js

@@ -0,0 +1,183 @@
+import { t } from '../language/index.js'
+export function createMediaMetadata({ imageName }) {
+  function normalizeGenMeta(gen) {
+    if (!gen || typeof gen !== 'object') return null
+    const refs = Array.isArray(gen.references)
+      ? gen.references
+          .filter((r) => r && r.id)
+          .map((r) => ({
+            id: r.id,
+            name: r.name || r.id,
+            role: r.role || undefined,
+            kind: r.kind || undefined,
+          }))
+      : []
+    return {
+      kind: gen.kind === 'video' ? 'video' : 'image',
+      prompt: String(gen.prompt || ''),
+      model: gen.model || '',
+      size: gen.size || '',
+      ratio: gen.ratio || '',
+      duration: gen.duration ?? null,
+      resolution: gen.resolution || '',
+      generateAudio: gen.generateAudio === true,
+      seed: gen.seed === '' || gen.seed == null ? null : gen.seed,
+      references: refs,
+      createdAt: gen.createdAt || null,
+    }
+  }
+  
+  function buildImageGenMeta({ prompt, model, size, references }) {
+    return normalizeGenMeta({
+      kind: 'image',
+      prompt,
+      model,
+      size,
+      references: (references || []).map((r) => ({
+        id: r.id,
+        name: r.name || imageName(r.id) || r.id,
+      })),
+      createdAt: new Date().toISOString(),
+    })
+  }
+  
+  function buildVideoGenMeta({
+    prompt,
+    model,
+    ratio,
+    duration,
+    resolution,
+    generateAudio,
+    seed,
+    references,
+  }) {
+    return normalizeGenMeta({
+      kind: 'video',
+      prompt,
+      model: model || 'seedance',
+      ratio,
+      duration,
+      resolution,
+      generateAudio,
+      seed,
+      references: (references || []).map((r) => ({
+        id: r.id,
+        name: r.name || imageName(r.id) || r.id,
+        role: r.role,
+        kind: r.kind,
+      })),
+      createdAt: new Date().toISOString(),
+    })
+  }
+  
+  function formatGenRefList(refs) {
+    if (!refs?.length) return t("media.metadata.text001")
+    return refs
+      .map((r) => {
+        const name = r.name || r.id
+        if (r.role) {
+          const roleLabel =
+            {
+              reference_image: t("media.metadata.text002"),
+              first_frame: t("media.metadata.text003"),
+              last_frame: t("media.metadata.text004"),
+              reference_video: t("media.metadata.text005"),
+              reference_audio: t("media.metadata.text006"),
+            }[r.role] || r.role
+          return `${name}（${roleLabel}）`
+        }
+        return name
+      })
+      .join('\n')
+  }
+  
+  function formatGenTime(iso) {
+    if (!iso) return ''
+    const d = new Date(iso)
+    if (Number.isNaN(d.getTime())) return String(iso)
+    const pad = (n) => String(n).padStart(2, '0')
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+  }
+  
+  function formatOriginTime(sec) {
+    const s = Math.max(0, Number(sec) || 0)
+    return `${s.toFixed(3)}s`
+  }
+  
+  function formatPerfectPixelSourceArea(pixelSizeX, pixelSizeY) {
+    const x = Number(pixelSizeX)
+    const y = Number(pixelSizeY)
+    if (!Number.isFinite(x) || !Number.isFinite(y) || x <= 0 || y <= 0) return '—'
+    const format = (value) => String(Math.round(value * 100) / 100)
+    return `${format(x)}${t("media.metadata.text007.part1")}${format(y)}${t("media.metadata.text007.part2")}`
+  }
+  
+  function normalizeOrigin(origin) {
+    if (!origin || typeof origin !== 'object') return null
+    const kind = String(origin.kind || '')
+    const parentId = origin.parentId || origin.sourceId || null
+    if (!parentId && kind !== 'ai_generate') return null
+  
+    if (kind === 'video_cycle') {
+      const start = Number(origin.start)
+      const end = Number(origin.end)
+      if (!Number.isFinite(start) || !Number.isFinite(end)) return null
+      return {
+        kind,
+        parentId,
+        parentName: origin.parentName || null,
+        start,
+        end,
+        score: origin.score != null && Number.isFinite(Number(origin.score)) ? Number(origin.score) : null,
+        threshold:
+          origin.threshold != null && Number.isFinite(Number(origin.threshold))
+            ? Number(origin.threshold)
+            : null,
+      }
+    }
+    if (kind === 'smart_split') {
+      return {
+        kind,
+        parentId,
+        parentName: origin.parentName || null,
+        resultIndex: Math.max(0, Math.round(Number(origin.resultIndex) || 0)),
+        resultCount: Math.max(
+          0,
+          Math.round(Number(origin.resultCount ?? origin.frameCount) || 0),
+        ),
+      }
+    }
+    return null
+  }
+  
+  function buildOrigin(kind, fields = {}) {
+    return normalizeOrigin({ kind, ...fields })
+  }
+  
+  function resolveItemOrigin(item) {
+    if (!item) return null
+    return normalizeOrigin(item.origin)
+  }
+  
+  function originParentLabel(origin) {
+    if (!origin?.parentId) return '—'
+    return origin.parentName || imageName(origin.parentId) || origin.parentId
+  }
+
+  return {
+    buildImageGenMeta,
+    buildOrigin,
+    buildVideoGenMeta,
+    formatGenRefList,
+    formatGenTime,
+    formatOriginTime,
+    formatPerfectPixelSourceArea,
+    normalizeGenMeta,
+    normalizeOrigin,
+    originParentLabel,
+    resolveItemOrigin,
+  }
+}
+
+
+