Remove unused segmented prompt feature

APP_FILES.json

@@ -31,8 +31,8 @@
   },
   {
     "path": "RUNTIME_SOURCES.json",
-    "size": 4138,
-    "sha256": "8c49d0cd826006266902ca6a53ff39b0907aabb68916f74f19f268438000d607"
+    "size": 3160,
+    "sha256": "b578d016ab1e692e7a5078b15cc94694ebb179556feb8df41c1f828437112e78"
   },
   {
     "path": "custom_nodes/hf_video_extensions/lora_stack_av.py",
@@ -99,56 +99,6 @@
     "size": 78,
     "sha256": "976b2b972fe79ee1464504a3509108f0e9f289d119d10d70b1327bd704e41f1d"
   },
-  {
-    "path": "custom_nodes/hf_prompt_relay/.promptrelay-commit",
-    "size": 41,
-    "sha256": "2c3151f945c1879766e69bddff7c57be025b6f52a09932709ff77e9db83bfdc8"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/advanced_options.py",
-    "size": 3225,
-    "sha256": "f4623279bf5535a2997acd013423c704d191ee2d8fae664f8484276e707bfe0a"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/nodes.py",
-    "size": 10941,
-    "sha256": "11a8c513c1b069a80a60d06a1917602a5123c4785bb1c147de9d790cdda7c014"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/parser.py",
-    "size": 5817,
-    "sha256": "bef700925aa2a9fc27cfb859a393c0356106843e38aec70e0c7cf13a1f9ab2b2"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/patches.py",
-    "size": 6919,
-    "sha256": "ba2386e9a89f03e96d7d3ddcb0d9b76b40a0fd7721884b35c0844219e2d9e622"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/prompt_relay.py",
-    "size": 7984,
-    "sha256": "c13a99550fae816231eea444db11c33b42502f1bd204418bf1446b7ef1b62a17"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/README.md",
-    "size": 5104,
-    "sha256": "16c8b1cbceaa6e8dedb9c77812de9bc2eebc6e7d177d29202a95cb7a873ed3a7"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/requirements.txt",
-    "size": 11,
-    "sha256": "724abb011d42013ae5dfdf76ae6b1c8c78c87101e8ac30f66c6addf8059d51ea"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/smart_nodes.py",
-    "size": 6058,
-    "sha256": "55d071155f44283625dcf7bb1b20ea0a50aded5cee2bf6bb7020711921e3914d"
-  },
-  {
-    "path": "custom_nodes/hf_prompt_relay/__init__.py",
-    "size": 1480,
-    "sha256": "ea5e0d53842a8c9c1aa2e3d9f204347c3268f6973120b2a6aca7453eb1398872"
-  },
   {
     "path": "index.html",
     "size": 18993,
@@ -156,13 +106,13 @@
   },
   {
     "path": "app.js",
-    "size": 78586,
-    "sha256": "8e91bfdeff26bdf812d2b83ed8b326c88affb4d62ed855039bc1708ec0e2f850"
+    "size": 72624,
+    "sha256": "433e10f36bd3241b4d6ee0d49876a277271564203ea788048303f7b944f383f1"
   },
   {
     "path": "style.css",
-    "size": 11010,
-    "sha256": "654c77251c61e1116f36b564db061ff9969914c1b7847aca222a19fc25104730"
+    "size": 10647,
+    "sha256": "44ec3a484b2857ac491f071a18342dc9068309d9ca01a5887c23e19fa5a267a7"
   },
   {
     "path": "laogames.json",
@@ -181,8 +131,8 @@
   },
   {
     "path": "MODEL_SOURCES.json",
-    "size": 2600,
-    "sha256": "603317717ee9cd6cdc269772cd2e3d868b4e7232f0f46bf31d177cdf66dd44d4"
+    "size": 2558,
+    "sha256": "c93d66119230e4164b076c79e0661107d63999cc71dcb69af5ecc56ba9494985"
   },
   {
     "path": "SUPPORT_SOURCES.json",

MODEL_SOURCES.json

@@ -19,7 +19,7 @@
     "size": 29161843630,
     "sha256": "54bcb40427ff1a3e54cfa6087df765b617bee238d58aa49947c517a727722ad2",
     "license": null,
-    "required_when": "All i2v, v2v, t2v, prompt-relay modes using this default slot."
+    "required_when": "All i2v, v2v, t2v modes using this default slot."
   },
   {
     "slot": "video-flow.distilled-lora",
@@ -30,7 +30,7 @@
     "size": 2741024390,
     "sha256": "31e0c0195fb841bf31af78e8b60858f489e87ddcea4a5239abc80943da65e3ac",
     "license": "other",
-    "required_when": "All i2v, v2v, t2v, prompt-relay modes using this default slot."
+    "required_when": "All i2v, v2v, t2v modes using this default slot."
   },
   {
     "slot": "video-flow.text-encoder",
@@ -41,7 +41,7 @@
     "size": 9447702218,
     "sha256": "aaca463d11e6d8d2a4bdb0d6299214c15ef78a3f73e0ef8113d5a9d0219b3f6d",
     "license": "other",
-    "required_when": "All i2v, v2v, t2v, prompt-relay modes using this default slot."
+    "required_when": "All i2v, v2v, t2v modes using this default slot."
   },
   {
     "slot": "video-flow.latent-upscaler",

RUNTIME_SOURCES.json

@@ -14,10 +14,6 @@
       ],
       "export": "mxSlider"
     },
-    "hf_prompt_relay": {
-      "source": "https://github.com/kijai/ComfyUI-PromptRelay",
-      "revision": "ca5d4e3edb6abd9c2a4c68a3a6798eec1980f450"
-    },
     "hf_failsafe_translate": {
       "source": "https://github.com/ah-kun/ComfyUI-FailSafe-Translate-Node",
       "revision": "b0b901a926f561176776c29ac8bfe0b4d3acaf03"
@@ -63,13 +59,6 @@
     "custom_nodes/hf_video_extensions/__init__.py": "05f242fb4ac2b91923d8a4da3826cd6abdef3e374ad43c92b71515c62a2bd913",
     "custom_nodes/hf_mx/mxtoolkit.py": "4167ce23fed719f651618965e0d2af094b2b7c0b7efef77bf1168a5d55c2deb2",
     "custom_nodes/hf_mx/__init__.py": "976b2b972fe79ee1464504a3509108f0e9f289d119d10d70b1327bd704e41f1d",
-    "custom_nodes/hf_nvidia_rtx/__init__.py": "185aa7648151904a1741237f54a186bd19647172d78cdfe4e598aef726314252",
-    "custom_nodes/hf_prompt_relay/advanced_options.py": "f4623279bf5535a2997acd013423c704d191ee2d8fae664f8484276e707bfe0a",
-    "custom_nodes/hf_prompt_relay/nodes.py": "11a8c513c1b069a80a60d06a1917602a5123c4785bb1c147de9d790cdda7c014",
-    "custom_nodes/hf_prompt_relay/parser.py": "bef700925aa2a9fc27cfb859a393c0356106843e38aec70e0c7cf13a1f9ab2b2",
-    "custom_nodes/hf_prompt_relay/patches.py": "ba2386e9a89f03e96d7d3ddcb0d9b76b40a0fd7721884b35c0844219e2d9e622",
-    "custom_nodes/hf_prompt_relay/prompt_relay.py": "c13a99550fae816231eea444db11c33b42502f1bd204418bf1446b7ef1b62a17",
-    "custom_nodes/hf_prompt_relay/smart_nodes.py": "55d071155f44283625dcf7bb1b20ea0a50aded5cee2bf6bb7020711921e3914d",
-    "custom_nodes/hf_prompt_relay/__init__.py": "ea5e0d53842a8c9c1aa2e3d9f204347c3268f6973120b2a6aca7453eb1398872"
+    "custom_nodes/hf_nvidia_rtx/__init__.py": "185aa7648151904a1741237f54a186bd19647172d78cdfe4e598aef726314252"
   }
 }

