Bump version from 1.0.1 to 1.0.2

[codex] Add WAN aspect-adaptive base resolution

nodes.py

@@ -3,15 +3,15 @@ from __future__ import annotations
 from typing import Any
 
 try:
-    from .tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, install_tide_wan_patch
+    from .tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, aspect_adaptive_base_resolution, install_tide_wan_patch
 except ModuleNotFoundError as exc:
     if exc.name not in {f"{__package__}.tide_core", "tide_core"}:
         raise
-    from tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, install_tide_wan_patch
+    from tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, aspect_adaptive_base_resolution, install_tide_wan_patch
 except ImportError as exc:
     if "attempted relative import with no known parent package" not in str(exc):
         raise
-    from tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, install_tide_wan_patch
+    from tide_core import TIDEConfig, TIDEAttentionOverride, TIDEAttentionPatch, TIDEModelWrapper, aspect_adaptive_base_resolution, install_tide_wan_patch
 
 
 class TIDEHighResolutionExtrapolation:
@@ -110,6 +110,24 @@ class TIDEHighResolutionExtrapolation:
         return (patched,)
 
 
+def _resolve_wan_base_resolution(
+    *,
+    width: int,
+    height: int,
+    base_width: int,
+    base_height: int,
+    base_resolution_mode: str,
+) -> tuple[int, int]:
+    mode = str(base_resolution_mode)
+    if mode == "manual":
+        return int(base_width), int(base_height)
+    if mode == "aspect_adaptive_720p":
+        return aspect_adaptive_base_resolution(width, height, 1280, 720)
+    if mode == "aspect_adaptive_480p":
+        return aspect_adaptive_base_resolution(width, height, 832, 480)
+    raise ValueError(f"Unsupported WAN base_resolution_mode: {base_resolution_mode!r}")
+
+
 class TIDEWANHighResolutionExtrapolation:
     """Patch a WAN 2.1/2.2-style DiT model with TIDE Dynamic Temperature Control."""
 
@@ -126,8 +144,12 @@ class TIDEWANHighResolutionExtrapolation:
                 ),
             },
             "optional": {
-                "base_width": ("INT", {"default": 640, "min": 16, "max": 16384, "step": 16}),
-                "base_height": ("INT", {"default": 640, "min": 16, "max": 16384, "step": 16}),
+                "base_resolution_mode": (
+                    ["aspect_adaptive_720p", "aspect_adaptive_480p", "manual"],
+                    {"default": "aspect_adaptive_720p", "tooltip": "WAN native reference. Adaptive modes preserve target aspect and keep a 1280x720 or 832x480 native pixel budget; manual uses base_width/base_height exactly."},
+                ),
+                "base_width": ("INT", {"default": 1280, "min": 16, "max": 16384, "step": 16}),
+                "base_height": ("INT", {"default": 720, "min": 16, "max": 16384, "step": 16}),
                 "alpha_low": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 8.0, "step": 0.05}),
                 "alpha_high": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 8.0, "step": 0.05}),
                 "tau_max": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 4.0, "step": 0.01}),
@@ -149,8 +171,9 @@ class TIDEWANHighResolutionExtrapolation:
         width: int,
         height: int,
         temperature_strength: float,
-        base_width: int = 640,
-        base_height: int = 640,
+        base_resolution_mode: str = "aspect_adaptive_720p",
+        base_width: int = 1280,
+        base_height: int = 720,
         alpha_low: float = 0.6,
         alpha_high: float = 0.2,
         tau_max: float = 1.0,
@@ -159,6 +182,14 @@ class TIDEWANHighResolutionExtrapolation:
         preserve_existing_wrapper: bool = True,
         debug: bool = False,
     ):
+        base_width, base_height = _resolve_wan_base_resolution(
+            width=int(width),
+            height=int(height),
+            base_width=int(base_width),
+            base_height=int(base_height),
+            base_resolution_mode=str(base_resolution_mode),
+        )
+
         config = TIDEConfig(
             width=int(width),
             height=int(height),

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tide"
 description = "A ComfyUI custom node implementing TIDE (Text-Informed Dynamic Extrapolation with Step-Aware Temperature Control) for diffusion models."
-version = "1.0.0"
+version = "1.0.2"
 license = { file = "LICENSE" }
 
 [project.urls]

tests/test_math.py

@@ -2,13 +2,14 @@ import math
 import pathlib
 import sys
 
+import pytest
 import torch
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT))
 
 from tide_core.config import TIDEConfig
