@uzooai/anime-ai-cli 0.0.0-stage → 0.5.0

package/src/repaint-video.js

@@ -0,0 +1,798 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { isDeepStrictEqual } from 'node:util'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { atomic, json, root, safeName } from './store.js'
+import { repaintPromptContext } from './repaint-reverse.js'
+import { repaintOf, jobPath } from './repaint-graph.js'
+import {
+  collectGenerationSources,
+  buildGenerationRequest,
+  normalizeMode,
+  readSource
+} from './generation-input.js'
+import { requireServiceReady } from './service.js'
+import { readProtocol, agreementError } from './agreement.js'
+import { archiveRepaintResult } from './repaint-archive.js'
+import { cancellation } from './api.js'
+
+const text = (value) => String(value ?? '').trim()
+const fail = (code, message, cause) =>
+  Object.assign(new Error(message), {
+    code,
+    ...(cause
+      ? {
+          cause,
+          diagnostic: {
+            ...(cause.status ? { http_status: cause.status } : {}),
+            ...(cause.apiCode ? { api_code: cause.apiCode } : {}),
+            ...(cause.requestId ? { request_id: cause.requestId } : {})
+          }
+        }
+      : {})
+  })
+const api = (client, endpoint, options = {}, controls) =>
+  client.raw(
+    endpoint,
+    {
+      ...options,
+      headers: { ...options.headers, 'X-Client-Source': 'canvas' }
+    },
+    controls
+  )
+export const repaintVideoPath = (profile, operation) =>
+  path.join(
+    root(),
+    'repaint-video',
+    safeName(profile),
+    safeName(operation) + '.json'
+  )
+const persist = (record) =>
+  atomic(repaintVideoPath(record.profile, record.operation), record)
+const statuses = ['queued', 'processing', 'retrying', 'completed', 'failed']
+const pending = (task) =>
+  ['queued', 'processing', 'retrying'].includes(task.status)
+
+export function repaintVideoInput(value) {
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    Object.keys(value).some(
+      (k) =>
+        !['model_name', 'duration', 'aspect_ratio', 'resolution'].includes(k)
+    )
+  )
+    throw new Error(
+      '转绘视频只支持model_name、duration、aspect_ratio、resolution；不接入声音、样片、额外参考或批量字段'
+    )
+  if (
+    !Number.isSafeInteger(value.duration) ||
+    value.duration < 1 ||
+    value.duration > 60
+  )
+    throw new Error('转绘视频时长须为1–60整数秒，再按实际模型范围校验')
+  for (const key of ['model_name', 'aspect_ratio', 'resolution'])
+    if (typeof value[key] !== 'string' || !text(value[key]))
+      throw new Error('转绘视频缺少明确选择的' + key)
+  return {
+    model_name: text(value.model_name),
+    duration: value.duration,
+    aspect_ratio: text(value.aspect_ratio),
+    resolution: text(value.resolution)
+  }
+}
+const configData = (data, input) => ({
+  ...data,
+  model_name: input.model_name,
+  duration: input.duration,
+  aspect_ratio: input.aspect_ratio,
+  resolution: input.resolution,
+  extra: {
+    ...data.extra,
+    aspect_ratio: input.aspect_ratio,
+    resolution: input.resolution,
+    generation_mode: 'text_to_video'
+  }
+})
+// Compare effective persisted inputs/results, tolerating web codec defaults and
+// top-level/extra mirrors. Layout, title and unrelated canvas edits are retained.
+export function repaintVideoNodeView(node) {
+  const d = node.data || {},
+    e = d.extra || {}
+  return {
+    prompt: String(d.prompt || ''),
+    model: text(d.model_name || d.model),
+    duration: Number(d.duration ?? e.duration) || 0,
+    aspect_ratio: text(d.aspect_ratio || e.aspect_ratio),
+    resolution: text(d.resolution || e.resolution),
+    mode: normalizeMode(e.generation_mode || d.generation_mode || d.videoMode),
+    last_task_id: text(d.last_task_id || d.lastTaskId),
+    status: text(d.status),
+    result: d.result || null,
+    file_ref: text(e.file_ref || d.resultFileRef),
+    error_message: text(d.error_message || d.errorMessage),
+    seedance_auto_review:
+      (d.seedanceAutoReview ?? e.seedance_auto_review) === true
+  }
+}
+const nodeView = repaintVideoNodeView
+async function context(client, profile, parent, index) {
+  const ctx = await repaintPromptContext(client, profile, parent, index)
+  const group = ctx.doc.meta.canvas_groups.find(
+    (g) => g.id === ctx.binding.group_id
+  )
+  const nodes = ctx.doc.nodes.filter(
+    (n) =>
+      group.nodeIds.includes(n.id) &&
+      repaintOf(n).jobId === ctx.job.id &&
+      repaintOf(n).role === 'generation' &&
+      repaintOf(n).segmentIndex === index
+  )
+  if (nodes.length !== 1 || nodes[0].type !== 'video')
+    throw new Error('缺少唯一原转绘视频生成节点，不创建占位节点')
+  const node = nodes[0],
+    incoming = ctx.doc.edges.filter((e) => e.target === node.id)
+  if (
+    incoming.length !== 1 ||
+    incoming[0].source !== ctx.final.id ||
+    incoming[0].data?.role !== 'final-generation-link'
+  )
+    throw new Error(
+      '本轮仅原最终提示词→生成节点；额外入边或系统线缺失须另行接入，不静默丢参考'
+    )
+  const inputs = collectGenerationSources(ctx.doc, node)
+  if (
+    inputs.references.length ||
+    inputs.all.some((s) => s.mediaType !== 'text')
+  )
+    throw new Error('本轮画布转绘不接额外参考/素材池附件；不静默忽略或漏算')
+  if (
+    !readSource(ctx.final).text ||
+    !ctx.job.delivery_prompts?.some(
+      (p) => p.segment_index === index && text(p.prompt)
+    ) ||
+    ctx.output.delivery_prompt_status !== 'completed' ||
+    ctx.output.delivery_prompt_fallback
+  )
+    throw new Error(
+      '先完成并核验该段正常最终提示词；不能将未处理或回退文本直接当成正常最终结果'
+    )
+  if (
+    node.data?.generation_config ||
+    node.data?.generate_audio !== undefined ||
+    node.data?.generateAudio !== undefined
+  )
+    throw new Error('生成节点存在未接入覆盖配置或声音字段，先核对前端生效配置')
+  return {
+    ...ctx,
+    generation: node,
+    inputs,
+    binding: {
+      ...ctx.binding,
+      reverse_node_id: ctx.node.id,
+      node_id: node.id,
+      final_id: ctx.final.id,
+      final_text: readSource(ctx.final).text
+    }
+  }
+}
+const eligible = (m) =>
+  m.content_type === 'video' &&
+  !m.member_locked &&
+  m.is_sample_mode !== true &&
+  !/draft|样片/i.test(m.label) &&
+  m.generation_modes?.map(normalizeMode).includes('text_to_video')
+async function catalog(client, ctx) {
+  const data = await client.raw(
+    '/canvas/models' +
+      (ctx.doc.team_uid
+        ? '?team_uid=' + encodeURIComponent(ctx.doc.team_uid)
+        : '')
+  )
+  if (!Array.isArray(data.items)) throw new Error('模型目录不完整')
+  return data.items
+}
+export async function repaintVideoOptions(client, profile, parent, index) {
+  await requireServiceReady(client)
+  const ctx = await context(client, profile, parent, index),
+    models = await catalog(client, ctx)
+  return {
+    repaint_operation: parent,
+    job_id: ctx.job.id,
+    plan_version: ctx.job.plan_version,
+    segment_index: index,
+    node_id: ctx.generation.id,
+    source_range_ms: [ctx.binding.start_ms, ctx.binding.end_ms],
+    workflow: 'canvas_redraw',
+    generation_mode: 'text_to_video',
+    source_video_sent_as_reference: false,
+    reference_images: [],
+    reference_audio: [],
+    current: {
+      model_name: nodeView(ctx.generation).model,
+      duration: nodeView(ctx.generation).duration,
+      aspect_ratio: nodeView(ctx.generation).aspect_ratio,
+      resolution: nodeView(ctx.generation).resolution
+    },
+    models: models.filter(eligible).map((m) => ({
+      label: m.label,
+      aspect_ratios: m.aspect_ratios || [],
+      resolutions: m.resolutions || [],
+      durations: m.durations || null,
+      prompt_max_length: m.prompt_max_length || null
+    })),
+    submitted: false,
+    next: '使用交互卡片选择模型和实际参数，再repaint video预估；不自动选模型或发起收费任务'
+  }
+}
+async function prepare(client, ctx, input) {
+  const model = (await catalog(client, ctx)).find(
+    (m) => m.label === input.model_name && eligible(m)
+  )
+  return repaintVideoRequests(ctx, model, input)
+}
+export function repaintVideoRequests(ctx, model, input) {
+  if (!model) throw new Error('模型不在当前空间可用的无额外参考转绘选项内')
+  if (
+    !model.aspect_ratios?.includes(input.aspect_ratio) ||
+    !model.resolutions?.includes(input.resolution)
+  )
+    throw new Error('比例或分辨率不在当前模型选项内')
+  const min = Number(model.durations?.min),
+    max = Number(model.durations?.max)
+  if (
+    !Number.isFinite(min) ||
+    !Number.isFinite(max) ||
+    input.duration < min ||
+    input.duration > max
+  )
+    throw new Error('当前模型时长范围未知或所选时长不合规')
+  const configured = {
+    ...ctx.generation,
+    data: configData(ctx.generation.data, input)
+  }
+  const { request } = buildGenerationRequest(
+    ctx.doc,
+    configured,
+    model,
+    ctx.inputs
+  )
+  if (
+    request.extra.generation_mode !== 'text_to_video' ||
+    [
+      'reference_image_urls',
+      'reference_video_urls',
+      'reference_audio_urls',
+      'reference_asset_ids',
+      'reference_canvas_task_ids'
+    ].some((k) => request[k]?.length)
+  )
+    throw new Error(
+      '本轮仅最终提示词驱动的画布转绘，不丢弃未接入参考或改用普通生成提交'
+    )
+  if (
+    !request.prompt ||
+    request.prompt.length > 20000 ||
+    (model.prompt_max_length && request.prompt.length > model.prompt_max_length)
+  )
+    throw new Error('实际生成提示词为空或超过当前模型限制')
+  return {
+    configured,
+    estimateBody: { ...request, protocol_agreed: false },
+    body: redrawVideoBody(ctx, request),
+    prompt: request.prompt
+  }
+}
+// Matches canvasService.createCanvasRedrawTask; consent is checked separately,
+// never submitted as true on the user's behalf.
+export function redrawVideoBody(ctx, request) {
+  return {
+    segment_index: ctx.binding.index,
+    prompt: request.prompt || null,
+    model_name: request.model_name,
+    duration: request.duration,
+    aspect_ratio: request.aspect_ratio || request.extra?.aspect_ratio,
+    resolution: request.resolution || request.extra?.resolution,
+    reference_image_material_ids: [],
+    reference_audio_material_ids: [],
+    canvas_doc_id: ctx.doc.id,
+    canvas_node_id: ctx.generation.id,
+    protocol_agreed: false
+  }
+}
+async function quote(client, ctx, prepared) {
+  const canvas = await client.raw(
+    '/canvas/generations/estimate',
+    { method: 'POST', body: prepared.estimateBody },
+    { retry: false }
+  )
+  const { model_name, duration, aspect_ratio, resolution, prompt } =
+    prepared.body
+  const redraw = await api(
+    client,
+    jobPath(ctx.job.id) + '/redraw-estimate',
+    {
+      method: 'POST',
+      body: {
+        model_name,
+        duration,
+        aspect_ratio,
+        resolution,
+        prompt,
+        segment_count: 1,
+        reference_image_material_ids: [],
+        reference_audio_material_ids: []
+      }
+    },
+    { retry: false }
+  )
+  const cost = canvas.estimated_credit_cost
+  if (
+    cost == null ||
+    !Number.isFinite(Number(cost)) ||
+    Number(cost) < 0 ||
+    canvas.will_intercept ||
+    redraw.total == null ||
+    Number(redraw.total) !== Number(cost) ||
+    Number(redraw.per_segment) !== Number(cost) ||
+    redraw.segment_count !== 1
+  )
+    throw new Error('画布与专用转绘预估缺失、被拦截或不一致，停止提交')
+  const me = await client.raw('/auth/me'),
+    team = ctx.doc.team_uid
+      ? me.teams?.find(
+          (t) => text(t.uid) === text(ctx.doc.team_uid) && t.status === 'active'
+        )
+      : null
+  if (text(me.uid) !== ctx.parent.owner || (ctx.doc.team_uid && !team))
+    throw new Error('原账号或团队有效成员身份已变化')
+  return {
+    estimated_credit_cost: Number(cost),
+    currency: 'OO',
+    canvas,
+    redraw,
+    wallet: {
+      space: ctx.parent.input.space,
+      team_uid: ctx.doc.team_uid || null,
+      team_name: team?.name || null,
+      shared: Boolean(team),
+      balance_snapshot: (team || me).oo_balance ?? null
+    }
+  }
+}
+async function listTasks(client, ctx) {
+  const data = await api(
+    client,
+    jobPath(ctx.job.id) + '/redraw-tasks?segment_index=' + ctx.binding.index
+  )
+  if (!Array.isArray(data.items)) throw new Error('原片段转绘任务列表不完整')
+  return data.items
+}
+async function preventDuplicate(profile, operation, ctx) {
+  const directory = path.dirname(repaintVideoPath(profile, operation))
+  const files = await fs.readdir(directory).catch((e) => {
+    if (e.code === 'ENOENT') return []
+    throw e
+  })
+  for (const file of files.filter((f) => f.endsWith('.json'))) {
+    const r = await json(path.join(directory, file))
+    if (
+      r.operation !== operation &&
+      r.owner === ctx.parent.owner &&
+      r.baseUrl === ctx.parent.baseUrl &&
+      r.binding?.job_id === ctx.job.id &&
+      r.index === ctx.binding.index &&
+      r.attempted &&
+      !['completed', 'failed'].includes(r.state)
+    )
+      throw new Error(
+        '同片段已有进行中或未知转绘operation，先查询原操作，不换名重提'
+      )
+  }
+}
+function assertNode(record, ctx) {
+  const view = nodeView(ctx.generation)
+  const allowed = record.configSaved
+    ? [record.savedView, record.pendingView]
+    : [record.nodeBefore, record.pendingView]
+  if (!allowed.filter(Boolean).some((v) => isDeepStrictEqual(view, v)))
+    throw fail(
+      'REPAINT_VIDEO_SYNC_PENDING',
+      '原生成节点的输入/结果已被编辑或旧快照覆盖，停止；不覆盖或自动恢复被清除内容'
+    )
+}
+async function bound(client, profile, operation) {
+  const record = await json(repaintVideoPath(profile, operation), null)
+  if (
+    !record ||
+    record.schema !== 1 ||
+    record.profile !== profile ||
+    record.baseUrl !== client.baseUrl
+  )
+    throw new Error('转绘视频operation不存在或服务不匹配')
+  const ctx = await context(
+    client,
+    profile,
+    record.parentOperation,
+    record.index
+  )
+  if (
+    record.owner !== ctx.parent.owner ||
+    !isDeepStrictEqual(record.binding, ctx.binding)
+  )
+    throw new Error('原任务/版本/来源/规则/最终提示词变化，停止原视频操作')
+  assertNode(record, ctx)
+  return { record, ctx }
+}
+function summary(record, task = null) {
+  return {
+    operation: record.operation,
+    repaint_operation: record.parentOperation,
+    state: record.state,
+    job_id: record.binding.job_id,
+    plan_version: record.binding.plan_version,
+    segment_index: record.index,
+    node_id: record.binding.node_id,
+    parameters: record.input,
+    source_range_ms: [record.binding.start_ms, record.binding.end_ms],
+    source_video_sent_as_reference: false,
+    submitted: Boolean(record.taskId),
+    submission_attempted: Boolean(record.attempted),
+    task_id: record.taskId || null,
+    canvas_synced: Boolean(record.canvasSynced),
+    estimate: record.estimate,
+    task,
+    library_saved: false,
+    ...(record.diagnostic ? { diagnostic: record.diagnostic } : {})
+  }
+}
+async function saveNode(client, record, ctx, data) {
+  const wanted = { ...ctx.generation, data },
+    view = nodeView(wanted)
+  if (!isDeepStrictEqual(nodeView(ctx.generation), view)) {
+    record.pendingView = view
+    await persist(record)
+    ctx.generation.data = data
+    try {
+      const saved = await api(
+        client,
+        '/canvas/docs/' + encodeURIComponent(ctx.doc.id),
+        {
+          method: 'PUT',
+          body: {
+            version: ctx.doc.version,
+            name: ctx.doc.name,
+            viewport: ctx.doc.viewport,
+            nodes: ctx.doc.nodes,
+            edges: ctx.doc.edges,
+            meta: ctx.doc.meta
+          }
+        },
+        { retry: false }
+      )
+      if (
+        saved.version !== ctx.doc.version + 1 ||
+        !isDeepStrictEqual(
+          nodeView(saved.nodes?.find((n) => n.id === wanted.id) || {}),
+          view
+        )
+      )
+        throw new Error('保存响应缺少匹配的节点/版本')
+    } catch (error) {
+      record.state = 'sync_pending'
+      await persist(record)
+      throw fail(
+        'REPAINT_VIDEO_SYNC_PENDING',
+        '原任务/配置保留；画布保存未确认，先用原operation恢复查询，不重发生成',
+        error
+      )
+    }
+  }
+  record.savedView = view
+  record.pendingView = null
+  record.configSaved = true
+  await persist(record)
+}
+export function validateRepaintVideoTask(record, task) {
+  const b = record.body
+  if (
+    !task ||
+    !Number.isSafeInteger(task.id) ||
+    task.id <= 0 ||
+    String(task.id) !== record.taskId ||
+    !Number.isSafeInteger(task.version) ||
+    task.version < 1 ||
+    task.job_id !== record.binding.job_id ||
+    task.segment_index !== record.index ||
+    !statuses.includes(task.status) ||
+    text(task.prompt).normalize('NFKC') !== text(b.prompt).normalize('NFKC') ||
+    task.model_name !== b.model_name ||
+    task.duration !== b.duration ||
+    task.aspect_ratio !== b.aspect_ratio ||
+    task.resolution !== b.resolution ||
+    task.reference_image_count !== 0 ||
+    task.reference_audio_count !== 0
+  )
+    throw fail(
+      'REPAINT_VIDEO_SUBMISSION_UNKNOWN',
+      '返回任务与原转绘参数/片段不一致，仅保留原接收ID，不重提或回填'
+    )
+  if (record.taskVersion && task.version !== record.taskVersion)
+    throw new Error('原转绘任务版本已变化')
+  if (
+    task.status === 'completed' &&
+    (!task.result?.file_ref || !task.result?.url || !task.completed_at)
+  )
+    throw fail(
+      'REPAINT_VIDEO_SYNC_PENDING',
+      '原任务completed但缺少真实视频结果，停止回填'
+    )
+  return task
+}
+const validateTask = validateRepaintVideoTask
+async function taskFor(client, record) {
+  if (!record.taskId) return null
+  return validateTask(
+    record,
+    await api(
+      client,
+      jobPath(record.binding.job_id) +
+        '/redraw-tasks/' +
+        encodeURIComponent(record.taskId)
+    )
+  )
+}
+export async function startRepaintVideo(
+  client,
+  profile,
+  parent,
+  index,
+  operation,
+  value,
+  confirmed = false,
+  expectedCost,
+  options = {}
+) {
+  safeName(operation)
+  const input = repaintVideoInput(value),
+    file = repaintVideoPath(profile, operation)
+  await requireServiceReady(client)
+  let ctx = await context(client, profile, parent, index),
+    record = await json(file, null)
+  await preventDuplicate(profile, operation, ctx)
+  if (record) {
+    if (
+      record.parentOperation !== parent ||
+      record.index !== index ||
+      !isDeepStrictEqual(record.input, input)
+    )
+      throw new Error('operation已绑定其他配置；不修改或换名重提未知任务')
+    ;({ record, ctx } = await bound(client, profile, operation))
+    if (record.attempted) return recoverRepaintVideo(client, profile, operation)
+  } else {
+    const view = nodeView(ctx.generation)
+    if (view.last_task_id || view.result)
+      throw new Error('本轮只接首轮转绘；目标已有结果/任务，不自动覆盖或重做')
+  }
+  let prepared = await prepare(client, ctx, input)
+  if (record && !isDeepStrictEqual(record.body, prepared.body))
+    throw new Error('原生成请求已变化，停止')
+  if ((await listTasks(client, ctx)).some(pending))
+    throw new Error('原片段已有进行中的远端转绘任务，停止新提交')
+  let estimate = await quote(client, ctx, prepared)
+  if (!record)
+    record = {
+      schema: 1,
+      profile,
+      operation,
+      parentOperation: parent,
+      index,
+      input,
+      baseUrl: client.baseUrl,
+      owner: ctx.parent.owner,
+      binding: ctx.binding,
+      nodeBefore: nodeView(ctx.generation),
+      body: prepared.body,
+      state: 'prepared',
+      createdAt: new Date().toISOString()
+    }
+  if (!confirmed) {
+    record.estimate = estimate
+    await persist(record)
+    return {
+      ...summary(record),
+      prompt: prepared.prompt,
+      request: record.body,
+      next: '交互卡片展示模型/输出时长/比例/分辨率/提示词/实际钱包和费用，明确确认后沿用原video命令加--yes --expected-cost；源片不作为视频参考发送'
+    }
+  }
+  const cost = Number(expectedCost)
+  if (
+    expectedCost === undefined ||
+    !Number.isFinite(cost) ||
+    cost < 0 ||
+    !record.estimate ||
+    record.estimate.estimated_credit_cost !== cost ||
+    estimate.estimated_credit_cost !== cost
+  )
+    throw new Error(
+      '先预估并当次明确确认；--expected-cost须与原预估及当前两个预估一致'
+    )
+  let protocol = await readProtocol(client)
+  if (protocol.required && !protocol.agreed) {
+    if (!options.onAgreementRequired)
+      throw agreementError(
+        'AGREEMENT_REQUIRED',
+        '需本人签署《统一协议》《Seedance2.0模型使用承诺书》，转绘尚未提交',
+        protocol
+      )
+    await options.onAgreementRequired({
+      operation,
+      body: record.body,
+      estimate
+    })
+    const next = await readProtocol(client)
+    if (next.version !== protocol.version || (next.required && !next.agreed))
+      throw agreementError(
+        'AGREEMENT_CHANGED',
+        '协议版本/状态变化，停止生成',
+        next
+      )
+    protocol = next
+  }
+  ;({ record, ctx } = await bound(client, profile, operation))
+  prepared = await prepare(client, ctx, input)
+  if (!isDeepStrictEqual(record.body, prepared.body))
+    throw new Error('协议确认后原生成请求变化')
+  estimate = await quote(client, ctx, prepared)
+  if (estimate.estimated_credit_cost !== cost)
+    throw new Error('实时费用变化，停止并重新确认')
+  if ((await listTasks(client, ctx)).some(pending))
+    throw new Error('原片段出现进行中任务，未提交')
+  await saveNode(client, record, ctx, prepared.configured.data)
+  ;({ record, ctx } = await bound(client, profile, operation))
+  record.approvedCost = cost
+  record.attempted = true
+  record.state = 'submitting'
+  await persist(record)
+  try {
+    const task = await api(
+      client,
+      jobPath(ctx.job.id) + '/redraw-tasks',
+      { method: 'POST', body: record.body },
+      { retry: false }
+    )
+    if (Number.isSafeInteger(task?.id) && task.id > 0) {
+      record.taskId = String(task.id)
+      await persist(record)
+    }
+    validateTask(record, task)
+    record.taskVersion = task.version
+    record.state = 'submitted'
+    await persist(record)
+  } catch (error) {
+    if (error.apiCode === 4401 && !record.taskId) {
+      record.attempted = false
+      record.state = 'blocked_agreement'
+      await persist(record)
+      throw agreementError(
+        'AGREEMENT_REQUIRED',
+        '《统一协议》《Seedance2.0模型使用承诺书》待签署（4401）；不是视频执行失败',
+        await readProtocol(client)
+      )
+    }
+    record.state = 'submission_unknown'
+    record.diagnostic = {
+      ...(error.status ? { http_status: error.status } : {}),
+      ...(error.apiCode ? { api_code: error.apiCode } : {}),
+      ...(error.requestId ? { request_id: error.requestId } : {})
+    }
+    await persist(record)
+    throw fail(
+      'REPAINT_VIDEO_SUBMISSION_UNKNOWN',
+      '转绘提交响应未确认；先检查服务并查询原operation，不重发POST或换operation',
+      error
+    )
+  }
+  return recoverRepaintVideo(client, profile, operation)
+}
+export async function getRepaintVideo(client, profile, operation) {
+  const { record, ctx } = await bound(client, profile, operation),
+    task = await taskFor(client, record)
+  const result = summary(record, task)
+  if (record.attempted && !record.taskId)
+    result.observed_remote_tasks = (await listTasks(client, ctx)).map((t) => ({
+      id: t.id,
+      status: t.status,
+      model_name: t.model_name,
+      segment_index: t.segment_index
+    }))
+  return result
+}
+export async function recoverRepaintVideo(client, profile, operation) {
+  await requireServiceReady(client)
+  const { record, ctx } = await bound(client, profile, operation)
+  if (!record.attempted) {
+    if (
+      record.pendingView &&
+      isDeepStrictEqual(nodeView(ctx.generation), record.pendingView)
+    ) {
+      record.savedView = record.pendingView
+      record.pendingView = null
+      record.configSaved = true
+      record.state = 'prepared'
+      await persist(record)
+    }
+    return summary(record)
+  }
+  if (!record.taskId)
+    throw fail(
+      'REPAINT_VIDEO_SUBMISSION_UNKNOWN',
+      '尚无原提交接收ID；get仅展示观察到的任务，不认领或重发'
+    )
+  const task = await taskFor(client, record)
+  if (task.status === 'completed') await archiveRepaintResult(record, 'video', task.result, {
+    estimated_credit_cost: task.estimated_credit_cost,
+    credit_cost: task.credit_cost, billing_status: task.billing_status
+  })
+  // Fresh file proxy signatures alone must not cause another canvas write.
+  if (record.canvasSynced && record.terminalStatus === task.status)
+    return summary(record, task)
+  const data = {
+    ...ctx.generation.data,
+    last_task_id: record.taskId,
+    status: task.status,
+    error_message: text(task.error_message),
+    extra: { ...ctx.generation.data.extra, task_no: text(task.task_no) }
+  }
+  if (task.status === 'completed') {
+    data.result = {
+      file_ref: task.result.file_ref,
+      url: task.result.url,
+      mime_type: task.result.mime_type,
+      width: task.result.width || null,
+      height: task.result.height || null,
+      duration: task.result.duration || null,
+      task_id: record.taskId,
+      status: 'completed'
+    }
+    data.extra.file_ref = task.result.file_ref
+  }
+  await saveNode(client, record, ctx, data)
+  record.state = task.status
+  record.canvasSynced = !pending(task)
+  record.terminalStatus = pending(task) ? null : task.status
+  await persist(record)
+  return summary(record, task)
+}
+export async function waitRepaintVideo(
+  client,
+  profile,
+  operation,
+  interval = 3000,
+  timeout = 600000
+) {
+  if (![interval, timeout].every((v) => Number.isSafeInteger(v) && v > 0))
+    throw new Error('等待参数须为正整数')
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const result = await recoverRepaintVideo(client, profile, operation)
+    if (result.state === 'completed') return result
+    if (result.state === 'failed')
+      throw fail('TASK_FAILED', '原转绘任务失败；查询原错误和计费，不自动重做')
+    if (!result.submission_attempted) return result
+    await sleep(
+      Math.min(interval, Math.max(1, deadline - Date.now())),
+      undefined,
+      {
+        signal: cancellation.signal
+      }
+    )
+  }
+  throw fail('WAIT_TIMEOUT', '原视频仍待查询；继续同operation，不重新提交')
+}
+export async function downloadRepaintVideo(client, profile, operation, output) {
+  const { exportRepaintResult } = await import('./repaint-export.js')
+  return exportRepaintResult(client, profile, operation, 'video', output)
+}