Delete negative_rejection_steering/scripts/nrs_kohaku_enhanced_v2 (1).py

negative_rejection_steering/scripts/nrs_kohaku_enhanced_v2 (1).py

@@ -1,1220 +0,0 @@
-import math
-import torch
-import gradio as gr
-from modules import scripts, script_callbacks, sd_samplers_cfg_denoiser, shared
-
-# ==============================================================================
-# NRS + KOHAKU ENHANCED — Version 2.0
-#
-# Improvements over v1:
-#  1. Midpoint Refinement (replaces flawed Antipodal — correct Kohaku principle)
-#  2. Curve Scheduling (12 curves: Constant/Linear/Cosine/Power/Repeating/Sawtooth)
-#  3. CADS Trapezoidal Schedule (tau1/tau2 annealing)
-#  4. Adaptive Phases (Euler → DPM++ → Detail, from adaptive_progressive.py)
-#  5. Per-Channel NRS (independent processing per latent channel)
-#  6. AD Normalization (Absolute Deviation, more robust than L2)
-#  7. Variance Preserving Rescale (phi blend)
-#  8. Interpolate Phi (NRS ↔ plain CFG blend)
-#  9. CFG Drift Correction (mean/median centering, from adept_sampler_v4)
-# 10. Momentum smoothing (from res_solver / clybius)
-# 11. GE-Gamma Extrapolation (from gradient_estimation.py)
-# 12. Native Detail Boost (Gaussian HF enhancement, from adept_sampler_v4)
-# 13. Spectral Modulation (FFT frequency correction, from adept_sampler_v4)
-# 14. Uncond Noise & Scale (from forge_condBlast)
-# 15. Output Clamp (adaptive sigma-based, from adept_sampler_v4)
-# ==============================================================================
-
-CURVE_CHOICES = [
-    "Constant",
-    "Linear Down", "Linear Up",
-    "Cosine Down", "Cosine Up",
-    "Half Cosine Down", "Half Cosine Up",
-    "Power Down", "Power Up",
-    "Linear Repeating", "Cosine Repeating",
-    "Sawtooth",
-]
-
-SCHED_MODES = ["Off", "Individual Curves", "CADS Anneal", "Adaptive Phases"]
-INTER_STEP_MODES = ["Off", "Momentum", "GE-Gamma"]
-DRIFT_METHODS = ["mean", "median"]
-
-
-# ==============================================================================
-# ЧАСТЬ 1: МАТЕМАТИЧЕСКОЕ ЯДРО
-# ==============================================================================
-
-def _nrs_core(x_orig, cond, uncond, sigma, skew, stretch, squash, use_ad_norm=False):
-    """
-    Base NRS math kernel.
-    use_ad_norm: use Absolute Deviation norm for squash (more robust to outliers).
-    Source: dynthres_core (3).py variability_measure='AD'
-    """
-    is_v_pred = False
-    if hasattr(shared.sd_model, 'parameterization'):
-        is_v_pred = shared.sd_model.parameterization == "v"
-
-    if isinstance(sigma, torch.Tensor):
-        sig_tens = sigma[0]
-    else:
-        sig_tens = torch.tensor(sigma, device=cond.device, dtype=cond.dtype)
-    if sig_tens.dtype != cond.dtype:
-        sig_tens = sig_tens.to(dtype=cond.dtype)
-
-    sig_tens = sig_tens.view(1, 1, 1, 1)
-    sig_root = (sig_tens ** 2 + 1).sqrt()
-
-    if is_v_pred:
-        nrs_cond, nrs_uncond = cond, uncond
-        x_div = None
-    else:
-        x_div = x_orig / (sig_tens ** 2 + 1)
-        factor = sig_tens / sig_root
-        nrs_cond = x_orig - (x_div - cond * factor)
-        nrs_uncond = x_orig - (x_div - uncond * factor)
-
-    def _dot(a, b):
-        return (a * b).sum(dim=1, keepdim=True)
-
-    def _nrm2(v):
-        return _dot(v, v)
-
-    eps_safe = 1e-6
-
-    c_dot_c = _nrm2(nrs_cond) + eps_safe
-    u_dot_c = _dot(nrs_uncond, nrs_cond)
-    u_on_c = (u_dot_c / c_dot_c) * nrs_cond
-
-    proj_diff = nrs_cond - u_on_c
-    stretched = nrs_cond + (stretch * proj_diff)
-
-    u_rej_c = nrs_uncond - u_on_c
-    skewed = stretched - (skew * u_rej_c)
-
-    if use_ad_norm:
-        # AD: Mean Absolute Deviation per channel, then average across channels
-        # Source: dynthres_core sep_feat_channels=True, variability_measure='AD'
-        cond_len = nrs_cond.abs().mean(dim=(2, 3), keepdim=True).mean(dim=1, keepdim=True)
-        nrs_len = skewed.abs().mean(dim=(2, 3), keepdim=True).mean(dim=1, keepdim=True) + eps_safe
-    else:
-        cond_len = nrs_cond.norm(dim=1, keepdim=True)
-        nrs_len = skewed.norm(dim=1, keepdim=True) + eps_safe
-
-    squash_scale = (1 - squash) + (squash * (cond_len / nrs_len))
-    x_final = skewed * squash_scale
-
-    if is_v_pred:
-        return x_final
-    else:
-        return (x_div - (x_orig - x_final)) * (sig_root / sig_tens)
-
-
-def calc_nrs(x_orig, cond, uncond, sigma, skew, stretch, squash):
-    """Backward-compatible wrapper."""
-    return _nrs_core(x_orig, cond, uncond, sigma, skew, stretch, squash)
-
-
-def calc_nrs_per_channel(x_orig, cond, uncond, sigma, skew, stretch, squash, use_ad_norm=False):
-    """
-    Per-channel NRS: process each latent channel independently.
-    Source: dynthres_core (3).py sep_feat_channels=True
-    Per-channel norms use dim=(2,3) spatial only, preventing cross-channel influence.
-    """
-    results = []
-    for ch in range(cond.shape[1]):
-        r = _nrs_core(
-            x_orig[:, ch:ch+1],
-            cond[:, ch:ch+1],
-            uncond[:, ch:ch+1],
-            sigma, skew, stretch, squash, use_ad_norm
-        )
-        results.append(r)
-    return torch.cat(results, dim=1)
-
-
-def calc_nrs_midpoint_refined(x_orig, cond, uncond, sigma, skew, stretch, squash,
-                               refine_blend=0.0, first_half_only=True,
-                               current_step=0, total_steps=20,
-                               use_per_channel=False, use_ad_norm=False):
-    """
-    Correct Kohaku midpoint refinement for NRS.
-
-    Kohaku_LoNyu_Yog (sampler, smea_sampling_46.py):
-        d  = to_d(x, sigma, model(x))
-        x3 = x + (d + d2) / 2 * dt   # midpoint from averaged direction
-        d3 = to_d(x3, sigma, model(x3))
-        real_d = (d + d3) / 2          # Runge-Kutta 2nd order average
-
-    NRS adaptation (no extra model calls needed):
-        nrs_direct = NRS(x_orig, cond, uncond)
-        x_mid      = x_orig + (nrs_direct - x_orig) * blend * 0.5  # shifted latent
-        nrs_refined = NRS(x_mid, cond, uncond)
-        result     = (nrs_direct + nrs_refined) / 2
-    """
-    _fn = calc_nrs_per_channel if use_per_channel else _nrs_core
-
-    nrs_direct = _fn(x_orig, cond, uncond, sigma, skew, stretch, squash, use_ad_norm)
-
-    if refine_blend <= 0.0:
-        return nrs_direct
-
-    if first_half_only and current_step > total_steps / 2:
-        return nrs_direct
-
-    # Midpoint in x-space (between noisy x_orig and denoised nrs_direct)
-    x_mid = x_orig + (nrs_direct - x_orig) * (refine_blend * 0.5)
-
-    nrs_refined = _fn(x_mid, cond, uncond, sigma, skew, stretch, squash, use_ad_norm)
-
-    # Runge-Kutta style average (Kohaku: real_d = (d + d3) / 2)
-    return (nrs_direct + nrs_refined) * 0.5
-
-
-# ==============================================================================
-# ЧАСТЬ 2: РАСПИСАНИЕ ПАРАМЕТРОВ (SCHEDULING)
-# ==============================================================================
-
-def nrs_schedule_value(base_value, step, total_steps, curve="Constant",
-                       min_value=0.0, sched_val=2.0):
-    """
-    Apply curve to parameter over sampling steps.
-    Source: dynthres_core (3).py interpret_scale() + khrfix (26).py curve_progress()
-    """
-    if curve == "Constant":
-        return base_value
-
-    frac = step / max(total_steps - 1, 1)
-    frac = max(0.0, min(1.0, frac))
-    scale = base_value - min_value
-
-    if curve == "Linear Down":
-        val = 1.0 - frac
-    elif curve == "Linear Up":
-        val = frac
-    elif curve == "Cosine Down":
-        # Source: dynthres_core cos(frac * pi/2) — от 1.0 до ~0
-        val = math.cos(frac * 1.5707963)
-    elif curve == "Cosine Up":
-        # Source: dynthres_core 1 - cos(frac * pi/2)
-        val = 1.0 - math.cos(frac * 1.5707963)
-    elif curve == "Half Cosine Down":
-        # Source: dynthres_core + khrfix → cos(frac), НЕ cos(frac*pi/2)
-        val = math.cos(frac)
-    elif curve == "Half Cosine Up":
-        # Source: dynthres_core + khrfix → 1 - cos(frac)
-        val = 1.0 - math.cos(frac)
-    elif curve == "Power Down":
-        val = 1.0 - math.pow(frac, max(sched_val, 0.1))
-    elif curve == "Power Up":
-        val = math.pow(frac, max(sched_val, 0.1))
-    elif curve == "Linear Repeating":
-        sv = max(sched_val, 0.1)
-        portion = (frac * sv) % 1.0
-        val = 1.0 - abs(2.0 * portion - 1.0)
-    elif curve == "Cosine Repeating":
-        sv = max(sched_val, 0.1)
-        val = math.cos(2.0 * math.pi * frac * sv) * 0.5 + 0.5
-    elif curve == "Sawtooth":
-        sv = max(sched_val, 0.1)
-        val = (frac * sv) % 1.0
-    else:
-        val = 1.0
-
-    return min_value + max(0.0, scale * val)
-
-
-def nrs_cads_schedule(step, total_steps, tau1=0.6, tau2=0.9):
-    """
-    CADS trapezoidal NRS strength schedule.
-    Source: cads__6__fixed.py cads_linear_schedule(), "Hold after full" mode.
-
-    t = 1 - step/total (descends from 1 to 0 during sampling)
-    - t > tau2 (early steps):          gamma = 0 (NRS off)
-    - tau1 < t < tau2 (ramp):          gamma linearly rises 0→1
-    - t <= tau1 (late steps):          gamma = 1 (NRS full strength)
-
-    Defaults tau1=0.6, tau2=0.9 → NRS activates at ~10% of steps,
-    reaches full strength at ~40%, stays full for remainder.
-    """
-    t = 1.0 - step / max(total_steps - 1, 1)
-    t = max(0.0, min(1.0, t))
-    tau1 = max(0.0, min(1.0, tau1))
-    tau2 = max(0.0, min(1.0, tau2))
-
-    if tau1 >= tau2:
-        return 1.0 if t <= tau1 else 0.0
-    if t >= tau2:
-        return 0.0
-    if t <= tau1:
-        return 1.0
-    return (tau2 - t) / (tau2 - tau1)
-
-
-def calc_adaptive_nrs_params(base_skew, base_stretch, base_squash, progress,
-                              euler_end=0.35, dpm_end=0.70):
-    """
-    Phase-based parameter adjustment.
-    Source: adaptive_progressive.py calc_phase_bounds() + phase weight logic.
-
-    Phase 1 (0 → euler_end):       Structural — max skew, moderate stretch
-    Phase 2 (euler_end → dpm_end): Transition — decreasing skew, rising squash
-    Phase 3 (dpm_end → 1.0):       Detail — minimal skew, max squash
-    """
-    euler_end = max(0.0, min(1.0, euler_end))
-    dpm_end = max(euler_end + 0.05, min(1.0, dpm_end))
-
-    if progress < euler_end:
-        skew_f, stretch_f, squash_add = 1.0, 0.8, 0.0
-    elif progress < dpm_end:
-        ph = (progress - euler_end) / max(dpm_end - euler_end, 1e-8)
-        w_euler = max(0.0, 1.0 - ph * 2.5)
-        skew_f = w_euler + (1.0 - w_euler) * 0.3
-        stretch_f = w_euler * 0.8 + (1.0 - w_euler) * 1.0
-        squash_add = (1.0 - w_euler) * 0.3
-    else:
-        ph = (progress - dpm_end) / max(1.0 - dpm_end, 1e-8)
-        skew_f = max(0.0, 0.3 - ph * 0.3)
-        stretch_f = 0.8
-        squash_add = 0.3 + ph * 0.4
-
-    return (
-        base_skew * skew_f,
-        base_stretch * stretch_f,
-        min(1.0, base_squash + (1.0 - base_squash) * squash_add),
-    )
-
-
-# ==============================================================================
-# ЧАСТЬ 3: POST-PROCESSING ФУНКЦИИ
-# ==============================================================================
-
-def apply_nrs_drift_correction(tensor, intensity=0.0, method='mean'):
-    """
-    Remove CFG mean/median drift.
-    Source: adept_sampler_v4_COMPLETE (2).py apply_combat_cfg_drift()
-    Based on ComfyUI-Latent-Modifiers.
-    """
-    if intensity <= 0.0:
-        return tensor
-    try:
-        if method == 'median':
-            center = tensor.view(tensor.shape[0], -1).median(dim=-1, keepdim=True)[0]
-            center = center.view(tensor.shape[0], 1, 1, 1)
-        else:
-            center = tensor.mean(dim=(1, 2, 3), keepdim=True)
-        return tensor - center * intensity
-    except Exception:
-        return tensor
-
-
-def apply_variance_preserving_rescale(nrs_result, cond_reference, phi=0.0):
-    """
-    Scale NRS result to match std of reference cond.
-    Source: dynthres_core (3).py interpolation logic + variance concept.
-    """
-    if phi <= 0.0:
-        return nrs_result
-    try:
-        std_ref = cond_reference.std()
-        std_nrs = nrs_result.std()
-        if std_nrs < 1e-8:
-            return nrs_result
-        rescaled = nrs_result * (std_ref / std_nrs)
-        return phi * rescaled + (1.0 - phi) * nrs_result
-    except Exception:
-        return nrs_result
-
-
-def apply_blend_phi(nrs_result, plain_cfg_result, phi=1.0):
-    """
-    Blend NRS output with standard CFG output.
-    Source: dynthres_core (3).py interpolate_phi.
-    phi=1.0 → pure NRS, phi=0.0 → pure CFG.
-    """
-    if phi >= 1.0:
-        return nrs_result
-    if phi <= 0.0:
-        return plain_cfg_result
-    return phi * nrs_result + (1.0 - phi) * plain_cfg_result
-
-
-def apply_nrs_momentum(nrs_result, prev_result, prev_vel, momentum=0.0):
-    """
-    Full momentum smoothing between steps.
-    Source: res_solver (11).py + clybius_dpmpp_4m_sde (7).py momentum_func()
-    Formula: vel = m*(1-m/2)*prev_vel + (1-m*(1-m/2))*curr_diff
-             result = prev_result + vel
-    Returns: (smoothed_result, new_vel)
-    """
-    if momentum <= 0.0 or prev_result is None:
-        curr_diff = nrs_result - prev_result if prev_result is not None else None
-        return nrs_result, curr_diff
-    try:
-        curr_diff = nrs_result - prev_result
-        eff_m = momentum * (1.0 - momentum * 0.5)
-        if prev_vel is None:
-            # First step: velocity = current diff (no history)
-            vel = curr_diff
-        else:
-            # Full RES/Clybius formula: blend prev velocity with current diff
-            vel = eff_m * prev_vel + (1.0 - eff_m) * curr_diff
-        smoothed = prev_result + vel
-        return smoothed, vel
-    except Exception:
-        return nrs_result, None
-
-
-def apply_nrs_ge_extrapolation(nrs_result, prev_result, prev_diff, ge_gamma=1.0):
-    """
-    Gradient Estimation extrapolation between steps.
-    Source: gradient_estimation (5).py
-    Formula: d_bar = ge_gamma * (d - old_d) + old_d
-    ge_gamma=1.0 → standard, >1.0 → extrapolation, <1.0 → smoothing.
-    """
-    if ge_gamma == 1.0 or prev_result is None or prev_diff is None:
-        return nrs_result
-    try:
-        d = nrs_result - prev_result
-        d_bar = ge_gamma * (d - prev_diff) + prev_diff
-        return prev_result + d_bar
-    except Exception:
-        return nrs_result
-
-
-def apply_nrs_detail_boost(nrs_result, progress, boost_strength=0.0):
-    """
-    Progressive high-frequency detail enhancement.
-    Source: adept_sampler_v4_COMPLETE (2).py compute_native_detail_boost()
-    Three phases: early (gentle) → mid → late (strong).
-    """
-    if boost_strength <= 0.0:
-        return nrs_result
-    try:
-        import torch.nn.functional as F
-
-        if progress < 0.30:
-            hf_boost = 0.03 * boost_strength * (progress / 0.30)
-        elif progress < 0.60:
-            hf_boost = (0.03 + 0.07 * (progress - 0.30) / 0.30) * boost_strength
-        else:
-            hf_boost = (0.10 + 0.08 * (progress - 0.60) / 0.40) * boost_strength
-
-        if hf_boost <= 1e-6:
-            return nrs_result
-
-        # Gaussian kernel for low-freq extraction
-        sigma_g = 0.5
-        ks = 3
-        x_k = torch.linspace(-(ks - 1) / 2, (ks - 1) / 2, ks,
-                              device=nrs_result.device, dtype=nrs_result.dtype)
-        gauss = torch.exp(-0.5 * (x_k / sigma_g) ** 2)
-        gauss = gauss / gauss.sum()
-        kernel = torch.mm(gauss[:, None], gauss[None, :])
-        # .contiguous() required: .expand() creates non-contiguous view, F.conv2d needs contiguous weight
-        kernel = kernel.expand(nrs_result.shape[1], 1, ks, ks).contiguous()
-
-        padded = F.pad(nrs_result, (1, 1, 1, 1), mode='reflect')
-        low_freq = F.conv2d(padded, kernel, groups=nrs_result.shape[1])
-        high_freq = nrs_result - low_freq
-        return nrs_result + high_freq * hf_boost
-    except Exception:
-        return nrs_result
-
-
-def apply_spectral_modulation(noise_pred, multiplier=0.0, percentile=5.0):
-    """
-    Clybius spectral modulation on noise_pred = (cond_x0 - uncond_x0).
-    Source: adept_sampler_v4_COMPLETE (2).py apply_spectral_modulation_clybius()
-    Boosts low-freq, suppresses extreme high-freq outliers.
-    Applied BEFORE NRS computation.
-    """
-    if multiplier == 0.0 or percentile <= 0:
-        return noise_pred
-    try:
-        fourier = torch.fft.fft2(noise_pred, dim=(-2, -1))
-        log_amp = torch.log(torch.sqrt(fourier.real ** 2 + fourier.imag ** 2) + 1e-8)
-        flat = log_amp.abs().flatten(2)  # [B, C, H*W]
-
-        q_lo = torch.quantile(flat, percentile * 0.01, dim=2)
-        q_hi = torch.quantile(flat, 1.0 - percentile * 0.01, dim=2)
-
-        # Expand to [B, C, H, W]
-        q_lo = q_lo.unsqueeze(-1).unsqueeze(-1).expand(log_amp.shape)
-        q_hi = q_hi.unsqueeze(-1).unsqueeze(-1).expand(log_amp.shape)
-
-        # mask_low: boost frequencies below lower threshold (1.0–1.5 range)
-        # mask_high: reduce frequencies above upper threshold (0.5–1.0 range)
-        mask_low = ((log_amp < q_lo).float() + 1.0).clamp_(max=1.5)
-        mask_high = (log_amp < q_hi).float().clamp_(min=0.5)
-
-        filtered = fourier * ((mask_low * mask_high) ** multiplier)
-        return torch.fft.ifft2(filtered, dim=(-2, -1)).real
-    except Exception:
-        return noise_pred
-
-
-def apply_uncond_modifications(uncond, noise_strength=0.0, uncond_scale=1.0):
-    """
-    Add noise to uncond and/or scale it.
-    Source: forge_condBlast (6).py
-    noise: lerp(uncond, randn*uncond.std(), strength)
-    scale: lerp(zeros, uncond, scale)
-    """
-    if noise_strength <= 0.0 and uncond_scale == 1.0:
-        return uncond
-    try:
-        result = uncond.clone()
-        if noise_strength > 0.0:
-            noise = torch.randn_like(result) * result.std()
-            result = torch.lerp(result, noise, noise_strength)
-        if uncond_scale != 1.0:
-            result = torch.lerp(torch.zeros_like(result), result, uncond_scale)
-        return result
-    except Exception:
-        return uncond
-
-
-def apply_nrs_output_clamp(nrs_result, sigma, clamp_multiplier=0.0):
-    """
-    Adaptive output clamping based on sigma.
-    Source: adept_sampler_v4_COMPLETE (2).py apply_dynamic_thresholding().
-    threshold = clamp * (1 + sigma/10)
-    """
-    if clamp_multiplier <= 0.0:
-        return nrs_result
-    try:
-        sigma_val = sigma[0].item() if isinstance(sigma, torch.Tensor) else float(sigma)
-        threshold = clamp_multiplier * (1.0 + sigma_val / 10.0)
-        return torch.clamp(nrs_result, -threshold, threshold)
-    except Exception:
-        return nrs_result
-
-
-# ==============================================================================
-# ЧАСТЬ 4: STEP CONTROL (сохранено из оригинала)
-# ==============================================================================
-
-def should_apply_at_step(current_step, total_steps, start_step, end_step,
-                         start_frac, end_frac, step_mode):
-    if step_mode == "Absolute Steps":
-        eff_start = max(0, start_step)
-        eff_end = min(total_steps, end_step) if end_step > 0 else total_steps
-        return eff_start <= current_step < eff_end
-    else:
-        eff_start = int(total_steps * max(0.0, min(1.0, start_frac)))
-        eff_end = int(total_steps * max(0.0, min(1.0, end_frac)))
-        if eff_end == 0:
-            eff_end = total_steps
-        return eff_start <= current_step < eff_end
-
-
-def get_param_value_at_step(base_value, current_step, total_steps, start_step, end_step,
-                             start_frac, end_frac, step_mode, enabled):
-    if not enabled:
-        return base_value
-    if should_apply_at_step(current_step, total_steps, start_step, end_step,
-                            start_frac, end_frac, step_mode):
-        return base_value
-    return 0.0
-
-
-# ==============================================================================
-# ЧАСТЬ 5: HOOKS
-# ==============================================================================
-
-def hook_cfg_denoiser_params(params):
-    if hasattr(params.denoiser, 'p') and getattr(params.denoiser.p, '_nrs_enabled', False):
-        params.denoiser.p._nrs_current_sigma = params.sigma
-        params.denoiser.p._nrs_current_x_in = params.x
-        if hasattr(params, 'sampling_step'):
-            params.denoiser.p._nrs_current_step = params.sampling_step
-        elif hasattr(params.denoiser, 'step'):
-            params.denoiser.p._nrs_current_step = params.denoiser.step
-        else:
-            params.denoiser.p._nrs_current_step = getattr(
-                params.denoiser.p, '_nrs_current_step', 0)
-
-
-script_callbacks.on_cfg_denoiser(hook_cfg_denoiser_params)
-
-if not hasattr(sd_samplers_cfg_denoiser.CFGDenoiser, 'original_combine_denoised_nrs_backup'):
-    sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup = \
-        sd_samplers_cfg_denoiser.CFGDenoiser.combine_denoised
-
-
-def hijacked_combine_denoised(self, x_out, conds_list, uncond, cond_scale):
-    _orig = sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup
-
-    if not getattr(self, 'p', None) or not getattr(self.p, '_nrs_enabled', False):
-        return _orig(self, x_out, conds_list, uncond, cond_scale)
-
-    if not hasattr(self.p, '_nrs_current_sigma') or not hasattr(self.p, '_nrs_current_x_in'):
-        return _orig(self, x_out, conds_list, uncond, cond_scale)
-
-    try:
-        p = self.p
-        sigma = p._nrs_current_sigma
-        base_skew, base_stretch, base_squash = p._nrs_params
-
-        # ── Step Control ──────────────────────────────────────────────────────
-        current_step = getattr(p, '_nrs_current_step', 0)
-        total_steps = getattr(p, 'steps', 20)
-        step_ctrl = getattr(p, '_nrs_step_control_enabled', False)
-        step_mode_global = getattr(p, '_nrs_step_control_mode', 'Global')
-
-        if step_ctrl:
-            if step_mode_global == 'Global':
-                gs = getattr(p, '_nrs_global_step_settings', {})
-                if not should_apply_at_step(
-                        current_step, total_steps,
-                        gs.get('start_step', 0), gs.get('end_step', total_steps),
-                        gs.get('start_frac', 0.0), gs.get('end_frac', 1.0),
-                        gs.get('step_mode', 'Absolute Steps')):
-                    return _orig(self, x_out, conds_list, uncond, cond_scale)
-                skew, stretch, squash = base_skew, base_stretch, base_squash
-            else:
-                ind = getattr(p, '_nrs_individual_step_settings', {})
-                sk = ind.get('skew', {})
-                st = ind.get('stretch', {})
-                sq = ind.get('squash', {})
-                skew = get_param_value_at_step(
-                    base_skew, current_step, total_steps,
-                    sk.get('start_step', 0), sk.get('end_step', total_steps),
-                    sk.get('start_frac', 0.0), sk.get('end_frac', 1.0),
-                    sk.get('step_mode', 'Absolute Steps'), sk.get('enabled', True))
-                stretch = get_param_value_at_step(
-                    base_stretch, current_step, total_steps,
-                    st.get('start_step', 0), st.get('end_step', total_steps),
-                    st.get('start_frac', 0.0), st.get('end_frac', 1.0),
-                    st.get('step_mode', 'Absolute Steps'), st.get('enabled', True))
-                squash = get_param_value_at_step(
-                    base_squash, current_step, total_steps,
-                    sq.get('start_step', 0), sq.get('end_step', total_steps),
-                    sq.get('start_frac', 0.0), sq.get('end_frac', 1.0),
-                    sq.get('step_mode', 'Absolute Steps'), sq.get('enabled', True))
-        else:
-            skew, stretch, squash = base_skew, base_stretch, base_squash
-
-        # ── Scheduling ────────────────────────────────────────────────────────
-        sched_mode = getattr(p, '_nrs_sched_mode', 'Off')
-        progress = current_step / max(total_steps - 1, 1)
-
-        if sched_mode == 'Individual Curves':
-            sched_val = getattr(p, '_nrs_sched_val', 2.0)
-            skew = nrs_schedule_value(
-                skew, current_step, total_steps,
-                getattr(p, '_nrs_skew_curve', 'Constant'),
-                getattr(p, '_nrs_skew_curve_min', 0.0), sched_val)
-            stretch = nrs_schedule_value(
-                stretch, current_step, total_steps,
-                getattr(p, '_nrs_stretch_curve', 'Constant'),
-                getattr(p, '_nrs_stretch_curve_min', 0.0), sched_val)
-            squash = nrs_schedule_value(
-                squash, current_step, total_steps,
-                getattr(p, '_nrs_squash_curve', 'Constant'),
-                getattr(p, '_nrs_squash_curve_min', 0.0), sched_val)
-
-        elif sched_mode == 'CADS Anneal':
-            tau1 = getattr(p, '_nrs_cads_tau1', 0.6)
-            tau2 = getattr(p, '_nrs_cads_tau2', 0.9)
-            cads_scale = nrs_cads_schedule(current_step, total_steps, tau1, tau2)
-            skew *= cads_scale
-            stretch *= cads_scale
-            # squash stays at base — CADS doesn't affect the clamp
-
-        elif sched_mode == 'Adaptive Phases':
-            euler_end = getattr(p, '_nrs_adaptive_euler_end', 0.35)
-            dpm_end = getattr(p, '_nrs_adaptive_dpm_end', 0.70)
-            skew, stretch, squash = calc_adaptive_nrs_params(
-                skew, stretch, squash, progress, euler_end, dpm_end)
-
-        # ── Feature flags ─────────────────────────────────────────────────────
-        per_channel = getattr(p, '_nrs_per_channel', False)
-        use_ad_norm = getattr(p, '_nrs_ad_norm', False)
-        refine_blend = getattr(p, '_nrs_refine_blend', 0.0)
-        refine_first_half = getattr(p, '_nrs_refine_first_half', True)
-        blend_phi = getattr(p, '_nrs_blend_phi', 1.0)
-        variance_phi = getattr(p, '_nrs_variance_phi', 0.0)
-        drift_intensity = getattr(p, '_nrs_drift_intensity', 0.0)
-        drift_method = getattr(p, '_nrs_drift_method', 'mean')
-        output_clamp = getattr(p, '_nrs_output_clamp', 0.0)
-        inter_step_mode = getattr(p, '_nrs_inter_step_mode', 'Off')
-        momentum = getattr(p, '_nrs_momentum', 0.0)
-        ge_gamma = getattr(p, '_nrs_ge_gamma', 1.0)
-        detail_boost = getattr(p, '_nrs_detail_boost', 0.0)
-        spectral_mod = getattr(p, '_nrs_spectral_mod', 0.0)
-        spectral_pct = getattr(p, '_nrs_spectral_pct', 5.0)
-        uncond_noise = getattr(p, '_nrs_uncond_noise', 0.0)
-        uncond_scale = getattr(p, '_nrs_uncond_scale', 1.0)
-
-        # Inter-step state
-        prev_results = getattr(p, '_nrs_prev_results', {})
-        prev_diffs = getattr(p, '_nrs_prev_diffs', {})
-
-        # ── Prepare tensors ───────────────────────────────────────────────────
-        denoised_uncond = x_out[-uncond.shape[0]:]
-        denoised = torch.clone(denoised_uncond)
-        x_orig_uncond = p._nrs_current_x_in[-uncond.shape[0]:]
-
-        # ── Main per-item loop ────────────────────────────────────────────────
-        for i, conds in enumerate(conds_list):
-            for idx, (cond_index, weight) in enumerate(conds):
-                current_cond = x_out[cond_index]
-                if idx != 0:
-                    denoised[i] += (current_cond - denoised_uncond[i]) * (weight * cond_scale)
-                    continue
-
-                x_orig_i = x_orig_uncond[i].unsqueeze(0)
-                c_in = current_cond.unsqueeze(0)   # original, before any modifications
-                u_in = denoised_uncond[i].unsqueeze(0)
-
-                # 1. Uncond modifications
-                if uncond_noise > 0.0 or uncond_scale != 1.0:
-                    u_in = apply_uncond_modifications(u_in, uncond_noise, uncond_scale)
-
-                # 2. Spectral modulation on noise_pred BEFORE NRS
-                # Applied to c_in_mod only — original c_in kept for blend_phi and variance_phi
-                c_in_for_nrs = c_in
-                if spectral_mod > 0.0:
-                    noise_pred = c_in - u_in
-                    noise_pred_mod = apply_spectral_modulation(noise_pred, spectral_mod, spectral_pct)
-                    c_in_for_nrs = u_in + noise_pred_mod
-
-                # 3. Core NRS computation
-                nrs_result = calc_nrs_midpoint_refined(
-                    x_orig_i, c_in_for_nrs, u_in, sigma,
-                    skew, stretch, squash,
-                    refine_blend=refine_blend,
-                    first_half_only=refine_first_half,
-                    current_step=current_step,
-                    total_steps=total_steps,
-                    use_per_channel=per_channel,
-                    use_ad_norm=use_ad_norm,
-                )
-
-                # 4. Variance preserving rescale — use ORIGINAL c_in as reference
-                if variance_phi > 0.0:
-                    nrs_result = apply_variance_preserving_rescale(nrs_result, c_in, variance_phi)
-
-                # 5. Drift correction
-                if drift_intensity > 0.0:
-                    nrs_result = apply_nrs_drift_correction(nrs_result, drift_intensity, drift_method)
-
-                # 6. Blend phi (NRS ↔ plain CFG) — plain_cfg uses ORIGINAL c_in
-                if blend_phi < 1.0:
-                    plain_cfg = u_in + (c_in - u_in) * cond_scale
-                    nrs_result = apply_blend_phi(nrs_result, plain_cfg, blend_phi)
-
-                # 7. Inter-step: Momentum or GE-Gamma
-                prev_r = prev_results.get(i, None)
-                if inter_step_mode == 'Momentum' and momentum > 0.0:
-                    # Full RES/Clybius momentum with velocity tracking
-                    prev_vel = prev_diffs.get(i, None)
-                    nrs_result, new_vel = apply_nrs_momentum(nrs_result, prev_r, prev_vel, momentum)
-                    if new_vel is not None:
-                        prev_diffs[i] = new_vel.detach().clone()
-                elif inter_step_mode == 'GE-Gamma' and ge_gamma != 1.0:
-                    prev_d = prev_diffs.get(i, None)
-                    # Save RAW diff BEFORE extrapolation (this is old_d for next step)
-                    if prev_r is not None:
-                        raw_diff = (nrs_result - prev_r).detach().clone()
-                    nrs_result = apply_nrs_ge_extrapolation(nrs_result, prev_r, prev_d, ge_gamma)
-                    if prev_r is not None:
-                        prev_diffs[i] = raw_diff  # store pre-extrapolation diff
-
-                # Update inter-step state
-                prev_results[i] = nrs_result.detach().clone()
-
-                # 8. Detail boost
-                if detail_boost > 0.0:
-                    nrs_result = apply_nrs_detail_boost(nrs_result, progress, detail_boost)
-
-                # 9. Output clamp
-                if output_clamp > 0.0:
-                    nrs_result = apply_nrs_output_clamp(nrs_result, sigma, output_clamp)
-
-                # Write result
-                if len(conds) == 1:
-                    denoised[i] = nrs_result.squeeze(0)
-                else:
-                    delta = nrs_result.squeeze(0) - denoised_uncond[i]
-                    denoised[i] += delta * weight
-
-        # Save inter-step state
-        p._nrs_prev_results = prev_results
-        p._nrs_prev_diffs = prev_diffs
-
-        return denoised
-
-    except Exception as e:
-        print(f"!!! NRS Enhanced Error (Fallback): {e}")
-        import traceback
-        traceback.print_exc()
-        return sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup(
-            self, x_out, conds_list, uncond, cond_scale)
-
-
-# ==============================================================================
-# ЧАСТЬ 6: UI
-# ==============================================================================
-
-class NRSScript(scripts.Script):
-    def title(self):
-        return "NRS + Kohaku Enhanced"
-
-    def show(self, is_img2img):
-        return scripts.AlwaysVisible
-
-    def ui(self, is_img2img):
-        with gr.Accordion("NRS + Kohaku Enhanced", open=False):
-            enabled = gr.Checkbox(label="Включить NRS (Enable)", value=False)
-
-            # ── Инструкция ────────────────────────────────────────────────────
-            with gr.Accordion("❓ Инструкция / Help", open=False):
-                gr.Markdown("""
-### NRS + Kohaku Enhanced v2.0
-
-**NRS (Negative Rejection Steering)** — замена стандартному CFG с 3 параметрами:
-- **Skew** — отталкивание от Negative prompt (аналог силы CFG для структуры). Старт: 3–5
-- **Stretch** — притяжение к Positive prompt (усиление цветов/стиля). Старт: 2–7
-- **Squash** — ограничитель (0=максимум, 1=мягко+детали). Старт: 0.0
-
-### 🔮 Midpoint Refinement (исправленный Kohaku)
-Правильная адаптация Kohaku_LoNyu_Yog: вычисляет NRS в промежуточной точке и усредняет результаты (Runge-Kutta 2-го порядка). Даёт более точное направление к целевой области.
-
-### 📐 Scheduling
-- **Individual Curves**: каждый параметр меняется по своей кривой (Linear/Cosine/Power/...)
-- **CADS Anneal**: NRS нарастает через несколько шагов (tau1/tau2 трапеция)
-- **Adaptive Phases**: автоматические фазы Euler→DPM→Detail
-
-### 🔬 Advanced Math
-- **Per-Channel**: независимая обработка каждого латентного канала
-- **AD Norm**: Absolute Deviation вместо L2 (устойчивее к выбросам)
-- **Blend Phi**: смешение NRS↔CFG (1.0=чистый NRS, 0.0=чистый CFG)
-- **Variance Phi**: сохранение дисперсии после NRS
-
-### 🔁 Inter-Step
-- **Momentum**: сглаживание NRS-векторов между шагами
-- **GE-Gamma**: экстраполяция направления (>1 усиливает тренд)
-                """)
-
-            # ── Основные параметры ────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>Основные параметры</div>")
-            with gr.Row():
-                skew = gr.Slider(label="Skew (Композиция)", minimum=-30.0, maximum=30.0,
-                                 step=0.05, value=4.0,
-                                 info="Отклонение от Neg prompt. Рекомендуется: 3–5")
-                stretch = gr.Slider(label="Stretch (Цвета/Стиль)", minimum=-30.0, maximum=30.0,
-                                    step=0.05, value=2.0,
-                                    info="Притяжение к Pos prompt. Рекомендуется: 2–7")
-            squash = gr.Slider(label="Squash (Защита от пережарки)", minimum=0.0, maximum=1.0,
-                               step=0.01, value=0.0,
-                               info="0=максимальный эффект, 1=больше деталей/мягче")
-
-            # ── Midpoint Refinement ───────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>🔮 Midpoint Refinement (Kohaku)</div>")
-            refine_blend = gr.Slider(
-                label="Refinement Blend", minimum=0.0, maximum=1.0, step=0.01, value=0.0,
-                info="0=выкл, 0.5=рекомендуется. Runge-Kutta уточнение NRS-вектора")
-            refine_first_half = gr.Checkbox(
-                label="Only first half of steps (как в оригинале Kohaku)",
-                value=True,
-                info="Применять refinement только на первой половине шагов")
-
-            # ── Scheduling ────────────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>📐 Parameter Scheduling</div>")
-            sched_mode = gr.Radio(
-                label="Режим расписания", choices=SCHED_MODES, value="Off")
-
-            with gr.Group(visible=False) as curves_group:
-                gr.HTML("<div style='font-size:0.85em; opacity:0.7; margin:0.3em 0;'>"
-                        "Кривые применяются к базовым значениям независимо</div>")
-                with gr.Row():
-                    skew_curve = gr.Dropdown(label="Skew Curve", choices=CURVE_CHOICES,
-                                             value="Constant")
-                    skew_curve_min = gr.Slider(label="Skew Min", minimum=-30.0, maximum=30.0,
-                                               step=0.05, value=0.0)
-                with gr.Row():
-                    stretch_curve = gr.Dropdown(label="Stretch Curve", choices=CURVE_CHOICES,
-                                                value="Constant")
-                    stretch_curve_min = gr.Slider(label="Stretch Min", minimum=-30.0, maximum=30.0,
-                                                  step=0.05, value=0.0)
-                with gr.Row():
-                    squash_curve = gr.Dropdown(label="Squash Curve", choices=CURVE_CHOICES,
-                                               value="Constant")
-                    squash_curve_min = gr.Slider(label="Squash Min", minimum=0.0, maximum=1.0,
-                                                 step=0.01, value=0.0)
-                sched_val = gr.Slider(
-                    label="Sched Value (для Power/Repeating кривых)",
-                    minimum=0.1, maximum=8.0, step=0.1, value=2.0)
-
-            with gr.Group(visible=False) as cads_group:
-                gr.HTML("<div style='font-size:0.85em; opacity:0.7; margin:0.3em 0;'>"
-                        "Трапецеидальное нарастание силы NRS. "
-                        "tau1=0.6, tau2=0.9: NRS включается на ~10% шагов, "
-                        "полная сила с ~40%</div>")
-                with gr.Row():
-                    cads_tau1 = gr.Slider(label="Tau 1 (полная сила)", minimum=0.0, maximum=1.0,
-                                          step=0.05, value=0.6)
-                    cads_tau2 = gr.Slider(label="Tau 2 (начало нарастания)", minimum=0.0, maximum=1.0,
-                                          step=0.05, value=0.9)
-
-            with gr.Group(visible=False) as adaptive_group:
-                gr.HTML("<div style='font-size:0.85em; opacity:0.7; margin:0.3em 0;'>"
-                        "Euler Phase: макс. Skew. "
-                        "DPM Phase: переход. "
-                        "Detail Phase: минимум Skew, максимум Squash</div>")
-                with gr.Row():
-                    adaptive_euler_end = gr.Slider(label="Euler Phase End", minimum=0.0, maximum=1.0,
-                                                   step=0.05, value=0.35)
-                    adaptive_dpm_end = gr.Slider(label="DPM Phase End", minimum=0.0, maximum=1.0,
-                                                 step=0.05, value=0.70)
-
-            def update_sched_groups(mode):
-                return {
-                    curves_group: gr.update(visible=(mode == "Individual Curves")),
-                    cads_group: gr.update(visible=(mode == "CADS Anneal")),
-                    adaptive_group: gr.update(visible=(mode == "Adaptive Phases")),
-                }
-
-            sched_mode.change(fn=update_sched_groups, inputs=[sched_mode],
-                              outputs=[curves_group, cads_group, adaptive_group])
-
-            # ── Advanced Math ─────────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>🔬 Advanced Math</div>")
-            with gr.Row():
-                per_channel = gr.Checkbox(
-                    label="Per-Channel Processing",
-                    value=False,
-                    info="Обрабатывать каждый латентный канал независимо")
-                ad_norm = gr.Checkbox(
-                    label="AD Normalization",
-                    value=False,
-                    info="Absolute Deviation вместо L2 (устойчивее к выбросам)")
-            with gr.Row():
-                blend_phi = gr.Slider(
-                    label="Blend Phi (NRS↔CFG)", minimum=0.0, maximum=1.0, step=0.01, value=1.0,
-                    info="1.0=чистый NRS, 0.0=чистый CFG, между — смесь")
-                variance_phi = gr.Slider(
-                    label="Variance Rescale Phi", minimum=0.0, maximum=1.0, step=0.01, value=0.0,
-                    info="0=выкл. Нормирует дисперсию NRS-результата к дисперсии cond")
-
-            # ── Post-Processing ───────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>📡 Post-Processing</div>")
-            with gr.Row():
-                drift_intensity = gr.Slider(
-                    label="Drift Correction", minimum=0.0, maximum=1.0, step=0.01, value=0.0,
-                    info="Убирает смещение mean/median от высокого CFG")
-                drift_method = gr.Radio(
-                    label="Метод", choices=DRIFT_METHODS, value="mean")
-            output_clamp = gr.Slider(
-                label="Output Clamp (0=выкл)", minimum=0.0, maximum=200.0, step=0.5, value=0.0,
-                info="Адаптивное ограничение экстремальных значений. threshold = clamp*(1+sigma/10)")
-
-            # ── Inter-Step ────────────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>🔁 Inter-Step</div>")
-            inter_step_mode = gr.Radio(
-                label="Режим", choices=INTER_STEP_MODES, value="Off")
-            with gr.Row():
-                momentum_slider = gr.Slider(
-                    label="Momentum", minimum=0.0, maximum=0.95, step=0.01, value=0.5,
-                    visible=False,
-                    info="Сглаживание NRS между шагами (0=выкл, 0.5=рекомендуется)")
-                ge_gamma_slider = gr.Slider(
-                    label="GE Gamma", minimum=0.1, maximum=4.0, step=0.05, value=1.5,
-                    visible=False,
-                    info=">1=экстраполяция тренда, 1=стандарт, <1=сглаживание")
-
-            def update_inter_step(mode):
-                return {
-                    momentum_slider: gr.update(visible=(mode == "Momentum")),
-                    ge_gamma_slider: gr.update(visible=(mode == "GE-Gamma")),
-                }
-
-            inter_step_mode.change(fn=update_inter_step, inputs=[inter_step_mode],
-                                   outputs=[momentum_slider, ge_gamma_slider])
-
-            # ── Enhancements ──────────────────────────────────────────────────
-            gr.HTML("<div style='margin:0.6em 0 0.4em; border-bottom:1px solid #555;"
-                    " font-size:0.9em; opacity:0.8;'>✨ Enhancements</div>")
-            with gr.Row():
-                detail_boost = gr.Slider(
-                    label="Detail Boost (0=выкл)", minimum=0.0, maximum=3.0, step=0.05, value=0.0,
-                    info="Усиление высокочастотных деталей на поздних шагах")
-                spectral_mod = gr.Slider(
-                    label="Spectral Modulation (0=выкл)", minimum=0.0, maximum=2.0, step=0.05, value=0.0,
-                    info="FFT-коррекция частот noise_pred перед NRS")
-            spectral_pct = gr.Slider(
-                label="Spectral Percentile", minimum=1.0, maximum=20.0, step=0.5, value=5.0,
-                info="Процентиль для частотной маски (меньше = агрессивнее)")
-            with gr.Row():
-                uncond_noise = gr.Slider(
-                    label="Uncond Noise (0=выкл)", minimum=0.0, maximum=0.5, step=0.01, value=0.0,
-                    info="Добавить шум к uncond (увеличивает разнообразие)")
-                uncond_scale = gr.Slider(
-                    label="Uncond Scale", minimum=0.1, maximum=2.0, step=0.01, value=1.0,
-                    info="Масштаб uncond (1.0=стандарт, <1=ослабить neg)")
-
-            # ── Step Control ──────────────────────────────────────────────────
-            with gr.Accordion("⏱️ Step Control", open=False):
-                with gr.Row():
-                    step_control_enabled = gr.Checkbox(label="Включить Step Control", value=False)
-                    step_control_mode = gr.Radio(
-                        label="Режим", choices=["Global", "Individual"], value="Global")
-
-                with gr.Group(visible=True) as global_group:
-                    gr.HTML("<div style='font-weight:bold; margin:0.4em 0;'>Глобальные настройки</div>")
-                    global_step_mode = gr.Radio(
-                        label="Режим шагов",
-                        choices=["Absolute Steps", "Fraction of Steps"],
-                        value="Absolute Steps")
-                    with gr.Row():
-                        global_start_step = gr.Slider(label="Start Step", minimum=0,
-                                                      maximum=150, step=1, value=0, visible=True)
-                        global_end_step = gr.Slider(label="End Step (0=конец)", minimum=0,
-                                                    maximum=150, step=1, value=0, visible=True)
-                    with gr.Row():
-                        global_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0,
-                                                      maximum=1.0, step=0.01, value=0.0, visible=False)
-                        global_end_frac = gr.Slider(label="End (fraction)", minimum=0.0,
-                                                    maximum=1.0, step=0.01, value=1.0, visible=False)
-
-                with gr.Group(visible=False) as individual_group:
-                    gr.HTML("<div style='font-weight:bold; margin:0.4em 0;'>Индивидуальные настройки</div>")
-                    with gr.Accordion("Skew — Step Settings", open=False):
-                        skew_step_enabled = gr.Checkbox(label="Включить для Skew", value=True)
-                        skew_step_mode = gr.Radio(label="Режим",
-                                                  choices=["Absolute Steps", "Fraction of Steps"],
-                                                  value="Absolute Steps")
-                        with gr.Row():
-                            skew_start_step = gr.Slider(label="Start Step", minimum=0,
-                                                        maximum=150, step=1, value=0, visible=True)
-                            skew_end_step = gr.Slider(label="End Step", minimum=0,
-                                                      maximum=150, step=1, value=0, visible=True)
-                        with gr.Row():
-                            skew_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0,
-                                                        maximum=1.0, step=0.01, value=0.0, visible=False)
-                            skew_end_frac = gr.Slider(label="End (fraction)", minimum=0.0,
-                                                      maximum=1.0, step=0.01, value=1.0, visible=False)
-                    with gr.Accordion("Stretch — Step Settings", open=False):
-                        stretch_step_enabled = gr.Checkbox(label="Включить для Stretch", value=True)
-                        stretch_step_mode = gr.Radio(label="Режим",
-                                                     choices=["Absolute Steps", "Fraction of Steps"],
-                                                     value="Absolute Steps")
-                        with gr.Row():
-                            stretch_start_step = gr.Slider(label="Start Step", minimum=0,
-                                                           maximum=150, step=1, value=0, visible=True)
-                            stretch_end_step = gr.Slider(label="End Step", minimum=0,
-                                                         maximum=150, step=1, value=0, visible=True)
-                        with gr.Row():
-                            stretch_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0,
-                                                           maximum=1.0, step=0.01, value=0.0, visible=False)
-                            stretch_end_frac = gr.Slider(label="End (fraction)", minimum=0.0,
-                                                         maximum=1.0, step=0.01, value=1.0, visible=False)
-                    with gr.Accordion("Squash — Step Settings", open=False):
-                        squash_step_enabled = gr.Checkbox(label="Включить для Squash", value=True)
-                        squash_step_mode = gr.Radio(label="Режим",
-                                                    choices=["Absolute Steps", "Fraction of Steps"],
-                                                    value="Absolute Steps")
-                        with gr.Row():
-                            squash_start_step = gr.Slider(label="Start Step", minimum=0,
-                                                          maximum=150, step=1, value=0, visible=True)
-                            squash_end_step = gr.Slider(label="End Step", minimum=0,
-                                                        maximum=150, step=1, value=0, visible=True)
-                        with gr.Row():
-                            squash_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0,
-                                                          maximum=1.0, step=0.01, value=0.0, visible=False)
-                            squash_end_frac = gr.Slider(label="End (fraction)", minimum=0.0,
-                                                        maximum=1.0, step=0.01, value=1.0, visible=False)
-
-                def update_sc_groups(mode):
-                    return {
-                        global_group: gr.update(visible=(mode == "Global")),
-                        individual_group: gr.update(visible=(mode == "Individual")),
-                    }
-
-                step_control_mode.change(fn=update_sc_groups, inputs=[step_control_mode],
-                                         outputs=[global_group, individual_group])
-
-                def _tog(mode):
-                    a = mode == "Absolute Steps"
-                    return (gr.update(visible=a), gr.update(visible=a),
-                            gr.update(visible=not a), gr.update(visible=not a))
-
-                global_step_mode.change(fn=_tog, inputs=[global_step_mode],
-                                        outputs=[global_start_step, global_end_step,
-                                                 global_start_frac, global_end_frac])
-                skew_step_mode.change(fn=_tog, inputs=[skew_step_mode],
-                                      outputs=[skew_start_step, skew_end_step,
-                                               skew_start_frac, skew_end_frac])
-                stretch_step_mode.change(fn=_tog, inputs=[stretch_step_mode],
-                                         outputs=[stretch_start_step, stretch_end_step,
-                                                  stretch_start_frac, stretch_end_frac])
-                squash_step_mode.change(fn=_tog, inputs=[squash_step_mode],
-                                        outputs=[squash_start_step, squash_end_step,
-                                                 squash_start_frac, squash_end_frac])
-
-        return [
-            # Core
-            enabled, skew, stretch, squash,
-            # Midpoint Refinement
-            refine_blend, refine_first_half,
-            # Scheduling
-            sched_mode,
-            skew_curve, skew_curve_min,
-            stretch_curve, stretch_curve_min,
-            squash_curve, squash_curve_min,
-            sched_val,
-            cads_tau1, cads_tau2,
-            adaptive_euler_end, adaptive_dpm_end,
-            # Advanced Math
-            per_channel, ad_norm,
-            blend_phi, variance_phi,
-            # Post-Processing
-            drift_intensity, drift_method,
-            output_clamp,
-            # Inter-Step
-            inter_step_mode, momentum_slider, ge_gamma_slider,
-            # Enhancements
-            detail_boost,
-            spectral_mod, spectral_pct,
-            uncond_noise, uncond_scale,
-            # Step Control
-            step_control_enabled, step_control_mode,
-            global_step_mode, global_start_step, global_end_step,
-            global_start_frac, global_end_frac,
-            skew_step_enabled, skew_step_mode, skew_start_step, skew_end_step,
-            skew_start_frac, skew_end_frac,
-            stretch_step_enabled, stretch_step_mode, stretch_start_step, stretch_end_step,
-            stretch_start_frac, stretch_end_frac,
-            squash_step_enabled, squash_step_mode, squash_start_step, squash_end_step,
-            squash_start_frac, squash_end_frac,
-        ]
-
-    def process(self, p,
-                # Core
-                enabled, skew, stretch, squash,
-                # Midpoint Refinement
-                refine_blend, refine_first_half,
-                # Scheduling
-                sched_mode,
-                skew_curve, skew_curve_min,
-                stretch_curve, stretch_curve_min,
-                squash_curve, squash_curve_min,
-                sched_val,
-                cads_tau1, cads_tau2,
-                adaptive_euler_end, adaptive_dpm_end,
-                # Advanced Math
-                per_channel, ad_norm,
-                blend_phi, variance_phi,
-                # Post-Processing
-                drift_intensity, drift_method,
-                output_clamp,
-                # Inter-Step
-                inter_step_mode, momentum, ge_gamma,
-                # Enhancements
-                detail_boost,
-                spectral_mod, spectral_pct,
-                uncond_noise, uncond_scale,
-                # Step Control
-                step_control_enabled, step_control_mode,
-                global_step_mode, global_start_step, global_end_step,
-                global_start_frac, global_end_frac,
-                skew_step_enabled, skew_step_mode, skew_start_step, skew_end_step,
-                skew_start_frac, skew_end_frac,
-                stretch_step_enabled, stretch_step_mode, stretch_start_step, stretch_end_step,
-                stretch_start_frac, stretch_end_frac,
-                squash_step_enabled, squash_step_mode, squash_start_step, squash_end_step,
-                squash_start_frac, squash_end_frac):
-
-        p._nrs_enabled = enabled
-        if not enabled:
-            return
-
-        # Core params
-        p._nrs_params = (skew, stretch, squash)
-
-        # Midpoint Refinement
-        p._nrs_refine_blend = refine_blend
-        p._nrs_refine_first_half = refine_first_half
-
-        # Scheduling
-        p._nrs_sched_mode = sched_mode
-        p._nrs_skew_curve = skew_curve
-        p._nrs_skew_curve_min = skew_curve_min
-        p._nrs_stretch_curve = stretch_curve
-        p._nrs_stretch_curve_min = stretch_curve_min
-        p._nrs_squash_curve = squash_curve
-        p._nrs_squash_curve_min = squash_curve_min
-        p._nrs_sched_val = sched_val
-        p._nrs_cads_tau1 = cads_tau1
-        p._nrs_cads_tau2 = cads_tau2
-        p._nrs_adaptive_euler_end = adaptive_euler_end
-        p._nrs_adaptive_dpm_end = adaptive_dpm_end
-
-        # Advanced Math
-        p._nrs_per_channel = per_channel
-        p._nrs_ad_norm = ad_norm
-        p._nrs_blend_phi = blend_phi
-        p._nrs_variance_phi = variance_phi
-
-        # Post-Processing
-        p._nrs_drift_intensity = drift_intensity
-        p._nrs_drift_method = drift_method
-        p._nrs_output_clamp = output_clamp
-
-        # Inter-Step
-        p._nrs_inter_step_mode = inter_step_mode
-        p._nrs_momentum = momentum
-        p._nrs_ge_gamma = ge_gamma
-        p._nrs_prev_results = {}
-        p._nrs_prev_diffs = {}
-
-        # Enhancements
-        p._nrs_detail_boost = detail_boost
-        p._nrs_spectral_mod = spectral_mod
-        p._nrs_spectral_pct = spectral_pct
-        p._nrs_uncond_noise = uncond_noise
-        p._nrs_uncond_scale = uncond_scale
-
-        # Step Control
-        p._nrs_step_control_enabled = step_control_enabled
-        p._nrs_step_control_mode = step_control_mode
-        p._nrs_global_step_settings = {
-            'step_mode': global_step_mode,
-            'start_step': global_start_step,
-            'end_step': global_end_step,
-            'start_frac': global_start_frac,
-            'end_frac': global_end_frac,
-        }
-        p._nrs_individual_step_settings = {
-            'skew': {
-                'enabled': skew_step_enabled, 'step_mode': skew_step_mode,
-                'start_step': skew_start_step, 'end_step': skew_end_step,
-                'start_frac': skew_start_frac, 'end_frac': skew_end_frac,
-            },
-            'stretch': {
-                'enabled': stretch_step_enabled, 'step_mode': stretch_step_mode,
-                'start_step': stretch_start_step, 'end_step': stretch_end_step,
-                'start_frac': stretch_start_frac, 'end_frac': stretch_end_frac,
-            },
-            'squash': {
-                'enabled': squash_step_enabled, 'step_mode': squash_step_mode,
-                'start_step': squash_start_step, 'end_step': squash_end_step,
-                'start_frac': squash_start_frac, 'end_frac': squash_end_frac,
-            },
-        }
-
-        p._nrs_current_step = 0
-        sd_samplers_cfg_denoiser.CFGDenoiser.combine_denoised = hijacked_combine_denoised
-
-    def postprocess(self, p, processed, *args):
-        # Clean up inter-step state to avoid memory leaks between generations
-        for attr in ('_nrs_prev_results', '_nrs_prev_diffs'):
-            if hasattr(p, attr):
-                delattr(p, attr)