-from tide_core.math import adaptive_text_bias, get_default_temperature, rope_temperature_scale
+from tide_core.math import adaptive_text_bias, aspect_adaptive_base_resolution, get_default_temperature, rope_temperature_scale
 
 
 def test_adaptive_text_bias_matches_paper_and_official_flux_script():
@@ -43,3 +44,32 @@ def test_temperature_strength_zero_disables_scaling():
     cfg = TIDEConfig(width=4096, height=4096, temperature_strength=0.0)
     scale = rope_temperature_scale(cfg, timestep=1.0, device=torch.device("cpu"))
     assert torch.allclose(scale, torch.ones_like(scale), atol=1e-6)
+
+
+def test_aspect_adaptive_base_resolution_preserves_720p_area_budget_for_square_targets():
+    assert aspect_adaptive_base_resolution(960, 960, 1280, 720) == (960, 960)
+
+
+def test_aspect_adaptive_base_resolution_preserves_native_landscape_and_portrait():
+    assert aspect_adaptive_base_resolution(1280, 720, 1280, 720) == (1280, 720)
+    assert aspect_adaptive_base_resolution(720, 1280, 1280, 720) == (720, 1280)
+
+
+def test_aspect_adaptive_base_resolution_uses_target_aspect_for_nonstandard_i2v_size():
+    assert aspect_adaptive_base_resolution(896, 656, 1280, 720) == (1120, 816)
+
+
+def test_aspect_adaptive_base_resolution_keeps_snapped_result_within_native_budget():
+    base_width, base_height = aspect_adaptive_base_resolution(1000, 777, 1280, 720)
+    assert base_width * base_height <= 1280 * 720
+
+
+def test_aspect_adaptive_base_resolution_preserves_wan_480p_budget():
+    assert aspect_adaptive_base_resolution(832, 480, 832, 480) == (832, 480)
+    base_width, base_height = aspect_adaptive_base_resolution(480, 832, 832, 480)
+    assert base_width * base_height <= 832 * 480
+
+
+def test_aspect_adaptive_base_resolution_rejects_unsnappable_budget():
+    with pytest.raises(ValueError, match="No grid-aligned base resolution"):
+        aspect_adaptive_base_resolution(100_000_000, 1, 1280, 720)

tide_core/__init__.py

