Upload nrs_kohaku_enhanced_v2 (1).py

negative_rejection_steering/scripts/nrs_kohaku_enhanced_v2 (1).py

@@ -0,0 +1,1220 @@
+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)