TowstyandCursor
608f7d8d47
abenzerps Q8_0 ships 1D RMSNorms as packed Q8 (136 vs 128), which breaks Comfy rms_rope; tagger now dequantizes small tensors and the graph uses TextEncodeQwenImage21's 64-ch latent plus AuraFlow shift. Co-authored-by: Cursor <cursoragent@cursor.com>
364 lines
21 KiB
TypeScript
364 lines
21 KiB
TypeScript
import { kleinIdentityPlan, applyKleinIdentity } from '~/shared/studio2/klein-identity.mjs';
|
|
import { stylePrompt } from '~/shared/studio2/styles.mjs';
|
|
import { purge } from './cleanup';
|
|
import { watchProgress } from './progress';
|
|
import { fitStill, needsFit } from './media';
|
|
import { resolveRequestSize } from './size';
|
|
import { queueSeeds } from '~/shared/studio2/seed.mjs';
|
|
import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import template from '../../assets/studio2_minimax_native.json';
|
|
import qwen21Template from '../../assets/studio2_qwen21_t2i.json';
|
|
import { nativeVideoGraph, attachHeroReference, applyResolvedImageSize } from '~/shared/studio2/graphs.mjs';
|
|
import { compilePrompt, scopedFile } from '~/shared/studio2/contracts.mjs';
|
|
import { resolveQwen21Size } from '~/shared/studio2/input.mjs';
|
|
import { createJob, restoreJob, getJob, emitJob, type Job } from '../jobs';
|
|
import { markStudioLive, onLiveVideoSettled, type StudioJob } from '../studioQueue';
|
|
import { readRecord, saveRecord, studio2Root, records } from './store';
|
|
import { ensureComfyReady } from '../comfyLifecycle';
|
|
import { comfyFetch, queuePrompt, fetchHistory, extractVideo } from '../comfy';
|
|
import { extractEditedImage } from '../imageComfy';
|
|
import { buildImageV2Workflow, resolveKreaGenerateAssets } from '../imageWorkflowV2';
|
|
import { resolveGraphLoraNames, applyUserLoraToGraph, ensureComfyLoraNames } from '../loras';
|
|
import { getClip, getStill, stillPath, clipVideoPath, saveStill, saveClip, downloadComfyImage, downloadComfyVideo, attachStudio2Metadata } from '../library';
|
|
import { imageDimensions } from '../resolution';
|
|
import { stitchExtension, probeDuration } from '../ffmpeg';
|
|
import { videoSourcePaths } from '../videoSources';
|
|
import { resolveExtensionHandoffFrame, persistClipAnchorFrame } from '../extensionFrame';
|
|
import { acquireSharedGpu, sharedGpuHeaders } from '../sharedGpu';
|
|
type DiskFile = {
|
|
filename: string;
|
|
subfolder: string;
|
|
type: string;
|
|
};
|
|
function update(r: any, state: string) { r.state = state; r.updatedAt = Date.now(); if (['complete','failed','cancelled'].includes(state)) r.finishedAt ??= r.updatedAt; saveRecord(r); }
|
|
// Labels whose pixels must never be resampled: the hero identity still, and the
|
|
// extend/video start frame (which is either the exact anchor PNG or an already-canvas-sized
|
|
// extracted last frame). Fitting these every hop is what destroys identity across chained extends.
|
|
const NEVER_FIT = new Set(['hero', 'start']);
|
|
async function upload(r: any, name: string, data: Buffer): Promise<string> {
|
|
const prefix = String(useRuntimeConfig().comfyFilenamePrefix).replace(/\/$/, '') + `/studio2/${r.id}/${r.index}`;
|
|
let fitted = false;
|
|
if (!NEVER_FIT.has(name) && needsFit(data, r.request.settings.width, r.request.settings.height)) {
|
|
data = await fitStill(data, r.request.settings.width, r.request.settings.height);
|
|
fitted = true;
|
|
}
|
|
if (name === 'start') { r.handoffFitted = fitted; saveRecord(r); }
|
|
const body = new FormData();
|
|
body.append('image', new Blob([new Uint8Array(data)]), name + '.png');
|
|
body.append('subfolder', prefix);
|
|
body.append('type', 'input');
|
|
body.append('overwrite', 'true');
|
|
const response = await comfyFetch('/upload/image', { method: 'POST', body });
|
|
if (!response.ok)
|
|
throw new Error('Reference image upload failed');
|
|
const file = await response.json() as any;
|
|
const disk = { filename: file.name, subfolder: file.subfolder || '', type: 'input' };
|
|
if (!scopedFile(disk, String(useRuntimeConfig().comfyFilenamePrefix)))
|
|
throw new Error('Comfy returned an input outside this instance prefix');
|
|
r.files.push(disk);
|
|
saveRecord(r);
|
|
return `${disk.subfolder}/${disk.filename}`;
|
|
}
|
|
async function prepareGraph(r: any) {
|
|
const q = r.request, s = q.settings, prefix = String(useRuntimeConfig().comfyFilenamePrefix).replace(/\/$/, '') + `/studio2/${r.id}/${r.index}`;
|
|
const load = async (id: string, label: string) => id ? upload(r, label, readFileSync(stillPath(r.owner, getStill(r.owner, id).id))) : '';
|
|
const video=['video','extend'].includes(q.mode);
|
|
const identityPlan=kleinIdentityPlan(q);
|
|
const sourceId=identityPlan ? identityPlan.sourceId : q.imageAId;
|
|
await resolveRequestSize(r.owner,identityPlan ? {...q,imageAId:sourceId} : q);
|
|
saveRecord(r);
|
|
const a=await load(sourceId,'source'),b=await load(q.imageBId,'compose'),mask=await load(q.maskId,'mask');
|
|
const attachHero=(video || q.engine==='flux') && (q.lockFace!==false || q.lockOutfit!==false) && !(!video && sourceId && sourceId===q.identityStillId);
|
|
const hero=attachHero ? await load(q.identityStillId,'hero') : '';
|
|
r.sourceStillId=sourceId || null;
|
|
r.heroReferenceAttached=!!hero || (!video && q.engine==='flux' && !!sourceId && sourceId===q.identityStillId);
|
|
|
|
let graph: any;
|
|
if (['video', 'extend'].includes(q.mode)) {
|
|
let start = a;
|
|
if (q.startClipId) {
|
|
const dir = join(studio2Root(), r.id);
|
|
mkdirSync(dir, { recursive: true });
|
|
const dest = join(dir, 'handoff.png');
|
|
const handoff = await resolveExtensionHandoffFrame({ ownerKey: r.owner, sourceClipId: q.startClipId, sourceVideoPath: clipVideoPath(r.owner, q.startClipId), destPath: dest });
|
|
r.handoffSource = handoff.source;
|
|
start = await upload(r, 'start', readFileSync(dest));
|
|
unlinkSync(dest);
|
|
}
|
|
if (q.engine === 'ltx') {
|
|
const { buildWorkflow } = await import('../workflow');
|
|
const { frameLength } = await import('../videoChain');
|
|
const { ltxWorkflowEnabled, LTX_DISABLED_MESSAGE } = await import('~/utils/videoModels');
|
|
if (!ltxWorkflowEnabled()) throw new Error(LTX_DISABLED_MESSAGE);
|
|
const textToVideo = q.mode === 'video' && !start;
|
|
if (!start && !textToVideo) throw new Error('Choose a start still for LTX video.');
|
|
const fps = s.fps || 24;
|
|
graph = buildWorkflow({
|
|
workflow: textToVideo ? 'ltx-t2v' : 'ltx',
|
|
imageName: start || '',
|
|
prompt: q.compiledPrompt,
|
|
width: s.width,
|
|
height: s.height,
|
|
length: frameLength(s.duration || 5, fps),
|
|
fps,
|
|
steps: s.steps,
|
|
cfg: s.cfg,
|
|
seed: s.seed,
|
|
samplerName: 'euler',
|
|
scheduler: 'simple',
|
|
turbo: false,
|
|
duration: s.duration || 5,
|
|
filenamePrefix: prefix + '/video',
|
|
loraStack: s.loraStack,
|
|
useIdentityRefs: false
|
|
});
|
|
await ensureComfyLoraNames('video');
|
|
r.graphId = textToVideo ? 'workflow_ltx_video.json#t2v' : 'workflow_ltx_video.json';
|
|
} else {
|
|
if (q.engine !== 'minimax')
|
|
throw new Error('Studio 2 video supports MiniMax H3 and LTX (xAIGen).');
|
|
const end = await load(q.endStillId, 'end'), guides = [];
|
|
for (const [i, g] of q.guides.entries())
|
|
guides.push({ image: await load(g.stillId, `guide${i}`), frame: g.frame });
|
|
graph = nativeVideoGraph(template, q, { hero, start, end, guides }, prefix);
|
|
await ensureComfyLoraNames('video');
|
|
resolveGraphLoraNames(graph, 'video');
|
|
applyUserLoraToGraph(graph, s.loraStack);
|
|
r.graphId = 'studio2_minimax_native.json';
|
|
}
|
|
}
|
|
else if (q.engine === 'qwen21') {
|
|
if (q.mode !== 'generate')
|
|
throw new Error('Qwen 2.1 is T2I in this build.');
|
|
const size = resolveQwen21Size(s.aspect);
|
|
s.width = size.width;
|
|
s.height = size.height;
|
|
graph = structuredClone(qwen21Template);
|
|
graph['9'].inputs.prompt = q.compiledPrompt;
|
|
graph['9'].inputs.negative_prompt = stylePrompt(q.imageStyles, true);
|
|
// TextEncodeQwenImage21 builds the 64-ch empty latent from resolution (square T2I).
|
|
graph['9'].inputs.resolution = Math.max(size.width, size.height);
|
|
graph['15'].inputs.seed = s.seed;
|
|
graph['15'].inputs.steps = s.steps || 25;
|
|
graph['15'].inputs.cfg = s.cfg ?? 1;
|
|
graph['15'].inputs.sampler_name = 'euler';
|
|
graph['15'].inputs.scheduler = 'simple';
|
|
graph['21'].inputs.filename_prefix = prefix + '/image';
|
|
r.sampleLatent = 'qwen21 textencode latent';
|
|
r.sampleDenoise = null;
|
|
r.heroReferenceAttached = false;
|
|
r.graphId = 'studio2_qwen21_t2i.json';
|
|
}
|
|
else {
|
|
const mode = identityPlan?.mode ?? (q.mode === 'iterate' ? (a ? 'edit' : 'generate') : q.mode);
|
|
const found = q.engine === 'krea' ? await resolveKreaGenerateAssets() : null;
|
|
const assets = found ? { kreaUnetName: found.unet, kreaClipName: found.clip, kreaVaeName: found.vae, kreaConceptLora: found.conceptLora } : {};
|
|
graph = buildImageV2Workflow({ ...s, ...assets, engine: q.engine, mode, task: 'scene', prompt: q.compiledPrompt, negative: stylePrompt(q.imageStyles, true), imageAName: a, imageBName: mode === 'compose' ? b : undefined, maskName: mode === 'refine' ? mask : undefined, filenamePrefix: prefix + '/image' }).graph;
|
|
applyResolvedImageSize(graph,s);
|
|
if (identityPlan) Object.assign(r,applyKleinIdentity(graph,identityPlan));
|
|
if (q.engine === 'flux')
|
|
attachHeroReference(graph, hero);
|
|
if (!identityPlan) {
|
|
r.sampleLatent=q.mode==='refine'?'masked source latent':'empty latent';
|
|
r.sampleDenoise=null;
|
|
}
|
|
if (q.engine !== 'flux' && hero && ['edit', 'compose', 'iterate'].includes(q.mode))
|
|
throw new Error('Krea native hero-reference binding is not supported by this graph. Select Klein explicitly; no fallback is performed.');
|
|
await ensureComfyLoraNames('image');
|
|
resolveGraphLoraNames(graph, 'image');
|
|
r.graphId = `${q.engine === 'flux' ? 'klein' : 'krea'}_v2_${mode}.json`;
|
|
}
|
|
saveRecord(r);
|
|
return graph;
|
|
}
|
|
async function run(r: any, job: Job) {
|
|
const stopProgress = watchProgress(r,job);
|
|
try {
|
|
const prompts = r.prompts || [r.request.promptSections, ...r.request.batch];
|
|
r.prompts = prompts;
|
|
r.request.shotSeeds ||= queueSeeds(r.request.settings,prompts.length);
|
|
saveRecord(r);
|
|
for (r.index = r.index || 0; r.index < prompts.length; r.index++) {
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
if (!r.promptId) {
|
|
while (!await acquireSharedGpu()) {
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
await new Promise(resolve => setTimeout(resolve, 2000));
|
|
}
|
|
r.request.settings.seed = r.request.shotSeeds[r.index];
|
|
r.files = [];
|
|
r.progress = null;
|
|
r.request.promptSections = prompts[r.index];
|
|
r.request.compiledPrompt = compilePrompt(prompts[r.index], ['video', 'extend'].includes(r.request.mode), r.request);
|
|
update(r, 'waking');
|
|
await ensureComfyReady(message => emitJob(job, { type: 'status', message }));
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
const graph = await prepareGraph(r);
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
update(r, 'submitting');
|
|
const queued = await queuePrompt(graph, job.clientId);
|
|
job.promptId = queued.prompt_id;
|
|
r.promptId = queued.prompt_id;
|
|
r.renderStartedAt = Date.now();
|
|
update(r, 'rendering');
|
|
}
|
|
let history: any, missingSince = 0;
|
|
for (;;) {
|
|
try {
|
|
history = await fetchHistory(r.promptId);
|
|
}
|
|
catch {
|
|
history = null;
|
|
}
|
|
const e = history?.[r.promptId];
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
if (['error', 'interrupted'].includes(e?.status?.status_str))
|
|
throw new Error('Comfy generation failed or was interrupted; inspect the host error log.');
|
|
if (!e) {
|
|
try {
|
|
const response = await comfyFetch('/queue', { signal: AbortSignal.timeout(5000) });
|
|
if (response.ok) {
|
|
const q = await response.json() as any;
|
|
const present = [...(q.queue_running || []), ...(q.queue_pending || [])].some((entry: any) => entry[1] === r.promptId);
|
|
if (present)
|
|
missingSince = 0;
|
|
else if (!missingSince)
|
|
missingSince = Date.now();
|
|
else if (Date.now() - missingSince > 60000)
|
|
throw new Error('PROMPT_MISSING');
|
|
}
|
|
}
|
|
catch (error: any) {
|
|
if (error.message === 'PROMPT_MISSING')
|
|
throw new Error('The saved Comfy prompt is no longer in history or the queue. It was not resubmitted.');
|
|
}
|
|
}
|
|
if (e?.status?.completed || e?.status?.status_str === 'success')
|
|
break;
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
await new Promise(resolve => setTimeout(resolve, 1500));
|
|
}
|
|
const messages = history[r.promptId]?.status?.messages || [];
|
|
const executionStart = messages.find((m: any) => m[0] === 'execution_start')?.[1]?.timestamp;
|
|
const executionEnd = messages.find((m: any) => m[0] === 'execution_success')?.[1]?.timestamp;
|
|
r.gpuSeconds = executionStart && executionEnd ? (executionEnd - executionStart) / 1000 : null;
|
|
update(r, 'saving');
|
|
job.saving = true;
|
|
const q = r.request, s = q.settings, video = ['video', 'extend'].includes(q.mode);
|
|
const file = video ? extractVideo(history, r.promptId) : extractEditedImage(history, r.promptId);
|
|
if (!file)
|
|
throw new Error('Comfy finished without a media output');
|
|
if (!r.files.some((f: DiskFile) => f.filename === file.filename && f.subfolder === file.subfolder))
|
|
r.files.push(file);
|
|
let asset: any = r.savedAssetId ? (video ? getClip(r.owner, r.savedAssetId) : getStill(r.owner, r.savedAssetId)) : null;
|
|
if (!asset && video) {
|
|
const data = await downloadComfyVideo(file);
|
|
if (!data.length || data.length < 64)
|
|
throw new Error('Comfy wrote an empty video file (<64 bytes); the job did not render. Nothing was saved.');
|
|
const sourceSegments = q.startClipId ? videoSourcePaths(clipVideoPath(r.owner, q.startClipId)) : [];
|
|
const tmp = join(studio2Root(), r.id);
|
|
mkdirSync(tmp, { recursive: true });
|
|
const assembled = q.startClipId ? await stitchExtension({ part1Path: clipVideoPath(r.owner, q.startClipId), part2: data, tmpDir: tmp, sourcePaths: sourceSegments }) : data;
|
|
if (!assembled.length || assembled.length < 64)
|
|
throw new Error('The assembled video file is empty (<64 bytes); the job did not render. Nothing was saved.');
|
|
const checkPath = join(tmp, 'duration-check.mp4');
|
|
writeFileSync(checkPath, assembled);
|
|
let duration = 0;
|
|
try { duration = await probeDuration(checkPath); }
|
|
finally { try { unlinkSync(checkPath); } catch { /* ignore */ } }
|
|
if (!Number.isFinite(duration) || duration <= 0)
|
|
throw new Error('The rendered video has no readable duration; the job did not render. Nothing was saved.');
|
|
asset = await saveClip({ ownerKey: r.owner, folderId: q.folderId, prompt: q.compiledPrompt, ...s, aspect: s.aspect || 'auto', hideThumbnail: false, video: assembled, originalSegment: data, sourceSegments, fps: s.fps || 24, sound: true, familyId: r.familyId, parentClipId: q.startClipId || undefined, chainIndex: r.index, comfyFilename: file.filename });
|
|
}
|
|
else if (!asset) {
|
|
const data = await downloadComfyImage(file), size = imageDimensions(data) || { width: s.width, height: s.height };
|
|
asset = await saveStill({ ownerKey: r.owner, folderId: q.folderId, filename: file.filename, data, ...size, role: 'output', prompt: q.compiledPrompt, familyId: r.familyId, chainIndex: r.index, settings: s });
|
|
}
|
|
if (!asset)
|
|
throw new Error('Library did not save the output');
|
|
r.savedAssetId = asset.id;
|
|
saveRecord(r);
|
|
r.savedAt = Date.now();
|
|
r.wallTime = (r.savedAt - r.startedAt) / 1000;
|
|
const metadata = { ...structuredClone(q), id: r.id, sourceStillId:r.sourceStillId,heroReferenceAttached:r.heroReferenceAttached,sampleLatent:r.sampleLatent,sampleDenoise:r.sampleDenoise,kind: video ? 'video' : 'image', graphId: r.graphId, promptId: r.promptId, queuedAt: r.queuedAt, startedAt: r.startedAt, savedAt: r.savedAt, gpuSeconds: r.gpuSeconds, wallTime: r.wallTime, outputWidth: asset.width || s.width, outputHeight: asset.height || s.height, purgeResult: 'Left on host', handoffSource: r.handoffSource || null, fitted: video && q.startClipId ? !!r.handoffFitted : null };
|
|
await attachStudio2Metadata(r.owner, asset.id, metadata);
|
|
if (!r.outputs.some((o:any)=>o.id===asset.id)) r.outputs.push({id:asset.id,kind:video?'clip':'still',studio2:metadata});
|
|
saveRecord(r);
|
|
const anchor = video && history[r.promptId].outputs?.anchor_save?.images?.[0];
|
|
if (anchor) {
|
|
if (!r.files.some((f: DiskFile)=>f.filename===anchor.filename && f.subfolder===anchor.subfolder)) r.files.push(anchor);
|
|
await persistClipAnchorFrame({ownerKey:r.owner,clipId:asset.id,fromBuffer:await downloadComfyImage(anchor)});
|
|
}
|
|
await purge(r);
|
|
metadata.purgeResult = r.purgeResult;
|
|
await attachStudio2Metadata(r.owner, asset.id, metadata);
|
|
saveRecord(r);
|
|
job.saving = false;
|
|
if (video) {
|
|
q.startClipId = asset.id;
|
|
q.startFrameSource = { kind: 'previous-last-frame', clipId: asset.id };
|
|
}
|
|
else if (q.mode === 'iterate')
|
|
q.imageAId = asset.id;
|
|
r.promptId = '';
|
|
r.savedAssetId = '';
|
|
r.index++;
|
|
saveRecord(r);
|
|
r.index--;
|
|
// Identity remains the original hero throughout the batch.
|
|
}
|
|
if (job.status === 'cancelled')
|
|
throw new Error('Cancelled');
|
|
job.status = 'complete';
|
|
update(r, 'complete');
|
|
emitJob(job, { type: 'complete', message: 'Studio 2 output saved' });
|
|
}
|
|
catch (e: any) {
|
|
job.status = job.status === 'cancelled' ? 'cancelled' : 'error';
|
|
job.error = e.message;
|
|
r.error = e.message;
|
|
update(r, job.status === 'cancelled' ? 'cancelled' : 'failed');
|
|
emitJob(job, { type: 'error', message: e.message });
|
|
}
|
|
finally {
|
|
stopProgress();
|
|
job.saving = false;
|
|
await onLiveVideoSettled(job);
|
|
}
|
|
}
|
|
export async function startStudio2Job(item: StudioJob) {
|
|
const r = readRecord(item.ownerKey, item.payload.studio2Id!), job = createJob(['video', 'extend'].includes(r.request.mode) ? 'video' : 'edit');
|
|
job.studio2 = true;
|
|
job.library = { ownerKey: item.ownerKey, folderId: r.request.folderId, extensions: [], queueAutoRun: false } as any;
|
|
job.status = 'running';
|
|
r.startedAt = Date.now();
|
|
delete r.finishedAt;
|
|
r.liveId = job.id;
|
|
r.clientId = job.clientId;
|
|
saveRecord(r);
|
|
await markStudioLive(item.ownerKey, item.id, job.id);
|
|
void run(r, job);
|
|
}
|
|
export function resumeStudio2Jobs() {
|
|
for (const r of records()) {
|
|
if (!r.liveId || getJob(r.liveId) || ['waiting', 'complete', 'failed', 'cancelled'].includes(r.state))
|
|
continue;
|
|
if (r.state === 'submitting' && !r.promptId) {
|
|
r.state = 'failed';
|
|
r.error = 'Submission outcome unknown after restart. Inspect the host before retrying.';
|
|
saveRecord(r);
|
|
continue;
|
|
}
|
|
const job = restoreJob({ id: r.liveId, clientId: r.clientId, startedAt: r.startedAt, promptId: r.promptId || '', library: { ownerKey: r.owner, folderId: r.request.folderId, extensions: [], queueAutoRun: false } as any });
|
|
job.studio2 = true;
|
|
void run(r, job);
|
|
}
|
|
}
|