@@ -1,6 +1,7 @@
 from .config import TIDEConfig
 from .math import (
     adaptive_text_bias,
+    aspect_adaptive_base_resolution,
     get_default_temperature,
     get_mscale,
     rope_temperature_scale,
@@ -11,6 +12,7 @@ from .wan import TIDEWanDiffusionWrapper, install_tide_wan_patch
 __all__ = [
     "TIDEConfig",
     "adaptive_text_bias",
+    "aspect_adaptive_base_resolution",
     "get_default_temperature",
     "get_mscale",
     "rope_temperature_scale",

tide_core/math.py

@@ -26,6 +26,72 @@ def get_default_temperature(scale: float) -> float:
     return 1.0 / (mscale * mscale)
 
 
+def aspect_adaptive_base_resolution(
+    width: int,
+    height: int,
+    native_width: int,
+    native_height: int,
+    *,
+    grid: int = 16,
+) -> tuple[int, int]:
+    """Return native-budget base dimensions matched to the target aspect.
+
+    WAN 480p/720p checkpoints are better represented as a native pixel budget
+    than as one fixed landscape rectangle.  For an arbitrary I2V aspect, preserve
+    the target aspect while keeping native_width * native_height as the maximum
+    native reference area used by TIDE's extrapolation gates and RoPE-axis scale
+    factors.
+    """
+
+    width = int(width)
+    height = int(height)
+    native_width = int(native_width)
+    native_height = int(native_height)
+    grid = int(grid)
+    if width <= 0 or height <= 0:
+        raise ValueError(f"width and height must be > 0, got {width}x{height}")
+    if native_width <= 0 or native_height <= 0:
+        raise ValueError(f"native base must be > 0, got {native_width}x{native_height}")
+    if grid <= 0:
+        raise ValueError(f"grid must be > 0, got {grid}")
+
+    native_area = float(native_width) * float(native_height)
+    aspect = float(width) / float(height)
+    raw_width = math.sqrt(native_area * aspect)
+    raw_height = math.sqrt(native_area / aspect)
+
+    def snapped_neighbors(value: float) -> tuple[int, int]:
+        scaled = value / grid
+        lower = max(grid, int(math.floor(scaled)) * grid)
+        upper = max(grid, int(math.ceil(scaled)) * grid)
+        return lower, upper
+
+    candidates = {
+        (candidate_width, candidate_height)
+        for candidate_width in snapped_neighbors(raw_width)
+        for candidate_height in snapped_neighbors(raw_height)
+    }
+    under_budget = [
+        candidate
+        for candidate in candidates
+        if candidate[0] * candidate[1] <= native_width * native_height
+    ]
+    if not under_budget:
+        raise ValueError(
+            "No grid-aligned base resolution satisfies the native area budget "
+            f"for {width}x{height} against {native_width}x{native_height} on grid {grid}"
+        )
+    candidates = set(under_budget)
+
+    def score(candidate: tuple[int, int]) -> tuple[float, float]:
+        candidate_width, candidate_height = candidate
+        area_error = abs((candidate_width * candidate_height) - native_area) / native_area
+        aspect_error = abs((candidate_width / candidate_height) - aspect) / aspect
+        return area_error, aspect_error
+
+    return min(candidates, key=score)
+
+
 def adaptive_text_bias(config: TIDEConfig) -> float:
     """Paper Eq. 17/18: beta = log(lambda), with lambda = pixel ratio.
 

tide_core/wan.py

@@ -18,6 +18,13 @@ _ENABLED_KEY = "tide_wan_enabled"
 _WRAPPER_KEY = "tide_wan_rope_temperature"
 _SCALED_FREQS_ID_KEY = "_tide_wan_scaled_freqs_id"
 _CONFIG_SOURCE_KEY = "_tide_wan_config_source"
+_INNER_KEY = "_tide_wan_inner"
+_BLOCK_PATCH_KEY = "_tide_wan_block_dtc_patch"
+_BLOCK_PATCH_CONFIG_KEY = "_tide_wan_block_dtc_config"
+_BLOCK_PATCH_INNER_KEY = "_tide_wan_block_dtc_inner"
+_BLOCK_PATCH_SOURCE_KEY = "_tide_wan_block_dtc_source"
+_BLOCK_PATCH_TRANSFORMER_OPTIONS_KEY = "_tide_wan_block_dtc_transformer_options"
+_BLOCK_SCALED_CACHE_KEY = "_tide_wan_block_scaled_freqs_cache"
 _TRACE_LOG_COUNT_KEY = "_tide_wan_trace_log_count"
 _DIFFUSION_MODEL_WRAPPER_TYPE = "diffusion_model"
 _DEBUG_SCALE_LOG_LIMIT = 12
@@ -202,9 +209,10 @@ def _scale_wan_freqs(
     out = freqs * scale.reshape(view_shape)
 
     if config.debug:
-        count = int(getattr(inner, "_tide_wan_scale_log_count", 0))
+        count = int(getattr(inner, "_tide_wan_scale_log_count", 0)) if inner is not None else 0
         if count < _DEBUG_SCALE_LOG_LIMIT:
-            setattr(inner, "_tide_wan_scale_log_count", count + 1)
+            if inner is not None:
+                setattr(inner, "_tide_wan_scale_log_count", count + 1)
             _debug_print(
                 config,
                 "[ComfyUI-TIDE] WAN DTC applied: "
@@ -390,6 +398,145 @@ def _resolve_apply_model_wan_inner(outer: Any) -> Any:
     return None
 
 
+
+def _get_block_scaled_freqs(
+    transformer_options: Optional[dict[str, Any]],
+    config: TIDEConfig,
+    inner: Any,
+    freqs: Any,
+) -> Any:
+    if not torch.is_tensor(freqs):
+        return freqs
+    if _freqs_already_scaled(transformer_options, freqs):
+        return freqs
+
+    cache = None
+    timestep = _resolve_timestep(transformer_options)
+    cache_key = (id(freqs), timestep, id(config))
+    if isinstance(transformer_options, dict):
+        cache = transformer_options.setdefault(_BLOCK_SCALED_CACHE_KEY, {})
+        if isinstance(cache, dict):
+            cached = cache.get(cache_key)
+            if torch.is_tensor(cached):
+                return cached
+
+    out = _scale_wan_freqs(config, inner, freqs, timestep=timestep)
+    _mark_scaled_freqs(transformer_options, out)
+    if isinstance(cache, dict) and torch.is_tensor(out):
+        cache[cache_key] = out
+    return out
+
+
+def _install_wan_block_dtc_patches(
+    transformer_options: Optional[dict[str, Any]],
+    config: TIDEConfig,
+    inner: Any,
+    *,
+    source: str,
+) -> bool:
+    """Install a block-level WAN PE scaling fallback.
+
+    Spectrum WAN 2.1 can run actual forwards through an APPLY_MODEL driver where
+    neither the native WanModel.rope_encode hook nor the WanModel.forward_orig
+    hook is reached by TIDE, even though transformer block execution still goes
+    through Comfy's patches_replace path.  Wrapping the block replacement hooks
+    lets TIDE scale the shared RoPE matrix at the last stable point before each
+    attention block while preserving existing DiffAid/Spectrum patches.
+    """
+
+    if not isinstance(transformer_options, dict) or not _looks_like_wan_inner(inner):
+        return False
+
+    patches_replace = transformer_options.get("patches_replace")
+    if not isinstance(patches_replace, dict):
+        patches_replace = {}
+    dit_replace = patches_replace.get("dit")
+    if not isinstance(dit_replace, dict):
+        dit_replace = {}
+
+    block_count = len(getattr(inner, "blocks", ()) or ())
+    if block_count <= 0:
+        return False
+
+    def make_tide_wan_block_patch(previous_patch: Any, block_index: int):
+        def tide_wan_block_patch(args, extra_options):
+            local_config = getattr(tide_wan_block_patch, _BLOCK_PATCH_CONFIG_KEY, config)
+            local_inner = getattr(tide_wan_block_patch, _BLOCK_PATCH_INNER_KEY, inner)
+            fallback_transformer_options = getattr(
+                tide_wan_block_patch,
+                _BLOCK_PATCH_TRANSFORMER_OPTIONS_KEY,
+                transformer_options,
+            )
+            block_transformer_options = None
+            if isinstance(args, dict):
+                block_transformer_options = args.get("transformer_options")
+            if not isinstance(block_transformer_options, dict):
+                block_transformer_options = fallback_transformer_options
+
+            resolved_config = _resolve_config(block_transformer_options, local_config)
+            if resolved_config is not None and isinstance(args, dict) and "pe" in args:
+                if isinstance(block_transformer_options, dict):
+                    block_transformer_options[_INNER_KEY] = local_inner
+                pe = args.get("pe")
+                scaled_pe = _get_block_scaled_freqs(block_transformer_options, resolved_config, local_inner, pe)
+                if scaled_pe is not pe:
+                    args = dict(args)
+                    args["pe"] = scaled_pe
+                    if resolved_config.debug and not getattr(tide_wan_block_patch, "_tide_wan_block_scaled_logged", False):
+                        setattr(tide_wan_block_patch, "_tide_wan_block_scaled_logged", True)
+                        _debug_print(
+                            resolved_config,
+                            "[ComfyUI-TIDE] WAN block DTC fallback scaled PE: "
+                            f"block={block_index} source={getattr(tide_wan_block_patch, _BLOCK_PATCH_SOURCE_KEY, source)} "
+                            f"pe_shape={tuple(pe.shape) if torch.is_tensor(pe) else None}",
+                        )
+
+            if callable(previous_patch):
+                return previous_patch(args, extra_options)
+            original_block = extra_options.get("original_block") if isinstance(extra_options, dict) else None
+            if not callable(original_block):
+                raise RuntimeError("TIDE WAN block DTC patch missing original_block")
+            return original_block(args)
+
+        return tide_wan_block_patch
+
+    installed = 0
+    for block_index in range(block_count):
+        block_key = ("double_block", block_index)
+        previous_patch = dit_replace.get(block_key)
+
+        if callable(previous_patch) and getattr(previous_patch, _BLOCK_PATCH_KEY, False):
+            setattr(previous_patch, _BLOCK_PATCH_CONFIG_KEY, config)
+            setattr(previous_patch, _BLOCK_PATCH_INNER_KEY, inner)
+            setattr(previous_patch, _BLOCK_PATCH_SOURCE_KEY, source)
+            setattr(previous_patch, _BLOCK_PATCH_TRANSFORMER_OPTIONS_KEY, transformer_options)
+            installed += 1
+            continue
+
+        tide_wan_block_patch = make_tide_wan_block_patch(previous_patch, block_index)
+        setattr(tide_wan_block_patch, _BLOCK_PATCH_KEY, True)
+        setattr(tide_wan_block_patch, _BLOCK_PATCH_CONFIG_KEY, config)
+        setattr(tide_wan_block_patch, _BLOCK_PATCH_INNER_KEY, inner)
+        setattr(tide_wan_block_patch, _BLOCK_PATCH_SOURCE_KEY, source)
+        setattr(tide_wan_block_patch, _BLOCK_PATCH_TRANSFORMER_OPTIONS_KEY, transformer_options)
+        dit_replace[block_key] = tide_wan_block_patch
+        installed += 1
+
+    patches_replace["dit"] = dit_replace
+    transformer_options["patches_replace"] = patches_replace
+
+    if config.debug:
+        marker = "_tide_wan_block_dtc_logged"
+        if not getattr(inner, marker, False):
+            setattr(inner, marker, True)
+            _debug_print(
+                config,
+                "[ComfyUI-TIDE] WAN block DTC fallback installed: "
+                f"blocks={installed}/{block_count} source={source}",
+            )
+    return installed > 0
+
+
 class TIDEWanDiffusionWrapper:
     """ComfyUI diffusion_model wrapper that enables WAN RoPE DTC hooks lazily."""
 
@@ -415,8 +562,11 @@ class TIDEWanDiffusionWrapper:
         inject_tide_wan_options(transformer_options, self.config, timestep=timestep, source="diffusion_wrapper")
 
         inner = getattr(executor, "class_obj", None)
+        if isinstance(transformer_options, dict):
+            transformer_options[_INNER_KEY] = inner
         wrapped_rope = _ensure_wan_rope_encode_wrapped(inner, self.config)
         wrapped_forward_orig = _ensure_wan_forward_orig_wrapped(inner, self.config)
+        installed_block_dtc = _install_wan_block_dtc_patches(transformer_options, self.config, inner, source="diffusion_wrapper")
         if self.config.debug:
             if not getattr(self, "_logged_runtime", False):
                 _debug_print(
@@ -424,6 +574,7 @@ class TIDEWanDiffusionWrapper:
                     "[ComfyUI-TIDE] WAN diffusion wrapper active: "
                     f"inner={type(inner).__name__ if inner is not None else None} "
                     f"wrapped_rope={bool(wrapped_rope)} wrapped_forward_orig={bool(wrapped_forward_orig)} "
+                    f"block_dtc={bool(installed_block_dtc)} "
                     f"enabled={bool(transformer_options[_ENABLED_KEY])}",
                 )
                 self._logged_runtime = True
@@ -467,9 +618,11 @@ def prepare_tide_wan_apply_model(
         return
 
     inject_tide_wan_options(transformer_options, config, source="model_function_wrapper")
+    transformer_options[_INNER_KEY] = inner
 
     wrapped_rope = _ensure_wan_rope_encode_wrapped(inner, config)
     wrapped_forward_orig = _ensure_wan_forward_orig_wrapped(inner, config)
+    installed_block_dtc = _install_wan_block_dtc_patches(transformer_options, config, inner, source="model_function_wrapper")
 
     if config.debug:
         # Log once per live inner. This is intentionally separate from
@@ -484,6 +637,7 @@ def prepare_tide_wan_apply_model(
                 f"outer={type(outer).__name__ if outer is not None else None} "
                 f"inner={type(inner).__name__ if inner is not None else None} "
                 f"wrapped_rope={bool(wrapped_rope)} wrapped_forward_orig={bool(wrapped_forward_orig)} "
+                f"block_dtc={bool(installed_block_dtc)} "
                 f"enabled={bool(transformer_options[_ENABLED_KEY])}",
             )