Upload custom-hires-fix-mod-for-automatic1111-2.1 using SD-Hub

custom-hires-fix-mod-for-automatic1111-2.1/README.md

@@ -0,0 +1,29 @@
+# Custom Hires Fix (webui Extension)
+## Webui Extension for customizing highres fix and improve details (currently separated from original highres fix)
+
+
+#### Update 16.10.23:
+- added ControlNet support: choose preprocessor/model in CN settings, but don't enable unit
+- added Lora support: put Lora in extension prompt to enable Lora only for upscaling, put Lora in negative prompt to disable active Lora
+
+#### Update 02.07.23:
+- code rewritten again
+- simplified settings
+- fixed batch generation and image saving
+
+#### Update 13.06.23:
+- added gaussian noise instead of random
+
+#### Update 29.05.23:
+- added ToMe optomization in second pass, latest Auto1111 update required, controlled via "Token merging ratio for high-res pass" in settings
+- added "Sharp" setting, should be used only with "Smoothness" if image is too blurry
+
+#### Update 12.05.23:
+- added smoothness for negative, completely fix ghosting/smears/dirt on flat colors with high denoising
+
+#### Update 02.04.23:
+ ###### Don't forget to clear ui-config.json!
+- upscale separated from original high-res fix
+- now works with img2img
+- many fixes
+

custom-hires-fix-mod-for-automatic1111-2.1/config.yaml

@@ -0,0 +1,17 @@
+width: 1536
+height: 0
+prompt: ''
+negative_prompt: ''
+steps: 15
+first_upscaler: R-ESRGAN 4x+ Anime6B
+second_upscaler: R-ESRGAN 4x+ Anime6B
+first_latent: 0.3
+second_latent: 0.1
+strength: 1.25
+filter: Noise sync (sharp)
+filter_offset: 0
+denoise_offset: 0.05
+clip_skip: 0
+sampler: Euler Dy
+cn_ref: false
+start_control_at: 0

custom-hires-fix-mod-for-automatic1111-2.1/scripts/custom_hires_fix.py