custom_nodes/hf_prompt_relay/.promptrelay-commit

@@ -1 +0,0 @@
-ca5d4e3edb6abd9c2a4c68a3a6798eec1980f450

custom_nodes/hf_prompt_relay/README.md

@@ -1,123 +0,0 @@
-# ComfyUI Prompt-Relay
-
-WORK IN PROGRESS
-
-<img width="1486" height="1022" alt="image" src="./assets/timeline_node.png" />
-
-
-Original project:
-
-https://gordonchen19.github.io/Prompt-Relay/
-
----
-
-## Prompt Relay Encode (Smart)
-
-<img width="1486" alt="image" src="./assets/smart_nodes.png" />
-
-The Smart node accepts a single `smart_prompt` field and automatically calculates how to distribute your video's latent frames across segments. No manual frame counting required.
-
-There are two syntax styles. Pick one per prompt — do not mix them.
-
----
-
-### Syntax 1 — Inline (pipe-separated)
-
-Segments are separated by `|`. Weights are optional. If omitted, all segments get equal time.
-
-**Equal distribution:**
-```
-A man walks through a forest | He stops and looks around | He runs back
-```
-
-**Proportional distribution using `[start-end]` tags:**
-```
-A man walks through a forest [0-50] | He stops and looks around [50-150] | He runs back [150-200]
-```
-
-The numbers inside `[ ]` are not frame counts — they are relative positions on an arbitrary scale. Only the span of each range matters. In the example above the total span is 200, so the first segment gets 25%, the second 50%, and the third 25% of the video regardless of how many actual frames the video has.
-
-You can also use a single number `[50]` as a plain weight instead of a range.
-
----
-
-### Syntax 2 — Block (newline headers)
-
-Each segment is preceded by a header line on its own line. The header is any words followed by a number and a colon. The header line is stripped entirely before encoding — it never reaches the tokenizer.
-
-**Equal distribution (ordinal headers):**
-```
-Scene 1:
-A man walks through a forest
-Scene 2:
-He stops and looks around
-Scene 3:
-He runs back
-```
-
-A single number in the header (`Scene 1:`, `Part 4:`, `segment 9:`) is treated as a sequence marker and gives every segment equal weight.
-
-**Proportional distribution (range headers):**
-```
-Scene 1-2:
-A man walks through a forest
-Scene 2-5:
-He stops and looks around
-Scene 5-6:
-He runs back
-```
-
-When the header contains a range (`1-2`, `2-5`, `5-6`), the span of the range (`1`, `3`, `1`) becomes the segment's proportional weight. Here the second segment gets three times as much screen time as the first and third.
-
-The prefix words before the number are completely flexible — `Scene`, `Part`, `Shot`, `Segment`, `Second`, `Beat`, `Chapter`, `Step`, or any word you choose. Only the number and colon matter structurally.
-
-If the `word2number` Python package is installed (`pip install word2number`), the number can also be written as a word: `Scene eleven:`, `Part twenty one:`.
-
----
-
-### The `global_prompt` field
-
-`global_prompt` anchors persistent details across the entire video — style, character description, lighting, quality tags. Leave it empty and the node will automatically use the first segment's text as the global anchor.
-
-**Recommended pattern:** put your establishing description in segment 1, leave `global_prompt` blank, and use subsequent segments for action and motion changes only.
-
----
-
-### The `normalize_by_tokens` toggle
-
-When enabled, each segment's weight is multiplied by its CLIP token count before frame distribution. This means segments with more tokens are allocated proportionally more latent frames. Off by default.
-
----
-
-### Writing prompts with a VLM or LLM
-
-Paste the raw output directly into `smart_prompt`. The templates below are instruction blocks you send to the model. The model needs no knowledge of this node or how it works. Replace `[PLACEHOLDERS]` with your values before sending.
-
-The first segment is automatically used as the global anchor for the entire video. It must therefore contain only a static description of what is directly visible in the provided content. The model must not add, infer, or invent anything not explicitly present in the input. All subsequent segments must describe only what changes during that period and must not re-establish what was already described in segment 1.
-
----
-
-**Block syntax:**
-
-```
-Write a video prompt with exactly [NUMBER] segments describing [YOUR SUBJECT/SCENARIO].
-
-Rules:
-1. Begin each segment with a header on its own line. Format: one word, a space, a number, a colon. Example: Scene 1:
-2. Write the segment text on the line after the header.
-3. Segment 1 describes only the static visible state of the provided input. No motion. No action. Nothing not present in the input.
-4. Each segment after segment 1 describes only what is changing or moving during that period. Do not repeat anything from segment 1.
-5. Output only the formatted segments. Nothing else.
-```
-
-**Inline syntax:**
-
-```
-Write a video prompt with exactly [NUMBER] segments describing [YOUR SUBJECT/SCENARIO].
-
-Rules:
-1. Write all segments on one line separated by |
-2. Segment 1 describes only the static visible state of the provided input. No motion. No action. Nothing not present in the input.
-3. Each segment after segment 1 describes only what is changing or moving during that period. Do not repeat anything from segment 1.
-4. Output only the single line. Nothing else.
-```

custom_nodes/hf_prompt_relay/__init__.py

@@ -1,42 +0,0 @@
-from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
-from .nodes import PromptRelayEncode, PromptRelayEncodeTimeline, PromptRelayAdvancedOptions
-from .smart_nodes import PromptRelaySmartEncode, PromptRelaySmartEncodeTest
-from comfy_api.latest import ComfyExtension, io
-from typing_extensions import override
-
-
-class PromptRelay(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[io.ComfyNode]]:
-        return [
-            PromptRelayEncode,
-            PromptRelayEncodeTimeline,
-            PromptRelaySmartEncode,
-            PromptRelaySmartEncodeTest,
-            PromptRelayAdvancedOptions
-        ]
-
-
-async def comfy_entrypoint() -> PromptRelay:
-    return PromptRelay()
-
-NODE_CLASS_MAPPINGS = {
-    "PromptRelayEncode": PromptRelayEncode,
-    "PromptRelayEncodeTimeline": PromptRelayEncodeTimeline,
-    "PromptRelaySmartEncode": PromptRelaySmartEncode,
-    "PromptRelaySmartEncodeTest": PromptRelaySmartEncodeTest,
-    "PromptRelayAdvancedOptions": PromptRelayAdvancedOptions
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "PromptRelayEncode": "Prompt Relay Encode",
-    "PromptRelayEncodeTimeline": "Prompt Relay Encode (Timeline)",
-    "PromptRelaySmartEncode": "Prompt Relay Encode (Smart)",
-    "PromptRelaySmartEncodeTest": "Prompt Relay Smart Encode Test",
-    "PromptRelayAdvancedOptions": "Prompt Relay Advanced Options"
-}
-
-
-WEB_DIRECTORY = "./web"
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

custom_nodes/hf_prompt_relay/advanced_options.py

