"""Integrated N-chunk Continuum runtime. V2 deliberately reuses the proven V1 continuation core. It changes execution orchestration only: all text/image conditioning is prepared first, H3 sampling runs for every chunk without intermediate VAE decoding, and decoding/assembly happens after the sampling phase. """ from __future__ import annotations import copy, logging from typing import Any import torch from ..compatibility import accelerator_summary, check_comfy_h3_runtime from ..constants import ( DIAGNOSTICS_FULL, DIAGNOSTICS_OFF, DIAGNOSTICS_OPTIONS, FPS, CONTINUUM_ACTUAL_PREFIX_STEPS, SEAM_CORRECTION_AUTO, SEAM_CORRECTION_OFF, SEAM_CORRECTION_OPTIONS, V2_CONTINUITY_AUTO, normalize_diagnostics_mode, ) from ..continuation import POLICY_REPLACE, prepare_conditioning from ..model_patch import clone_model_for_chunk from ..state import assert_context_unchanged, context_fingerprint, make_plan, select_context, validate_state from ..temporal import align_frame_count_up, largest_context_capacity, make_extension_shape from ..version import PACKAGE_VERSION from .decoder import decode_sequence, decode_sequence_with_seam, enforce_total_frames from .h3_builder import attach_keyframes, empty_h3_latent, encode_identity_latents, encode_prompt_conditioning, prepare_identity_assets from .motion import choose_context_frames from .prompts import prompt_plan_report, validate_prompt_plan from .sampling import sample_chunk from .seeds import derive_chunk_seed from .session import ( SessionValidationError, entry_to_state, make_chunk_entry, make_session, model_fingerprint, session_summary, validate_chunk_entry, validate_session, ) LOG=logging.getLogger("h3_continuum_join") class SequenceRuntimeError(RuntimeError): pass def _check_decode_memory_budget(*,width,height,chunks,chunk_seconds): target_frames=max(1,int(round(chunks*chunk_seconds*FPS))); max_chunk_frames=max(5,int(round(chunk_seconds*FPS))+39) image_bytes=target_frames*width*height*3*4; transient_bytes=max_chunk_frames*width*height*3*4 required_bytes=image_bytes+int(transient_bytes*1.5)+1*1024**3; estimate_gib=required_bytes/1024**3; available_gib=None try: import psutil available=int(psutil.virtual_memory().available); available_gib=available/1024**3 if required_bytes>int(available*0.75): raise SequenceRuntimeError(f"estimated decoded output requires about {estimate_gib:.1f} GiB including one-chunk headroom, but only {available_gib:.1f} GiB RAM is currently available. Reduce chunks, chunk_seconds, or resolution before sampling.") except ImportError: pass return estimate_gib,available_gib def _clone_entry_for_reuse(entry): entry=validate_chunk_entry(entry); result=dict(entry); result["plan"]=copy.deepcopy(entry["plan"]); result["reused"]=True; return result def _preserved_prefix(*,session,prompt_hashes,chunks,reroll_from_chunk,width,height,chunk_seconds,identity_hash): if session is None: return [],[] session=validate_session(session); notes=[] if int(session["width"])!=int(width) or int(session["height"])!=int(height): raise SessionValidationError(f"session is {session['width']}x{session['height']} but V2 is configured for {width}x{height}") if abs(float(session["chunk_seconds"])-float(chunk_seconds))>1e-6: raise SessionValidationError(f"session chunk_seconds={session['chunk_seconds']} does not match {chunk_seconds}") if str(session.get("identity_hash","none"))!=str(identity_hash): raise SessionValidationError("the current first-frame identity image does not match the saved session") if reroll_from_chunk<0 or reroll_from_chunk>chunks: raise SessionValidationError("reroll_from_chunk must be 0 or a valid one-based chunk index") limit=min(len(session["chunks"]),chunks) if reroll_from_chunk>0: limit=min(limit,reroll_from_chunk-1) preserved=[] for index in range(limit): entry=validate_chunk_entry(session["chunks"][index]) if entry["prompt_hash"]!=prompt_hashes[index]: notes.append(f"session reuse stopped before chunk {index+1}: prompt changed"); break preserved.append(_clone_entry_for_reuse(entry)) if reroll_from_chunk==0 and len(preserved)==min(len(session["chunks"]),chunks): notes.append(f"resuming after accepted chunk {len(session['chunks'])}" if len(session["chunks"])0: notes.append(f"preserved chunks 1-{len(preserved)}; regenerated from chunk {reroll_from_chunk}") return preserved,notes def _conditioning_cache(*,clip,prompts,assets,final_has_last_frame): cache={}; final_index=len(prompts)-1 for index,prompt in enumerate(prompts): include_last=bool(final_has_last_frame and index==final_index); key=(prompt,include_last) if key in cache: continue cache[key]=encode_prompt_conditioning(clip,prompt,first_image=assets.first_image,last_image=assets.last_image if include_last else None) return cache def run_sequence(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampler:Any,sigmas:torch.Tensor,first_frame:torch.Tensor|None,last_frame:torch.Tensor|None,prompt_plan:dict[str,Any],width:int,height:int,continuity:str,base_seed:int,audio_continuity:bool,exact_total_duration:bool,diagnostics_mode:str,reroll_from_chunk:int,reroll_nonce:int,strict_compatibility:bool,debug:bool,seam_correction:str=SEAM_CORRECTION_OFF,enable_preview:bool=True,session:dict[str,Any]|None=None,initial_state:dict[str,Any]|None=None,latent_only:bool=False): diagnostics_mode=normalize_diagnostics_mode(diagnostics_mode); plan=validate_prompt_plan(prompt_plan); chunks=int(plan["chunks"]); chunk_seconds=float(plan["chunk_seconds"]); prompts=list(plan["prompts"]); prompt_hashes=list(plan["hashes"]); width,height=int(width),int(height) if width<=0 or height<=0 or width%32 or height%32: raise SequenceRuntimeError("width and height must be positive multiples of 32") if session is not None and initial_state is not None: raise SequenceRuntimeError("connect either a session or an initial_state, not both") if diagnostics_mode not in DIAGNOSTICS_OPTIONS: raise SequenceRuntimeError(f"unknown diagnostics mode: {diagnostics_mode!r}") if seam_correction not in SEAM_CORRECTION_OPTIONS: raise SequenceRuntimeError(f"unknown seam correction mode: {seam_correction!r}") if not 0<=int(reroll_from_chunk)<=chunks: raise SequenceRuntimeError("reroll_from_chunk must be 0 or a valid one-based chunk index") if initial_state is not None and int(reroll_from_chunk) not in (0,1): raise SequenceRuntimeError("with initial_state, reroll_from_chunk can only be 0 or 1") decode_estimate_gib=0.0; available_ram_gib=None if not latent_only: decode_estimate_gib,available_ram_gib=_check_decode_memory_budget(width=width,height=height,chunks=chunks,chunk_seconds=chunk_seconds) issues=check_comfy_h3_runtime() if issues and strict_compatibility: raise SequenceRuntimeError("H3 runtime is incompatible: "+"; ".join(issues)) assets=prepare_identity_assets(video_vae,width=width,height=height,first_frame=first_frame,last_frame=last_frame,encode_latents=False) current_model_fingerprint=model_fingerprint(model,extra_wrapper_keys=("h3_continuum_join.apply_model.v1",)) accelerators=accelerator_summary(model) if "Continuum APPLY_MODEL wrapper installed" not in accelerators: accelerators+="; Continuum APPLY_MODEL wrapper installed" preserved,reuse_notes=_preserved_prefix(session=session,prompt_hashes=prompt_hashes,chunks=chunks,reroll_from_chunk=int(reroll_from_chunk),width=width,height=height,chunk_seconds=chunk_seconds,identity_hash=assets.identity_hash) if session is not None: old_fingerprint=str(session.get("model_fingerprint","")) if old_fingerprint and old_fingerprint!=current_model_fingerprint: reuse_notes.append("model/accelerator fingerprint differs from the saved session; accepted chunks were kept") cache={} if len(preserved)