670 lines
36 KiB
TypeScript
670 lines
36 KiB
TypeScript
import { NODE_DEFAULT_SIZE } from "@/constant/canvas";
|
||
import { commitCanvasGenerationResult } from "@/lib/canvas/canvas-generation-result";
|
||
import { findAvailableGenerationGroupPosition, imageGenerationChildPosition } from "@/lib/canvas/canvas-generation-layout";
|
||
import { fitNodeSize, nodeSizeFromRatio, VIDEO_NODE_MAX_SIZE } from "@/lib/canvas/canvas-node-size";
|
||
import { compositeEmotionImage } from "@/lib/canvas/canvas-emotion";
|
||
import { storeGeneratedAudio } from "@/services/api/audio";
|
||
import { storeGeneratedVideo } from "@/services/api/video";
|
||
import { parseBackendGenerationResult } from "@/services/api/generation-task";
|
||
import type { GenerationTask, GenerationTaskOutput } from "@/services/api/task-center";
|
||
import { resolveMediaUrl, resolveVideoMediaUrl, type UploadedFile } from "@/services/file-storage";
|
||
import { resolveImageUrl, uploadImage, type UploadedImage } from "@/services/image-storage";
|
||
import { getCachedResourceBlob } from "@/services/resource-blob-cache";
|
||
import { useCanvasStore } from "@/stores/canvas/use-canvas-store";
|
||
import { useAssetStore } from "@/stores/use-asset-store";
|
||
import { applyGenerationConsumerEffect, generationEffectApplied } from "@/services/generation-consumer-dedupe";
|
||
import { commitProducedModel } from "@/lib/canvas/produced-model";
|
||
import { experimentalLayerSignature, hasUsableLayerTransparency, imageLayerCompositeSignature, validateImageLayerOutput } from "@/lib/canvas/canvas-image-layers";
|
||
import { composeCanvasImageLayerGroup, decodeAndComposeImageLayers, inspectImageLayer, normalizeImageLayerCanvas } from "@/services/canvas-image-layer-compositor";
|
||
import { patchImageLayerBackground } from "@/services/canvas-image-layer-source";
|
||
import { imageLayerTargetName } from "@/lib/canvas/canvas-image-layer-plan";
|
||
import { resetGenerationTaskMetadata } from "@/lib/canvas/canvas-task-state";
|
||
import { CanvasNodeType, type CanvasGenerationMode, type CanvasNodeData, type CanvasNodeMetadata } from "@/types/canvas";
|
||
|
||
export function generationTaskInput(task: GenerationTask) {
|
||
if (!task.inputJson) return null;
|
||
try {
|
||
return JSON.parse(task.inputJson) as { mode?: CanvasGenerationMode; metadata?: { nodeId?: string; sourceNodeId?: string; domainProjectId?: string; layerDecomposition?: boolean }; prompt?: string };
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
export function generationTaskNodeId(task: GenerationTask) {
|
||
return task.clientContext?.nodeId || generationTaskInput(task)?.metadata?.nodeId || "";
|
||
}
|
||
|
||
export function generationTaskMode(task: GenerationTask, fallback?: CanvasGenerationMode): CanvasGenerationMode {
|
||
const inputMode = generationTaskInput(task)?.mode;
|
||
if (inputMode === "text" || inputMode === "image" || inputMode === "video" || inputMode === "audio") return inputMode;
|
||
if (task.type === "canvas_text") return "text";
|
||
if (task.type === "canvas_video") return "video";
|
||
if (task.type === "canvas_audio") return "audio";
|
||
if (task.type === "canvas_image") return "image";
|
||
return fallback || "image";
|
||
}
|
||
|
||
export function generationTaskCanReloadResource(task: GenerationTask) {
|
||
const mode = generationTaskMode(task);
|
||
return task.status === "succeeded" && (mode === "image" || mode === "video" || mode === "audio") && (Boolean(task.resultJson) || Boolean(task.outputs?.length));
|
||
}
|
||
|
||
export function imageMetadata(image: UploadedImage): CanvasNodeMetadata {
|
||
return {
|
||
content: image.url,
|
||
storageKey: image.storageKey,
|
||
status: "success",
|
||
naturalWidth: image.width,
|
||
naturalHeight: image.height,
|
||
bytes: image.bytes,
|
||
mimeType: image.mimeType,
|
||
errorDetails: undefined,
|
||
generationErrorCode: undefined,
|
||
resourceReloadAvailable: undefined,
|
||
failedPromptFingerprint: undefined,
|
||
};
|
||
}
|
||
|
||
export function videoMetadata(video: UploadedFile): CanvasNodeMetadata {
|
||
return {
|
||
content: video.url,
|
||
storageKey: video.storageKey,
|
||
status: "success",
|
||
naturalWidth: video.width,
|
||
naturalHeight: video.height,
|
||
bytes: video.bytes,
|
||
mimeType: video.mimeType || "video/mp4",
|
||
durationMs: video.durationMs,
|
||
hasAudio: video.hasAudio,
|
||
videoPreview: video.preview
|
||
? {
|
||
content: video.preview.url,
|
||
storageKey: video.preview.storageKey,
|
||
width: video.preview.width,
|
||
height: video.preview.height,
|
||
bytes: video.preview.bytes,
|
||
mimeType: video.preview.mimeType,
|
||
}
|
||
: undefined,
|
||
errorDetails: undefined,
|
||
generationErrorCode: undefined,
|
||
resourceReloadAvailable: undefined,
|
||
failedPromptFingerprint: undefined,
|
||
};
|
||
}
|
||
|
||
export function audioMetadata(audio: UploadedFile): CanvasNodeMetadata {
|
||
return {
|
||
content: audio.url,
|
||
storageKey: audio.storageKey,
|
||
status: "success",
|
||
bytes: audio.bytes,
|
||
mimeType: audio.mimeType || "audio/mpeg",
|
||
durationMs: audio.durationMs,
|
||
errorDetails: undefined,
|
||
generationErrorCode: undefined,
|
||
resourceReloadAvailable: undefined,
|
||
failedPromptFingerprint: undefined,
|
||
};
|
||
}
|
||
|
||
function workflowMetadataForResultNode(): Partial<CanvasNodeMetadata> {
|
||
return {
|
||
workflowProvider: undefined,
|
||
runningHubWorkflowId: undefined,
|
||
runningHubWorkflowKind: undefined,
|
||
workflowParameters: undefined,
|
||
};
|
||
}
|
||
|
||
// 原地重生会换 storageKey 但继承旧 assetId，形成「旧素材 + 新资源」配对，云端校验会永久拒绝。
|
||
// 新媒体结果必须清掉旧绑定，交给入库/修复路径按新资源重绑。
|
||
export function applyGeneratedMediaResultMetadata(node: CanvasNodeData, media: CanvasNodeMetadata, extra: Partial<CanvasNodeMetadata> = {}, fallbackModel?: string): CanvasNodeMetadata {
|
||
return commitProducedModel(
|
||
{
|
||
...node.metadata,
|
||
...workflowMetadataForResultNode(),
|
||
...media,
|
||
...extra,
|
||
errorDetails: undefined,
|
||
assetId: undefined,
|
||
},
|
||
fallbackModel,
|
||
);
|
||
}
|
||
|
||
export async function buildSourceImageLayerNodeResult(node: CanvasNodeData, image: { dataUrl: string }, signal: AbortSignal): Promise<CanvasNodeData> {
|
||
const extraction = node.metadata?.layerExtraction;
|
||
if (!extraction?.strategy || extraction.strategy.method === "generate") throw new Error("本层不是原图提取结果");
|
||
if ((extraction.index === 0) !== (extraction.strategy.method === "source")) throw new Error("原图提取方式与本层角色不一致");
|
||
if (signal.aborted) throw new DOMException("拆层已停止", "AbortError");
|
||
const uploaded = await uploadImage(image.dataUrl);
|
||
if (signal.aborted) throw new DOMException("拆层已停止", "AbortError");
|
||
return {
|
||
...node,
|
||
metadata: applyGeneratedMediaResultMetadata({ ...node, metadata: resetGenerationTaskMetadata(node.metadata) }, imageMetadata(uploaded), {
|
||
model: undefined,
|
||
producedModelCandidate: undefined,
|
||
producedModel: undefined,
|
||
layerExtraction: { ...extraction, phase: "complete", rejectedTaskId: undefined, extractionTaskId: undefined },
|
||
}),
|
||
};
|
||
}
|
||
|
||
export async function buildGenerationTaskNodeResult(node: CanvasNodeData, task: GenerationTask, nodes: CanvasNodeData[] = [node], outputIndex = 0): Promise<CanvasNodeData> {
|
||
const mode = generationTaskMode(task, node.type === CanvasNodeType.Text ? "text" : node.type === CanvasNodeType.Video ? "video" : node.type === CanvasNodeType.Audio ? "audio" : "image");
|
||
const prompt = node.metadata?.prompt || task.prompt;
|
||
const result = parseBackendGenerationResult(task);
|
||
|
||
if (mode === "image") {
|
||
const sourceResultStorageKey = result.images?.[outputIndex]?.storageKey;
|
||
let extraction = node.metadata?.layerExtraction;
|
||
let needsRemoval = false;
|
||
if (node.metadata?.layerExtraction) {
|
||
if (result.images?.length !== 1) throw new Error("逐层提取必须返回一张独立图片，不能返回拼版或多张候选图");
|
||
const normalized = await normalizeImageLayerCanvas(result.images[0], extraction?.canvas);
|
||
const info = normalized.info;
|
||
result.images[0] = normalized.image;
|
||
if (!info.nonempty) throw new Error("提取结果是完全透明的空图层");
|
||
if (extraction?.canvas && (info.width !== extraction.canvas.width || info.height !== extraction.canvas.height)) throw new Error("图层尺寸与底图不一致，已停止后续调用");
|
||
needsRemoval = Boolean(extraction?.index && !hasUsableLayerTransparency(info) && extraction.allowBackgroundRemoval && extraction.phase === "extract");
|
||
if (!needsRemoval) validateImageLayerOutput(info);
|
||
if (extraction?.index === 0 && extraction.backgroundPatch) result.images[0] = await patchImageLayerBackground(normalized.image, extraction.backgroundPatch);
|
||
extraction = { ...extraction!, phase: needsRemoval ? "background-removal-required" : "complete", extractionTaskId: extraction?.phase === "extract" ? task.id : extraction?.extractionTaskId, rejectedTaskId: undefined };
|
||
}
|
||
const image = result.images?.[outputIndex];
|
||
if (!image?.dataUrl) throw new Error("后端任务没有返回图片");
|
||
let resultDataUrl = image.dataUrl;
|
||
const emotionEdit = node.metadata?.emotionEdit;
|
||
if (emotionEdit) {
|
||
if (!emotionEdit.editRegion) throw new Error("情绪编辑任务缺少局部合成区域，已拒绝使用整图重绘结果");
|
||
const sourceNode = nodes.find((item) => item.id === emotionEdit.sourceNodeId);
|
||
if (!sourceNode?.metadata?.content) throw new Error("情绪编辑源图片已删除，无法恢复局部合成结果");
|
||
const sourceDataUrl = await resolveImageUrl(sourceNode.metadata.storageKey, sourceNode.metadata.content);
|
||
if (!sourceDataUrl) throw new Error("无法读取情绪编辑源图片，未使用整图重绘结果");
|
||
resultDataUrl = await compositeEmotionImage(sourceDataUrl, image.dataUrl, emotionEdit.editRegion, emotionEdit.faceBox);
|
||
}
|
||
const uploaded =
|
||
image.storageKey && !emotionEdit
|
||
? { url: await resolveImageUrl(image.storageKey, image.dataUrl), storageKey: image.storageKey, width: image.width || 1024, height: image.height || 1024, bytes: image.bytes || 0, mimeType: image.mimeType || "image/png" }
|
||
: await uploadImage(resultDataUrl);
|
||
const imageConfig = NODE_DEFAULT_SIZE[CanvasNodeType.Image];
|
||
if (extraction) extraction = { ...extraction, sourceResultStorageKey: uploaded.storageKey !== sourceResultStorageKey ? sourceResultStorageKey : undefined };
|
||
const requestedImageSize = nodeSizeFromRatio(node.metadata?.size || "auto", imageConfig.width, imageConfig.height);
|
||
const imageSizeBounds = requestedImageSize || { width: node.width || imageConfig.width, height: node.height || imageConfig.height };
|
||
const hasReportedImageSize = Boolean(image.width && image.width > 0 && image.height && image.height > 0);
|
||
const resultWidth = image.storageKey && !hasReportedImageSize && requestedImageSize ? requestedImageSize.width : uploaded.width;
|
||
const resultHeight = image.storageKey && !hasReportedImageSize && requestedImageSize ? requestedImageSize.height : uploaded.height;
|
||
const normalizedImage = resultWidth === uploaded.width && resultHeight === uploaded.height ? uploaded : { ...uploaded, width: resultWidth, height: resultHeight };
|
||
const imageSize =
|
||
node.metadata?.generationType === "edit" && !requestedImageSize ? { width: node.width || imageConfig.width, height: node.height || imageConfig.height } : fitNodeSize(resultWidth, resultHeight, imageSizeBounds.width, imageSizeBounds.height);
|
||
return {
|
||
...node,
|
||
type: CanvasNodeType.Image,
|
||
width: imageSize.width,
|
||
height: imageSize.height,
|
||
position: { x: node.position.x + node.width / 2 - imageSize.width / 2, y: node.position.y + node.height / 2 - imageSize.height / 2 },
|
||
metadata: applyGeneratedMediaResultMetadata(
|
||
node,
|
||
imageMetadata(normalizedImage),
|
||
{ prompt, ...completedTaskMetadata(task), generationOutputCount: 1, ...(extraction ? { layerExtraction: extraction, status: needsRemoval ? "idle" : "success" } : {}) },
|
||
task.model,
|
||
),
|
||
};
|
||
}
|
||
|
||
if (mode === "video") {
|
||
if (!result.video?.storageKey && !result.video?.dataUrl) throw new Error("后端任务没有返回视频");
|
||
const video = result.video.storageKey ? await cacheGeneratedRemoteVideo({ ...result.video, storageKey: result.video.storageKey }) : await storeGeneratedVideo({ url: result.video.dataUrl, mimeType: result.video.mimeType || "video/mp4" });
|
||
const videoSize = fitNodeSize(video.width || node.width || VIDEO_NODE_MAX_SIZE.width, video.height || node.height || VIDEO_NODE_MAX_SIZE.height, VIDEO_NODE_MAX_SIZE.width, VIDEO_NODE_MAX_SIZE.height);
|
||
const geometry = node.metadata?.locked
|
||
? {}
|
||
: {
|
||
width: videoSize.width,
|
||
height: videoSize.height,
|
||
position: { x: node.position.x + node.width / 2 - videoSize.width / 2, y: node.position.y + node.height / 2 - videoSize.height / 2 },
|
||
};
|
||
return {
|
||
...node,
|
||
type: CanvasNodeType.Video,
|
||
...geometry,
|
||
metadata: applyGeneratedMediaResultMetadata(node, videoMetadata(video), { prompt, ...completedTaskMetadata(task) }, task.model),
|
||
};
|
||
}
|
||
|
||
if (mode === "audio") {
|
||
if (!result.audio?.dataUrl) throw new Error("后端任务没有返回音频");
|
||
const audio = result.audio.storageKey
|
||
? { url: await resolveMediaUrl(result.audio.storageKey, result.audio.dataUrl), storageKey: result.audio.storageKey, durationMs: result.audio.durationMs, bytes: result.audio.bytes || 0, mimeType: result.audio.mimeType || "audio/mpeg" }
|
||
: await storeGeneratedAudio(await (await fetch(result.audio.dataUrl)).blob(), result.audio.format || "mp3");
|
||
return { ...node, type: CanvasNodeType.Audio, metadata: applyGeneratedMediaResultMetadata(node, audioMetadata(audio), { prompt, ...completedTaskMetadata(task) }, task.model) };
|
||
}
|
||
|
||
if (!result.text) throw new Error("后端任务没有返回文本");
|
||
return {
|
||
...node,
|
||
type: CanvasNodeType.Text,
|
||
metadata: {
|
||
...node.metadata,
|
||
content: result.text,
|
||
richText: undefined,
|
||
prompt,
|
||
...completedTaskMetadata(task),
|
||
status: "success",
|
||
errorDetails: undefined,
|
||
generationErrorCode: undefined,
|
||
resourceReloadAvailable: undefined,
|
||
failedPromptFingerprint: undefined,
|
||
},
|
||
};
|
||
}
|
||
|
||
type GeneratedVideoResult = {
|
||
dataUrl: string;
|
||
storageKey?: string;
|
||
width?: number;
|
||
height?: number;
|
||
durationMs?: number;
|
||
bytes?: number;
|
||
mimeType?: string;
|
||
};
|
||
|
||
/**
|
||
* 生成任务的远程视频只有在浏览器已拿到可复用的 Blob 后才进入成功态。
|
||
* 节点仍保存稳定的资源文件地址，Blob 只作为本地缓存和后续字节处理的加速层。
|
||
*/
|
||
async function cacheGeneratedRemoteVideo(result: GeneratedVideoResult & { storageKey: string }): Promise<UploadedFile> {
|
||
const blob = await getCachedResourceBlob(result.storageKey);
|
||
if (!blob) throw new Error("生成视频资源缓存失败，未标记为成功");
|
||
const url = await resolveVideoMediaUrl(result.storageKey, result.dataUrl || "");
|
||
if (!url) throw new Error("生成视频资源地址为空，未标记为成功");
|
||
return {
|
||
url,
|
||
storageKey: result.storageKey,
|
||
width: result.width,
|
||
height: result.height,
|
||
durationMs: result.durationMs,
|
||
bytes: result.bytes || blob.size,
|
||
mimeType: result.mimeType || blob.type || "video/mp4",
|
||
};
|
||
}
|
||
|
||
export async function applyGenerationTaskResultToNodes(nodes: CanvasNodeData[], task: GenerationTask, targetNodeId?: string) {
|
||
const node = findGenerationTaskNode(nodes, task, targetNodeId);
|
||
if (!node) return { nodes, updated: false, nodeId: "", node: null };
|
||
const { node: updatedNode, additionalNodes } = await buildGenerationTaskNodeResults(node, task, nodes);
|
||
return {
|
||
nodes: commitCanvasGenerationResult(nodes, node, updatedNode, task.id, additionalNodes),
|
||
updated: true,
|
||
nodeId: node.id,
|
||
node: updatedNode,
|
||
additionalNodes,
|
||
};
|
||
}
|
||
|
||
export async function applyMaterializedGenerationTaskResultToNodes(nodes: CanvasNodeData[], task: GenerationTask, output: GenerationTaskOutput, effectKey: string, targetNodeId?: string) {
|
||
const node = findGenerationTaskNode(nodes, task, targetNodeId);
|
||
if (!node) return { nodes, updated: false, nodeId: "", node: null };
|
||
if (generationEffectApplied(node.metadata || {}, effectKey) && generationTaskOutputsApplied(node, task)) {
|
||
return { nodes, updated: true, nodeId: node.id, node, additionalNodes: [] };
|
||
}
|
||
const asset = useAssetStore.getState().assets.find((candidate) => candidate.id === output.materializedAssetId);
|
||
if (!asset) throw new Error("生成任务输出素材不存在");
|
||
const result = parseBackendGenerationResult(task);
|
||
if (asset.kind === "image") {
|
||
const images = [...(result.images || [])];
|
||
// materialize 已保存整个任务；画布按真实输出序号接收每张图及其素材绑定。
|
||
for (const item of task.outputs?.length ? task.outputs : [output]) {
|
||
const imageAsset = useAssetStore.getState().assets.find((candidate) => candidate.id === item.materializedAssetId);
|
||
if (!imageAsset || imageAsset.kind !== "image") throw new Error("生成任务图片输出素材不存在");
|
||
images[item.outputIndex] = {
|
||
dataUrl: imageAsset.data.dataUrl || imageAsset.coverUrl,
|
||
storageKey: imageAsset.data.storageKey,
|
||
width: imageAsset.data.width,
|
||
height: imageAsset.data.height,
|
||
bytes: imageAsset.data.bytes,
|
||
mimeType: imageAsset.data.mimeType,
|
||
};
|
||
}
|
||
result.images = images;
|
||
} else if (asset.kind === "video") {
|
||
result.video = { dataUrl: asset.data.url, ...asset.data };
|
||
} else if (asset.kind === "audio") {
|
||
result.audio = { dataUrl: asset.data.url, ...asset.data };
|
||
} else {
|
||
throw new Error("生成任务输出素材类型不支持画布节点");
|
||
}
|
||
const { node: updatedNode, additionalNodes } = await buildGenerationTaskNodeResults(node, { ...task, resultJson: JSON.stringify(result) }, nodes);
|
||
const stamp = (item: CanvasNodeData) => ({ ...item, metadata: applyGenerationConsumerEffect(item.metadata || {}, effectKey, (metadata) => metadata).value });
|
||
const durableNode = stamp({
|
||
...updatedNode,
|
||
metadata: {
|
||
...updatedNode.metadata,
|
||
assetId: updatedNode.metadata?.assetId || (updatedNode.metadata?.imageLayerGroup || (updatedNode.metadata?.layerExtraction && updatedNode.metadata.storageKey !== asset.data.storageKey) ? undefined : asset.id),
|
||
},
|
||
});
|
||
const durableChildren = additionalNodes.map(stamp);
|
||
return {
|
||
nodes: commitCanvasGenerationResult(nodes, node, durableNode, task.id, durableChildren),
|
||
updated: true,
|
||
nodeId: node.id,
|
||
node: durableNode,
|
||
additionalNodes: durableChildren,
|
||
};
|
||
}
|
||
|
||
export function generationTaskOutputsApplied(node: CanvasNodeData, task: GenerationTask) {
|
||
if (node.metadata?.layerExtraction?.extractionTaskId === task.id && node.metadata.content) return true;
|
||
if (node.metadata?.taskId !== task.id || node.metadata.status !== "success" || !node.metadata.content) return false;
|
||
if (generationTaskMode(task) !== "image") return true;
|
||
const count = parseBackendGenerationResult(task).images?.length || 1;
|
||
return node.metadata.generationOutputCount === count || (count > 1 && (node.metadata.batchChildIds?.length || 0) >= count);
|
||
}
|
||
|
||
export function shouldRecoverCanvasImageOutputs(node: CanvasNodeData) {
|
||
return (
|
||
node.type === CanvasNodeType.Image &&
|
||
node.metadata?.status === "success" &&
|
||
Boolean(node.metadata.taskId) &&
|
||
node.metadata.generationOutputCount === undefined &&
|
||
!node.metadata.isBatchRoot &&
|
||
!node.metadata.batchRootId &&
|
||
/(?:midjourney|(?:^|::)mj-)/i.test(node.metadata.producedModel || node.metadata.model || "")
|
||
);
|
||
}
|
||
|
||
async function buildGenerationTaskNodeResults(node: CanvasNodeData, task: GenerationTask, nodes: CanvasNodeData[]) {
|
||
if (generationTaskInput(task)?.metadata?.layerDecomposition) return buildImageLayerTaskResult(node, task, nodes);
|
||
const resultNode = await buildGenerationTaskNodeResult(node, task, nodes);
|
||
const images = generationTaskMode(task) === "image" ? parseBackendGenerationResult(task).images || [] : [];
|
||
if (images.length <= 1) return { node: resultNode, additionalNodes: [] as CanvasNodeData[] };
|
||
const children: CanvasNodeData[] = [];
|
||
for (let index = 0; index < images.length; index += 1) {
|
||
const id = `${node.id}:task:${task.id}:image:${index}`;
|
||
const existing = nodes.find((item) => item.id === id);
|
||
const child = await buildGenerationTaskNodeResult(
|
||
existing
|
||
? { ...node, ...existing, id, title: existing.title, position: existing.position, width: existing.width, height: existing.height }
|
||
: { ...node, id, title: `${node.title} · ${index + 1}`, parentId: undefined },
|
||
task,
|
||
nodes,
|
||
index,
|
||
);
|
||
children.push({
|
||
...child,
|
||
...(existing ? { title: existing.title, position: existing.position, width: existing.metadata?.manualSize ? existing.width : child.width, height: existing.metadata?.manualSize ? existing.height : child.height } : { position: imageGenerationChildPosition(resultNode.position, resultNode.width, child, index) }),
|
||
metadata: {
|
||
...child.metadata,
|
||
assetId: task.outputs?.find((output) => output.outputIndex === index)?.materializedAssetId,
|
||
isBatchRoot: undefined,
|
||
batchChildIds: undefined,
|
||
primaryImageId: undefined,
|
||
imageBatchExpanded: undefined,
|
||
batchRootId: node.id,
|
||
versionOfNodeId: undefined,
|
||
versionLabel: undefined,
|
||
versionPrimary: undefined,
|
||
agentGenerationContinuation: undefined,
|
||
},
|
||
});
|
||
}
|
||
const primary = children.find((child) => child.id === node.metadata?.primaryImageId) || children[0];
|
||
return {
|
||
node: {
|
||
...resultNode,
|
||
metadata: {
|
||
...resultNode.metadata,
|
||
...imageMetadata({
|
||
url: primary.metadata!.content!,
|
||
storageKey: primary.metadata!.storageKey!,
|
||
width: primary.metadata!.naturalWidth!,
|
||
height: primary.metadata!.naturalHeight!,
|
||
bytes: primary.metadata!.bytes || 0,
|
||
mimeType: primary.metadata!.mimeType || "image/png",
|
||
}),
|
||
assetId: primary.metadata?.assetId,
|
||
isBatchRoot: true,
|
||
batchChildIds: children.map((child) => child.id),
|
||
primaryImageId: primary.id,
|
||
imageBatchExpanded: node.metadata?.imageBatchExpanded ?? false,
|
||
generationOutputCount: images.length,
|
||
},
|
||
},
|
||
additionalNodes: children,
|
||
};
|
||
}
|
||
|
||
export async function buildImageLayerTaskResult(node: CanvasNodeData, task: GenerationTask, nodes: CanvasNodeData[]) {
|
||
const images = parseBackendGenerationResult(task).images || [];
|
||
if (node.metadata?.taskId === task.id && node.metadata.content && node.metadata.imageLayerGroup && node.metadata.generationOutputCount === images.length)
|
||
return {
|
||
node: node.metadata.status === "success" ? node : { ...node, metadata: { ...node.metadata, ...completedTaskMetadata(task), status: "success" as const } },
|
||
additionalNodes: [] as CanvasNodeData[],
|
||
};
|
||
const layerImages = [];
|
||
for (const image of images) layerImages.push((await normalizeImageLayerCanvas(image, node.metadata?.layerDecomposition?.canvas)).image);
|
||
const decoded = await decodeAndComposeImageLayers(layerImages);
|
||
const size = fitNodeSize(decoded.width, decoded.height, node.width, node.height);
|
||
const firstPosition = imageGenerationChildPosition(node.position, size.width, size, 0);
|
||
const lastPosition = imageGenerationChildPosition(node.position, size.width, size, images.length - 1);
|
||
const secondPosition = imageGenerationChildPosition(node.position, size.width, size, 1);
|
||
const layoutPosition = findAvailableGenerationGroupPosition(nodes, firstPosition, {
|
||
width: secondPosition.x - firstPosition.x + size.width,
|
||
height: lastPosition.y - firstPosition.y + size.height,
|
||
});
|
||
const children: CanvasNodeData[] = [];
|
||
for (let index = 0; index < images.length; index += 1) {
|
||
const id = `${node.id}:task:${task.id}:layer:${index}`;
|
||
const image = images[index];
|
||
const stored: UploadedImage = image.storageKey
|
||
? {
|
||
url: await resolveImageUrl(image.storageKey, image.dataUrl),
|
||
storageKey: image.storageKey,
|
||
width: decoded.width,
|
||
height: decoded.height,
|
||
bytes: image.bytes || decoded.layers[index].blob.size,
|
||
mimeType: decoded.layers[index].blob.type || "image/png",
|
||
}
|
||
: await uploadImage(decoded.layers[index].blob);
|
||
if (stored.pendingRemoteUpload) throw new Error("图层仅缓存在本机，服务端保存未完成；请重试保存结果");
|
||
const existing = nodes.find((item) => item.id === id);
|
||
const metadata = commitProducedModel(
|
||
{
|
||
...(existing?.metadata || {}),
|
||
...imageMetadata(stored),
|
||
assetId: task.outputs?.find((output) => output.outputIndex === index)?.materializedAssetId,
|
||
batchRootId: node.id,
|
||
imageLayer: { groupId: node.id, outputIndex: index, kind: decoded.layers[index].transparent ? "transparent" : "base" },
|
||
model: node.metadata?.model || task.model,
|
||
producedModel: task.model,
|
||
},
|
||
task.model,
|
||
);
|
||
if (existing) {
|
||
children.push({
|
||
...existing,
|
||
type: CanvasNodeType.Image,
|
||
width: existing.metadata?.manualSize ? existing.width : size.width,
|
||
height: existing.metadata?.manualSize ? existing.height : size.height,
|
||
position: existing.position,
|
||
metadata,
|
||
});
|
||
continue;
|
||
}
|
||
children.push({
|
||
id,
|
||
type: CanvasNodeType.Image,
|
||
title: decoded.layers[index].transparent ? `图层 ${index + 1}` : "底图",
|
||
...size,
|
||
position: (() => {
|
||
const position = imageGenerationChildPosition(node.position, size.width, size, index);
|
||
return { x: position.x + layoutPosition.x - firstPosition.x, y: position.y + layoutPosition.y - firstPosition.y };
|
||
})(),
|
||
metadata,
|
||
});
|
||
}
|
||
const composite = await uploadImage(decoded.composite);
|
||
if (composite.pendingRemoteUpload) throw new Error("合成图仅缓存在本机，服务端保存未完成；请重试保存结果");
|
||
const group: NonNullable<CanvasNodeMetadata["imageLayerGroup"]> = {
|
||
width: decoded.width,
|
||
height: decoded.height,
|
||
compositeStatus: "ready",
|
||
layers: decoded.order.map((index) => ({ nodeId: children[index].id, x: 0, y: 0, visible: true })),
|
||
};
|
||
group.compositeSignature = imageLayerCompositeSignature(group, children);
|
||
return {
|
||
node: {
|
||
...node,
|
||
...size,
|
||
metadata: applyGeneratedMediaResultMetadata(
|
||
node,
|
||
imageMetadata(composite),
|
||
{
|
||
...completedTaskMetadata(task),
|
||
imageLayerGroup: group,
|
||
isBatchRoot: true,
|
||
batchChildIds: group.layers.map((layer) => layer.nodeId),
|
||
primaryImageId: undefined,
|
||
imageBatchExpanded: node.metadata?.imageBatchExpanded ?? false,
|
||
generationOutputCount: images.length,
|
||
},
|
||
task.model,
|
||
),
|
||
},
|
||
additionalNodes: children,
|
||
};
|
||
}
|
||
|
||
/** 仅合成已验收的层，保留失败项身份；重试新增结果不会覆盖已有排序与可见性。 */
|
||
export async function buildExperimentalImageLayerResult(root: CanvasNodeData, nodes: CanvasNodeData[]) {
|
||
const plan = root.metadata?.experimentalLayerPlan;
|
||
if (!plan || !plan.requests.length || plan.requests.length > 8) throw new Error("实验拆层计划无效");
|
||
const candidates = plan.requests.flatMap((request, index) => {
|
||
const node = nodes.find((node) => node.id === request.nodeId);
|
||
return node?.metadata?.content && node.metadata.status === "success" && (!node.metadata.layerExtraction?.phase || node.metadata.layerExtraction.phase === "complete") ? [{ node, index: node.metadata.layerExtraction?.index ?? index }] : [];
|
||
});
|
||
const ready: typeof candidates = [];
|
||
const rejected: CanvasNodeData[] = [];
|
||
for (const item of candidates) {
|
||
try {
|
||
validateImageLayerOutput(await inspectImageLayer({ dataUrl: item.node.metadata!.content!, storageKey: item.node.metadata?.storageKey }));
|
||
ready.push(item);
|
||
} catch (error) {
|
||
rejected.push({
|
||
...item.node,
|
||
metadata: {
|
||
...item.node.metadata,
|
||
status: "error",
|
||
errorDetails: error instanceof Error ? error.message : "图层资源验收失败",
|
||
...(item.node.metadata?.layerExtraction ? { layerExtraction: { ...item.node.metadata.layerExtraction, rejectedTaskId: item.node.metadata.taskId } } : {}),
|
||
},
|
||
});
|
||
}
|
||
}
|
||
if (!ready.length) throw new Error("没有已验收的图层可生成合成图");
|
||
const previous = root.metadata?.imageLayerGroup;
|
||
const order = previous?.layers.flatMap((layer) => ready.filter((item) => item.node.id === layer.nodeId)) || [];
|
||
for (const item of ready) {
|
||
if (order.some((existing) => existing.node.id === item.node.id)) continue;
|
||
const before = order.findIndex((existing) => existing.index > item.index);
|
||
order.splice(before < 0 ? order.length : before, 0, item);
|
||
}
|
||
const sources = order.map((item) => item.node);
|
||
const decoded = await decodeAndComposeImageLayers(
|
||
sources.map((node) => ({ dataUrl: node.metadata!.content!, storageKey: node.metadata?.storageKey })),
|
||
order.map((item) => item.index),
|
||
);
|
||
const updatedChildren = sources.map((node, index) => ({
|
||
...node,
|
||
title: node.metadata?.imageLayer ? node.title : imageLayerTargetName(plan.requests.find((request) => request.nodeId === node.id)!.target),
|
||
metadata: { ...node.metadata, batchRootId: root.id, imageLayer: { groupId: root.id, outputIndex: order[index].index, kind: order[index].index === 0 ? ("base" as const) : ("transparent" as const) } },
|
||
}));
|
||
const completed = sources.length;
|
||
const group: NonNullable<CanvasNodeMetadata["imageLayerGroup"]> = {
|
||
width: decoded.width,
|
||
height: decoded.height,
|
||
compositeStatus: "ready",
|
||
layers: decoded.order.map(
|
||
(index) =>
|
||
previous?.layers.find((layer) => layer.nodeId === sources[index].id) || {
|
||
nodeId: sources[index].id,
|
||
x: 0,
|
||
y: 0,
|
||
visible: !order.some((item) => item.index === 0) || order[index].index === 0 || plan.requests.find((request) => request.nodeId === sources[index].id)?.removeFromBackground !== false,
|
||
},
|
||
),
|
||
...(completed < plan.requests.length ? { incomplete: { completed, total: plan.requests.length, failed: plan.requests.length - completed, missingBackground: !order.some((item) => item.index === 0) } } : {}),
|
||
};
|
||
const composite = await uploadImage(previous || group.layers.some((layer) => !layer.visible) ? await composeCanvasImageLayerGroup(group, updatedChildren) : decoded.composite);
|
||
if (composite.pendingRemoteUpload) throw new Error("合成图尚未保存到服务端，请重试本地合成");
|
||
group.compositeSignature = imageLayerCompositeSignature(group, updatedChildren);
|
||
return {
|
||
node: {
|
||
...root,
|
||
...fitNodeSize(decoded.width, decoded.height, root.width, root.height),
|
||
metadata: applyGeneratedMediaResultMetadata(root, imageMetadata(composite), {
|
||
imageLayerGroup: group,
|
||
isBatchRoot: true,
|
||
batchChildIds: plan.requests.map((request) => request.nodeId),
|
||
imageBatchExpanded: root.metadata?.imageBatchExpanded ?? false,
|
||
primaryImageId: undefined,
|
||
experimentalLayerPlan: {
|
||
...plan,
|
||
composedSignature: experimentalLayerSignature(
|
||
root,
|
||
nodes.map((node) => rejected.find((item) => item.id === node.id) || node),
|
||
),
|
||
errorSignature: undefined,
|
||
},
|
||
status: "success",
|
||
errorDetails: undefined,
|
||
batchFailedCount: plan.requests.length - completed,
|
||
generationOutputCount: sources.length,
|
||
}),
|
||
},
|
||
additionalNodes: [...updatedChildren, ...rejected],
|
||
};
|
||
}
|
||
|
||
export async function syncGenerationTaskToCanvasStore(task: GenerationTask) {
|
||
if (task.status !== "succeeded" || !task.projectId) return false;
|
||
// 短剧任务使用业务项目 ID，不能拿它请求同名的画布项目。
|
||
const domainProjectId = task.clientContext?.domainProjectId || generationTaskInput(task)?.metadata?.domainProjectId;
|
||
if (domainProjectId === task.projectId || !generationTaskNodeId(task)) return false;
|
||
const { loadCanvasProjectForEditing } = await import("@/services/user-data-sync");
|
||
const project = await loadCanvasProjectForEditing(task.projectId);
|
||
if (!project) return false;
|
||
const node = findGenerationTaskNode(project.nodes, task);
|
||
if (!node) return false;
|
||
if (generationTaskOutputsApplied(node, task)) return false;
|
||
const { node: updatedNode, additionalNodes } = await buildGenerationTaskNodeResults(node, task, project.nodes);
|
||
const latest = useCanvasStore.getState().projects.find((item) => item.id === project.id);
|
||
if (!latest?.nodes.some((item) => item.id === node.id)) return false;
|
||
useCanvasStore.getState().updateProject(project.id, { nodes: commitCanvasGenerationResult(latest.nodes, node, updatedNode, task.id, additionalNodes) });
|
||
return true;
|
||
}
|
||
|
||
function findGenerationTaskNode(nodes: CanvasNodeData[], task: GenerationTask, targetNodeId?: string) {
|
||
const nodeId = targetNodeId || generationTaskNodeId(task);
|
||
return nodeId ? nodes.find((node) => node.id === nodeId) : nodes.find((node) => node.metadata?.taskId === task.id);
|
||
}
|
||
|
||
function completedTaskMetadata(task: GenerationTask): CanvasNodeMetadata {
|
||
return {
|
||
taskId: task.id,
|
||
taskStatus: task.status,
|
||
taskProgress: typeof task.progress === "number" && Number.isFinite(task.progress) ? Math.max(0, Math.min(100, Math.round(task.progress))) : 100,
|
||
taskStage: task.stage,
|
||
taskMediaStage: task.mediaStage,
|
||
taskCanRecoverMedia: task.canRecoverMedia,
|
||
taskStartedAt: task.startedAt,
|
||
taskCompletedAt: task.completedAt,
|
||
taskDurationMs: task.startedAt && task.completedAt ? Math.max(0, Date.parse(task.completedAt) - Date.parse(task.startedAt)) : undefined,
|
||
taskCreatedAt: task.createdAt || task.created_at,
|
||
taskUpdatedAt: task.updatedAt || task.updated_at,
|
||
errorDetails: undefined,
|
||
generationErrorCode: undefined,
|
||
failedPromptFingerprint: undefined,
|
||
};
|
||
}
|