Add DUMAS MiniMax H3 custom nodes

This commit is contained in:
2026-10-20 10:45:59 +00:00
parent 65312ad7c4
commit cda7860a59
7 changed files with 1438 additions and 6 deletions
+29 -4
View File
@@ -1,8 +1,9 @@
# DumasNodes # DumasNodes
Generic ComfyUI utility nodes under the Dumas brand. The repository contains Generic ComfyUI utility nodes under the Dumas brand. MiniMax H3-specific
image, JSON and video utilities and intentionally has no model-specific video nodes are grouped under `Dumas/MiniMax H3/...` so they can be installed
sampler dependency. alongside the maintained upstream `ComfyUI-H3-Continuum` pack without
overriding its node IDs.
## Sequential video assembly ## Sequential video assembly
@@ -30,7 +31,7 @@ or accept a re-encoded workflow.
## Project rendering ## Project rendering
## MiniMax-H3 tiled latent upscale ## MiniMax H3 tiled latent upscale
`DumasMMH3TiledLatentUpscale` is a thin integration node for the native `DumasMMH3TiledLatentUpscale` is a thin integration node for the native
`MMH3UltimateUpscale` node used by the MiniMax-H3 workflow. It accepts the `MMH3UltimateUpscale` node used by the MiniMax-H3 workflow. It accepts the
@@ -56,6 +57,30 @@ current socket types are `H3_UPSCALE_PARAM`, `H3_TEMPORAL_PARAM`, and
`H3_SPATIAL_PARAM`; these are deliberately used unchanged for workflow `H3_SPATIAL_PARAM`; these are deliberately used unchanged for workflow
compatibility. compatibility.
### DUMAS H3 Sequence Prompt Builder
`DumasH3SequencePromptBuilder` provides the tabbed, timeline-oriented prompt
editor used for multi-chunk H3 jobs. It emits one absolute sequence prompt,
the chunk count, the shared chunk duration, and a per-chunk reference bundle.
Reference images are inserted as `@R1` through `@R9`; routing is based on the
shared directive, soundscape, music, and each chunk's full prompt text.
The prompt builder intentionally uses the `ReferenceImagesV39Bundle` class
from the installed upstream H3 Continuum pack. Install that pack alongside
DumasNodes; DumasNodes does not copy or replace the upstream reference-image
implementation.
### DUMAS H3 Continuum Tiled Latent Upscale (Per Clip)
`DumasH3ContinuumTiledLatentUpscalePerClip` applies the native H3 tiled
upscale independently to each physical Continuum clip. It accepts the
Continuum `refine_context` and uses the upstream refine bridge when no direct
conditioning is connected. Its sampler, scheduler, sigma input, steps,
denoise, CFG, and noise seed are separate from the base generation pass.
Connected sockets take precedence over node defaults. The node preserves one
LATENT list item per physical clip to avoid concatenating a long sequence
into one oversized VRAM allocation.
The CSGlide `Render Project` control is the generation orchestrator: it renders The CSGlide `Render Project` control is the generation orchestrator: it renders
clips sequentially, adopts each completed render, extracts the previous clip's clips sequentially, adopts each completed render, extracts the previous clip's
tail, fills the next clip's `CONTINUE FROM` guide, and waits before advancing. tail, fills the next clip's `CONTINUE FROM` guide, and waits before advancing.
+12
View File
@@ -19,18 +19,30 @@ from .dumas_minimax_nodes import (
NODE_CLASS_MAPPINGS as MINIMAX_NODE_CLASS_MAPPINGS, NODE_CLASS_MAPPINGS as MINIMAX_NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS as MINIMAX_NODE_DISPLAY_NAME_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS as MINIMAX_NODE_DISPLAY_NAME_MAPPINGS,
) )
from .dumas_h3_prompt_nodes import (
NODE_CLASS_MAPPINGS as H3_PROMPT_NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS as H3_PROMPT_NODE_DISPLAY_NAME_MAPPINGS,
)
from .dumas_h3_upscale_nodes import (
NODE_CLASS_MAPPINGS as H3_UPSCALE_NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS as H3_UPSCALE_NODE_DISPLAY_NAME_MAPPINGS,
)
NODE_CLASS_MAPPINGS = {} NODE_CLASS_MAPPINGS = {}
NODE_CLASS_MAPPINGS.update(JSON_NODE_CLASS_MAPPINGS) NODE_CLASS_MAPPINGS.update(JSON_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(IMAGE_NODE_CLASS_MAPPINGS) NODE_CLASS_MAPPINGS.update(IMAGE_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(VIDEO_NODE_CLASS_MAPPINGS) NODE_CLASS_MAPPINGS.update(VIDEO_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(MINIMAX_NODE_CLASS_MAPPINGS) NODE_CLASS_MAPPINGS.update(MINIMAX_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(H3_PROMPT_NODE_CLASS_MAPPINGS)
NODE_CLASS_MAPPINGS.update(H3_UPSCALE_NODE_CLASS_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS = {} NODE_DISPLAY_NAME_MAPPINGS = {}
NODE_DISPLAY_NAME_MAPPINGS.update(JSON_NODE_DISPLAY_NAME_MAPPINGS) NODE_DISPLAY_NAME_MAPPINGS.update(JSON_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(IMAGE_NODE_DISPLAY_NAME_MAPPINGS) NODE_DISPLAY_NAME_MAPPINGS.update(IMAGE_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(VIDEO_NODE_DISPLAY_NAME_MAPPINGS) NODE_DISPLAY_NAME_MAPPINGS.update(VIDEO_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(MINIMAX_NODE_DISPLAY_NAME_MAPPINGS) NODE_DISPLAY_NAME_MAPPINGS.update(MINIMAX_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(H3_PROMPT_NODE_DISPLAY_NAME_MAPPINGS)
NODE_DISPLAY_NAME_MAPPINGS.update(H3_UPSCALE_NODE_DISPLAY_NAME_MAPPINGS)
WEB_DIRECTORY = "./js" WEB_DIRECTORY = "./js"
+248
View File
@@ -0,0 +1,248 @@
"""UI-backed sequence prompt construction for H3 Continuum."""
from __future__ import annotations
import json
import re
from typing import Any, Mapping
import sys
REFERENCE_IMAGES_V39_TYPE = "H3_CONTINUUM_REFERENCE_IMAGES_V39"
def _continuum_reference_bundle_type():
"""Find the upstream H3 bundle class without copying its implementation."""
candidates = [
module for name, module in list(sys.modules.items())
if module is not None and name.endswith(".v3.reference_images_v39")
]
try:
import importlib
candidates.append(importlib.import_module("v3.reference_images_v39"))
except Exception:
pass
for module in candidates:
bundle = getattr(module, "ReferenceImagesV39Bundle", None)
if bundle is not None:
return bundle
raise RuntimeError(
"DUMAS H3 Sequence Prompt Builder requires the original "
"ComfyUI-H3-Continuum reference_images_v39 module to be installed."
)
MAX_CLIPS = 16
DEFAULT_CLIP_SECONDS = 4.0
def _number(value: Any, name: str, *, minimum: float = 0.0) -> float:
if isinstance(value, bool):
raise ValueError(f"{name} must be a number")
try:
result = float(value)
except (TypeError, ValueError) as exc:
raise ValueError(f"{name} must be a number") from exc
if result < minimum:
raise ValueError(f"{name} must be >= {minimum}")
return result
def default_sequence(clip_count: int = 2, clip_seconds: float = DEFAULT_CLIP_SECONDS) -> dict[str, Any]:
"""Return a portable editor state with one slot per clip."""
count = int(clip_count)
if count < 1 or count > MAX_CLIPS:
raise ValueError(f"clip_count must be between 1 and {MAX_CLIPS}")
duration = _number(clip_seconds, "clip_seconds", minimum=0.1)
return {
"version": 1,
"clips": [
{
"duration": duration,
"slots": [{"start": 0.0, "end": duration, "text": ""}],
}
for _ in range(count)
],
}
def normalize_sequence(value: Any, *, clip_count: int, default_seconds: float) -> dict[str, Any]:
"""Validate and normalize editor JSON without changing user-authored text."""
if isinstance(value, str):
try:
value = json.loads(value or "{}")
except json.JSONDecodeError as exc:
raise ValueError(f"timeline_json is not valid JSON: {exc.msg}") from exc
if not isinstance(value, Mapping):
raise ValueError("timeline_json must be a JSON object")
raw_clips = value.get("clips", [])
if not isinstance(raw_clips, list):
raise ValueError("timeline_json.clips must be a list")
count = int(clip_count)
if count < 1 or count > MAX_CLIPS:
raise ValueError(f"clip_count must be between 1 and {MAX_CLIPS}")
fallback_duration = _number(default_seconds, "default_chunk_seconds", minimum=0.1)
clips: list[dict[str, Any]] = []
for clip_index in range(count):
raw_clip = raw_clips[clip_index] if clip_index < len(raw_clips) else {}
if not isinstance(raw_clip, Mapping):
raise ValueError(f"clip {clip_index + 1} must be an object")
# Continuum projects use one chunk duration for every clip. Older
# editor state may still contain per-clip durations; ignore them so
# the single node control remains authoritative.
duration = fallback_duration
raw_slots = raw_clip.get("slots", [])
if not isinstance(raw_slots, list):
raise ValueError(f"clip {clip_index + 1} slots must be a list")
slots: list[dict[str, Any]] = []
for slot_index, raw_slot in enumerate(raw_slots):
if not isinstance(raw_slot, Mapping):
raise ValueError(f"clip {clip_index + 1} slot {slot_index + 1} must be an object")
start = _number(raw_slot.get("start", 0), f"clip {clip_index + 1} slot {slot_index + 1} start")
end = _number(raw_slot.get("end", duration), f"clip {clip_index + 1} slot {slot_index + 1} end")
if end <= start:
raise ValueError(f"clip {clip_index + 1} slot {slot_index + 1} end must be after start")
if end > duration + 1e-6:
raise ValueError(f"clip {clip_index + 1} slot {slot_index + 1} ends after the clip duration")
text = str(raw_slot.get("text", "")).strip()
if text:
slots.append({"start": start, "end": end, "text": text})
slots.sort(key=lambda slot: (slot["start"], slot["end"]))
if slots:
# The final shot owns the end of every uniform-duration chunk;
# there must be no unassigned tail on the editor track.
slots[-1]["end"] = duration
clips.append({"duration": duration, "slots": slots})
return {"version": 1, "clips": clips}
def format_sequence_prompt(
*,
shared_directive: str,
sequence: Mapping[str, Any],
soundscape: str = "",
music: str = "",
) -> str:
"""Format uniform clips as chunk blocks with relative shot timings.
Continuum treats square-bracket ranges as physical/logical chunk markers.
Shot timings belong inside each chunk and must therefore use plain
``start-end s:`` lines rather than creating additional Timeline sections.
"""
directive = str(shared_directive or "").strip()
sound = str(soundscape or "").strip() or "N/A"
music_text = str(music or "").strip() or "N/A"
sections: list[str] = []
cursor = 0.0
for clip in sequence["clips"]:
duration = float(clip["duration"])
chunk_lines = [f"[{cursor:g}-{cursor + duration:g}s]"]
if directive:
chunk_lines.append(directive)
for slot in clip["slots"]:
start = float(slot["start"])
end = float(slot["end"])
chunk_lines.append(f"{start:g}-{end:g}s: {slot['text']}")
chunk_lines.append(f"overall_soundscape: {sound}")
chunk_lines.append(f"non_diegetic_music: {music_text}")
sections.append("\n".join(chunk_lines))
cursor += duration
return "\n\n".join(sections).strip()
class DumasH3SequencePromptBuilder:
"""Build one Timeline prompt from clip tabs and clip-local time slots."""
DESCRIPTION = (
"DUMAS H3 prompt editor. Define clips and local time slots in the UI; "
"the node emits one absolute Timeline prompt for Sequence Prompt."
)
CATEGORY = "DUMAS H3/Prompt"
RETURN_TYPES = ("STRING", "INT", "FLOAT", REFERENCE_IMAGES_V39_TYPE)
RETURN_NAMES = ("sequence_prompt", "chunk_count", "chunk_duration", "reference_images")
FUNCTION = "build"
@classmethod
def INPUT_TYPES(cls):
state = json.dumps(default_sequence(), separators=(",", ":"))
return {
"required": {
"clip_count": ("INT", {"default": 2, "min": 1, "max": MAX_CLIPS, "step": 1}),
"default_chunk_seconds": ("FLOAT", {"default": DEFAULT_CLIP_SECONDS, "min": 0.1, "max": 30.0, "step": 0.1}),
"shared_directive": ("STRING", {"default": "", "multiline": True}),
"timeline_json": ("STRING", {"default": state, "multiline": True}),
"soundscape": ("STRING", {"default": "", "multiline": True}),
"music": ("STRING", {"default": "", "multiline": True}),
},
"optional": {
f"reference_image_{index}": ("IMAGE", {
"display_name": f"Reference Image {index} (@R{index})",
"tooltip": f"Fixed Reference Image {index}; use @R{index} in a clip prompt.",
}) for index in range(1, 10)
}
}
def build(
self,
clip_count,
default_chunk_seconds,
shared_directive,
timeline_json,
soundscape,
music,
**kwargs,
):
sequence = normalize_sequence(
timeline_json,
clip_count=int(clip_count),
default_seconds=float(default_chunk_seconds),
)
selectors = []
directive = str(shared_directive or "").strip()
sound = str(soundscape or "").strip() or "N/A"
music_text = str(music or "").strip() or "N/A"
for reference_index in range(1, 10):
chunks = []
for chunk_index, clip in enumerate(sequence["clips"], start=1):
# Match against the same per-chunk content emitted by
# format_sequence_prompt, not only the editable shot lines.
text = "\n".join([
directive,
*(str(slot.get("text", "")) for slot in clip["slots"]),
f"overall_soundscape: {sound}",
f"non_diegetic_music: {music_text}",
])
if kwargs.get(f"reference_image_{reference_index}") is not None and re.search(
rf"@(R{reference_index}|image{reference_index})(?![A-Za-z0-9_])",
text,
re.IGNORECASE,
):
chunks.append(chunk_index)
selectors.append(",".join(map(str, chunks)) or "off")
images = tuple(kwargs.get(f"reference_image_{index}") for index in range(1, 10))
reference_bundle = _continuum_reference_bundle_type()(
images=images,
reference_use="Per chunk",
selectors=tuple(selectors),
)
return (
format_sequence_prompt(
shared_directive=shared_directive,
sequence=sequence,
soundscape=soundscape,
music=music,
),
len(sequence["clips"]),
float(default_chunk_seconds),
reference_bundle,
)
NODE_CLASS_MAPPINGS = {"DumasH3SequencePromptBuilder": DumasH3SequencePromptBuilder}
NODE_DISPLAY_NAME_MAPPINGS = {
"DumasH3SequencePromptBuilder": "DUMAS H3 Sequence Prompt Builder",
}
+374
View File
@@ -0,0 +1,374 @@
"""Per-clip tiled latent upscaling for MiniMax H3 Continuum.
Continuum exposes physical video groups as a LATENT list. The native
``MMH3UltimateUpscale`` node operates on one H3 latent at a time, so this
adapter deliberately applies it independently to each physical clip instead
of concatenating the clips into one larger VRAM allocation.
"""
from __future__ import annotations
from typing import Any
def _sampler_options() -> list[str]:
try:
import comfy.samplers
return list(comfy.samplers.KSampler.SAMPLERS)
except Exception: # pragma: no cover - exercised on a ComfyUI host
return ["euler", "euler_ancestral", "res_multistep", "sa_solver"]
def _scheduler_options() -> list[str]:
try:
import comfy.samplers
return list(comfy.samplers.KSampler.SCHEDULERS)
except Exception: # pragma: no cover - exercised on a ComfyUI host
return ["simple", "beta", "sgm_uniform", "karras", "exponential"]
def _continuum_helper(name: str):
"""Resolve a helper from the installed upstream H3 Continuum package."""
import sys
for module_name, module in list(sys.modules.items()):
if module is not None and module_name.endswith(".v3.second_pass"):
helper = getattr(module, name, None)
if helper is not None:
return helper
try:
import importlib
return getattr(importlib.import_module("v3.second_pass"), name)
except Exception as exc:
raise RuntimeError(
"DUMAS H3 per-clip upscale requires the original "
"ComfyUI-H3-Continuum second_pass module."
) from exc
def _native_node(name: str):
try:
import nodes
return (getattr(nodes, "NODE_CLASS_MAPPINGS", {}) or {}).get(name)
except Exception:
return None
def _unwrap_node_output(value: Any) -> Any:
"""Extract values returned by ComfyUI's newer NodeOutput API.
The v3 API wraps node results in ``NodeOutput`` while legacy nodes expect
the underlying tensor/object directly. Keep this adapter compatible with
both APIs without importing ComfyUI internals.
"""
result = getattr(value, "result", None)
if result is None and not hasattr(value, "result"):
return value
return result
def _unwrap_single_output(value: Any, name: str) -> Any:
marker = object()
result = getattr(value, "result", marker)
# Ordinary tuples are valid values for the lightweight test doubles and
# for some legacy ComfyUI helpers. Only unwrap an actual NodeOutput-like
# object, identified by its result property.
if result is marker:
return value
if isinstance(result, (tuple, list)):
if len(result) != 1:
raise ValueError(f"{name} returned {len(result)} outputs; expected one")
return result[0]
return result
def _call_native(node_class, kwargs: dict[str, Any]):
"""Invoke a ComfyUI node through its declared FUNCTION contract.
ComfyUI node classes do not have a universal Python method name. The live
MiniMax node currently declares its executor through ``FUNCTION`` rather
than exposing a method named ``upscale``.
"""
instance = node_class()
declared = getattr(node_class, "FUNCTION", None)
candidates = []
if isinstance(declared, str) and declared:
candidates.append(declared)
candidates.extend(("execute", "run", "process", "sample", "upscale"))
seen = set()
for name in candidates:
if name in seen:
continue
seen.add(name)
method = getattr(instance, name, None)
if callable(method):
return _unwrap_node_output(method(**kwargs))
raise RuntimeError(
"MMH3UltimateUpscale exposes no callable ComfyUI FUNCTION method "
f"(declared={declared!r})"
)
def _one(value: Any, name: str) -> Any:
"""Unwrap ComfyUI list inputs while rejecting ambiguous values."""
if isinstance(value, list):
if len(value) != 1:
raise ValueError(f"{name} must contain one shared value")
return value[0]
return value
def _clips(value: Any) -> list[Any]:
if isinstance(value, list):
return value
return [value]
def _per_clip(value: Any, count: int, name: str) -> list[Any]:
values = _clips(value)
if len(values) == 1:
return values * count
if len(values) != count:
raise ValueError(f"{name} has {len(values)} values for {count} clips")
return values
class DumasH3ContinuumTiledLatentUpscalePerClip:
"""Upscale each Continuum physical clip separately with tiled H3 latent work.
This is intentionally a thin adapter around ComfyUI's native
``MMH3UltimateUpscale`` implementation. It does not vendor or replace
the model-specific implementation; it only supplies an independent
sampler/scheduler/noise/CFG schedule for each clip and preserves list
boundaries so clips never become one oversized VRAM job.
"""
DESCRIPTION = (
"Apply native MiniMax H3 tiled latent upscaling independently to every "
"Continuum physical clip. Clips remain separate LATENT list items."
)
SEARCH_ALIASES = [
"H3 tiled upscale per clip",
"MiniMax H3 clip upscale",
"Continuum latent upscale",
]
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"model": ("MODEL",),
"clip": ("CLIP",),
"video_latents": ("LATENT",),
"assembly_plan": ("H3_CONTINUUM_ASSEMBLY_PLAN",),
"refine_context": ("H3_CONTINUUM_REFINE_CONTEXT",),
"latent_upscale_param": ("H3_UPSCALE_PARAM",),
"spatial_split_param": ("H3_SPATIAL_PARAM",),
"upscale_sampler": (
_sampler_options(),
{"default": "euler_ancestral"},
),
"upscale_scheduler": (
_scheduler_options(),
{"default": "simple"},
),
"upscale_steps": ("INT", {"default": 3, "min": 1, "max": 50}),
"upscale_denoise": (
"FLOAT",
{"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01},
),
"upscale_cfg": (
"FLOAT",
{"default": 1.0, "min": 0.0, "max": 20.0, "step": 0.1},
),
"upscale_noise_seed": (
"INT",
{
"default": 363742558835919,
"min": 0,
"max": 0xFFFFFFFFFFFFFFFF,
"control_after_generate": True,
},
),
},
"optional": {
"conditioning": ("CONDITIONING",),
"video_vae": ("VAE",),
"negative": ("CONDITIONING",),
"temporal_split_param": ("H3_TEMPORAL_PARAM",),
"upscale_sigmas": ("SIGMAS",),
},
}
INPUT_IS_LIST = True
RETURN_TYPES = ("LATENT", "STRING")
RETURN_NAMES = ("upscaled_video_latents", "report")
OUTPUT_IS_LIST = (True, False)
FUNCTION = "upscale"
CATEGORY = "Dumas/MiniMax H3/Upscale"
def upscale(
self,
model,
clip,
video_latents,
assembly_plan,
refine_context,
latent_upscale_param,
spatial_split_param,
upscale_sampler,
upscale_scheduler,
upscale_steps,
upscale_denoise,
upscale_cfg,
upscale_noise_seed,
conditioning=None,
video_vae=None,
negative=None,
temporal_split_param=None,
upscale_sigmas=None,
):
native = _native_node("MMH3UltimateUpscale")
random_noise = _native_node("RandomNoise")
sampler_select = _native_node("KSamplerSelect")
scheduler = _native_node("BasicScheduler")
missing = [
name
for name, value in (
("MMH3UltimateUpscale", native),
("RandomNoise", random_noise),
("KSamplerSelect", sampler_select),
("BasicScheduler", scheduler),
)
if value is None
]
if missing:
raise RuntimeError("Missing native ComfyUI nodes: " + ", ".join(missing))
latents = _clips(video_latents)
if not latents:
raise ValueError("video_latents must contain at least one clip")
if conditioning is None:
# The Continuum sampler's refine context is a runtime contract, not
# a Core CONDITIONING value. Reuse Continuum's own bridge so each
# physical clip receives its captured prompt/reference conditioning
# and its context-aware model clone at the target geometry.
prepare_physical_refine_groups = _continuum_helper("prepare_physical_refine_groups")
prepared = prepare_physical_refine_groups(
model=_one(model, "model"),
clip=_one(clip, "clip"),
video_latents=latents,
assembly_plan=_one(assembly_plan, "assembly_plan"),
refine_context=_one(refine_context, "refine_context"),
video_vae=(
None if video_vae is None else _one(video_vae, "video_vae")
),
)
models = prepared["group_models"]
conditionings = prepared["conditioning"]
if len(models) != len(latents) or len(conditionings) != len(latents):
raise ValueError(
"refine context bridge did not produce one model and conditioning "
"value per physical clip"
)
else:
models = _per_clip(model, len(latents), "model")
conditionings = _per_clip(conditioning, len(latents), "conditioning")
negatives = (
[None] * len(latents)
if negative is None
else _per_clip(negative, len(latents), "negative")
)
temporal = (
[None] * len(latents)
if temporal_split_param is None
else _per_clip(temporal_split_param, len(latents), "temporal_split_param")
)
sigma_values = (
[None] * len(latents)
if upscale_sigmas is None
else _per_clip(upscale_sigmas, len(latents), "upscale_sigmas")
)
sampler_name = str(_one(upscale_sampler, "upscale_sampler"))
scheduler_name = str(_one(upscale_scheduler, "upscale_scheduler"))
steps = int(_one(upscale_steps, "upscale_steps"))
denoise = float(_one(upscale_denoise, "upscale_denoise"))
cfg = float(_one(upscale_cfg, "upscale_cfg"))
seed = int(_one(upscale_noise_seed, "upscale_noise_seed"))
upscale_param = _one(latent_upscale_param, "latent_upscale_param")
spatial_param = _one(spatial_split_param, "spatial_split_param")
outputs = []
reports = []
for index, (clip_latent, clip_model, clip_conditioning) in enumerate(
zip(latents, models, conditionings), start=1
):
samples = clip_latent.get("samples") if isinstance(clip_latent, dict) else None
if samples is None or getattr(samples, "ndim", None) != 5:
raise ValueError(f"clip {index} is not a 5-D H3 LATENT")
noise = _unwrap_single_output(
random_noise().get_noise(seed + index - 1), "RandomNoise"
)
sampler = _unwrap_single_output(
sampler_select().get_sampler(sampler_name), "KSamplerSelect"
)
sigmas = sigma_values[index - 1]
if sigmas is None:
sigmas = _unwrap_single_output(
scheduler().get_sigmas(
clip_model, scheduler_name, steps, denoise
),
"BasicScheduler",
)
kwargs = {
"model": clip_model,
"conditioning": clip_conditioning,
"latent": clip_latent,
"noise": noise,
"sampler": sampler,
"sigmas": sigmas,
"cfg": cfg,
"latent_upscale_param": upscale_param,
"temporal_split_param": temporal[index - 1],
"spatial_split_param": spatial_param,
}
if negatives[index - 1] is not None:
kwargs["negative"] = negatives[index - 1]
result = _call_native(native, kwargs)
if not isinstance(result, (tuple, list)) or not result:
raise RuntimeError(f"native upscale returned no output for clip {index}")
output = result[0]
output_samples = output.get("samples") if isinstance(output, dict) else None
if output_samples is None or output_samples.ndim != 5:
raise RuntimeError(f"native upscale returned an invalid clip {index}")
if output_samples.shape[2] != samples.shape[2]:
raise RuntimeError(f"tiled upscale changed temporal length for clip {index}")
outputs.append(output)
reports.append(
f"clip {index}: {tuple(samples.shape)} -> {tuple(output_samples.shape)}"
)
return (
outputs,
"H3 Continuum per-clip tiled upscale; "
f"clips={len(outputs)}, sampler={sampler_name}, scheduler={scheduler_name}, "
f"steps={steps}, denoise={denoise:g}, cfg={cfg:g}, seed_base={seed}; "
+ "; ".join(reports),
)
NODE_CLASS_MAPPINGS = {
"DumasH3ContinuumTiledLatentUpscalePerClip": DumasH3ContinuumTiledLatentUpscalePerClip,
}
NODE_DISPLAY_NAME_MAPPINGS = {
"DumasH3ContinuumTiledLatentUpscalePerClip": (
"DUMAS H3 Continuum Tiled Latent Upscale (Per Clip)"
),
}
+2 -2
View File
@@ -71,7 +71,7 @@ class DumasMMH3TiledLatentUpscale:
RETURN_TYPES = ("LATENT", "STRING") RETURN_TYPES = ("LATENT", "STRING")
RETURN_NAMES = ("upscaled_latent", "info") RETURN_NAMES = ("upscaled_latent", "info")
FUNCTION = "upscale" FUNCTION = "upscale"
CATEGORY = "Dumas/MiniMax" CATEGORY = "Dumas/MiniMax H3/Upscale"
def upscale( def upscale(
self, model, conditioning, latent, latent_upscale_param, self, model, conditioning, latent, latent_upscale_param,
@@ -146,5 +146,5 @@ NODE_CLASS_MAPPINGS = {
} }
NODE_DISPLAY_NAME_MAPPINGS = { NODE_DISPLAY_NAME_MAPPINGS = {
"DumasMMH3TiledLatentUpscale": "Dumas MiniMax-H3 Tiled Latent Upscale", "DumasMMH3TiledLatentUpscale": "DUMAS MiniMax-H3 Tiled Latent Upscale",
} }
+657
View File
@@ -0,0 +1,657 @@
import { app } from "../../scripts/app.js";
const CLASS = "DumasH3SequencePromptBuilder";
const MAX_CLIPS = 16;
const FIXED_TEXT_WIDGETS = [
["shared_directive", 84],
["soundscape", 60],
["music", 60],
];
const DURATION_OPTIONS = [
["1–5", 5, 2, 0.21], ["6–22", 22, 7, 0.92], ["23–39", 39, 12, 1.63],
["40–56", 56, 17, 2.33], ["57–73", 73, 22, 3.04], ["74–90", 90, 27, 3.75],
["91–107", 107, 32, 4.46], ["108–124", 124, 37, 5.17], ["125–141", 141, 42, 5.88],
["142–158", 158, 47, 6.58], ["159–175", 175, 52, 7.29], ["176–192", 192, 57, 8.00],
["193–209", 209, 62, 8.71], ["210–226", 226, 67, 9.42], ["227–243", 243, 72, 10.13],
["244–260", 260, 77, 10.83], ["261–277", 277, 82, 11.54], ["278–294", 294, 87, 12.25],
["295–311", 311, 92, 12.96], ["312–328", 328, 97, 13.67], ["329–345", 345, 102, 14.38],
["346–362", 362, 107, 15.08],
].map(([requested, actual, latent, labelSeconds]) => ({
requested, actual, latent, labelSeconds, seconds: actual / 24,
}));
const CAMERA_HELPERS = [
["Push / Pull", ["The camera pushes in", "The camera pulls out"]],
["Zoom", ["The camera zooms in", "The camera zooms out"]],
["Pan", ["The camera pans left", "The camera pans right"]],
["Truck", ["The camera trucks left", "The camera trucks right"]],
["Tilt", ["The camera tilts up", "The camera tilts down"]],
["Pedestal", ["The camera pedestals up", "The camera pedestals down"]],
["Movement", ["The camera holds a static shot", "The camera arcs around the subject", "The camera tracks the subject"]],
["POV", ["The camera holds the subject's point of view"]],
["Roll", ["The camera rolls clockwise", "The camera rolls counterclockwise"]],
["Shake", ["The camera shakes slightly", "The camera shakes strongly"]],
];
const get = (node, name) => node.widgets?.find((widget) => widget.name === name);
const el = (tag, text = "") => { const item = document.createElement(tag); item.textContent = text; return item; };
function defaultState(count, seconds) {
return { version: 1, clips: Array.from({ length: count }, () => ({
duration: seconds, slots: [{ start: 0, end: seconds, text: "" }], prompt: "",
})) };
}
function readState(widget, count, seconds) {
try {
const value = JSON.parse(String(widget?.value || ""));
if (Array.isArray(value.clips)) return value;
} catch (_) { /* replace malformed editor state with a usable default */ }
return defaultState(count, seconds);
}
function hide(widget) {
if (!widget) return;
widget.type = "hidden"; widget.hidden = true; widget.options ||= {};
widget.options.hidden = true; widget.computeSize = () => [0, 0]; widget.draw = () => {};
}
function configure(node) {
if (node?.comfyClass !== CLASS || typeof document === "undefined" || typeof node.addDOMWidget !== "function") return;
if (node.__dumasSequencePromptBuilder) return node.__dumasSequencePromptBuilder();
const countWidget = get(node, "clip_count");
const secondsWidget = get(node, "default_chunk_seconds");
const stateWidget = get(node, "timeline_json");
if (!countWidget || !secondsWidget || !stateWidget) return;
hide(secondsWidget);
hide(stateWidget);
FIXED_TEXT_WIDGETS.forEach(([name, height]) => {
const widget = get(node, name);
if (!widget) return;
widget.options ||= {};
widget.options.multiline = true;
widget.__dumasFixedHeight = height;
widget.computeSize = (width) => [
Math.max(300, Number(width) || Number(node.size?.[0]) || 420),
height,
];
});
const panel = el("div");
panel.style.cssText = "box-sizing:border-box;position:relative;width:calc(100% + 14px);margin-left:-7px;min-width:420px;padding:9px;color:#d9e3dc;background:#292929;border:1px solid #454545;border-radius:4px;font:12px Arial;pointer-events:auto";
const host = el("div"); host.style.cssText = "box-sizing:border-box;pointer-events:auto;background:#292929;width:100%"; host.append(panel);
["pointerdown", "mousedown", "mouseup", "dblclick"].forEach((name) => host.addEventListener(name, (event) => event.stopPropagation()));
const display = node.addDOMWidget("clip_tabs", "dumas_h3_clip_tabs", host, { serialize: false });
if (!node.__dumasSequenceResizeWrapped) {
const previousResize = node.onResize;
node.onResize = function (size) {
if (this.__dumasSequenceMinHeight > 0 && size[1] < this.__dumasSequenceMinHeight) {
size[1] = this.__dumasSequenceMinHeight;
}
return previousResize?.apply(this, arguments);
};
node.__dumasSequenceResizeWrapped = true;
}
display.options ||= {}; display.options.serialize = false;
let active = 0;
let state = readState(stateWidget, Number(countWidget.value) || 2, Number(secondsWidget.value) || 4);
let promptText = null;
// Writing the hidden widget value is safe while a textarea owns focus.
// Calling its callback is not: ComfyUI callbacks redraw the DOM widget,
// which destroys the focused textarea during blur/pointer transitions.
const persistState = () => {
stateWidget.value = JSON.stringify(state);
node.setDirtyCanvas?.(true, true);
};
const setState = () => {
persistState();
stateWidget.callback?.(stateWidget.value);
};
const input = (type, value, onChange) => {
const item = el("input"); item.type = type; item.value = value;
item.style.cssText = type === "range"
? "width:100%;box-sizing:border-box;margin:2px 0;accent-color:#79c98a"
: "width:100%;box-sizing:border-box;margin:2px 0;color:#111";
item.onchange = () => onChange(item.value); return item;
};
const addSlot = (clip, afterIndex = clip.slots.length - 1) => {
const duration = Number(clip.duration) || 0.1;
if (!clip.slots.length) {
clip.slots.push({ start: 0, end: duration, text: "" });
return;
}
const newCount = clip.slots.length + 1;
// Keep a minimum only when the selected duration allows it. The old
// fixed 0.1s floor made later shots collapse at short frame choices.
const minSlice = Math.min(0.1, duration / newCount);
let splitIndex = Math.max(0, Math.min(afterIndex, clip.slots.length - 1));
const lengthOf = (slot) => Math.max(0, Number(slot.end) - Number(slot.start));
if (lengthOf(clip.slots[splitIndex]) < minSlice * 2) {
splitIndex = clip.slots.reduce(
(best, slot, index) => lengthOf(slot) > lengthOf(clip.slots[best]) ? index : best,
0,
);
}
const target = clip.slots[splitIndex];
const start = Number(target?.start) || 0;
const end = Math.min(duration, Number(target?.end) || duration);
let split = start + (end - start) / 2;
split = Math.max(start + minSlice, Math.min(end - minSlice, split));
if (!(split > start && split < end)) {
// This is only reachable for malformed or extremely short state;
// redistribute boundaries evenly so the new shot is still real.
const texts = clip.slots.map((slot) => slot.text || "");
texts.splice(splitIndex + 1, 0, "");
clip.slots = texts.map((text, index) => ({
start: duration * index / newCount,
end: duration * (index + 1) / newCount,
text,
}));
return;
}
target.end = split;
clip.slots.splice(splitIndex + 1, 0, { start: split, end, text: "" });
};
const formatTime = (seconds) => `00:${Number(seconds).toFixed(3).padStart(6, "0")}`;
// Keep the user's script as the source of truth, like CSGlide does. The
// slots are only the timeline model used to paint the bar and to locate
// boundaries. Rebuilding the textarea from slots is lossy (and was the
// reason a redraw could erase text that had just been typed).
const formatPromptFromSlots = (clip) => clip.slots.map((slot, index) =>
`[Shot ${index + 1}] At ${formatTime(slot.start)}, ${slot.text || ""}`).join("\n\n");
const promptFor = (clip) => {
if (typeof clip.prompt === "string" && clip.prompt.length) return clip.prompt;
return formatPromptFromSlots(clip);
};
const parseTime = (value) => {
const parts = String(value || "").split(":").map(Number);
if (parts.some((part) => !Number.isFinite(part))) return NaN;
if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
if (parts.length === 2) return parts[0] * 60 + parts[1];
return parts[0];
};
const parsePromptSlots = (clip, value) => {
const text = String(value || "");
const markerPattern = /\[Shot\s+\d+\]\s+At\s+((?:\d+(?::\d+){1,2}(?:\.\d+)?|\d+(?:\.\d+)?))\s*,\s*/gi;
const markers = [...text.matchAll(markerPattern)];
if (!markers.length) return false;
const duration = Math.max(0.1, Number(clip.duration) || 0.1);
const slots = markers.map((marker, index) => {
const rawStart = parseTime(marker[1]);
const start = Number.isFinite(rawStart)
? Math.min(Math.max(0, rawStart), Math.max(0, duration - 0.1))
: 0;
const next = markers[index + 1];
const rawEnd = next ? parseTime(next[1]) : duration;
const end = Math.min(duration, Math.max(start + 0.1, Number.isFinite(rawEnd) ? rawEnd : duration));
const from = marker.index + marker[0].length;
const to = next ? next.index : text.length;
return { start, end, text: text.slice(from, to).trim() };
});
slots.forEach((slot, index) => {
if (index > 0) slot.start = slots[index - 1].end;
if (slot.end <= slot.start) slot.end = Math.min(duration, slot.start + 0.1);
});
slots[slots.length - 1].end = duration;
clip.slots = slots;
return true;
};
const syncPrompt = (clip, value) => {
const text = String(value || "");
if (parsePromptSlots(clip, text)) return true;
// The shot description starts on the same line as the marker in the
// CSGlide-style editor. Only consume the marker prefix through its
// timestamp comma; consuming the whole line would discard text such
// as `[Shot 1] At 00:00.000, the character walks...` when a new shot
// is added and the marker scaffold is rebuilt.
const marks = [...text.matchAll(/\[Shot\s+(\d+)\]\s+At\s+[^,\n]+,\s*/gi)];
if (!marks.length) { if (clip.slots[0]) clip.slots[0].text = text.trim(); return; }
marks.forEach((mark, index) => {
const slotIndex = Number(mark[1]) - 1;
if (!clip.slots[slotIndex]) return;
const from = mark.index + mark[0].length;
const to = index + 1 < marks.length ? marks[index + 1].index : text.length;
clip.slots[slotIndex].text = text.slice(from, to).trim();
});
return false;
};
const retimePrompt = (text, clip) => {
let index = 0;
return String(text || "").replace(/(\[Shot\s+\d+\]\s+At\s+)[^,\n]+(,?)/gi, (whole, prefix, suffix) => {
const start = clip.slots[index++]?.start ?? 0;
return `${prefix}${formatTime(start)}${suffix}`;
});
};
const commitPrompt = (clip, value, redraw = false) => {
clip.prompt = String(value ?? "");
syncPrompt(clip, clip.prompt);
// Do not invoke the widget callback for ordinary text edits. The
// callback redraws the DOM and can run while the textarea is blurring
// to a timeline handle, exactly the interaction CSGlide avoids.
persistState();
if (redraw) render();
};
const rebuildPromptAfterStructureChange = (clip) => {
// The caller syncs the current text before changing the slot list.
// Do not parse clip.prompt again here: after adding a shot it still
// has the old marker count, and reparsing would discard the new slot.
clip.prompt = formatPromptFromSlots(clip);
};
const render = () => {
const count = Math.max(1, Math.min(MAX_CLIPS, Number(countWidget.value) || 1));
const currentSeconds = Number(secondsWidget.value) || DURATION_OPTIONS[6].seconds;
const selectedDuration = DURATION_OPTIONS.reduce((best, option) =>
Math.abs(option.seconds - currentSeconds) < Math.abs(best.seconds - currentSeconds) ? option : best,
DURATION_OPTIONS[6]);
if (Number(secondsWidget.value) !== selectedDuration.seconds) secondsWidget.value = selectedDuration.seconds;
const chunkDuration = selectedDuration.seconds;
while (state.clips.length < count) state.clips.push({ duration: chunkDuration, slots: [] });
state.clips = state.clips.slice(0, count); active = Math.min(active, count - 1);
panel.replaceChildren();
const tabs = el("div"); tabs.style.cssText = "display:flex;flex-wrap:wrap;gap:4px;margin-bottom:8px;border-bottom:1px solid #444;padding-bottom:6px";
state.clips.forEach((clip, index) => {
const button = el("button", `Clip ${index + 1}`); button.type = "button"; button.disabled = index === active;
button.style.cssText = `padding:3px 10px;border:1px solid ${index === active ? "#8bc99b" : "#555"};border-radius:3px;background:${index === active ? "#4b6f55" : "#333"};color:${index === active ? "#fff" : "#bbb"};cursor:pointer`;
button.onclick = () => { active = index; render(); }; tabs.append(button);
});
panel.append(tabs);
const clip = state.clips[active];
// All clips share the one authoritative project duration widget.
const duration = chunkDuration;
clip.duration = duration;
if (clip.slots.length) clip.slots[clip.slots.length - 1].end = duration;
promptText = promptFor(clip);
const durationControl = el("div");
durationControl.style.cssText = "display:flex;align-items:center;gap:8px;margin:0 0 8px;color:#b7d6bf";
const durationLabel = el("span", "Chunk duration / frame choice");
durationLabel.style.cssText = "font-weight:bold;white-space:nowrap";
const durationSelect = document.createElement("select");
durationSelect.style.cssText = "flex:1;min-width:0;box-sizing:border-box;padding:4px 6px;color:#e8e8e8;background:#171717;border:1px solid #596b60;border-radius:4px;font:11px monospace";
DURATION_OPTIONS.forEach((option) => {
const item = document.createElement("option");
item.value = String(option.seconds);
item.textContent = `${option.actual} Real Frames - ${option.latent} Latent Frames - ${option.labelSeconds.toFixed(2)}s`;
item.selected = option === selectedDuration;
durationSelect.append(item);
});
durationSelect.title = "Choose a native H3 frame length; actual frames are encoded from the latent-frame choice.";
durationSelect.onchange = () => {
secondsWidget.value = Number(durationSelect.value);
secondsWidget.callback?.(secondsWidget.value);
};
durationControl.append(durationLabel, durationSelect);
panel.append(durationControl);
const durationRow = el("div"); durationRow.style.cssText = "display:flex;align-items:center;gap:8px;margin:4px 0 6px;color:#b7d6bf";
durationRow.append(el("strong", `Clip ${active + 1}`), el("span", `· ${selectedDuration.actual} actual frames · ${selectedDuration.latent} latent frames · ${selectedDuration.labelSeconds.toFixed(2)}s shared chunk duration`)); panel.append(durationRow);
const timeline = el("div"); timeline.style.cssText = "position:relative;height:38px;margin:8px 0 4px;background:#171717;border-radius:4px;overflow:hidden;border:1px solid #555";
const palette = ["#4b9b67", "#4d7fb1", "#a87945", "#8c5aa8", "#a44f5d", "#3f8e8a"];
let prompt = null;
let promptSelectionStart = 0;
let promptSelectionEnd = 0;
let autocomplete = null;
let autocompleteRange = null;
let promptFrame = null;
let suggestionLayer = null;
let encoder = null;
const focusPrompt = () => {
if (!prompt) return;
try {
prompt.focus({ preventScroll: true });
} catch (_) {
prompt.focus();
}
};
const segments = [];
const handles = [];
const updateTimeline = () => {
clip.slots.forEach((slot, index) => {
const left = Math.max(0, Number(slot.start) / duration * 100);
const width = Math.max(0.1, (Number(slot.end) - Number(slot.start)) / duration * 100);
segments[index].style.left = `${left}%`;
segments[index].style.width = `${width}%`;
segments[index].title = `${Number(slot.start).toFixed(1)}s–${Number(slot.end).toFixed(1)}s`;
});
handles.forEach(({ handle, slot }) => { handle.style.left = `${Number(slot.end) / duration * 100}%`; });
};
clip.slots.forEach((slot, index) => {
const segment = el("button", `Shot ${index + 1}\n${(slot.text || "unscripted").slice(0, 18)}`); segment.type = "button";
segment.style.cssText = `position:absolute;top:0;height:100%;border:0;border-right:2px solid #292929;color:white;background:${palette[index % palette.length]};white-space:pre-wrap;font-size:10px;overflow:hidden;padding:2px;cursor:pointer`;
segment.onclick = (event) => {
event.preventDefault(); event.stopPropagation();
focusPrompt();
}; segments.push(segment); timeline.append(segment);
});
clip.slots.slice(0, -1).forEach((slot, index) => {
const next = clip.slots[index + 1];
const handle = el("div"); handle.title = `Resize boundary between Shot ${index + 1} and Shot ${index + 2}`;
handle.style.cssText = "position:absolute;top:0;width:17px;height:100%;transform:translateX(-50%);background:transparent;border:0;border-radius:3px;cursor:ew-resize;z-index:5;box-sizing:border-box;touch-action:none";
const ink = el("div");
ink.style.cssText = "position:absolute;left:7px;top:0;width:2px;height:100%;background:#f1f7f2;border:0;border-radius:1px;pointer-events:none";
handle.append(ink);
const move = (event) => {
event.preventDefault(); event.stopPropagation();
const rect = timeline.getBoundingClientRect();
const point = Math.min(duration - 0.1, Math.max(0.1, ((event.clientX - rect.left) / rect.width) * duration));
slot.end = point; next.start = point; updateTimeline();
};
let dragging = false;
const finish = (event) => {
if (!dragging) return;
dragging = false;
event?.preventDefault?.(); event?.stopPropagation?.();
document.removeEventListener("pointermove", move, true);
window.removeEventListener("pointerup", finish, true);
document.removeEventListener("mousemove", moveMouse, true);
document.removeEventListener("mouseup", finish, true);
promptText = retimePrompt(promptText ?? prompt?.value ?? clip.prompt ?? "", clip);
commitPrompt(clip, promptText);
// The timeline is already updated in place. Avoid rebuilding
// the panel, which moves the textarea and canvas viewport.
if (prompt) prompt.value = promptText;
if (encoder) encoder.textContent = clip.slots
.map((item, itemIndex) => `Shot ${itemIndex + 1} ${formatTime(item.start)}`)
.join(" ");
};
const moveMouse = (event) => { if (dragging) move(event); };
handle.onpointerdown = (event) => {
event.preventDefault();
event.stopPropagation();
dragging = true;
// Textarea edits are intentionally committed on change, but a
// drag can happen while it still has focus. Capture them before
// the timeline redraws the prompt from state.
if (prompt) { promptText = prompt.value; clip.prompt = promptText; }
handle.setPointerCapture?.(event.pointerId);
document.addEventListener("pointermove", move, true);
window.addEventListener("pointerup", finish, true);
document.addEventListener("mousemove", moveMouse, true);
document.addEventListener("mouseup", finish, true);
};
handles.push({ handle, slot }); timeline.append(handle);
});
updateTimeline();
panel.append(timeline);
const sliderHint = el("div", "Drag the white handles to resize shots. The bar represents the complete chunk duration."); sliderHint.style.cssText = "color:#aab6ad;margin-bottom:6px;font-size:11px"; panel.append(sliderHint);
const shotChips = el("div"); shotChips.style.cssText = "display:flex;gap:4px;overflow:hidden;margin:3px 0 5px";
clip.slots.forEach((slot, index) => {
const chipText = (slot.text || `Shot ${index + 1}`).replace(/\s+/g, " ").trim().slice(0, 31);
const chip = el("button", chipText || `Shot ${index + 1}`); chip.type = "button";
chip.title = `Jump to Shot ${index + 1}`;
chip.style.cssText = `max-width:180px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:3px 8px;border:1px solid ${palette[index % palette.length]};border-radius:4px;background:#1e1e1e;color:#e6e6e6;font:11px Arial;cursor:pointer`;
chip.onclick = (event) => {
event.preventDefault(); event.stopPropagation();
if (!prompt) return;
const marker = `[Shot ${index + 1}]`;
const position = prompt.value.indexOf(marker);
focusPrompt();
if (position >= 0) prompt.setSelectionRange(position, position + marker.length);
};
shotChips.append(chip);
});
panel.append(shotChips);
const referenceRow = el("div"); referenceRow.style.cssText = "display:flex;gap:8px;overflow:hidden;margin:7px 0 8px;align-items:center;flex-wrap:wrap";
const connectedReferences = Array.from({ length: 9 }, (_, offset) => offset + 1)
.filter((index) => node.inputs?.some((input) => input.name === `reference_image_${index}` && input.link != null));
if (connectedReferences.length) {
connectedReferences.forEach((index) => {
const button = el("button"); button.type = "button";
button.title = `Insert reference image ${index} as @image${index}`;
button.style.cssText = "display:inline-flex;align-items:center;gap:7px;height:31px;padding:2px 11px 2px 3px;border:2px solid #49c9f5;border-radius:18px;background:#202b31;color:#70d8ff;font:16px monospace;cursor:pointer;white-space:nowrap";
const thumbnail = document.createElement("img");
thumbnail.alt = ""; thumbnail.draggable = false;
thumbnail.style.cssText = "width:25px;height:25px;object-fit:cover;border-radius:50%;background:#68727a;display:block";
const linkId = node.inputs?.find((input) => input.name === `reference_image_${index}`)?.link;
const link = linkId == null ? null : (app.graph?.links?.get?.(linkId) ?? app.graph?.links?.[linkId]);
const source = link?.origin_id == null ? null : app.graph?.getNodeById?.(link.origin_id);
const imageWidget = source?.widgets?.find((widget) => ["image", "filename", "file"].includes(widget.name));
const imageValue = imageWidget?.value;
if (imageValue && typeof imageValue === "object" && imageValue.filename) {
const params = new URLSearchParams({ filename: imageValue.filename, type: imageValue.type || "input", subfolder: imageValue.subfolder || "" });
thumbnail.src = `/view?${params.toString()}`;
} else if (typeof imageValue === "string" && imageValue) {
const params = new URLSearchParams({ filename: imageValue, type: "input", subfolder: "" });
thumbnail.src = `/view?${params.toString()}`;
} else {
thumbnail.src = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='25' height='25' viewBox='0 0 25 25'%3E%3Crect width='25' height='25' fill='%2368727a'/%3E%3Cpath d='M4 19l5-6 3 3 3-4 6 7' fill='none' stroke='%23dce8ed' stroke-width='2'/%3E%3Ccircle cx='17' cy='8' r='2' fill='%23dce8ed'/%3E%3C/svg%3E";
}
thumbnail.onerror = () => { thumbnail.style.opacity = "0.35"; };
button.append(thumbnail, el("span", `@image${index}`));
const rememberPromptSelection = () => {
if (!prompt) return;
promptSelectionStart = prompt.selectionStart ?? prompt.value.length;
promptSelectionEnd = prompt.selectionEnd ?? promptSelectionStart;
};
button.onpointerdown = (event) => {
rememberPromptSelection();
event.preventDefault();
event.stopPropagation();
};
button.onmousedown = (event) => {
event.preventDefault();
event.stopPropagation();
};
button.onclick = (event) => {
event.preventDefault(); event.stopPropagation();
if (!prompt) return;
const start = Math.min(promptSelectionStart, prompt.value.length);
const end = Math.min(Math.max(start, promptSelectionEnd), prompt.value.length);
const token = `@R${index} `;
prompt.value = prompt.value.slice(0, start) + token + prompt.value.slice(end);
const caret = start + token.length;
focusPrompt(); prompt.setSelectionRange(caret, caret);
promptSelectionStart = caret; promptSelectionEnd = caret;
promptText = prompt.value; clip.prompt = prompt.value;
syncPrompt(clip, clip.prompt); persistState();
};
referenceRow.append(button);
});
}
panel.append(referenceRow);
const promptLabel = el("div", "PROMPT SCRIPT"); promptLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:4px 0 3px"; panel.append(promptLabel);
prompt = el("textarea"); prompt.rows = 10; prompt.value = promptText; prompt.placeholder = "[Shot 1] At 00:00.000, describe the opening action...\n\nType @ at the start of a new line to add the next shot."; prompt.style.cssText = "width:100%;box-sizing:border-box;color:#e8e8e8;background:#171717;border:1px solid #4e4e4e;border-radius:4px;padding:8px;font:12px/1.45 monospace;margin-top:2px;resize:vertical;outline:none";
const rememberPromptSelection = () => {
promptSelectionStart = prompt.selectionStart ?? prompt.value.length;
promptSelectionEnd = prompt.selectionEnd ?? promptSelectionStart;
};
const closeAutocomplete = () => {
autocomplete?.remove();
autocomplete = null;
autocompleteRange = null;
};
const sourceThumbnail = (index) => {
const thumbnail = document.createElement("img");
thumbnail.alt = ""; thumbnail.draggable = false;
thumbnail.style.cssText = "width:24px;height:24px;object-fit:cover;border-radius:50%;background:#68727a;display:block;flex:none";
const linkId = node.inputs?.find((input) => input.name === `reference_image_${index}`)?.link;
const link = linkId == null ? null : (app.graph?.links?.get?.(linkId) ?? app.graph?.links?.[linkId]);
const source = link?.origin_id == null ? null : app.graph?.getNodeById?.(link.origin_id);
const imageWidget = source?.widgets?.find((widget) => ["image", "filename", "file"].includes(widget.name));
const imageValue = imageWidget?.value;
if (imageValue && typeof imageValue === "object" && imageValue.filename) {
const params = new URLSearchParams({ filename: imageValue.filename, type: imageValue.type || "input", subfolder: imageValue.subfolder || "" });
thumbnail.src = `/view?${params.toString()}`;
} else if (typeof imageValue === "string" && imageValue) {
const params = new URLSearchParams({ filename: imageValue, type: "input", subfolder: "" });
thumbnail.src = `/view?${params.toString()}`;
}
thumbnail.onerror = () => { thumbnail.style.opacity = "0.35"; };
return thumbnail;
};
const openAutocomplete = (at) => {
closeAutocomplete();
autocompleteRange = { start: at, end: at + 1 };
const menu = el("div");
menu.style.cssText = "display:block;visibility:visible;opacity:1;position:absolute;z-index:100;left:4px;min-width:220px;max-width:310px;padding:5px;background:#25282b;border:1px solid #4b5960;border-radius:8px;box-shadow:0 8px 24px #000b;color:#e7edf0;pointer-events:auto";
menu.style.top = "0px";
const connected = Array.from({ length: 9 }, (_, offset) => offset + 1)
.filter((index) => node.inputs?.some((input) => input.name === `reference_image_${index}` && input.link != null));
const addOption = (content, title, action) => {
const option = el("button"); option.type = "button"; option.title = title;
option.style.cssText = "display:flex;align-items:center;gap:9px;width:100%;padding:6px 8px;border:0;border-radius:5px;background:transparent;color:#e7edf0;text-align:left;font:12px monospace;cursor:pointer";
option.onpointerdown = (event) => { event.preventDefault(); event.stopPropagation(); };
option.onmouseenter = () => { option.style.background = "#3b5661"; };
option.onmouseleave = () => { option.style.background = "transparent"; };
option.onclick = (event) => { event.preventDefault(); event.stopPropagation(); action(); };
option.append(...content); menu.append(option);
};
connected.forEach((index) => addOption([
sourceThumbnail(index),
el("span", `@image${index}`),
(() => { const hint = el("span", `<Picture ${index}>`); hint.style.cssText = "margin-left:auto;color:#84939a;font-size:10px"; return hint; })(),
], `Insert @R${index}`, () => {
const start = autocompleteRange?.start ?? prompt.value.length;
const end = autocompleteRange?.end ?? start;
const token = `@R${index} `;
prompt.value = prompt.value.slice(0, start) + token + prompt.value.slice(end);
const caret = start + token.length;
focusPrompt(); prompt.setSelectionRange(caret, caret);
promptSelectionStart = caret; promptSelectionEnd = caret;
promptText = prompt.value; clip.prompt = prompt.value;
syncPrompt(clip, clip.prompt); persistState(); closeAutocomplete();
}));
addOption([
(() => { const icon = el("span", "S"); icon.style.cssText = "display:grid;place-items:center;width:24px;height:24px;border-radius:50%;background:#397a91;color:#dff7ff;font-weight:bold"; return icon; })(),
el("span", "[Shot " + (clip.slots.length + 1) + "]"),
(() => { const hint = el("span", "new shot"); hint.style.cssText = "margin-left:auto;color:#84939a;font-size:10px"; return hint; })(),
], "Create the next timed shot", () => {
const start = autocompleteRange?.start ?? prompt.value.length;
prompt.value = prompt.value.slice(0, start) + prompt.value.slice(start + 1);
promptText = prompt.value; clip.prompt = prompt.value;
syncPrompt(clip, clip.prompt); addSlot(clip); rebuildPromptAfterStructureChange(clip);
closeAutocomplete(); setState(); render();
});
panel.append(menu);
menu.style.left = `${Math.max(5, (suggestionLayer?.offsetLeft || 0) + 4)}px`;
menu.style.top = `${Math.max(5, suggestionLayer?.offsetTop || 0)}px`;
autocomplete = menu;
};
prompt.oninput = () => { rememberPromptSelection(); promptText = prompt.value; clip.prompt = prompt.value; };
prompt.onpaste = () => {
// Let the browser insert the pasted text first, then parse its
// shot markers and redraw the track without losing the paste.
setTimeout(() => {
const changed = syncPrompt(clip, prompt.value);
promptText = prompt.value;
clip.prompt = prompt.value;
persistState();
if (changed) render();
}, 0);
};
prompt.onselect = rememberPromptSelection;
prompt.onkeyup = rememberPromptSelection;
prompt.onmouseup = rememberPromptSelection;
prompt.onblur = () => { rememberPromptSelection(); clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); persistState(); };
prompt.onchange = () => { commitPrompt(clip, prompt.value); };
prompt.onpointerdown = (event) => event.stopPropagation();
prompt.onkeydown = (event) => {
if (event.key !== "@") return;
event.preventDefault();
const start = prompt.selectionStart ?? prompt.value.length;
const end = prompt.selectionEnd ?? start;
prompt.value = prompt.value.slice(0, start) + "@" + prompt.value.slice(end);
prompt.setSelectionRange(start + 1, start + 1);
promptSelectionStart = start;
promptSelectionEnd = start + 1;
promptText = prompt.value; clip.prompt = prompt.value;
syncPrompt(clip, clip.prompt); persistState();
openAutocomplete(start);
};
promptFrame = el("div");
promptFrame.style.cssText = "position:relative;overflow:visible;width:100%;box-sizing:border-box";
suggestionLayer = el("div");
suggestionLayer.style.cssText = "position:relative;z-index:100;height:0;width:100%;pointer-events:none;overflow:visible";
promptFrame.append(prompt);
panel.append(suggestionLayer);
panel.append(promptFrame);
promptSelectionStart = prompt.value.length;
promptSelectionEnd = prompt.value.length;
const insertPromptText = (text) => {
if (!prompt) return;
const start = Math.min(promptSelectionStart, prompt.value.length);
const end = Math.min(Math.max(start, promptSelectionEnd), prompt.value.length);
const before = prompt.value.slice(0, start);
const after = prompt.value.slice(end);
const prefix = before && !/\s$/.test(before) ? " " : "";
const token = `${prefix}${text} `;
prompt.value = before + token + after;
const caret = before.length + token.length;
focusPrompt(); prompt.setSelectionRange(caret, caret);
promptSelectionStart = caret; promptSelectionEnd = caret;
promptText = prompt.value; clip.prompt = prompt.value;
syncPrompt(clip, clip.prompt); persistState();
};
const helperPanel = el("div");
helperPanel.style.cssText = "display:flex;flex-wrap:wrap;gap:4px;align-items:center;margin:5px 0 7px;padding:5px 6px;background:#202020;border:1px solid #414141;border-radius:4px";
const helperTitle = el("span", "CAMERA HELPERS");
helperTitle.style.cssText = "width:100%;color:#8fa898;font-size:10px;letter-spacing:.08em;margin-bottom:1px";
helperPanel.append(helperTitle);
CAMERA_HELPERS.forEach(([category, phrases]) => phrases.forEach((phrase) => {
const button = el("button", phrase.replace(/^The camera /, ""));
button.type = "button";
button.title = `${category}: insert \"${phrase}\"`;
button.style.cssText = "padding:3px 7px;border:1px solid #596b60;border-radius:4px;background:#2b3b31;color:#b9e6c4;font:11px Arial;cursor:pointer;white-space:nowrap";
button.onpointerdown = (event) => { event.preventDefault(); event.stopPropagation(); };
button.onmousedown = (event) => { event.preventDefault(); event.stopPropagation(); };
button.onclick = (event) => { event.preventDefault(); event.stopPropagation(); insertPromptText(phrase); };
helperPanel.append(button);
}));
panel.insertBefore(helperPanel, promptFrame);
const checkLabel = el("div", "PROMPT CHECK"); checkLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:7px 0 3px"; panel.append(checkLabel);
const check = el("div", `${clip.slots.length} shot${clip.slots.length === 1 ? "" : "s"} · ${duration.toFixed(1)}s chunk · @ references preserved`); check.style.cssText = "padding:6px 8px;background:#171717;border:1px solid #444;border-radius:4px;color:#9bd0a8;font:11px monospace"; panel.append(check);
const encoderLabel = el("div", "SENT TO ENCODER AS"); encoderLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:7px 0 3px"; panel.append(encoderLabel);
encoder = el("div", clip.slots.map((slot, index) => `Shot ${index + 1} ${formatTime(slot.start)}`).join(" ")); encoder.style.cssText = "padding:6px 8px;background:#171717;border:1px solid #444;border-radius:4px;color:#7cc4d5;font:11px monospace;white-space:nowrap;overflow:hidden;text-overflow:ellipsis"; panel.append(encoder);
const actions = el("div"); actions.style.cssText = "display:flex;gap:5px;margin-top:5px";
const add = el("button", "@ Add shot"); add.type = "button"; add.onclick = () => { clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); addSlot(clip); rebuildPromptAfterStructureChange(clip); setState(); render(); }; actions.append(add);
if (clip.slots.length > 1) { const remove = el("button", "Remove last shot"); remove.type = "button"; remove.onclick = () => { clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); clip.slots.pop(); clip.slots.at(-1).end = clip.duration; rebuildPromptAfterStructureChange(clip); setState(); render(); }; actions.append(remove); }
panel.append(actions);
// The editor now contains chips, the prompt check and encoder summary;
// the old slot-count estimate left a large blank tail in the node.
// Measure the actual DOM panel instead of guessing from slot count.
const measuredHeight = Math.ceil(panel.getBoundingClientRect().height || panel.scrollHeight || 0);
display.computeSize = (width) => [Math.max(420, Number(width) || 420), measuredHeight + 2];
// CSGlide keeps the DOM panel floating but stores a node-level floor
// from measured content. Temporarily hide this widget from the
// ordinary LiteGraph calculation to get the non-panel chrome, then
// add the real panel height and clamp future manual resizes.
const realComputeSize = display.computeSize;
display.computeSize = () => [420, 0];
const chromeHeight = Number(node.computeSize?.()[1]) || 0;
display.computeSize = realComputeSize;
const width = Math.max(420, Number(node.size?.[0]) || 420);
const desiredHeight = chromeHeight + measuredHeight + 2;
node.__dumasSequenceMinHeight = desiredHeight;
if (typeof node.setSize === "function"
&& (Number(node.size?.[0]) !== width || Number(node.size?.[1]) < desiredHeight)) {
node.setSize([width, desiredHeight]);
}
};
const refresh = () => { state = readState(stateWidget, Number(countWidget.value) || 2, Number(secondsWidget.value) || 4); render(); setState(); };
countWidget.callback = ((previous) => function(...args) { const result = previous?.apply(this, args); refresh(); return result; })(countWidget.callback);
secondsWidget.callback = ((previous) => function(...args) {
const result = previous?.apply(this, args);
const duration = Math.max(0.1, Number(secondsWidget.value) || 0.1);
state.clips.forEach((clip) => {
clip.duration = duration;
clip.slots.forEach((slot) => {
slot.start = Math.min(Number(slot.start) || 0, Math.max(0, duration - 0.1));
slot.end = Math.min(Math.max(Number(slot.end) || duration, slot.start + 0.1), duration);
});
});
setState(); render(); return result;
})(secondsWidget.callback);
stateWidget.callback = ((previous) => function(...args) { const result = previous?.apply(this, args); render(); return result; })(stateWidget.callback);
const previousConnections = node.onConnectionsChange;
node.onConnectionsChange = function(...args) {
const result = previousConnections?.apply(this, args);
render();
return result;
};
node.__dumasSequencePromptBuilder = refresh;
refresh();
}
app.registerExtension({
name: "DUMAS.H3.SequencePromptBuilder",
nodeCreated(node) { setTimeout(() => configure(node), 0); },
loadedGraphNode(node) { setTimeout(() => configure(node), 0); },
afterConfigureGraph() { for (const node of app.graph?._nodes || []) configure(node); },
});
+116
View File
@@ -0,0 +1,116 @@
from __future__ import annotations
import importlib.util
import pathlib
import sys
import types
import unittest
from dataclasses import dataclass
ROOT = pathlib.Path(__file__).parents[1]
def load_module(name, path):
spec = importlib.util.spec_from_file_location(name, ROOT / path)
module = importlib.util.module_from_spec(spec)
assert spec.loader is not None
spec.loader.exec_module(module)
return module
PROMPT = load_module("dumas_h3_prompt_test", "dumas_h3_prompt_nodes.py")
UPSCALE = load_module("dumas_h3_upscale_test", "dumas_h3_upscale_nodes.py")
class FakeSamples:
def __init__(self, shape):
self.shape = shape
self.ndim = len(shape)
class FakeNoise:
def get_noise(self, seed):
return ("noise", seed)
class FakeSampler:
def get_sampler(self, name):
return ("sampler", name)
class FakeScheduler:
def get_sigmas(self, model, scheduler, steps, denoise):
return ("sigmas", scheduler, steps, denoise)
class FakeUpscale:
FUNCTION = "execute"
calls = []
def execute(self, **kwargs):
self.calls.append(kwargs)
source = kwargs["latent"]["samples"]
_, _, frames, height, width = source.shape
return ({"samples": FakeSamples((1, 16, frames, height * 2, width * 2))},)
@dataclass(frozen=True)
class FakeReferenceBundle:
images: tuple
reference_use: str
selectors: tuple
class H3NodeTests(unittest.TestCase):
def test_prompt_schema_and_full_chunk_reference_routing(self):
reference_module = types.ModuleType("upstream.v3.reference_images_v39")
reference_module.ReferenceImagesV39Bundle = FakeReferenceBundle
sys.modules[reference_module.__name__] = reference_module
try:
node = PROMPT.DumasH3SequencePromptBuilder()
result = node.build(
2, 4, "Keep @R1 present.",
'{"clips":[{"slots":[{"start":0,"end":4,"text":"Walk."}]},'
'{"slots":[{"start":0,"end":4,"text":"Turn."}]}]}',
"Use @R2 ambience.", "Music.",
reference_image_1=object(), reference_image_2=object(),
)
self.assertEqual(result[1], 2)
self.assertEqual(result[2], 4.0)
self.assertEqual(result[3].selectors, ("1,2", "1,2") + ("off",) * 7)
self.assertIn("[0-4s]", result[0])
self.assertIn("[4-8s]", result[0])
finally:
sys.modules.pop(reference_module.__name__, None)
def test_per_clip_upscale_uses_connected_sigmas(self):
original = UPSCALE._native_node
FakeUpscale.calls = []
UPSCALE._native_node = lambda name: {
"MMH3UltimateUpscale": FakeUpscale,
"RandomNoise": FakeNoise,
"KSamplerSelect": FakeSampler,
"BasicScheduler": FakeScheduler,
}.get(name)
try:
node = UPSCALE.DumasH3ContinuumTiledLatentUpscalePerClip()
outputs, report = node.upscale(
model=["model"], clip=["clip"],
video_latents=[{"samples": FakeSamples((1, 16, 85, 48, 84))}],
assembly_plan=["plan"], refine_context=["context"],
latent_upscale_param=["upscale"], spatial_split_param=["spatial"],
upscale_sampler=["euler"], upscale_scheduler=["simple"],
upscale_steps=[3], upscale_denoise=[0.2], upscale_cfg=[1.0],
upscale_noise_seed=[100], conditioning=["conditioning"],
upscale_sigmas=["connected-sigmas"],
)
self.assertEqual(len(outputs), 1)
self.assertEqual(FakeUpscale.calls[0]["sigmas"], "connected-sigmas")
self.assertIn("clips=1", report)
finally:
UPSCALE._native_node = original
if __name__ == "__main__":
unittest.main()