@@ -0,0 +1,1433 @@
+import math
+import json
+import hashlib
+from pathlib import Path
+from collections import OrderedDict
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image, ImageFilter
+
+from modules import scripts, shared, processing, sd_schedulers, sd_samplers, script_callbacks, rng
+from modules import images, devices, prompt_parser, sd_models, extra_networks
+
+# Optional deps (best-effort)
+def _safe_import(modname, pipname=None):
+    try:
+        __import__(modname)
+        return True
+    except Exception:
+        try:
+            import pip
+            if hasattr(pip, "main"):
+                pip.main(["install", pipname or modname])
+            else:
+                pip._internal.main(["install", pipname or modname])
+            __import__(modname)
+            return True
+        except Exception:
+            return False
+
+_safe_import("omegaconf")
+_safe_import("kornia")
+_safe_import("k_diffusion", "k-diffusion")
+_safe_import("skimage")
+_safe_import("cv2")
+
+try:
+    from omegaconf import OmegaConf, DictConfig  # type: ignore
+except Exception:  # graceful fallback if OmegaConf not available
+    class DictConfig(dict):  # minimal stub
+        pass
+    class OmegaConf:  # minimal stub
+        @staticmethod
+        def load(path):
+            return DictConfig()
+        @staticmethod
+        def create(obj):
+            return DictConfig(obj)
+
+import kornia  # type: ignore
+import k_diffusion as K  # type: ignore
+
+# skimage helpers (optional)
+try:
+    from skimage.exposure import match_histograms, equalize_adapthist  # type: ignore
+    from skimage import color as skcolor  # type: ignore
+    _SKIMAGE_OK = True
+except Exception:
+    _SKIMAGE_OK = False
+
+# OpenCV (optional)
+try:
+    import cv2  # type: ignore
+    _CV2_OK = True
+except Exception:
+    _CV2_OK = False
+
+quote_swap = str.maketrans("\'\"", "\"\'")
+config_path = (Path(__file__).parent.resolve() / "../config.yaml").resolve()
+
+
+class CustomHiresFix(scripts.Script):
+    """Two-stage img2img upscaling with optional latent mixing and prompt overrides.
+
+    Features:
+    - Ratio/width/height or Megapixels target (+ quick MP buttons)
+    - Compact preset panel (global presets)
+    - Separate steps for 1st/2nd pass
+    - Per-pass sampler + scheduler
+    - CFG base + optional delta on 2nd pass
+    - Reuse seed/noise on 2nd pass
+    - Conditioning cache (LRU) with capacity
+    - Second-pass prompt (append/replace)
+    - Per-pass LoRA weight scaling
+    - Seamless tiling (+ overlap)
+    - VAE tiling toggle (low VRAM)
+    - Color match to original (strength) with presets
+    - Post-FX presets: CLAHE (local contrast), Unsharp Mask
+    - PNG-info serialization + paste support
+    """
+    def __init__(self):
+        super().__init__()
+        # Load or init config
+        if config_path.exists():
+            try:
+                self.config: DictConfig = OmegaConf.load(str(config_path)) or OmegaConf.create({})  # type: ignore
+            except Exception:
+                self.config = OmegaConf.create({})  # type: ignore
+        else:
+            self.config = OmegaConf.create({})  # type: ignore
+
+        # Runtime state
+        self.p = None
+        self.pp = None
+        self.cfg = 0.0
+        self.cond = None
+        self.uncond = None
+        self.width = None
+        self.height = None
+        self._orig_clip_skip = None
+        self._cn_units = []
+        self._use_cn = False
+
+        # Reuse state
+        self._saved_seeds = None
+        self._saved_subseeds = None
+        self._saved_subseed_strength = None
+        self._saved_seed_resize_from_h = None
+        self._saved_seed_resize_from_w = None
+        self._first_noise = None
+        self._first_noise_shape = None
+
+        # Conditioning cache (LRU)
+        self._cond_cache: OrderedDict[str, tuple] = OrderedDict()
+
+        # VAE tiling state restore
+        self._orig_opt_vae_tiling = None
+
+        # Seamless tiling restore
+        self._orig_tiling = None
+        self._orig_tile_overlap = None
+
+        # Prompt override for second pass
+        self._override_prompt_second = None
+
+        # LoRA scaling factor per pass (used during _prepare_conditioning by pass context)
+        self._current_lora_factor = 1.0
+
+    # ---- A1111 Script API ----
+    def title(self):
+        return "Custom Hires Fix"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        visible_names = [x.name for x in sd_samplers.visible_samplers()]
+        sampler_names = ["Restart + DPM++ 3M SDE"] + visible_names
+        scheduler_names = ["Use same scheduler"] + [x.label for x in sd_schedulers.schedulers]
+
+        with gr.Accordion(label="Custom Hires Fix", open=False) as enable_box:
+            enable = gr.Checkbox(label="Enable extension", value=bool(self.config.get("enable", False)))
+
+            # ---------- Compact preset panel ----------
+            with gr.Row():
+                quick_preset = gr.Dropdown(
+                    ["None", "Hi-Res Portrait", "Hi-Res Texture", "Hi-Res Illustration", "Hi-Res Product Shot"],
+                    label="Quick preset",
+                    value="None"
+                )
+                btn_apply_preset = gr.Button(value="Apply preset", variant="primary")
+
+                btn_mp_1 = gr.Button(value="MP 1.0")
+                btn_mp_2 = gr.Button(value="MP 2.0")
+                btn_mp_4 = gr.Button(value="MP 4.0")
+                btn_mp_8 = gr.Button(value="MP 8.0")
+
+            with gr.Row():
+                ratio = gr.Slider(minimum=0.0, maximum=4.0, step=0.05, label="Upscale by (ratio)",
+                                  value=float(self.config.get("ratio", 0.0)))
+                width = gr.Slider(minimum=0, maximum=4096, step=8, label="Resize width to",
+                                  value=int(self.config.get("width", 0)))
+                height = gr.Slider(minimum=0, maximum=4096, step=8, label="Resize height to",
+                                   value=int(self.config.get("height", 0)))
+            # --------- Size helpers ---------
+            with gr.Row():
+                long_edge = gr.Slider(minimum=0, maximum=8192, step=8,
+                                      label="Resize by long edge (0 = off)",
+                                      value=int(self.config.get("long_edge", 0)))
+                btn_swap_wh = gr.Button(value="Swap W↔H")
+
+
+            with gr.Row():
+                steps_first = gr.Slider(minimum=1, maximum=100, step=1, label="Hires steps — 1st pass",
+                                        value=int(self.config.get("steps_first", max(1, int(self.config.get("steps", 20))))))
+                steps_second = gr.Slider(minimum=1, maximum=100, step=1, label="Hires steps — 2nd pass",
+                                         value=int(self.config.get("steps_second", int(self.config.get("steps", 20)))))
+
+            # --------- Per-pass denoising ---------
+            with gr.Row():
+                denoise_first = gr.Slider(minimum=0.0, maximum=1.0, step=0.01,
+                                          label="Denoising strength — 1st pass",
+                                          value=float(self.config.get("denoise_first", 0.33)))
+                denoise_second = gr.Slider(minimum=0.0, maximum=1.0, step=0.01,
+                                           label="Denoising strength — 2nd pass",
+                                           value=float(self.config.get("denoise_second", 0.45)))
+            with gr.Row():
+                first_upscaler = gr.Dropdown([x.name for x in shared.sd_upscalers],
+                                             label="First upscaler", value=self.config.get("first_upscaler", "R-ESRGAN 4x+"))
+                second_upscaler = gr.Dropdown([x.name for x in shared.sd_upscalers],
+                                              label="Second upscaler", value=self.config.get("second_upscaler", "R-ESRGAN 4x+"))
+
+            with gr.Row():
+                first_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Latent mix (first stage)",
+                                         value=float(self.config.get("first_latent", 0.3)))
+                second_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Latent mix (second stage)",
+                                          value=float(self.config.get("second_latent", 0.1)))
+
+            with gr.Row():
+                filter_mode = gr.Dropdown(["Noise sync (sharp)", "Morphological (smooth)", "Combined (balanced)"],
+                                          label="Filter mode", value=self.config.get("filter_mode", "Noise sync (sharp)"))
+                strength = gr.Slider(minimum=0.5, maximum=4.0, step=0.1, label="Generation strength",
+                                     value=float(self.config.get("strength", 2.0)))
+                denoise_offset = gr.Slider(minimum=-0.1, maximum=0.2, step=0.01, label="Denoise offset",
+                                           value=float(self.config.get("denoise_offset", 0.05)))
+
+            with gr.Row():
+                prompt = gr.Textbox(label="Prompt override (1st pass)", placeholder="Leave empty to use main UI prompt",
+                                    value=self.config.get("prompt", ""))
+                negative_prompt = gr.Textbox(label="Negative prompt override", placeholder="Leave empty to use main UI negative prompt",
+                                             value=self.config.get("negative_prompt", ""))
+
+            with gr.Row():
+                second_pass_prompt = gr.Textbox(label="Second-pass prompt", placeholder="Append or replace on 2nd pass",
+                                                value=self.config.get("second_pass_prompt", ""))
+                second_pass_prompt_append = gr.Checkbox(label="Append instead of replace",
+                                                        value=bool(self.config.get("second_pass_prompt_append", True)))
+
+            with gr.Accordion(label="Extra", open=False):
+                with gr.Row():
+                    filter_offset = gr.Slider(minimum=-1.0, maximum=1.0, step=0.1, label="Filter offset",
+                                              value=float(self.config.get("filter_offset", 0.0)))
+                    clip_skip = gr.Slider(minimum=0, maximum=12, step=1, label="CLIP skip (0 = keep)",
+                                          value=int(self.config.get("clip_skip", 0)))
+
+                # Per-pass sampler/scheduler
+                with gr.Row():
+                    sampler_first = gr.Dropdown(sampler_names, label="Sampler — 1st pass",
+                                                value=self.config.get("sampler_first", sampler_names[0]))
+                    sampler_second = gr.Dropdown(sampler_names, label="Sampler — 2nd pass",
+                                                 value=self.config.get("sampler_second", self.config.get("sampler", sampler_names[0])))
+                with gr.Row():
+                    scheduler_first = gr.Dropdown(choices=scheduler_names, label="Schedule type — 1st pass",
+                                                  value=self.config.get("scheduler_first", self.config.get("scheduler", scheduler_names[0])))
+                    scheduler_second = gr.Dropdown(choices=scheduler_names, label="Schedule type — 2nd pass",
+                                                   value=self.config.get("scheduler_second", self.config.get("scheduler", scheduler_names[0])))
+
+                with gr.Row():
+                    cfg = gr.Slider(minimum=0, maximum=30, step=0.5, label="CFG Scale (base)",
+                                    value=float(self.config.get("cfg", 7.0)))
+                    cfg_second_pass_boost = gr.Checkbox(label="Enable CFG delta on 2nd pass",
+                                                        value=bool(self.config.get("cfg_second_pass_boost", True)))
+                    cfg_second_pass_delta = gr.Slider(minimum=-5.0, maximum=5.0, step=0.5, label="CFG delta (2nd pass)",
+                                                      value=float(self.config.get("cfg_second_pass_delta", 3.0)))
+
+                # Reuse seed/noise + Megapixels target
+                with gr.Row():
+                    reuse_seed_noise = gr.Checkbox(label="Reuse seed/noise on 2nd pass",
+                                                   value=bool(self.config.get("reuse_seed_noise", False)))
+                    mp_target_enabled = gr.Checkbox(label="Enable Megapixels target",
+                                                    value=bool(self.config.get("mp_target_enabled", False)))
+                    mp_target = gr.Slider(minimum=0.3, maximum=16.0, step=0.1, label="Megapixels",
+                                          value=float(self.config.get("mp_target", 2.0)))
+
+                # Conditioning cache controls
+                with gr.Row():
+                    cond_cache_enabled = gr.Checkbox(label="Enable conditioning cache (LRU)",
+                                                     value=bool(self.config.get("cond_cache_enabled", True)))
+                    cond_cache_max = gr.Slider(minimum=8, maximum=256, step=8, label="Conditioning cache size",
+                                               value=int(self.config.get("cond_cache_max", 64)))
+
+                # VAE tiling
+                with gr.Row():
+                    vae_tiling_enabled = gr.Checkbox(label="Enable VAE tiling (low VRAM)",
+                                                     value=bool(self.config.get("vae_tiling_enabled", False)))
+
+                # Seamless tiling
+                with gr.Row():
+                    seamless_tiling_enabled = gr.Checkbox(label="Seamless tiling (texture)",
+                                                          value=bool(self.config.get("seamless_tiling_enabled", False)))
+                    tile_overlap = gr.Slider(minimum=0, maximum=64, step=1, label="Tile overlap (px)",
+                                             value=int(self.config.get("tile_overlap", 12)))
+
+                # LoRA scaling
+                with gr.Row():
+                    lora_weight_first_factor = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="LoRA weight × (1st pass)",
+                                                         value=float(self.config.get("lora_weight_first_factor", 1.0)))
+                    lora_weight_second_factor = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="LoRA weight × (2nd pass)",
+                                                          value=float(self.config.get("lora_weight_second_factor", 1.0)))
+
+                # Match colors presets & controls
+                with gr.Row():
+                    match_colors_preset = gr.Dropdown(
+                        ["Off", "Subtle (0.3)", "Natural (0.5)", "Strong (0.8)"],
+                        label="Match colors preset",
+                        value=self.config.get("match_colors_preset", "Off")
+                    )
+                    match_colors_enabled = gr.Checkbox(label="Match colors to original",
+                                                       value=bool(self.config.get("match_colors_enabled", False)))
+                    match_colors_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Match strength",
+                                                      value=float(self.config.get("match_colors_strength", 0.5)))
+
+                # Post-processing presets & controls
+                with gr.Row():
+                    postfx_preset = gr.Dropdown(
+                        ["Off", "Soft clarity", "Portrait safe", "Texture boost", "Crisp detail"],
+                        label="Post-FX preset",
+                        value=self.config.get("postfx_preset", "Off")
+                    )
+                    clahe_enabled = gr.Checkbox(label="CLAHE (local contrast)",
+                                                value=bool(self.config.get("clahe_enabled", False)))
+                    clahe_clip = gr.Slider(minimum=1.0, maximum=5.0, step=0.1, label="CLAHE clip limit",
+                                           value=float(self.config.get("clahe_clip", 2.0)))
+                    clahe_tile_grid = gr.Slider(minimum=4, maximum=16, step=2, label="CLAHE tile grid",
+                                                value=int(self.config.get("clahe_tile_grid", 8)))
+
+                with gr.Row():
+                    unsharp_enabled = gr.Checkbox(label="Unsharp Mask (sharpen)",
+                                                  value=bool(self.config.get("unsharp_enabled", False)))
+                    unsharp_radius = gr.Slider(minimum=0.5, maximum=5.0, step=0.1, label="Unsharp radius",
+                                               value=float(self.config.get("unsharp_radius", 1.5)))
+                    unsharp_amount = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="Unsharp amount",
+                                               value=float(self.config.get("unsharp_amount", 0.75)))
+                    unsharp_threshold = gr.Slider(minimum=0, maximum=10, step=1, label="Unsharp threshold",
+                                                  value=int(self.config.get("unsharp_threshold", 0)))
+
+                with gr.Row():
+                    cn_ref = gr.Checkbox(label="Use last image as ControlNet reference", value=bool(self.config.get("cn_ref", False)))
+                    start_control_at = gr.Slider(minimum=0.0, maximum=0.7, step=0.01, label="CN start (enabled units)",
+                                                 value=float(self.config.get("start_control_at", 0.0)))
+
+            # ---------- Preset logic (UI events) ----------
+
+            def _apply_match_preset(preset_name):
+                if preset_name == "Off":
+                    return (gr.update(value=False), gr.update(value=0.5))
+                if preset_name == "Subtle (0.3)":
+                    return (gr.update(value=True), gr.update(value=0.3))
+                if preset_name == "Natural (0.5)":
+                    return (gr.update(value=True), gr.update(value=0.5))
+                if preset_name == "Strong (0.8)":
+                    return (gr.update(value=True), gr.update(value=0.8))
+                return (gr.update(), gr.update())
+
+            def _apply_postfx_preset(preset_name):
+                # Returns: clahe_enabled, clahe_clip, clahe_tile_grid, unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold
+                if preset_name == "Off":
+                    return (gr.update(value=False), gr.update(value=2.0), gr.update(value=8),
+                            gr.update(value=False), gr.update(value=1.5), gr.update(value=0.75), gr.update(value=0))
+                if preset_name == "Soft clarity":
+                    return (gr.update(value=True), gr.update(value=1.8), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.2), gr.update(value=0.6), gr.update(value=0))
+                if preset_name == "Portrait safe":
+                    return (gr.update(value=True), gr.update(value=1.6), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.4), gr.update(value=0.8), gr.update(value=2))
+                if preset_name == "Texture boost":
+                    return (gr.update(value=True), gr.update(value=2.4), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.6), gr.update(value=1.0), gr.update(value=0))
+                if preset_name == "Crisp detail":
+                    return (gr.update(value=True), gr.update(value=2.1), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.3), gr.update(value=0.9), gr.update(value=0))
+                return (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
+
+            def _apply_quick_preset(name):
+                # Returns a large tuple of updates for several controls
+                # Order must match the outputs list in .click below
+                # Defaults (no change)
+                out = [
+                    gr.update(),  # steps_first
+                    gr.update(),  # steps_second
+                    gr.update(),  # cfg_second_pass_boost
+                    gr.update(),  # cfg_second_pass_delta
+                    gr.update(),  # sampler_first
+                    gr.update(),  # sampler_second
+                    gr.update(),  # scheduler_first
+                    gr.update(),  # scheduler_second
+                    gr.update(),  # vae_tiling_enabled
+                    gr.update(),  # seamless_tiling_enabled
+                    gr.update(),  # tile_overlap
+                    gr.update(),  # match_colors_preset
+                    gr.update(),  # match_colors_enabled
+                    gr.update(),  # match_colors_strength
+                    gr.update(),  # postfx_preset
+                    gr.update(),  # clahe_enabled
+                    gr.update(),  # clahe_clip
+                    gr.update(),  # clahe_tile_grid
+                    gr.update(),  # unsharp_enabled
+                    gr.update(),  # unsharp_radius
+                    gr.update(),  # unsharp_amount
+                    gr.update(),  # unsharp_threshold
+                    gr.update(),  # reuse_seed_noise
+                    gr.update(),  # cond_cache_max
+                    gr.update(),  # lora_weight_first_factor
+                    gr.update(),  # lora_weight_second_factor
+                    gr.update(),  # mp_target_enabled
+                    gr.update(),  # mp_target
+                ]
+                if name == "Hi-Res Portrait":
+                    out = [
+                        gr.update(value=18), gr.update(value=28),
+                        gr.update(value=True), gr.update(value=2.5),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ 3M SDE"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=12),
+                        gr.update(value="Subtle (0.3)"), gr.update(value=True), gr.update(value=0.3),
+                        gr.update(value="Portrait safe"), gr.update(value=True), gr.update(value=1.6), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.4), gr.update(value=0.8), gr.update(value=2),
+                        gr.update(value=True), gr.update(value=64),
+                        gr.update(value=1.0), gr.update(value=1.1),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                elif name == "Hi-Res Texture":
+                    out = [
+                        gr.update(value=14), gr.update(value=22),
+                        gr.update(value=True), gr.update(value=3.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ SDE Karras"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=True), gr.update(value=12),
+                        gr.update(value="Off"), gr.update(value=False), gr.update(value=0.5),
+                        gr.update(value="Texture boost"), gr.update(value=True), gr.update(value=2.2), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.6), gr.update(value=1.0), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=128),
+                        gr.update(value=0.9), gr.update(value=1.25),
+                        gr.update(value=True), gr.update(value=4.0),
+                    ]
+                elif name == "Hi-Res Illustration":
+                    out = [
+                        gr.update(value=16), gr.update(value=24),
+                        gr.update(value=True), gr.update(value=2.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ 3M SDE"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=8),
+                        gr.update(value="Off"), gr.update(value=False), gr.update(value=0.5),
+                        gr.update(value="Crisp detail"), gr.update(value=True), gr.update(value=2.0), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.2), gr.update(value=0.9), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=64),
+                        gr.update(value=0.85), gr.update(value=1.2),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                elif name == "Hi-Res Product Shot":
+                    out = [
+                        gr.update(value=18), gr.update(value=26),
+                        gr.update(value=True), gr.update(value=2.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ SDE Karras"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=8),
+                        gr.update(value="Natural (0.5)"), gr.update(value=True), gr.update(value=0.5),
+                        gr.update(value="Crisp detail"), gr.update(value=True), gr.update(value=2.1), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.3), gr.update(value=0.9), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=96),
+                        gr.update(value=1.0), gr.update(value=1.15),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                return tuple(out)
+
+            def _set_mp():
+                # Will be replaced by lambda with closure per button via _kwargs in A1111? Not guaranteed.
+                # Provide a neutral default; we wire explicit functions below in WebUI won't support _kwargs.
+                return (gr.update(value=True), gr.update(value=2.0))
+
+            # Wire events
+            match_colors_preset.change(
+                fn=_apply_match_preset,
+                inputs=[match_colors_preset],
+                outputs=[match_colors_enabled, match_colors_strength]
+            )
+            postfx_preset.change(
+                fn=_apply_postfx_preset,
+                inputs=[postfx_preset],
+                outputs=[clahe_enabled, clahe_clip, clahe_tile_grid, unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold]
+            )
+            btn_apply_preset.click(
+                fn=_apply_quick_preset,
+                inputs=[quick_preset],
+                outputs=[
+                    steps_first, steps_second,
+                    cfg_second_pass_boost, cfg_second_pass_delta,
+                    sampler_first, sampler_second,
+                    scheduler_first, scheduler_second,
+                    vae_tiling_enabled, seamless_tiling_enabled, tile_overlap,
+                    match_colors_preset, match_colors_enabled, match_colors_strength,
+                    postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+                    unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+                    reuse_seed_noise, cond_cache_max,
+                    lora_weight_first_factor, lora_weight_second_factor,
+                    mp_target_enabled, mp_target
+                ]
+            )
+            # MP buttons (Gradio inside A1111 doesn't allow passing kwargs; define per-target lambdas)
+            btn_mp_1.click(fn=lambda: (gr.update(value=True), gr.update(value=1.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_2.click(fn=lambda: (gr.update(value=True), gr.update(value=2.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_4.click(fn=lambda: (gr.update(value=True), gr.update(value=4.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_8.click(fn=lambda: (gr.update(value=True), gr.update(value=8.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+
+        # Exclusivity helpers
+        width.change(fn=lambda x: gr.update(value=0), inputs=width, outputs=height)
+        height.change(fn=lambda x: gr.update(value=0), inputs=height, outputs=width)
+        ratio.change(fn=lambda x: (gr.update(value=0), gr.update(value=0)), inputs=ratio, outputs=[width, height])
+        # Long edge excludes ratio and explicit W/H
+        long_edge.change(fn=lambda _: (gr.update(value=0), gr.update(value=0), gr.update(value=0.0)),
+                         inputs=long_edge, outputs=[width, height, ratio])
+        # Swap button
+        btn_swap_wh.click(fn=lambda w, h: (h, w), inputs=[width, height], outputs=[width, height])
+
+
+        # infotext paste support
+        def read_params(d, key, default=None):
+            try:
+                return d["Custom Hires Fix"].get(key, default)
+            except Exception:
+                return default
+
+        self.infotext_fields = [
+            (enable, lambda d: "Custom Hires Fix" in d),
+            (ratio, lambda d: read_params(d, "ratio", 0.0)),
+            (width, lambda d: read_params(d, "width", 0)),
+            (height, lambda d: read_params(d, "height", 0)),
+            (long_edge, lambda d: read_params(d, "long_edge", 0)),
+            (steps_first, lambda d: read_params(d, "steps_first", read_params(d, "steps", 20))),
+            (steps_second, lambda d: read_params(d, "steps_second", read_params(d, "steps", 20))),
+            (denoise_first, lambda d: read_params(d, "denoise_first", 0.33)),
+            (denoise_second, lambda d: read_params(d, "denoise_second", 0.45)),
+            (first_upscaler, lambda d: read_params(d, "first_upscaler")),
+            (second_upscaler, lambda d: read_params(d, "second_upscaler")),
+            (first_latent, lambda d: read_params(d, "first_latent", 0.0)),
+            (second_latent, lambda d: read_params(d, "second_latent", 0.0)),
+            (prompt, lambda d: read_params(d, "prompt", "")),
+            (negative_prompt, lambda d: read_params(d, "negative_prompt", "")),
+            (second_pass_prompt, lambda d: read_params(d, "second_pass_prompt", "")),
+            (second_pass_prompt_append, lambda d: read_params(d, "second_pass_prompt_append", True)),
+            (strength, lambda d: read_params(d, "strength", 0.0)),
+            (filter_mode, lambda d: read_params(d, "filter_mode")),
+            (filter_offset, lambda d: read_params(d, "filter_offset", 0.0)),
+            (denoise_offset, lambda d: read_params(d, "denoise_offset", 0.0)),
+            (clip_skip, lambda d: read_params(d, "clip_skip", 0)),
+            # per-pass samplers/schedulers + legacy fallbacks
+            (sampler_first, lambda d: read_params(d, "sampler_first", read_params(d, "sampler", sampler_names[0]))),
+            (sampler_second, lambda d: read_params(d, "sampler_second", read_params(d, "sampler", sampler_names[0]))),
+            (scheduler_first, lambda d: read_params(d, "scheduler_first", read_params(d, "scheduler", scheduler_names[0]))),
+            (scheduler_second, lambda d: read_params(d, "scheduler_second", read_params(d, "scheduler", scheduler_names[0]))),
+            # cfg/delta
+            (cfg, lambda d: read_params(d, "cfg", 7.0)),
+            (cfg_second_pass_boost, lambda d: read_params(d, "cfg_second_pass_boost", True)),
+            (cfg_second_pass_delta, lambda d: read_params(d, "cfg_second_pass_delta", 3.0)),
+            # flags
+            (reuse_seed_noise, lambda d: read_params(d, "reuse_seed_noise", False)),
+            (mp_target_enabled, lambda d: read_params(d, "mp_target_enabled", False)),
+            (mp_target, lambda d: read_params(d, "mp_target", 2.0)),
+            (cond_cache_enabled, lambda d: read_params(d, "cond_cache_enabled", True)),
+            (cond_cache_max, lambda d: read_params(d, "cond_cache_max", 64)),
+            (vae_tiling_enabled, lambda d: read_params(d, "vae_tiling_enabled", False)),
+            (seamless_tiling_enabled, lambda d: read_params(d, "seamless_tiling_enabled", False)),
+            (tile_overlap, lambda d: read_params(d, "tile_overlap", 12)),
+            (lora_weight_first_factor, lambda d: read_params(d, "lora_weight_first_factor", 1.0)),
+            (lora_weight_second_factor, lambda d: read_params(d, "lora_weight_second_factor", 1.0)),
+            (match_colors_preset, lambda d: read_params(d, "match_colors_preset", "Off")),
+            (match_colors_enabled, lambda d: read_params(d, "match_colors_enabled", False)),
+            (match_colors_strength, lambda d: read_params(d, "match_colors_strength", 0.5)),
+            (postfx_preset, lambda d: read_params(d, "postfx_preset", "Off")),
+            (clahe_enabled, lambda d: read_params(d, "clahe_enabled", False)),
+            (clahe_clip, lambda d: read_params(d, "clahe_clip", 2.0)),
+            (clahe_tile_grid, lambda d: read_params(d, "clahe_tile_grid", 8)),
+            (unsharp_enabled, lambda d: read_params(d, "unsharp_enabled", False)),
+            (unsharp_radius, lambda d: read_params(d, "unsharp_radius", 1.5)),
+            (unsharp_amount, lambda d: read_params(d, "unsharp_amount", 0.75)),
+            (unsharp_threshold, lambda d: read_params(d, "unsharp_threshold", 0)),
+            (cn_ref, lambda d: read_params(d, "cn_ref", False)),
+            (start_control_at, lambda d: read_params(d, "start_control_at", 0.0)),
+        ]
+
+        return [
+            enable, quick_preset,
+            ratio, width, height, long_edge,
+            steps_first, steps_second, denoise_first, denoise_second,
+            first_upscaler, second_upscaler, first_latent, second_latent,
+            prompt, negative_prompt, second_pass_prompt, second_pass_prompt_append,
+            strength, filter_mode, filter_offset, denoise_offset,
+            sampler_first, sampler_second, scheduler_first, scheduler_second,
+            cfg, cfg_second_pass_boost, cfg_second_pass_delta,
+            reuse_seed_noise, mp_target_enabled, mp_target,
+            cond_cache_enabled, cond_cache_max,
+            vae_tiling_enabled,
+            seamless_tiling_enabled, tile_overlap,
+            lora_weight_first_factor, lora_weight_second_factor,
+            match_colors_preset, match_colors_enabled, match_colors_strength,
+            postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+            unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+            cn_ref, start_control_at
+        ]
+
+    # Capture base processing object and optional ControlNet state
+    def process(self, p, *args, **kwargs):
+        self.p = p
+        self._cn_units = []
+        self._use_cn = False
+        self._first_noise = None
+        self._first_noise_shape = None
+        self._saved_seeds = None
+        self._saved_subseeds = None
+        self._saved_subseed_strength = None
+        self._saved_seed_resize_from_h = None
+        self._saved_seed_resize_from_w = None
+        self._override_prompt_second = None
+
+        # Try detect ControlNet (best-effort; path may vary across installs)
+        ext_candidates = [
+            "extensions.sd_webui_controlnet.scripts.external_code",
+            "extensions.sd-webui-controlnet.scripts.external_code",
+            "extensions-builtin.sd-webui-controlnet.scripts.external_code",
+        ]
+        self._cn_ext = None
+        for mod in ext_candidates:
+            try:
+                self._cn_ext = __import__(mod, fromlist=["external_code"])
+                break
+            except Exception:
+                continue
+        if self._cn_ext:
+            try:
+                units = self._cn_ext.get_all_units_in_processing(p)
+                self._cn_units = list(units) if units else []
+                self._use_cn = len(self._cn_units) > 0
+            except Exception:
+                self._use_cn = False
+
+    # Log settings into PNG-info (single JSON block)
+    def before_process_batch(self, p, *args, **kwargs):
+        if not bool(self.config.get("enable", False)):
+            return
+        p.extra_generation_params["Custom Hires Fix"] = self.create_infotext
+
+    def create_infotext(self, p, *args, **kwargs):
+        scale_val = 0
+        if int(self.config.get("width", 0)) and int(self.config.get("height", 0)):
+            scale_val = f"{int(self.config.get('width'))}x{int(self.config.get('height'))}"
+        elif float(self.config.get("ratio", 0)):
+            scale_val = float(self.config.get("ratio"))
+
+        payload = {
+            "scale": scale_val,
+            "ratio": float(self.config.get("ratio", 0.0)),
+            "width": int(self.config.get("width", 0) or 0),
+            "height": int(self.config.get("height", 0) or 0),
+            "long_edge": int(self.config.get("long_edge", 0)),
+            "denoise_first": float(self.config.get("denoise_first", 0.33)),
+            "denoise_second": float(self.config.get("denoise_second", 0.45)),
+
+            "steps_first": int(self.config.get("steps_first", int(self.config.get("steps", 20)))),
+            "steps_second": int(self.config.get("steps_second", int(self.config.get("steps", 20)))),
+            "steps": int(self.config.get("steps", int(self.config.get("steps_first", 20)))),
+            "first_upscaler": self.config.get("first_upscaler", ""),
+            "second_upscaler": self.config.get("second_upscaler", ""),
+            "first_latent": float(self.config.get("first_latent", 0.3)),
+            "second_latent": float(self.config.get("second_latent", 0.1)),
+            "prompt": self.config.get("prompt", ""),
+            "negative_prompt": self.config.get("negative_prompt", ""),
+            "second_pass_prompt": self.config.get("second_pass_prompt", ""),
+            "second_pass_prompt_append": bool(self.config.get("second_pass_prompt_append", True)),
+            "strength": float(self.config.get("strength", 2.0)),
+            "filter_mode": self.config.get("filter_mode", ""),
+            "filter_offset": float(self.config.get("filter_offset", 0.0)),
+            "denoise_offset": float(self.config.get("denoise_offset", 0.05)),
+            "clip_skip": int(self.config.get("clip_skip", 0)),
+            # per-pass sampler/scheduler (include legacy for context)
+            "sampler_first": self.config.get("sampler_first", ""),
+            "sampler_second": self.config.get("sampler_second", self.config.get("sampler", "")),
+            "scheduler_first": self.config.get("scheduler_first", self.config.get("scheduler", "")),
+            "scheduler_second": self.config.get("scheduler_second", self.config.get("scheduler", "")),
+            # cfg
+            "cfg": float(self.cfg),
+            "cfg_second_pass_boost": bool(self.config.get("cfg_second_pass_boost", True)),
+            "cfg_second_pass_delta": float(self.config.get("cfg_second_pass_delta", 3.0)),
+            # flags
+            "reuse_seed_noise": bool(self.config.get("reuse_seed_noise", False)),
+            "mp_target_enabled": bool(self.config.get("mp_target_enabled", False)),
+            "mp_target": float(self.config.get("mp_target", 2.0)),
+            "cond_cache_enabled": bool(self.config.get("cond_cache_enabled", True)),
+            "cond_cache_max": int(self.config.get("cond_cache_max", 64)),
+            "vae_tiling_enabled": bool(self.config.get("vae_tiling_enabled", False)),
+            "seamless_tiling_enabled": bool(self.config.get("seamless_tiling_enabled", False)),
+            "tile_overlap": int(self.config.get("tile_overlap", 12)),
+            "lora_weight_first_factor": float(self.config.get("lora_weight_first_factor", 1.0)),
+            "lora_weight_second_factor": float(self.config.get("lora_weight_second_factor", 1.0)),
+            "match_colors_preset": self.config.get("match_colors_preset", "Off"),
+            "match_colors_enabled": bool(self.config.get("match_colors_enabled", False)),
+            "match_colors_strength": float(self.config.get("match_colors_strength", 0.5)),
+            "postfx_preset": self.config.get("postfx_preset", "Off"),
+            "clahe_enabled": bool(self.config.get("clahe_enabled", False)),
+            "clahe_clip": float(self.config.get("clahe_clip", 2.0)),
+            "clahe_tile_grid": int(self.config.get("clahe_tile_grid", 8)),
+            "unsharp_enabled": bool(self.config.get("unsharp_enabled", False)),
+            "unsharp_radius": float(self.config.get("unsharp_radius", 1.5)),
+            "unsharp_amount": float(self.config.get("unsharp_amount", 0.75)),
+            "unsharp_threshold": int(self.config.get("unsharp_threshold", 0)),
+            "cn_ref": bool(self.config.get("cn_ref", False)),
+            "start_control_at": float(self.config.get("start_control_at", 0.0)),
+        }
+        return json.dumps(payload, ensure_ascii=False).translate(quote_swap)
+
+    # --- Main postprocess hook ---
+    def postprocess_image(self, p, pp,
+                          enable, quick_preset,
+                          ratio, width, height, long_edge,
+                          steps_first, steps_second, denoise_first, denoise_second,
+                          first_upscaler, second_upscaler, first_latent, second_latent,
+                          prompt, negative_prompt, second_pass_prompt, second_pass_prompt_append,
+                          strength, filter_mode, filter_offset, denoise_offset,
+                          sampler_first, sampler_second, scheduler_first, scheduler_second,
+                          cfg, cfg_second_pass_boost, cfg_second_pass_delta,
+                          reuse_seed_noise, mp_target_enabled, mp_target,
+                          cond_cache_enabled, cond_cache_max,
+                          vae_tiling_enabled,
+                          seamless_tiling_enabled, tile_overlap,
+                          lora_weight_first_factor, lora_weight_second_factor,
+                          match_colors_preset, match_colors_enabled, match_colors_strength,
+                          postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+                          unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+                          cn_ref, start_control_at):
+        if not enable:
+            return
+
+        # Save config chosen in UI
+        self.pp = pp
+        self.config["enable"] = bool(enable)
+        self.config["ratio"] = float(ratio)
+        self.config["width"] = int(width)
+        self.config["height"] = int(height)
+        self.config["long_edge"] = int(long_edge)
+        self.config["steps_first"] = int(steps_first)
+        self.config["steps_second"] = int(steps_second)
+        self.config["denoise_first"] = float(denoise_first)
+        self.config["denoise_second"] = float(denoise_second)
+        self.config["steps"] = int(steps_second)  # legacy aggregate
+        self.config["first_upscaler"] = first_upscaler
+        self.config["second_upscaler"] = second_upscaler
+        self.config["first_latent"] = float(first_latent)
+        self.config["second_latent"] = float(second_latent)
+        self.config["prompt"] = prompt.strip()
+        self.config["negative_prompt"] = negative_prompt.strip()
+        self.config["second_pass_prompt"] = second_pass_prompt.strip()
+        self.config["second_pass_prompt_append"] = bool(second_pass_prompt_append)
+        self.config["strength"] = float(strength)
+        self.config["filter_mode"] = filter_mode
+        self.config["filter_offset"] = float(filter_offset)
+        self.config["denoise_offset"] = float(denoise_offset)
+        # per-pass sampler/scheduler
+        self.config["sampler_first"] = sampler_first
+        self.config["sampler_second"] = sampler_second
+        self.config["scheduler_first"] = scheduler_first
+        self.config["scheduler_second"] = scheduler_second
+        # cfg/delta
+        self.config["cfg"] = float(cfg)
+        self.config["cfg_second_pass_boost"] = bool(cfg_second_pass_boost)
+        self.config["cfg_second_pass_delta"] = float(cfg_second_pass_delta)
+        # flags & extras
+        self.config["reuse_seed_noise"] = bool(reuse_seed_noise)
+        self.config["mp_target_enabled"] = bool(mp_target_enabled)
+        self.config["mp_target"] = float(mp_target)
+        self.config["cond_cache_enabled"] = bool(cond_cache_enabled)
+        self.config["cond_cache_max"] = int(cond_cache_max)
+        self.config["vae_tiling_enabled"] = bool(vae_tiling_enabled)
+        self.config["seamless_tiling_enabled"] = bool(seamless_tiling_enabled)
+        self.config["tile_overlap"] = int(tile_overlap)
+        self.config["lora_weight_first_factor"] = float(lora_weight_first_factor)
+        self.config["lora_weight_second_factor"] = float(lora_weight_second_factor)
+        self.config["match_colors_preset"] = match_colors_preset
+        self.config["match_colors_enabled"] = bool(match_colors_enabled)
+        self.config["match_colors_strength"] = float(match_colors_strength)
+        self.config["postfx_preset"] = postfx_preset
+        self.config["clahe_enabled"] = bool(clahe_enabled)
+        self.config["clahe_clip"] = float(clahe_clip)
+        self.config["clahe_tile_grid"] = int(clahe_tile_grid)
+        self.config["unsharp_enabled"] = bool(unsharp_enabled)
+        self.config["unsharp_radius"] = float(unsharp_radius)
+        self.config["unsharp_amount"] = float(unsharp_amount)
+        self.config["unsharp_threshold"] = int(unsharp_threshold)
+        self.config["cn_ref"] = bool(cn_ref)
+        self.config["start_control_at"] = float(start_control_at)
+        self.cfg = float(cfg) if cfg else float(p.cfg_scale)
+
+        # Validate sizing rules if MP target is off; if MP is on, sizing will be computed
+        if not self.config["mp_target_enabled"]:
+            assert ((width and height) or
+                    ((width == 0 and height == 0) and (ratio and ratio > 0)) or
+                    (width > 0) or (height > 0)),                 "Set width+height, or set both to 0 and ratio>0, or provide at least one dimension."
+
+        # Apply CLIP skip for the run
+        self._orig_clip_skip = shared.opts.CLIP_stop_at_last_layers
+        if int(self.config.get("clip_skip", 0)) > 0:
+            shared.opts.CLIP_stop_at_last_layers = int(self.config.get("clip_skip", 0))
+
+        # Toggle VAE tiling for the run
+        self._set_vae_tiling(self.config["vae_tiling_enabled"])
+
+        # Toggle seamless tiling
+        self._orig_tiling = getattr(self.p, "tiling", None)
+        self._orig_tile_overlap = getattr(self.p, "tile_overlap", None)
+        if bool(self.config.get("seamless_tiling_enabled", False)):
+            try:
+                self.p.tiling = True
+                if hasattr(self.p, "tile_overlap"):
+                    self.p.tile_overlap = int(self.config.get("tile_overlap", 12))
+            except Exception:
+                pass
+
+        # Activate extra networks from prompts
+        _, loras_act = extra_networks.parse_prompt(self.config["prompt"])
+        extra_networks.activate(p, loras_act)
+        _, loras_deact = extra_networks.parse_prompt(self.config["negative_prompt"])
+        extra_networks.deactivate(p, loras_deact)
+
+        try:
+            with devices.autocast():
+                shared.state.nextjob()
+                x = self._first_pass(pp.image)
+                shared.state.nextjob()
+                x = self._second_pass(x)
+            sd_models.apply_token_merging(p.sd_model, p.get_token_merging_ratio())
+            # Post-FX chain is inside _second_pass
+            pp.image = x
+        finally:
+            # Restore options
+            shared.opts.CLIP_stop_at_last_layers = self._orig_clip_skip
+            self._restore_vae_tiling()
+            if self._orig_tiling is not None:
+                try:
+                    self.p.tiling = self._orig_tiling
+                    if hasattr(self.p, "tile_overlap") and self._orig_tile_overlap is not None:
+                        self.p.tile_overlap = self._orig_tile_overlap
+                except Exception:
+                    pass
+            extra_networks.deactivate(p, loras_act)
+
+    # ---- Helpers ----
+    def _maybe_mp_resize(self, base_w, base_h, target_mp: float):
+        """Compute size from megapixels while keeping aspect ratio; quantize to multiple of 8."""
+        aspect = base_w / base_h if base_h else 1.0
+        total_px = max(0.01, target_mp) * 1_000_000.0
+        w_float = math.sqrt(total_px * aspect)
+        h_float = w_float / aspect
+        w = max(8, int(round(w_float / 8) * 8))
+        h = max(8, int(round(h_float / 8) * 8))
+        return w, h
+
+    def _compute_denoise(self, base_key: str) -> float:
+        """
+        Returns clamped denoising strength in [0,1] as (config[base_key] + denoise_offset).
+        Keeps backwards-compatibility with the previous "denoise_offset" knob.
+        """
+        try:
+            base = float(self.config.get(base_key, 0.5))
+        except Exception:
+            base = 0.5
+        try:
+            off = float(self.config.get("denoise_offset", 0.0))
+        except Exception:
+            off = 0.0
+        val = max(0.0, min(1.0, base + off))
+        return val
+
+    def _model_hash_for_cache(self):
+        # best-effort model hash for cache key
+        try:
+            return getattr(shared.sd_model, "sd_model_hash", None) or getattr(shared.sd_model, "hash", None) or str(id(shared.sd_model))
+        except Exception:
+            return str(id(shared.sd_model))
+
+    def _cond_key(self, width, height, steps_for_cond, prompt: str, negative: str, clip_skip: int):
+        h = hashlib.sha256()
+        h.update((prompt or "").encode("utf-8"))
+        h.update(b"::")
+        h.update((negative or "").encode("utf-8"))
+        key = f"{self._model_hash_for_cache()}|{width}x{height}|{steps_for_cond}|cs={clip_skip}|{h.hexdigest()}"
+        return key
+
+    def _cond_cache_get(self, key: str):
+        if not bool(self.config.get("cond_cache_enabled", True)):
+            return None
+        item = self._cond_cache.get(key)
+        if item is not None:
+            self._cond_cache.move_to_end(key)
+        return item
+
+    def _cond_cache_put(self, key: str, value: tuple):
+        if not bool(self.config.get("cond_cache_enabled", True)):
+            return
+        self._cond_cache[key] = value
+        self._cond_cache.move_to_end(key)
+        max_items = int(self.config.get("cond_cache_max", 64))
+        while len(self._cond_cache) > max_items:
+            self._cond_cache.popitem(last=False)
+
+    def _set_vae_tiling(self, enabled: bool):
+        # Save original state if we have not yet
+        if self._orig_opt_vae_tiling is None and hasattr(shared.opts, "sd_vae_tiling"):
+            self._orig_opt_vae_tiling = bool(shared.opts.sd_vae_tiling)
+        # Toggle option
+        if hasattr(shared.opts, "sd_vae_tiling"):
+            shared.opts.sd_vae_tiling = bool(enabled)
+        # Try model-level toggle
+        vae = getattr(shared.sd_model, "first_stage_model", None)
+        if vae is not None:
+            try:
+                if enabled and hasattr(vae, "enable_tiling"):
+                    vae.enable_tiling()
+                if not enabled and hasattr(vae, "disable_tiling"):
+                    vae.disable_tiling()
+            except Exception:
+                pass
+
+    def _restore_vae_tiling(self):
+        if self._orig_opt_vae_tiling is not None and hasattr(shared.opts, "sd_vae_tiling"):
+            shared.opts.sd_vae_tiling = self._orig_opt_vae_tiling
+        vae = getattr(shared.sd_model, "first_stage_model", None)
+        if vae is not None:
+            try:
+                if self._orig_opt_vae_tiling and hasattr(vae, "enable_tiling"):
+                    vae.enable_tiling()
+                elif not self._orig_opt_vae_tiling and hasattr(vae, "disable_tiling"):
+                    vae.disable_tiling()
+            except Exception:
+                pass
+        self._orig_opt_vae_tiling = None
+
+    def _scale_lora_in_prompt(self, text: str, factor: float) -> str:
+        # Multiply existing <lora:name:weight>, or append weight if missing
+        # Very lightweight parser to keep prompt untouched otherwise
+        if factor is None or abs(factor - 1.0) < 1e-6:
+            return text
+        out = []
+        i = 0
+        while i < len(text):
+            start = text.find("<lora:", i)
+            if start == -1:
+                out.append(text[i:])
+                break
+            out.append(text[i:start])
+            end = text.find(">", start)
+            if end == -1:
+                out.append(text[start:])
+                break
+            token = text[start:end+1]
+            parts = token[1:-1].split(":")  # lora,name,weight?
+            if len(parts) >= 2 and parts[0] == "lora":
+                name = parts[1]
+                if len(parts) >= 3:
+                    try:
+                        w = float(parts[2])
+                    except Exception:
+                        w = 1.0
+                    new_w = max(0.0, w * factor)
+                    new_token = f"<lora:{name}:{new_w:.4g}>"
+                else:
+                    new_token = f"<lora:{name}:{factor:.4g}>"
+                out.append(new_token)
+            else:
+                out.append(token)
+            i = end + 1
+        return "".join(out)
+
+    def _prepare_conditioning(self, width, height, steps_for_cond: int, prompt_override: str = None):
+        """Build (cond, uncond) with optional LRU caching and LoRA scaling."""
+        base_prompt = self.config.get("prompt", "").strip() or self.p.prompt.strip()
+        negative_base = self.config.get("negative_prompt", "").strip() or self.p.negative_prompt.strip()
+
+        if prompt_override:
+            base_prompt = prompt_override.strip()
+
+        # Apply LoRA scaling for this pass
+        scaled_prompt = self._scale_lora_in_prompt(base_prompt, self._current_lora_factor)
+
+        clip_skip = int(self.config.get("clip_skip", 0))
+
+        # Cache lookup
+        cache_key = self._cond_key(width, height, steps_for_cond, scaled_prompt, negative_base, clip_skip)
+        cached = self._cond_cache_get(cache_key)
+        if cached is not None:
+            self.cond, self.uncond = cached
+            return
+
+        # Parse extra networks and build cond
+        prompt_text = scaled_prompt
+        if not getattr(self.p, "disable_extra_networks", False):
+            try:
+                prompt_text, extra = extra_networks.parse_prompt(prompt_text)
+                if extra:
+                    extra_networks.activate(self.p, extra)
+            except Exception:
+                pass
+
+        if width and height and hasattr(prompt_parser, "SdConditioning"):
+            c = prompt_parser.SdConditioning([prompt_text], False, width, height)
+            uc = prompt_parser.SdConditioning([negative_base], False, width, height)
+        else:
+            c, uc = [prompt_text], [negative_base]
+
+        cond = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, c, steps_for_cond)
+        uncond = prompt_parser.get_learned_conditioning(shared.sd_model, uc, steps_for_cond)
+        self.cond, self.uncond = cond, uncond
+
+        # Store in cache
+        self._cond_cache_put(cache_key, (cond, uncond))
+
+    def _to_sample(self, x_img: Image.Image):
+        image = np.array(x_img).astype(np.float32) / 255.0
+        image = np.moveaxis(image, 2, 0)
+        decoded = torch.from_numpy(image).to(shared.device).to(devices.dtype_vae)
+        decoded = 2.0 * decoded - 1.0
+        encoded = shared.sd_model.encode_first_stage(decoded.unsqueeze(0).to(devices.dtype_vae))
+        sample = shared.sd_model.get_first_stage_encoding(encoded)
+        return decoded, sample
+
+    def _create_sampler(self, sampler_name: str):
+        if "Restart" in sampler_name:
+            try:
+                return sd_samplers.create_sampler("Restart", shared.sd_model)
+            except Exception:
+                return sd_samplers.create_sampler("DPM++ 2M Karras", shared.sd_model)
+        return sd_samplers.create_sampler(sampler_name, shared.sd_model)
+
+    def _apply_clahe(self, img: Image.Image) -> Image.Image:
+        if not bool(self.config.get("clahe_enabled", False)):
+            return img
+        np_img = np.array(img)
+        if _CV2_OK:
+            lab = cv2.cvtColor(np_img, cv2.COLOR_RGB2LAB)
+            l, a, b = cv2.split(lab)
+            clip = float(self.config.get("clahe_clip", 2.0))
+            tiles = int(self.config.get("clahe_tile_grid", 8))
+            clahe = cv2.createCLAHE(clipLimit=max(0.1, clip), tileGridSize=(tiles, tiles))
+            l2 = clahe.apply(l)
+            lab2 = cv2.merge((l2, a, b))
+            rgb = cv2.cvtColor(lab2, cv2.COLOR_LAB2RGB)
+            return Image.fromarray(rgb)
+        if _SKIMAGE_OK:
+            # skimage fallback on L channel in LAB
+            lab = skcolor.rgb2lab(np_img / 255.0)
+            l = lab[..., 0] / 100.0
+            l2 = equalize_adapthist(l, clip_limit=float(self.config.get("clahe_clip", 2.0)))
+            lab[..., 0] = np.clip(l2 * 100.0, 0, 100.0)
+            rgb = skcolor.lab2rgb(lab)
+            rgb8 = np.clip(rgb * 255.0, 0, 255).astype(np.uint8)
+            return Image.fromarray(rgb8)
+        # No-op fallback
+        return img
+
+    def _apply_unsharp(self, img: Image.Image) -> Image.Image:
+        if not bool(self.config.get("unsharp_enabled", False)):
+            return img
+        radius = float(self.config.get("unsharp_radius", 1.5))
+        amount = float(self.config.get("unsharp_amount", 0.75))
+        threshold = int(self.config.get("unsharp_threshold", 0))
+        return img.filter(ImageFilter.UnsharpMask(radius=radius, percent=int(amount * 100), threshold=threshold))
+
+    def _apply_match_colors(self, img: Image.Image, ref: Image.Image) -> Image.Image:
+        if not bool(self.config.get("match_colors_enabled", False)):
+            return img
+        strength = float(self.config.get("match_colors_strength", 0.5))
+        strength = max(0.0, min(1.0, strength))
+        if strength <= 0.0:
+            return img
+
+        arr = np.array(img).astype(np.float32)
+        ref_arr = np.array(ref).astype(np.float32)
+
+        matched = None
+        if _SKIMAGE_OK:
+            try:
+                matched = match_histograms(arr, ref_arr, channel_axis=-1).astype(np.float32)
+            except TypeError:
+                # older skimage
+                matched = match_histograms(arr, ref_arr, multichannel=True).astype(np.float32)
+        else:
+            # simple mean-std per channel fallback
+            eps = 1e-6
+            for c in range(arr.shape[2]):
+                src = arr[..., c]
+                dst = ref_arr[..., c]
+                src_m, src_s = src.mean(), src.std() + eps
+                dst_m, dst_s = dst.mean(), dst.std() + eps
+                arr[..., c] = np.clip((src - src_m) * (dst_s / src_s) + dst_m, 0, 255)
+            matched = arr
+
+        out = (1.0 - strength) * arr + strength * matched
+        out = np.clip(out, 0, 255).astype(np.uint8)
+        return Image.fromarray(out)
+
+    def _first_pass(self, x: Image.Image) -> Image.Image:
+        # Determine target size
+        if bool(self.config.get("mp_target_enabled", False)):
+            w, h = self._maybe_mp_resize(x.width, x.height, float(self.config.get("mp_target", 2.0)))
+        else:
+            ratio = x.width / x.height if x.height else 1.0
+            
+            le = int(self.config.get("long_edge", 0))
+            if le > 0:
+                if x.width >= x.height:
+                    w = int(max(8, round(le / 8) * 8))
+                    h = int(max(8, round((le / ratio) / 8) * 8))
+                else:
+                    h = int(max(8, round(le / 8) * 8))
+                    w = int(max(8, round((le * ratio) / 8) * 8))
+            elif int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and float(self.config.get("ratio", 0)) > 0:
+                w = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+                h = int(max(8, round(x.height * float(self.config["ratio"]) / 8) * 8))
+            else:
+                if int(self.config.get("width", 0)) > 0 and int(self.config.get("height", 0)) > 0:
+                    w, h = int(self.config["width"]), int(self.config["height"])
+                elif int(self.config.get("width", 0)) > 0:
+                    w = int(self.config["width"])
+                    h = int(round(w / ratio / 8) * 8)
+                elif int(self.config.get("height", 0)) > 0:
+                    h = int(self.config["height"])
+                    w = int(round(h * ratio / 8) * 8)
+                else:
+                    w, h = x.width, x.height
+
+        self.width, self.height = w, h
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True) / 2)
+
+        # Per-pass scheduler
+        sched_first = self.config.get("scheduler_first", self.config.get("scheduler", "Use same scheduler"))
+        self.p.scheduler = self.p.scheduler if sched_first == "Use same scheduler" else sched_first
+
+        # Optional ControlNet
+        if self._use_cn:
+            try:
+                cn_np = np.array(x.resize((self.width, self.height)))
+                self._enable_controlnet(cn_np)
+            except Exception:
+                pass
+
+        # Build override prompt for first pass (none; base prompt)
+        self._current_lora_factor = float(self.config.get("lora_weight_first_factor", 1.0))
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(self.width, self.height, int(self.config.get("steps_first", 20)))
+
+        # Upscale (image domain) then (optionally) blend latent
+        x_img = images.resize_image(0, x, self.width, self.height, upscaler_name=self.config.get("first_upscaler", "R-ESRGAN 4x+"))
+        decoded, sample = self._to_sample(x_img)
+        x_latent = torch.nn.functional.interpolate(sample, (self.height // 8, self.width // 8), mode="nearest")
+
+        first_latent = float(self.config.get("first_latent", 0.3))
+        if 0.0 <= first_latent <= 1.0:
+            sample = (x_latent * (1.0 - first_latent)) + (sample * first_latent)
+
+        image_conditioning = self.p.img2img_image_conditioning(decoded, sample)
+
+        # RNG setup
+        self._saved_seeds = list(getattr(self.p, "seeds", [])) or None
+        self._saved_subseeds = list(getattr(self.p, "subseeds", [])) or None
+        self._saved_subseed_strength = getattr(self.p, "subseed_strength", None)
+        self._saved_seed_resize_from_h = getattr(self.p, "seed_resize_from_h", None)
+        self._saved_seed_resize_from_w = getattr(self.p, "seed_resize_from_w", None)
+
+        self.p.rng = rng.ImageRNG(sample.shape[1:], self.p.seeds, subseeds=self.p.subseeds,
+                                  subseed_strength=self.p.subseed_strength,
+                                  seed_resize_from_h=self.p.seed_resize_from_h, seed_resize_from_w=self.p.seed_resize_from_w)
+
+        # Denoise config for first pass
+        steps = int(self.config.get("steps_first", int(self.config.get("steps", 20))))
+        noise = torch.randn_like(sample)
+        if bool(self.config.get("reuse_seed_noise", False)):
+            self._first_noise = noise.detach().clone()
+            self._first_noise_shape = tuple(sample.shape)
+
+        self.p.denoising_strength = self._compute_denoise("denoise_first")
+        self.p.cfg_scale = float(self.cfg)
+
+        def denoiser_override(n):
+            return K.sampling.get_sigmas_polyexponential(n, 0.005, 20, 0.6, devices.device)  # type: ignore
+
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+
+        # Per-pass sampler
+        sampler_first = self.config.get("sampler_first", self.config.get("sampler", "DPM++ 2M Karras"))
+        sampler = self._create_sampler(sampler_first)
+
+        samples = sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                         steps=steps, image_conditioning=image_conditioning).to(devices.dtype_vae)
+
+        devices.torch_gc()
+        decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        if math.isnan(decoded_sample.min() if hasattr(decoded_sample, "min") else 0):
+            devices.torch_gc()
+            samples = torch.clamp(samples, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_np = 255.0 * np.moveaxis(decoded_sample.to(torch.float32).cpu().numpy(), 0, 2)
+        return Image.fromarray(x_np.astype(np.uint8))
+
+    def _second_pass(self, x: Image.Image) -> Image.Image:
+        # Determine target size for second pass
+        if bool(self.config.get("mp_target_enabled", False)):
+            w, h = self._maybe_mp_resize(x.width, x.height, float(self.config.get("mp_target", 2.0)))
+        else:
+            
+            le = int(self.config.get("long_edge", 0))
+            if le > 0:
+                aspect = x.width / x.height if x.height else 1.0
+                if x.width >= x.height:
+                    w = int(max(8, round(le / 8) * 8))
+                    h = int(max(8, round((le / aspect) / 8) * 8))
+                else:
+                    h = int(max(8, round(le / 8) * 8))
+                    w = int(max(8, round((le * aspect) / 8) * 8))
+            elif (int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and
+                    float(self.config.get("ratio", 0)) > 0):
+                w = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+                h = int(max(8, round(x.height * float(self.config["ratio"]) / 8) * 8))
+            else:
+                aspect = x.width / x.height if x.height else 1.0
+                if int(self.config.get("width", 0)) > 0 and int(self.config.get("height", 0)) > 0:
+                    w, h = int(self.config["width"]), int(self.config["height"])
+                elif int(self.config.get("width", 0)) > 0:
+                    w = int(self.config["width"])
+                    h = int(round(w / aspect / 8) * 8)
+                elif int(self.config.get("height", 0)) > 0:
+                    h = int(self.config["height"])
+                    w = int(round(h * aspect / 8) * 8)
+                else:
+                    w, h = x.width, x.height
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True))
+
+        # Per-pass scheduler
+        sched_second = self.config.get("scheduler_second", self.config.get("scheduler", "Use same scheduler"))
+        self.p.scheduler = self.p.scheduler if sched_second == "Use same scheduler" else sched_second
+
+        if self._use_cn:
+            cn_img = x if bool(self.config.get("cn_ref", False)) else self.pp.image
+            try:
+                self._enable_controlnet(np.array(cn_img.resize((w, h))))
+            except Exception:
+                pass
+
+        # Build override prompt for second pass
+        base_prompt = self.config.get("prompt", "").strip() or self.p.prompt.strip()
+        p2 = (self.config.get("second_pass_prompt", "") or "").strip()
+        if p2:
+            if bool(self.config.get("second_pass_prompt_append", True)):
+                prompt_override = (base_prompt + ", " + p2) if base_prompt else p2
+            else:
+                prompt_override = p2
+        else:
+            prompt_override = None
+
+        # Apply LoRA scaling for second pass
+        self._current_lora_factor = float(self.config.get("lora_weight_second_factor", 1.0))
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(w, h, int(self.config.get("steps_second", 20)), prompt_override=prompt_override)
+
+        # Optional latent mix
+        x_latent = None
+        second_latent = float(self.config.get("second_latent", 0.1))
+        if second_latent > 0:
+            _, sample_from_img = self._to_sample(x)
+            x_latent = torch.nn.functional.interpolate(sample_from_img, (h // 8, w // 8), mode="nearest")
+
+        # Upscale to target and encode
+        if second_latent < 1.0:
+            x_up = images.resize_image(0, x, w, h, upscaler_name=self.config.get("second_upscaler", "R-ESRGAN 4x+"))
+            decoded, sample = self._to_sample(x_up)
+        else:
+            decoded, sample = self._to_sample(x)
+
+        if x_latent is not None and 0.0 <= second_latent <= 1.0:
+            sample = (sample * (1.0 - second_latent)) + (x_latent * second_latent)
+
+        image_conditioning = self.p.img2img_image_conditioning(decoded, sample)
+
+        # RNG: optionally reuse seed/noise
+        if bool(self.config.get("reuse_seed_noise", False)) and self._saved_seeds is not None:
+            try:
+                self.p.seeds = list(self._saved_seeds)
+                self.p.subseeds = list(self._saved_subseeds) if self._saved_subseeds is not None else self.p.subseeds
+                self.p.subseed_strength = self._saved_subseed_strength if self._saved_subseed_strength is not None else self.p.subseed_strength
+                self.p.seed_resize_from_h = self._saved_seed_resize_from_h if self._saved_seed_resize_from_h is not None else self.p.seed_resize_from_h
+                self.p.seed_resize_from_w = self._saved_seed_resize_from_w if self._saved_seed_resize_from_w is not None else self.p.seed_resize_from_w
+            except Exception:
+                pass
+
+        self.p.rng = rng.ImageRNG(sample.shape[1:], self.p.seeds, subseeds=self.p.subseeds,
+                                  subseed_strength=self.p.subseed_strength,
+                                  seed_resize_from_h=self.p.seed_resize_from_h, seed_resize_from_w=self.p.seed_resize_from_w)
+
+        # Denoise config for second pass
+        steps = int(self.config.get("steps_second", int(self.config.get("steps", 20))))
+        if bool(self.config.get("cfg_second_pass_boost", True)):
+            self.p.cfg_scale = float(self.cfg) + float(self.config.get("cfg_second_pass_delta", 3.0))
+        else:
+            self.p.cfg_scale = float(self.cfg)
+        self.p.denoising_strength = self._compute_denoise("denoise_second")
+
+        # Noise: reuse tensor if shapes match, else fresh noise
+        if bool(self.config.get("reuse_seed_noise", False)) and self._first_noise is not None:
+            if tuple(sample.shape) == tuple(self._first_noise_shape or ()):
+                noise = self._first_noise.to(sample.device, dtype=sample.dtype)
+            else:
+                noise = torch.randn_like(sample)
+        else:
+            noise = torch.randn_like(sample)
+
+        def denoiser_override(n):
+            return K.sampling.get_sigmas_polyexponential(n, 0.01, 15, 0.5, devices.device)  # type: ignore
+
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+
+        # Per-pass sampler
+        sampler_second = self.config.get("sampler_second", self.config.get("sampler", "DPM++ 2M Karras"))
+        sampler = self._create_sampler(sampler_second)
+
+        samples = sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                         steps=steps, image_conditioning=image_conditioning).to(devices.dtype_vae)
+
+        devices.torch_gc()
+        decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        if math.isnan(decoded_sample.min() if hasattr(decoded_sample, "min") else 0):
+            devices.torch_gc()
+            samples = torch.clamp(samples, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_np = 255.0 * np.moveaxis(decoded_sample.to(torch.float32).cpu().numpy(), 0, 2)
+        out_img = Image.fromarray(x_np.astype(np.uint8))
+
+        # Post-FX: CLAHE -> Unsharp -> Color match
+        out_img = self._apply_clahe(out_img)
+        out_img = self._apply_unsharp(out_img)
+        if bool(self.config.get("match_colors_enabled", False)):
+            # match to original input
+            out_img = self._apply_match_colors(out_img, self.pp.image)
+
+        return out_img
+
+    def _enable_controlnet(self, image_np: np.ndarray):
+        if not getattr(self, "_cn_ext", None):
+            return
+        for unit in self._cn_units:
+            try:
+                if getattr(unit, "model", "None") != "None":
+                    if getattr(unit, "enabled", True):
+                        unit.guidance_start = float(self.config.get("start_control_at", 0.0))
+                    unit.processor_res = min(image_np.shape[0], image_np.shape[1])
+                    unit.enabled = True
+                    if getattr(unit, "image", None) is None:
+                        unit.image = image_np
+                self.p.width = image_np.shape[1]
+                self.p.height = image_np.shape[0]
+            except Exception:
+                continue
+        try:
+            self._cn_ext.update_cn_script_in_processing(self.p, self._cn_units)
+            for script in self.p.scripts.alwayson_scripts:
+                if script.title().lower() == "controlnet":
+                    script.controlnet_hack(self.p)
+        except Exception:
+            pass
+
+
+def parse_infotext(infotext, params):
+    try:
+        block = params.get("Custom Hires Fix")
+        if not block:
+            return
+        data = json.loads(block.translate(quote_swap)) if isinstance(block, str) else block
+        params["Custom Hires Fix"] = data
+        scale = data.get("scale", 0)
+        if isinstance(scale, str) and "x" in scale:
+            w, _, h = scale.partition("x")
+            data["ratio"] = 0.0
+            data["width"] = int(w)
+            data["height"] = int(h)
+        else:
+            try:
+                r = float(scale)
+            except Exception:
+                r = 0.0
+            data["ratio"] = r
+            data["width"] = int(data.get("width", 0) or 0)
+            data["height"] = int(data.get("height", 0) or 0)
+
+        # Defaults for new/legacy fields
+        if "steps_first" not in data:
+            data["steps_first"] = int(data.get("steps", 20))
+        if "steps_second" not in data:
+            data["steps_second"] = int(data.get("steps", 20))
+
+        # per-pass sampler/scheduler defaults from legacy single values
+        data.setdefault("sampler_first", data.get("sampler", ""))
+        data.setdefault("sampler_second", data.get("sampler", ""))
+        data.setdefault("scheduler_first", data.get("scheduler", "Use same scheduler"))
+        data.setdefault("scheduler_second", data.get("scheduler", "Use same scheduler"))
+
+        # CFG delta defaults
+        data.setdefault("cfg_second_pass_boost", True)
+        data.setdefault("cfg_second_pass_delta", 3.0)
+
+        # Flags defaults
+        data.setdefault("reuse_seed_noise", False)
+        data.setdefault("mp_target_enabled", False)
+        data.setdefault("mp_target", 2.0)
+        data.setdefault("cond_cache_enabled", True)
+        data.setdefault("cond_cache_max", 64)
+        data.setdefault("vae_tiling_enabled", False)
+        data.setdefault("seamless_tiling_enabled", False)
+        data.setdefault("tile_overlap", 12)
+        data.setdefault("lora_weight_first_factor", 1.0)
+        data.setdefault("lora_weight_second_factor", 1.0)
+        data.setdefault("match_colors_preset", "Off")
+        data.setdefault("match_colors_enabled", False)
+        data.setdefault("match_colors_strength", 0.5)
+        data.setdefault("postfx_preset", "Off")
+        data.setdefault("clahe_enabled", False)
+        data.setdefault("clahe_clip", 2.0)
+        data.setdefault("clahe_tile_grid", 8)
+        data.setdefault("unsharp_enabled", False)
+        data.setdefault("unsharp_radius", 1.5)
+        data.setdefault("unsharp_amount", 0.75)
+        data.setdefault("unsharp_threshold", 0)
+        data.setdefault("second_pass_prompt", "")
+        data.setdefault("second_pass_prompt_append", True)
+
+    except Exception:
+        pass
+
+# Register paste-params hook
+script_callbacks.on_infotext_pasted(parse_infotext)