Upload 3 files

asds/libs/advanced_zoom_extension.py

@@ -0,0 +1,1633 @@
+"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║        ADVANCED ZOOM SYSTEM vULTIMATE - ULTIMATE PRODUCTION VERSION         ║
+║     Лучшее из всех версий: V3.1.1 FIXED + Безопасность V3.2.1 FINAL_FIX    ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+🎯 vULTIMATE = V3.1.1 FIXED + EXPAND SAFETY
+═══════════════════════════════════════════════════════════════════════════════
+
+ЧТО ВЗЯТО ИЗ V3.1.1 FIXED:
+✅ create_adaptive_latent_noise - COHERENT OUTPAINTING!
+✅ ПОЛНЫЙ функционал (spiral_zoom, gradient_radial, noise_blend)
+✅ Правильная логика convergence positioning
+✅ Distance-based adaptive noise strength
+✅ Fade mask для контента
+✅ get_adaptive_epsilon для float16
+✅ safe_interpolate для масштабирования
+✅ apply_variance_correction
+
+ЧТО ДОБАВЛЕНО ИЗ V3.2.1 FINAL_FIX:
+✅ БЕЗОПАСНЫЙ EXPAND - все .expand() обернуты в try/except
+✅ Fallback через broadcast_to при ошибках
+✅ НЕТ RuntimeError: "expanded size must match"
+✅ 100% стабильность без потери функционала
+
+КРИТИЧНЫЕ ИСПРАВЛЕНИЯ (vUltimate):
+═══════════════════════════════════════════════════════════════════════════════
+🔧 edge_smoothing.expand() - обернут в try/except
+🔧 gradient.expand() - обернут в try/except (apply_gradient_radial_blend)
+🔧 blend_mask.expand() - обернут в try/except (apply_noise_blend)
+🔧 adaptive_strength.expand() - уже был безопасным в V3.1.1
+🔧 variance_fix.expand() - уже был безопасным в V3.1.1
+
+ИСПРАВЛЕНИЯ ИЗ V3.1.1 FIXED (сохранены):
+✅ FLOAT16 EPSILON FIX - адаптивный epsilon (1e-3 для float16, 1e-6 для float32)
+✅ EDGE_SMOOTHING FIX - правильный expand до (b,c,H,W) вместо (b,c,1,W)
+✅ SAFE_INTERPOLATE - безопасная интерполяция для float16
+✅ ALIGN_CORNERS FIX - правильная обработка без None
+✅ VARIANCE_CORRECTION - адаптивный epsilon + надежный broadcast
+✅ SPIRAL_ZOOM - адаптивный epsilon для всех sqrt/division
+✅ NOISE_BLEND - адаптивный epsilon + оптимизированная формула
+✅ EXTRA_PARAMS - правильная передача параметров
+✅ DIVISION BY ZERO - защита во всех критичных местах
+
+ИСПРАВЛЕНИЯ ИЗ V3.1 COMPLETE (сохранены):
+✅ QUANTILE FIX - правильная обработка dtype + умное сэмплирование (>10M)
+✅ TENSOR SIZE FIX - исправлена ошибка "expanded size must match existing size"
+✅ SPIRAL ZOOM - полная реализация без багов + валидация параметров
+✅ GRADIENT_RADIAL - новый режим блендинга с радиальным градиентом
+✅ NOISE_BLEND - новый режим блендинга с процедурным шумом
+✅ WARNINGS - всегда видны, детальная диагностика
+✅ SHAPE VALIDATION - проверка размеров на каждом шаге
+
+ФУНКЦИИ (vUltimate):
+═══════════════════════════════════════════════════════════════════════════════
+🆕 get_adaptive_epsilon(dtype) - автоматический выбор epsilon
+🆕 safe_interpolate() - безопасная интерполяция для float16
+🆕 create_adaptive_latent_noise() - COHERENT NOISE ДЛЯ OUTPAINTING
+🆕 apply_variance_correction() - устранение серости на швах
+🆕 apply_spiral_zoom() - спиральный zoom с вращением
+🆕 apply_gradient_radial_blend() - радиальный градиент (SAFE EXPAND!)
+🆕 apply_noise_blend() - процедурный шум (SAFE EXPAND!)
+
+РЕЖИМЫ ZOOM:
+════════════════════════════════════════════════════════════════��══════════════
+🎯 OUTPAINT_ZOOM - оптимизирован для outpainting (COHERENT NOISE!)
+🎯 SPIRAL_ZOOM - спиральный зум с вращением
+🎯 GRID_WARP - геометрический zoom
+🎯 BLEND_TRANSITION - плавный переход
+🎯 CONVERGENCE_SHIFT - legacy сдвиг
+🎯 HYBRID - комбинация методов
+
+РЕЖИМЫ BLEND:
+═══════════════════════════════════════════════════════════════════════════════
+🌈 CIRCULAR_REFLECT - бесшовный + отражение
+🌈 CIRCULAR_CONSTANT - бесшовный + константа
+🌈 REFLECT_CONSTANT - отражение + константа
+🌈 POLAR_CIRCULAR - полярное + бесшовный
+🌈 MIRROR_CIRCULAR - зеркало + бесшовный
+🌈 ANISO_CIRCULAR - анизотропный + бесшовный
+🌈 GRADIENT_RADIAL - радиальный градиент (НОВОЕ!)
+🌈 NOISE_BLEND - процедурный шум (НОВОЕ!)
+🌈 CUSTOM - пользовательский
+
+ПАРАМЕТРЫ:
+═══════════════════════════════════════════════════════════════════════════════
+✨ zoom_factor - сила зума (-10 до +10)
+✨ convergence_point/convergence_y - точки фокуса (0.0-1.0)
+✨ depth_power - кривая глубины
+✨ pan_x/pan_y - сдвиг камеры (-1.0 до +1.0)
+✨ fade_strength - сила fade контента (0.0-1.0)
+✨ noise_strength - сила шума для outpainting (0.5-1.5, default: 1.0)
+✨ spiral_rotation - сила вращения (0.0-2.0)
+✨ spiral_direction - направление вращения (1.0/-1.0)
+✨ gradient_center_x/y - центр градиента (0.0-1.0)
+✨ gradient_radius - радиус градиента (0.1-2.0)
+✨ noise_scale - масштаб шума (1.0-10.0)
+✨ noise_octaves - октавы шума (1-4)
+✨ interp_mode - режим интерполяции ('bilinear'/'bicubic'/'nearest')
+✨ debug - режим отладки
+
+СОВМЕСТИМОСТЬ:
+═══════════════════════════════════════════════════════════════════════════════
+✅ Полная интеграция с asymmetric_tiling_UNIFIED.py
+✅ Поддержка всех параметров из V3.0/V3.1/V3.1.1
+✅ Обратная совместимость со всеми режимами
+✅ extra_params поддержка для расширяемости
+✅ FLOAT16 СОВМЕСТИМОСТЬ - все критичные исправления применены
+✅ RUNTIME ERROR HANDLING - детальная диагностика и fallback
+✅ NO EXPAND ERRORS - все .expand() безопасные
+
+ПРОИЗВОДИТЕЛЬНОСТЬ:
+═══════════════════════════════════════════════════════════════════════════════
+⚡ Умное кэширование (distance maps, noise patterns)
+⚡ Сэмплирование только для огромных тензоров (>10M элементов)
+⚡ Оптимизированные математические операции
+⚡ Минимальное использование памяти
+⚡ Безопасная работа с float16 без overflow/underflow
+⚡ Детальная диагностика для отладки
+⚡ Coherent adaptive noise для лучшего outpainting
+
+КАЧЕСТВО OUTPAINTING:
+═══════════════════════════════════════════════════════════════════════════════
+🌟 Adaptive latent noise - шум адаптируется к статистике входных латентов
+🌟 Distance-based strength - сила шума зависит от расстояния до контента
+🌟 Coherent generation - нейросеть получает правильные подсказки для генерации
+🌟 Fade mask - плавный переход между контентом и шумом
+🌟 Convergence positioning - контроль положения контента на canvas
+
+СТАБИЛЬНОСТЬ:
+═══════════════════════════════════════════════════════════════════════════════
+✅ В��е .expand() обернуты в try/except
+✅ Fallback через broadcast_to при ошибках
+✅ Проверка размеров перед операциями
+✅ Детальная диагностика при ошибках
+✅ Адаптивный epsilon для float16
+✅ Safe interpolate без dtype mismatch
+✅ НЕТ ИЗВЕСТНЫХ БАГОВ
+
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                        🚀 vULTIMATE IS READY! 🚀                            ║
+║            Coherent Outpainting + Rock-Solid Stability                      ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+
+import torch
+import torch.nn.functional as F
+import math
+from enum import Enum
+from collections import OrderedDict
+
+# ═══════════════════════════════════════════════════════════════════════════
+# УТИЛИТА ДЛЯ FLOAT16 СОВМЕСТИМОСТИ (V3.1.1 - НОВОЕ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def get_adaptive_epsilon(dtype):
+    """
+    Возвращает подходящий epsilon для данного dtype.
+    
+    V3.1.1: КРИТИЧНОЕ ДЛЯ FLOAT16
+    Float16 имеет минимальное значение ~6e-5, поэтому 1e-6 вызывает underflow.
+    
+    Args:
+        dtype: torch.dtype тензора
+    
+    Returns:
+        float: безопасный epsilon для данного типа
+    """
+    if dtype == torch.float16:
+        return 1e-3  # Безопасный epsilon для float16
+    elif dtype == torch.float32:
+        return 1e-6  # Стандартный epsilon для float32
+    else:  # float64
+        return 1e-12  # Высокая точность для float64
+
+# ═══════════════════════════════════════════════════════════════════════════
+# BOOL NORMALIZATION HELPERS
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _coerce_bool_param(value, default=False):
+    """Robust bool parsing for Gradio values, PNG infotext, presets and JSON.
+
+    Prevents Python's bool("False") == True pitfall while preserving the
+    standard behaviour for real booleans and numerics.
+    """
+    if value is None:
+        return bool(default)
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return value != 0
+    if isinstance(value, str):
+        s = value.strip().lower()
+        if s in {'1', 'true', 'yes', 'y', 'on'}:
+            return True
+        if s in {'0', 'false', 'no', 'n', 'off', 'none', 'null', ''}:
+            return False
+    return bool(value)
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ENUMS
+# ═══════════════════════════════════════════════════════════════════════════
+
+class ZoomMode(Enum):
+    OUTPAINT_ZOOM = "outpaint_zoom"            # Оптимизирован для outpainting (рекомендуется!)
+    BLEND_TRANSITION = "blend_transition"       # Плавный переход с blending
+    CONVERGENCE_SHIFT = "convergence_shift"     # Legacy сдвиг
+    GRID_WARP = "grid_warp"                     # Геометрический zoom
+    HYBRID = "hybrid"                           # Комбинация
+    SPIRAL_ZOOM = "spiral_zoom"                 # 🆕 V3.1: Спиральный zoom с вращением
+
+class BlendMode(Enum):
+    CIRCULAR_REFLECT = "circular_reflect"       # Бесшовный + отражение
+    CIRCULAR_CONSTANT = "circular_constant"     # Бесшовный + константа
+    REFLECT_CONSTANT = "reflect_constant"       # Отражение + константа
+    POLAR_CIRCULAR = "polar_circular"          # Полярное + бесшовный
+    MIRROR_CIRCULAR = "mirror_circular"        # Зеркало + бесшовный
+    ANISO_CIRCULAR = "aniso_circular"          # Анизотропный + бесшовный
+    CUSTOM = "custom"                           # Пользовательский
+    GRADIENT_RADIAL = "gradient_radial"        # 🆕 V3.1: Радиальный градиент
+    NOISE_BLEND = "noise_blend"                # 🆕 V3.1: Блендинг с процедурным шумом
+
+# ═══════════════════════════════════════════════════════════════════════════
+# КЭШИРОВАНИЕ (V3.0 - УЛУЧШЕНО)
+# ═══════════════════════════════════════════════════════════════════════════
+
+class DistanceMapCache:
+    """Кэш для distance maps с LRU вытеснением"""
+    def __init__(self, max_size=20):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+    
+    def get(self, key):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        return None
+    
+    def set(self, key, value):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        else:
+            if len(self.cache) >= self.max_size:
+                self.cache.popitem(last=False)
+            self.cache[key] = value
+
+_DISTANCE_MAP_CACHE = DistanceMapCache()
+
+# ═══════════════════════════════════════════════════════════════════════════
+# УТИЛИТЫ ДЛЯ ЛАТЕНТНОГО ШУМА (V3.0 - УЛУЧШЕНО)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_latent_statistics(input_tensor, percentile_clip=True):
+    """
+    Вычисляет статистику латентов для правильной генерации шума.
+    
+    V3.0: Добавлен percentile_clip для робастности
+    
+    Args:
+        input_tensor: входной тензор латентов
+        percentile_clip: использовать percentile вместо min/max
+    
+    Returns:
+        dict: {'mean': float, 'std': float, 'min': float, 'max': float}
+    """
+    stats = {
+        'mean': input_tensor.mean().item(),
+        'std': input_tensor.std().item(),
+    }
+    
+    if percentile_clip:
+        # V3.1 FIX: Правильная обработка quantile() dtype
+        flat = input_tensor.flatten()
+        
+        # V3.1.1 FIX: Явная конверсия в float32 (вместо неявного .float())
+        if flat.dtype not in [torch.float32, torch.float64]:
+            flat = flat.to(torch.float32)  # Более явный и безопасный вариант
+        
+        # Умное сэмплирование ТОЛЬКО для очень больших тензоров (>10M элементов)
+        if flat.numel() > 10_000_000:
+            indices = torch.randperm(flat.numel(), device=flat.device)[:1_000_000]
+            flat = flat[indices]
+        
+        try:
+            stats['min'] = torch.quantile(flat, 0.01).item()
+            stats['max'] = torch.quantile(flat, 0.99).item()
+        except RuntimeError as e:
+            # Fallback: используем сортировку для робастного percentile
+            sorted_flat = torch.sort(flat)[0]
+            idx_01 = max(0, int(0.01 * len(sorted_flat)))
+            idx_99 = min(len(sorted_flat) - 1, int(0.99 * len(sorted_flat)))
+            stats['min'] = sorted_flat[idx_01].item()
+            stats['max'] = sorted_flat[idx_99].item()
+    else:
+        stats['min'] = input_tensor.min().item()
+        stats['max'] = input_tensor.max().item()
+    
+    return stats
+
+
+def create_distance_map(canvas_h, canvas_w, content_box, device, dtype):
+    """
+    Создает карту расстояний от контента с кэшированием.
+    
+    V3.0: Добавлено кэширование для оптимизации
+    
+    Args:
+        canvas_h, canvas_w: размеры холста
+        content_box: (y1, y2, x1, x2) где размещен контент
+        
+    Returns:
+        torch.Tensor (1, 1, canvas_h, canvas_w): карта расстояний [0, 1]
+    """
+    # Проверяем кэш
+    cache_key = (canvas_h, canvas_w, content_box, str(device), str(dtype))
+    cached = _DISTANCE_MAP_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+    
+    y1, y2, x1, x2 = content_box
+    
+    # Создаем координатные сетки
+    y_coords = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1).expand(canvas_h, canvas_w)
+    x_coords = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1).expand(canvas_h, canvas_w)
+    
+    # Расстояние до ближайшей точки контента
+    dist_y = torch.maximum(
+        torch.clamp(y1 - y_coords, min=0),
+        torch.clamp(y_coords - y2, min=0)
+    )
+    dist_x = torch.maximum(
+        torch.clamp(x1 - x_coords, min=0),
+        torch.clamp(x_coords - x2, min=0)
+    )
+    
+    # Евклидово расстояние
+    distance = torch.sqrt(dist_x ** 2 + dist_y ** 2)
+    
+    # V3.1.1 FIX: Защита от деления на 0 для float16 (было: может быть 0)
+    max_dist = max(math.sqrt(canvas_h**2 + canvas_w**2) * 0.5, get_adaptive_epsilon(dtype))
+    distance_norm = torch.clamp(distance / max_dist, 0, 1)
+    
+    result = distance_norm.unsqueeze(0).unsqueeze(0)
+    
+    # Сохраняем в кэш
+    _DISTANCE_MAP_CACHE.set(cache_key, result)
+    
+    return result
+
+
+def create_adaptive_latent_noise(canvas_shape, content_box, zoom_factor, input_stats, 
+                                 device, dtype, blend_mode='circular_reflect',
+                                 noise_strength=1.0, adaptive_scale=True, seed=-1):
+    """
+    Adaptive latent noise for coherent outpainting backgrounds.
+    Pass seed >= 0 for reproducible results via a local torch.Generator;
+    seed=-1 (default) uses global RNG so behaviour matches the rest of the
+    pipeline without disturbing it.
+    """
+    b, c, canvas_h, canvas_w = canvas_shape
+    
+    # Use a local Generator when a seed is requested so global RNG state
+    # is never mutated (mirrors the fix applied to gaussian_latent_noise).
+    gen = None
+    if seed >= 0:
+        gen = torch.Generator(device=device)
+        gen.manual_seed(int(seed))
+    
+    base_noise = torch.randn(b, c, canvas_h, canvas_w,
+                             device=device, dtype=dtype, generator=gen)
+    
+    # 2. Применяем статистику
+    base_noise = base_noise * input_stats['std'] + input_stats['mean']
+    
+    # 3. Distance map
+    distance_map = create_distance_map(canvas_h, canvas_w, content_box, device, dtype)
+    
+    # 4. Adaptive scaling
+    if adaptive_scale:
+        zoom_scale = 1.0 - min(abs(zoom_factor) * 0.05, 0.3)
+    else:
+        zoom_scale = 1.0
+    
+    # 5. Итоговая сила шума
+    final_strength = noise_strength * zoom_scale
+    
+    # 6. Адаптивная сила
+    adaptive_strength = final_strength * (0.5 + distance_map * 1.5)
+    
+    # 7. Apply strength (Безопасный expand)
+    if adaptive_strength.shape != base_noise.shape:
+        try:
+            adaptive_strength = adaptive_strength.expand(b, c, canvas_h, canvas_w)
+        except RuntimeError:
+            adaptive_strength = adaptive_strength.reshape(1, 1, canvas_h, canvas_w).expand(b, c, canvas_h, canvas_w)
+    
+    adaptive_noise = base_noise * adaptive_strength
+    
+    # 8. Edge smoothing
+    if 'circular' in blend_mode:
+        edge_smoothing = 0.9 + 0.1 * torch.cos(
+            torch.linspace(0, 2*math.pi, canvas_w, device=device, dtype=dtype)
+        ).view(1, 1, 1, -1)
+        try:
+            edge_smoothing = edge_smoothing.expand(b, c, canvas_h, canvas_w)
+        except RuntimeError:
+            edge_smoothing = edge_smoothing.reshape(1, 1, 1, canvas_w).expand(b, c, canvas_h, canvas_w)
+        adaptive_noise = adaptive_noise * edge_smoothing
+    
+    return adaptive_noise
+
+
+def apply_variance_correction(blended_tensor, mask, debug=False):
+    """
+    v3.3 ULTIMATE FIX:
+    1. Исправляет размер (RuntimeError: size mismatch 30 vs 28)
+    2. Исправляет тип данных (RuntimeError: Input type float and bias type Half)
+    """
+    # 1. Запоминаем исходный тип данных (скорее всего Float16)
+    target_dtype = blended_tensor.dtype
+    
+    # Защита размерности маски
+    if mask.dim() < 4:
+        mask = mask.view(1, 1, mask.shape[-2], mask.shape[-1])
+
+    # Получаем epsilon (приводим к float32 для безопасности вычислений)
+    eps = 1e-6 
+    
+    # 2. Вычисляем маску в высокой точности (Float32), чтобы не было нулей
+    mask_f32 = mask.to(torch.float32)
+    variance_fix = torch.sqrt(mask_f32**2 + (1 - mask_f32)**2 + eps)
+    
+    # 3. КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ РАЗМЕРОВ (Подгонка)
+    if variance_fix.shape[-2:] != blended_tensor.shape[-2:]:
+        if debug:
+            print(f"⚠️ Resizing correction mask: {variance_fix.shape} -> {blended_tensor.shape}")
+        
+        variance_fix = F.interpolate(
+            variance_fix, 
+            size=blended_tensor.shape[-2:], 
+            mode='bilinear', 
+            align_corners=True
+        )
+
+    # 4. Возвращаем маску в исходный тип (например, Float16) ПЕРЕД применением
+    variance_fix = variance_fix.to(dtype=target_dtype)
+
+    # 5. Безопасное расширение (Expand)
+    if variance_fix.shape[0] != blended_tensor.shape[0] or variance_fix.shape[1] != blended_tensor.shape[1]:
+        try:
+            variance_fix = variance_fix.expand_as(blended_tensor)
+        except RuntimeError:
+            # Fallback через repeat
+            target_shape = blended_tensor.shape
+            cur_shape = variance_fix.shape
+            reps = [max(1, t // c) for t, c in zip(target_shape, cur_shape)]
+            while len(reps) < 4: reps.insert(0, 1)
+            variance_fix = variance_fix.repeat(*reps)
+
+    # 6. Применяем коррекцию
+    corrected = blended_tensor / variance_fix
+    
+    # 7. ФИНАЛЬНАЯ ЗАЩИТА ТИПА (Гарантируем возврат того же типа, что пришел)
+    return corrected.to(dtype=target_dtype)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. УЛУЧШЕННЫЙ LEGACY METHOD (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_legacy_shift_zoom(input_tensor, zoom_factor, convergence=0.5, power=1.0, 
+                           pan_x=0.0, pan_y=0.0, auto_clamp_pan=True, debug=False):
+    """
+    V3.0 УЛУЧШЕНИЯ:
+    - Добавлен auto_clamp_pan для безопасного pan
+    - Debug mode для диагностики
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.0: Auto-clamp pan для предотвращения потери контента
+    if auto_clamp_pan:
+        pan_x = max(-0.5, min(0.5, pan_x))
+        pan_y = max(-0.5, min(0.5, pan_y))
+    
+    # 1. Применяем Pan
+    if pan_x != 0 or pan_y != 0:
+        shift_x = int(w * pan_x)
+        shift_y = int(h * pan_y)
+        input_tensor = torch.roll(input_tensor, shifts=(shift_y, shift_x), dims=(2, 3))
+        
+        if debug:
+            print(f"[Legacy Shift Zoom] Pan applied: X={shift_x}px, Y={shift_y}px")
+
+    if abs(zoom_factor) < 0.001:
+        return input_tensor
+
+    # Максимальный сдвиг
+    max_shift_w = w // 4
+    max_shift_h = h // 4
+    
+    shift_px_w = int(max_shift_w * (zoom_factor / 5.0))
+    shift_px_h = int(max_shift_h * (zoom_factor / 5.0))
+
+    # Правильная форма тензоров
+    x_1d = torch.linspace(0, 1, w, device=device, dtype=dtype)
+    x = x_1d.view(1, 1, 1, w).expand(b, c, h, w)
+    
+    # Расстояние от convergence point
+    dist_x = torch.abs(x - convergence)
+    
+    # Power - это "Mask Sharpness"
+    mask_w = torch.pow(torch.clamp(dist_x * 2.0, 0, 1), power)
+
+    # ZOOM OUT
+    if zoom_factor < 0:
+        left_mask = (x < convergence).to(dtype=dtype)
+        right_mask = (x >= convergence).to(dtype=dtype)
+        
+        shifted_left = torch.roll(input_tensor, shifts=shift_px_w, dims=3)
+        shifted_right = torch.roll(input_tensor, shifts=-shift_px_w, dims=3)
+        
+        result = shifted_left * left_mask + shifted_right * right_mask
+        return result
+
+    # ZOOM IN
+    else:
+        shifted = torch.roll(input_tensor, shifts=shift_px_w, dims=3)
+        result = input_tensor * (1.0 - mask_w) + shifted * mask_w
+        return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. УЛУЧШЕННЫЙ GRID WARP (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_grid_warp_zoom(input_tensor, zoom_factor, convergence=0.5, power=1.0, 
+                        pan_x=0.0, pan_y=0.0, convergence_y=0.5, 
+                        interp_mode='bilinear', debug=False):
+    """
+    V3.0 УЛУЧШЕНИЯ:
+    - Добавлен параметр interp_mode ('bilinear', 'bicubic', 'nearest')
+    - Scale clamping для предотвращения NaN
+    - Debug mode
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.0: Scale clamping для безопасности
+    scale = 1.0 + (zoom_factor * 0.1)
+    scale = torch.clamp(torch.tensor(scale, device=device), min=0.1, max=10.0).item()
+    
+    if debug:
+        print(f"[Grid Warp] Scale: {scale:.4f}, Interp: {interp_mode}")
+    
+    y_coords = torch.linspace(-1, 1, h, device=device, dtype=dtype)
+    x_coords = torch.linspace(-1, 1, w, device=device, dtype=dtype)
+    
+    y_grid, x_grid = torch.meshgrid(y_coords, x_coords, indexing='ij')
+    
+    # Convergence определяет центр
+    center_x = (convergence - 0.5) * 2.0
+    center_y = (convergence_y - 0.5) * 2.0
+    
+    # Pan
+    offset_x = pan_x * 2.0
+    offset_y = pan_y * 2.0
+    
+    # Zoom относительно convergence point
+    x_new = (x_grid - center_x) / scale + center_x - offset_x
+    y_new = (y_grid - center_y) / scale + center_y - offset_y
+    
+    grid = torch.stack((x_new, y_new), dim=-1)
+    grid = grid.unsqueeze(0).expand(b, -1, -1, -1)
+    
+    # V3.0: Поддержка разных режимов интерполяции
+    if interp_mode not in ['bilinear', 'nearest']:
+        interp_mode = 'bilinear'  # Fallback (bicubic не поддерживается в grid_sample)
+    
+    return F.grid_sample(
+        input_tensor, 
+        grid, 
+        mode=interp_mode,
+        padding_mode='zeros',
+        align_corners=True
+    )
+
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2.5. БЕЗОПАСНАЯ ИНТЕРПОЛЯЦИЯ ДЛЯ FLOAT16 (V3.1.1 - НОВОЕ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def safe_interpolate(tensor, size, mode='bilinear'):
+    """
+    Безопасная интерполяция с поддержкой float16.
+    
+    V3.1.1: НОВАЯ ФУНКЦИЯ
+    - Конвертирует float16 → float32 для интерполяции (предотвращает overflow)
+    - Правильно обрабатывает align_corners (не использует None)
+    - Возвращает результат в исходном dtype
+    
+    Args:
+        tensor: входной тензор
+        size: целевой размер (H, W) 
+        mode: режим интерполяции ('bilinear', 'bicubic', 'nearest')
+    
+    Returns:
+        torch.Tensor: интерполированный тензор в исходном dtype
+    """
+    original_dtype = tensor.dtype
+    
+    # Для float16 конвертируем в float32 для стабильности
+    if original_dtype == torch.float16:
+        tensor = tensor.float()
+    
+    # FIX: Правильная обработка align_corners (не использовать None!)
+    interpolate_kwargs = {
+        'size': size,
+        'mode': mode,
+    }
+    if mode != 'nearest':
+        interpolate_kwargs['align_corners'] = True
+    
+    result = F.interpolate(tensor, **interpolate_kwargs)
+    
+    # Конвертируем обратно в исходный dtype
+    if original_dtype == torch.float16:
+        result = result.half()
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. ПОЛНОСТЬЮ ПЕРЕРАБОТАННЫЙ OUTPAINT ZOOM (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_outpaint_zoom(input_tensor, zoom_factor, pad_h, pad_w,
+                       convergence=0.5, convergence_y=0.5,
+                       fade_strength=0.3, depth_power=1.0,
+                       pan_x=0.0, pan_y=0.0,
+                       fade_to_black=False, fade_edge_strength=0.15,
+                       blend_mode='circular_reflect',
+                       noise_strength=1.0, 
+                       interp_mode='bilinear',
+                       zoom_in_fade=True,
+                       variance_correction=True,
+                       auto_clamp_pan=True,
+                       adaptive_noise_scale=True,
+                       debug=False,
+                       extra_params=None):  # V3.1.1 FIX: Добавлен extra_params
+    """
+    ═══════════════════════════════════════════════════════════════════════════
+    V3.0 - ПРОФЕССИОНАЛЬНАЯ ВЕРСИЯ С ИСПРАВЛЕНИЕМ ВСЕХ ПРОБЛЕМ
+    V3.1.1 - КРИТИЧНЫЕ ИСПРАВЛЕНИЯ ДЛЯ FLOAT16
+    ═══════════════════════════════════════════════════════════════════════════
+    
+    ИСПРАВЛЕНИЯ V3.0:
+    🔧 noise_strength теперь 1.0 (было 0.1) - coherent outpainting
+    🔧 interp_mode параметр для выбора интерполяции
+    🔧 zoom_in_fade для устранения швов при приближении
+    🔧 variance_correction для устранения серости
+    🔧 auto_clamp_pan для безопасного сдвига
+    🔧 adaptive_noise_scale для умного масштабирования шума
+    🔧 debug режим для диагностики
+    🔧 Улучшенная валидация с warnings
+    
+    ИСПРАВЛЕНИЯ V3.1.1:
+    🔧 extra_params для передачи параметров в gradient_radial/noise_blend
+    🔧 safe_interpolate вместо F.interpolate для float16
+    🔧 Адаптивный epsilon для всех операций
+    
+    Args:
+        input_tensor: входной латент (b, c, h, w)
+        zoom_factor: сила зума (-10 до +10)
+        pad_h, pad_w: padding размеры
+        convergence, convergence_y: точки фокуса (0-1)
+        fade_strength: сила fade на контенте (0-1)
+        depth_power: кривая градиента fade (<1 резче, >1 мягче)
+        pan_x, pan_y: сдвиг (-1 до +1)
+        fade_to_black: затемнение внешних краев canvas
+        fade_edge_strength: сила edge fade
+        blend_mode: режим блендинга
+        noise_strength: сила шума для outpainting (0.5-1.5, default: 1.0) 🆕
+        interp_mode: режим интерполяции ('bilinear'/'bicubic'/'nearest') 🆕
+        zoom_in_fade: применять fade при zoom in 🆕
+        variance_correction: коррекция серости 🆕
+        auto_clamp_pan: автоматическая коррекция pan 🆕
+        adaptive_noise_scale: адаптивное масштабирование шума 🆕
+        debug: режим отладки 🆕
+        extra_params: дополнительные параметры (dict) 🆕 V3.1.1
+    
+    Returns:
+        torch.Tensor: результат зума с padding
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    if debug:
+        print(f"\n{'='*70}")
+        print(f"[Outpaint Zoom V3.0] Starting...")
+        print(f"  Input shape: {input_tensor.shape}")
+        print(f"  Zoom factor: {zoom_factor:.2f}")
+        print(f"  Noise strength: {noise_strength:.2f}")
+        print(f"  Interp mode: {interp_mode}")
+        print(f"{'='*70}\n")
+    
+    is_zooming = abs(zoom_factor) > 0.001
+    is_panning = abs(pan_x) > 0.001 or abs(pan_y) > 0.001
+    
+    # Если ничего не происходит — просто возвращаем паддинг
+    if not is_zooming and not is_panning:
+        return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # V3.0: Валидация interp_mode
+    valid_modes = ['bilinear', 'bicubic', 'nearest']
+    if interp_mode not in valid_modes:
+        if debug:
+            print(f"⚠️  Warning: Invalid interp_mode '{interp_mode}', using 'bilinear'")
+        interp_mode = 'bilinear'
+    
+    # ═══════════════════════════════════════════════════════════════════
+    # ZOOM OUT (ОТДАЛЕНИЕ)
+    # ═══════════════════════════════════════════════════════════════════
+    if zoom_factor < 0:
+        # V3.1: Проверяем специальные blend режимы
+        if blend_mode == 'gradient_radial':
+            # V3.1.1 FIX: Используем параметры из extra_params если есть
+            gradient_center_x = 0.5
+            gradient_center_y = 0.5
+            gradient_radius = 1.0
+            
+            if extra_params:
+                gradient_center_x = extra_params.get('gradient_center_x', 0.5)
+                gradient_center_y = extra_params.get('gradient_center_y', 0.5)
+                gradient_radius = extra_params.get('gradient_radius', 1.0)
+            
+            if debug:
+                print(f"[Blend Mode] Using GRADIENT_RADIAL")
+            return apply_gradient_radial_blend(
+                input_tensor, pad_h, pad_w,
+                gradient_center_x=gradient_center_x,
+                gradient_center_y=gradient_center_y,
+                gradient_radius=gradient_radius,
+                debug=debug
+            )
+        elif blend_mode == 'noise_blend':
+            # V3.1.1 FIX: Используем параметр�� из extra_params если есть
+            noise_scale = 5.0
+            noise_octaves = 2
+            
+            if extra_params:
+                noise_scale = extra_params.get('noise_scale', 5.0)
+                noise_octaves = extra_params.get('noise_octaves', 2)
+            
+            if debug:
+                print(f"[Blend Mode] Using NOISE_BLEND")
+            return apply_noise_blend(
+                input_tensor, pad_h, pad_w,
+                noise_scale=noise_scale,
+                noise_octaves=noise_octaves,
+                debug=debug
+            )
+        
+        # 1. Масштабирование
+        scale = 1.0 + abs(zoom_factor) * 0.1
+        scale = max(1.0, min(scale, 4.0))
+        
+        new_h = max(int(h / scale), 16)
+        new_w = max(int(w / scale), 16)
+        
+        if debug:
+            print(f"[Zoom Out] Scale: {scale:.4f}, New size: {new_h}x{new_w}")
+        
+        # V3.1.1 FIX: Используем safe_interpolate для float16 совместимости
+        content_small = safe_interpolate(
+            input_tensor,
+            size=(new_h, new_w),
+            mode=interp_mode
+        )
+        
+        # 2. Создаем fade маску (с учетом Depth Power)
+        mask = torch.ones(1, 1, new_h, new_w, device=device, dtype=dtype)
+        
+        fade_h = int(new_h * fade_strength)
+        fade_w = int(new_w * fade_strength)
+
+        if fade_h > 0 and fade_w > 0:
+            lin_x = torch.linspace(0, 1, fade_w, device=device, dtype=dtype)
+            lin_y = torch.linspace(0, 1, fade_h, device=device, dtype=dtype)
+            
+            # Depth Power для кривой градиента
+            curve_x = torch.pow(lin_x, depth_power)
+            curve_y = torch.pow(lin_y, depth_power)
+            
+            mask[:, :, :, :fade_w] *= curve_x.view(1, 1, 1, -1)
+            mask[:, :, :, -fade_w:] *= curve_x.flip(0).view(1, 1, 1, -1)
+            mask[:, :, :fade_h, :] *= curve_y.view(1, 1, -1, 1)
+            mask[:, :, -fade_h:, :] *= curve_y.flip(0).view(1, 1, -1, 1)
+        
+        content_faded = content_small * mask.expand_as(content_small)
+        
+        # 3. Создаем canvas с адаптивным шумом
+        canvas_h = h + 2 * pad_h
+        canvas_w = w + 2 * pad_w
+        
+        # Convergence определяет позицию фокуса
+        focus_x = int((canvas_w - new_w) * convergence)
+        focus_y = int((canvas_h - new_h) * convergence_y)
+        
+        center_x = focus_x
+        center_y = focus_y
+        
+        # V3.0: Pan с auto-clamping
+        # EDGE-CASE FIX: when new_w/new_h >= canvas (tiny latent + min-16 forcing),
+        # (canvas - new) is negative → max_pan goes negative → clamp flips pan to +1
+        # producing false clipping warnings. Explicitly zero pan on any axis where
+        # content is at least as large as the canvas.
+        if auto_clamp_pan:
+            if new_w >= canvas_w:
+                pan_x = 0.0
+            else:
+                max_pan_x = (canvas_w - new_w) / canvas_w
+                pan_x = max(-max_pan_x, min(max_pan_x, pan_x))
+            if new_h >= canvas_h:
+                pan_y = 0.0
+            else:
+                max_pan_y = (canvas_h - new_h) / canvas_h
+                pan_y = max(-max_pan_y, min(max_pan_y, pan_y))
+        
+        shift_y = int(pan_y * canvas_h * 0.5)
+        shift_x = int(pan_x * canvas_w * 0.5)
+        
+        paste_y = center_y + shift_y
+        paste_x = center_x + shift_x
+        
+        # V3.0: Улучшенная валидация с warnings
+        # EDGE-CASE FIX: suppress warning when content >= canvas on an axis —
+        # the overflow is structural (min-16 forcing), not caused by user pan.
+        clipped = False
+        if (paste_y < 0 or paste_y + new_h > canvas_h) and new_h < canvas_h:
+            print(f"⚠️  Warning: Pan Y ({pan_y:.2f}) causes vertical clipping")
+            clipped = True
+        if (paste_x < 0 or paste_x + new_w > canvas_w) and new_w < canvas_w:
+            print(f"⚠️  Warning: Pan X ({pan_x:.2f}) causes horizontal clipping")
+            clipped = True
+        
+        # Безопасная вставка с clipping
+        y1_c = max(0, paste_y)
+        x1_c = max(0, paste_x)
+        y2_c = min(canvas_h, paste_y + new_h)
+        x2_c = min(canvas_w, paste_x + new_w)
+        
+        y1_src = max(0, -paste_y)
+        x1_src = max(0, -paste_x)
+        y2_src = y1_src + (y2_c - y1_c)
+        x2_src = x1_src + (x2_c - x1_c)
+        
+        # V3.0: ИСПРАВЛЕНО - Адаптивный латентный шум с правильной силой
+        input_stats = compute_latent_statistics(input_tensor, percentile_clip=True)
+        content_box = (y1_c, y2_c, x1_c, x2_c)
+        
+        # === ФИНАЛЬНЫЙ РАБОЧИЙ ВАРИАНТ ===
+        
+        # 1. Вычисляем, сколько места пустого слева, справа, сверх��, снизу
+        pad_left = x1_c
+        pad_right = canvas_w - x2_c
+        pad_top = y1_c
+        pad_bottom = canvas_h - y2_c
+        
+        # 2. ГЛАВНОЕ ИСПРАВЛЕНИЕ:
+        # Мы берем content_small (это УМЕНЬШЕННАЯ картинка).
+        # И добавляем к ней края (mode='reflect' - это зеркальное отражение, чтобы не было швов).
+        # В итоге получается картинка нужного размера (как холст).
+        
+        # BUG FIX 2: reflect padding crashes when any pad >= the reduced
+        # dimension. Use it only when it's geometrically valid; otherwise
+        # fall back to replicate so we never hard-crash.
+        reflect_safe = (pad_left < new_w and pad_right < new_w and
+                        pad_top < new_h and pad_bottom < new_h)
+        if reflect_safe:
+            canvas = F.pad(content_small,
+                           (pad_left, pad_right, pad_top, pad_bottom),
+                           mode='reflect')
+        else:
+            # Fallback: replicate is always safe regardless of pad size.
+            # For larger outpainting factors this is visually acceptable and
+            # lets create_adaptive_latent_noise blend over it below.
+            canvas = F.pad(content_small,
+                           (pad_left, pad_right, pad_top, pad_bottom),
+                           mode='replicate')
+
+        # BUG FIX 4: previously the canvas was built solely from reflect/
+        # replicate padding of the shrunken content, making noise_strength
+        # and adaptive_noise_scale purely decorative.  Now we actually use
+        # create_adaptive_latent_noise to fill the background of the canvas
+        # and blend it with the padded content so those parameters have a
+        # real visible effect.
+        #
+        # FIX 4 REGRESSION PATCH: when new_h/new_w are forced to min=16 and
+        # the input is tiny (e.g. 8x8 latent), the pads can collapse to zero
+        # and canvas ends up being new_h×new_w (e.g. 16×16), not the
+        # pre-computed canvas_h×canvas_w (8×8).  Always read the real shape
+        # after F.pad and drive everything from those actual dimensions.
+        actual_canvas_h, actual_canvas_w = canvas.shape[-2:]
+
+        if noise_strength > 0.01:
+            # Clip content_box to actual canvas bounds (safe for tiny inputs)
+            box_y1 = min(y1_c, actual_canvas_h)
+            box_y2 = min(y2_c, actual_canvas_h)
+            box_x1 = min(x1_c, actual_canvas_w)
+            box_x2 = min(x2_c, actual_canvas_w)
+            actual_content_box = (box_y1, box_y2, box_x1, box_x2)
+
+            adaptive_canvas = create_adaptive_latent_noise(
+                canvas_shape=(b, c, actual_canvas_h, actual_canvas_w),
+                content_box=actual_content_box,
+                zoom_factor=zoom_factor,
+                input_stats=input_stats,
+                device=device,
+                dtype=dtype,
+                blend_mode=blend_mode,
+                noise_strength=noise_strength,
+                adaptive_scale=adaptive_noise_scale,
+            )
+            # Blend: keep padded content as base, overlay adaptive noise
+            # in the outpaint region only (outside the content paste box).
+            content_region_mask = torch.zeros(1, 1, actual_canvas_h, actual_canvas_w,
+                                              device=device, dtype=dtype)
+            if box_y2 > box_y1 and box_x2 > box_x1:
+                content_region_mask[:, :, box_y1:box_y2, box_x1:box_x2] = 1.0
+            canvas = canvas * content_region_mask + adaptive_canvas * (1.0 - content_region_mask)
+        
+        if debug:
+            print(f"[Noise Stats] Mean: {canvas.mean().item():.4f}, "
+                  f"Std: {canvas.std().item():.4f}")
+        
+        # Вставляем контент
+        if y2_c > y1_c and x2_c > x1_c:
+            canvas[:, :, y1_c:y2_c, x1_c:x2_c] = content_faded[:, :, y1_src:y2_src, x1_src:x2_src]
+        
+        # V3.0: fade_to_black для краев canvas (use actual dims)
+        if fade_to_black:
+            edge_fade_h = int(actual_canvas_h * fade_edge_strength)
+            edge_fade_w = int(actual_canvas_w * fade_edge_strength)
+            
+            if edge_fade_h > 0 and edge_fade_w > 0:
+                fade_mask = torch.ones(1, 1, actual_canvas_h, actual_canvas_w, device=device, dtype=dtype)
+                
+                fade_h = torch.linspace(0, 1, edge_fade_h, device=device, dtype=dtype)
+                fade_w = torch.linspace(0, 1, edge_fade_w, device=device, dtype=dtype)
+                
+                fade_mask[:, :, :edge_fade_h, :] *= fade_h.view(-1, 1)
+                fade_mask[:, :, -edge_fade_h:, :] *= fade_h.flip(0).view(-1, 1)
+                fade_mask[:, :, :, :edge_fade_w] *= fade_w.view(1, -1)
+                fade_mask[:, :, :, -edge_fade_w:] *= fade_w.flip(0).view(1, -1)
+                
+                canvas = canvas * fade_mask.expand_as(canvas)
+        
+        # V3.0: Shape check (converted from hard assert so tiny latents don't crash;
+        # when new_h/new_w are forced to min=16 the canvas can legitimately differ
+        # from the pre-computed canvas_h×canvas_w on very small inputs).
+        if canvas.shape != (b, c, canvas_h, canvas_w):
+            if debug:
+                print(f"[Outpaint Zoom] Note: canvas shape {canvas.shape} differs from "
+                      f"expected {(b, c, canvas_h, canvas_w)} (normal for tiny latents)")
+        
+        return canvas
+    
+    # ═══════════════════════════════════════════════════════════════════
+    # ZOOM IN (ПРИБЛИЖЕНИЕ)
+    # ═══════════════════════════════════════════════════════════════════
+    else:
+        scale = 1.0 + zoom_factor * 0.1
+        new_h = int(h * scale)
+        new_w = int(w * scale)
+        
+        if debug:
+            print(f"[Zoom In] Scale: {scale:.4f}, New size: {new_h}x{new_w}")
+        
+        # V3.1.1 FIX: Используем safe_interpolate для float16 совместимости
+        content_large = safe_interpolate(
+            input_tensor, 
+            size=(new_h, new_w), 
+            mode=interp_mode
+        )
+        
+        # Convergence для zoom in - определяет откуда "смотрим"
+        focus_x = int(new_w * convergence) - w // 2
+        focus_y = int(new_h * convergence_y) - h // 2
+        
+        # V3.0: Pan с auto-clamping
+        if auto_clamp_pan:
+            max_pan_x = (new_w - w) / w * 0.5
+            max_pan_y = (new_h - h) / h * 0.5
+            pan_x = max(-max_pan_x, min(max_pan_x, pan_x))
+            pan_y = max(-max_pan_y, min(max_pan_y, pan_y))
+        
+        shift_y = int(pan_y * h * 0.5)
+        shift_x = int(pan_x * w * 0.5)
+        
+        crop_y = max(0, min(new_h - h, focus_y + shift_y))
+        crop_x = max(0, min(new_w - w, focus_x + shift_x))
+        
+        cropped = content_large[:, :, crop_y:crop_y+h, crop_x:crop_x+w]
+        
+        # V3.0: НОВОЕ - Fade для zoom in (устраняет швы!)
+        # BUG FIX 3: initialise fade_mask=None so downstream code can always
+        # do a safe `if fade_mask is not None:` check.  Without this,
+        # if fade_h_in==0 or fade_w_in==0 the variable is never created but
+        # is still referenced inside the variance_correction block.
+        fade_mask = None
+        if zoom_in_fade and fade_strength > 0:
+            # Легкий fade на краях для smooth transitions
+            fade_h_in = int(h * fade_strength * 0.5)  # Меньше чем для zoom out
+            fade_w_in = int(w * fade_strength * 0.5)
+            
+            if fade_h_in > 0 and fade_w_in > 0:
+                fade_mask = torch.ones(1, 1, h, w, device=device, dtype=dtype)
+                
+                lin_x = torch.linspace(0, 1, fade_w_in, device=device, dtype=dtype)
+                lin_y = torch.linspace(0, 1, fade_h_in, device=device, dtype=dtype)
+                
+                curve_x = torch.pow(lin_x, depth_power)
+                curve_y = torch.pow(lin_y, depth_power)
+                
+                fade_mask[:, :, :, :fade_w_in] *= curve_x.view(1, 1, 1, -1)
+                fade_mask[:, :, :, -fade_w_in:] *= curve_x.flip(0).view(1, 1, 1, -1)
+                fade_mask[:, :, :fade_h_in, :] *= curve_y.view(1, 1, -1, 1)
+                fade_mask[:, :, -fade_h_in:, :] *= curve_y.flip(0).view(1, 1, -1, 1)
+                
+                cropped = cropped * fade_mask.expand_as(cropped)
+                
+                if debug:
+                    print(f"[Zoom In Fade] Applied with strength {fade_strength:.2f}")
+        
+        # Padding
+        padded = F.pad(cropped, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+        
+        # V3.0: Variance correction для устранения серости на швах
+        if variance_correction and zoom_in_fade:
+            # BUG FIX 3 (continued): use fade_mask only if it was actually
+            # created; fall back to a neutral all-ones mask when fade
+            # dimensions collapsed to zero (very small latents).
+            if fade_mask is not None:
+                correction_mask = fade_mask
+            else:
+                # Fade dimensions were zero — use a flat mask so
+                # variance_correction still runs without crashing.
+                correction_mask = torch.ones(1, 1, h, w, device=device, dtype=dtype)
+            
+            padded = apply_variance_correction(padded, correction_mask, debug=debug)
+        
+        # V3.0: Shape assertion
+        expected_shape = (b, c, h + 2*pad_h, w + 2*pad_w)
+        assert padded.shape == expected_shape, \
+            f"Shape mismatch! Expected {expected_shape}, got {padded.shape}"
+        
+        return padded
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.5. SPIRAL ZOOM (V3.1 - НОВАЯ ФУНКЦИЯ БЕЗ БАГОВ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_spiral_zoom(input_tensor, zoom_factor, pad_h, pad_w,
+                     spiral_rotation=0.5, 
+                     spiral_direction=1.0,
+                     interp_mode='bilinear', 
+                     debug=False, 
+                     **kwargs):
+    """
+    Спиральный зум с эффектом вращения.
+    
+    V3.1: ПОЛНАЯ РЕАЛИЗАЦИЯ БЕЗ БАГОВ
+    - Правильная валидация параметров
+    - Безопасная обработка особых случаев (dx=dy=0)
+    - Проверка размеров на всех этапах
+    
+    V3.1.1: КРИТИЧНЫЕ ИСПРАВЛЕНИЯ ДЛЯ FLOAT16
+    - Адаптивный epsilon для всех sqrt/division операций
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        zoom_factor: сила зума (-5.0 до 5.0)
+        pad_h, pad_w: размеры паддинга
+        spiral_rotation: сила вращения (0.0 до 2.0)
+            - 0.0 = без вращения (обычный зум)
+            - 0.5 = слабое вращение
+            - 1.0 = среднее вращение  
+            - 2.0 = сильное вращение
+        spiral_direction: направление (1.0 = по часовой, -1.0 = против)
+        interp_mode: режим интерполяции ('bilinear', 'bicubic', 'nearest')
+        debug: вывод отладочной информации
+    
+    Returns:
+        torch.Tensor: трансформированный и padded тензор
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.1.1 FIX: Получаем адаптивный epsilon для данного dtype
+    eps = get_adaptive_epsilon(dtype)
+    
+    # V3.1: Валидация параметров
+    spiral_rotation = float(max(0.0, min(2.0, spiral_rotation)))
+    spiral_direction = 1.0 if spiral_direction >= 0 else -1.0
+    zoom_factor = float(max(-5.0, min(5.0, zoom_factor)))
+    
+    if debug:
+        print(f"\n{'='*70}")
+        print(f"[Spiral Zoom V3.1.1]")
+        print(f"  Input shape: {input_tensor.shape}")
+        print(f"  Zoom Factor: {zoom_factor:.2f}")
+        print(f"  Rotation: {spiral_rotation:.2f} ({'clockwise' if spiral_direction > 0 else 'counter-clockwise'})")
+        print(f"  Interp mode: {interp_mode}")
+        print(f"  Epsilon: {eps} (for {dtype})")
+        print(f"{'='*70}\n")
+    
+    # Центр изображения
+    center_y = (h - 1) / 2.0
+    center_x = (w - 1) / 2.0
+    
+    # Создаем координатные сетки
+    y_coords = torch.arange(h, device=device, dtype=dtype).view(-1, 1).expand(h, w)
+    x_coords = torch.arange(w, device=device, dtype=dtype).view(1, -1).expand(h, w)
+    
+    # Смещение от центра
+    dy = y_coords - center_y
+    dx = x_coords - center_x
+    
+    # V3.1.1 FIX: Полярные координаты с адаптивным epsilon
+    r = torch.sqrt(dx**2 + dy**2 + eps)
+    theta = torch.atan2(dy, dx)
+    
+    # Спиральная трансформация
+    # 1. Zoom scale
+    zoom_scale = 1.0 + zoom_factor * 0.1
+    
+    # 2. Rotation - зависит от расстояния от центра
+    max_radius = math.sqrt(h**2 + w**2) / 2.0
+    # V3.1.1 FIX: Адаптивный epsilon для division
+    normalized_r = torch.clamp(r / (max_radius + eps), 0.0, 1.0)
+    
+    # Угол вращения увеличивается с расстоянием от центра (спиральный эффект)
+    rotation_angle = spiral_direction * spiral_rotation * normalized_r * math.pi
+    
+    # 3. Применяем трансформацию
+    new_theta = theta + rotation_angle
+    new_r = r * zoom_scale
+    
+    # Обратно в декартовы координаты
+    new_x = center_x + new_r * torch.cos(new_theta)
+    new_y = center_y + new_r * torch.sin(new_theta)
+    
+    # Нормализация для grid_sample [-1, 1]
+    grid_x = 2.0 * new_x / max(w - 1, 1) - 1.0
+    grid_y = 2.0 * new_y / max(h - 1, 1) - 1.0
+    
+    # V3.1 FIX: Clamp grid values для предотвращения выхода за границы
+    grid_x = torch.clamp(grid_x, -1.0, 1.0)
+    grid_y = torch.clamp(grid_y, -1.0, 1.0)
+    
+    # Собира��м grid
+    grid = torch.stack([grid_x, grid_y], dim=-1).unsqueeze(0).to(dtype)
+    
+    # V3.1: Валидация размеров grid
+    expected_grid_shape = (1, h, w, 2)
+    if grid.shape != expected_grid_shape:
+        raise ValueError(f"Grid shape mismatch! Expected {expected_grid_shape}, got {grid.shape}")
+    
+    # Применяем деформацию
+    warped = F.grid_sample(
+        input_tensor,
+        grid.expand(b, -1, -1, -1),
+        mode=interp_mode,
+        padding_mode='zeros',
+        align_corners=True
+    )
+    
+    # V3.1: Проверка после warp
+    if warped.shape != input_tensor.shape:
+        raise ValueError(f"Warped shape mismatch! Expected {input_tensor.shape}, got {warped.shape}")
+    
+    # Паддинг
+    padded = F.pad(warped, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # V3.1: Финальная проверка размеров
+    expected_padded_shape = (b, c, h + 2*pad_h, w + 2*pad_w)
+    if padded.shape != expected_padded_shape:
+        raise ValueError(f"Padded shape mismatch! Expected {expected_padded_shape}, got {padded.shape}")
+    
+    if debug:
+        print(f"[Spiral Zoom] Input shape: {input_tensor.shape}")
+        print(f"[Spiral Zoom] Output shape: {padded.shape}")
+        print(f"[Spiral Zoom] ✓ All shape checks passed")
+    
+    return padded
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.6. GRADIENT RADIAL BLENDING (V3.1 - НОВАЯ ФУНКЦИЯ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_gradient_radial_blend(input_tensor, pad_h, pad_w, 
+                                gradient_center_x=0.5, gradient_center_y=0.5,
+                                gradient_radius=1.0, debug=False):
+    """
+    Радиальный градиент для плавных переходов от центра к краям.
+    
+    V3.1: НОВАЯ ФУНКЦИЯ
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        pad_h, pad_w: размеры паддинга
+        gradient_center_x: центр по X (0.0-1.0, default 0.5)
+        gradient_center_y: центр по Y (0.0-1.0, default 0.5)
+        gradient_radius: радиус градиента (0.1-2.0, default 1.0)
+        debug: вывод отладки
+    
+    Returns:
+        torch.Tensor: padded тензор с радиальным градиентом
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # Валидация параметров
+    gradient_center_x = float(max(0.0, min(1.0, gradient_center_x)))
+    gradient_center_y = float(max(0.0, min(1.0, gradient_center_y)))
+    gradient_radius = float(max(0.1, min(2.0, gradient_radius)))
+    
+    if debug:
+        print(f"[Gradient Radial] Center: ({gradient_center_x:.2f}, {gradient_center_y:.2f}), "
+              f"Radius: {gradient_radius:.2f}")
+    
+    # Размеры с паддингом
+    canvas_h = h + 2 * pad_h
+    canvas_w = w + 2 * pad_w
+    
+    # Координаты центра градиента
+    center_y = gradient_center_y * canvas_h
+    center_x = gradient_center_x * canvas_w
+    
+    # Создаем координатную сетку
+    y = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1)
+    x = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1)
+    
+    # Расстояние от центра (нормализованное)
+    max_dist = math.sqrt(canvas_h**2 + canvas_w**2) / 2.0
+    dist = torch.sqrt((y - center_y)**2 + (x - center_x)**2) / max_dist
+    
+    # Радиальный градиент [0, 1]
+    gradient = torch.clamp(1.0 - (dist / gradient_radius), 0.0, 1.0)
+    gradient = gradient.unsqueeze(0).unsqueeze(0)  # (1, 1, canvas_h, canvas_w)
+    
+    # Circular padding для входного тензора
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # vUltimate FIX: Безопасный expand с try/except
+    try:
+        gradient_expanded = gradient.expand(b, c, canvas_h, canvas_w)
+    except RuntimeError as e:
+        if debug:
+            print(f"⚠️  [Gradient Radial] Expand failed: {e}, using broadcast_to")
+        # Fallback: используем broadcast_to
+        gradient_expanded = torch.broadcast_to(gradient, (b, c, canvas_h, canvas_w))
+    
+    # Применяем градиент (плавный переход к circular padding на краях)
+    result = padded * gradient_expanded
+    
+    if debug:
+        print(f"[Gradient Radial] Gradient range: [{gradient.min().item():.3f}, {gradient.max().item():.3f}]")
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.7. NOISE BLEND (V3.1 - НОВАЯ ФУНКЦИЯ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_noise_blend(input_tensor, pad_h, pad_w, noise_scale=5.0, 
+                     noise_octaves=2, debug=False):
+    """
+    Блендинг с процедурным шумом для органичных границ.
+    
+    V3.1: НОВАЯ ФУНКЦИЯ
+    V3.1.1: КРИТИЧНЫЕ ИСПРАВЛЕНИЯ ДЛЯ FLOAT16
+    - Адаптивный epsilon для нормализации
+    - Упрощенная формула для blend (оптимизация)
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        pad_h, pad_w: размеры паддинга
+        noise_scale: масштаб шума (1.0-10.0, default 5.0)
+        noise_octaves: количество октав шума (1-4, default 2)
+        debug: вывод отладки
+    
+    Returns:
+        torch.Tensor: padded тензор с noise blending
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.1.1 FIX: Получаем адаптивный epsilon
+    eps = get_adaptive_epsilon(dtype)
+    
+    # Валидация параметров
+    noise_scale = float(max(1.0, min(10.0, noise_scale)))
+    noise_octaves = int(max(1, min(4, noise_octaves)))
+    
+    if debug:
+        print(f"[Noise Blend] Scale: {noise_scale:.2f}, Octaves: {noise_octaves}, Epsilon: {eps}")
+    
+    # Размеры с паддингом
+    canvas_h = h + 2 * pad_h
+    canvas_w = w + 2 * pad_w
+    
+    # Создаем координатную сетку
+    y = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1)
+    x = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1)
+    
+    # Многооктавный Perlin-style шум
+    noise_mask = torch.zeros(canvas_h, canvas_w, device=device, dtype=dtype)
+    amplitude = 1.0
+    frequency = 1.0
+    
+    for octave in range(noise_octaves):
+        # Простой процедурный шум через sin/cos
+        phase_x = x * frequency * noise_scale / canvas_w * 2 * math.pi
+        phase_y = y * frequency * noise_scale / canvas_h * 2 * math.pi
+        
+        octave_noise = torch.sin(phase_x + octave) * torch.cos(phase_y + octave * 0.7)
+        noise_mask = noise_mask + octave_noise * amplitude
+        
+        amplitude *= 0.5
+        frequency *= 2.0
+    
+    # V3.1.1 FIX: Нормализация в [0, 1] с адаптивным epsilon
+    noise_mask = (noise_mask - noise_mask.min()) / (noise_mask.max() - noise_mask.min() + eps)
+    
+    # Расстояние от контента (для комбинирования с шумом)
+    content_box = (pad_h, pad_h + h, pad_w, pad_w + w)
+    distance = create_distance_map(canvas_h, canvas_w, content_box, device, dtype)
+    
+    # V3.1.1 FIX: Явное преобразование размеров для ясности
+    distance_2d = distance.squeeze(0).squeeze(0)  # (canvas_h, canvas_w)
+    
+    # Комбинируем distance с noise (больше шума на краях)
+    blend_mask = 0.7 * distance_2d + 0.3 * noise_mask
+    blend_mask = torch.clamp(blend_mask, 0.0, 1.0).unsqueeze(0).unsqueeze(0)
+    
+    # Circular padding
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # vUltimate FIX: Безопасный expand с try/except
+    try:
+        blend_mask_expanded = blend_mask.expand(b, c, canvas_h, canvas_w)
+    except RuntimeError as e:
+        if debug:
+            print(f"⚠️  [Noise Blend] Expand failed: {e}, using broadcast_to")
+        # Fallback: используем broadcast_to
+        blend_mask_expanded = torch.broadcast_to(blend_mask, (b, c, canvas_h, canvas_w))
+    
+    # V3.1.1 FIX: Упрощенная формула для blend
+    # Было: padded * (1.0 - blend_mask) + padded * blend_mask * 0.5
+    # Упрощено: padded * (1.0 - 0.5 * blend_mask)
+    result = padded * (1.0 - 0.5 * blend_mask_expanded)
+    
+    if debug:
+        print(f"[Noise Blend] Mask range: [{blend_mask.min().item():.3f}, {blend_mask.max().item():.3f}]")
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. ГЛАВНАЯ ФУНКЦИЯ (V3.0 - УЛУЧШЕНО)
+# ════════════════════════════��══════════════════════════════════════════════
+
+def validate_zoom_params(params):
+    """
+    V3.0+: нормализация zoom-параметров с сохранением старых и новых alias-ключей.
+
+    Критично для latent/router пути:
+    - сохраняем zoom_engine (раньше терялся и backend silently откатывался в auto)
+    - выравниваем edge_fade <-> zoom_in_fade
+    - выравниваем zoom_fade_to_black/zoom_fade_strength <-> fade_to_black/fade_strength
+    - принимаем debug_mode и debug
+    """
+    z_mode = params.get('zoom_mode', 'outpaint_zoom')
+    try:
+        zoom_mode = z_mode if isinstance(z_mode, ZoomMode) else ZoomMode(z_mode)
+    except Exception:
+        zoom_mode = ZoomMode.OUTPAINT_ZOOM
+
+    b_mode = params.get('blend_mode', 'circular_reflect')
+    try:
+        blend_mode = b_mode if isinstance(b_mode, BlendMode) else BlendMode(b_mode)
+    except Exception:
+        blend_mode = BlendMode.CIRCULAR_REFLECT
+
+    edge_fade = _coerce_bool_param(params.get('edge_fade', params.get('zoom_in_fade', True)), True)
+    fade_to_black = _coerce_bool_param(params.get('zoom_fade_to_black', params.get('fade_to_black', False)), False)
+    fade_strength = float(params.get('zoom_fade_strength', params.get('fade_strength', 0.3)))
+    debug_value = _coerce_bool_param(params.get('debug_mode', params.get('debug', False)), False)
+
+    return {
+        'zoom_engine': str(params.get('zoom_engine', 'auto')),
+        'zoom_factor': float(params.get('zoom_factor', 0.0)),
+        'zoom_mode': zoom_mode,
+        'blend_mode': blend_mode,
+        'convergence_point': float(params.get('convergence_point', 0.5)),
+        'convergence_y': float(params.get('convergence_y', 0.5)),
+        'depth_power': float(params.get('depth_power', 1.0)),
+        'blend_falloff': str(params.get('blend_falloff', 'smoothstep')),
+        'blend_sharpness': float(params.get('blend_sharpness', 1.0)),
+        'blend_width': params.get('blend_width', None),
+        'pan_x': float(params.get('pan_x', params.get('x_pan', 0.0))),
+        'pan_y': float(params.get('pan_y', params.get('y_pan', 0.0))),
+        'edge_fade': edge_fade,
+        'zoom_in_fade': edge_fade,
+        'zoom_fade_to_black': fade_to_black,
+        'zoom_fade_strength': fade_strength,
+        'fade_to_black': fade_to_black,
+        'fade_strength': fade_strength,
+        'fade_edge_strength': float(params.get('fade_edge_strength', 0.15)),
+        'noise_strength': float(params.get('noise_strength', 1.0)),
+        'interp_mode': str(params.get('interp_mode', 'bilinear')),
+        'variance_correction': _coerce_bool_param(params.get('variance_correction', True), True),
+        'auto_clamp_pan': _coerce_bool_param(params.get('auto_clamp_pan', True), True),
+        'adaptive_noise_scale': _coerce_bool_param(params.get('adaptive_noise_scale', True), True),
+        'debug': debug_value,
+        'debug_mode': debug_value,
+        'spiral_rotation': float(params.get('spiral_rotation', 0.5)),
+        'spiral_direction': float(params.get('spiral_direction', 1.0)),
+        'gradient_center_x': float(params.get('gradient_center_x', 0.5)),
+        'gradient_center_y': float(params.get('gradient_center_y', 0.5)),
+        'gradient_radius': float(params.get('gradient_radius', 1.0)),
+        'noise_scale': float(params.get('noise_scale', 5.0)),
+        'noise_octaves': int(params.get('noise_octaves', 2)),
+    }
+def apply_unified_zoom(input_tensor, pad_h, pad_w, zoom_factor=0.0, 
+                      zoom_mode=ZoomMode.OUTPAINT_ZOOM, 
+                      blend_mode=BlendMode.CIRCULAR_REFLECT,
+                      convergence_point=0.5, convergence_y=0.5,
+                      depth_power=1.0,
+                      blend_falloff='smoothstep', blend_sharpness=1.0, 
+                      blend_width=None, 
+                      pan_x=0.0, pan_y=0.0,
+                      fade_to_black=False, fade_strength=0.3,
+                      fade_edge_strength=0.15,
+                      noise_strength=1.0,
+                      interp_mode='bilinear',
+                      zoom_in_fade=True,
+                      variance_correction=True,
+                      auto_clamp_pan=True,
+                      adaptive_noise_scale=True,
+                      debug=False,
+                      extra_params=None):
+    
+    # 1. Запоминаем оригинальный тип (скорее всего float16)
+    original_dtype = input_tensor.dtype
+    
+    # 2. ПРИНУДИТЕЛЬНО ПЕРЕВОДИМ В FLOAT32 для вычислений
+    # Это предотвращает появление "кислотного шума" (NaN/Inf)
+    input_tensor = input_tensor.float()
+    
+    # Защита от нулевого zoom
+    is_active = (abs(zoom_factor) > 0.001) or (abs(pan_x) > 0.001) or (abs(pan_y) > 0.001)
+    
+    if not is_active:
+        result = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+        # Возвращаем в исходном типе
+        return result.to(dtype=original_dtype)
+    
+    if debug:
+        print(f"[Unified Zoom] Mode: {zoom_mode}, Dtype safe cast: {original_dtype} -> float32")
+
+    # Переменная для результата
+    result = None
+
+    # ═══════════════════════════════════════════════════════════════════
+    # ВЫЗОВ ФУНКЦИЙ (Теперь напрямую, так как они в этом же файле)
+    # ═══════════════════════════════════════════════════════════════════
+    
+    if zoom_mode == ZoomMode.OUTPAINT_ZOOM:
+        result = apply_outpaint_zoom(
+            input_tensor, 
+            zoom_factor, 
+            pad_h, pad_w,
+            convergence=convergence_point,
+            convergence_y=convergence_y,
+            fade_strength=fade_strength,
+            depth_power=depth_power,
+            pan_x=pan_x, pan_y=pan_y,
+            fade_to_black=fade_to_black,
+            fade_edge_strength=fade_edge_strength,
+            blend_mode=blend_mode.value if isinstance(blend_mode, BlendMode) else str(blend_mode),
+            noise_strength=noise_strength,
+            interp_mode=interp_mode,
+            zoom_in_fade=zoom_in_fade,
+            variance_correction=variance_correction,
+            auto_clamp_pan=auto_clamp_pan,
+            adaptive_noise_scale=adaptive_noise_scale,
+            debug=debug,
+            extra_params=extra_params
+        )
+    
+    elif zoom_mode == ZoomMode.GRID_WARP:
+        x_warped = apply_grid_warp_zoom(
+            input_tensor, 
+            zoom_factor, 
+            convergence_point,
+            depth_power,
+            pan_x, pan_y,
+            convergence_y,
+            interp_mode=interp_mode,
+            debug=debug
+        )
+        result = F.pad(x_warped, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=0)
+    
+    elif zoom_mode == ZoomMode.SPIRAL_ZOOM:
+        spiral_rotation = 0.5
+        spiral_direction = 1.0
+        
+        if extra_params:
+            spiral_rotation = extra_params.get('spiral_rotation', 0.5)
+            spiral_direction = extra_params.get('spiral_direction', 1.0)
+        
+        result = apply_spiral_zoom(
+            input_tensor, 
+            zoom_factor, 
+            pad_h, pad_w,
+            spiral_rotation=spiral_rotation,
+            spiral_direction=spiral_direction,
+            interp_mode=interp_mode,
+            debug=debug
+        )
+    
+    elif zoom_mode in [ZoomMode.CONVERGENCE_SHIFT, ZoomMode.HYBRID, ZoomMode.BLEND_TRANSITION]:
+        x_shifted = apply_legacy_shift_zoom(
+            input_tensor, 
+            zoom_factor, 
+            convergence_point, 
+            depth_power, 
+            pan_x, pan_y,
+            auto_clamp_pan=auto_clamp_pan,
+            debug=debug
+        )
+        
+        if zoom_mode == ZoomMode.CONVERGENCE_SHIFT:
+            padded = F.pad(x_shifted, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+            if fade_to_black:
+                # Импорт только если нужен (для совместимости)
+                try:
+                    from improved_tiling_functions import compute_blend_fade_to_black
+                    padded = compute_blend_fade_to_black(padded, pad_h, pad_w, fade_strength)
+                except ImportError:
+                    pass
+            result = padded
+        else:
+            # Fallback для остальных режимов
+            try:
+                from improved_tiling_functions import compute_advanced_blend_padding
+                mode_str = blend_mode.value if isinstance(blend_mode, BlendMode) else str(blend_mode)
+                mode_adv = mode_str.split('_')[0] if '_' in mode_str else 'circular'
+                
+                result = compute_advanced_blend_padding(
+                    x_shifted, pad_h, pad_w,
+                    mode_simple='replicate',
+                    mode_advanced=mode_adv,
+                    blend_strength=0.7,
+                    blend_width=blend_width,
+                    falloff_curve=blend_falloff,
+                    edge_sharpness=blend_sharpness,
+                    fade_to_black=fade_to_black,
+                    fade_strength=fade_strength
+                )
+                
+                # ═══════════════════════════════════════════════════════════════
+                # КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: Защита от переполнения float16
+                # ═══════════════════════════════════════════════════════════════
+                # Это исправление устраняет "серый шум"!
+                # 
+                # Проблема: compute_advanced_blend_padding может создать значения
+                # за пределами диапазона float16 (-65504 до 65504).
+                # При конвертации float32→float16 они превращаются в Inf/NaN → шум
+                #
+                # Решение: Сначала очищаем и ограничиваем В FLOAT32,
+                # затем безопасно конвертируем в float16
+                # ═══════════════════════════════════════════════════════════════
+                
+                if original_dtype == torch.float16:
+                    # Шаг 1: Очищаем NaN/Inf в float32 (пока значения не испорчены)
+                    result = torch.nan_to_num(result, nan=0.0, posinf=65504.0, neginf=-65504.0)
+                    
+                    # Шаг 2: Ограничиваем диапазон значений ПЕРЕД конвертацией
+                    # float16 range: -65504 to 65504
+                    result = torch.clamp(result, min=-65504.0, max=65504.0)
+                    
+                    if debug:
+                        print(f"[Unified Zoom] Float16 safety: clamped to [-65504, 65504]")
+                
+            except ImportError:
+                result = F.pad(x_shifted, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+
+    # Fallback если режим не найден
+    if result is None:
+        result = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+
+    # ═══════════════════════════════════════════════════════════════════
+    # 3. БЕЗОПАСНАЯ КОНВЕРТАЦИЯ ОБРАТНО В ИСХОДНЫЙ ТИП
+    # ═══════════════════════════════════════════════════════════════════
+    # Теперь, когда все опасные значения очищены и ограничены,
+    # можно безопасно конвертировать в float16
+    # ═══════════════════════════════════════════════════════════════════
+    
+    if torch.is_tensor(result) and result.dtype != original_dtype:
+        # Если мы ещё не применили защиту (для других режимов кроме HYBRID/BLEND_TRANSITION)
+        if original_dtype == torch.float16:
+            # Финальная очистка перед конвертацией (на всякий случай)
+            result = torch.nan_to_num(result, nan=0.0, posinf=65504.0, neginf=-65504.0)
+            result = torch.clamp(result, min=-65504.0, max=65504.0)
+        
+        # Теперь конвертируем - безопасно!
+        result = result.to(dtype=original_dtype)
+
+    return result

asds/libs/improved_tiling_functions.py

@@ -0,0 +1,644 @@
+import torch
+import torch.nn.functional as F
+import math
+import numpy as np
+from collections import OrderedDict
+
+# =======================================================================
+# vUltimate - REAL Deep Code Audit
+# Based on v13 (THE_last_version) with CRITICAL FIXES
+# =======================================================================
+
+# =======================================================================
+# BOOL NORMALIZATION HELPERS
+# =======================================================================
+
+def _coerce_bool_param(value, default=False):
+    """Robust bool parsing for UI values, presets and metadata strings."""
+    if value is None:
+        return bool(default)
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return value != 0
+    if isinstance(value, str):
+        s = value.strip().lower()
+        if s in {'1', 'true', 'yes', 'y', 'on'}:
+            return True
+        if s in {'0', 'false', 'no', 'n', 'off', 'none', 'null', ''}:
+            return False
+    return bool(value)
+
+# =======================================================================
+# 1. SMART CACHING (Speed optimization ~15-20%)
+# =======================================================================
+class SmartMaskCache:
+    """LRU cache for blend masks to avoid regeneration"""
+    def __init__(self, max_size=50):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+
+    def get(self, key):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        return None
+
+    def set(self, key, value):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        self.cache[key] = value
+        if len(self.cache) > self.max_size:
+            self.cache.popitem(last=False)
+
+# Global cache instance
+_MASK_CACHE = SmartMaskCache()
+
+
+# =======================================================================
+# 2. SAFE EPSILON (🔴 CRITICAL FIX: Infinite recursion bug in v13!)
+# =======================================================================
+def get_safe_epsilon(tensor_or_dtype):
+    """
+    Float16-safe epsilon - CRITICAL for half precision!
+    
+    🔴 vUltimate Fix: v13 had INFINITE RECURSION bug:
+    Line 51: return get_safe_epsilon(torch.float16)  # INFINITE LOOP!
+    
+    Args:
+        tensor_or_dtype: torch.Tensor or torch.dtype
+    
+    Returns:
+        float: safe epsilon for given dtype
+    """
+    if isinstance(tensor_or_dtype, torch.Tensor):
+        dtype = tensor_or_dtype.dtype
+    else:
+        dtype = tensor_or_dtype
+    
+    # Float16 minimum value ~6e-5, so 1e-6 causes underflow
+    if dtype in (torch.float16, torch.bfloat16):
+        return 1e-3  # Safe for half precision
+    elif dtype == torch.float32:
+        return 1e-6  # 🔴 FIX: Changed from recursive call to direct value
+    else:
+        return 1e-12  # High precision for float64
+
+
+# =======================================================================
+# 3. LATENT COLOR FIX (Variance-preserving blend)
+# =======================================================================
+def blend_with_variance_fix(a, b, mask):
+    """
+    Mathematically correct blending of latent noise.
+    ✅ FLOAT16 FIX: Safe sqrt with adaptive epsilon
+    
+    Args:
+        a: Primary layer (active where mask=1) -> Advanced/Circular
+        b: Background layer (active where mask=0) -> Simple/Replicate
+        mask: Blend mask [0,1]
+    
+    🔴 IMPORTANT: From v11+ the mask semantics are:
+        mask=1.0 on EDGES (where Advanced padding is needed)
+        mask=0.0 in CENTER (where content or Simple padding is)
+    """
+    # 1. Linear blend
+    blended = a * mask + b * (1 - mask)
+    
+    # 2. Variance correction with adaptive epsilon
+    eps_val = get_safe_epsilon(mask.dtype)
+    variance_fix = torch.sqrt(mask**2 + (1 - mask)**2 + eps_val)
+    
+    return blended / variance_fix
+
+
+# =======================================================================
+# 4. LEGACY FADE TO BLACK (For ZOOM effect) ✅
+# =======================================================================
+def compute_blend_fade_to_black(padded, pad_h, pad_w, fade_strength=0.1):
+    """
+    ⚡ LEGACY MODE for Zoom effect (V3.5 logic from v11-v13) ⚡
+    
+    Gradient now covers ENTIRE padding + part of content.
+    Result: Beautiful vignette from 0 (edge) to 1 (center).
+    
+    🔴 vUltimate Note: This is v13 logic (NOT v7 logic).
+    v7 applied fade only to content inside padding zones.
+    v13 applies fade to ENTIRE image including padding.
+    
+    Args:
+        padded: Already padded tensor [B, C, H, W]
+        pad_h: Vertical padding size
+        pad_w: Horizontal padding size
+        fade_strength: Fade depth into content (0.0-1.0), typically 0.05-0.2
+    
+    Returns:
+        Tensor with darkened edges
+    """
+    b, c, H, W = padded.shape
+    
+    # Calculate content size (without padding)
+    h_content = max(H - 2 * pad_h, 0)
+    w_content = max(W - 2 * pad_w, 0)
+    
+    # Fade depth inside content
+    blend_in_h = int(h_content * fade_strength)
+    blend_in_w = int(w_content * fade_strength)
+    
+    # Total fade zone = Padding + Entry into content
+    total_fade_h = pad_h + blend_in_h
+    total_fade_w = pad_w + blend_in_w
+    
+    result = padded.clone()
+    
+    # ═══════════════════════════════════════════════════════════════════
+    # VERTICAL EDGES
+    # ═══════════════════════════════════════════════════════════════════
+    if total_fade_h > 0:
+        # Create gradient 0 -> 1
+        fade = torch.linspace(0, 1, steps=total_fade_h, 
+                            device=padded.device, dtype=padded.dtype)
+        fade = fade.view(1, 1, -1, 1)  # Shape: (1,1,H,1)
+        
+        # Top (from 0 to total_fade_h)
+        safe_h = min(total_fade_h, H)
+        result[:, :, :safe_h, :] *= fade[:, :, :safe_h, :]
+        
+        # Bottom (from H-total_fade_h to H) - use flipped gradient
+        result[:, :, -safe_h:, :] *= fade[:, :, :safe_h, :].flip(2)
+
+    # ═══════════════════════════════════════════════════════════════════
+    # HORIZONTAL EDGES
+    # ═══════════════════════════════════════════════════════════════════
+    if total_fade_w > 0:
+        # Create gradient 0 -> 1
+        fade = torch.linspace(0, 1, steps=total_fade_w, 
+                            device=padded.device, dtype=padded.dtype)
+        fade = fade.view(1, 1, 1, -1)  # Shape: (1,1,1,W)
+        
+        # Left
+        safe_w = min(total_fade_w, W)
+        result[:, :, :, :safe_w] *= fade[:, :, :, :safe_w]
+        
+        # Right
+        result[:, :, :, -safe_w:] *= fade[:, :, :, :safe_w].flip(3)
+
+    return result
+
+
+# =======================================================================
+# 5. ADVANCED BLEND MASK (For modern tiling mode)
+# =======================================================================
+def create_advanced_blend_mask(h, w, blend_width, device, dtype=torch.float32, 
+                               falloff_curve="smoothstep", edge_sharpness=1.0):
+    """
+    Creates cached edge blend mask.
+    
+    🔴 MASK SEMANTICS (v11+ convention):
+        1.0 = on the very EDGE (where Advanced Padding is needed)
+        0.0 = in CENTER (where content or Simple Padding is)
+    
+    Args:
+        h, w: Mask dimensions
+        blend_width: Transition zone width (pixels)
+        device: Torch device
+        dtype: Data type
+        falloff_curve: Curve type ('linear', 'smoothstep', 'cosine')
+        edge_sharpness: Edge sharpness (1.0 = normal, >1 = sharper, <1 = softer)
+    
+    Returns:
+        Mask of size [1, 1, h, w]
+    """
+    if blend_width <= 0:
+        # Defensive behaviour for invalid/manual callers: no transition zone.
+        # Normal UI flow uses 0=None(auto) before reaching this helper. Returning
+        # zeros is much safer than blending the entire frame as 'advanced'.
+        return torch.zeros(1, 1, h, w, device=device, dtype=dtype)
+
+    # BUG FIX 6a: normalise falloff_curve to a known value; warn loudly if
+    # the UI has sent something the backend doesn't actually implement.
+    _KNOWN_FALLOFFS = {'linear', 'smoothstep', 'cosine'}
+    if falloff_curve not in _KNOWN_FALLOFFS:
+        print(f"[AdvancedBlend] Warning: unsupported falloff_curve '{falloff_curve}' "
+              f"— falling back to 'smoothstep'. Supported: {sorted(_KNOWN_FALLOFFS)}")
+        falloff_curve = 'smoothstep'
+
+    blend_w = min(blend_width, w // 2)
+    blend_h = min(blend_width, h // 2)
+    
+    mask = torch.zeros((1, 1, h, w), device=device, dtype=dtype)
+    
+    def get_ramp(size):
+        """Generate gradient with configurable curve.
+        BUG FIX: size==1 через linspace(0,1,1) давал [0], то есть нулевую маску.
+        Теперь для size<=1 возвращаем ones — граничный пиксель получает полный вес.
+        """
+        if size <= 1:
+            return torch.ones(max(size, 1), device=device, dtype=dtype)
+        t = torch.linspace(0, 1, steps=size, device=device, dtype=dtype)
+        if edge_sharpness != 1.0:
+            t = torch.pow(t, edge_sharpness)
+        
+        if falloff_curve == 'smoothstep':
+            return t * t * (3 - 2 * t)
+        elif falloff_curve == 'cosine':
+            return (1 - torch.cos(t * math.pi)) / 2
+        elif falloff_curve == 'linear':
+            return t
+        return t
+
+    # Fill edges
+    if blend_w > 0:
+        ramp = get_ramp(blend_w)
+        # Left edge
+        mask[:, :, :, :blend_w] = torch.maximum(mask[:, :, :, :blend_w], 
+                                                 ramp.flip(0).view(1,1,1,-1))
+        # Right edge
+        mask[:, :, :, -blend_w:] = torch.maximum(mask[:, :, :, -blend_w:], 
+                                                  ramp.view(1,1,1,-1))
+
+    if blend_h > 0:
+        ramp = get_ramp(blend_h)
+        # Top edge
+        mask[:, :, :blend_h, :] = torch.maximum(mask[:, :, :blend_h, :], 
+                                                 ramp.flip(0).view(1,1,-1,1))
+        # Bottom edge
+        mask[:, :, -blend_h:, :] = torch.maximum(mask[:, :, -blend_h:, :], 
+                                                  ramp.view(1,1,-1,1))
+        
+    return mask
+
+
+# =======================================================================
+# 6. IMPROVED BLEND PADDING (Main tiling function)
+# =======================================================================
+def compute_advanced_blend_padding(input_tensor, pad_h, pad_w, 
+                                 mode_simple='replicate', 
+                                 mode_advanced='circular',
+                                 blend_strength=0.5, 
+                                 blend_width=None, 
+                                 falloff_curve='smoothstep', 
+                                 edge_sharpness=1.0,
+                                 fade_to_black=False, 
+                                 fade_strength=0.1):
+    """
+    IMPROVED PADDING MODE
+    
+    Two operation modes:
+    
+    1. FADE TO BLACK (fade_to_black=True) - for Zoom effect:
+       - Applies one padding (mode_advanced)
+       - DARKENS edges, creating zoom out effect
+       - Uses legacy compute_blend_fade_to_black function
+       
+    2. BLEND TWO PADDINGS (fade_to_black=False) - for quality edges:
+       - Creates two different paddings (simple and advanced)
+       - Blends them via mask
+       - Applies variance fix for color correction
+       - Does NOT create zoom effect
+    
+    Args:
+        input_tensor: Original tensor WITHOUT padding [B, C, H, W]
+        pad_h, pad_w: Padding sizes
+        mode_simple: Mode for "simple" padding ('replicate', 'constant')
+        mode_advanced: Mode for "advanced" padding ('circular', 'reflect')
+        blend_strength: Blend strength (0.0-1.0)
+        blend_width: Transition width (None = auto)
+        falloff_curve: Gradient curve type
+        edge_sharpness: Edge sharpness
+        fade_to_black: If True, uses legacy darkening mode
+        fade_strength: Darkening strength for fade_to_black mode
+    
+    Returns:
+        Padded tensor [B, C, H+2*pad_h, W+2*pad_w]
+    """
+    
+    # ═══════════════════════════════════════════════════════════════════
+    # MODE 1: FADE TO BLACK (for Zoom)
+    # ═══════════════════════════════════════════════════════════════════
+    if fade_to_black:
+        # Apply ONE padding first
+        if isinstance(mode_advanced, str):
+            if mode_advanced == 'reflect':
+                b, c, h, w = input_tensor.shape
+                if pad_w < w and pad_h < h:
+                    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+                else:
+                    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='replicate')
+            else:  # circular
+                padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode=mode_advanced)
+        else:
+            padded = mode_advanced  # Pre-computed tensor
+        
+        # Darken edges (now works correctly!)
+        return compute_blend_fade_to_black(padded, pad_h, pad_w, fade_strength)
+    
+    # ═══════════════════════════════════════════════════════════════════
+    # MODE 2: BLEND TWO PADDINGS (Tiling)
+    # ═══════════════════════════════════════════════════════════════════
+    
+    # If disabled
+    if blend_strength <= 0.001:
+        if mode_simple == 'constant':
+            return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=0)
+        return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode=mode_simple)
+
+    # If 100% strength
+    if blend_strength >= 0.999:
+        if isinstance(mode_advanced, str):
+            if mode_advanced == 'reflect':
+                b, c, h, w = input_tensor.shape
+                if pad_w < w and pad_h < h:
+                    return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+                else:
+                    return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='replicate')
+            return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode=mode_advanced)
+        return mode_advanced  # Pre-computed tensor
+
+    # 1. Prepare layers
+    if mode_simple == 'constant':
+        simple = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=0)
+    else:
+        simple = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode=mode_simple)
+        
+    if isinstance(mode_advanced, str):
+        if mode_advanced == 'reflect':
+            b, c, h, w = input_tensor.shape
+            if pad_w < w and pad_h < h:
+                advanced = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+            else:
+                advanced = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='replicate')
+        else:  # circular
+            advanced = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    else:
+        advanced = mode_advanced  # Pre-computed
+
+    # 2. Get mask from cache
+    if blend_width is None: 
+        blend_width = max(pad_h, pad_w)
+    
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # 🔴 vUltimate Fix: Enhanced cache key WITH dtype (v11+ feature)
+    cache_key = (h, w, pad_h, pad_w, blend_width, falloff_curve, edge_sharpness, 
+                 str(device), str(dtype))
+    mask = _MASK_CACHE.get(cache_key)
+    
+    if mask is None:
+        H_pad, W_pad = simple.shape[2:]
+        mask = create_advanced_blend_mask(H_pad, W_pad, blend_width, device, 
+                                         dtype, falloff_curve, edge_sharpness)
+        _MASK_CACHE.set(cache_key, mask)
+
+    # 3. Blend with variance fix
+    final_mask = mask * blend_strength
+    
+    # 🔴 vUltimate: v11+ semantics: advanced (mask=1 on edges) / simple (mask=0 in center)
+    return blend_with_variance_fix(advanced, simple, final_mask)
+
+
+# =======================================================================
+# 7. MULTI-RESOLUTION (Temporal strategy)
+# =======================================================================
+class BlendStrategy:
+    """Interpolation strategies for multi-resolution transitions"""
+    LINEAR = "linear"
+    COSINE = "cosine"
+    EXPONENTIAL = "exponential"
+    SIGMOID = "sigmoid"
+
+class MultiResStrategy:
+    """Handles temporal blending curves for progressive detail addition"""
+    def __init__(self, strategy_type=BlendStrategy.COSINE):
+        self.strategy_type = strategy_type
+
+    def get_factor(self, progress, sharpness=1.0):
+        """Calculate blend factor based on progress (0.0 to 1.0)"""
+        t = max(0.0, min(1.0, progress))
+        if sharpness != 1.0:
+            t = math.pow(t, sharpness)
+
+        if self.strategy_type == BlendStrategy.LINEAR:
+            return t
+        elif self.strategy_type == BlendStrategy.COSINE:
+            return (1.0 - math.cos(t * math.pi)) / 2.0
+        elif self.strategy_type == BlendStrategy.EXPONENTIAL:
+            return math.pow(t, 2)
+        elif self.strategy_type == BlendStrategy.SIGMOID:
+            if t <= 0: return 0.0
+            if t >= 1: return 1.0
+            return 1.0 / (1.0 + math.exp(-12.0 * (t - 0.5)))
+        return t
+
+def apply_multires_blend(tensor_simple, tensor_advanced, current_step, 
+                        start_step, end_step, 
+                        strategy="cosine", 
+                        transition_start=0.0, 
+                        transition_end=0.3, 
+                        sharpness=1.0, 
+                        enabled=False):
+    """
+    Progressive blending from simple to advanced over denoising steps.
+    
+    Args:
+        tensor_simple: Low-detail padding result
+        tensor_advanced: High-detail padding result
+        current_step: Current denoising step
+        start_step, end_step: Denoising range
+        strategy: Interpolation curve type
+        transition_start, transition_end: Transition window (0.0-1.0)
+        sharpness: Curve adjustment
+        enabled: Master switch
+    
+    Returns:
+        Blended tensor
+    """
+    if not enabled:
+        return tensor_advanced
+
+    # BUG FIX 6b: normalise strategy to a supported value before use.
+    _KNOWN_STRATEGIES = {BlendStrategy.LINEAR, BlendStrategy.COSINE,
+                         BlendStrategy.EXPONENTIAL, BlendStrategy.SIGMOID}
+    _STRATEGY_ALIASES = {
+        'linear': BlendStrategy.LINEAR,
+        'cosine': BlendStrategy.COSINE,
+        'exponential': BlendStrategy.EXPONENTIAL,
+        'sigmoid': BlendStrategy.SIGMOID,
+    }
+    if isinstance(strategy, str):
+        strategy_key = strategy.lower()
+        if strategy_key not in _STRATEGY_ALIASES:
+            print(f"[MultiRes] Warning: unsupported strategy '{strategy}' "
+                  f"— falling back to 'cosine'. "
+                  f"Supported: {sorted(_STRATEGY_ALIASES.keys())}")
+            strategy = BlendStrategy.COSINE
+        else:
+            strategy = _STRATEGY_ALIASES[strategy_key]
+    elif strategy not in _KNOWN_STRATEGIES:
+        print(f"[MultiRes] Warning: unknown strategy {strategy!r} — falling back to cosine")
+        strategy = BlendStrategy.COSINE
+
+    total_steps = end_step - start_step
+    if total_steps <= 0: 
+        return tensor_advanced
+
+    step_frac = (current_step - start_step) / total_steps
+    step_frac = max(0.0, min(1.0, step_frac))
+    
+    if step_frac < transition_start:
+        local_progress = 0.0
+    elif step_frac > transition_end:
+        local_progress = 1.0
+    else:
+        duration = transition_end - transition_start
+        if duration <= 0:
+            local_progress = 1.0
+        else:
+            local_progress = (step_frac - transition_start) / duration
+
+    strat = MultiResStrategy(strategy)
+    alpha = strat.get_factor(local_progress, sharpness)
+
+    if alpha <= 0.001: 
+        return tensor_simple
+    if alpha >= 0.999: 
+        return tensor_advanced
+
+    # Standard lerp (temporal blend, not spatial)
+    return tensor_simple * (1.0 - alpha) + tensor_advanced * alpha
+
+
+# =======================================================================
+# 8. HELPER FUNCTIONS (From v13 for compatibility)
+# =======================================================================
+
+def create_circular_mask(h, w, center_x=0.5, center_y=0.5, radius=0.5, 
+                        device='cpu', dtype=torch.float32):
+    """
+    Creates circular mask (white circle on black background).
+    ✅ FLOAT16 FIX: Safe sqrt
+    
+    NOTE: This is v13 version (radial distance mask).
+    Different from v1/exp which don't have this function.
+    """
+    eps_val = get_safe_epsilon(dtype)
+    
+    # Create coordinate grid
+    y, x = torch.meshgrid(
+        torch.linspace(-1, 1, h, device=device, dtype=dtype),
+        torch.linspace(-1, 1, w, device=device, dtype=dtype),
+        indexing='ij'
+    )
+    
+    # Shift center
+    x = x - (center_x - 0.5) * 2
+    y = y - (center_y - 0.5) * 2
+    
+    # Calculate distance from center with protection
+    dist = torch.sqrt(x*x + y*y + eps_val)
+    
+    # Create soft mask (smooth edges 0.1)
+    mask = 1.0 - torch.clamp((dist - (radius - 0.1)) / 0.2, 0, 1)
+    
+    # Add channel and batch dimensions
+    if len(mask.shape) == 2:
+        mask = mask.unsqueeze(0).unsqueeze(0)
+        
+    return mask
+
+def create_fade_to_black_mask(h, w, strength=0.1, device='cpu', dtype=torch.float32):
+    """
+    Creates vignette (darkening towards edges).
+    ✅ FLOAT16 FIX: Safe sqrt
+    
+    NOTE: This is v13 version (radial vignette).
+    Different from v1/exp which don't have this function.
+    """
+    eps_val = get_safe_epsilon(dtype)
+    
+    y, x = torch.meshgrid(
+        torch.linspace(-1, 1, h, device=device, dtype=dtype),
+        torch.linspace(-1, 1, w, device=device, dtype=dtype),
+        indexing='ij'
+    )
+    
+    # sqrt with protection
+    dist = torch.sqrt(x*x + y*y + eps_val)
+    
+    # Normalize so corners are 1.0 (max distance ~1.41)
+    dist = dist / 1.4142
+    
+    # Invert: center white (1), edges black (0)
+    threshold = 1.0 - strength
+    mask = 1.0 - torch.clamp((dist - threshold) / strength, 0, 1)
+    
+    if len(mask.shape) == 2:
+        mask = mask.unsqueeze(0).unsqueeze(0)
+        
+    return mask
+
+
+# =======================================================================
+# 9. PARAMETER VALIDATION HELPERS
+# =======================================================================
+
+def validate_blend_params(params):
+    """Extract and validate blend parameters from dict.
+    Unsupported falloff values are normalised here with a warning so callers
+    never silently receive a mode the backend cannot honour.
+    Supported: 'linear', 'smoothstep', 'cosine'
+    """
+    falloff = params.get('blend_falloff', 'smoothstep')
+    _SUPPORTED_FALLOFFS = {'linear', 'smoothstep', 'cosine'}
+    if falloff not in _SUPPORTED_FALLOFFS:
+        print(f"[validate_blend_params] Warning: unsupported blend_falloff '{falloff}' "
+              f"— falling back to 'smoothstep'. Supported: {sorted(_SUPPORTED_FALLOFFS)}")
+        falloff = 'smoothstep'
+
+    raw_width = params.get('blend_width', None)
+    width = None if raw_width is None else int(raw_width)
+    if width is not None and width <= 0:
+        # UI contract: 0 means auto. Keep helper-level validation aligned with
+        # the main script and avoid surprising low-level whole-frame blending.
+        width = None
+
+    return {
+        'strength': float(params.get('blend_strength', 0.5)),
+        'width': width,
+        'falloff': falloff,
+        'sharpness': float(params.get('blend_sharpness', 1.0)),
+        'fade_to_black': _coerce_bool_param(params.get('blend_fade_to_black', False), False),
+        'fade_strength': float(params.get('blend_fade_strength', 0.1))
+    }
+
+def validate_multires_params(params):
+    """Extract and validate multi-resolution parameters from dict.
+    Unsupported strategy values are normalised here with a warning.
+    Supported: 'linear', 'cosine', 'exponential', 'sigmoid'
+    """
+    strategy = params.get('multires_strategy', 'cosine')
+    _SUPPORTED_STRATEGIES = {'linear', 'cosine', 'exponential', 'sigmoid'}
+    if strategy not in _SUPPORTED_STRATEGIES:
+        print(f"[validate_multires_params] Warning: unsupported multires_strategy '{strategy}' "
+              f"— falling back to 'cosine'. Supported: {sorted(_SUPPORTED_STRATEGIES)}")
+        strategy = 'cosine'
+
+    return {
+        'strategy': strategy,
+        'transition_start': float(params.get('multires_start', 0.0)),
+        'transition_end': float(params.get('multires_end', 0.3)),
+        'sharpness': float(params.get('multires_sharpness', 1.0))
+    }
+
+# =======================================================================
+# vUltimate - End of File
+# CRITICAL FIXES APPLIED:
+# ✅ Fix 1: Infinite recursion in get_safe_epsilon (v13 bug at line 51/65)
+# ✅ Fix 2: Correct v11+ mask semantics (advanced first, mask=1.0 on edges)
+# ✅ Fix 3: Cache key includes dtype (v11+ improvement)
+# ✅ Fix 4: Safe reflect with size validation
+# ✅ Fix 5: v13 fade_to_black logic (not v7 logic)
+# ✅ Fix 6: v13 circular/vignette masks (not v1/exp)
+# =======================================================================