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

package/src/remake.js

@@ -0,0 +1,738 @@
+import crypto from 'node:crypto'
+import path from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { atomic, json, root, safeName } from './store.js'
+import { scopedCanvas, materialScope } from './materials.js'
+import { readSource, normalizeMode, promptInput } from './generation-input.js'
+import { sameVideoReferences } from './media.js'
+import { segment } from './workflows.js'
+import { readProtocol, agreementError } from './agreement.js'
+import { cancellation } from './api.js'
+
+const text = (v) => String(v ?? '').trim()
+const hash = (v) => crypto.createHash('sha256').update(JSON.stringify(v)).digest('hex')
+const fail = (code, message, error) =>
+  Object.assign(new Error(message), {
+    code,
+    ...(error
+      ? {
+          cause: error,
+          diagnostic: {
+            ...(error.status ? { http_status: error.status } : {}),
+            ...(error.apiCode ? { api_code: error.apiCode } : {}),
+            ...(error.requestId ? { request_id: error.requestId } : {})
+          }
+        }
+      : {})
+  })
+export const remakePath = (profile, operation) =>
+  path.join(root(), 'remakes', safeName(profile), safeName(operation) + '.json')
+// Server prompt sanitization uses NFKC. Only treat compatibility punctuation as
+// equivalent here; other rewritten text still requires investigation.
+const comparablePrompt = (value) => text(value).normalize('NFKC')
+export function remakeInput(value) {
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    Object.keys(value).some(
+      (key) =>
+        ![
+          'doc_id',
+          'node_id',
+          'space',
+          'team_uid',
+          'start_ms',
+          'end_ms',
+          'model_name',
+          'resolution',
+          'prompt'
+        ].includes(key)
+    )
+  )
+    throw new Error('重拍输入无效或包含未接入字段；本轮仅源视频，不支持附加参考/时长/比例/声音开关')
+  for (const key of ['doc_id', 'node_id', 'model_name', 'resolution', 'prompt'])
+    if (typeof value[key] !== 'string' || !text(value[key])) throw new Error('重拍缺少 ' + key)
+  if (value.prompt.length > 20000 || /<[^>]+>|\[\[.*?\]\]/.test(value.prompt))
+    throw new Error('重拍提示词须为不含素材占位符的纯文本，最长20000字符')
+  if (
+    ![value.start_ms, value.end_ms].every(Number.isSafeInteger) ||
+    value.start_ms < 0 ||
+    value.end_ms - value.start_ms < 1000 ||
+    value.end_ms - value.start_ms > 120000
+  )
+    throw new Error('重拍使用整数毫秒，区间须在1–120秒内，另按当前模型限制校验')
+  materialScope(value.space, value.team_uid)
+  return Object.fromEntries(
+    Object.entries(value).map(([key, v]) => [key, typeof v === 'string' ? v.trim() : v])
+  )
+}
+export function mediaNodeSize(width, height) {
+  const ratio = width / height
+  return ratio >= 1
+    ? { width: Math.round(272 * ratio) + 2, height: 300 }
+    : { width: 274, height: Math.round(272 / ratio) + 28 }
+}
+async function sourceContext(client, input) {
+  const doc = await scopedCanvas(client, input.doc_id, input.space, input.team_uid)
+  const node = doc.nodes.find((n) => n.id === input.node_id),
+    data = node?.data || {}
+  if (
+    !node ||
+    !['video', 'video_upload'].includes(node.type) ||
+    data.extra?.repaint ||
+    data.extra?.video_remake ||
+    data.extra?.clip_redraw
+  )
+    throw new Error('重拍来源须为普通视频生成/素材节点')
+  const source = readSource(node)
+  const refs = [
+    data.resultFileRef,
+    data.fileRef,
+    data.file_ref,
+    data.extra?.file_ref,
+    data.result?.file_ref,
+    data.node_output?.file_ref
+  ]
+    .map(text)
+    .filter(Boolean)
+  const taskId = text(
+    data.sourceTaskId || data.extra?.source_task_id || data.last_task_id || data.lastTaskId
+  )
+  if (
+    !source.url ||
+    source.uploading ||
+    source.uploadError ||
+    new Set(refs).size !== 1 ||
+    !/^[1-9]\d*$/.test(taskId)
+  )
+    throw new Error('重拍要求同画布真实完成视频任务与一致媒体引用')
+  const task = await client.raw('/canvas/generations/' + segment(taskId))
+  if (
+    text(task.task_id ?? task.id) !== taskId ||
+    task.doc_id !== doc.id ||
+    task.segment_type !== 'video' ||
+    task.status !== 'completed' ||
+    !(await sameVideoReferences(client, refs[0], task.result?.file_ref))
+  )
+    throw new Error('重拍来源与同画布已完成视频任务不匹配')
+  const width = Number(task.result?.width),
+    height = Number(task.result?.height),
+    duration = Number(task.result?.duration)
+  if (
+    ![width, height].every((v) => Number.isSafeInteger(v) && v > 0) ||
+    !Number.isFinite(duration) ||
+    duration <= 0 ||
+    input.end_ms > Math.round(duration * 1000)
+  )
+    throw new Error('重拍区间超出真实视频，或缺少源片尺寸/时长')
+  return {
+    doc,
+    node,
+    binding: { task_id: taskId, file_ref: refs[0], width, height, duration },
+    url: client.baseUrl + '/files/' + encodeURIComponent(refs[0])
+  }
+}
+async function identity(client, input) {
+  const me = await client.raw('/auth/me')
+  if (!text(me.uid)) throw new Error('重拍账号信息缺少UID')
+  const team =
+    input.space === 'team' &&
+    me.teams?.find((t) => text(t.uid) === input.team_uid && t.status === 'active')
+  if (input.space === 'team' && !team) throw new Error('当前账号没有目标团队的有效成员身份')
+  return {
+    owner: text(me.uid),
+    wallet: {
+      space: input.space,
+      team_uid: input.team_uid || null,
+      ...(team ? { team_name: team.name, shared: true } : {}),
+      balance_snapshot: (team || me).oo_balance ?? (team || me).credit_balance ?? null,
+      currency: 'OO'
+    }
+  }
+}
+async function validateModel(client, input) {
+  const catalog = await client.raw(
+    '/canvas/models' + (input.space === 'team' ? '?team_uid=' + segment(input.team_uid) : '')
+  )
+  const model = catalog.items?.find(
+    (m) => m.label === input.model_name && m.content_type === 'video' && !m.member_locked
+  )
+  if (!model || !model.generation_modes?.map(normalizeMode).includes('video_editing'))
+    throw new Error('模型未在当前空间声明支持视频编辑/重拍')
+  if (!model.resolutions?.includes(input.resolution))
+    throw new Error('重拍分辨率不在当前模型可选项内')
+  if (model.supports_draft === true && /draft|样片/i.test(model.label))
+    throw new Error('片段重拍不支持样片模型')
+  const seconds = (input.end_ms - input.start_ms) / 1000
+  if (
+    (model.durations?.min != null && seconds < Number(model.durations.min)) ||
+    (model.durations?.max != null && seconds > Number(model.durations.max))
+  )
+    throw new Error('片段时长不在当前模型的重拍范围内')
+  if (model.prompt_max_length && input.prompt.length > model.prompt_max_length)
+    throw new Error('提示词超出当前模型长度限制')
+  return model
+}
+function configNode(record, current) {
+  const { input, binding } = record
+  return {
+    id: record.configId,
+    type: 'video',
+    ...mediaNodeSize(binding.width, binding.height),
+    position: {
+      x: Math.round(Number(current.node.position?.x || 0) + Number(current.node.width || 486) + 80),
+      y: Math.round(Number(current.node.position?.y || 0))
+    },
+    data: {
+      title: '片段重拍',
+      prompt: input.prompt,
+      model_name: input.model_name,
+      duration: (input.end_ms - input.start_ms) / 1000,
+      extra: {
+        node_kind: 'generation',
+        generation_mode: 'video_editing',
+        resolution: input.resolution,
+        aspect_ratio: binding.width + ':' + binding.height,
+        video_remake: {
+          role: 'node',
+          sourceNodeId: input.node_id,
+          sourceRef: binding.file_ref,
+          sourceUrl: current.url,
+          sourceDuration: binding.duration,
+          clipStart: input.start_ms / 1000,
+          clipEnd: input.end_ms / 1000
+        }
+      }
+    }
+  }
+}
+function configMatches(node, record) {
+  const data = node?.data || {},
+    remake = data.extra?.video_remake,
+    input = record.input
+  return (
+    ['video', 'video_upload'].includes(node?.type) &&
+    data.model_name === input.model_name &&
+    data.prompt === input.prompt &&
+    data.extra?.resolution === input.resolution &&
+    data.extra?.generation_mode === 'video_editing' &&
+    remake?.role === 'node' &&
+    remake.sourceNodeId === input.node_id &&
+    remake.sourceRef === record.binding.file_ref &&
+    remake.clipStart === input.start_ms / 1000 &&
+    remake.clipEnd === input.end_ms / 1000
+  )
+}
+const edge = (id, source, target, role) => ({
+  id,
+  source,
+  target,
+  sourceHandle: '',
+  targetHandle: '',
+  type: 'default',
+  data: { role, repaintSystem: true }
+})
+const edgeExists = (doc, source, target, role) =>
+  doc.edges.some((e) => e.source === source && e.target === target && e.data?.role === role)
+const summary = (r) => ({
+  operation: r.operation,
+  state: r.state,
+  doc_id: r.input.doc_id,
+  source_node_id: r.input.node_id,
+  configuration_node_id: r.configId,
+  result_node_id: r.task ? r.resultId : null,
+  task_id: r.task?.id || null,
+  canvas_synced: r.canvasSynced === true,
+  processing_submitted: Boolean(r.task || r.taskId) ? true : r.submitAttempted ? null : false,
+  library_saved: false,
+  ...(r.task ? { task: r.task } : {}),
+  ...(r.lastFailure ? { last_failure: r.lastFailure } : {})
+})
+async function bound(client, profile, operation) {
+  const record = await json(remakePath(profile, operation), null)
+  if (!record) throw new Error('未找到原重拍operation')
+  if (
+    record.baseUrl !== client.baseUrl ||
+    record.owner !== (await identity(client, record.input)).owner
+  )
+    throw new Error('重拍operation的账号或服务不匹配')
+  const current = await sourceContext(client, record.input)
+  const { file_ref: oldRef, ...oldBinding } = record.binding,
+    { file_ref: newRef, ...newBinding } = current.binding
+  if (hash(oldBinding) !== hash(newBinding) || !(await sameVideoReferences(client, oldRef, newRef)))
+    throw new Error('重拍源任务或素材已变化，停止恢复')
+  const config = current.doc.nodes.find((n) => n.id === record.configId)
+  if (
+    config &&
+    (!configMatches(config, record) ||
+      !edgeExists(current.doc, record.input.node_id, config.id, 'video-remake-input'))
+  )
+    throw new Error('重拍配置/来源线已变化，停止覆盖')
+  if (!config && (record.configSaved || record.configSaveAttempted))
+    throw fail('REMAKE_SYNC_PENDING', '原配置节点缺失或保存未知；不自动重建')
+  return { record, current, config }
+}
+async function save(client, profile, record, doc, nodes, edges, attemptedKey) {
+  if (!Number.isSafeInteger(doc.version) || !doc.viewport || !doc.meta || !Array.isArray(doc.edges))
+    throw new Error('重拍画布快照不完整')
+  record[attemptedKey] = true
+  await atomic(remakePath(profile, record.operation), record)
+  try {
+    const saved = await client.raw(
+      '/canvas/docs/' + segment(doc.id),
+      {
+        method: 'PUT',
+        body: {
+          version: doc.version,
+          name: doc.name,
+          viewport: doc.viewport,
+          nodes,
+          edges,
+          meta: doc.meta
+        }
+      },
+      { retry: false }
+    )
+    if (
+      saved.id !== doc.id ||
+      saved.version <= doc.version ||
+      !Array.isArray(saved.nodes) ||
+      !Array.isArray(saved.edges)
+    )
+      throw new Error('画布保存响应不完整')
+    return saved
+  } catch (error) {
+    if (error.status === 409 || error.apiCode === 3002) record[attemptedKey] = false
+    record.state = 'sync_pending'
+    await atomic(remakePath(profile, record.operation), record)
+    throw fail(
+      'REMAKE_SYNC_PENDING',
+      '重拍画布保存未确认；查原节点后恢复原operation，不重拍或重建缺失节点',
+      error
+    )
+  }
+}
+async function persistConfig(client, profile, record, current) {
+  const existing = current.doc.nodes.find((n) => n.id === record.configId)
+  if (!existing) {
+    if (record.configSaved || record.configSaveAttempted)
+      throw fail('REMAKE_SYNC_PENDING', '配置保存未知或节点被删，不自动重建')
+    const node = configNode(record, current),
+      link = edge(
+        'remake-input-' + record.configId,
+        record.input.node_id,
+        record.configId,
+        'video-remake-input'
+      )
+    const saved = await save(
+      client,
+      profile,
+      record,
+      current.doc,
+      [...current.doc.nodes, node],
+      [...current.doc.edges, link],
+      'configSaveAttempted'
+    )
+    if (
+      !configMatches(
+        saved.nodes.find((n) => n.id === node.id),
+        record
+      ) ||
+      !edgeExists(saved, record.input.node_id, node.id, 'video-remake-input')
+    )
+      throw fail('REMAKE_SYNC_PENDING', '重拍配置保存结果不完整')
+  } else if (
+    !configMatches(existing, record) ||
+    !edgeExists(current.doc, record.input.node_id, existing.id, 'video-remake-input')
+  )
+    throw new Error('原重拍配置已变化')
+  record.configSaved = true
+  record.state = 'prepared'
+  await atomic(remakePath(profile, record.operation), record)
+  return summary(record)
+}
+export async function prepareRemake(client, profile, value, operation, confirmed = false) {
+  const input = remakeInput(value),
+    file = remakePath(profile, operation),
+    old = await json(file, null)
+  if (old) {
+    if (hash(old.input) !== hash(input)) throw new Error('原重拍operation不能修改输入')
+    return getRemake(client, profile, operation)
+  }
+  const current = await sourceContext(client, input),
+    account = await identity(client, input)
+  await validateModel(client, input)
+  if (!confirmed)
+    return {
+      operation,
+      configuration_saved: false,
+      processing_submitted: false,
+      library_saved: false,
+      input,
+      source: {
+        task_id: current.binding.task_id,
+        width: current.binding.width,
+        height: current.binding.height,
+        duration: current.binding.duration
+      },
+      wallet: account.wallet,
+      next: '核对区间/参数并暂停画布编辑后，prepare加--yes仅创建重拍配置和来源线；之后submit预估，不生成'
+    }
+  const record = {
+    operation,
+    owner: account.owner,
+    baseUrl: client.baseUrl,
+    input,
+    binding: current.binding,
+    configId: 'remake-' + crypto.randomUUID(),
+    resultId: 'remake-result-' + crypto.randomUUID(),
+    state: 'preparing',
+    createdAt: new Date().toISOString()
+  }
+  await atomic(file, record)
+  return persistConfig(client, profile, record, current)
+}
+export function estimateBody(record, current) {
+  const input = record.input
+  const source = readSource(current.node)
+  const prompt = promptInput({ data: { prompt: input.prompt } }, [source], [], [source], {
+    image: [],
+    video: [source.url],
+    audio: []
+  }).nodePrompt.trim()
+  return {
+    doc_id: input.doc_id,
+    node_id: record.configId,
+    segment_type: 'video',
+    prompt,
+    model_name: input.model_name,
+    duration: Math.round((input.end_ms - input.start_ms) / 1000),
+    resolution: input.resolution,
+    reference_video_urls: [source.url],
+    reference_image_urls: [],
+    reference_audio_urls: [],
+    reference_asset_ids: [],
+    reference_canvas_task_ids: [],
+    extra: { generation_mode: 'video_editing' },
+    protocol_agreed: false
+  }
+}
+async function quote(client, record, current) {
+  await validateModel(client, record.input)
+  const estimate = await client.raw('/canvas/generations/estimate', {
+    method: 'POST',
+    body: estimateBody(record, current)
+  })
+  if (
+    !Number.isFinite(Number(estimate.estimated_credit_cost)) ||
+    Number(estimate.estimated_credit_cost) < 0 ||
+    estimate.estimated_credit_cost == null ||
+    estimate.will_intercept
+  )
+    throw new Error('重拍预估未通过或费用缺失，停止提交')
+  return estimate
+}
+export function submissionBody(record, sourceRef = record.binding.file_ref) {
+  return {
+    source_ref: sourceRef,
+    start_ms: record.input.start_ms,
+    end_ms: record.input.end_ms,
+    model_name: record.input.model_name,
+    prompt: record.input.prompt,
+    resolution: record.input.resolution,
+    generation_mode: 'video_editing',
+    protocol_agreed: false
+  }
+}
+function validateTask(response, record) {
+  const task = response?.task || response,
+    clip = response?.clip || task?.clip
+  if (
+    !task ||
+    !/^[a-zA-Z0-9_-]{1,100}$/.test(text(task.id)) ||
+    !clip ||
+    text(clip.source_task_id) !== record.binding.task_id ||
+    clip.start_ms !== record.input.start_ms ||
+    clip.end_ms !== record.input.end_ms ||
+    Number(clip.id) <= 0 ||
+    Number(task.clip_id) !== Number(clip.id) ||
+    comparablePrompt(task.prompt) !== comparablePrompt(record.input.prompt) ||
+    task.model_name !== record.input.model_name ||
+    task.resolution !== record.input.resolution ||
+    !['queued', 'processing', 'retrying', 'completed', 'failed', 'cancelled'].includes(task.status)
+  )
+    throw new Error('重拍任务来源/区间/参数响应不完整，不重发提交')
+  if (record.task && text(record.task.id) !== text(task.id)) throw new Error('查询返回不同重拍任务')
+  return { ...structuredClone(task), clip: structuredClone(clip) }
+}
+export async function submitRemake(
+  client,
+  profile,
+  operation,
+  confirmed = false,
+  expectedCost,
+  options = {}
+) {
+  let { record, current, config } = await bound(client, profile, operation)
+  if (!config || !record.configSaved) throw new Error('先恢复原配置保存，再预估')
+  if (record.submitAttempted) return getRemake(client, profile, operation)
+  let estimate = await quote(client, record, current)
+  if (!confirmed) {
+    record.estimate = estimate
+    await atomic(remakePath(profile, operation), record)
+    return {
+      ...summary(record),
+      submitted: false,
+      parameters: record.input,
+      estimate,
+      wallet: (await identity(client, record.input)).wallet,
+      next: '展示原视频/区间/模型/提示词/钱包和费用，取得当次确认后submit原operation加--yes --expected-cost；不能保证重发幂等'
+    }
+  }
+  const cost = Number(expectedCost)
+  if (
+    expectedCost === undefined ||
+    !Number.isFinite(cost) ||
+    cost < 0 ||
+    !record.estimate ||
+    Number(record.estimate.estimated_credit_cost) !== cost ||
+    Number(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模型使用承诺书》（code4401），尚未提交重拍',
+        protocol
+      )
+    await options.onAgreementRequired({
+      operation,
+      body: { model_name: record.input.model_name },
+      estimate
+    })
+    const fresh = await bound(client, profile, operation)
+    record = fresh.record
+    current = fresh.current
+    const next = await readProtocol(client)
+    if (next.version !== protocol.version || (next.required && !next.agreed))
+      throw agreementError('AGREEMENT_CHANGED', '协议版本或状态变化，停止重拍', next)
+    protocol = next
+    estimate = await quote(client, record, current)
+    if (Number(estimate.estimated_credit_cost) !== cost)
+      throw new Error('协议确认后重拍费用已变化，重新预估确认')
+  }
+  const fresh = await bound(client, profile, operation)
+  record = fresh.record
+  current = fresh.current
+  // No server idempotency contract. Persist the attempt before the only POST.
+  record.submitAttempted = true
+  record.state = 'submitting'
+  record.approvedCost = cost
+  await atomic(remakePath(profile, operation), record)
+  try {
+    const response = await client.raw(
+      '/clip-redraw/tasks',
+      { method: 'POST', body: submissionBody(record, current.binding.file_ref) },
+      { retry: false }
+    )
+    const id = text((response?.task || response)?.id)
+    if (/^[a-zA-Z0-9_-]{1,100}$/.test(id)) {
+      record.taskId = id
+      await atomic(remakePath(profile, operation), record)
+    }
+    record.task = validateTask(response, record)
+    record.state = 'submitted'
+    await atomic(remakePath(profile, operation), record)
+  } catch (error) {
+    if (error.apiCode === 4401) {
+      record.submitAttempted = false
+      record.state = 'blocked_agreement'
+      record.lastFailure = { api_code: 4401, status: 'awaiting_agreement' }
+      await atomic(remakePath(profile, operation), record)
+      throw agreementError(
+        'AGREEMENT_REQUIRED',
+        '《统一协议》《Seedance2.0模型使用承诺书》需本人确认（code4401）；重拍未执行',
+        await readProtocol(client)
+      )
+    }
+    record.state = 'submission_unknown'
+    record.lastFailure = {
+      ...(error.status ? { http_status: error.status } : {}),
+      ...(error.apiCode ? { api_code: error.apiCode } : {}),
+      ...(error.requestId ? { request_id: error.requestId } : {})
+    }
+    await atomic(remakePath(profile, operation), record)
+    throw fail(
+      'REMAKE_SUBMISSION_UNKNOWN',
+      '重拍提交结果未确认；不换operation或重发POST，先查后端与原任务副作用',
+      error
+    )
+  }
+  return syncRemake(client, profile, operation)
+}
+export async function getRemake(client, profile, operation) {
+  const { record, current, config } = await bound(client, profile, operation)
+  if (record.submitAttempted && !record.task && !record.taskId)
+    throw fail('REMAKE_SUBMISSION_UNKNOWN', '重拍提交未知且没有可靠查询ID，不自动重提或猜测任务')
+  if (record.task || record.taskId) {
+    record.task = validateTask(
+      await client.raw('/clip-redraw/tasks/' + segment(record.task?.id || record.taskId)),
+      record
+    )
+    if (record.state === 'submission_unknown') record.state = 'submitted'
+    await atomic(remakePath(profile, operation), record)
+  }
+  const result = summary(record)
+  if (!config) result.state = 'configuration_pending'
+  if (record.task) {
+    const node = current.doc.nodes.find((n) => n.id === record.resultId)
+    result.canvas_synced = Boolean(
+      node &&
+      node.data?.extra?.clip_redraw?.taskId === record.task.id &&
+      edgeExists(current.doc, record.configId, node.id, 'clip-redraw-link') &&
+      node.data.extra.clip_redraw.status === record.task.status &&
+      (record.task.status !== 'completed' || node.data?.result?.url === record.task.result?.url)
+    )
+    if (record.canvasSynced && !node) result.state = 'canvas_changed'
+  }
+  return result
+}
+export async function syncRemake(client, profile, operation) {
+  await getRemake(client, profile, operation)
+  const { record, current, config } = await bound(client, profile, operation)
+  if (!record.task) return persistConfig(client, profile, record, current)
+  const task = record.task,
+    clip = task.clip,
+    result = task.result
+  let node = current.doc.nodes.find((n) => n.id === record.resultId)
+  if (!node && (record.resultSaveAttempted || record.canvasSynced))
+    throw fail('REMAKE_SYNC_PENDING', '重拍结果节点缺失或保存未知，禁止自动重建')
+  if (
+    node &&
+    (node.type !== 'video_upload' ||
+      node.data?.extra?.clip_redraw?.taskId !== task.id ||
+      !edgeExists(current.doc, record.configId, node.id, 'clip-redraw-link'))
+  )
+    throw new Error('重拍结果节点/系统线已变化，停止覆盖')
+  if (
+    node?.data?.result?.url &&
+    node.data.extra.clip_redraw.status === 'completed' &&
+    result?.file_ref &&
+    !(await sameVideoReferences(client, node.data.extra.file_ref, result.file_ref))
+  )
+    throw new Error('重拍结果素材已被替换，停止同步')
+  const marker = {
+    role: 'clip-redraw',
+    taskId: task.id,
+    taskNo: task.task_no || '',
+    clipId: clip.id,
+    status: task.status,
+    progress: task.progress || 0,
+    prompt: task.prompt,
+    sourceNodeId: record.configId,
+    clip,
+    result: result || null,
+    errorMessage: task.error_message || ''
+  }
+  if (task.status === 'completed' && (!result?.url || !result.file_ref))
+    throw new Error('重拍任务完成但缺少稳定结果引用，停止落图')
+  const data = {
+    ...(node?.data || {}),
+    title: node?.data?.title || '片段重拍 结果',
+    mediaType: 'video',
+    status: task.status,
+    url: result?.url || '',
+    file_ref: result?.file_ref || '',
+    file_name: clip.file_name || '',
+    file_size: result?.file_size || result?.size || 0,
+    width: result?.width || 0,
+    height: result?.height || 0,
+    duration: result?.duration || (record.input.end_ms - record.input.start_ms) / 1000,
+    last_task_id: task.id,
+    result: result || null,
+    extra: {
+      ...(node?.data?.extra || {}),
+      node_kind: 'asset',
+      file_ref: result?.file_ref || '',
+      clip_redraw: marker,
+      task_no: task.task_no || '',
+      aspect_ratio: result?.width && result?.height ? result.width + ':' + result.height : ''
+    }
+  }
+  const output = {
+    ...(node || {
+      id: record.resultId,
+      type: 'video_upload',
+      position: { x: config.position.x + (config.width || 420) + 96, y: config.position.y }
+    }),
+    data
+  }
+  const configData = {
+    ...config.data,
+    extra: {
+      ...config.data.extra,
+      video_remake: { ...config.data.extra.video_remake, clipId: clip.id, clip },
+      clip_redraw: {
+        taskId: task.id,
+        taskNo: task.task_no || '',
+        clipId: clip.id,
+        status: task.status,
+        progress: task.progress || 0
+      }
+    }
+  }
+  const nodes = current.doc.nodes.map((n) =>
+    n.id === record.configId ? { ...n, data: configData } : n.id === record.resultId ? output : n
+  )
+  if (!node) nodes.push(output)
+  const edges = node
+    ? current.doc.edges
+    : [
+        ...current.doc.edges,
+        edge(
+          'remake-result-' + record.resultId,
+          record.configId,
+          record.resultId,
+          'clip-redraw-link'
+        )
+      ]
+  const saved = await save(
+    client,
+    profile,
+    record,
+    current.doc,
+    nodes,
+    edges,
+    'resultSaveAttempted'
+  )
+  if (
+    saved.nodes.find((n) => n.id === record.resultId)?.data?.extra?.clip_redraw?.taskId !==
+      task.id ||
+    !edgeExists(saved, record.configId, record.resultId, 'clip-redraw-link')
+  )
+    throw fail('REMAKE_SYNC_PENDING', '重拍结果保存响应不完整')
+  record.canvasSynced = true
+  record.state =
+    task.status === 'completed' ? 'completed' : task.status === 'failed' ? 'failed' : 'submitted'
+  await atomic(remakePath(profile, operation), record)
+  return summary(record)
+}
+export async function recoverRemake(client, profile, operation, confirmed = false) {
+  return confirmed ? syncRemake(client, profile, operation) : getRemake(client, profile, operation)
+}
+export async function waitRemake(client, profile, operation, interval = 6000, timeout = 600000) {
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const status = await getRemake(client, profile, operation)
+    if (!status.task_id) throw new Error('重拍尚未提交任务')
+    if (['completed', 'failed', 'cancelled'].includes(status.task.status))
+      return syncRemake(client, profile, operation)
+    await sleep(Math.min(interval, Math.max(1, deadline - Date.now())), undefined, {
+      signal: cancellation.signal
+    })
+  }
+  throw fail('WAIT_TIMEOUT', '重拍等待超时，保留原任务，用原operation继续wait/recover')
+}