Support per-chunk timeline durations
tests / test (push) Canceled after 0s
tests / windows-storage (push) Canceled after 0s

This commit is contained in:
2026-11-10 11:46:19 +00:00
parent 3716b02a57
commit 92135c0db0
13 changed files with 153 additions and 58 deletions
+2 -2
View File
@@ -9,11 +9,11 @@ FRAME_RESCALE = AUDIO_LATENT_FPS / FPS
FRAME_PER_TOKEN = (1, 4, 4, 4, 4)
CHUNK_SECONDS_DEFAULT = 5.0
CHUNK_SECONDS_MIN = 4.0
CHUNK_SECONDS_MIN = 4.1
CHUNK_SECONDS_MAX = 30.0
CHUNK_SECONDS_STEP = 0.1
CHUNK_SECONDS_TOOLTIP = (
"Target duration shared by every chunk. 5–15 seconds is the recommended "
"Target duration for each chunk. 5–15 seconds is the recommended "
"and validated range. Values above 15 seconds are supported, but VRAM "
"use and processing time can increase substantially, especially at high "
"resolution."
+3 -1
View File
@@ -59,6 +59,8 @@ For the supplied `2 × 10 s` workflow, put each time header on its own line and
Use the actual subjects and actions from your images; this is a syntax example, not a saved prompt in the downloadable workflow. Do not place prompt text on the same line as `[0-10s]`: that is not a Timeline header. A Reference can still influence a chunk without an explicit `@R` mention when its checkbox is enabled.
Timeline ranges can use different durations. For example, `[0-10s]`, `[10-15s]`, and `[15-25s]` create 10-second, 5-second, and 10-second chunks. The prompt plan reports those durations and the Sampler uses them during generation. Each duration must be at least 4.1 seconds; the normal recommended range remains 5–15 seconds.
The [official V3.9 workflow](../examples/workflows/MiniMax_H3_Continuum_V39.json) is the latest user-supplied JSON, copied without editing; its [single-workflow ZIP](../examples/workflows/MiniMax_H3_Continuum_V39.zip) is also available. It preserves the full V38X2 model/LoRA, Decode Cache, Finalize and Save chain. Six image loaders are prewired (initially bypassed); to use Image 7–9, add `H3 Continuum Load Image` nodes and connect them to the matching helper slots. The Sequence Prompt input remains connected but is intentionally blank: write your own prompt before Queue. The saved graph uses `Timeline`, two 10-second chunks, `Full Run` (displayed as Generate Full Video), First Image + Draft 0.30 MP size selection, and a separate Project ID. The earlier [Reference Inline migration fixture](../examples/workflows/MiniMax_H3_Continuum_V39_Reference_Inline.json) remains available unchanged. See the [step-by-step Reference Images guide](V39_REFERENCE_INLINE.md). Replace local media and model filenames as needed before Queue; enabling an image requires choosing a real file. Seven to nine active references can be particularly memory-intensive: start with fewer, smaller source images. A full ComfyUI backend restart and browser hard-refresh are required before the new node definitions appear. Browser save/reload and GPU acceptance of this unchanged default graph are still pending; a GitHub Release does not imply these gates or a Registry package have been completed.
**Compatibility:** Existing V3.8X2 workflows still use the V3.8 Sampler and old Reference Images 4–9 helper. V3.9 needs its new helper and connection. Open the new V3.9 workflow instead of only changing the Sampler type in an old graph: older V3.9 prototype workflows with direct 1–3 connections and Sampler-side routing widgets need manual rewiring, and their saved widget positions may differ. Accepted V3.8 Runs/Takes are not automatically migrated. Keep a copy of the previous workflow and use a new Run Name for V3.9.
@@ -307,7 +309,7 @@ Every `H3 Continuum Load Image` has `Enable Image`. `ON` loads through ComfyUI C
| `Control After Generate` | What ComfyUI does to `Base Seed` after a Queue | `fixed` for `Review Each Chunk`, resume, and controlled comparisons |
| `Audio Continuity` | Carries generated-audio context across boundaries | `true` for normal audiovisual generation |
| `Chunks` | Planned total chunk count, from 1 to 16 | Enter the final total, not the number to add next |
| `Seconds per Chunk` | Duration shared by every chunk | 5–15 seconds is the validated range; see duration notes below |
| `Seconds per Chunk` | Fallback duration when the prompt does not define per-chunk durations | 5–15 seconds is the validated range; see duration notes below |
| `Total Length` | Read-only `Chunks × Seconds per Chunk` | Check only; it never edits either input |
| `Size Source` | `First Image` or `Manual` output geometry | First Image for I2VA/FL2VA; Manual for T2VA or exact dimensions |
| `Resolution` | First-Image sizing preset | `Draft — 0.30 MP` for tests, `Balanced — 0.60 MP` for more detail, or `Native 768` for the H3-native short edge |
+4 -1
View File
@@ -81,7 +81,10 @@ def validate_assembly_plan_contract(plan: Mapping[str, Any]) -> None:
raise ValueError("assembly_plan.chunk_seconds must be finite and positive")
target_frames = _strict_int("assembly_plan.target_frames", plan.get("target_frames"), 1)
expected_target = int(round(len(chunks) * chunk_seconds * fps))
durations = plan.get("chunk_durations") or [chunk_seconds] * len(chunks)
if not isinstance(durations, list) or len(durations) != len(chunks):
raise ValueError("assembly_plan.chunk_durations does not match chunks")
expected_target = int(round(sum(float(value) for value in durations) * fps))
if target_frames != expected_target:
raise ValueError(
"assembly_plan.target_frames does not match chunks * chunk_seconds * fps"
+4 -1
View File
@@ -1463,6 +1463,7 @@ def build_sampling_contract(
"sigmas": _tensor_exact(sigmas),
"width": int(width), "height": int(height),
"chunk_seconds": float(chunk_seconds),
"chunk_durations": [float(value) for value in (prompt_plan.get("chunk_durations") or [chunk_seconds] * chunks)],
"continuity": continuity_storage_mode(continuity),
"audio_continuity": bool(audio_continuity),
"base_seed": int(base_seed),
@@ -3367,7 +3368,9 @@ class RunStorageController:
)
return make_session(
chunks=best_entries, width=int(width), height=int(height),
chunk_seconds=float(chunk_seconds), identity_hash=str(identity_hash),
chunk_seconds=float(chunk_seconds),
chunk_durations=list(prompt_plan.get("chunk_durations") or [chunk_seconds] * len(best_entries)),
identity_hash=str(identity_hash),
model_fingerprint_value=str(model_fingerprint_value),
parent_session_id=None, reroll_from_chunk=0,
settings=session_settings,
+22 -2
View File
@@ -12,6 +12,7 @@ from ComfyUI_H3_Continuum_Join.v3.nodes import (
H3ContinuumSamplerProduction,
H3ContinuumSamplerV3,
)
from ComfyUI_H3_Continuum_Join.v2.prompts import make_prompt_plan
def _chunk_seconds_schema(node_class):
@@ -31,7 +32,7 @@ def test_all_shared_sampler_and_prompt_plan_schemas_allow_thirty_seconds():
for node_class in node_classes:
schema = _chunk_seconds_schema(node_class)
assert schema["default"] == 5.0
assert schema["min"] == 4.0
assert schema["min"] == 4.1
assert schema["max"] == 30.0
assert schema["step"] == 0.1
assert schema["tooltip"] == CHUNK_SECONDS_TOOLTIP
@@ -42,4 +43,23 @@ def test_chunk_seconds_tooltip_describes_validated_and_high_cost_ranges():
assert "above 15 seconds are supported" in CHUNK_SECONDS_TOOLTIP
assert "VRAM" in CHUNK_SECONDS_TOOLTIP
assert "high resolution" in CHUNK_SECONDS_TOOLTIP
assert "shared by every chunk" in CHUNK_SECONDS_TOOLTIP
assert "for each chunk" in CHUNK_SECONDS_TOOLTIP
def test_timeline_prompt_can_define_per_chunk_durations():
plan = make_prompt_plan(
mode="Timeline",
script="[0-10s]\nfirst\n\n[10-15s]\nsecond\n\n[15-25s]\nthird",
chunks=3,
chunk_seconds=5.0,
)
assert plan["chunk_durations"] == [10.0, 5.0, 10.0]
assert plan["prompts"] == ["first", "second", "third"]
def test_timeline_prompt_rejects_four_second_chunks_with_fixed_fallback():
plan = make_prompt_plan(
mode="Timeline", script="[0-4s]\nshort", chunks=1, chunk_seconds=5.0
)
assert plan["chunk_durations"] == [5.0]
assert any(item.get("code") == "H3C-P100" for item in plan["diagnostics"])
+2 -2
View File
@@ -137,7 +137,7 @@ class H3ContinuumSamplerV2:
"dynamicPrompts": True,
"tooltip": (
"Fixed: one prompt. List: separate chunks with a line containing ---. "
"Timeline: use [0-5s], [5-10s], ... or [Chunk 1] headers."
"Timeline: use [0-5s], [5-10s], ... for equal chunks, or use contiguous ranges such as [0-10s], [10-15s] for per-chunk durations."
),
},
),
@@ -393,7 +393,7 @@ class H3ContinuumSamplerV2:
chunk_seconds=float(chunk_seconds),
prompt_hashes=list(prompt_plan["hashes"]),
timeline_video_source=timeline_video_source,
),
) and len(set(prompt_plan.get("chunk_durations") or [float(chunk_seconds)] * int(chunks))) == 1,
mode="Custom",
selectors_by_slot=reference_routing_request.selectors_by_slot,
)
+42 -14
View File
@@ -143,7 +143,27 @@ def _parse_timeline(script,chunks,chunk_seconds,*,ignore_list_separators=False):
scored.sort(reverse=True,key=lambda row:(row[0],row[1])); selected=scored[0][2]; prompts.append(selected["prompt"]); previous_prompt=selected["prompt"]; previous_source=f"{selected['source']} at line {selected['line_number']}"
diagnostics.append({"level":"info","code":"H3C-P000","message":f"Chunk {chunk_index} source: {previous_source}"})
if len(scored)>1 and abs(scored[0][0]-scored[1][0])<1e-9: notes.append(f"chunk {chunk_index} had an equal-overlap timeline tie; used the earlier section")
return prompts,notes,diagnostics
time_sections = [item for item in sections if item["kind"] == "time"]
durations = None
if len(time_sections) >= chunks:
candidate = sorted(time_sections, key=lambda item: (item["start"], item["end"]))[:chunks]
contiguous = abs(candidate[0]["start"]) <= 1e-6 and all(
abs(candidate[index]["start"] - candidate[index - 1]["end"]) <= 1e-6
for index in range(1, len(candidate))
)
if contiguous:
durations = [round(item["end"] - item["start"], 6) for item in candidate]
if any(value < CHUNK_SECONDS_MIN or value > CHUNK_SECONDS_MAX for value in durations):
raise PromptPlanError(
f"timeline chunk durations must be between {CHUNK_SECONDS_MIN:.1f} and {CHUNK_SECONDS_MAX:.1f} seconds"
)
prompts = [item["prompt"] for item in candidate]
diagnostics.extend(
{"level": "info", "code": "H3C-P000", "message": f"Chunk {index + 1} source: {item['source']}"}
for index, item in enumerate(candidate)
)
notes.append("derived per-chunk durations from timeline headers")
return prompts,notes,diagnostics,durations
def _has_timeline_header(script):
return any(_TIMELINE_HEADER.match(line) or _CHUNK_HEADER.match(line) for line in str(script).splitlines())
def _has_list_separator(script):
@@ -168,28 +188,28 @@ def resolve_prompt_mode(mode,script):
def make_prompt_plan(*,mode,script,chunks,chunk_seconds):
chunks=int(chunks); chunk_seconds=float(chunk_seconds)
if not 1<=chunks<=16: raise PromptPlanError("chunks must be between 1 and 16")
if not CHUNK_SECONDS_MIN<=chunk_seconds<=CHUNK_SECONDS_MAX: raise PromptPlanError(f"chunk_seconds must be between {CHUNK_SECONDS_MIN:.1f} and {CHUNK_SECONDS_MAX:.1f}")
notes=[]; diagnostics=[]
if not CHUNK_SECONDS_MIN<=chunk_seconds<=CHUNK_SECONDS_MAX: raise PromptPlanError(f"chunk_seconds must be between {CHUNK_SECONDS_MIN:.1f} and {CHUNK_SECONDS_MAX:.1f}")
notes=[]; diagnostics=[]; durations=[chunk_seconds]*chunks
try:
resolved_mode=resolve_prompt_mode(mode,script)
if mode==PROMPT_FORMAT_AUTO:
detected={PROMPT_MODE_FIXED:PROMPT_FORMAT_FIXED,PROMPT_MODE_LIST:PROMPT_FORMAT_LIST,PROMPT_MODE_TIMELINE:PROMPT_FORMAT_TIMELINE}[resolved_mode]; notes.append(f"Auto detected {detected}")
if resolved_mode==PROMPT_MODE_FIXED: prompt=_normalize_prompt(script,label="fixed prompt"); prompts=[prompt]*chunks
if resolved_mode==PROMPT_MODE_FIXED: prompt=_normalize_prompt(script,label="fixed prompt"); prompts=[prompt]*chunks; durations=[chunk_seconds]*chunks
elif resolved_mode==PROMPT_MODE_LIST:
prompts,parse_notes,list_sources=_parse_list(script,chunks); notes.extend(parse_notes)
if _has_timeline_header(script):
diagnostics.append(_mixed_syntax_diagnostic(timeline_active=False))
diagnostics.extend({"level":"info","code":"H3C-P000","message":f"Chunk {index+1} source: List section {source}"} for index,source in enumerate(list_sources))
elif resolved_mode==PROMPT_MODE_TIMELINE:
mixed_syntax=_has_list_separator(script)
prompts,parse_notes,diagnostics=_parse_timeline(script,chunks,chunk_seconds,ignore_list_separators=mixed_syntax); notes.extend(parse_notes)
elif resolved_mode==PROMPT_MODE_TIMELINE:
mixed_syntax=_has_list_separator(script)
prompts,parse_notes,diagnostics,durations=_parse_timeline(script,chunks,chunk_seconds,ignore_list_separators=mixed_syntax); notes.extend(parse_notes)
if mixed_syntax: diagnostics.insert(0,_mixed_syntax_diagnostic(timeline_active=True))
else: raise PromptPlanError(f"unknown prompt mode: {resolved_mode!r}")
except (PromptPlanError,TypeError,ValueError) as exc:
resolved_mode=PROMPT_MODE_FIXED; prompts=[_normalize_prompt(script,label="fixed prompt")]*chunks
resolved_mode=PROMPT_MODE_FIXED; prompts=[_normalize_prompt(script,label="fixed prompt")]*chunks; durations=[chunk_seconds]*chunks
notes.append("Prompt syntax was not recognized; used Fixed prompt fallback")
diagnostics=[{"level":"warning","code":"H3C-P100","message":str(exc)}]
result={"magic":PROMPT_PLAN_MAGIC,"schema_version":PROMPT_PLAN_SCHEMA_VERSION,"mode":resolved_mode,"chunks":chunks,"chunk_seconds":chunk_seconds,"prompts":prompts,"hashes":[prompt_hash(p) for p in prompts],"notes":notes}
result={"magic":PROMPT_PLAN_MAGIC,"schema_version":PROMPT_PLAN_SCHEMA_VERSION,"mode":resolved_mode,"chunks":chunks,"chunk_seconds":chunk_seconds,"chunk_durations":durations,"prompts":prompts,"hashes":[prompt_hash(p) for p in prompts],"notes":notes}
if diagnostics: result["diagnostics"]=diagnostics
return result
def validate_prompt_plan(plan):
@@ -197,9 +217,14 @@ def validate_prompt_plan(plan):
if int(plan.get("schema_version",-1))!=PROMPT_PLAN_SCHEMA_VERSION: raise PromptPlanError(f"unsupported prompt-plan schema {plan.get('schema_version')}; expected {PROMPT_PLAN_SCHEMA_VERSION}")
chunks=int(plan.get("chunks",0)); prompts=plan.get("prompts"); hashes=plan.get("hashes")
if not 1<=chunks<=16: raise PromptPlanError("prompt-plan chunks are invalid")
try: chunk_seconds=float(plan.get("chunk_seconds"))
try: chunk_seconds=float(plan.get("chunk_seconds"))
except (TypeError,ValueError): raise PromptPlanError("prompt-plan chunk_seconds is invalid") from None
if not CHUNK_SECONDS_MIN<=chunk_seconds<=CHUNK_SECONDS_MAX: raise PromptPlanError(f"prompt-plan chunk_seconds must be between {CHUNK_SECONDS_MIN:.1f} and {CHUNK_SECONDS_MAX:.1f}")
if not CHUNK_SECONDS_MIN<=chunk_seconds<=CHUNK_SECONDS_MAX: raise PromptPlanError(f"prompt-plan chunk_seconds must be between {CHUNK_SECONDS_MIN:.1f} and {CHUNK_SECONDS_MAX:.1f}")
durations=plan.get("chunk_durations")
if durations is None: durations=[chunk_seconds]*chunks
if not isinstance(durations,list) or len(durations)!=chunks: raise PromptPlanError("prompt-plan chunk duration count does not match chunks")
durations=[float(value) for value in durations]
if any(value<CHUNK_SECONDS_MIN or value>CHUNK_SECONDS_MAX for value in durations): raise PromptPlanError("prompt-plan contains an invalid chunk duration")
if not isinstance(prompts,list) or len(prompts)!=chunks: raise PromptPlanError("prompt-plan prompt count does not match chunks")
if not isinstance(hashes,list) or len(hashes)!=chunks: raise PromptPlanError("prompt-plan hash count does not match chunks")
for index,prompt in enumerate(prompts):
@@ -207,7 +232,8 @@ def validate_prompt_plan(plan):
if hashes[index]!=prompt_hash(prompt): raise PromptPlanError(f"prompt-plan hash mismatch at chunk {index+1}")
diagnostics=plan.get("diagnostics")
if diagnostics is not None and (not isinstance(diagnostics,list) or not all(isinstance(item,dict) for item in diagnostics)): raise PromptPlanError("prompt-plan diagnostics are invalid")
return plan
plan["chunk_durations"]=durations
return plan
def build_sampler_prompt_plan(*,prompt_mode,prompt_script,sequence_prompt,prompt_plan,chunks,chunk_seconds):
chunks=int(chunks); chunk_seconds=float(chunk_seconds)
if sequence_prompt is not None: return make_prompt_plan(mode=prompt_mode,script=sequence_prompt,chunks=chunks,chunk_seconds=chunk_seconds)
@@ -216,7 +242,8 @@ def build_sampler_prompt_plan(*,prompt_mode,prompt_script,sequence_prompt,prompt
prompts=list(plan["prompts"])
if len(prompts)<chunks: prompts.extend([prompts[-1] if prompts else ""]*(chunks-len(prompts)))
elif len(prompts)>chunks: prompts=prompts[:chunks]
result=dict(plan); result["chunks"]=chunks; result["chunk_seconds"]=chunk_seconds; result["prompts"]=prompts; result["hashes"]=[prompt_hash(p) for p in prompts]
result=dict(plan); result["chunks"]=chunks; result["chunk_seconds"]=chunk_seconds; result["chunk_durations"]=list(plan.get("chunk_durations") or [chunk_seconds]*int(plan["chunks"]))[:chunks]; result["prompts"]=prompts; result["hashes"]=[prompt_hash(p) for p in prompts]
if len(result["chunk_durations"])<chunks: result["chunk_durations"].extend([chunk_seconds]*(chunks-len(result["chunk_durations"])))
if int(plan["chunks"])!=chunks or abs(float(plan["chunk_seconds"])-chunk_seconds)>1e-6: result["notes"]=list(plan.get("notes") or [])+["adapted connected prompt plan to Sampler chunk settings"]
return validate_prompt_plan(result)
return make_prompt_plan(mode=prompt_mode,script=prompt_script,chunks=chunks,chunk_seconds=chunk_seconds)
@@ -230,7 +257,8 @@ def apply_prompt_overrides(plan,overrides):
return validate_prompt_plan(result)
def prompt_plan_report(plan):
plan=validate_prompt_plan(plan); unique=len(set(plan["hashes"])); note="; ".join(plan.get("notes") or [])
result=f"Prompt plan: {plan['mode']}; {plan['chunks']} chunks; {unique} unique prompt(s); {plan['chunk_seconds']:.3f}s per chunk."
durations=plan.get("chunk_durations") or [plan["chunk_seconds"]]*plan["chunks"]
result=f"Prompt plan: {plan['mode']}; {plan['chunks']} chunks; durations [{', '.join(f'{value:g}s' for value in durations)}]; total {sum(durations):g}s; {unique} unique prompt(s)."
if note: result+=" "+note+"."
diagnostics=list(plan.get("diagnostics") or [])
if not diagnostics: return result+"\nPrompt Preflight: OK."
+28 -17
View File
@@ -80,26 +80,35 @@ def _record_context_diagnostics(*,tracker,reports,state,continuity,reused):
except Exception as exc:
reports.append(f"context diagnostics source chunk {state.get('clip_index','?')}: unavailable ({exc})")
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)
def _check_decode_memory_budget(*,width,height,total_seconds,max_chunk_seconds):
target_frames=max(1,int(round(total_seconds*FPS))); max_chunk_frames=max(5,int(round(max_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
except ImportError: pass
return estimate_gib,available_gib
return estimate_gib,available_gib
def _plan_durations(plan: dict[str, Any]) -> list[float]:
chunks = int(plan["chunks"])
fallback = float(plan["chunk_seconds"])
values = plan.get("chunk_durations") or [fallback] * chunks
if len(values) != chunks:
raise SequenceRuntimeError("prompt plan duration count does not match chunks")
return [float(value) for value in values]
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,last_frame_hash,reference_storage_plan=None):
def _preserved_prefix(*,session,prompt_hashes,chunks,reroll_from_chunk,width,height,chunk_seconds,chunk_durations,identity_hash,last_frame_hash,reference_storage_plan=None):
if session is None: return [],[]
notes=[]
try: session=validate_session(session)
except SessionValidationError as exc: return [],[f"saved session was ignored; generated a fresh run ({exc})"]
if int(session["width"])!=int(width) or int(session["height"])!=int(height): return [],["saved session resolution differs; generated a fresh run"]
if abs(float(session["chunk_seconds"])-float(chunk_seconds))>1e-6: return [],["saved session chunk duration differs; generated a fresh run"]
saved_durations=session.get("chunk_durations") or [float(session["chunk_seconds"])]*len(session["chunks"])
if len(saved_durations)!=len(chunk_durations) or any(abs(float(a)-float(b))>1e-6 for a,b in zip(saved_durations,chunk_durations)): return [],["saved session chunk durations differ; generated a fresh run"]
if str(session.get("identity_hash","none"))!=str(identity_hash): return [],["saved session identity differs; generated a fresh run"]
routed_limit=None
if reference_storage_plan is not None:
@@ -526,8 +535,8 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
if memory_collector is not None:
from ..v3.memory_attribution import capture_attribution_fail_soft
capture_memory=capture_attribution_fail_soft
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)
visible_target_frames=int(round(chunks*chunk_seconds*FPS))
plan=validate_prompt_plan(prompt_plan); chunks=int(plan["chunks"]); chunk_seconds=float(plan["chunk_seconds"]); durations=_plan_durations(plan); prompts=list(plan["prompts"]); prompt_hashes=list(plan["hashes"]); width,height=int(width),int(height)
visible_target_frames=int(round(sum(durations)*FPS))
validate_guide_visible_range(guide_source,target_frames=visible_target_frames)
continuation_transport=str(continuation_transport)
if continuation_transport not in CONTINUATION_TRANSPORTS:
@@ -572,11 +581,11 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
)
timeline_video_warning=validate_timeline_video_prompts(prompts,timeline_video_source)
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)
if not latent_only: decode_estimate_gib,available_ram_gib=_check_decode_memory_budget(width=width,height=height,total_seconds=sum(durations),max_chunk_seconds=max(durations))
issues=check_comfy_h3_runtime()
assets=prepare_identity_assets(video_vae,width=width,height=height,first_frame=first_frame,last_frame=last_frame,encode_latents=False)
multi_chunk_flf=bool(chunks>=2 and first_frame is not None and last_frame is not None)
terminal_merge_enabled=_terminal_flf_merge_enabled(multi_chunk_flf=multi_chunk_flf,chunks=chunks,chunk_seconds=chunk_seconds,prompt_hashes=prompt_hashes,timeline_video_source=timeline_video_source)
terminal_merge_enabled=_terminal_flf_merge_enabled(multi_chunk_flf=multi_chunk_flf,chunks=chunks,chunk_seconds=chunk_seconds,prompt_hashes=prompt_hashes,timeline_video_source=timeline_video_source) and len(set(durations)) == 1
if _reference_routing_runtime is not None:
try:
_reference_routing_runtime.check_physical_contract(
@@ -669,7 +678,7 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
except Exception as exc:
adaptive_observer_unavailable=f"{type(exc).__name__}: {exc}"
effective_reroll_from_chunk=0 if storage_controller is not None and session is not None and bool((session.get("settings") or {}).get("run_storage_validated_prefix")) else int(reroll_from_chunk)
preserved,reuse_notes=_preserved_prefix(session=session,prompt_hashes=prompt_hashes,chunks=chunks,reroll_from_chunk=effective_reroll_from_chunk,width=width,height=height,chunk_seconds=chunk_seconds,identity_hash=sequence_identity_hash,last_frame_hash=assets.last_frame_hash,reference_storage_plan=reference_storage_plan)
preserved,reuse_notes=_preserved_prefix(session=session,prompt_hashes=prompt_hashes,chunks=chunks,reroll_from_chunk=effective_reroll_from_chunk,width=width,height=height,chunk_seconds=chunk_seconds,chunk_durations=durations,identity_hash=sequence_identity_hash,last_frame_hash=assets.last_frame_hash,reference_storage_plan=reference_storage_plan)
if _terminal_strategy_mismatch(session,merge_enabled=terminal_merge_enabled):
preserved=[]
reuse_notes.append("FLF chunk contract changed; regenerated the requested FLF sequence.")
@@ -941,7 +950,7 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
capture_memory(memory_collector, "finish_phase", phase="conditioning_prompt_clip")
if memory_collector is not None:
capture_memory(memory_collector, "finish_phase", phase="conditioning")
initial_frame_count=align_frame_count_up(int(round(chunk_seconds*FPS))); retained_frames=sum(int(entry["plan"]["net_frames"]) for entry in entries); sampling_reports=[]
retained_frames=sum(int(entry["plan"]["net_frames"]) for entry in entries); sampling_reports=[]
context_diagnostics=ContextDiagnosticsTracker() if bool(debug) else None
if context_diagnostics is not None:
if entries:
@@ -982,6 +991,8 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
if memory_collector is not None:
capture_memory(memory_collector, "finish_phase", phase="preparation")
for sequence_index in normal_indices:
chunk_seconds_for_chunk=durations[sequence_index]
initial_frame_count=align_frame_count_up(int(round(chunk_seconds_for_chunk*FPS)))
reusing_group=sequence_index<reused_count
if memory_collector is not None:
capture_memory(memory_collector, "start_phase", phase="group_prepare", physical_group=sequence_index+1, logical_chunks=(sequence_index+1,))
@@ -1044,9 +1055,9 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
physical_group=sequence_index+1,
)
conditioning=attach_keyframes(chunk_cache[conditioning_key],frame_count=total_frames,first_latent=chunk_assets.first_latent,last_latent=chunk_assets.last_latent if include_chunk_last else None); clip_index=1; context_frames=0
chunk_plan=make_plan(continuation=False,clip_index=clip_index,total_frames=total_frames,trim_frames=0,width=width,height=height,context_frames=5,state_capacity_frames=largest_context_capacity(total_frames),requested_extend_seconds=chunk_seconds,debug=debug); reason="initial clip"
chunk_plan=make_plan(continuation=False,clip_index=clip_index,total_frames=total_frames,trim_frames=0,width=width,height=height,context_frames=5,state_capacity_frames=largest_context_capacity(total_frames),requested_extend_seconds=chunk_seconds_for_chunk,debug=debug); reason="initial clip"
else:
context_frames,motion_score,reason=choose_context_frames(continuity,previous_state); desired_cumulative=int(round((sequence_index+1)*chunk_seconds*FPS)); requested_new_frames=max(1,desired_cumulative-retained_frames); shape=make_extension_shape(context_frames,requested_new_frames/FPS); latent=empty_h3_latent(width,height,shape.total_frames)
context_frames,motion_score,reason=choose_context_frames(continuity,previous_state); desired_cumulative=int(round(sum(durations[:sequence_index+1])*FPS)); requested_new_frames=max(1,desired_cumulative-retained_frames); shape=make_extension_shape(context_frames,requested_new_frames/FPS); latent=empty_h3_latent(width,height,shape.total_frames)
include_chunk_last=bool(last_frame is not None and is_final)
conditioning_key=_conditioning_cache_key(prompt,include_last=include_chunk_last,reference_assets=reference_assets)
if following_video:
@@ -1100,7 +1111,7 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
video_context,audio_context,grid_offset=select_context(previous_state,context_frames,include_audio=bool(audio_continuity)); context_before=context_fingerprint(video_context,audio_context)
conditioning=prepare_conditioning(base_conditioning,video_context=video_context,audio_context=audio_context,audio_grid_offset=grid_offset,context_frames=context_frames,new_frame_count=shape.total_frames,first_frame_policy=POLICY_REPLACE,preserve_last_frame=True)
context_interop_emitted=True
clip_index=int(previous_state["clip_index"])+1; chunk_plan=make_plan(continuation=True,clip_index=clip_index,total_frames=shape.total_frames,trim_frames=context_frames,width=width,height=height,context_frames=context_frames,state_capacity_frames=largest_context_capacity(shape.net_new_frames),requested_extend_seconds=chunk_seconds,debug=debug)
clip_index=int(previous_state["clip_index"])+1; chunk_plan=make_plan(continuation=True,clip_index=clip_index,total_frames=shape.total_frames,trim_frames=context_frames,width=width,height=height,context_frames=context_frames,state_capacity_frames=largest_context_capacity(shape.net_new_frames),requested_extend_seconds=chunk_seconds_for_chunk,debug=debug)
if follow_slice_contract is not None:
chunk_plan[FOLLOW_PLAN_KEY] = follow_slice_contract
if adaptive_observer_event is not None and not reusing_group:
@@ -1673,7 +1684,7 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
if timeline_video_source is not None: settings["timeline_video_contract"]=timeline_video_source.contract
if guide_source is not None: settings["guide_contract"]=dict(guide_source.contract)
if reference_storage_plan is not None: settings["reference_routing_v1"]=routed_session_settings
new_session=make_session(chunks=entries,width=width,height=height,chunk_seconds=chunk_seconds,identity_hash=sequence_identity_hash,model_fingerprint_value=current_model_fingerprint,parent_session_id=parent_id,reroll_from_chunk=int(reroll_from_chunk),settings=settings)
new_session=make_session(chunks=entries,width=width,height=height,chunk_seconds=chunk_seconds,chunk_durations=durations,identity_hash=sequence_identity_hash,model_fingerprint_value=current_model_fingerprint,parent_session_id=parent_id,reroll_from_chunk=int(reroll_from_chunk),settings=settings)
report_lines=[f"H3 Continuum V3 {PACKAGE_VERSION}",f"Conditioning mode: {conditioning_display}.",prompt_plan_report(plan),"Decode: external ComfyUI Core VAE nodes; full raw AV chunks retained.",accelerators,"Execution: conditioning precomputed; single call-local MODEL clone per chunk; no internal VAE decode.",*reuse_notes,*routing_warnings]
if max_new_physical_groups is not None:
report_lines.append(
@@ -1726,14 +1737,14 @@ def _run_runtime_internal(*,model:Any,clip:Any,video_vae:Any,audio_vae:Any,sampl
else: images,audio,decode_reports=decode_sequence_with_seam(entries=entries,video_vae=video_vae,audio_vae=audio_vae,diagnostics_mode=diagnostics_mode,automatic=seam_correction==SEAM_CORRECTION_AUTO)
duration_report=""
if exact_total_duration:
target_frames=int(round(chunks*chunk_seconds*FPS)); images,audio,duration_report=enforce_total_frames(images,audio,target_frames=target_frames,preserve_final_frame=last_frame is not None)
target_frames=int(round(sum(durations)*FPS)); images,audio,duration_report=enforce_total_frames(images,audio,target_frames=target_frames,preserve_final_frame=last_frame is not None)
last_state=entry_to_state(entries[-1]); parent_id=session.get("session_id") if session is not None else None
settings={"continuity":continuity,"audio_continuity":bool(audio_continuity),"exact_total_duration":bool(exact_total_duration),"prompt_mode":plan["mode"],"base_seed":int(base_seed),"reroll_nonce":int(reroll_nonce),"diagnostics_mode":diagnostics_mode,"initial_state_source":initial_state is not None,"first_frame_hash":assets.first_frame_hash,"last_frame_hash":assets.last_frame_hash,"reference_contract":reference_assets.contract if reference_assets is not None else None}
if multi_chunk_flf: settings["flf_execution"]=FLF_STRATEGY
if continuation_transport!=REFERENCE_CONTEXT_V1: settings["continuation_transport"]=continuation_transport
if guide_source is not None: settings["guide_contract"]=dict(guide_source.contract)
if reference_storage_plan is not None: settings["reference_routing_v1"]=routed_session_settings
new_session=make_session(chunks=entries,width=width,height=height,chunk_seconds=chunk_seconds,identity_hash=sequence_identity_hash,model_fingerprint_value=current_model_fingerprint,parent_session_id=parent_id,reroll_from_chunk=int(reroll_from_chunk),settings=settings)
new_session=make_session(chunks=entries,width=width,height=height,chunk_seconds=chunk_seconds,chunk_durations=durations,identity_hash=sequence_identity_hash,model_fingerprint_value=current_model_fingerprint,parent_session_id=parent_id,reroll_from_chunk=int(reroll_from_chunk),settings=settings)
decoded_gib=float(images.shape[0])*float(width)*float(height)*3.0*4.0/(1024.0**3)
report_lines=[f"H3 Continuum V2 {PACKAGE_VERSION}",prompt_plan_report(plan),f"Seam correction: {seam_correction}.",accelerators,"Execution: conditioning precomputed; single call-local MODEL clone per chunk; decode deferred until sampling completed.",*reuse_notes,*routing_warnings]
if diagnostics_mode!=DIAGNOSTICS_OFF: report_lines.extend([f"Decode RAM estimate: {decode_estimate_gib:.2f} GiB including transient headroom"+(f"; available at start {available_ram_gib:.2f} GiB." if available_ram_gib is not None else "."),*sampling_reports,*decode_reports])
+5
View File
@@ -129,6 +129,7 @@ def make_session(
width: int,
height: int,
chunk_seconds: float,
chunk_durations: list[float] | None = None,
identity_hash: str,
model_fingerprint_value: str,
parent_session_id: str | None,
@@ -154,6 +155,7 @@ def make_session(
"width": int(width),
"height": int(height),
"chunk_seconds": float(chunk_seconds),
"chunk_durations": [float(value) for value in (chunk_durations or [chunk_seconds] * len(normalized))],
"identity_hash": str(identity_hash),
"model_fingerprint": str(model_fingerprint_value),
"settings": copy.deepcopy(settings),
@@ -173,6 +175,9 @@ def validate_session(session: dict[str, Any]) -> dict[str, Any]:
raise SessionValidationError("session dimensions are invalid")
if float(session.get("chunk_seconds", 0.0)) <= 0:
raise SessionValidationError("session chunk_seconds is invalid")
durations=session.get("chunk_durations")
if durations is not None and (not isinstance(durations,list) or len(durations)!=len(session.get("chunks") or [])):
raise SessionValidationError("session chunk_durations are invalid")
chunks = session.get("chunks")
if not isinstance(chunks, list) or not chunks:
raise SessionValidationError("session contains no chunks")
+10 -3
View File
@@ -227,9 +227,16 @@ class H3ContinuumSamplerV34(H3ContinuumSamplerProduction):
from ..reference_video import prepare_reference_video_source
from ..temporal import align_frame_count_up
target_frames = round(
int(kwargs["chunks"]) * float(kwargs["chunk_seconds"]) * FPS
)
from ..v2.prompts import build_sampler_prompt_plan
prompt_plan = build_sampler_prompt_plan(
prompt_mode=kwargs["prompt_mode"],
prompt_script=kwargs.get("prompt_script", ""),
sequence_prompt=kwargs.get("sequence_prompt"),
prompt_plan=None,
chunks=int(kwargs["chunks"]),
chunk_seconds=float(kwargs["chunk_seconds"]),
)
target_frames = round(sum(prompt_plan.get("chunk_durations") or [float(kwargs["chunk_seconds"])] * int(kwargs["chunks"])) * FPS)
source = prepare_driving_audio_source(
driving_audio,
audio_vae,
+3 -2
View File
@@ -197,7 +197,7 @@ def _apply_review_decode_scope(
from ..v2.sequence import _terminal_flf_merge_enabled
from .plan import prepare_physical_decode_entries
terminal_merged = sequence_complete and _terminal_flf_merge_enabled(
terminal_merged = sequence_complete and len(set(assembly_plan.get("chunk_durations") or [float(chunk_seconds)] * int(configured_chunks))) == 1 and _terminal_flf_merge_enabled(
multi_chunk_flf=(
first_frame is not None
and last_frame is not None
@@ -643,7 +643,8 @@ class H3ContinuumSamplerV3:
configured_chunks = int(chunks)
completed_chunks = len(entries)
sequence_complete = completed_chunks == configured_chunks
terminal_merged = sequence_complete and _terminal_flf_merge_enabled(
prompt_durations = [float(entry.get("plan", {}).get("requested_extend_seconds", chunk_seconds)) for entry in entries]
terminal_merged = sequence_complete and len(set(prompt_durations)) == 1 and _terminal_flf_merge_enabled(
multi_chunk_flf=(
first_frame is not None
and advanced_values["last_frame"] is not None
+27 -12
View File
@@ -19,11 +19,12 @@ class AssemblyPlanError(ValueError):
pass
def make_assembly_plan(
entries: list[dict[str, Any]],
*,
chunk_seconds: float,
preserve_final_frame: bool,
def make_assembly_plan(
entries: list[dict[str, Any]],
*,
chunk_seconds: float,
chunk_durations: list[float] | None = None,
preserve_final_frame: bool,
) -> dict[str, Any]:
if not entries:
raise AssemblyPlanError("cannot create an assembly plan for an empty sequence")
@@ -61,14 +62,18 @@ def make_assembly_plan(
}
)
result = {
durations = [float(value) for value in (chunk_durations or [chunk_seconds] * len(chunks))]
if len(durations) != len(chunks):
raise AssemblyPlanError("chunk duration count does not match chunks")
result = {
"magic": ASSEMBLY_PLAN_MAGIC,
"schema_version": ASSEMBLY_PLAN_SCHEMA_VERSION,
"fps": FPS,
"width": int(width),
"height": int(height),
"chunk_seconds": float(chunk_seconds),
"target_frames": int(round(len(chunks) * float(chunk_seconds) * FPS)),
"chunk_seconds": float(chunk_seconds),
"chunk_durations": durations,
"target_frames": int(round(sum(durations) * FPS)),
"preserve_final_frame": bool(preserve_final_frame),
"chunks": chunks,
}
@@ -89,8 +94,11 @@ def validate_assembly_plan(plan: Any) -> dict[str, Any]:
raise AssemblyPlanError("assembly plan FPS must be 24")
if int(plan.get("width", 0)) <= 0 or int(plan.get("height", 0)) <= 0:
raise AssemblyPlanError("assembly plan dimensions are invalid")
if float(plan.get("chunk_seconds", 0.0)) <= 0:
raise AssemblyPlanError("assembly plan chunk duration is invalid")
if float(plan.get("chunk_seconds", 0.0)) <= 0:
raise AssemblyPlanError("assembly plan chunk duration is invalid")
durations = plan.get("chunk_durations") or [float(plan["chunk_seconds"])] * len(plan.get("chunks") or [])
if not isinstance(durations, list) or len(durations) != len(plan.get("chunks") or []):
raise AssemblyPlanError("assembly plan chunk durations are invalid")
if int(plan.get("target_frames", 0)) <= 0:
raise AssemblyPlanError("assembly plan target frame count is invalid")
@@ -356,6 +364,7 @@ def prepare_physical_decode_entries(
entries,
*,
chunk_seconds: float,
chunk_durations: list[float] | None = None,
preserve_final_frame: bool,
terminal_merged: bool,
terminal_initial_pair: bool | None = None,
@@ -363,9 +372,15 @@ def prepare_physical_decode_entries(
"""Return external-VAE decode units while preserving logical plan metadata."""
logical_entries = list(entries)
if chunk_durations is None:
chunk_durations = [
float(entry.get("plan", {}).get("requested_extend_seconds", chunk_seconds))
for entry in logical_entries
]
plan = make_assembly_plan(
logical_entries,
chunk_seconds=float(chunk_seconds),
logical_entries,
chunk_seconds=float(chunk_seconds),
chunk_durations=chunk_durations,
preserve_final_frame=bool(preserve_final_frame),
)
logical_chunk_indices = [
+1 -1
View File
@@ -5,4 +5,4 @@ STATE_SCHEMA_VERSION = 1
PLAN_SCHEMA_VERSION = 1
PUBLIC_API_VERSION = 3
SESSION_SCHEMA_VERSION = 1
PROMPT_PLAN_SCHEMA_VERSION = 1
PROMPT_PLAN_SCHEMA_VERSION = 1