@@ -1,58 +0,0 @@
-from comfy_api.latest import io
-
-
-RelayOptions = io.Custom("RELAY_OPTIONS")
-
-
-
-class PromptRelayAdvancedOptions(io.ComfyNode):
-    """Per-stream temporal-penalty knobs for Prompt Relay encoders."""
-
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="PromptRelayAdvancedOptions",
-            display_name="Prompt Relay Advanced Options",
-            category="conditioning/prompt_relay",
-            is_experimental=True,
-            description=(
-                "Optional per-stream tuning. Connect to the relay_options input on a Prompt Relay encoder. Audio fields only affect LTX2."
-            ),
-            inputs=[
-                io.Float.Input(
-                    "video_strength", default=1.0, min=0.0, max=10.0, step=0.05,
-                    tooltip="Multiplier on the video temporal penalty. 0 disables video segmentation. Most useful in the 0–1 range to soften boundaries; values >1 saturate quickly at the default epsilon (1e-3) because the bias is already large enough to zero out distant tokens. To make >1 visibly meaningful, raise epsilon to ~0.1 or higher.",
-                ),
-                io.Float.Input(
-                    "video_window_scale", default=1.0, min=0.0, max=4.0, step=0.05,
-                    tooltip="Scales the flat anchor zone (default L/2 - 2 frames). <1 starts the soft falloff sooner; >1 widens the rigid zone. 0 collapses the anchor to a point — falloff begins immediately at the segment midpoint (sharper than default, not softer).",
-                ),
-                io.Float.Input(
-                    "audio_epsilon", default=0.0, min=0.0, max=0.99, step=1e-4,
-                    tooltip="Epsilon for the audio stream. 0 = inherit from the encoder's main epsilon.",
-                ),
-                io.Float.Input(
-                    "audio_strength", default=1.0, min=0.0, max=10.0, step=0.05,
-                    tooltip="Multiplier on the audio temporal penalty. 0 lets audio bleed across visual cuts. Most useful in the 0–1 range; values >1 saturate quickly at the default epsilon (1e-3) — raise audio_epsilon to ~0.1 or higher to make >1 visibly meaningful.",
-                ),
-                io.Float.Input(
-                    "audio_window_scale", default=1.0, min=0.0, max=4.0, step=0.05,
-                    tooltip="Scales the flat anchor zone width for the audio stream. <1 starts the soft falloff sooner; >1 widens the rigid zone. 0 collapses the anchor to a point — falloff begins immediately at the segment midpoint (sharper than default, not softer).",
-                ),
-            ],
-            outputs=[
-                RelayOptions.Output(display_name="relay_options"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, video_strength, video_window_scale,
-                audio_epsilon, audio_strength, audio_window_scale) -> io.NodeOutput:
-        opts = {
-            "video_strength": video_strength,
-            "video_window_scale": video_window_scale,
-            "audio_epsilon": audio_epsilon if audio_epsilon > 0 else None,
-            "audio_strength": audio_strength,
-            "audio_window_scale": audio_window_scale,
-        }
-        return io.NodeOutput(opts)

custom_nodes/hf_prompt_relay/nodes.py

@@ -1,241 +0,0 @@
-import logging
-
-from comfy_api.latest import io
-
-from .prompt_relay import (
-    get_raw_tokenizer,
-    map_token_indices,
-    build_segments,
-    create_mask_fn,
-    distribute_segment_lengths,
-)
-
-from .patches import detect_model_type, apply_patches
-from .advanced_options import PromptRelayAdvancedOptions, RelayOptions
-
-log = logging.getLogger(__name__)
-
-
-def _convert_to_latent_lengths(pixel_lengths, temporal_stride, latent_frames):
-    """Convert pixel-space segment lengths to integer latent-space lengths using the
-    largest-remainder method. Targets the full `latent_frames` when the pixel sum looks
-    like full coverage (within one stride of latent_frames * stride). Otherwise targets
-    round(total_pixel / temporal_stride) so partial-coverage timelines stay partial.
-    """
-    if not pixel_lengths:
-        return []
-    total_pixel = sum(pixel_lengths)
-    if total_pixel <= 0:
-        return [1] * len(pixel_lengths)
-
-    naive_total = max(1, round(total_pixel / temporal_stride))
-    target_total = min(latent_frames, naive_total)
-    # Within one frame of full → user clearly intended full coverage; pin to latent_frames.
-    if target_total >= latent_frames - 1:
-        target_total = latent_frames
-
-    exact = [p * target_total / total_pixel for p in pixel_lengths]
-    result = [int(e) for e in exact]
-    diff = target_total - sum(result)
-    if diff > 0:
-        order = sorted(range(len(exact)), key=lambda i: -(exact[i] - int(exact[i])))
-        for k in range(diff):
-            result[order[k % len(order)]] += 1
-
-    # Ensure every segment has ≥ 1 latent frame (steal from the largest if needed).
-    for i in range(len(result)):
-        if result[i] < 1:
-            max_idx = max(range(len(result)), key=lambda j: result[j])
-            if result[max_idx] > 1:
-                result[max_idx] -= 1
-                result[i] = 1
-
-    return result
-
-
-def _encode_relay(model, clip, latent, global_prompt, local_prompts, segment_lengths, epsilon, relay_options=None):
-    for name, val in (("global_prompt", global_prompt),
-                      ("local_prompts", local_prompts),
-                      ("segment_lengths", segment_lengths)):
-        if val is None:
-            raise ValueError(
-                f"PromptRelay: '{name}' arrived as None. "
-                "Likely causes: a stale workflow JSON saved with null, the timeline "
-                "editor's web extension failing to load, or an upstream node returning None. "
-                "Set the field to an empty string or fix the upstream connection."
-            )
-
-    locals_list = [p.strip() for p in local_prompts.split("|") if p.strip()]
-    if not locals_list:
-        raise ValueError("At least one local prompt is required (separate with |)")
-
-    arch, patch_size, temporal_stride = detect_model_type(model)
-
-    samples = latent["samples"]
-    latent_frames = samples.shape[2]
-    tokens_per_frame = (samples.shape[3] // patch_size[1]) * (samples.shape[4] // patch_size[2])
-
-    parsed_lengths = None
-    if segment_lengths.strip():
-        pixel_lengths = [int(x.strip()) for x in segment_lengths.split(",") if x.strip()]
-        parsed_lengths = _convert_to_latent_lengths(pixel_lengths, temporal_stride, latent_frames)
-
-    raw_tokenizer = get_raw_tokenizer(clip)
-    full_prompt, token_ranges = map_token_indices(raw_tokenizer, global_prompt, locals_list)
-
-    log.info("[PromptRelay] Global: tokens [0:%d] (%d tokens)", token_ranges[0][0], token_ranges[0][0])
-    for i, (s, e) in enumerate(token_ranges):
-        log.info("[PromptRelay] Segment %d: tokens [%d:%d] (%d tokens)", i, s, e, e - s)
-
-    conditioning = clip.encode_from_tokens_scheduled(clip.tokenize(full_prompt))
-
-    effective_lengths = distribute_segment_lengths(len(locals_list), latent_frames, parsed_lengths)
-
-    log.info(
-        "[PromptRelay] Latent: %d frames, %d tokens/frame, segments: %s",
-        latent_frames, tokens_per_frame, effective_lengths,
-    )
-
-    q_token_idx = build_segments(token_ranges, effective_lengths, epsilon, relay_options)
-    mask_fn = create_mask_fn(q_token_idx, tokens_per_frame, latent_frames)
-
-    patched = model.clone()
-    apply_patches(patched, arch, mask_fn)
-
-    return patched, conditioning
-
-
-class PromptRelayEncode(io.ComfyNode):
-    """Encodes temporal local prompts and patches the model for Prompt Relay."""
-
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="PromptRelayEncode",
-            display_name="Prompt Relay Encode",
-            category="conditioning/prompt_relay",
-            description=(
-                "Encodes a global prompt combined with temporal local prompts and patches the model "
-                "for Prompt Relay temporal control. Local prompts are separated by |. "
-                "Use a standard CLIPTextEncode for the negative prompt."
-            ),
-            inputs=[
-                io.Model.Input("model"),
-                io.Clip.Input("clip"),
-                io.Latent.Input("latent", tooltip="Empty latent video — dimensions are read from its shape."),
-                io.String.Input(
-                    "global_prompt", multiline=True, default="",
-                    tooltip="Conditions the entire video. Anchors persistent characters, objects, and scene context.",
-                ),
-                io.String.Input(
-                    "local_prompts", multiline=True, default="",
-                    tooltip="Ordered prompts for each temporal segment, separated by |",
-                ),
-                io.String.Input(
-                    "segment_lengths", default="",
-                    tooltip="Comma-separated pixel space frame counts per segment. Leave empty to auto-distribute evenly.",
-                ),
-                io.Float.Input(
-                    "epsilon", default=1e-3, min=1e-6, max=0.99, step=1e-4,
-                    tooltip="Penalty decay parameter. Values below ~0.1 all produce sharp boundaries (paper default 0.001). For softer transitions, try 0.5 or higher.",
-                ),
-                RelayOptions.Input(
-                    "relay_options", optional=True,
-                    tooltip="Optional advanced per-stream tuning. Connect a Prompt Relay Advanced Options node.",
-                ),
-            ],
-            outputs=[
-                io.Model.Output(display_name="model"),
-                io.Conditioning.Output(display_name="positive"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, model, clip, latent, global_prompt, local_prompts, segment_lengths, epsilon, relay_options=None) -> io.NodeOutput:
-        patched, conditioning = _encode_relay(
-            model, clip, latent, global_prompt, local_prompts, segment_lengths, epsilon, relay_options,
-        )
-        return io.NodeOutput(patched, conditioning)
-
-
-class PromptRelayEncodeTimeline(io.ComfyNode):
-    """WYSIWYG timeline variant — segments and lengths come from a visual editor in the node UI."""
-
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="PromptRelayEncodeTimeline",
-            display_name="Prompt Relay Encode (Timeline)",
-            category="conditioning/prompt_relay",
-            description=(
-                "Same as Prompt Relay Encode, but local prompts and segment lengths are edited "
-                "visually as draggable blocks on a timeline. The max_frames input only sets the "
-                "timeline scale (pixel space) — actual frame count is still read from the latent."
-            ),
-            inputs=[
-                io.Model.Input("model"),
-                io.Clip.Input("clip"),
-                io.Latent.Input("latent", tooltip="Empty latent video — dimensions are read from its shape."),
-                io.String.Input(
-                    "global_prompt", multiline=True, default="",
-                    tooltip="Conditions the entire video. Anchors persistent characters, objects, and scene context.",
-                ),
-                io.Int.Input(
-                    "max_frames", default=129, min=1, max=10000, step=1,
-                    tooltip="Total timeline length in pixel-space frames. Used by the editor for visual scale only.",
-                ),
-                io.String.Input(
-                    "timeline_data", default="",
-                    tooltip="JSON state of the timeline editor (auto-managed; do not edit by hand).",
-                ),
-                io.String.Input(
-                    "local_prompts", multiline=True, default="",
-                    tooltip="Auto-populated from the timeline editor.",
-                ),
-                io.String.Input(
-                    "segment_lengths", default="",
-                    tooltip="Auto-populated from the timeline editor (pixel-space frame counts).",
-                ),
-                io.Float.Input(
-                    "epsilon", default=1e-3, min=1e-6, max=0.99, step=1e-4,
-                    tooltip="Penalty decay parameter. Values below ~0.1 all produce sharp boundaries (paper default 0.001). For softer transitions, try 0.5 or higher.",
-                ),
-                io.Float.Input(
-                    "fps", default=24.0, min=0.1, max=240.0, step=0.1, optional=True,
-                    tooltip="Frames per second — only affects how time is displayed in the timeline editor when time_units is set to 'seconds'.",
-                ),
-                io.Combo.Input(
-                    "time_units", options=["frames", "seconds"], default="frames", optional=True,
-                    tooltip="Display the ruler, segment ranges, length input, and total in frames or seconds. Internal storage is always pixel-space frames.",
-                ),
-                RelayOptions.Input(
-                    "relay_options", optional=True,
-                    tooltip="Optional advanced per-stream tuning. Connect a Prompt Relay Advanced Options node.",
-                ),
-            ],
-            outputs=[
-                io.Model.Output(display_name="model"),
-                io.Conditioning.Output(display_name="positive"),
-            ],
-        )
-
-
-    @classmethod
-    def execute(cls, model, clip, latent, global_prompt, max_frames, timeline_data, local_prompts, segment_lengths, epsilon, fps=24.0, time_units="frames", relay_options=None) -> io.NodeOutput:
-        patched, conditioning = _encode_relay(
-            model, clip, latent, global_prompt, local_prompts, segment_lengths, epsilon, relay_options,
-        )
-        return io.NodeOutput(patched, conditioning)
-
-
-NODE_CLASS_MAPPINGS = {
-    "PromptRelayEncode": PromptRelayEncode,
-    "PromptRelayEncodeTimeline": PromptRelayEncodeTimeline,
-    "PromptRelayAdvancedOptions": PromptRelayAdvancedOptions,
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "PromptRelayEncode": "Prompt Relay Encode",
-    "PromptRelayEncodeTimeline": "Prompt Relay Encode (Timeline)",
-    "PromptRelayAdvancedOptions": "Prompt Relay Advanced Options",
-}

custom_nodes/hf_prompt_relay/parser.py

@@ -1,152 +0,0 @@
-import re
-
-_INLINE_TAG_RE = re.compile(r"\[([\d\.]+)(?:[:\-]([\d\.]+))?\]")
-_DIGIT_RANGE_TAIL_RE = re.compile(r"([\d]+(?:\.\d+)?)\s*[-\u2013]\s*([\d]+(?:\.\d+)?)\s*$")
-
-def _try_parse_num(s):
-    """Parse s as integer. Tries digit conversion first, then word2number if available."""
-    s = s.strip()
-    try:
-        return int(float(s))
-    except (ValueError, TypeError):
-        pass
-    try:
-        from word2number import w2n
-        return int(w2n.word_to_num(s))
-    except Exception:
-        pass
-    return None
-
-def _parse_header(line):
-    """Return (start, end_or_None) if line is a block segment header, else None.
-
-    Valid format: one or more prefix words, followed by a number (digit or word form),
-    optional range, then colon at end of line. Matching is case-insensitive.
-
-    Examples:
-        'Scene 1:'          -> (1, None)
-        'My Scene 3:'       -> (3, None)
-        'Shot 2-4:'         -> (2, 4)
-        'Part eleven:'      -> (11, None)    [requires word2number]
-        'segment twenty:'   -> (20, None)   [requires word2number]
-    """
-    line = line.strip()
-    if not line.endswith(':'):
-        return None
-    body = line[:-1].rstrip()
-    tokens = body.split()
-    # Need at least 2 tokens: at least one prefix word + one number token
-    if len(tokens) < 2:
-        return None
-    # Try digit range at end: "Scene 2-4:"
-    m = _DIGIT_RANGE_TAIL_RE.search(body)
-    if m and body[:m.start()].strip():
-        start = _try_parse_num(m.group(1))
-        end = _try_parse_num(m.group(2))
-        if start is not None and end is not None:
-            return (start, end)
-    # Try 1..N tail tokens as word-or-digit number (longest candidate first)
-    # Keep at least one prefix token so bare "1:" is not matched as a header
-    max_num_tokens = min(4, len(tokens) - 1)
-    for n in range(max_num_tokens, 0, -1):
-        candidate = " ".join(tokens[-n:])
-        val = _try_parse_num(candidate)
-        if val is not None:
-            return (val, None)
-    return None
-
-def _extract_inline_tag(text):
-    """Extract first [n] or [n-m] weight tag from text.
-    Returns (clean_text, weight_or_None). Tag is stripped from text.
-    """
-    m = _INLINE_TAG_RE.search(text)
-    if not m:
-        return text.strip(), None
-    val1 = float(m.group(1))
-    val2 = float(m.group(2)) if m.group(2) else None
-    weight = (val2 - val1) if val2 is not None else val1
-    clean = _INLINE_TAG_RE.sub("", text).strip()
-    return clean, weight
-
-def _parse_inline_syntax(text):
-    """Parse pipe-separated inline syntax with optional [n-m] weight tags.
-
-    Syntax examples:
-        'one | two | three'                       -> equal weights
-        'one [0-50] | two [50-150] | three [150]' -> proportional weights
-    """
-    segments = []
-    for part in text.split('|'):
-        clean, weight = _extract_inline_tag(part)
-        if clean:
-            segments.append({"text": clean, "weight": weight if weight is not None else 1.0})
-    return segments
-
-def _parse_block_syntax(text):
-    """Parse block header syntax where each segment is preceded by a header line.
-
-    Header format: any words followed by a number (or word-number) and a colon
-    on its own line. Optional [n-m] inline tag in body overrides header weight.
-
-    Syntax examples:
-        'Scene 1:\\ntext\\nScene 2:\\ntext'
-        'My Part 3-6:\\ntext'          -> weight = 6-3 = 3
-        'segment eleven:\\ntext'       -> weight = 1.0 (single number = sequence marker)
-    """
-    lines = text.splitlines(keepends=True)
-    raw_segments = []
-    current_header = None
-    current_body = []
-    for line in lines:
-        h = _parse_header(line)
-        if h is not None:
-            if current_body or current_header is not None:
-                raw_segments.append((current_header, "".join(current_body)))
-            current_header = h
-            current_body = []
-        else:
-            current_body.append(line)
-    if current_body or current_header is not None:
-        raw_segments.append((current_header, "".join(current_body)))
-    segments = []
-    for header, body in raw_segments:
-        clean, inline_weight = _extract_inline_tag(body)
-        if not clean:
-            continue
-        if inline_weight is not None:
-            weight = inline_weight
-        elif header is not None:
-            start, end = header
-            # Range header: weight is proportional span. Single number: equal weight.
-            weight = (end - start) if end is not None else 1.0
-        else:
-            weight = 1.0
-        segments.append({"text": clean, "weight": weight})
-    return segments
-
-def parse_smart_prompt(text):
-    """Parse smart_prompt text into a list of {"text": str, "weight": float} dicts.
-
-    Detects syntax automatically:
-
-    --- Inline (newline-agnostic) ---
-    Segments separated by | with optional [n-m] proportional weight tags.
-        'man walks | man runs | man jumps'
-        'man walks [0-50] | man runs [50-150] | man jumps [150-200]'
-
-    --- Block (newline-specific) ---
-    Segments preceded by a header line: any words + number + colon on its own line.
-    The number (or range) is stripped and used only for weight. Ordinal numbers
-    like 'Scene 1:' are sequence markers (equal weight). Ranges like 'Scene 1-3:'
-    assign proportional weight (3-1=2). Word-form numbers require word2number package.
-        'Scene 1:\\nman walks\\nScene 2:\\nman runs'
-        'My Shot 1-3:\\nman walks\\nMy Shot 3-7:\\nman runs'
-        'segment eleven:\\nman walks'   (requires: pip install word2number)
-
-    All syntax markers are fully stripped before text is returned.
-    """
-    lines = text.splitlines()
-    has_blocks = any(_parse_header(line) is not None for line in lines)
-    if has_blocks:
-        return _parse_block_syntax(text)
-    return _parse_inline_syntax(text)

custom_nodes/hf_prompt_relay/patches.py

@@ -1,179 +0,0 @@
-import logging
-import types
-
-import comfy.ldm.modules.attention
-
-log = logging.getLogger(__name__)
-
-
-def _masked_attention(q, k, v, heads, mask, transformer_options={}, **kwargs):
-    # Bypass wrap_attn (sage/etc may ignore masks) by calling attention_pytorch directly.
-    return comfy.ldm.modules.attention.attention_pytorch(
-        q, k, v, heads, mask=mask,
-        _inside_attn_wrapper=True,
-        transformer_options=transformer_options,
-        **kwargs,
-    )
-
-
-def _wan_t2v_forward(self, mask_fn, x, context, transformer_options={}, **kwargs):
-    q = self.norm_q(self.q(x))
-    k = self.norm_k(self.k(context))
-    v = self.v(context)
-
-    mask = mask_fn(q.shape[1], k.shape[1], q.dtype, q.device, transformer_options)
-    if mask is not None:
-        x = _masked_attention(q, k, v, heads=self.num_heads, mask=mask,
-                              transformer_options=transformer_options)
-    else:
-        x = comfy.ldm.modules.attention.optimized_attention(
-            q, k, v, heads=self.num_heads, transformer_options=transformer_options,
-        )
-    return self.o(x)
-
-
-def _wan_i2v_forward(self, mask_fn, x, context, context_img_len, transformer_options={}, **kwargs):
-    context_img = context[:, :context_img_len]
-    context_text = context[:, context_img_len:]
-
-    q = self.norm_q(self.q(x))
-
-    k_img = self.norm_k_img(self.k_img(context_img))
-    v_img = self.v_img(context_img)
-    img_x = comfy.ldm.modules.attention.optimized_attention(
-        q, k_img, v_img, heads=self.num_heads, transformer_options=transformer_options,
-    )
-
-    k = self.norm_k(self.k(context_text))
-    v = self.v(context_text)
-
-    mask = mask_fn(q.shape[1], k.shape[1], q.dtype, q.device, transformer_options)
-    if mask is not None:
-        x = _masked_attention(q, k, v, heads=self.num_heads, mask=mask,
-                              transformer_options=transformer_options)
-    else:
-        x = comfy.ldm.modules.attention.optimized_attention(
-            q, k, v, heads=self.num_heads, transformer_options=transformer_options,
-        )
-
-    return self.o(x + img_x)
-
-
-def _make_masked_override(prev_override):
-    """transformer_options override that routes mask-bearing attention calls through
-    attention_pytorch (sage/etc. drop arbitrary masks). Chains to a prior override
-    when no mask is present so we don't clobber other backends."""
-    def override(func, *args, **kwargs):
-        if kwargs.get("mask") is not None:
-            return comfy.ldm.modules.attention.attention_pytorch(*args, **kwargs)
-        if prev_override is not None:
-            return prev_override(func, *args, **kwargs)
-        return func(*args, **kwargs)
-    return override
-
-
-def _make_ltx_mask_wrapper(underlying, mask_fn):
-    """Wrap an existing LTX cross-attn forward (the default `CrossAttention.forward`
-    or another node's patch — e.g. KJNodes NAG), injecting PromptRelay's additive
-    mask via the `mask` kwarg the upstream signature already accepts.
-
-    `underlying` must already be bound to its module — callable as
-    `underlying(x, context=..., mask=..., ...)`.
-    """
-    def wrapped(_self, x, context=None, mask=None, pe=None, k_pe=None, transformer_options={}):
-        if context is not None:
-            pr_mask = mask_fn(x.shape[1], context.shape[1], x.dtype, x.device, transformer_options)
-            if pr_mask is not None:
-                mask = pr_mask if mask is None else mask + pr_mask
-
-        if mask is not None:
-            prev = transformer_options.get("optimized_attention_override")
-            transformer_options = {
-                **transformer_options,
-                "optimized_attention_override": _make_masked_override(prev),
-            }
-
-        return underlying(
-            x, context=context, mask=mask, pe=pe, k_pe=k_pe,
-            transformer_options=transformer_options,
-        )
-
-    wrapped._promptrelay_wrapper = True
-    return wrapped
-
-
-class _CrossAttnPatch:
-    """Descriptor that binds (impl, mask_fn) as a method onto a Wan cross-attn module."""
-
-    def __init__(self, impl, mask_fn):
-        self.impl = impl
-        self.mask_fn = mask_fn
-
-    def __get__(self, obj, objtype=None):
-        impl, mask_fn = self.impl, self.mask_fn
-
-        def wrapped(self_module, *args, **kwargs):
-            return impl(self_module, mask_fn, *args, **kwargs)
-
-        return types.MethodType(wrapped, obj)
-
-
-def detect_model_type(model):
-    """Return (arch, patch_size, temporal_stride) for latent geometry.
-
-    temporal_stride is the VAE's pixel→latent temporal compression factor,
-    used to convert user-facing pixel frame counts to latent frames.
-    """
-    diff_model = model.model.diffusion_model
-
-    if hasattr(diff_model, "patch_size") and not hasattr(diff_model, "patchifier"):
-        return "wan", tuple(diff_model.patch_size), 4
-
-    if hasattr(diff_model, "patchifier"):
-        return "ltx", (1, 1, 1), int(diff_model.vae_scale_factors[0])
-
-    raise ValueError(
-        f"Unsupported model type: {type(diff_model).__name__}. "
-        f"Currently supports Wan and LTX models."
-    )
-
-
-def _check_unpatched(model_clone, key):
-    if key in getattr(model_clone, "object_patches", {}):
-        raise RuntimeError(
-            f"PromptRelay: cross-attention forward at '{key}' is already patched by "
-            "another node. Stacking is not supported for this architecture — remove "
-            "the conflicting node."
-        )
-
-
-def apply_patches(model_clone, arch, mask_fn):
-    diffusion_model = model_clone.get_model_object("diffusion_model")
-
-    if arch == "wan":
-        from comfy.ldm.wan.model import WanI2VCrossAttention
-        for idx, block in enumerate(diffusion_model.blocks):
-            key = f"diffusion_model.blocks.{idx}.cross_attn.forward"
-            _check_unpatched(model_clone, key)
-            cross_attn = block.cross_attn
-            impl = _wan_i2v_forward if isinstance(cross_attn, WanI2VCrossAttention) else _wan_t2v_forward
-            model_clone.add_object_patch(key, _CrossAttnPatch(impl, mask_fn).__get__(cross_attn, cross_attn.__class__))
-        return
-
-    if arch == "ltx":
-        to = model_clone.model_options["transformer_options"]
-        to["promptrelay_mask_fn"] = mask_fn
-
-        for idx, block in enumerate(diffusion_model.transformer_blocks):
-            for attr in ("attn2", "audio_attn2"):
-                module = getattr(block, attr, None)
-                if module is None:
-                    continue
-                key = f"diffusion_model.transformer_blocks.{idx}.{attr}.forward"
-                # get_model_object returns the prior patch if present, else the default bound forward.
-                underlying = model_clone.get_model_object(key)
-                wrapper = _make_ltx_mask_wrapper(underlying, mask_fn)
-                model_clone.add_object_patch(key, types.MethodType(wrapper, module))
-        return
-
-    raise ValueError(f"Unknown model arch: {arch}")

custom_nodes/hf_prompt_relay/prompt_relay.py

@@ -1,204 +0,0 @@
-import logging
-import math
-import torch
-
-log = logging.getLogger(__name__)
-
-
-def build_temporal_cost(q_token_idx, Lq, Lk, device, dtype, tokens_per_frame):
-    """Gaussian penalty matrix [Lq, Lk] for video cross-attention (integer frame indexing)."""
-    offset = torch.zeros(Lq, Lk, device=device, dtype=dtype)
-    query_frames = torch.arange(Lq, device=device, dtype=torch.long) // tokens_per_frame
-
-    for seg in q_token_idx:
-        local = seg["local_token_idx"].to(device=device)
-        d = (query_frames.float()[:, None] - seg["midpoint"]).abs()
-        strength = seg.get("strength", 1.0)
-        cost = strength * (torch.relu(d - seg["window"]) ** 2) / (2 * seg["sigma"] ** 2)
-        offset[:, local] = cost.to(offset.dtype)
-
-    return offset
-
-
-def build_temporal_cost_scaled(q_token_idx, Lq, Lk, device, dtype, latent_frames):
-    """Penalty matrix for queries that don't map to integer frames (e.g. LTXAV audio tokens)."""
-    offset = torch.zeros(Lq, Lk, device=device, dtype=dtype)
-    query_frames = torch.arange(Lq, device=device, dtype=torch.float32) * latent_frames / Lq
-
-    for seg in q_token_idx:
-        local = seg["local_token_idx"].to(device=device)
-        d = (query_frames[:, None] - seg["midpoint"]).abs()
-        sigma_a = seg.get("sigma_audio", seg["sigma"])
-        window_a = seg.get("window_audio", seg["window"])
-        strength_a = seg.get("strength_audio", 1.0)
-        cost = strength_a * (torch.relu(d - window_a) ** 2) / (2 * sigma_a ** 2)
-        offset[:, local] = cost.to(offset.dtype)
-
-    return offset
-
-
-def create_mask_fn(q_token_idx, fallback_tokens_per_frame, latent_frames):
-    """Closure: mask_fn(Lq, Lk, dtype, device, transformer_options) -> additive mask or None.
-
-    Takes shapes/dtype/device instead of tensors so callers can compute the mask
-    without first materializing q/k projections — required so PromptRelay can
-    wrap an existing cross-attn forward (e.g. KJNodes NAG) instead of replacing it.
-    """
-    cache = {}
-    max_token_idx = max(int(seg["local_token_idx"].max().item()) for seg in q_token_idx) + 1
-
-    def mask_fn(Lq, Lk, dtype, device, transformer_options):
-        if Lq == Lk:
-            return None
-
-        # Only apply on conditional pass — not unconditional (negative prompt)
-        cond_or_uncond = transformer_options.get("cond_or_uncond", [])
-        if 1 in cond_or_uncond and 0 not in cond_or_uncond:
-            return None
-
-        grid_sizes = transformer_options.get("grid_sizes", None)
-        video_tpf = int(grid_sizes[1]) * int(grid_sizes[2]) if grid_sizes is not None else fallback_tokens_per_frame
-        video_lq = latent_frames * video_tpf
-
-        # Skip cross-modal attention — text keys are padded to a fixed length ≥ max_token_idx and != video_lq
-        if Lk == video_lq or Lk < max_token_idx:
-            return None
-
-        mode = "video" if Lq == video_lq else "scaled"
-
-        key = (Lq, Lk, mode, device)
-        if key not in cache:
-            if mode == "video":
-                cost = build_temporal_cost(q_token_idx, Lq, Lk, device, dtype, video_tpf)
-            else:
-                cost = build_temporal_cost_scaled(q_token_idx, Lq, Lk, device, dtype, latent_frames)
-            log.info(
-                "[PromptRelay] Built penalty matrix (%s): Lq=%d, Lk=%d, nonzero=%d/%d",
-                mode, Lq, Lk, (cost > 0).sum().item(), cost.numel(),
-            )
-            cache[key] = -cost
-
-        return cache[key].to(dtype)
-
-    return mask_fn
-
-
-def build_segments(token_ranges, segment_lengths, epsilon=1e-3, relay_options=None):
-    """Per-segment metadata for the temporal penalty.
-
-    relay_options (optional dict) overrides per-stream knobs:
-        video_strength, video_window_scale,
-        audio_epsilon, audio_strength, audio_window_scale
-    Audio knobs only affect architectures whose cross-attention takes the scaled
-    (non-integer-frame) path — currently LTX audio_attn2.
-    """
-    # Paper uses constant sigma = 1/ln(1/epsilon) regardless of segment length
-    sigma = 1.0 / math.log(1.0 / epsilon) if 0 < epsilon < 1 else 0.1448
-
-    opts = relay_options or {}
-    v_strength = opts.get("video_strength", 1.0)
-    v_window_scale = opts.get("video_window_scale", 1.0)
-    a_epsilon = opts.get("audio_epsilon")
-    a_strength = opts.get("audio_strength", 1.0)
-    a_window_scale = opts.get("audio_window_scale", 1.0)
-
-    if a_epsilon is not None and 0 < a_epsilon < 1:
-        sigma_audio = 1.0 / math.log(1.0 / a_epsilon)
-    else:
-        sigma_audio = sigma
-
-    if relay_options:
-        log.info(
-            "[PromptRelay] Advanced options active — video: strength=%.3f window_scale=%.3f | "
-            "audio: epsilon=%s strength=%.3f window_scale=%.3f",
-            v_strength, v_window_scale,
-            f"{a_epsilon:.4f}" if a_epsilon is not None else "inherit",
-            a_strength, a_window_scale,
-        )
-
-    q_token_idx = []
-    frame_cursor = 0
-
-    for (tok_start, tok_end), L in zip(token_ranges, segment_lengths):
-        if L <= 0:
-            frame_cursor += L
-            continue
-        midpoint = (2 * frame_cursor + L) // 2
-        base_window = max(L // 2 - 2, 0)
-        q_token_idx.append({
-            "local_token_idx": torch.arange(tok_start, tok_end),
-            "midpoint": midpoint,
-            "window": max(base_window * v_window_scale, 0.0),
-            "sigma": sigma,
-            "strength": v_strength,
-            "window_audio": max(base_window * a_window_scale, 0.0),
-            "sigma_audio": sigma_audio,
-            "strength_audio": a_strength,
-        })
-        frame_cursor += L
-
-    return q_token_idx
-
-
-def get_raw_tokenizer(clip):
-    """Extract the raw SPiece/HF tokenizer from a ComfyUI CLIP object."""
-    tokenizer_wrapper = clip.tokenizer
-    for attr_name in dir(tokenizer_wrapper):
-        if attr_name.startswith("_"):
-            continue
-        inner = getattr(tokenizer_wrapper, attr_name, None)
-        if inner is not None and hasattr(inner, "tokenizer"):
-            return inner.tokenizer
-
-    raise RuntimeError(
-        f"Could not find raw tokenizer on CLIP object. "
-        f"Known attributes: {[a for a in dir(tokenizer_wrapper) if not a.startswith('_')]}"
-    )
-
-
-def map_token_indices(raw_tokenizer, global_prompt, local_prompts):
-    """Tokenize global + space-prefixed locals; return (full_prompt, per-local token ranges).
-
-    Uses incremental tokenization to avoid SentencePiece context-dependency issues.
-    """
-    prefixed_locals = [" " + lp for lp in local_prompts]
-    full_prompt = global_prompt + "".join(prefixed_locals)
-    has_eos = getattr(raw_tokenizer, "add_eos", False)
-    eos_adj = 1 if has_eos else 0
-
-    prev_len = len(raw_tokenizer(global_prompt)["input_ids"]) - eos_adj
-    token_ranges = []
-    built = global_prompt
-
-    for plp in prefixed_locals:
-        built += plp
-        cur_len = len(raw_tokenizer(built)["input_ids"]) - eos_adj
-        if cur_len <= prev_len:
-            raise ValueError(f"Local prompt produced no tokens: '{plp.strip()}'")
-        token_ranges.append((prev_len, cur_len))
-        prev_len = cur_len
-
-    return full_prompt, token_ranges
-
-
-def distribute_segment_lengths(num_segments, latent_frames, specified_lengths=None):
-    """Validate or auto-distribute segment frame counts, capped to fit within latent_frames."""
-    if specified_lengths:
-        if len(specified_lengths) != num_segments:
-            raise ValueError(
-                f"Number of segment_lengths ({len(specified_lengths)}) "
-                f"must match number of local prompts ({num_segments})"
-            )
-        lengths = specified_lengths
-    else:
-        # ceil division — matches reference implementation
-        step = -(-latent_frames // num_segments)
-        lengths = [step] * num_segments
-
-    effective = []
-    cursor = 0
-    for L in lengths:
-        end = min(cursor + L, latent_frames)
-        effective.append(max(end - cursor, 0))
-        cursor = end
-    return effective

custom_nodes/hf_prompt_relay/requirements.txt

@@ -1 +0,0 @@
-word2number

custom_nodes/hf_prompt_relay/smart_nodes.py

@@ -1,145 +0,0 @@
-import logging
-from comfy_api.latest import io
-from .nodes import _encode_relay
-from .prompt_relay import get_raw_tokenizer
-from .parser import parse_smart_prompt
-
-log = logging.getLogger(__name__)
-
-class PromptRelaySmartEncode(io.ComfyNode):
-    """Parses advanced syntax into Prompt Relay segments and lengths."""
-
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="PromptRelaySmartEncode",
-            display_name="Prompt Relay Encode (Smart)",
-            category="conditioning/prompt_relay",
-            description="Parses syntax like [0-50] or block headers (Second 1:) to automatically calculate segment lengths.",
-            inputs=[
-                io.Model.Input("model"),
-                io.Clip.Input("clip"),
-                io.Latent.Input("latent"),
-                io.String.Input(
-                    "global_prompt", multiline=True, default="",
-                    tooltip="Conditions entire video. Leave empty to auto-use the first parsed segment from smart_prompt as the global anchor."
-                ),
-                io.String.Input(
-                    "smart_prompt", multiline=True, default="",
-                    tooltip="Enter prompt using Smart Syntax:\\n1. Inline: 'text one [0-50] | text two [50-100]'\\n2. Block: 'Second 1:\\ntext one\\nSecond 2:\\ntext two'\\nSyntax is auto-stripped and normalized evenly or proportionally."
-                ),
-                io.Boolean.Input("normalize_by_tokens", default=False, tooltip="If true, scales the calculated length of each segment by its token count."),
-                io.Float.Input("epsilon", default=1e-3, min=1e-6, max=0.99, step=1e-4),
-            ],
-            outputs=[
-                io.Model.Output(display_name="model"),
-                io.Conditioning.Output(display_name="positive"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, model, clip, latent, global_prompt, smart_prompt, normalize_by_tokens, epsilon) -> io.NodeOutput:
-        parsed = parse_smart_prompt(smart_prompt)
-
-        valid_segments = [s for s in parsed if s["text"].strip()]
-        if not valid_segments:
-            valid_segments = [{"text": " ", "weight": 1.0}]
-
-        raw_tokenizer = get_raw_tokenizer(clip) if normalize_by_tokens else None
-
-        local_prompts_list = []
-        weights_list = []
-
-        for seg in valid_segments:
-            text = seg["text"]
-            weight = seg["weight"]
-
-            if normalize_by_tokens and raw_tokenizer:
-                try:
-                    tokens = raw_tokenizer(text)["input_ids"]
-                    has_eos = getattr(raw_tokenizer, "add_eos", False)
-                    token_count = len(tokens) - (1 if has_eos else 0)
-                    token_count = max(1, token_count)
-                    weight *= token_count
-                except Exception as e:
-                    log.warning(f"Token counting failed for segment '{text}': {e}")
-
-            local_prompts_list.append(text)
-            weights_list.append(weight)
-
-        local_prompts_str = " | ".join(local_prompts_list)
-
-        scale_factor = 100000.0
-        segment_lengths_str = ", ".join(str(int(w * scale_factor)) for w in weights_list)
-
-        global_prompt_str = global_prompt.strip()
-        if not global_prompt_str and valid_segments:
-            global_prompt_str = valid_segments[0]["text"]
-
-        patched, conditioning = _encode_relay(
-            model, clip, latent, global_prompt_str, local_prompts_str, segment_lengths_str, epsilon
-        )
-
-        return io.NodeOutput(patched, conditioning)
-
-
-class PromptRelaySmartEncodeTest(io.ComfyNode):
-    """Test node for Prompt Relay Smart Encode syntax parsing."""
-
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="PromptRelaySmartEncodeTest",
-            display_name="Prompt Relay Smart Encode Test",
-            category="conditioning/prompt_relay",
-            description="Outputs the parsed syntax for testing purposes.",
-            inputs=[
-                io.String.Input(
-                    "smart_prompt", multiline=True, default="",
-                    tooltip="Enter prompt using Smart Syntax:\\n1. Inline: 'text one [0-50] | text two [50-100]'\\n2. Block: 'Second 1:\\ntext one\\nSecond 2:\\ntext two'\\nSyntax is auto-stripped and normalized evenly or proportionally."
-                ),
-                io.Boolean.Input("normalize_by_tokens", default=False),
-                io.Clip.Input("clip", optional=True),
-            ],
-            outputs=[
-                io.String.Output(display_name="parsed_output"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, smart_prompt, normalize_by_tokens, clip=None) -> io.NodeOutput:
-        parsed = parse_smart_prompt(smart_prompt)
-
-        valid_segments = [s for s in parsed if s["text"].strip()]
-        if not valid_segments:
-            valid_segments = [{"text": " ", "weight": 1.0}]
-
-        raw_tokenizer = None
-        if normalize_by_tokens and clip is not None:
-            from .prompt_relay import get_raw_tokenizer
-            raw_tokenizer = get_raw_tokenizer(clip)
-
-        output_lines = []
-        for i, seg in enumerate(valid_segments):
-            text = seg["text"]
-            weight = seg["weight"]
-
-            base_weight = weight
-            token_count = None
-
-            if normalize_by_tokens and raw_tokenizer:
-                try:
-                    tokens = raw_tokenizer(text)["input_ids"]
-                    has_eos = getattr(raw_tokenizer, "add_eos", False)
-                    token_count = len(tokens) - (1 if has_eos else 0)
-                    token_count = max(1, token_count)
-                    weight *= token_count
-                except Exception:
-                    pass
-
-            line = f"Segment {i+1}: text='{text}', base_weight={base_weight}"
-            if token_count is not None:
-                line += f", tokens={token_count}, final_weight={weight}"
-            output_lines.append(line)
-
-        return io.NodeOutput("\n".join(output_lines))

style.css

@@ -14,8 +14,8 @@ html{background:#f4f6f4;color-scheme:light}body{max-width:none;margin:0;padding:
 .preview-stage{position:relative;min-height:340px}.preview-loading{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:24px;color:#487ba7;font-size:13px;letter-spacing:.12em;background:radial-gradient(circle at center,#e5f3ff 0,transparent 65%)}.light-ring{display:block;width:84px;height:84px;border-radius:50%;border:3px solid #d9ebfa;border-top-color:#249dff;border-right-color:#74caff;box-shadow:0 0 18px #55b7ff55,inset 0 0 13px #55b7ff33;animation:preview-orbit 1s linear infinite}@keyframes preview-orbit{to{transform:rotate(360deg)}}@media(max-width:760px){.preview-stage{min-height:220px}.light-ring{width:68px;height:68px}}@media(prefers-reduced-motion:reduce){.light-ring{animation:none}}
 @media(max-width:760px){.output{margin-bottom:24px}}
 
-.relay-scene{display:grid;gap:10px;padding:14px;border:1px solid #cbd5e1;border-radius:12px;min-width:0}.relay-scene>.field{min-width:0}.relay-scene input[type=number]{width:100%;max-width:180px}.relay-duration-hint{margin:0}
+
 
 .video-loras{margin:16px 0;padding:14px;border:1px solid #cbd5e1;border-radius:12px;min-width:0}.video-lora-control{display:grid;grid-template-columns:minmax(0,1fr) 88px;gap:4px 12px;align-items:center;margin:18px 0}.video-lora-control label{grid-column:1;grid-row:1;font-weight:600}.video-lora-control input{min-width:0;width:100%;box-sizing:border-box}.video-lora-control input[type=number]{grid-column:2;grid-row:1;min-height:44px;font-size:16px;text-align:center}.video-lora-control input[type=range]{grid-column:1/-1;grid-row:2;appearance:none;-webkit-appearance:none;height:48px;margin:0;padding:0;background:transparent;border:0;border-radius:8px;cursor:pointer;touch-action:pan-y;accent-color:#286645}.video-lora-control input[type=range]::-webkit-slider-runnable-track{height:10px;background:#c8dfd1;border-radius:999px}.video-lora-control input[type=range]::-webkit-slider-thumb{appearance:none;-webkit-appearance:none;width:32px;height:32px;margin-top:-11px;border:3px solid white;border-radius:50%;background:#286645;box-shadow:0 1px 5px #153e3540}.video-lora-control input[type=range]::-moz-range-track{height:10px;background:#c8dfd1;border-radius:999px}.video-lora-control input[type=range]::-moz-range-thumb{box-sizing:border-box;width:32px;height:32px;border:3px solid white;border-radius:50%;background:#286645;box-shadow:0 1px 5px #153e3540}.video-lora-control input[type=range]:focus-visible{outline:3px solid #59aa7b;outline-offset:3px}.video-loras>button{min-height:44px}
 
-.relay-scenes{display:grid;gap:16px}.relay-remove{min-height:44px;justify-self:end;grid-column:1/-1}.relay-add{min-height:48px;width:100%}
+