Squashed 'vendor/dumas_h3_continuum/' content from commit d07ed31

git-subtree-dir: vendor/dumas_h3_continuum
git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
This commit is contained in:
2026-10-20 13:43:38 +00:00
commit bf8f76505f
481 changed files with 131517 additions and 0 deletions
+933
View File
@@ -0,0 +1,933 @@
"""ComfyUI node layer for H3 Continuum V2."""
from __future__ import annotations
import logging
from ..constants import (
CHUNK_SECONDS_DEFAULT,
CHUNK_SECONDS_MAX,
CHUNK_SECONDS_MIN,
CHUNK_SECONDS_STEP,
CHUNK_SECONDS_TOOLTIP,
DIAGNOSTICS_ACCEPTED_OPTIONS,
DIAGNOSTICS_OPTIONS,
PROMPT_FORMAT_OPTIONS,
PROMPT_MODE_OPTIONS,
SEAM_CORRECTION_AUTO,
SEAM_CORRECTION_OFF,
SEAM_CORRECTION_OPTIONS,
V2_CONTINUITY_OPTIONS,
normalize_diagnostics_mode,
)
from .prompts import (
apply_prompt_overrides,
build_sampler_prompt_plan,
make_prompt_plan,
parse_sparse_prompt_overrides,
prompt_plan_report,
validate_sparse_prompt_overrides,
)
from .sequence import run_sequence
from .session import entry_to_state, session_summary, validate_session
from .session_io import (
load_session,
save_session,
session_mtime,
session_paths,
)
CATEGORY = "MiniMax H3/Continuum"
LOG = logging.getLogger("h3_continuum_join")
SPARSE_OVERRIDE_SCHEMA_VERSION = 1
def _repair_v200_example_widget_shift(
*,
audio_continuity,
exact_total_duration,
diagnostics,
reroll_from_chunk,
reroll_nonce,
strict_compatibility,
debug,
):
"""Repair the malformed bundled 2.0.0 example workflow in memory.
``base_seed`` uses ComfyUI's ``control_after_generate`` option, which owns an
additional serialized widget. The original hand-authored V2 example omitted
that widget, shifting every following widget by one slot. A distinctive
signature is therefore ``exact_total_duration == 'Basic'/'Full'/'Off'`` and
numeric ``diagnostics``. Valid workflows never have a diagnostics label in
the BOOLEAN exact-duration input, so this migration is narrow and safe.
The missing exact-duration value cannot be recovered from the malformed JSON;
restore its documented V2 default (True). The remaining values can be shifted
back losslessly.
"""
if isinstance(exact_total_duration, str) and exact_total_duration in DIAGNOSTICS_ACCEPTED_OPTIONS:
if isinstance(diagnostics, (int, float, bool)) and not isinstance(diagnostics, str):
LOG.warning(
"H3 Continuum V2 detected the malformed 2.0.0 bundled workflow widget "
"layout; repairing shifted settings in memory. exact_total_duration "
"is restored to its default True. Save the workflow again after this run."
)
return (
bool(audio_continuity),
True,
normalize_diagnostics_mode(exact_total_duration),
int(diagnostics),
int(reroll_from_chunk),
bool(reroll_nonce),
bool(strict_compatibility),
)
return (
bool(audio_continuity),
bool(exact_total_duration),
normalize_diagnostics_mode(diagnostics),
int(reroll_from_chunk),
int(reroll_nonce),
bool(strict_compatibility),
bool(debug),
)
class H3ContinuumSamplerV2:
DESCRIPTION = (
"Integrated N-chunk MiniMax H3 continuation sampler. Precomputes prompt/image "
"conditioning, isolates accelerator runtime state per chunk, captures "
"latent state before decoding, then decodes and assembles the final AV stream."
)
SEARCH_ALIASES = [
"H3 long video sampler",
"MiniMax H3 integrated continuation",
"H3 Continuum V2",
]
@classmethod
def VALIDATE_INPUTS(cls, diagnostics):
return True if diagnostics in DIAGNOSTICS_ACCEPTED_OPTIONS else f"unknown report detail: {diagnostics!r}"
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"model": ("MODEL",),
"clip": ("CLIP",),
"video_vae": ("VAE",),
"audio_vae": ("VAE",),
"sampler": ("SAMPLER",),
"sigmas": ("SIGMAS",),
"prompt_mode": (
PROMPT_FORMAT_OPTIONS,
{
"default": PROMPT_FORMAT_OPTIONS[0],
"tooltip": (
"Auto detects Fixed text, --- separated List text, or "
"[0-5s] / [Chunk 1] Timeline sections."
),
},
),
"prompt_script": (
"STRING",
{
"default": "Describe one continuous MiniMax H3 shot with audio.",
"multiline": True,
"dynamicPrompts": True,
"tooltip": (
"Fixed: one prompt. List: separate chunks with a line containing ---. "
"Timeline: use [0-5s], [5-10s], ... or [Chunk 1] headers."
),
},
),
"chunks": (
"INT",
{"default": 3, "min": 1, "max": 16, "step": 1},
),
"chunk_seconds": (
"FLOAT",
{
"default": CHUNK_SECONDS_DEFAULT,
"min": CHUNK_SECONDS_MIN,
"max": CHUNK_SECONDS_MAX,
"step": CHUNK_SECONDS_STEP,
"tooltip": CHUNK_SECONDS_TOOLTIP,
},
),
"width": (
"INT",
{"default": 1344, "min": 32, "max": 16384, "step": 32},
),
"height": (
"INT",
{"default": 768, "min": 32, "max": 16384, "step": 32},
),
"continuity": (
V2_CONTINUITY_OPTIONS,
{
"default": V2_CONTINUITY_OPTIONS[1],
"tooltip": (
"Balanced 22f reproduces the V1 default. Auto uses a conservative "
"latent-motion score and falls back to 22f near thresholds."
),
},
),
"base_seed": (
"INT",
{
"default": 0,
"min": 0,
"max": 0xFFFFFFFFFFFFFFFF,
"control_after_generate": True,
},
),
"audio_continuity": ("BOOLEAN", {"default": True}),
"exact_total_duration": (
"BOOLEAN",
{
"default": True,
"tooltip": "Trim or minimally pad the assembled result to chunks × seconds × 24fps.",
},
),
"diagnostics": (
DIAGNOSTICS_OPTIONS,
{
"default": DIAGNOSTICS_OPTIONS[0],
"display_name": "Report Detail",
"tooltip": "Controls report verbosity only; it does not change generation or seam correction.",
},
),
"reroll_from_chunk": (
"INT",
{
"default": 0,
"min": 0,
"max": 16,
"step": 1,
"tooltip": (
"0 resumes/reuses every matching accepted chunk from the optional session. "
"N preserves chunks before N and regenerates N onward."
),
},
),
"reroll_nonce": (
"INT",
{
"default": 0,
"min": 0,
"max": 0xFFFFFFFF,
"step": 1,
"tooltip": "Change this to derive new seeds for regenerated chunks only.",
},
),
"strict_compatibility": ("BOOLEAN", {"default": False}),
"debug": ("BOOLEAN", {"default": False}),
"seam_correction": (
SEAM_CORRECTION_OPTIONS,
{
"default": SEAM_CORRECTION_AUTO,
"tooltip": (
"Auto keeps native video unless a no-blend candidate improves the boundary "
"and five-frame transition without component regression; audio is guarded "
"independently. Off preserves the decode path. Basic applies the decoded "
"A/V correction including conservative video blend."
),
},
),
},
"optional": {
"sequence_prompt": (
"STRING",
{
"forceInput": True,
"tooltip": (
"Connect one Text (Multiline). Prompt Format parses it for "
"the complete sequence without changing this socket."
),
},
),
"first_frame": ("IMAGE",),
"last_frame": ("IMAGE",),
"session": ("H3_CONTINUUM_SESSION",),
"initial_state": ("H3_CONTINUUM_STATE",),
"prompt_plan": ("H3_CONTINUUM_PROMPT_PLAN",),
"show_preview": (
"BOOLEAN",
{
"default": True,
"tooltip": "Show the in-progress latent thumbnail for this sampler node.",
},
),
**{
f"clip_{index}_prompt": (
"STRING",
{
"forceInput": True,
"tooltip": f"Optional prompt override for Clip {index}.",
},
)
for index in range(1, 17)
},
},
}
RETURN_TYPES = (
"IMAGE",
"AUDIO",
"H3_CONTINUUM_STATE",
"H3_CONTINUUM_SESSION",
"STRING",
)
RETURN_NAMES = ("images", "audio", "last_state", "session", "report")
FUNCTION = "run"
CATEGORY = CATEGORY
def run(
self,
model,
clip,
video_vae,
audio_vae,
sampler,
sigmas,
prompt_mode,
prompt_script,
chunks,
chunk_seconds,
width,
height,
continuity,
base_seed,
audio_continuity,
exact_total_duration,
diagnostics,
reroll_from_chunk,
reroll_nonce,
strict_compatibility,
debug,
seam_correction=SEAM_CORRECTION_OFF,
first_frame=None,
last_frame=None,
session=None,
initial_state=None,
prompt_plan=None,
sequence_prompt=None,
show_preview=True,
latent_only=False,
reference_assets=None,
reference_audio_source=None,
reference_audio_vae=None,
driving_audio_source=None,
driving_audio_vae=None,
reference_video_source=None,
timeline_video_source=None,
guide_source=None,
capture_refine_context=False,
memory_attribution=False,
prompt_conditioning_cache=False,
reference_encode_cache=False,
continuation_transport="reference_context_v1",
max_new_physical_groups=None,
_diagnostic_continuation_policy=None,
reference_routing_request=None,
**clip_prompt_inputs,
):
(
audio_continuity,
exact_total_duration,
diagnostics,
reroll_from_chunk,
reroll_nonce,
strict_compatibility,
debug,
) = _repair_v200_example_widget_shift(
audio_continuity=audio_continuity,
exact_total_duration=exact_total_duration,
diagnostics=diagnostics,
reroll_from_chunk=reroll_from_chunk,
reroll_nonce=reroll_nonce,
strict_compatibility=strict_compatibility,
debug=debug,
)
# V2.0.2 workflows stored show_preview in this newly inserted widget slot.
if isinstance(seam_correction, bool):
seam_correction = SEAM_CORRECTION_OFF
prompt_plan = build_sampler_prompt_plan(
prompt_mode=prompt_mode,
prompt_script=prompt_script,
sequence_prompt=sequence_prompt,
prompt_plan=prompt_plan,
chunks=int(chunks),
chunk_seconds=float(chunk_seconds),
)
prompt_plan = apply_prompt_overrides(
prompt_plan,
[
clip_prompt_inputs.get(f"clip_{index}_prompt")
for index in range(1, int(chunks) + 1)
],
)
sequence_runner = run_sequence
if reference_routing_request is not None:
from .sequence import (
_terminal_flf_merge_enabled,
run_sequence_with_reference_routing,
)
from ..v3.reference_routing import compile_reference_routing_schedule
from ..v3.reference_runtime import (
ReferenceRoutingRequest,
ReferenceRoutingRuntime,
)
if not isinstance(reference_routing_request, ReferenceRoutingRequest):
raise ValueError("invalid private Reference Routing request")
routing_schedule = compile_reference_routing_schedule(
total_chunks=int(chunks),
terminal_merge_enabled=_terminal_flf_merge_enabled(
multi_chunk_flf=bool(
int(chunks) >= 2 and first_frame is not None and last_frame is not None
),
chunks=int(chunks),
chunk_seconds=float(chunk_seconds),
prompt_hashes=list(prompt_plan["hashes"]),
timeline_video_source=timeline_video_source,
),
mode="Custom",
selectors_by_slot=reference_routing_request.selectors_by_slot,
)
if not routing_schedule.valid:
details = "; ".join(issue.message for issue in routing_schedule.issues)
raise ValueError(f"Reference Routing is invalid: {details}")
routing_runtime = ReferenceRoutingRuntime(
schedule=routing_schedule,
inputs=reference_routing_request.inputs,
)
reference_routing_request.runtime = routing_runtime
sequence_runner = lambda **values: run_sequence_with_reference_routing(
reference_routing_runtime=routing_runtime, **values
)
return sequence_runner(
model=model,
clip=clip,
video_vae=video_vae,
audio_vae=audio_vae,
sampler=sampler,
sigmas=sigmas,
first_frame=first_frame,
last_frame=last_frame,
prompt_plan=prompt_plan,
width=int(width),
height=int(height),
continuity=continuity,
base_seed=int(base_seed),
audio_continuity=bool(audio_continuity),
exact_total_duration=bool(exact_total_duration),
diagnostics_mode=diagnostics,
reroll_from_chunk=int(reroll_from_chunk),
reroll_nonce=int(reroll_nonce),
strict_compatibility=False,
debug=bool(debug),
seam_correction=seam_correction,
enable_preview=bool(show_preview),
session=session,
initial_state=initial_state,
latent_only=bool(latent_only),
reference_assets=reference_assets,
reference_audio_source=reference_audio_source,
reference_audio_vae=reference_audio_vae,
driving_audio_source=driving_audio_source,
driving_audio_vae=driving_audio_vae,
reference_video_source=reference_video_source,
timeline_video_source=timeline_video_source,
guide_source=guide_source,
capture_refine_context=bool(capture_refine_context),
memory_attribution=bool(memory_attribution),
prompt_conditioning_cache=bool(prompt_conditioning_cache),
reference_encode_cache=bool(reference_encode_cache),
continuation_transport=str(continuation_transport),
max_new_physical_groups=max_new_physical_groups,
_diagnostic_continuation_policy=_diagnostic_continuation_policy,
)
class H3ContinuumPromptPlanPreview:
DESCRIPTION = "Validate and preview Fixed/List/Timeline prompt parsing without sampling."
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"prompt_mode": (
PROMPT_FORMAT_OPTIONS,
{
"default": PROMPT_FORMAT_OPTIONS[0],
"tooltip": (
"Auto detects Fixed text, --- separated List text, or "
"[0-5s] / [Chunk 1] Timeline sections."
),
},
),
"prompt_script": ("STRING", {"default": "Prompt", "multiline": True}),
"chunks": ("INT", {"default": 3, "min": 1, "max": 16, "step": 1}),
"chunk_seconds": (
"FLOAT",
{
"default": CHUNK_SECONDS_DEFAULT,
"min": CHUNK_SECONDS_MIN,
"max": CHUNK_SECONDS_MAX,
"step": CHUNK_SECONDS_STEP,
"tooltip": CHUNK_SECONDS_TOOLTIP,
},
),
}
}
RETURN_TYPES = ("H3_CONTINUUM_PROMPT_PLAN", "STRING")
RETURN_NAMES = ("prompt_plan", "report")
FUNCTION = "build"
CATEGORY = CATEGORY
def build(self, prompt_mode, prompt_script, chunks, chunk_seconds):
plan = make_prompt_plan(
mode=prompt_mode,
script=prompt_script,
chunks=int(chunks),
chunk_seconds=float(chunk_seconds),
)
report = prompt_plan_report(plan) + "\n" + "\n\n".join(
f"Chunk {index + 1}:\n{prompt}" for index, prompt in enumerate(plan["prompts"])
)
return plan, report
class H3ContinuumSaveSession:
DESCRIPTION = "Atomically save every accepted V2 chunk latent plus session metadata."
OUTPUT_NODE = True
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"session": ("H3_CONTINUUM_SESSION",),
"prefix": ("STRING", {"default": "h3_continuum_session"}),
"slot": ("INT", {"default": 1, "min": 1, "max": 9999, "step": 1}),
}
}
RETURN_TYPES = ("H3_CONTINUUM_SESSION", "STRING")
RETURN_NAMES = ("session", "path")
FUNCTION = "save"
CATEGORY = CATEGORY
def save(self, session, prefix, slot):
tensor_path, _json_path = save_session(session, prefix=prefix, slot=int(slot))
return session, str(tensor_path)
class H3ContinuumLoadSession:
DESCRIPTION = "Load an explicitly numbered V2 session for resume or reroll."
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"prefix": ("STRING", {"default": "h3_continuum_session"}),
"slot": ("INT", {"default": 1, "min": 1, "max": 9999, "step": 1}),
}
}
RETURN_TYPES = ("H3_CONTINUUM_SESSION", "STRING")
RETURN_NAMES = ("session", "path")
FUNCTION = "load"
CATEGORY = CATEGORY
@classmethod
def IS_CHANGED(cls, prefix, slot):
return session_mtime(prefix=prefix, slot=int(slot))
def load(self, prefix, slot):
session = load_session(prefix=prefix, slot=int(slot))
tensor_path, _json_path = session_paths(prefix, int(slot))
return session, str(tensor_path)
class H3ContinuumSessionInfo:
DESCRIPTION = "Inspect a V2 session and expose its final V1-compatible continuation state."
@classmethod
def INPUT_TYPES(cls):
return {"required": {"session": ("H3_CONTINUUM_SESSION",)}}
RETURN_TYPES = ("H3_CONTINUUM_SESSION", "H3_CONTINUUM_STATE", "STRING")
RETURN_NAMES = ("session", "last_state", "report")
FUNCTION = "inspect"
CATEGORY = CATEGORY
def inspect(self, session):
session = validate_session(session)
state = entry_to_state(session["chunks"][-1])
report = session_summary(session)
return session, state, report
class H3ContinuumClipOverrides:
DEPRECATED = True
"""Build a static prompt-override pack without per-clip sockets."""
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"prompt_mode": (
PROMPT_FORMAT_OPTIONS,
{
"default": PROMPT_FORMAT_OPTIONS[0],
"display_name": "Prompt Format",
"tooltip": (
"Retained for V2.1.7 workflow compatibility. Sparse overrides "
"use explicit [Clip N] sections."
),
},
),
"override_script": (
"STRING",
{
"forceInput": True,
"display_name": "Override Script",
"tooltip": (
"Connect one Text (Multiline). Define only the clips to replace "
"with [Clip N] or [Chunk N] sections."
),
},
),
}
}
RETURN_TYPES = ("H3_CONTINUUM_CLIP_OVERRIDES",)
RETURN_NAMES = ("prompt_overrides",)
FUNCTION = "build"
CATEGORY = CATEGORY
def build(self, prompt_mode, override_script):
return (
{
"schema_version": SPARSE_OVERRIDE_SCHEMA_VERSION,
"overrides": parse_sparse_prompt_overrides(override_script),
},
)
class H3ContinuumAdvanced:
"""Package optional continuation inputs and infrequent sampler settings."""
@classmethod
def VALIDATE_INPUTS(cls, diagnostics):
return True if diagnostics in DIAGNOSTICS_ACCEPTED_OPTIONS else f"unknown report detail: {diagnostics!r}"
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"audio_continuity": ("BOOLEAN", {"default": True}),
"exact_total_duration": ("BOOLEAN", {"default": True}),
"diagnostics": (
DIAGNOSTICS_OPTIONS,
{
"default": DIAGNOSTICS_OPTIONS[0],
"display_name": "Report Detail",
"tooltip": "Controls report verbosity only; it does not change generation or seam correction.",
},
),
"reroll_from_chunk": (
"INT",
{"default": 0, "min": 0, "max": 16, "step": 1},
),
"reroll_nonce": (
"INT",
{"default": 0, "min": 0, "max": 0xFFFFFFFF, "step": 1},
),
"strict_compatibility": ("BOOLEAN", {"default": False}),
"debug": ("BOOLEAN", {"default": False}),
"show_preview": ("BOOLEAN", {"default": True}),
},
"optional": {
"last_frame": ("IMAGE",),
"session": ("H3_CONTINUUM_SESSION",),
"initial_state": ("H3_CONTINUUM_STATE",),
"prompt_plan": ("H3_CONTINUUM_PROMPT_PLAN",),
},
}
RETURN_TYPES = ("H3_CONTINUUM_ADVANCED",)
RETURN_NAMES = ("advanced",)
FUNCTION = "build"
CATEGORY = CATEGORY
def build(
self,
audio_continuity,
exact_total_duration,
diagnostics,
reroll_from_chunk,
reroll_nonce,
strict_compatibility,
debug,
show_preview,
last_frame=None,
session=None,
initial_state=None,
prompt_plan=None,
):
return (
{
"audio_continuity": bool(audio_continuity),
"exact_total_duration": bool(exact_total_duration),
"diagnostics": normalize_diagnostics_mode(diagnostics),
"reroll_from_chunk": int(reroll_from_chunk),
"reroll_nonce": int(reroll_nonce),
"strict_compatibility": False,
"debug": bool(debug),
"show_preview": bool(show_preview),
"last_frame": last_frame,
"session": session,
"initial_state": initial_state,
"prompt_plan": prompt_plan,
},
)
class H3ContinuumSampler:
"""Stable, compact facade over the fully compatible V2 sampler core."""
DESCRIPTION = (
"Compact H3 Continuum sampler facade. Uses the legacy V2 execution core "
"without dynamic sockets or frontend display patches."
)
SEARCH_ALIASES = ["H3 Continuum", "MiniMax H3 long video"]
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"model": ("MODEL",),
"clip": ("CLIP",),
"video_vae": ("VAE",),
"audio_vae": ("VAE",),
"sampler": ("SAMPLER",),
"sigmas": ("SIGMAS",),
"sequence_prompt": (
"STRING",
{
"forceInput": True,
"display_name": "Sequence Prompt",
"tooltip": "Connect one Text (Multiline) for the complete sequence.",
},
),
"prompt_mode": (
PROMPT_FORMAT_OPTIONS,
{
"default": PROMPT_FORMAT_OPTIONS[0],
"display_name": "Prompt Format",
},
),
"chunks": ("INT", {"default": 3, "min": 1, "max": 16, "step": 1}),
"chunk_seconds": (
"FLOAT",
{
"default": CHUNK_SECONDS_DEFAULT,
"min": CHUNK_SECONDS_MIN,
"max": CHUNK_SECONDS_MAX,
"step": CHUNK_SECONDS_STEP,
"tooltip": CHUNK_SECONDS_TOOLTIP,
},
),
"width": ("INT", {"default": 1344, "min": 32, "max": 16384, "step": 32}),
"height": ("INT", {"default": 768, "min": 32, "max": 16384, "step": 32}),
"continuity": (
V2_CONTINUITY_OPTIONS,
{"default": V2_CONTINUITY_OPTIONS[1]},
),
"base_seed": (
"INT",
{
"default": 0,
"min": 0,
"max": 0xFFFFFFFFFFFFFFFF,
"control_after_generate": True,
},
),
"seam_correction": (
SEAM_CORRECTION_OPTIONS,
{
"default": SEAM_CORRECTION_AUTO,
"tooltip": (
"Auto is native-first: video correction is adopted only when the boundary "
"and five-frame transition clearly improve; audio is guarded independently."
),
},
),
},
"optional": {
"first_frame": ("IMAGE",),
"prompt_overrides": ("H3_CONTINUUM_CLIP_OVERRIDES",),
"advanced": ("H3_CONTINUUM_ADVANCED",),
},
}
RETURN_TYPES = ("IMAGE", "AUDIO", "H3_CONTINUUM_RESULT")
RETURN_NAMES = ("images", "audio", "result")
FUNCTION = "run"
CATEGORY = CATEGORY
def run(
self,
model,
clip,
video_vae,
audio_vae,
sampler,
sigmas,
sequence_prompt,
prompt_mode,
chunks,
chunk_seconds,
width,
height,
continuity,
base_seed,
seam_correction,
first_frame=None,
prompt_overrides=None,
advanced=None,
):
if prompt_overrides is not None and not isinstance(prompt_overrides, dict):
raise TypeError("prompt_overrides must be an H3_CONTINUUM_CLIP_OVERRIDES pack")
if advanced is not None and not isinstance(advanced, dict):
advanced = None
advanced_values = {
"audio_continuity": True,
"exact_total_duration": True,
"diagnostics": DIAGNOSTICS_OPTIONS[0],
"reroll_from_chunk": 0,
"reroll_nonce": 0,
"strict_compatibility": False,
"debug": False,
"show_preview": True,
"last_frame": None,
"session": None,
"initial_state": None,
"prompt_plan": None,
}
if advanced:
advanced_values.update(advanced)
advanced_values["strict_compatibility"] = False
clip_prompt_inputs = {}
if prompt_overrides:
if (
type(prompt_overrides.get("schema_version")) is not int
or prompt_overrides.get("schema_version") != SPARSE_OVERRIDE_SCHEMA_VERSION
):
prompt_overrides = None
if prompt_overrides is not None:
try:
sparse_overrides = validate_sparse_prompt_overrides(
prompt_overrides.get("overrides"), chunks=int(chunks)
)
except (TypeError, ValueError):
sparse_overrides = {}
for index, prompt in sparse_overrides.items():
clip_prompt_inputs[f"clip_{index}_prompt"] = prompt
images, audio, last_state, session, report = H3ContinuumSamplerV2().run(
model=model,
clip=clip,
video_vae=video_vae,
audio_vae=audio_vae,
sampler=sampler,
sigmas=sigmas,
prompt_mode=prompt_mode,
prompt_script=sequence_prompt,
chunks=chunks,
chunk_seconds=chunk_seconds,
width=width,
height=height,
continuity=continuity,
base_seed=base_seed,
audio_continuity=advanced_values["audio_continuity"],
exact_total_duration=advanced_values["exact_total_duration"],
diagnostics=advanced_values["diagnostics"],
reroll_from_chunk=advanced_values["reroll_from_chunk"],
reroll_nonce=advanced_values["reroll_nonce"],
strict_compatibility=False,
debug=advanced_values["debug"],
seam_correction=seam_correction,
first_frame=first_frame,
last_frame=advanced_values["last_frame"],
session=advanced_values["session"],
initial_state=advanced_values["initial_state"],
prompt_plan=advanced_values["prompt_plan"],
sequence_prompt=sequence_prompt,
show_preview=advanced_values["show_preview"],
**clip_prompt_inputs,
)
return (
images,
audio,
{
"last_state": last_state,
"session": session,
"report": report,
},
)
class H3ContinuumResult:
"""Expand the compact facade result pack only when advanced outputs are needed."""
DEPRECATED = True
@classmethod
def INPUT_TYPES(cls):
return {"required": {"result": ("H3_CONTINUUM_RESULT",)}}
RETURN_TYPES = ("H3_CONTINUUM_STATE", "H3_CONTINUUM_SESSION", "STRING")
RETURN_NAMES = ("last_state", "session", "report")
FUNCTION = "unpack"
CATEGORY = CATEGORY
def unpack(self, result):
if not isinstance(result, dict):
raise TypeError("result must be an H3_CONTINUUM_RESULT pack")
missing = {"last_state", "session", "report"} - set(result)
if missing:
raise ValueError("H3_CONTINUUM_RESULT is missing: " + ", ".join(sorted(missing)))
return result["last_state"], result["session"], str(result["report"])
NODE_CLASS_MAPPINGS = {
"H3ContinuumSampler": H3ContinuumSampler,
"H3ContinuumClipOverrides": H3ContinuumClipOverrides,
"H3ContinuumAdvanced": H3ContinuumAdvanced,
"H3ContinuumResult": H3ContinuumResult,
"H3ContinuumSamplerV2": H3ContinuumSamplerV2,
"H3ContinuumPromptPlanPreview": H3ContinuumPromptPlanPreview,
"H3ContinuumSaveSession": H3ContinuumSaveSession,
"H3ContinuumLoadSession": H3ContinuumLoadSession,
"H3ContinuumSessionInfo": H3ContinuumSessionInfo,
}
NODE_DISPLAY_NAME_MAPPINGS = {
"H3ContinuumSampler": "H3 Continuum Sampler",
"H3ContinuumClipOverrides": "H3 Continuum Clip Overrides",
"H3ContinuumAdvanced": "H3 Continuum Advanced",
"H3ContinuumResult": "H3 Continuum Result",
"H3ContinuumSamplerV2": "H3 Continuum Sampler V2",
"H3ContinuumPromptPlanPreview": "H3 Continuum Prompt Plan",
"H3ContinuumSaveSession": "H3 Continuum Save Session",
"H3ContinuumLoadSession": "H3 Continuum Load Session",
"H3ContinuumSessionInfo": "H3 Continuum Session Info",
}