Initial project structure and core files added (#1)

Add MagicNodes repository with documentation, licensing, assets, workflows, presets, and main Python modules for Easy/Hard nodes, CADE 2.5, ControlFusion, QSilk, and supporting utilities. Includes sample images, negative LoRA, Depth Anything v2 vendor code, and setup scripts for ComfyUI integration.

.gitattributes

@@ -1,3 +1,11 @@
+* text=auto
+
+# Track large model files with Git LFS
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt        filter=lfs diff=lfs merge=lfs -text
+*.pt          filter=lfs diff=lfs merge=lfs -text
+*.pth         filter=lfs diff=lfs merge=lfs -text
+*.bin         filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text

.github/CODEOWNERS

@@ -0,0 +1,9 @@
+# Code owners for MagicNodes
+# Docs: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+
+# Default owner for the whole repository
+* @1dZb1
+
+# (Optional)
+# /docs/ @1dZb1
+# /mod/  @1dZb1

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+github: 1dZb1
+buy_me_a_coffee: dzrobo
+custom:
+  - https://buymeacoffee.com/dzrobo
+  - https://github.com/sponsors/1dZb1

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,67 @@
+name: "Bug report"
+description: "Something is broken or not working as expected"
+title: "[Bug] <short summary>"
+labels: [bug]
+body:
+  - type: checkboxes
+    id: preflight
+    attributes:
+      label: Pre‑flight
+      description: Please confirm you checked these first
+      options:
+        - label: I searched existing issues and discussions
+          required: true
+        - label: I’m on the latest MagicNodes commit and preset files
+          required: false
+  - type: textarea
+    id: summary
+    attributes:
+      label: Summary
+      description: What happened? What did you expect instead?
+      placeholder: A clear and concise description of the issue
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: Steps to reproduce
+      description: Minimal steps / workflow to reproduce the problem
+      placeholder: |
+        1. Preset/step/config used
+        2. Node settings (seed/steps/cfg/denoise/sampler)
+        3. What you observed
+    validations:
+      required: true
+  - type: textarea
+    id: env
+    attributes:
+      label: Environment
+      description: OS/GPU/driver and versions
+      placeholder: |
+        OS: Windows 11 / Linux
+        GPU: RTX 4090 (driver 560.xx)
+        Python: 3.10.x  |  PyTorch: 2.8.0+cu129
+        ComfyUI: <commit/date>
+        MagicNodes: <commit>
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / Screenshots
+      description: Paste relevant logs, stack traces, or attach screenshots
+      render: shell
+    validations:
+      required: false
+  - type: dropdown
+    id: severity
+    attributes:
+      label: Impact
+      options:
+        - Crash/blocks generation
+        - Wrong output/quality regression
+        - UI/Docs glitch
+        - Minor inconvenience
+    validations:
+      required: false
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Q&A and ideas (Discussions)
+    url: https://github.com/1dZb1/MagicNodes/discussions
+    about: Ask questions and share ideas in Discussions
+  - name: Hugging Face page
+    url: https://huggingface.co/DD32/MagicNodes
+    about: Releases and mirrors on HF

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,39 @@
+name: "Feature request"
+description: "Request an enhancement or new capability"
+title: "[Feat] <short summary>"
+labels: [enhancement]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem / motivation
+      description: What use‑case does this solve? Why is it valuable?
+    validations:
+      required: true
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed solution
+      description: API/UI/UX draft, presets, examples
+      placeholder: Describe the change and how it would work
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+      description: Any workarounds or different approaches
+    validations:
+      required: false
+  - type: checkboxes
+    id: scope
+    attributes:
+      label: Scope
+      options:
+        - label: Easy nodes / presets
+        - label: Hard nodes / advanced params
+        - label: Docs / examples / workflows
+        - label: Performance / memory
+    validations:
+      required: false
+

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,20 @@
+name: "Question / Help"
+description: "Ask a question about usage, presets, or behavior"
+title: "[Q] <short summary>"
+labels: [question]
+body:
+  - type: textarea
+    id: question
+    attributes:
+      label: Your question
+      description: What do you want to understand or achieve?
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Context
+      description: Share your preset, node settings, or screenshot if helpful
+    validations:
+      required: false
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,28 @@
+<!--
+Thank you for your contribution to MagicNodes!
+Please provide a clear summary and the minimal context to review safely.
+-->
+
+Title: <short, action‑oriented summary>
+
+What
+- Briefly describe the change (user‑facing behavior, docs, presets, or internals).
+
+Why
+- What problem does it solve? Link issues/discussions if applicable.
+
+How (high level)
+- Outline the approach. Call out any trade‑offs.
+
+Test plan
+- Steps or screenshots proving it works (minimal workflow, seed/steps/cfg if relevant).
+
+Checklist
+- [ ] Builds/runs locally with default presets
+- [ ] Docs/README updated if behavior changed
+- [ ] No large binaries added (weights go to HF or Releases)
+- [ ] Passes lint/format (if configured)
+
+Notes for reviewers
+- Anything sensitive or risky to double‑check (paths, presets, defaults).
+

.github/workflows/hf-mirror.yml

@@ -0,0 +1,41 @@
+name: Mirror to Hugging Face
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: hf-mirror-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  mirror:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout (full history)
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          lfs: false
+
+      - name: Configure git identity
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Push to HF mirror
+        env:
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_REPO: MagicNodes
+        run: |
+          if [ -z "${HF_USERNAME}" ] || [ -z "${HF_TOKEN}" ]; then
+            echo "HF secrets are missing. Set HF_USERNAME and HF_TOKEN in repo secrets." >&2
+            exit 1
+          fi
+          git lfs install || true
+          git remote add hf "https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/${HF_USERNAME}/${HF_REPO}.git" 2>/dev/null || true
+          # Mirror current branch to HF main
+          git push --force --prune hf HEAD:main
+

.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+*.pyo
+
+# Virtual envs / tooling
+.venv/
+venv/
+.env
+.env.*
+.idea/
+.vscode/
+
+# OS junk
+.DS_Store
+Thumbs.db
+
+# Build/output/temp
+dist/
+build/
+out/
+*.log
+*.tmp
+temp/
+temp_patch.diff
+
+# NOTE: We intentionally keep model weights in repo via Git LFS.
+# If you prefer not to ship them, re-add ignores for models/** and weight extensions.
+
+# ComfyUI caches
+**/web/tmp/
+**/web/dist/
+
+# Node / front-end (if any submodules appear later)
+node_modules/

CITATION.cff

@@ -0,0 +1,35 @@
+cff-version: 1.2.0
+message: If you use CADE 2.5 / MG_SuperSimple, please cite our preprints (ZeResFDG and QSilk).
+title: "MagicNodes: CADE 2.5 (ZeResFDG and QSilk)"
+authors:
+  - family-names: Rychkovskiy
+    given-names: Denis
+    alias: DZRobo
+version: preprint
+date-released: 2025-10-11
+repository-code: https://github.com/1dZb1/MagicNodes
+url: https://huggingface.co/DD32/MagicNodes
+
+preferred-citation:
+  type: article
+  title: CADE 2.5: ZeResFDG - Frequency-Decoupled, Rescaled and Zero-Projected Guidance for SD/SDXL Latent Diffusion Models
+  authors:
+    - family-names: Rychkovskiy
+      given-names: Denis
+  year: 2025
+  journal: arXiv
+  identifiers:
+    - type: url
+      value: https://arxiv.org/abs/2510.12954
+
+references:
+  - type: article
+    title: QSilk: Micrograin Stabilization and Adaptive Quantile Clipping for Detail-Friendly Latent Diffusion
+    authors:
+      - family-names: Rychkovskiy
+        given-names: Denis
+    year: 2025
+    journal: arXiv
+    identifiers:
+      - type: url
+        value: https://arxiv.org/abs/2510.15761

CREDITS.md

@@ -0,0 +1,14 @@
+# Credits and Attributions
+
+This project includes adapted code and ideas from:
+
+- KJ-Nodes — ComfyUI-KJNodes (GPL-3.0) by KJ (kijai)
+  Repository: https://github.com/kijai/ComfyUI-KJNodes
+  Usage: SageAttention integration and attention override approach in mod/mg_sagpu_attention.py.
+
+- ComfyUI (GPL-3.0+)
+  Source idea: early beta node "Mahiro is so cute that she deserves a better guidance function!! (｡・ω・｡)"
+  Repository: https://github.com/comfyanonymous/ComfyUI
+  Usage: inspiration for directional post‑mix ("Muse Blend"); implementation rewritten and expanded in MagicNodes.
+
+Licensing note: Under GPLv3 §13, the combined work is distributed under AGPL-3.0-or-later. See LICENSE.

LICENSE

@@ -0,0 +1,19 @@
+MagicNodes
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+This project is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+The full text of the GNU Affero General Public License v3.0 is available at:
+https://www.gnu.org/licenses/agpl-3.0.txt
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see https://www.gnu.org/licenses/.
+
+Copyright (C) 2025 MagicNodes contributors
+
+Third-party notices: Portions of this project are derived from third-party code.
+See CREDITS.md for attribution and links to original repositories.
+

NOTICE

@@ -0,0 +1,6 @@
+Attribution (kind request)
+
+Includes CADE 2.5 (ZeResFDG) by Denis Rychkovskiy (“DZRobo”).
+
+If you use this work or parts of it, please consider preserving this notice
+in your README/About or documentation.

README.md

@@ -0,0 +1,322 @@
+# MagicNodes — ComfyUI Render Pipeline (SD/SDXL)
+Simple start. Expert-grade results. Reliable detail.
+[![arXiv](https://img.shields.io/badge/arXiv-2510.12954-B31B1B.svg)](https://arxiv.org/abs/2510.12954) / [![arXiv](https://img.shields.io/badge/arXiv-2510.15761-B31B1B.svg)](https://arxiv.org/pdf/2510.15761)
+
+<table>
+  <tr>
+    <td width="140" valign="top">
+      <img src="assets/MagicNodes.png" alt="MagicNodes" width="120" />
+    </td>
+    <td>
+TL;DR: MagicNodes, it's a plug-and-play multi-pass "render-machine" for SD/SDXL models. Simple one-node start, expert-grade results. Core is ZeResFDG (Frequency-Decoupled + Rescale + Zero-Projection)  and the always-on QSilk Micrograin Stabilizer, complemented by practical stabilizers (NAG, local masks, EPS, Muse Blend, Polish). Ships with a four-pass preset for robust, clean, and highly detailed outputs.
+
+Our pipeline runs through several purposeful passes: early steps assemble global shapes, mid steps refine important regions, and late steps polish without overcooking the texture. We gently stabilize the amplitudes of the "image’s internal draft" (latent) and adapt the allowed value range per region: where the model is confident we give more freedom, and where it’s uncertain we act more conservatively. The result is clean gradients, crisp edges, and photographic detail even at very high resolutions and, as a side effect on SDXL models, text becomes noticeably more stable and legible.
+  </tr>
+</table>
+
+Please note that the SDXL architecture itself has limitations and the result depends on the success of the seed, the purity of your prompt and the quality of your model+LoRA.
+
+Draw
+<div align="center">
+  <img src="assets/Anime1.jpg" alt="Anime full" width="39%" />
+  <img src="assets/Anime1_crop.jpg" alt="Anime crop" width="39%" />
+  
+</div>
+
+Photo Portrait
+<div align="center">
+  <img src="assets/PhotoPortrait1.jpg" alt="Photo A" width="39%" />
+  <img src="assets/PhotoPortrait1_crop1.jpg" alt="Photo B" width="39%" />
+</div>
+<div align="center">
+  <img src="assets/PhotoPortrait1_crop2.jpg" alt="Photo C" width="39%" />
+  <img src="assets/PhotoPortrait1_crop3.jpg" alt="Photo D" width="39%" />
+</div>
+
+Photo Cup
+<div align="center">
+  <img src="assets/PhotoCup1.jpg" alt="Photo A" width="39%" />
+  <img src="assets/PhotoCup1_crop.jpg" alt="Photo B" width="39%" />
+</div>
+
+Photo Dog
+<div align="center">
+  <img src="assets/Dog1_crop_ours_CADE25_QSilk.jpg" alt="Photo A" width="39%" />
+  <img src="assets/Dog1_ours_CADE25_QSilk.jpg" alt="Photo B" width="39%" />
+</div>
+
+---
+
+## Features
+- ZeResFDG: LF/HF split, energy rescale, and zero-projection (stable early, sharp late)
+- NAG (Normalized Attention Guidance): small attention variance normalization (positive branch)
+- Local spatial gating: optional CLIPSeg masks for faces/hands/pose
+- EPS scale: small early-step exposure bias
+- QSilk Micrograin Stabilizer: gently smooths rare spikes and lets natural micro-texture (skin, fabric, tiny hairs) show through — without halos or grid patterns. Always on, zero knobs, near‑zero cost.
+- Adaptive Quantile Clip (AQClip): softly adapts the allowed range per region. Confident areas keep more texture; uncertain ones get cleaner denoising. Tile‑based with seamless blending (no seams). Optional Attn mode uses attention confidence for an even smarter balance.
+- MGHybrid scheduler: hybrid Karras/Beta sigma stack with smooth tail blending and tiny schedule jitter (ZeSmart-inspired) for more stable, detail-friendly denoising; used by CADE and SuperSimple by default
+- Seed Latent (MG_SeedLatent): fast, deterministic latent initializer aligned to VAE stride; supports pure-noise starts or image-mixed starts (encode + noise) to gently bias content; batch-ready and resolution-agnostic, pairs well with SuperSimple recommended latent sizes for reproducible pipelines
+- Muse Blend and Polish: directional post-mix and final low-frequency-preserving clean-up
+- SmartSeed (CADE Easy and SuperSimple): set `seed = 0` to auto-pick a good seed from a tiny low-step probe. Uses a low-discrepancy sweep, avoids speckles/overexposure, and, if available, leverages CLIP-Vision (with `reference_image`) and CLIPSeg focus text to favor semantically aligned candidates. Logs `Smart_seed_random: Start/End`. 
+<b>I highly recommend working with SmartSeed.</b>
+- CADE2.5 pipeline does not just upscale the image, it iterates and adds small details, doing it carefully, at every stage.
+
+## Hardware Requirements
+- GPU VRAM: ~10-28 GB (free memory) for the default presets (start latent ~ 672x944 -> final ~ 3688x5192 across 4 steps). 15-25 GB is recommended; 32 GB is comfortable for large prompts/batches.
+- System RAM: ~12-20 GB during generation (depends on start latent and whether Depth/ControlFusion are enabled). 16+ GB recommended.
+- Notes
+  - Lowering the starting latent (e.g., 512x768) reduces both VRAM and RAM.
+  - Disabling hi-res depth/edges (ControlFusion) reduces peaks. (not recommended!)
+  - Depth weights add a bit of RAM on load; models live under `depth-anything/`. 
+
+
+## Install (ComfyUI 0.3.60, tested on this version)
+Preparing:
+I recomend update pytorch version: 2.8.0+cu129.
+1. PyTorch install: `pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu129`
+2. CUDA manual download and install: https://developer.nvidia.com/cuda-12-9-0-download-archive?target_os=Windows&target_arch=x86_64&target_version=11&target_type=exe_local
+3. Install `SageAttention 2.2.0`, manualy `https://github.com/thu-ml/SageAttention` or use script `scripts/check_sageattention.bat`. The installation takes a few minutes, wait for the installation to finish.
+
+Next:
+1. Clone or download this repo into `ComfyUI/custom_nodes/`
+2. Install helpers: `pip install -r requirements.txt`
+3. Take my negative LoRA `models/LoRA/mg_7lambda_negative.safetensors` and place the file in ComfyUI, to `ComfyUI/models/loras`
+4. download model `depth_anything_v2_vitl.pth` https://huggingface.co/depth-anything/Depth-Anything-V2-Large/tree/main and place inside in to `depth-anything/` folder.
+5. Workflows
+Folder `workflows/` contains ready-to-use graphs:
+- `mg_SuperSimple-Workflow.json` — one-node pipeline (2/3/4 steps) with presets
+- `mg_Easy-Workflow.json` — the same logic built from individual Easy nodes
+You can save this workflow to ComfyUI `ComfyUI\user\default\workflows`
+6. Restart ComfyUI. Nodes appear under the "MagicNodes" categories.
+
+💥 I strongly recommend use `mg_Easy-Workflow` workflow + default settings + your model and my negative LoRA `mg_7lambda_negative.safetensors`, for best result.
+
+
+## 🚀 "One-Node" Quickstart (MG_SuperSimple)
+Start with `MG_SuperSimple` for the easiest path:
+1. Drop `MG_SuperSimple` into the graph
+2. Connect `model / positive / negative / vae / latent` and a `Load ControlNet Model` module
+3. Choose `step_count` (2/3/4) and Run
+
+or load `mg_SuperSimple-Workflow` in panel ComfyUI
+
+Notes:
+- When "Custom" is off, presets fully drive parameters
+- When "Custom" is on, the visible CADE controls override the Step presets across all steps; Step 1 still enforces `denoise=1.0`
+- CLIP Vision (if connected) is applied from Step 2 onward; if no reference image is provided, SuperSimple uses the previous step image as reference
+
+## ❗Tips
+(!) There are almost always artifacts in the first step, don't pay attention to them, they will be removed in the next steps. Keep your prompt clean and logical, don't duplicate details and be careful with symbols.
+
+0) `MG_SuperSimple-Workflow` is a bit less flexible than `MG_Easy-Workflow`, but extremely simple to use. If you just want a stable, interesting result, start with SuperSimple.
+
+1) Recommended negative LoRA: `mg_7lambda_negative.safetensors` with `strength_model = -1.0`, `strength_clip = 0.2`. Place LoRA files under `ComfyUI/models/loras` so they appear in the LoRA selector.
+
+2) Download a CLIP Vision model and place it under `ComfyUI/models/clip_vision` (e.g., https://huggingface.co/openai/clip-vit-large-patch14; heavy alternative: https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K). SuperSimple/CADE will use it for reference-based polish.
+
+3) Samplers: i recomend use `ddim` for many cases (Draw and Realism style). Scheduler: use `MGHybrid` in this pipeline.
+
+4) Denoise: higher -> more expressive and vivid; you can go up to 1.0. The same applies to CFG: higher -> more expressive but may introduce artifacts. Suggested CFG range: ~4.5–8.5.
+
+5) If you see unwanted artifacts on the final (4th) step, slightly lower denoise to ~0.5–0.6 or simply change the seed.
+
+6) You can get interesting results by repeating steps (in Easy/Hard workflows), e.g., `1 -> 2 -> 3 -> 3`.  Just experiment with it!
+
+7) Recommended starting latent close to ~672x944 (other aspect ratios are fine). With that, step 4 produces ~3688x5192. Larger starting sizes are OK if the model and your hardware allow.
+
+8) Unlucky seeds happen — just try another. (We may later add stabilization to this process.)
+
+9) Rarely, step 3 can show a strange grid artifact (in both Easy and Hard workflows). If this happens, try changing CFG or seed. Root cause still under investigation.
+
+10) Results depend on checkpoint/LoRA quality. The pipeline “squeezes” everything SDXL and your model can deliver, so prefer high‑quality checkpoints and non‑overtrained LoRAs.
+
+11) Avoid using more than 3 LoRAs at once, and keep only one “lead” LoRA (one you trust is not overtrained). Too many/strong LoRAs can spoil results.
+
+12) Try connecting reference images in either workflow — you can get unusual and interesting outcomes.
+
+13) Very often, the image in `step 3 is of very good quality`, but it usually lacks sharpness. But if you have a `weak system`, you can `limit yourself to 3 steps`.
+
+14) SmartSeed (auto seed pick): set `seed = 0` in Easy or SuperSimple. The node will sample several candidate seeds and do a quick low‑step probe to choose a balanced one. You’ll see logs `Smart_seed_random: Start` and `Smart_seed_random: End. Seed is: <number>`. Use any non‑zero seed for fully deterministic runs.
+
+15) The 4th step sometimes saves the image for a long time, just wait for the end of the process, it depends on the initial resolution you set.
+
+
+
+## Repository Layout
+```
+MagicNodes/
+├─ README.md
+├─ LICENSE                      # AGPL-3.0-or-later
+├─ assets/
+├─ docs/
+│  ├─ EasyNodes.md
+│  ├─ HardNodes.md
+│  └─ hard/
+│     ├─ CADE25.md
+│     ├─ ControlFusion.md
+│     ├─ UpscaleModule.md
+│     ├─ IDS.md
+│     └─ ZeSmartSampler.md
+│ 
+├─ mod/
+│  ├─ easy/
+│  │  ├─ mg_cade25_easy.py
+│  │  ├─ mg_controlfusion_easy.py
+│  │  └─ mg_supersimple_easy.py
+│  │  └─ preset_loader.py
+│  └─ hard/
+│     ├─ mg_cade25.py
+│     ├─ mg_controlfusion.py
+│     ├─ mg_tde2.py
+│     ├─ mg_upscale_module.py
+│     ├─ mg_ids.py
+│     └─ mg_zesmart_sampler_v1_1.py
+│ 
+├─ pressets/
+│  ├─ mg_cade25.cfg
+│  └─ mg_controlfusion.cfg
+│ 
+├─ scripts/
+│  ├─ check_sageattention.bat
+│  └─ check_sageattention.ps1
+│ 
+├─ depth-anything/              # place Depth Anything v2 weights (.pth), e.g., depth_anything_v2_vitl.pth
+│  └─depth_anything_v2_vitl.pth
+│ 
+├─ vendor/
+│  └─ depth_anything_v2/        # vendored Depth Anything v2 code (Apache-2.0)
+│ 
+├─ models/
+│  └─ LoRA/
+│     └─ mg_7lambda_negative.safetensors
+│ 
+├─ workflows/ 
+│  ├─ mg_SuperSimple-Workflow.json
+│  └─ mg_Easy-Workflow.json           
+|  
+└─ requirements.txt
+```
+
+Models folder
+- The repo includes a sample negative LoRA at `models/LoRA/mg_7lambda_negative.safetensors`.
+- To use it in ComfyUI, copy or move the file to `ComfyUI/models/loras` — it will then appear in LoRA selectors.
+- Keeping a copy under `models/` here is fine as a backup.
+
+Depth models (Depth Anything v2)
+- Place DA v2 weights (`.pth`) in `depth-anything/`. Recommended: `depth_anything_v2_vitl.pth` (ViT-L). Supported names include:
+  `depth_anything_v2_vits.pth`, `depth_anything_v2_vitb.pth`, `depth_anything_v2_vitl.pth`, `depth_anything_v2_vitg.pth`,
+  and the metric variants `depth_anything_v2_metric_vkitti_vitl.pth`, `depth_anything_v2_metric_hypersim_vitl.pth`.
+- ControlFusion auto-detects the correct config from the filename and uses this path by default. You can override via the
+  `depth_model_path` parameter (preset) if needed.
+- If no weights are found, ControlFusion falls back gracefully (luminance pseudo-depth), but results are better with DA v2.
+- Where to get weights: see the official Depth Anything v2 repository (https://github.com/DepthAnything/Depth-Anything-V2)
+  and its Hugging Face models page (https://huggingface.co/Depth-Anything) for pre-trained `.pth` files.
+
+
+## Documentation
+- Easy nodes overview and `MG_SuperSimple`: `docs/EasyNodes.md`
+- Hard nodes documentation index: `docs/HardNodes.md`
+
+## Control Fusion (mg_controlfusion.py, mg_controlfusion_easy.py,)
+- Builds depth + edge masks with preserved aspect ratio; hires-friendly mask mode
+- Key surface knobs: `edge_alpha`, `edge_smooth`, `edge_width`, `edge_single_line`/`edge_single_strength`, `edge_depth_gate`/`edge_depth_gamma`
+- Preview can optionally reflect ControlNet strength via `preview_show_strength` and `preview_strength_branch`
+
+## CADE 2.5 (mg_cade25.py, mg_cade25_easy.py)
+- Deterministic preflight: CLIPSeg pinned to CPU; preview mask reset; noise tied to `iter_seed`
+- Encode/Decode: stride-aligned, with larger overlap for >2K to avoid artifacts
+- Polish mode (final hi-res refinement):
+  - `polish_enable`, `polish_keep_low` (global form from reference), `polish_edge_lock`, `polish_sigma`
+  - Smooth start via `polish_start_after` and `polish_keep_low_ramp`
+- `eps_scale` supported for gentle exposure shaping
+
+## Depth Anything v2 (vendor)
+- Lives under `vendor/depth_anything_v2`; Apache-2.0 license
+
+## MG_ZeSmartSampler (Experimental)
+- Custom sampler that builds hybrid sigma schedules (Karras/Beta blend) with tail smoothing
+- Inputs/Outputs match KSampler: `MODEL/SEED/STEPS/CFG/base_sampler/schedule/CONDITIONING/LATENT` -> `LATENT`
+- Key params: `hybrid_mix`, `jitter_sigma`, `tail_smooth`, optional PC2-like shaping (`smart_strength`, `target_error`, `curv_sensitivity`)
+
+## Seed Latent (mg_seed_latent.py)
+- Purpose: quick LATENT initializer aligned to VAE stride (4xC, H/8, W/8). Can start from pure noise or mix an input image encoding with noise to gently bias content.
+- Inputs
+  - `width`, `height`, `batch_size`
+  - `sigma` (noise amplitude) and `bias` (additive offset)
+  - Optional `vae` and `image` when `mix_image` is enabled
+- Output: `LATENT` dict `{ "samples": tensor }` ready to feed into CADE/SuperSimple.
+- Usage notes
+  - Keep dimensions multiples of 8; recommended starting sizes around ~672x944 (other aspect ratios work). With SuperSimple’s default scale, step 4 lands near ~3688x5192.
+  - `mix_image=True` encodes the provided image via VAE and adds noise: a soft way to keep global structure while allowing refinement downstream.
+  - For run-to-run comparability, hold your sampler seed fixed (in SuperSimple/CADE). SeedLatent itself does not expose a seed; variation is primarily controlled by the sampler seed.
+  - Batch friendly: `batch_size>1` produces independent latents of the chosen size.
+
+## Dependencies (Why These Packages)
+- transformers — used by CADE for CLIPSeg (CIDAS/clipseg-rd64-refined) to build text‑driven masks (e.g., face/hands). If missing, CLIPSeg is disabled gracefully.
+ 
+- opencv-contrib-python — ControlFusion edge stack (Pyramid Canny, thinning via ximgproc), morphological ops, light smoothing.
+- Pillow — image I/O and small conversions in preview/CLIPSeg pipelines.
+- scipy — preferred Gaussian filtering path for IDS (quality). If not installed, IDS falls back to a PyTorch implementation.
+- sageattention — accelerated attention kernels (auto-picks a kernel per GPU arch); CADE/attention patch falls back to stock attention if not present.
+
+Optional extras
+- controlnet-aux — alternative loader for Depth Anything v2 if you don’t use the vendored implementation (not required by default).
+  
+
+## Preprint
+- CADE 2.5 - ZeResFDG
+- PDF: https://arxiv.org/pdf/2510.12954.pdf
+- arXiv: https://arxiv.org/abs/2510.12954
+
+- CADE 2.5 - QSilk
+- PDF: https://arxiv.org/pdf/2510.15761
+- arXiv: https://arxiv.org/abs/2510.15761
+
+
+### How to Cite
+```
+@misc{rychkovskiy2025cade25zeresfdg,
+      title={CADE 2.5 - ZeResFDG: Frequency-Decoupled, Rescaled and Zero-Projected Guidance for SD/SDXL Latent Diffusion Models}, 
+      author={Denis Rychkovskiy},
+      year={2025},
+      eprint={2510.12954},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2510.12954}, 
+}
+```
+```
+@misc{rychkovskiy2025qsilkmicrograinstabilizationadaptive,
+      title={QSilk: Micrograin Stabilization and Adaptive Quantile Clipping for Detail-Friendly Latent Diffusion}, 
+      author={Denis Rychkovskiy},
+      year={2025},
+      eprint={2510.15761},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2510.15761}, 
+}
+```
+
+## Attribution (kind request)
+If you use this work or parts of it, please consider adding the following credit in your README/About/credits: "Includes CADE 2.5 (ZeResFDG, QSilk) by Denis Rychkovskiy (“DZRobo”)"
+
+
+## License and Credits
+- License: AGPL-3.0-or-later (see `LICENSE`)
+
+
+## Support
+If this project saved you time, you can leave a tip:
+- GitHub Sponsors: https://github.com/sponsors/1dZb1
+- Bymeacoffee: https://buymeacoffee.com/dzrobo
+
+
+
+
+
+
+
+
+
+
+

__init__.py

@@ -0,0 +1,97 @@
+import os, sys, importlib.util
+
+# Normalize package name so relative imports work even if loaded by absolute path
+if __name__ != 'MagicNodes':
+    sys.modules['MagicNodes'] = sys.modules[__name__]
+    __package__ = 'MagicNodes'
+    # Precreate subpackage alias MagicNodes.mod
+    _mod_pkg_name = 'MagicNodes.mod'
+    _mod_pkg_dir = os.path.join(os.path.dirname(__file__), 'mod')
+    _mod_pkg_file = os.path.join(_mod_pkg_dir, '__init__.py')
+    if _mod_pkg_name not in sys.modules and os.path.isfile(_mod_pkg_file):
+        _spec = importlib.util.spec_from_file_location(
+            _mod_pkg_name, _mod_pkg_file, submodule_search_locations=[_mod_pkg_dir]
+        )
+        _mod = importlib.util.module_from_spec(_spec)
+        sys.modules[_mod_pkg_name] = _mod
+        assert _spec.loader is not None
+        _spec.loader.exec_module(_mod)
+
+# Imports of active nodes
+from .mod.mg_combinode import MagicNodesCombiNode
+from .mod.hard.mg_upscale_module import MagicUpscaleModule
+from .mod.hard.mg_adaptive import AdaptiveSamplerHelper
+from .mod.hard.mg_cade25 import ComfyAdaptiveDetailEnhancer25
+from .mod.hard.mg_ids import IntelligentDetailStabilizer
+from .mod.mg_seed_latent import MagicSeedLatent
+from .mod.mg_sagpu_attention import PatchSageAttention
+from .mod.hard.mg_controlfusion import MG_ControlFusion
+from .mod.hard.mg_zesmart_sampler_v1_1 import MG_ZeSmartSampler
+from .mod.easy.mg_cade25_easy import CADEEasyUI as ComfyAdaptiveDetailEnhancer25_Easy
+from .mod.easy.mg_controlfusion_easy import MG_ControlFusionEasyUI as MG_ControlFusion_Easy
+from .mod.easy.mg_supersimple_easy import MG_SuperSimple
+
+# Place Easy/Hard variants under dedicated UI categories
+try:
+    ComfyAdaptiveDetailEnhancer25_Easy.CATEGORY = "MagicNodes/Easy"
+except Exception:
+    pass
+try:
+    MG_ControlFusion_Easy.CATEGORY = "MagicNodes/Easy"
+except Exception:
+    pass
+try:
+    MG_SuperSimple.CATEGORY = "MagicNodes/Easy"
+except Exception:
+    pass
+try:
+    ComfyAdaptiveDetailEnhancer25.CATEGORY = "MagicNodes/Hard"
+    IntelligentDetailStabilizer.CATEGORY = "MagicNodes/Hard"
+    MagicUpscaleModule.CATEGORY = "MagicNodes/Hard"
+    AdaptiveSamplerHelper.CATEGORY = "MagicNodes/Hard"
+    PatchSageAttention.CATEGORY = "MagicNodes"
+    MG_ControlFusion.CATEGORY = "MagicNodes/Hard"
+    MG_ZeSmartSampler.CATEGORY = "MagicNodes/Hard"
+except Exception:
+    pass
+
+NODE_CLASS_MAPPINGS = {
+    "MagicNodesCombiNode": MagicNodesCombiNode,
+    "MagicSeedLatent": MagicSeedLatent,
+    "PatchSageAttention": PatchSageAttention,
+    "MagicUpscaleModule": MagicUpscaleModule,
+    "ComfyAdaptiveDetailEnhancer25": ComfyAdaptiveDetailEnhancer25,
+    "IntelligentDetailStabilizer": IntelligentDetailStabilizer,
+    "MG_ControlFusion": MG_ControlFusion,
+    "MG_ZeSmartSampler": MG_ZeSmartSampler,
+    # Easy variants (limited-surface controls)
+    "ComfyAdaptiveDetailEnhancer25_Easy": ComfyAdaptiveDetailEnhancer25_Easy,
+    "MG_ControlFusion_Easy": MG_ControlFusion_Easy,
+    "MG_SuperSimple": MG_SuperSimple,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MagicNodesCombiNode": "MG_CombiNode",
+    "MagicSeedLatent": "MG_SeedLatent",
+    # TDE removed from this build
+    "PatchSageAttention": "MG_AccelAttention",
+    "ComfyAdaptiveDetailEnhancer25": "MG_CADE 2.5",
+    "MG_ControlFusion": "MG_ControlFusion",
+    "MG_ZeSmartSampler": "MG_ZeSmartSampler",
+    "IntelligentDetailStabilizer": "MG_IDS",
+    "MagicUpscaleModule": "MG_UpscaleModule",
+    # Easy variants (grouped under MagicNodes/Easy)
+    "ComfyAdaptiveDetailEnhancer25_Easy": "MG_CADE 2.5 (Easy)",
+    "MG_ControlFusion_Easy": "MG_ControlFusion (Easy)",
+    "MG_SuperSimple": "MG_SuperSimple",
+}
+
+__all__ = [
+    'NODE_CLASS_MAPPINGS',
+    'NODE_DISPLAY_NAME_MAPPINGS',
+]
+
+
+
+
+

docs/EasyNodes.md

@@ -0,0 +1,54 @@
+# Easy Nodes and MG_SuperSimple
+
+MagicNodes provides simplified “Easy” variants that expose only high‑value controls while relying on preset files for the rest. These are grouped under the UI category `MagicNodes/Easy`.
+
+- Presets live in `pressets/mg_cade25.cfg` and `pressets/mg_controlfusion.cfg` with INI‑like sections `Step 1..4` and simple `key: value` pairs. The token `$(ROOT)` is supported in paths and is substituted at load time.
+- Loader: `mod/easy/preset_loader.py` caches by mtime and does light type parsing.
+- The Step+Custom scheme keeps UI and presets in sync: choose a Step to load defaults, then optionally toggle Custom to override only the visible controls, leaving hidden parameters from the Step preset intact.
+
+## MG_SuperSimple (Easy)
+
+Single node that reproduces the 2/3/4‑step CADE+ControlFusion pipeline with minimal surface.
+
+Category: `MagicNodes/Easy`
+
+Inputs
+- `model` (MODEL)
+- `positive` (CONDITIONING), `negative` (CONDITIONING)
+- `vae` (VAE)
+- `latent` (LATENT)
+- `control_net` (CONTROL_NET) — required by ControlFusion
+- `reference_image` (IMAGE, optional) — forwarded to CADE
+- `clip_vision` (CLIP_VISION, optional) — forwarded to CADE
+
+Controls
+- `step_count` int (1..4): how many steps to run
+- `custom` toggle: when On, the visible CADE controls below override the Step presets across all steps; when Off, all CADE values come from presets
+- `seed` int with `control_after_generate`
+- `steps` int (default 25) — applies to steps 2..4
+- `cfg` float (default 4.5)
+- `denoise` float (default 0.65, clamped 0.45..0.9) — applies to steps 2..4
+- `sampler_name` (default `ddim`)
+- `scheduler` (default `MGHybrid`)
+- `clipseg_text` string (default `hand, feet, face`)
+
+Behavior
+- Step 1 runs CADE with `Step 1` preset and forces `denoise=1.0` (single exception to the override rule). All other visible fields follow the Step+Custom logic described above.
+- For steps 2..N: ControlFusion (with `Step N` preset) updates `positive/negative` based on the current image, then CADE (with `Step N` preset) refines the latent/image.
+- Initial `positive/negative` come from the node inputs; subsequent steps use the latest CF outputs. `latent` is always taken from the previous CADE.
+- When `custom` is Off, UI values are ignored entirely; presets define all CADE parameters.
+- ControlFusion inside this node always relies on presets (no additional CF UI here) to keep the surface minimal.
+
+Outputs
+- `(LATENT, IMAGE)` from the final executed step (e.g., step 2 if `step_count=2`). No preview outputs.
+
+Quickstart
+1) Drop `MG_SuperSimple` into your graph under `MagicNodes/Easy`.
+2) Connect `model/positive/negative/vae/latent`, and a `control_net` module; optionally connect `reference_image` and `clip_vision`.
+3) Choose `step_count` (2/3/4). Leave `custom` Off to use pure presets, or enable it to apply your `seed/steps/cfg/denoise/sampler/scheduler/clipseg_text` across all steps (with Step 1 `denoise=1.0`).
+4) Run. The node returns the final `(LATENT, IMAGE)` for the chosen depth.
+
+Notes
+- Presets are read from `pressets/mg_cade25.cfg` and `pressets/mg_controlfusion.cfg`. Keep them in UTF‑8 and prefer `$(ROOT)` over absolute paths.
+- `seed` is shared across all steps for determinism; if per‑step offsets are desired later, this can be added as an option without breaking current behavior.
+

docs/HardNodes.md

@@ -0,0 +1,11 @@
+# Hard Nodes (Overview)
+
+This folder documents the advanced (Hard) variants in MagicNodes. These nodes expose the full surface of controls and are intended for expert tuning and experimentation. Easy variants cover most use‑cases with presets; Hard variants reveal the rest.
+
+Available docs
+- CADE 2.5: see `docs/hard/CADE25.md`
+- ControlFusion: see `docs/hard/ControlFusion.md`
+- Upscale Module: see `docs/hard/UpscaleModule.md`
+- Intelligent Detail Stabilizer (IDS): see `docs/hard/IDS.md`
+- ZeSmart Sampler: see `docs/hard/ZeSmartSampler.md`
+

docs/hard/CADE25.md

@@ -0,0 +1,72 @@
+# CADE 2.5 (ComfyAdaptiveDetailEnhancer25)
+
+CADE 2.5 is a refined adaptive enhancer with a single clean iteration loop, optional reference‑driven polishing, and flexible sampler scheduling. It can run standalone or as part of multi‑step pipelines (e.g., with ControlFusion masks in between passes).
+
+This document describes the Hard variant — the full‑surface node that exposes advanced controls. For a minimal, preset‑driven experience, use the Easy variant or the `MG_SuperSimple` orchestrator.
+
+## Overview
+- Iterative latent refinement with configurable steps/CFG/denoise
+- Optional guidance override (Rescale/CFGZero‑style, FDG/NAG ideas, epsilon scaling)
+- Hybrid schedule path (`MGHybrid`) that builds ZeSmart‑style sigma stacks
+- Local spatial guidance via CLIPSeg prompts
+- Reference polishing with CLIP‑Vision (preserves low‑frequency structure)
+- Optional upscaling mid‑run, detail stabilization, and gentle sharpening
+- Determinism helpers: CLIPSeg pinned to CPU, mask state cleared per run
+
+## Inputs
+- `model` (MODEL)
+- `positive` (CONDITIONING), `negative` (CONDITIONING)
+- `vae` (VAE)
+- `latent` (LATENT)
+- `reference_image` (IMAGE, optional)
+- `clip_vision` (CLIP_VISION, optional)
+
+## Outputs
+- `LATENT`: refined latent
+- `IMAGE`: decoded image after the last internal iteration
+- `mask_preview` (IMAGE): last fused mask preview (RGB 0..1)
+- Internal values like effective `steps/cfg/denoise` are tracked across the loop (the Easy wrapper surfaces them if needed).
+
+## Core Controls (essentials)
+- `seed` (with control_after_generate)
+- `steps`, `cfg`, `denoise`
+- `sampler_name` (e.g., `ddim`)
+- `scheduler` (`MGHybrid` recommended for smooth tails)
+
+Typical starting points
+- General: steps≈25, cfg≈7.0, denoise≈0.7, sampler=`euler_ancestral`, scheduler=`MGHybrid`
+- As the first pass of a multi‑step pipeline: denoise=1.0 (full rewrite pass)
+
+## MGHybrid schedule
+When `scheduler = MGHybrid`, CADE builds a hybrid sigma schedule compatible with the internal KSampler path. It follows ZeSmart principles (hybrid mix and smooth tail), then calls a custom sampler entry — falling back to `nodes.common_ksampler` if anything goes wrong. The behavior remains deterministic under fixed `seed/steps/cfg/denoise`.
+
+## Local guidance (CLIPSeg)
+- CLIPSeg prompts (comma‑separated) produce a soft mask that can attenuate denoise/CFG.
+- CLIPSeg inference is pinned to CPU by default for reproducibility.
+
+## Reference polish (CLIP‑Vision)
+Provide `reference_image` and `clip_vision` to preserve global form while refining details. CADE encodes the current and reference images and reduces denoise/CFG when they diverge; in polish mode it also mixes low frequencies from the reference using a blur‑based split.
+
+## Advanced features (high‑level)
+- Guidance override wrapper (rescale curves, momentum, perpendicular dampers)
+- FDG/ZeRes‑inspired options with adaptive thresholds
+- Mid‑run upscale support via `MagicUpscaleModule` with post‑adjusted CFG/denoise
+- Post passes: `IntelligentDetailStabilizer`, optional mild sharpen
+
+## Related
+- QSilk (micrograin stabilizer + AQClip): a lightweight latent‑space regularizer that suppresses rare activation tails while preserving micro‑texture. Works plug‑and‑play inside CADE 2.5 and synergizes with ZeResFDG by allowing slightly higher effective CFG without speckle. See preprint draft in `Arxiv_QSilk/` (source: [Arxiv_QSilk/main_qsilk.tex](../../Arxiv_QSilk/main_qsilk.tex)). Replace with arXiv link when available.
+
+## Tips
+- Keep `vae` consistent across passes; CADE re‑encodes when scale changes.
+- For multi‑step flows (e.g., with ControlFusion), feed the current decoded `IMAGE` into CF, update `positive/negative`, then run CADE again with the latest `LATENT`.
+- If you rely on presets, consider the Easy wrapper or `MG_SuperSimple` to avoid UI/preset drift.
+
+## Quickstart (Hard)
+1) Connect `MODEL / VAE / CONDITIONING / LATENT`.
+2) Set `seed`, `steps≈25`, `cfg≈7.0`, `denoise≈0.7`, `sampler=euler_ancestral`, `scheduler=MGHybrid`.
+3) (Optional) Add `reference_image` and `clip_vision`, and a CLIPSeg prompt.
+4) Run and fine‑tune denoise/CFG first; only then adjust sampler/schedule.
+
+Notes
+- The node clears internal masks and patches at the end of a run even on errors.
+- Some experimental toggles are intentionally conservative in default configs to avoid destabilizing results.

docs/hard/ControlFusion.md

@@ -0,0 +1,70 @@
+# ControlFusion (Hard)
+
+Builds a fused control mask from Depth and Pyramid Canny Edges, then injects it into ControlNet for both positive and negative conditionings. Designed to be resolution‑aware (keeps aspect), with optional split application (Depth then Edges) and a rich set of edge post‑processing knobs.
+
+For minimal usage, see the Easy wrapper documented in `docs/EasyNodes.md`.
+
+## Overview
+- Depth: Depth Anything v2 if available (vendored/local/aux fallbacks), otherwise pseudo‑depth from luminance + blur.
+- Edges: multi‑scale Pyramid Canny with optional thinning, width adjust, smoothing, single‑line collapse, and depth‑based gating.
+- Blending: `normal` (weighted mix), `max`, or `edge_over_depth` prior to ControlNet.
+- Application: single fused hint or `split_apply` (Depth first, then Edges) with independent strengths and schedules.
+- Preview: aspect‑kept visualization with optional strength reflection (display‑only).
+
+## Inputs
+- `image` (IMAGE, BHWC 0..1)
+- `positive` (CONDITIONING), `negative` (CONDITIONING)
+- `control_net` (CONTROL_NET)
+- `vae` (VAE)
+
+## Outputs
+- `positive` (CONDITIONING), `negative` (CONDITIONING) — updated with ControlNet hint
+- `Mask_Preview` (IMAGE) — fused mask preview (RGB 0..1)
+
+## Core Controls
+Depth
+- `enable_depth` (bool)
+- `depth_model_path` (pth for Depth Anything v2)
+- `depth_resolution` (min‑side target; hires mode keeps aspect)
+
+Edges (PyraCanny)
+- `enable_pyra` (bool), `pyra_low`, `pyra_high`, `pyra_resolution`
+- `edge_thin_iter` (thinning passes, auto‑tuned in smart mode)
+- `edge_alpha` (pre‑blend opacity), `edge_boost` (micro‑contrast), `smart_tune`, `smart_boost`
+
+Blend and Strength
+- `blend_mode`: `normal` | `max` | `edge_over_depth`
+- `blend_factor` (for `normal`)
+- `strength_pos`, `strength_neg` (global)
+- `start_percent`, `end_percent` (schedule window 0..1)
+
+Preview and Quality
+- `preview_res` (min‑side), `mask_brightness`
+- `preview_show_strength` with `preview_strength_branch` = `positive` | `negative` | `max` | `avg`
+- `hires_mask_auto` (keep aspect and higher caps)
+
+Application Options
+- `apply_to_uncond` (mirror ControlNet hint to uncond)
+- `stack_prev_control` (stack with previous ControlNet in the cond dict)
+- `split_apply` (Depth first, Edges second)
+- Separate schedules and multipliers when split:
+  - Depth: `depth_start_percent`, `depth_end_percent`, `depth_strength_mul`
+  - Edges: `edge_start_percent`, `edge_end_percent`, `edge_strength_mul`
+
+Extra Edge Controls
+- `edge_width` (thin/thicken), `edge_smooth` (reduce pixelation)
+- `edge_single_line`, `edge_single_strength` (collapse double outlines)
+- `edge_depth_gate`, `edge_depth_gamma` (weigh edges by depth)
+
+## Behavior Notes
+- Depth min‑side is capped (default 1024) and aspect is preserved to avoid distortions.
+- In `split_apply`, the order is deterministic: Depth → Edges.
+- Preview image reflects strength only if `preview_show_strength` is enabled; it does not affect the hint itself.
+- When both Depth and Edges are disabled, the node passes inputs through and returns a zero preview.
+
+## Quickstart
+1) Connect `image/positive/negative/control_net/vae`.
+2) Enable Depth and/or PyraCanny. Start with `edge_alpha≈1.0`, `blend_mode=normal`, `blend_factor≈0.02`.
+3) Schedule the apply window (`start_percent/end_percent`) and tune `strength_pos/neg`.
+4) Use `split_apply` if you want Depth to anchor structure and Edges to refine contours separately.
+

docs/hard/IDS.md

@@ -0,0 +1,20 @@
+# IntelligentDetailStabilizer (IDS)
+
+Gentle, fast post‑pass for stabilizing micro‑detail and suppressing noise while preserving sharpness.
+
+## Overview
+- Two‑stage blur/sharpen split with strength‑controlled recombination.
+- Uses SciPy Gaussian if available; otherwise a portable PyTorch separable blur.
+- Operates on images (BHWC, 0..1) and returns a single stabilized `IMAGE`.
+
+## Inputs
+- `image` (IMAGE)
+- `ids_strength` (float, default 0.5, range −1.0..1.0)
+
+## Outputs
+- `IMAGE` — stabilized image
+
+## Tips
+- Start around `ids_strength≈0.5` for gentle cleanup.
+- Negative values bias toward more smoothing; positive increases sharpening of denoised base.
+

docs/hard/UpscaleModule.md

@@ -0,0 +1,23 @@
+# MagicUpscaleModule
+
+Lightweight latent‑space upscaler that keeps shapes aligned to the VAE stride to avoid border artifacts.
+
+## Overview
+- Decodes latent to image, resamples with selected filter, and re‑encodes.
+- Aligns target size up to the VAE spatial compression stride to keep shapes consistent.
+- Clears GPU/RAM caches to minimize fragmentation before heavy resizes.
+
+## Inputs
+- `samples` (LATENT)
+- `vae` (VAE)
+- `upscale_method` in `nearest-exact | bilinear | area | bicubic | lanczos`
+- `scale_by` (float)
+
+## Outputs
+- `LATENT` — upscaled latent
+- `Upscaled Image` — convenience decoded image
+
+## Tips
+- Use modest `scale_by` first (e.g., 1.2–1.5) and chain passes if needed.
+- Keep the same `vae` before and after upscale in a larger pipeline.
+

docs/hard/ZeSmartSampler.md

@@ -0,0 +1,22 @@
+# MG_ZeSmartSampler (v1.1)
+
+Custom sampler that builds hybrid sigma schedules (Karras/Beta blend), adds tiny schedule jitter, and optionally applies a PC2‑like predictor‑corrector shaping.
+
+## Overview
+- Inputs/Outputs match a standard KSampler: `MODEL / SEED / STEPS / CFG / base_sampler / schedule / CONDITIONING / LATENT` → `LATENT`.
+- `hybrid_mix` blends the tail toward Beta; `tail_smooth` softens tail jumps adaptively.
+- `jitter_sigma` introduces a tiny monotonic noise to schedules for de‑ringing; remains deterministic with fixed seed.
+- PC2‑style shaping is available via `smart_strength/target_error/curv_sensitivity` (kept conservative by default).
+
+## Controls (high‑level)
+- `base_sampler` and `schedule` (karras/beta/hybrid)
+- `hybrid_mix` ∈ [0..1]
+- `jitter_sigma` ∈ [0..0.1]
+- `tail_smooth` ∈ [0..1]
+- `smart_strength`, `target_error`, `curv_sensitivity`
+
+## Tips
+- Start hybrid at `hybrid_mix≈0.3` for 2D work; 0.5–0.7 for photo‑like.
+- Keep `jitter_sigma` very small (≈0.005–0.01) to avoid destabilizing steps.
+- If using inside CADE (`scheduler=MGHybrid`), CADE will construct the schedule and run the custom path automatically.
+

init

@@ -1 +0,0 @@
-Init: MagicNodes (CADE 2.5, QSilk)

mod/__init__.py

@@ -0,0 +1,8 @@
+"""MagicNodes.mod package
+
+Holds the primary node implementations after repo cleanup. Keeping this as a
+package ensures stable relative imports from the project root.
+"""
+
+# No runtime side effects; modules are imported from MagicNodes.__init__.
+

mod/easy/__init__.py

@@ -0,0 +1,8 @@
+"""MagicNodes Easy variants
+
+Holds simplified, user‑friendly node variants that expose only
+high‑level parameters. Registered under category "MagicNodes/Easy".
+"""
+
+# Modules are imported from MagicNodes.__init__ to control registration.
+

mod/easy/mg_controlfusion_easy.py

@@ -0,0 +1,611 @@
+import os
+import sys
+import math
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+import comfy.model_management as model_management
+from .preset_loader import get as load_preset
+
+
+_DEPTH_INIT = False
+_DEPTH_MODEL = None
+_DEPTH_PROC = None
+
+
+def _insert_aux_path():
+    try:
+        base = os.path.dirname(os.path.dirname(__file__))  # .../custom_nodes
+        aux_root = os.path.join(base, 'comfyui_controlnet_aux')
+        aux_src = os.path.join(aux_root, 'src')
+        for p in (aux_src, aux_root):
+            if os.path.isdir(p) and p not in sys.path:
+                sys.path.insert(0, p)
+    except Exception:
+        pass
+
+
+def _try_init_depth_anything(model_path: str):
+    global _DEPTH_INIT, _DEPTH_MODEL, _DEPTH_PROC
+    if _DEPTH_INIT:
+        return _DEPTH_MODEL is not None
+    _DEPTH_INIT = True
+    # Prefer our vendored implementation first
+    try:
+        from ...vendor.depth_anything_v2.dpt import DepthAnythingV2  # type: ignore
+        # Guess config from filename
+        fname = os.path.basename(model_path or '')
+        cfgs = {
+            'depth_anything_v2_vits.pth': dict(encoder='vits', features=64, out_channels=[48,96,192,384]),
+            'depth_anything_v2_vitb.pth': dict(encoder='vitb', features=128, out_channels=[96,192,384,768]),
+            'depth_anything_v2_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            'depth_anything_v2_vitg.pth': dict(encoder='vitg', features=384, out_channels=[1536,1536,1536,1536]),
+            'depth_anything_v2_metric_vkitti_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            'depth_anything_v2_metric_hypersim_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+        }
+        # fallback to vitl if unknown
+        cfg = cfgs.get(fname, cfgs['depth_anything_v2_vitl.pth'])
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        m = DepthAnythingV2(**cfg)
+        sd = torch.load(model_path, map_location='cpu')
+        m.load_state_dict(sd)
+        _DEPTH_MODEL = m.to(device).eval()
+        _DEPTH_PROC = True
+        return True
+    except Exception:
+        # Try local checkout of comfyui_controlnet_aux (if present)
+        _insert_aux_path()
+        try:
+            from custom_controlnet_aux.depth_anything_v2.dpt import DepthAnythingV2  # type: ignore
+            fname = os.path.basename(model_path or '')
+            cfgs = {
+                'depth_anything_v2_vits.pth': dict(encoder='vits', features=64, out_channels=[48,96,192,384]),
+                'depth_anything_v2_vitb.pth': dict(encoder='vitb', features=128, out_channels=[96,192,384,768]),
+                'depth_anything_v2_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+                'depth_anything_v2_vitg.pth': dict(encoder='vitg', features=384, out_channels=[1536,1536,1536,1536]),
+                'depth_anything_v2_metric_vkitti_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+                'depth_anything_v2_metric_hypersim_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            }
+            cfg = cfgs.get(fname, cfgs['depth_anything_v2_vitl.pth'])
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+            m = DepthAnythingV2(**cfg)
+            sd = torch.load(model_path, map_location='cpu')
+            m.load_state_dict(sd)
+            _DEPTH_MODEL = m.to(device).eval()
+            _DEPTH_PROC = True
+            return True
+        except Exception:
+            # Fallback: packaged auxiliary API
+            try:
+                from controlnet_aux.depth_anything import DepthAnythingDetector, DepthAnythingV2  # type: ignore
+                device = 'cuda' if torch.cuda.is_available() else 'cpu'
+                _DEPTH_MODEL = DepthAnythingV2(model_path=model_path, device=device)
+                _DEPTH_PROC = True
+                return True
+            except Exception:
+                _DEPTH_MODEL = None
+                _DEPTH_PROC = False
+                return False
+
+
+def _build_depth_map(image_bhwc: torch.Tensor, res: int, model_path: str, hires_mode: bool = True) -> torch.Tensor:
+    B, H, W, C = image_bhwc.shape
+    dev = image_bhwc.device
+    dtype = image_bhwc.dtype
+    # Choose target min-side for processing. In hires mode we allow higher caps and keep aspect.
+    # DepthAnything v2 can be memory-hungry on large inputs; cap min-side at 1024
+    cap = 1024
+    target = int(max(16, min(cap, res)))
+    if _try_init_depth_anything(model_path):
+        try:
+            # to CPU uint8
+            img = image_bhwc.detach().to('cpu')
+            x = img[0].movedim(-1, 0).unsqueeze(0)
+            # keep aspect ratio: scale so that min(H,W) == target
+            _, Cc, Ht, Wt = x.shape
+            min_side = max(1, min(Ht, Wt))
+            scale = float(target) / float(min_side)
+            out_h = max(1, int(round(Ht * scale)))
+            out_w = max(1, int(round(Wt * scale)))
+            x = F.interpolate(x, size=(out_h, out_w), mode='bilinear', align_corners=False)
+            # make channels-last and ensure contiguous layout for OpenCV
+            arr = (x[0].movedim(0, -1).contiguous().numpy() * 255.0).astype('uint8')
+            # Prefer direct DepthAnythingV2 inference if model has infer_image
+            if hasattr(_DEPTH_MODEL, 'infer_image'):
+                import cv2
+                # Drive input_size from desired depth resolution (min side), let DA keep aspect
+                input_sz = int(max(224, min(cap, res)))
+                depth = _DEPTH_MODEL.infer_image(cv2.cvtColor(arr, cv2.COLOR_RGB2BGR), input_size=input_sz, max_depth=20.0)
+                d = np.asarray(depth, dtype=np.float32)
+                # Normalize DepthAnythingV2 output (0..max_depth) to 0..1
+                d = d / 20.0
+            else:
+                depth = _DEPTH_MODEL(arr)
+                d = np.asarray(depth, dtype=np.float32)
+            if d.max() > 1.0:
+                d = d / 255.0
+            d = torch.from_numpy(d)[None, None]  # 1,1,h,w
+            d = F.interpolate(d, size=(H, W), mode='bilinear', align_corners=False)
+            d = d[0, 0].to(device=dev, dtype=dtype)
+            d = d.clamp(0, 1)
+            return d
+        except Exception:
+            pass
+    # Fallback pseudo-depth: luminance + gentle blur
+    lum = (0.2126 * image_bhwc[..., 0] + 0.7152 * image_bhwc[..., 1] + 0.0722 * image_bhwc[..., 2]).to(dtype=dtype)
+    x = lum.movedim(-1, 0).unsqueeze(0) if lum.ndim == 3 else lum.unsqueeze(0).unsqueeze(0)
+    x = F.interpolate(x, size=(H, W), mode='bilinear', align_corners=False)
+    x = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+    return x[0, 0].clamp(0, 1)
+
+
+def _pyracanny(image_bhwc: torch.Tensor,
+               low: int,
+               high: int,
+               res: int,
+               thin_iter: int = 0,
+               edge_boost: float = 0.0,
+               smart_tune: bool = False,
+               smart_boost: float = 0.2,
+               preserve_aspect: bool = True) -> torch.Tensor:
+    try:
+        import cv2
+    except Exception:
+        # Fallback: simple Sobel magnitude
+        x = image_bhwc.movedim(-1, 1)
+        xg = x.mean(dim=1, keepdim=True)
+        gx = F.conv2d(xg, torch.tensor([[[-1, 0, 1],[-2,0,2],[-1,0,1]]], dtype=x.dtype, device=x.device).unsqueeze(1), padding=1)
+        gy = F.conv2d(xg, torch.tensor([[[-1,-2,-1],[0,0,0],[1,2,1]]], dtype=x.dtype, device=x.device).unsqueeze(1), padding=1)
+        mag = torch.sqrt(gx*gx + gy*gy)
+        mag = (mag - mag.amin())/(mag.amax()-mag.amin()+1e-6)
+        return mag[0,0].clamp(0,1)
+    B,H,W,C = image_bhwc.shape
+    img = (image_bhwc.detach().to('cpu')[0].contiguous().numpy()*255.0).astype('uint8')
+    cap = 4096
+    target = int(max(64, min(cap, res)))
+    if preserve_aspect:
+        scale = float(target) / float(max(1, min(H, W)))
+        out_h = max(8, int(round(H * scale)))
+        out_w = max(8, int(round(W * scale)))
+        img_res = cv2.resize(img, (out_w, out_h), interpolation=cv2.INTER_LINEAR)
+    else:
+        img_res = cv2.resize(img, (target, target), interpolation=cv2.INTER_LINEAR)
+    gray = cv2.cvtColor(img_res, cv2.COLOR_RGB2GRAY)
+    pyr_scales = [1.0, 0.5, 0.25]
+    acc = None
+    for s in pyr_scales:
+        if preserve_aspect:
+            sz = (max(8, int(round(img_res.shape[1]*s))), max(8, int(round(img_res.shape[0]*s))))
+        else:
+            sz = (max(8, int(target*s)), max(8, int(target*s)))
+        g = cv2.resize(gray, sz, interpolation=cv2.INTER_AREA)
+        g = cv2.GaussianBlur(g, (5,5), 0)
+        e = cv2.Canny(g, threshold1=int(low*s), threshold2=int(high*s))
+        e = cv2.resize(e, (W, H), interpolation=cv2.INTER_LINEAR)
+        e = (e.astype(np.float32)/255.0)
+        acc = e if acc is None else np.maximum(acc, e)
+    # Estimate density and sharpness for smart tuning
+    edensity_pre = None
+    try:
+        edensity_pre = float(np.mean(acc)) if acc is not None else None
+    except Exception:
+        edensity_pre = None
+    lap_var = None
+    try:
+        g32 = gray.astype(np.float32) / 255.0
+        lap = cv2.Laplacian(g32, cv2.CV_32F)
+        lap_var = float(lap.var())
+    except Exception:
+        lap_var = None
+
+    # optional thinning
+    try:
+        thin_iter_eff = int(thin_iter)
+        if smart_tune:
+            # simple heuristic: more thinning on high res and dense edges
+            auto = 0
+            if target >= 1024:
+                auto += 1
+            if target >= 1400:
+                auto += 1
+            if edensity_pre is not None and edensity_pre > 0.12:
+                auto += 1
+            if edensity_pre is not None and edensity_pre < 0.05:
+                auto = max(0, auto - 1)
+            thin_iter_eff = max(thin_iter_eff, min(3, auto))
+        if thin_iter_eff > 0:
+            import cv2
+            if hasattr(cv2, 'ximgproc') and hasattr(cv2.ximgproc, 'thinning'):
+                th = acc.copy()
+                th = (th*255).astype('uint8')
+                th = cv2.ximgproc.thinning(th)
+                acc = th.astype(np.float32)/255.0
+            else:
+                # simple erosion-based thinning approximation
+                kernel = np.ones((3,3), np.uint8)
+                t = (acc*255).astype('uint8')
+                for _ in range(int(thin_iter_eff)):
+                    t = cv2.erode(t, kernel, iterations=1)
+                acc = t.astype(np.float32)/255.0
+    except Exception:
+        pass
+    # optional edge boost (unsharp on edge map)
+    # We fix a gentle boost for micro‑contrast; smart_tune may nudge it slightly
+    boost_eff = 0.10
+    if smart_tune:
+        try:
+            lv = 0.0 if lap_var is None else max(0.0, min(1.0, lap_var / 2.0))
+            dens = 0.0 if edensity_pre is None else float(max(0.0, min(1.0, edensity_pre)))
+            boost_eff = max(0.05, min(0.20, boost_eff + (1.0 - dens) * 0.05 + (1.0 - lv) * 0.02))
+        except Exception:
+            pass
+    if boost_eff and boost_eff != 0.0:
+        try:
+            import cv2
+            blur = cv2.GaussianBlur(acc, (0,0), sigmaX=1.0)
+            acc = np.clip(acc + float(boost_eff)*(acc - blur), 0.0, 1.0)
+        except Exception:
+            pass
+    ed = torch.from_numpy(acc).to(device=image_bhwc.device, dtype=image_bhwc.dtype)
+    return ed.clamp(0,1)
+
+
+def _blend(depth: torch.Tensor, edges: torch.Tensor, mode: str, factor: float) -> torch.Tensor:
+    depth = depth.clamp(0,1)
+    edges = edges.clamp(0,1)
+    if mode == 'max':
+        return torch.maximum(depth, edges)
+    if mode == 'edge_over_depth':
+        # edges override depth (edge=1) while preserving depth elsewhere
+        return (depth * (1.0 - edges) + edges).clamp(0,1)
+    # normal
+    f = float(max(0.0, min(1.0, factor)))
+    return (depth*(1.0-f) + edges*f).clamp(0,1)
+
+
+def _apply_controlnet_separate(positive, negative, control_net, image_bhwc: torch.Tensor,
+                               strength_pos: float, strength_neg: float,
+                               start_percent: float, end_percent: float, vae=None,
+                               apply_to_uncond: bool = False,
+                               stack_prev_control: bool = False):
+    control_hint = image_bhwc.movedim(-1,1)
+    out_pos = []
+    out_neg = []
+    # POS
+    for t in positive:
+        d = t[1].copy()
+        prev = d.get('control', None) if stack_prev_control else None
+        c_net = control_net.copy().set_cond_hint(control_hint, float(strength_pos), (start_percent, end_percent), vae=vae, extra_concat=[])
+        c_net.set_previous_controlnet(prev)
+        d['control'] = c_net
+        d['control_apply_to_uncond'] = bool(apply_to_uncond)
+        out_pos.append([t[0], d])
+    # NEG
+    for t in negative:
+        d = t[1].copy()
+        prev = d.get('control', None) if stack_prev_control else None
+        c_net = control_net.copy().set_cond_hint(control_hint, float(strength_neg), (start_percent, end_percent), vae=vae, extra_concat=[])
+        c_net.set_previous_controlnet(prev)
+        d['control'] = c_net
+        d['control_apply_to_uncond'] = bool(apply_to_uncond)
+        out_neg.append([t[0], d])
+    return out_pos, out_neg
+
+
+class MG_ControlFusion:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "preset_step": (["Custom", "Step 2", "Step 3", "Step 4"], {"default": "Custom", "tooltip": "Apply preset values from pressets/mg_controlfusion.cfg. UI values override."}),
+                "image": ("IMAGE", {"tooltip": "Input RGB image (B,H,W,3) in 0..1."}),
+                "positive": ("CONDITIONING", {"tooltip": "Positive conditioning to apply ControlNet to."}),
+                "negative": ("CONDITIONING", {"tooltip": "Negative conditioning to apply ControlNet to."}),
+                "control_net": ("CONTROL_NET", {"tooltip": "ControlNet module receiving the fused mask as hint."}),
+                "vae": ("VAE", {"tooltip": "VAE used by ControlNet when encoding the hint."}),
+            },
+            "optional": {
+                "enable_depth": ("BOOLEAN", {"default": True, "tooltip": "Enable depth map fusion (Depth Anything v2 if available)."}),
+                "depth_model_path": ("STRING", {"default": os.path.join(os.path.dirname(os.path.dirname(__file__)), 'MagicNodes','depth-anything','depth_anything_v2_vitl.pth') if False else os.path.join(os.path.dirname(__file__), '..','depth-anything','depth_anything_v2_vitl.pth'), "tooltip": "Path to Depth Anything v2 .pth weights (vits/vitb/vitl/vitg)."}),
+                "depth_resolution": ("INT", {"default": 768, "min": 64, "max": 1024, "step": 64, "tooltip": "Depth min-side resolution (cap 1024). In Hi‑Res mode drives DepthAnything input_size."}),
+                "enable_pyra": ("BOOLEAN", {"default": True, "tooltip": "Enable PyraCanny edge detector."}),
+                "pyra_low": ("INT", {"default": 109, "min": 0, "max": 255, "tooltip": "Canny low threshold (0..255)."}),
+                "pyra_high": ("INT", {"default": 147, "min": 0, "max": 255, "tooltip": "Canny high threshold (0..255)."}),
+                "pyra_resolution": ("INT", {"default": 1024, "min": 64, "max": 4096, "step": 64, "tooltip": "Working resolution for edges (min side, keeps aspect)."}),
+                "edge_thin_iter": ("INT", {"default": 0, "min": 0, "max": 10, "step": 1, "tooltip": "Thinning iterations for edges (skeletonize). 0 = off."}),
+                "edge_alpha": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Opacity for edges before blending (0..1)."}),
+                "edge_boost": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Deprecated: internal boost fixed (~0.10); use edge_alpha instead."}),
+                "smart_tune": ("BOOLEAN", {"default": False, "tooltip": "Auto-adjust thinning/boost from image edge density and sharpness."}),
+                "smart_boost": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Scale for auto edge boost when Smart Tune is on."}),
+                "blend_mode": (["normal","max","edge_over_depth"], {"default": "normal", "tooltip": "Depth+edges merge: normal (mix), max (strongest), edge_over_depth (edges overlay)."}),
+                "blend_factor": ("FLOAT", {"default": 0.02, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Blend strength for edges into depth (depends on mode)."}),
+                "strength_pos": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, "tooltip": "ControlNet strength for positive branch."}),
+                "strength_neg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, "tooltip": "ControlNet strength for negative branch."}),
+                "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Start percentage along the sampling schedule."}),
+                "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "End percentage along the sampling schedule."}),
+                "preview_res": ("INT", {"default": 1024, "min": 256, "max": 2048, "step": 64, "tooltip": "Preview minimum side (keeps aspect ratio)."}),
+                "mask_brightness": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Preview brightness multiplier (visualization only)."}),
+                "preview_show_strength": ("BOOLEAN", {"default": True, "tooltip": "Multiply preview by ControlNet strength for visualization."}),
+                "preview_strength_branch": (["positive","negative","max","avg"], {"default": "max", "tooltip": "Which strength to reflect in preview (display only)."}),
+                "hires_mask_auto": ("BOOLEAN", {"default": True, "tooltip": "High‑res mask: keep aspect ratio, scale by minimal side for depth/edges, and drive DepthAnything with your depth_resolution (no 2K cap)."}),
+                "apply_to_uncond": ("BOOLEAN", {"default": False, "tooltip": "Apply ControlNet hint to the unconditional branch as well (stronger global hold on very large images)."}),
+                "stack_prev_control": ("BOOLEAN", {"default": False, "tooltip": "Chain with any previously attached ControlNet in the conditioning (advanced). Off = replace to avoid memory bloat."}),
+                # Split apply: chain Depth and Edges with separate schedules/strengths (fixed order: depth -> edges)
+                "split_apply": ("BOOLEAN", {"default": False, "tooltip": "Apply Depth and Edges as two chained ControlNets (fixed order: depth then edges)."}),
+                "edge_start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Edges start percent (when split is enabled)."}),
+                "edge_end_percent": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Edges end percent (when split is enabled)."}),
+                "depth_start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Depth start percent (when split is enabled)."}),
+                "depth_end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Depth end percent (when split is enabled)."}),
+                "edge_strength_mul": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiply global strength for Edges when split is enabled."}),
+                "depth_strength_mul": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiply global strength for Depth when split is enabled."}),
+                # Extra edge controls (bottom)
+                "edge_width": ("FLOAT", {"default": 0.0, "min": -0.5, "max": 1.5, "step": 0.05, "tooltip": "Edge thickness adjust: negative thins, positive thickens."}),
+                "edge_smooth": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05, "tooltip": "Small smooth on edges to reduce pixelation (0..1)."}),
+                "edge_single_line": ("BOOLEAN", {"default": False, "tooltip": "Try to collapse double outlines into a single centerline."}),
+                "edge_single_strength": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Strength of single-line collapse (0..1). 0 = off, 1 = strong."}),
+                "edge_depth_gate": ("BOOLEAN", {"default": False, "tooltip": "Weigh edges by depth so distant lines are fainter."}),
+                "edge_depth_gamma": ("FLOAT", {"default": 1.5, "min": 0.2, "max": 4.0, "step": 0.1, "tooltip": "Gamma for depth gating: edges *= (1−depth)^gamma."}),
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING","CONDITIONING","IMAGE")
+    RETURN_NAMES = ("positive","negative","Mask_Preview")
+    FUNCTION = "apply"
+    CATEGORY = "MagicNodes"
+
+    def apply(self, image, positive, negative, control_net, vae,
+              enable_depth=True, depth_model_path="", depth_resolution=1024,
+              enable_pyra=True, pyra_low=109, pyra_high=147, pyra_resolution=1024,
+              edge_thin_iter=0, edge_alpha=1.0, edge_boost=0.0,
+              smart_tune=False, smart_boost=0.2,
+              blend_mode="normal", blend_factor=0.02,
+              strength_pos=1.0, strength_neg=1.0, start_percent=0.0, end_percent=1.0,
+              preview_res=1024, mask_brightness=1.0,
+              preview_show_strength=True, preview_strength_branch="max",
+              hires_mask_auto=True, apply_to_uncond=False, stack_prev_control=False,
+              edge_width=0.0, edge_smooth=0.0, edge_single_line=False, edge_single_strength=0.0,
+              edge_depth_gate=False, edge_depth_gamma=1.5,
+              split_apply=False, edge_start_percent=0.0, edge_end_percent=0.6,
+              depth_start_percent=0.0, depth_end_percent=1.0,
+              edge_strength_mul=1.0, depth_strength_mul=1.0,
+              preset_step="Step 2", custom_override=False):
+
+        # Merge preset values (if selected) with UI values; UI overrides preset
+        try:
+            if isinstance(preset_step, str) and preset_step.lower() != "custom":
+                p = load_preset("mg_controlfusion", preset_step)
+            else:
+                p = {}
+        except Exception:
+            p = {}
+        def pv(name, cur):
+            return p.get(name, cur)
+        enable_depth = bool(pv('enable_depth', enable_depth))
+        depth_model_path = str(pv('depth_model_path', depth_model_path))
+        depth_resolution = int(pv('depth_resolution', depth_resolution))
+        enable_pyra = bool(pv('enable_pyra', enable_pyra))
+        pyra_low = int(pv('pyra_low', pyra_low))
+        pyra_high = int(pv('pyra_high', pyra_high))
+        pyra_resolution = int(pv('pyra_resolution', pyra_resolution))
+        edge_thin_iter = int(pv('edge_thin_iter', edge_thin_iter))
+        edge_alpha = float(pv('edge_alpha', edge_alpha))
+        edge_boost = float(pv('edge_boost', edge_boost))
+        smart_tune = bool(pv('smart_tune', smart_tune))
+        smart_boost = float(pv('smart_boost', smart_boost))
+        blend_mode = str(pv('blend_mode', blend_mode))
+        blend_factor = float(pv('blend_factor', blend_factor))
+        strength_pos = float(pv('strength_pos', strength_pos))
+        strength_neg = float(pv('strength_neg', strength_neg))
+        start_percent = float(pv('start_percent', start_percent))
+        end_percent = float(pv('end_percent', end_percent))
+        preview_res = int(pv('preview_res', preview_res))
+        mask_brightness = float(pv('mask_brightness', mask_brightness))
+        preview_show_strength = bool(pv('preview_show_strength', preview_show_strength))
+        preview_strength_branch = str(pv('preview_strength_branch', preview_strength_branch))
+        hires_mask_auto = bool(pv('hires_mask_auto', hires_mask_auto))
+        apply_to_uncond = bool(pv('apply_to_uncond', apply_to_uncond))
+        stack_prev_control = bool(pv('stack_prev_control', stack_prev_control))
+        split_apply = bool(pv('split_apply', split_apply))
+        edge_start_percent = float(pv('edge_start_percent', edge_start_percent))
+        edge_end_percent = float(pv('edge_end_percent', edge_end_percent))
+        depth_start_percent = float(pv('depth_start_percent', depth_start_percent))
+        depth_end_percent = float(pv('depth_end_percent', depth_end_percent))
+        edge_strength_mul = float(pv('edge_strength_mul', edge_strength_mul))
+        depth_strength_mul = float(pv('depth_strength_mul', depth_strength_mul))
+        edge_width = float(pv('edge_width', edge_width))
+        edge_smooth = float(pv('edge_smooth', edge_smooth))
+        edge_single_line = bool(pv('edge_single_line', edge_single_line))
+        edge_single_strength = float(pv('edge_single_strength', edge_single_strength))
+        edge_depth_gate = bool(pv('edge_depth_gate', edge_depth_gate))
+        edge_depth_gamma = float(pv('edge_depth_gamma', edge_depth_gamma))
+
+        dev = image.device
+        dtype = image.dtype
+        B,H,W,C = image.shape
+        # Build depth/edges
+        depth = None
+        edges = None
+        if enable_depth:
+            model_path = depth_model_path or os.path.join(os.path.dirname(__file__), '..','depth-anything','depth_anything_v2_vitl.pth')
+            depth = _build_depth_map(image, int(depth_resolution), model_path, bool(hires_mask_auto))
+        if enable_pyra:
+            edges = _pyracanny(image,
+                               int(pyra_low), int(pyra_high), int(pyra_resolution),
+                               int(edge_thin_iter), float(edge_boost),
+                               bool(smart_tune), float(smart_boost), bool(hires_mask_auto))
+        if depth is None and edges is None:
+            # Nothing to do: return inputs and zero preview
+            prev = torch.zeros((B, max(H,1), max(W,1), 3), device=dev, dtype=dtype)
+            return positive, negative, prev
+
+        if depth is None:
+            depth = torch.zeros_like(edges)
+        if edges is None:
+            edges = torch.zeros_like(depth)
+
+        # Edge post-process: width/single-line/smooth
+        def _edges_post(acc_t: torch.Tensor) -> torch.Tensor:
+            try:
+                import cv2, numpy as _np
+                acc = acc_t.detach().to('cpu').numpy()
+                img = (acc*255.0).astype(_np.uint8)
+                k = _np.ones((3,3), _np.uint8)
+                # Adjust thickness
+                w = float(edge_width)
+                if abs(w) > 1e-6:
+                    it = int(abs(w))
+                    frac = abs(w) - it
+                    op = cv2.dilate if w > 0 else cv2.erode
+                    y = img.copy()
+                    for _ in range(max(0, it)):
+                        y = op(y, k, iterations=1)
+                    if frac > 1e-6:
+                        y2 = op(y, k, iterations=1)
+                        y = ((1.0-frac)*y.astype(_np.float32) + frac*y2.astype(_np.float32)).astype(_np.uint8)
+                    img = y
+                # Collapse double lines to single centerline
+                if bool(edge_single_line) and float(edge_single_strength) > 1e-6:
+                    try:
+                        s = float(edge_single_strength)
+                        close = cv2.morphologyEx(img, cv2.MORPH_CLOSE, k, iterations=1)
+                        if hasattr(cv2, 'ximgproc') and hasattr(cv2.ximgproc, 'thinning'):
+                            sk = cv2.ximgproc.thinning(close)
+                        else:
+                            # limited-iteration morphological skeletonization
+                            iters = max(1, int(round(2 + 6*s)))
+                            sk = _np.zeros_like(close)
+                            src = close.copy()
+                            elem = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
+                            for _ in range(iters):
+                                er = cv2.erode(src, elem, iterations=1)
+                                op = cv2.morphologyEx(er, cv2.MORPH_OPEN, elem)
+                                tmp = cv2.subtract(er, op)
+                                sk = cv2.bitwise_or(sk, tmp)
+                                src = er
+                                if not _np.any(src):
+                                    break
+                        # Blend skeleton back with original according to strength
+                        img = ((_np.float32(1.0 - s) * img.astype(_np.float32)) + (_np.float32(s) * sk.astype(_np.float32))).astype(_np.uint8)
+                    except Exception:
+                        pass
+                # Smooth
+                if float(edge_smooth) > 1e-6:
+                    sigma = max(0.1, min(2.0, float(edge_smooth) * 1.2))
+                    img = cv2.GaussianBlur(img, (0,0), sigmaX=sigma)
+                out = torch.from_numpy((img.astype(_np.float32)/255.0)).to(device=acc_t.device, dtype=acc_t.dtype)
+                return out.clamp(0,1)
+            except Exception:
+                # Torch fallback: light blur-only
+                if float(edge_smooth) > 1e-6:
+                    s = max(1, int(round(float(edge_smooth)*2)))
+                    return F.avg_pool2d(acc_t.unsqueeze(0).unsqueeze(0), kernel_size=2*s+1, stride=1, padding=s)[0,0].clamp(0,1)
+                return acc_t
+
+        edges = _edges_post(edges)
+
+        # Depth gating of edges
+        if bool(edge_depth_gate):
+            # Inverted gating per feedback: use depth^gamma (nearer = stronger if depth is larger)
+            g = (depth.clamp(0,1)) ** float(edge_depth_gamma)
+            edges = (edges * g).clamp(0,1)
+
+        # Apply edge alpha before blending
+        edges = (edges * float(edge_alpha)).clamp(0,1)
+
+        fused = _blend(depth, edges, str(blend_mode), float(blend_factor))
+        # Apply as split (Edges then Depth) or single fused hint
+        if bool(split_apply):
+            # Fixed order for determinism: Depth first, then Edges
+            hint_edges = edges.unsqueeze(-1).repeat(1,1,1,3)
+            hint_depth = depth.unsqueeze(-1).repeat(1,1,1,3)
+            # Depth first
+            pos_mid, neg_mid = _apply_controlnet_separate(
+                positive, negative, control_net, hint_depth,
+                float(strength_pos) * float(depth_strength_mul),
+                float(strength_neg) * float(depth_strength_mul),
+                float(depth_start_percent), float(depth_end_percent), vae,
+                bool(apply_to_uncond), True
+            )
+            # Then edges
+            pos_out, neg_out = _apply_controlnet_separate(
+                pos_mid, neg_mid, control_net, hint_edges,
+                float(strength_pos) * float(edge_strength_mul),
+                float(strength_neg) * float(edge_strength_mul),
+                float(edge_start_percent), float(edge_end_percent), vae,
+                bool(apply_to_uncond), True
+            )
+        else:
+            hint = fused.unsqueeze(-1).repeat(1,1,1,3)
+            pos_out, neg_out = _apply_controlnet_separate(
+                positive, negative, control_net, hint,
+                float(strength_pos), float(strength_neg),
+                float(start_percent), float(end_percent), vae,
+                bool(apply_to_uncond), bool(stack_prev_control)
+            )
+        # Build preview: keep aspect ratio, set minimal side
+        prev_res = int(max(256, min(2048, preview_res)))
+        scale = prev_res / float(min(H, W))
+        out_h = max(1, int(round(H * scale)))
+        out_w = max(1, int(round(W * scale)))
+        prev = F.interpolate(fused.unsqueeze(0).unsqueeze(0), size=(out_h, out_w), mode='bilinear', align_corners=False)[0,0]
+        # Optionally reflect ControlNet strength in preview (display only)
+        if bool(preview_show_strength):
+            br = str(preview_strength_branch)
+            sp = float(strength_pos)
+            sn = float(strength_neg)
+            if br == 'negative':
+                s_vis = sn
+            elif br == 'max':
+                s_vis = max(sp, sn)
+            elif br == 'avg':
+                s_vis = 0.5 * (sp + sn)
+            else:
+                s_vis = sp
+            # clamp for display range
+            s_vis = max(0.0, min(1.0, s_vis))
+            prev = prev * s_vis
+        # Apply visualization brightness only for preview
+        prev = (prev * float(mask_brightness)).clamp(0.0, 1.0)
+        prev = prev.unsqueeze(-1).repeat(1,1,3).to(device=dev, dtype=dtype).unsqueeze(0)
+        return (pos_out, neg_out, prev)
+
+
+# === Easy UI wrapper: simplified controls + Step/Custom preset logic ===
+class MG_ControlFusionEasyUI(MG_ControlFusion):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # Step preset first for emphasis
+                "preset_step": (["Step 2", "Step 3", "Step 4"], {"default": "Step 2", "tooltip": "Choose the Step preset. Toggle Custom below to apply UI values; otherwise Step preset values are used."}),
+                # Custom toggle: when enabled, UI values override the Step for visible controls
+                "custom": ("BOOLEAN", {"default": False, "tooltip": "Custom override: when enabled, your UI values override the selected Step for visible controls; hidden parameters still come from the Step preset."}),
+                # Connectors
+                "image": ("IMAGE", {"tooltip": "Input RGB image (B,H,W,3) in 0..1."}),
+                "positive": ("CONDITIONING", {"tooltip": "Positive conditioning to apply ControlNet to."}),
+                "negative": ("CONDITIONING", {"tooltip": "Negative conditioning to apply ControlNet to."}),
+                "control_net": ("CONTROL_NET", {"tooltip": "ControlNet module receiving the fused mask as hint."}),
+                "vae": ("VAE", {"tooltip": "VAE used by ControlNet when encoding the hint."}),
+                # Minimal surface controls
+                "enable_depth": ("BOOLEAN", {"default": True, "tooltip": "Enable depth map fusion (Depth Anything v2 if available)."}),
+                "enable_pyra": ("BOOLEAN", {"default": True, "tooltip": "Enable PyraCanny edge detector."}),
+                "edge_alpha": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Opacity for edges before blending (0..1)."}),
+                "blend_factor": ("FLOAT", {"default": 0.02, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Blend strength for edges into depth (depends on mode)."}),
+            },
+            "optional": {}
+        }
+
+    RETURN_TYPES = ("CONDITIONING","CONDITIONING","IMAGE")
+    RETURN_NAMES = ("positive","negative","Mask_Preview")
+    FUNCTION = "apply_easy"
+
+    def apply_easy(self, preset_step, custom, image, positive, negative, control_net, vae,
+                   enable_depth=True, enable_pyra=True, edge_alpha=1.0, blend_factor=0.02):
+        # Use Step preset; if custom is True, allow visible UI values to override inside base impl via custom_override
+        return super().apply(
+            image=image, positive=positive, negative=negative, control_net=control_net, vae=vae,
+            enable_depth=bool(enable_depth), enable_pyra=bool(enable_pyra), edge_alpha=float(edge_alpha), blend_factor=float(blend_factor),
+            preset_step=str(preset_step) if not bool(custom) else "Custom",
+            custom_override=bool(custom),
+        )

mod/easy/mg_supersimple_easy.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+"""MG_SuperSimple: Orchestrates a 1–4 step pipeline over CF→CADE pairs.
+
+- Step 1: CADE with Step 1 preset. Exception: forces denoise=1.0.
+- Steps 2..N: ControlFusion (CF) with Step N preset → CADE with Step N preset.
+- When custom is True: visible CADE controls (seed/steps/cfg/denoise/sampler/scheduler/clipseg_text)
+  override corresponding Step presets across all steps (except step 1 denoise is always 1.0).
+- When custom is False: all CADE values come from Step presets; node UI values are ignored.
+- CF always uses its Step presets (no extra UI here) to keep the node minimal.
+
+Inputs
+- model/vae/latent/positive/negative: standard Comfy connectors
+- control_net: ControlNet module for CF (required)
+- reference_image/clip_vision: forwarded into CADE (optional)
+
+Outputs
+- (LATENT, IMAGE) from the final executed step
+"""
+
+import torch
+
+from .mg_cade25_easy import ComfyAdaptiveDetailEnhancer25 as _CADE
+from .mg_controlfusion_easy import MG_ControlFusion as _CF
+from .mg_cade25_easy import _sampler_names as _sampler_names
+from .mg_cade25_easy import _scheduler_names as _scheduler_names
+
+
+class MG_SuperSimple:
+    CATEGORY = "MagicNodes/Easy"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # High-level pipeline control
+                "step_count": ("INT", {"default": 4, "min": 1, "max": 4, "tooltip": "Number of steps to run (1..4)."}),
+                "custom": ("BOOLEAN", {"default": False, "tooltip": "When enabled, CADE UI values below override Step presets across all steps (denoise on Step 1 is still forced to 1.0)."}),
+
+                # Connectors
+                "model": ("MODEL", {}),
+                "positive": ("CONDITIONING", {}),
+                "negative": ("CONDITIONING", {}),
+                "vae": ("VAE", {}),
+                "latent": ("LATENT", {}),
+                "control_net": ("CONTROL_NET", {"tooltip": "ControlNet module used by ControlFusion."}),
+
+                # Shared CADE surface controls
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF, "control_after_generate": True, "tooltip": "Seed 0 = SmartSeed (Sobol + light probe). Non-zero = fixed seed (deterministic)."}),
+                "steps": ("INT", {"default": 25, "min": 1, "max": 10000, "tooltip": "KSampler steps for CADE (applies to all steps)."}),
+                "cfg": ("FLOAT", {"default": 4.5, "min": 0.0, "max": 100.0, "step": 0.1}),
+                # Denoise is clamped; Step 1 uses 1.0 regardless
+                "denoise": ("FLOAT", {"default": 0.65, "min": 0.35, "max": 0.9, "step": 0.0001}),
+                "sampler_name": (_sampler_names(), {"default": _sampler_names()[0]}),
+                "scheduler": (_scheduler_names(), {"default": "MGHybrid"}),
+                "clipseg_text": ("STRING", {"default": "hand, feet, face", "multiline": False, "tooltip": "Focus terms for CLIPSeg (comma-separated)."}),
+            },
+            "optional": {
+                "reference_image": ("IMAGE", {}),
+                "clip_vision": ("CLIP_VISION", {}),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "IMAGE")
+    RETURN_NAMES = ("LATENT", "IMAGE")
+    FUNCTION = "run"
+
+    def _cade(self,
+              preset_step: str,
+              custom_override: bool,
+              model, vae, positive, negative, latent,
+              seed: int, steps: int, cfg: float, denoise: float,
+              sampler_name: str, scheduler: str,
+              clipseg_text: str,
+              reference_image=None, clip_vision=None):
+        # CADE core call mirrors CADEEasyUI -> apply_cade2
+        lat, img, _s, _c, _d, _mask = _CADE().apply_cade2(
+            model, vae, positive, negative, latent,
+            int(seed), int(steps), float(cfg), float(denoise),
+            str(sampler_name), str(scheduler), 0.0,
+            preset_step=str(preset_step), custom_override=bool(custom_override),
+            clipseg_text=str(clipseg_text),
+            reference_image=reference_image, clip_vision=clip_vision,
+        )
+        return lat, img
+
+    def _cf(self,
+            preset_step: str,
+            image, positive, negative, control_net, vae):
+        # Keep CF strictly on presets for SuperSimple (no extra UI),
+        # so pass custom_override=False intentionally.
+        pos, neg, _prev = _CF().apply(
+            image=image, positive=positive, negative=negative,
+            control_net=control_net, vae=vae,
+            preset_step=str(preset_step), custom_override=False,
+        )
+        return pos, neg
+
+    def run(self,
+            step_count, custom,
+            model, positive, negative, vae, latent, control_net,
+            seed, steps, cfg, denoise, sampler_name, scheduler, clipseg_text,
+            reference_image=None, clip_vision=None):
+        # Clamp step_count to 1..4
+        n = int(max(1, min(4, step_count)))
+
+        cur_latent = latent
+        cur_image = None
+        cur_pos = positive
+        cur_neg = negative
+
+        # Step 1: CADE with Step 1 preset, denoise forced to 1.0
+        denoise_step1 = 1.0
+        lat1, img1 = self._cade(
+            preset_step="Step 1",
+            custom_override=bool(custom),
+            model=model, vae=vae, positive=cur_pos, negative=cur_neg, latent=cur_latent,
+            seed=seed, steps=steps, cfg=cfg, denoise=denoise_step1,
+            sampler_name=sampler_name, scheduler=scheduler,
+            clipseg_text=clipseg_text,
+            reference_image=reference_image, clip_vision=clip_vision,
+        )
+        cur_latent, cur_image = lat1, img1
+
+        # Steps 2..n: CF -> CADE per step
+        for i in range(2, n + 1):
+            # ControlFusion on current image/conds
+            cur_pos, cur_neg = self._cf(
+                preset_step=f"Step {i}",
+                image=cur_image, positive=cur_pos, negative=cur_neg,
+                control_net=control_net, vae=vae,
+            )
+            # CADE with shared controls
+            # If no external reference_image is provided, use the previous step image
+            # so that reference_clean / CLIP-Vision gating can take effect.
+            ref_img = reference_image if (reference_image is not None) else cur_image
+            lat_i, img_i = self._cade(
+                preset_step=f"Step {i}",
+                custom_override=bool(custom),
+                model=model, vae=vae, positive=cur_pos, negative=cur_neg, latent=cur_latent,
+                seed=seed, steps=steps, cfg=cfg, denoise=denoise,
+                sampler_name=sampler_name, scheduler=scheduler,
+                clipseg_text=clipseg_text,
+                reference_image=ref_img, clip_vision=clip_vision,
+            )
+            cur_latent, cur_image = lat_i, img_i
+
+        return (cur_latent, cur_image)

mod/easy/preset_loader.py

@@ -0,0 +1,115 @@
+import os
+from typing import Dict, Tuple
+
+_CACHE: Dict[str, Tuple[float, Dict[str, Dict[str, object]]]] = {}
+
+_MSG_PREFIX = "[MagicNodes][Presets]"
+
+def _root_dir() -> str:
+    # .../MagicNodes/mod/easy -> .../MagicNodes
+    return os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+def _pressets_dir() -> str:
+    return os.path.join(_root_dir(), "pressets")
+
+def _cfg_path(kind: str) -> str:
+    # kind examples: "mg_cade25", "mg_controlfusion"
+    return os.path.join(_pressets_dir(), f"{kind}.cfg")
+
+def _parse_value(raw: str):
+    s = raw.strip()
+    if not s:
+        return ""
+    low = s.lower()
+    if low in ("true", "false"):
+        return low == "true"
+    try:
+        if "." in s or "e" in low:
+            return float(s)
+        return int(s)
+    except Exception:
+        pass
+    # variable substitution
+    s = s.replace("$(ROOT)", _root_dir())
+    if (s.startswith('"') and s.endswith('"')) or (s.startswith("'") and s.endswith("'")):
+        s = s[1:-1]
+    return s
+
+def _load_kind(kind: str) -> Dict[str, Dict[str, object]]:
+    path = _cfg_path(kind)
+    if not os.path.isfile(path):
+        print(f"{_MSG_PREFIX} No configuration file for '{kind}' found; loaded defaults — results may be unpredictable!")
+        return {}
+    try:
+        mtime = os.path.getmtime(path)
+        cached = _CACHE.get(path)
+        if cached and cached[0] == mtime:
+            return cached[1]
+
+        data: Dict[str, Dict[str, object]] = {}
+        cur_section = None
+        with open(path, "r", encoding="utf-8") as f:
+            for ln, line in enumerate(f, start=1):
+                line = line.strip()
+                if not line or line.startswith("#") or line.startswith(";"):
+                    continue
+                if line.startswith("[") and line.endswith("]"):
+                    cur_section = line[1:-1].strip().lower()
+                    data.setdefault(cur_section, {})
+                    continue
+                if ":" in line:
+                    if cur_section is None:
+                        print(f"{_MSG_PREFIX} Parse warning at line {ln}: key outside of any [section]; ignored")
+                        continue
+                    k, v = line.split(":", 1)
+                    key = k.strip()
+                    try:
+                        val = _parse_value(v)
+                    except Exception:
+                        print(f"{_MSG_PREFIX} Missing or invalid parameter '{key}'; this may affect results!")
+                        continue
+                    data[cur_section][key] = val
+                else:
+                    print(f"{_MSG_PREFIX} Unknown line at {ln}: '{line}'; ignored")
+
+        _CACHE[path] = (mtime, data)
+        return data
+    except Exception as e:
+        print(f"{_MSG_PREFIX} Failed to read '{path}': {e}. Loaded defaults — results may be unpredictable!")
+        return {}
+
+def get(kind: str, step: str) -> Dict[str, object]:
+    """Return dict of parameters for a given kind and step.
+    step accepts 'Step 1', '1', 'step1', case-insensitive.
+    """
+    data = _load_kind(kind)
+    if not data:
+        return {}
+    label = step.strip().lower().replace(" ", "")
+    if label.startswith("step"):
+        key = label
+    elif label.isdigit():
+        key = f"step{label}"
+    else:
+        key = f"step{label}"
+
+    if key not in data:
+        # Special case: CF is intentionally not applied on Step 1 in this pipeline.
+        # Suppress noisy log for missing 'Step 1' in mg_controlfusion.
+        if kind == "mg_controlfusion" and key in ("step1", "1"):
+            return {}
+        print(f"{_MSG_PREFIX} Preset step '{step}' not found for '{kind}'; using defaults")
+        return {}
+    res = dict(data[key])
+    # Side-effect: when CADE presets are loaded, optionally enable KV pruning in attention
+    try:
+        if kind == "mg_cade25":
+            from .. import mg_sagpu_attention as sa_patch  # local import to avoid cycles
+            kv_enable = bool(res.get("kv_prune_enable", False))
+            kv_keep = float(res.get("kv_keep", 0.85))
+            kv_min = int(res.get("kv_min_tokens", 128)) if "kv_min_tokens" in res else 128
+            if hasattr(sa_patch, "set_kv_prune"):
+                sa_patch.set_kv_prune(kv_enable, kv_keep, kv_min)
+    except Exception:
+        pass
+    return res

mod/hard/__init__.py

@@ -0,0 +1,9 @@
+"""MagicNodes Hard variants
+
+Complex, full‑control node implementations. Imported and registered
+from the package root to expose them under the UI category
+"MagicNodes/Hard".
+"""
+
+# No side effects on import.
+

mod/hard/mg_adaptive.py

@@ -0,0 +1,39 @@
+"""Adaptive sampler helper node (moved to mod/).
+
+Keeps class/key name AdaptiveSamplerHelper for backward compatibility.
+"""
+
+import numpy as np
+from scipy.ndimage import laplace
+
+
+class AdaptiveSamplerHelper:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE", {}),
+                "steps": ("INT", {"default": 20, "min": 1, "max": 200}),
+                "cfg": ("FLOAT", {"default": 7.0, "min": 0.1, "max": 20.0, "step": 0.1}),
+                "denoise": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("INT", "FLOAT", "FLOAT")
+    RETURN_NAMES = ("steps", "cfg", "denoise")
+    FUNCTION = "tune"
+    CATEGORY = "MagicNodes"
+
+    def tune(self, image, steps, cfg, denoise):
+        img = image[0].cpu().numpy()
+        gray = img.mean(axis=2)
+        brightness = float(gray.mean())
+        contrast = float(gray.std())
+        sharpness = float(np.var(laplace(gray)))
+
+        tuned_steps = int(max(1, round(steps + sharpness * 10)))
+        tuned_cfg = float(cfg + contrast * 2.0)
+        tuned_denoise = float(np.clip(denoise + (0.5 - brightness), 0.0, 1.0))
+
+        return (tuned_steps, tuned_cfg, tuned_denoise)
+

mod/hard/mg_cade25.py

@@ -0,0 +1,1864 @@
+"""CADE 2.5: refined adaptive enhancer with reference clean and accumulation override.
+
+Builds on the CADE2 Beta: single clean iteration loop, optional latent-based
+parameter damping, CLIP-based reference clean, and per-run SageAttention
+accumulation override.
+"""
+
+from __future__ import annotations  # moved/renamed module: mg_cade25
+
+import torch
+import os
+import numpy as np
+import torch.nn.functional as F
+
+import nodes
+import comfy.model_management as model_management
+
+from .mg_adaptive import AdaptiveSamplerHelper
+from .mg_zesmart_sampler_v1_1 import _build_hybrid_sigmas
+import comfy.sample as _sample
+import comfy.samplers as _samplers
+import comfy.utils as _utils
+from .mg_upscale_module import MagicUpscaleModule, clear_gpu_and_ram_cache
+from .mg_controlfusion import _build_depth_map as _cf_build_depth_map
+from .mg_ids import IntelligentDetailStabilizer
+from .. import mg_sagpu_attention as sa_patch
+# FDG/NAG experimental paths removed for now; keeping code lean
+
+
+# Lazy CLIPSeg cache
+_CLIPSEG_MODEL = None
+_CLIPSEG_PROC = None
+_CLIPSEG_DEV = "cpu"
+_CLIPSEG_FORCE_CPU = True  # pin CLIPSeg to CPU to avoid device drift
+
+# Per-iteration spatial guidance mask (B,1,H,W) in [0,1]; used by cfg_func when enabled
+# Kept for potential future use with non-ONNX masks (e.g., CLIPSeg/ControlFusion),
+# but not set by this node since ONNX paths are removed.
+CURRENT_ONNX_MASK_BCHW = None
+
+
+# ONNX runtime initialization removed
+
+
+def _try_init_clipseg():
+    """Lazy-load CLIPSeg processor + model and choose device.
+    Returns True on success.
+    """
+    global _CLIPSEG_MODEL, _CLIPSEG_PROC, _CLIPSEG_DEV
+    if (_CLIPSEG_MODEL is not None) and (_CLIPSEG_PROC is not None):
+        return True
+    try:
+        from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation  # type: ignore
+    except Exception:
+        if not globals().get("_CLIPSEG_WARNED", False):
+            print("[CADE2.5][CLIPSeg] transformers not available; CLIPSeg disabled.")
+            globals()["_CLIPSEG_WARNED"] = True
+        return False
+    try:
+        _CLIPSEG_PROC = CLIPSegProcessor.from_pretrained("CIDAS/clipseg-rd64-refined")
+        _CLIPSEG_MODEL = CLIPSegForImageSegmentation.from_pretrained("CIDAS/clipseg-rd64-refined")
+        if _CLIPSEG_FORCE_CPU:
+            _CLIPSEG_DEV = "cpu"
+        else:
+            _CLIPSEG_DEV = "cuda" if torch.cuda.is_available() else "cpu"
+        _CLIPSEG_MODEL = _CLIPSEG_MODEL.to(_CLIPSEG_DEV)
+        _CLIPSEG_MODEL.eval()
+        return True
+    except Exception as e:
+        print(f"[CADE2.5][CLIPSeg] failed to load model: {e}")
+        return False
+
+
+def _clipseg_build_mask(image_bhwc: torch.Tensor,
+                        text: str,
+                        preview: int = 224,
+                        threshold: float = 0.4,
+                        blur: float = 7.0,
+                        dilate: int = 4,
+                        gain: float = 1.0,
+                        ref_embed: torch.Tensor | None = None,
+                        clip_vision=None,
+                        ref_threshold: float = 0.03) -> torch.Tensor | None:
+    """Return BHWC single-channel mask [0,1] from CLIPSeg.
+    - Uses cached CLIPSeg model; gracefully returns None on failure.
+    - Applies optional threshold/blur/dilate and scaling gain.
+    - If clip_vision + ref_embed provided, gates mask by CLIP-Vision distance.
+    """
+    if not text or not isinstance(text, str):
+        return None
+    if not _try_init_clipseg():
+        return None
+    try:
+        # Prepare preview image (CPU PIL)
+        target = int(max(16, min(1024, preview)))
+        img = image_bhwc.detach().to('cpu')
+        B, H, W, C = img.shape
+        x = img[0].movedim(-1, 0).unsqueeze(0)  # 1,C,H,W
+        x = F.interpolate(x, size=(target, target), mode='bilinear', align_corners=False)
+        x = x.clamp(0, 1)
+        arr = (x[0].movedim(0, -1).numpy() * 255.0).astype('uint8')
+        from PIL import Image  # lazy import
+        pil_img = Image.fromarray(arr)
+
+        # Run CLIPSeg
+        import re
+        prompts = [t.strip() for t in re.split(r"[\|,;\n]+", text) if t.strip()]
+        if not prompts:
+            prompts = [text.strip()]
+        prompts = prompts[:8]
+        inputs = _CLIPSEG_PROC(text=prompts, images=[pil_img] * len(prompts), return_tensors="pt")
+        inputs = {k: v.to(_CLIPSEG_DEV) for k, v in inputs.items()}
+        with torch.inference_mode():
+            outputs = _CLIPSEG_MODEL(**inputs)  # type: ignore
+            # logits: [N, H', W'] for N prompts
+            logits = outputs.logits  # [N,h,w]
+            if logits.ndim == 2:
+                logits = logits.unsqueeze(0)
+            prob = torch.sigmoid(logits)  # [N,h,w]
+            # Soft-OR fuse across prompts
+            prob = 1.0 - torch.prod(1.0 - prob.clamp(0, 1), dim=0, keepdim=True)  # [1,h,w]
+            prob = prob.unsqueeze(1)  # [1,1,h,w]
+        # Resize to original image size
+        prob = F.interpolate(prob, size=(H, W), mode='bilinear', align_corners=False)
+        m = prob[0, 0].to(dtype=image_bhwc.dtype, device=image_bhwc.device)
+        # Threshold + blur (approx)
+        if threshold > 0.0:
+            m = torch.where(m > float(threshold), m, torch.zeros_like(m))
+        # Gaussian blur via our depthwise helper
+        if blur > 0.0:
+            rad = int(max(1, min(7, round(blur))))
+            m = _gaussian_blur_nchw(m.unsqueeze(0).unsqueeze(0), sigma=float(max(0.5, blur)), radius=rad)[0, 0]
+        # Dilation via max-pool
+        if int(dilate) > 0:
+            k = int(dilate) * 2 + 1
+            p = int(dilate)
+            m = F.max_pool2d(m.unsqueeze(0).unsqueeze(0), kernel_size=k, stride=1, padding=p)[0, 0]
+        # Optional CLIP-Vision gating by reference distance
+        if (clip_vision is not None) and (ref_embed is not None):
+            try:
+                cur = _encode_clip_image(image_bhwc, clip_vision, target_res=224)
+                dist = _clip_cosine_distance(cur, ref_embed)
+                if dist > float(ref_threshold):
+                    # up to +50% gain if сильно уехали
+                    gate = 1.0 + min(0.5, (dist - float(ref_threshold)) * 4.0)
+                    m = m * gate
+            except Exception:
+                pass
+        m = (m * float(max(0.0, gain))).clamp(0, 1)
+        return m.unsqueeze(0).unsqueeze(-1)  # BHWC with B=1,C=1
+    except Exception as e:
+        if not globals().get("_CLIPSEG_WARNED", False):
+            print(f"[CADE2.5][CLIPSeg] mask failed: {e}")
+            globals()["_CLIPSEG_WARNED"] = True
+        return None
+
+
+def _np_to_mask_tensor(np_map: np.ndarray, out_h: int, out_w: int, device, dtype):
+    """Convert numpy heatmap [H,W] or [1,H,W] or [H,W,1] to BHWC torch mask with B=1 and resize to out_h,out_w."""
+    if np_map.ndim == 3:
+        np_map = np_map.reshape(np_map.shape[-2], np_map.shape[-1]) if (np_map.shape[0] == 1) else np_map.squeeze()
+    if np_map.ndim != 2:
+        return None
+    t = torch.from_numpy(np_map.astype(np.float32))
+    t = t.clamp_min(0.0)
+    t = t.unsqueeze(0).unsqueeze(0)  # B=1,C=1,H,W
+    t = F.interpolate(t, size=(out_h, out_w), mode="bilinear", align_corners=False)
+    t = t.permute(0, 2, 3, 1).to(device=device, dtype=dtype)  # B,H,W,C
+    return t.clamp(0, 1)
+
+
+# --- Firefly/Hot-pixel remover (image space, BHWC in 0..1) ---
+def _median_pool3x3_bhwc(img_bhwc: torch.Tensor) -> torch.Tensor:
+    B, H, W, C = img_bhwc.shape
+    x = img_bhwc.permute(0, 3, 1, 2)  # B,C,H,W
+    unfold = F.unfold(x, kernel_size=3, padding=1)  # B, 9*C, H*W
+    unfold = unfold.view(B, x.shape[1], 9, H, W)    # B,C,9,H,W
+    med, _ = torch.median(unfold, dim=2)            # B,C,H,W
+    return med.permute(0, 2, 3, 1)                  # B,H,W,C
+
+
+def _despeckle_fireflies(img_bhwc: torch.Tensor,
+                         thr: float = 0.985,
+                         max_iso: float | None = None,
+                         grad_gate: float = 0.25) -> torch.Tensor:
+    try:
+        dev, dt = img_bhwc.device, img_bhwc.dtype
+        B, H, W, C = img_bhwc.shape
+        s = max(H, W) / 1024.0
+        k = 3 if s <= 1.1 else (5 if s <= 2.0 else 7)
+        pad = k // 2
+        lum = (0.2126 * img_bhwc[..., 0] + 0.7152 * img_bhwc[..., 1] + 0.0722 * img_bhwc[..., 2]).to(device=dev, dtype=dt)
+        try:
+            q = float(torch.quantile(lum.reshape(-1), 0.9995).item())
+            thr_eff = max(float(thr), min(0.997, q))
+        except Exception:
+            thr_eff = float(thr)
+        # S/V based candidate: white, low saturation
+        R, G, Bc = img_bhwc[..., 0], img_bhwc[..., 1], img_bhwc[..., 2]
+        V = torch.maximum(R, torch.maximum(G, Bc))
+        mi = torch.minimum(R, torch.minimum(G, Bc))
+        S = 1.0 - (mi / (V + 1e-6))
+        v_thr = max(0.985, thr_eff)
+        s_thr = 0.06
+        cand = (V > v_thr) & (S < s_thr)
+        # gradient gate
+        kx = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], device=dev, dtype=dt).view(1, 1, 3, 3)
+        ky = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], device=dev, dtype=dt).view(1, 1, 3, 3)
+        gx = F.conv2d(lum.unsqueeze(1), kx, padding=1)
+        gy = F.conv2d(lum.unsqueeze(1), ky, padding=1)
+        grad = torch.sqrt(gx * gx + gy * gy).squeeze(1)
+        safe_gate = float(grad_gate) * (k / 3.0) ** 0.5
+        cand = cand & (grad < safe_gate)
+        if cand.any():
+            try:
+                import cv2, numpy as _np
+                masks = []
+                for b in range(cand.shape[0]):
+                    msk = cand[b].detach().to('cpu').numpy().astype('uint8') * 255
+                    num, labels, stats, _ = cv2.connectedComponentsWithStats(msk, connectivity=8)
+                    rem = _np.zeros_like(msk, dtype='uint8')
+                    area_max = int(max(3, round((k * k) * 0.6)))
+                    for lbl in range(1, num):
+                        area = stats[lbl, cv2.CC_STAT_AREA]
+                        if area <= area_max:
+                            rem[labels == lbl] = 255
+                    masks.append(torch.from_numpy(rem > 0))
+                rm = torch.stack(masks, dim=0).to(device=dev)
+                rm = rm.unsqueeze(-1)
+                if rm.any():
+                    med = _median_pool3x3_bhwc(img_bhwc)
+                    return torch.where(rm, med, img_bhwc)
+            except Exception:
+                pass
+        # Fallback: density isolation
+        bright = (img_bhwc.min(dim=-1).values > v_thr)
+        dens = F.avg_pool2d(bright.float().unsqueeze(1), k, 1, pad).squeeze(1)
+        max_iso_eff = (2.0 / (k * k)) if (max_iso is None) else float(max_iso)
+        iso = bright & (dens < max_iso_eff) & (grad < safe_gate)
+        if not iso.any():
+            return img_bhwc
+        med = _median_pool3x3_bhwc(img_bhwc)
+        return torch.where(iso.unsqueeze(-1), med, img_bhwc)
+    except Exception:
+        return img_bhwc
+
+
+def _try_heatmap_from_outputs(outputs: list, preview_hw: tuple[int, int]):
+    """Return [H,W] heatmap from model outputs if possible.
+    Supports:
+      - Segmentation logits/probabilities (NCHW / NHWC)
+      - Keypoints arrays -> gaussian disks on points
+      - Bounding boxes -> soft rectangles
+    """
+    if not outputs:
+        return None
+
+    Ht, Wt = int(preview_hw[0]), int(preview_hw[1])
+
+    def to_float(arr):
+        if arr.dtype not in (np.float32, np.float64):
+            try:
+                arr = arr.astype(np.float32)
+            except Exception:
+                return None
+        return arr
+
+    def sigmoid(x):
+        return 1.0 / (1.0 + np.exp(-x))
+
+    # 1) Prefer any spatial heatmap first
+    for out in outputs:
+        try:
+            arr = np.asarray(out)
+        except Exception:
+            continue
+        arr = to_float(arr)
+        if arr is None:
+            continue
+        if arr.ndim == 4:
+            n, a, b, c = arr.shape
+            if c <= 4 and a >= 8 and b >= 8:
+                if c == 1:
+                    hm = sigmoid(arr[0, :, :, 0]) if np.max(np.abs(arr)) > 1.5 else arr[0, :, :, 0]
+                else:
+                    ex = np.exp(arr[0] - np.max(arr[0], axis=-1, keepdims=True))
+                    prob = ex / np.clip(ex.sum(axis=-1, keepdims=True), 1e-6, None)
+                    hm = 1.0 - prob[..., 0] if prob.shape[-1] > 1 else prob[..., 0]
+                return hm.astype(np.float32)
+            else:
+                if a == 1:
+                    ch = arr[0, 0]
+                    hm = sigmoid(ch) if np.max(np.abs(ch)) > 1.5 else ch
+                    return hm.astype(np.float32)
+                else:
+                    x = arr[0]
+                    x = x - np.max(x, axis=0, keepdims=True)
+                    ex = np.exp(x)
+                    prob = ex / np.clip(np.sum(ex, axis=0, keepdims=True), 1e-6, None)
+                    bg = prob[0] if prob.shape[0] > 1 else prob[0]
+                    hm = 1.0 - bg
+                    return hm.astype(np.float32)
+        if arr.ndim == 3:
+            if arr.shape[0] == 1 and arr.shape[1] >= 8 and arr.shape[2] >= 8:
+                return arr[0].astype(np.float32)
+        if arr.ndim == 2 and arr.shape[0] >= 8 and arr.shape[1] >= 8:
+            return arr.astype(np.float32)
+
+    # 2) Try keypoints and boxes
+    heat = np.zeros((Ht, Wt), dtype=np.float32)
+
+    def draw_gaussian(hm, cx, cy, sigma=2.5, amp=1.0):
+        r = max(1, int(3 * sigma))
+        xs = np.arange(-r, r + 1, dtype=np.float32)
+        ys = np.arange(-r, r + 1, dtype=np.float32)
+        gx = np.exp(-(xs**2) / (2 * sigma * sigma))
+        gy = np.exp(-(ys**2) / (2 * sigma * sigma))
+        g = np.outer(gy, gx) * float(amp)
+        x0 = int(round(cx)) - r
+        y0 = int(round(cy)) - r
+        x1 = x0 + g.shape[1]
+        y1 = y0 + g.shape[0]
+        if x1 < 0 or y1 < 0 or x0 >= Wt or y0 >= Ht:
+            return
+        xs0 = max(0, x0)
+        ys0 = max(0, y0)
+        xs1 = min(Wt, x1)
+        ys1 = min(Ht, y1)
+        gx0 = xs0 - x0
+        gy0 = ys0 - y0
+        gx1 = gx0 + (xs1 - xs0)
+        gy1 = gy0 + (ys1 - ys0)
+        hm[ys0:ys1, xs0:xs1] = np.maximum(hm[ys0:ys1, xs0:xs1], g[gy0:gy1, gx0:gx1])
+
+    def draw_soft_rect(hm, x0, y0, x1, y1, edge=3.0):
+        x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1)
+        if x1 <= 0 or y1 <= 0 or x0 >= Wt or y0 >= Ht:
+            return
+        xs0 = max(0, min(x0, x1))
+        ys0 = max(0, min(y0, y1))
+        xs1 = min(Wt, max(x0, x1))
+        ys1 = min(Ht, max(y0, y1))
+        if xs1 - xs0 <= 0 or ys1 - ys0 <= 0:
+            return
+        hm[ys0:ys1, xs0:xs1] = np.maximum(hm[ys0:ys1, xs0:xs1], 1.0)
+        # feather edges with simple blur-like falloff
+        if edge > 0:
+            rad = int(edge)
+            if rad > 0:
+                # quick separable triangle filter
+                line = np.linspace(0, 1, rad + 1, dtype=np.float32)[1:]
+                for d in range(1, rad + 1):
+                    w = line[d - 1]
+                    if ys0 - d >= 0:
+                        hm[ys0 - d:ys0, xs0:xs1] = np.maximum(hm[ys0 - d:ys0, xs0:xs1], w)
+                    if ys1 + d <= Ht:
+                        hm[ys1:ys1 + d, xs0:xs1] = np.maximum(hm[ys1:ys1 + d, xs0:xs1], w)
+                    if xs0 - d >= 0:
+                        hm[max(0, ys0 - d):min(Ht, ys1 + d), xs0 - d:xs0] = np.maximum(
+                            hm[max(0, ys0 - d):min(Ht, ys1 + d), xs0 - d:xs0], w)
+                    if xs1 + d <= Wt:
+                        hm[max(0, ys0 - d):min(Ht, ys1 + d), xs1:xs1 + d] = np.maximum(
+                            hm[max(0, ys0 - d):min(Ht, ys1 + d), xs1:xs1 + d], w)
+
+    # Inspect outputs to find plausible keypoints/boxes
+    for out in outputs:
+        try:
+            arr = np.asarray(out)
+        except Exception:
+            continue
+        arr = to_float(arr)
+        if arr is None:
+            continue
+        a = arr
+        # Squeeze batch dims like [1,N,4] -> [N,4]
+        while a.ndim > 2 and a.shape[0] == 1:
+            a = np.squeeze(a, axis=0)
+        # Keypoints: [N,2] or [N,3] or [K, N, 2/3] (relax N limit; subsample if huge)
+        if a.ndim == 2 and a.shape[-1] in (2, 3):
+            pts = a
+        elif a.ndim == 3 and a.shape[-1] in (2, 3):
+            pts = a.reshape(-1, a.shape[-1])
+        else:
+            pts = None
+        if pts is not None:
+            # Coordinates range guess: if max>1.2 -> absolute; else normalized
+            maxv = float(np.nanmax(np.abs(pts[:, :2]))) if pts.size else 0.0
+            for px, py, *rest in pts:
+                if np.isnan(px) or np.isnan(py):
+                    continue
+                if maxv <= 1.2:
+                    cx = float(px) * (Wt - 1)
+                    cy = float(py) * (Ht - 1)
+                else:
+                    cx = float(px)
+                    cy = float(py)
+                base_sig = max(1.5, min(Ht, Wt) / 128.0)
+                if _ONNX_KPTS_ENABLE:
+                    draw_gaussian(heat, cx, cy, sigma=base_sig * float(_ONNX_KPTS_SIGMA), amp=float(_ONNX_KPTS_GAIN))
+                else:
+                    draw_gaussian(heat, cx, cy, sigma=base_sig)
+            continue
+
+        # Wholebody-style packed keypoints: [N, K*3] with triples (x,y,conf)
+        if _ONNX_KPTS_ENABLE and a.ndim == 2 and a.shape[-1] >= 6 and (a.shape[-1] % 3) == 0:
+            K = a.shape[-1] // 3
+            if K >= 5 and K <= 256:
+                # Guess coordinate range once
+                with np.errstate(invalid='ignore'):
+                    maxv = float(np.nanmax(np.abs(a[:, :2]))) if a.size else 0.0
+                for i in range(a.shape[0]):
+                    row = a[i]
+                    kp = row.reshape(K, 3)
+                    for (px, py, pc) in kp:
+                        if np.isnan(px) or np.isnan(py):
+                            continue
+                        if np.isfinite(pc) and pc < float(_ONNX_KPTS_CONF):
+                            continue
+                        if maxv <= 1.2:
+                            cx = float(px) * (Wt - 1)
+                            cy = float(py) * (Ht - 1)
+                        else:
+                            cx = float(px)
+                            cy = float(py)
+                        base_sig = max(1.0, min(Ht, Wt) / 128.0)
+                        draw_gaussian(heat, cx, cy, sigma=base_sig * float(_ONNX_KPTS_SIGMA), amp=float(_ONNX_KPTS_GAIN))
+                continue
+        # Boxes: [N,4+] (x0,y0,x1,y1) or [N, (x,y,w,h, [conf, ...])]; relax N limit (handle YOLO-style outputs)
+        if a.ndim == 2 and a.shape[-1] >= 4:
+            boxes = a
+        elif a.ndim == 3 and a.shape[-1] >= 4:
+            # choose the smallest first two dims as N
+            if a.shape[0] == 1:
+                boxes = a.reshape(-1, a.shape[-1])
+            else:
+                boxes = a.reshape(-1, a.shape[-1])
+        else:
+            boxes = None
+        if boxes is not None:
+            # Optional score gating (try to find a confidence column)
+            score = None
+            if boxes.shape[-1] >= 6:
+                score = boxes[:, 4]
+                # if classes follow, mix in best class prob
+                try:
+                    score = score * np.max(boxes[:, 5:], axis=-1)
+                except Exception:
+                    pass
+            elif boxes.shape[-1] == 5:
+                score = boxes[:, 4]
+            # Keep top-K by score if available
+            if score is not None:
+                try:
+                    order = np.argsort(-score)
+                    keep = order[: min(64, order.shape[0])]
+                    boxes = boxes[keep]
+                    score = score[keep]
+                except Exception:
+                    score = None
+
+            xy = boxes[:, :4]
+            maxv = float(np.nanmax(np.abs(xy))) if xy.size else 0.0
+            if maxv <= 1.2:
+                x0 = xy[:, 0] * (Wt - 1)
+                y0 = xy[:, 1] * (Ht - 1)
+                x1 = xy[:, 2] * (Wt - 1)
+                y1 = xy[:, 3] * (Ht - 1)
+            else:
+                x0, y0, x1, y1 = xy[:, 0], xy[:, 1], xy[:, 2], xy[:, 3]
+            # Heuristic: if many boxes are inverted, treat as [x,y,w,h]
+            invalid = np.sum((x1 <= x0) | (y1 <= y0))
+            if invalid > 0.5 * x0.shape[0]:
+                x, y, w, h = x0, y0, x1, y1
+                x0 = x - w * 0.5
+                y0 = y - h * 0.5
+                x1 = x + w * 0.5
+                y1 = y + h * 0.5
+            for i in range(x0.shape[0]):
+                if score is not None and np.isfinite(score[i]) and score[i] < 0.2:
+                    continue
+                draw_soft_rect(heat, x0[i], y0[i], x1[i], y1[i], edge=3.0)
+
+            # Embedded keypoints in YOLO-style rows: try to parse trailing triples (x,y,conf)
+            if _ONNX_KPTS_ENABLE and boxes.shape[-1] > 6:
+                D = boxes.shape[-1]
+                for i in range(boxes.shape[0]):
+                    row = boxes[i]
+                    parsed = False
+                    # try [xyxy, conf, cls, kpts] or [xyxy, conf, kpts] or [xyxy, kpts]
+                    for offset in (6, 5, 4):
+                        t = D - offset
+                        if t >= 6 and t % 3 == 0:
+                            k = t // 3
+                            kp = row[offset:offset + 3 * k].reshape(k, 3)
+                            parsed = True
+                            break
+                    if not parsed:
+                        continue
+                    for (px, py, pc) in kp:
+                        if np.isnan(px) or np.isnan(py):
+                            continue
+                        if pc < float(_ONNX_KPTS_CONF):
+                            continue
+                        if maxv <= 1.2:
+                            cx = float(px) * (Wt - 1)
+                            cy = float(py) * (Ht - 1)
+                        else:
+                            cx = float(px)
+                            cy = float(py)
+                        base_sig = max(1.0, min(Ht, Wt) / 128.0)
+                        draw_gaussian(heat, cx, cy, sigma=base_sig * float(_ONNX_KPTS_SIGMA), amp=float(_ONNX_KPTS_GAIN))
+
+    if heat.max() > 0:
+        heat = np.clip(heat, 0.0, 1.0)
+        return heat
+    return None
+
+
+def _onnx_build_mask(image_bhwc: torch.Tensor, preview: int, sensitivity: float, models_dir: str, anomaly_gain: float = 1.0) -> torch.Tensor:
+    """Deprecated: ONNX path removed. Returns zero mask of input size."""
+    B, H, W, C = image_bhwc.shape
+    return torch.zeros((B, H, W, 1), device=image_bhwc.device, dtype=image_bhwc.dtype)
+    if not _try_init_onnx(models_dir):
+        return torch.zeros((image_bhwc.shape[0], image_bhwc.shape[1], image_bhwc.shape[2], 1), device=image_bhwc.device, dtype=image_bhwc.dtype)
+
+    if not _ONNX_SESS:
+        return torch.zeros((image_bhwc.shape[0], image_bhwc.shape[1], image_bhwc.shape[2], 1), device=image_bhwc.device, dtype=image_bhwc.dtype)
+
+    B, H, W, C = image_bhwc.shape
+    device = image_bhwc.device
+    dtype = image_bhwc.dtype
+
+    # Process per-batch image
+    masks = []
+    img_cpu = image_bhwc.detach().to('cpu')
+    for b in range(B):
+        masks_b = []
+        # Prepare input resized square preview
+        target = int(max(16, min(1024, preview)))
+        xb = img_cpu[b].movedim(-1, 0).unsqueeze(0)  # 1,C,H,W
+        x_stretch = F.interpolate(xb, size=(target, target), mode='bilinear', align_corners=False).clamp(0, 1)
+        x_letter = _letterbox_nchw(xb, target).clamp(0, 1)
+        # Try four variants: stretch RGB, letterbox RGB, stretch BGR, letterbox BGR
+        variants = [
+            ("stretch-RGB", x_stretch),
+            ("letterbox-RGB", x_letter),
+            ("stretch-BGR", x_stretch[:, [2, 1, 0], :, :]),
+            ("letterbox-BGR", x_letter[:, [2, 1, 0], :, :]),
+        ]
+        if _ONNX_DEBUG:
+            try:
+                print(f"[CADE2.5][ONNX] Build mask for image[{b}] -> preview {target}x{target}")
+            except Exception:
+                pass
+
+        for name, sess in list(_ONNX_SESS.items()):
+            try:
+                inputs = sess.get_inputs()
+                if not inputs:
+                    continue
+                in_name = inputs[0].name
+                in_shape = inputs[0].shape if hasattr(inputs[0], 'shape') else None
+                # Choose layout automatically based on the presence of channel dim=3
+                if isinstance(in_shape, (list, tuple)) and len(in_shape) == 4:
+                    dim_vals = []
+                    for d in in_shape:
+                        try:
+                            dim_vals.append(int(d))
+                        except Exception:
+                            dim_vals.append(-1)
+                    if dim_vals[-1] == 3:
+                        layout = "NHWC"
+                    else:
+                        layout = "NCHW"
+                else:
+                    layout = "NCHW?"
+                if _ONNX_DEBUG:
+                    try:
+                        print(f"[CADE2.5][ONNX] Model '{name}' in_shape={in_shape} layout={layout}")
+                    except Exception:
+                        pass
+                # Try multiple input variants and scales
+                hm = None
+                chosen = None
+                for vname, vx in variants:
+                    if layout.startswith("NHWC"):
+                        xin = vx.permute(0, 2, 3, 1)
+                    else:
+                        xin = vx
+                    for scale in (1.0, 255.0):
+                        inp = (xin * float(scale)).numpy().astype(np.float32)
+                        feed = {in_name: inp}
+                        outs = sess.run(None, feed)
+                        if _ONNX_DEBUG:
+                            try:
+                                shapes = []
+                                for o in outs:
+                                    try:
+                                        shapes.append(tuple(np.asarray(o).shape))
+                                    except Exception:
+                                        shapes.append("?")
+                                print(f"[CADE2.5][ONNX] '{name}' {vname} scale={scale} -> outs shapes {shapes}")
+                            except Exception:
+                                pass
+                        hm = _try_heatmap_from_outputs(outs, (target, target))
+                        if _ONNX_DEBUG:
+                            try:
+                                if hm is None:
+                                    print(f"[CADE2.5][ONNX] '{name}' {vname} scale={scale}: no spatial heatmap detected")
+                                else:
+                                    print(f"[CADE2.5][ONNX] '{name}' {vname} scale={scale}: heat stats min={np.min(hm):.4f} max={np.max(hm):.4f} mean={np.mean(hm):.4f}")
+                            except Exception:
+                                pass
+                        if hm is not None and np.max(hm) > 0:
+                            chosen = (vname, scale)
+                            break
+                    if hm is not None and np.max(hm) > 0:
+                        break
+                if hm is None:
+                    continue
+                # Scale by sensitivity and optional anomaly gain
+                gain = float(max(0.0, sensitivity))
+                if 'anomaly' in name.lower():
+                    gain *= float(max(0.0, anomaly_gain))
+                hm = np.clip(hm * gain, 0.0, 1.0)
+                tmask = _np_to_mask_tensor(hm, H, W, device, dtype)
+                if tmask is not None:
+                    masks_b.append(tmask)
+                    if _ONNX_DEBUG:
+                        try:
+                            area = float(tmask.movedim(-1,1).mean().item())
+                            if chosen is not None:
+                                vname, scale = chosen
+                                print(f"[CADE2.5][ONNX] '{name}' via {vname} x{scale} area={area:.4f}")
+                            else:
+                                print(f"[CADE2.5][ONNX] '{name}' contribution area={area:.4f}")
+                        except Exception:
+                            pass
+            except Exception:
+                # Ignore failing models
+                continue
+        if not masks_b:
+            masks.append(torch.zeros((1, H, W, 1), device=device, dtype=dtype))
+        else:
+            # Soft-OR fusion: 1 - prod(1 - m)
+            stack = torch.stack([masks_b[i] for i in range(len(masks_b))], dim=0)  # M,1,H,W,1? actually B dims kept as 1
+            fused = 1.0 - torch.prod(1.0 - stack.clamp(0, 1), dim=0)
+            # Light smoothing via bilinear down/up (anti alias)
+            ch = fused.permute(0, 3, 1, 2)  # B=1,C=1,H,W
+            dd = F.interpolate(ch, scale_factor=0.5, mode='bilinear', align_corners=False, recompute_scale_factor=False)
+            uu = F.interpolate(dd, size=(H, W), mode='bilinear', align_corners=False)
+            fused = uu.permute(0, 2, 3, 1).clamp(0, 1)
+            if _ONNX_DEBUG:
+                try:
+                    area = float(fused.movedim(-1,1).mean().item())
+                    print(f"[CADE2.5][ONNX] Fused area (image[{b}])={area:.4f}")
+                except Exception:
+                    pass
+            masks.append(fused)
+
+    return torch.cat(masks, dim=0)
+
+def _sampler_names():
+    try:
+        import comfy.samplers
+        return comfy.samplers.KSampler.SAMPLERS
+    except Exception:
+        return ["euler"]
+
+
+def _scheduler_names():
+    try:
+        import comfy.samplers
+        scheds = list(comfy.samplers.KSampler.SCHEDULERS)
+        if "MGHybrid" not in scheds:
+            scheds.append("MGHybrid")
+        return scheds
+    except Exception:
+        return ["normal", "MGHybrid"]
+
+
+def safe_decode(vae, lat, tile=512, ovlp=64):
+    h, w = lat["samples"].shape[-2:]
+    if min(h, w) > 1024:
+        # Increase overlap for ultra-hires to reduce seam artifacts
+        ov = 128 if max(h, w) > 2048 else ovlp
+        return vae.decode_tiled(lat["samples"], tile_x=tile, tile_y=tile, overlap=ov)
+    return vae.decode(lat["samples"])
+
+
+def safe_encode(vae, img, tile=512, ovlp=64):
+    import math, torch.nn.functional as F
+    h, w = img.shape[1:3]
+    try:
+        stride = int(vae.spacial_compression_decode())
+    except Exception:
+        stride = 8
+    if stride <= 0:
+        stride = 8
+    def _align_up(x, s):
+        return int(((x + s - 1) // s) * s)
+    Ht = _align_up(h, stride)
+    Wt = _align_up(w, stride)
+    x = img
+    if (Ht != h) or (Wt != w):
+        # pad on bottom/right using replicate to avoid black borders
+        pad_h = Ht - h
+        pad_w = Wt - w
+        x_nchw = img.movedim(-1, 1)
+        x_nchw = F.pad(x_nchw, (0, pad_w, 0, pad_h), mode='replicate')
+        x = x_nchw.movedim(1, -1)
+    if min(Ht, Wt) > 1024:
+        ov = 128 if max(Ht, Wt) > 2048 else ovlp
+        return vae.encode_tiled(x[:, :, :, :3], tile_x=tile, tile_y=tile, overlap=ov)
+    return vae.encode(x[:, :, :, :3])
+    
+
+
+def _gaussian_kernel(kernel_size: int, sigma: float, device=None):
+    x, y = torch.meshgrid(
+        torch.linspace(-1, 1, kernel_size, device=device),
+        torch.linspace(-1, 1, kernel_size, device=device),
+        indexing="ij",
+    )
+    d = torch.sqrt(x * x + y * y)
+    g = torch.exp(-(d * d) / (2.0 * sigma * sigma))
+    return g / g.sum()
+
+
+def _sharpen_image(image: torch.Tensor, sharpen_radius: int, sigma: float, alpha: float):
+    if sharpen_radius == 0:
+        return (image,)
+
+    image = image.to(model_management.get_torch_device())
+    batch_size, height, width, channels = image.shape
+
+    kernel_size = sharpen_radius * 2 + 1
+    kernel = _gaussian_kernel(kernel_size, sigma, device=image.device) * -(alpha * 10)
+    kernel = kernel.to(dtype=image.dtype)
+    center = kernel_size // 2
+    kernel[center, center] = kernel[center, center] - kernel.sum() + 1.0
+    kernel = kernel.repeat(channels, 1, 1).unsqueeze(1)
+
+    tensor_image = image.permute(0, 3, 1, 2)
+    tensor_image = F.pad(tensor_image, (sharpen_radius, sharpen_radius, sharpen_radius, sharpen_radius), 'reflect')
+    sharpened = F.conv2d(tensor_image, kernel, padding=center, groups=channels)[:, :, sharpen_radius:-sharpen_radius, sharpen_radius:-sharpen_radius]
+    sharpened = sharpened.permute(0, 2, 3, 1)
+
+    result = torch.clamp(sharpened, 0, 1)
+    return (result.to(model_management.intermediate_device()),)
+
+
+def _encode_clip_image(image: torch.Tensor, clip_vision, target_res: int) -> torch.Tensor:
+    # image: BHWC in [0,1]
+    img = image.movedim(-1, 1)  # BCHW
+    img = F.interpolate(img, size=(target_res, target_res), mode="bilinear", align_corners=False)
+    img = (img * 2.0) - 1.0
+    embeds = clip_vision.encode_image(img)["image_embeds"]
+    embeds = F.normalize(embeds, dim=-1)
+    return embeds
+
+
+def _clip_cosine_distance(a: torch.Tensor, b: torch.Tensor) -> float:
+    if a.shape != b.shape:
+        m = min(a.shape[0], b.shape[0])
+        a = a[:m]
+        b = b[:m]
+    sim = (a * b).sum(dim=-1).mean().clamp(-1.0, 1.0).item()
+    return 1.0 - sim
+
+
+def _gaussian_blur_nchw(x: torch.Tensor, sigma: float = 1.0, radius: int = 1) -> torch.Tensor:
+    """Lightweight depthwise Gaussian blur for NCHW tensors.
+    Uses reflect padding and a normalized kernel built by _gaussian_kernel.
+    """
+    if radius <= 0:
+        return x
+    ksz = radius * 2 + 1
+    kernel = _gaussian_kernel(ksz, sigma, device=x.device).to(dtype=x.dtype)
+    kernel = kernel.repeat(x.shape[1], 1, 1).unsqueeze(1)  # [C,1,K,K]
+    x_pad = F.pad(x, (radius, radius, radius, radius), mode='reflect')
+    y = F.conv2d(x_pad, kernel, padding=0, groups=x.shape[1])
+    return y
+
+
+def _letterbox_nchw(x: torch.Tensor, target: int, pad_val: float = 114.0 / 255.0) -> torch.Tensor:
+    """Letterbox a BCHW tensor to target x target with constant padding (YOLO-style).
+    Preserves aspect ratio, centers content, pads with pad_val.
+    """
+    if x.ndim != 4:
+        return F.interpolate(x, size=(target, target), mode='bilinear', align_corners=False)
+    b, c, h, w = x.shape
+    if h == 0 or w == 0:
+        return F.interpolate(x, size=(target, target), mode='bilinear', align_corners=False)
+    r = float(min(target / max(1, h), target / max(1, w)))
+    nh = max(1, int(round(h * r)))
+    nw = max(1, int(round(w * r)))
+    y = F.interpolate(x, size=(nh, nw), mode='bilinear', align_corners=False)
+    pt = (target - nh) // 2
+    pb = target - nh - pt
+    pl = (target - nw) // 2
+    pr = target - nw - pl
+    if pt < 0 or pb < 0 or pl < 0 or pr < 0:
+        # Fallback stretch if rounding went weird
+        return F.interpolate(x, size=(target, target), mode='bilinear', align_corners=False)
+    return F.pad(y, (pl, pr, pt, pb), mode='constant', value=float(pad_val))
+
+
+def _fdg_filter(delta: torch.Tensor, low_gain: float, high_gain: float, sigma: float = 1.0, radius: int = 1) -> torch.Tensor:
+    """Frequency-Decoupled Guidance: split delta into low/high bands and reweight.
+    delta: [B,C,H,W]
+    """
+    low = _gaussian_blur_nchw(delta, sigma=sigma, radius=radius)
+    high = delta - low
+    return low * float(low_gain) + high * float(high_gain)
+
+
+def _fdg_split_three(delta: torch.Tensor,
+                     sigma_lo: float = 0.8,
+                     sigma_hi: float = 2.0,
+                     radius: int = 1) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Tri-band split: returns (low, mid, high) for NCHW delta.
+    low  = G(sigma_hi)
+    mid  = G(sigma_lo) - G(sigma_hi)
+    high = delta - G(sigma_lo)
+    """
+    sig_lo = float(max(0.05, sigma_lo))
+    sig_hi = float(max(sig_lo + 1e-3, sigma_hi))
+    blur_lo = _gaussian_blur_nchw(delta, sigma=sig_lo, radius=radius)
+    blur_hi = _gaussian_blur_nchw(delta, sigma=sig_hi, radius=radius)
+    low = blur_hi
+    mid = blur_lo - blur_hi
+    high = delta - blur_lo
+    return low, mid, high
+
+
+def _fdg_energy_fraction(delta: torch.Tensor, sigma: float = 1.0, radius: int = 1) -> torch.Tensor:
+    """Return fraction of high-frequency energy: E_high / (E_low + E_high)."""
+    low = _gaussian_blur_nchw(delta, sigma=sigma, radius=radius)
+    high = delta - low
+    e_low = (low * low).mean(dim=(1, 2, 3), keepdim=True)
+    e_high = (high * high).mean(dim=(1, 2, 3), keepdim=True)
+    frac = e_high / (e_low + e_high + 1e-8)
+    return frac
+
+
+def _wrap_model_with_guidance(model, guidance_mode: str, rescale_multiplier: float, momentum_beta: float, cfg_curve: float, perp_damp: float, use_zero_init: bool=False, zero_init_steps: int=0, fdg_low: float = 0.6, fdg_high: float = 1.3, fdg_sigma: float = 1.0, ze_zero_steps: int = 0, ze_adaptive: bool = False, ze_r_switch_hi: float = 0.6, ze_r_switch_lo: float = 0.45, fdg_low_adaptive: bool = False, fdg_low_min: float = 0.45, fdg_low_max: float = 0.7, fdg_ema_beta: float = 0.8, use_local_mask: bool = False, mask_inside: float = 1.0, mask_outside: float = 1.0,
+                                midfreq_enable: bool = False, midfreq_gain: float = 0.0, midfreq_sigma_lo: float = 0.8, midfreq_sigma_hi: float = 2.0,
+                                mahiro_plus_enable: bool = False, mahiro_plus_strength: float = 0.5,
+                                eps_scale_enable: bool = False, eps_scale: float = 0.0):
+
+    """Clone model and attach a cfg mixing function implementing RescaleCFG/FDG, CFGZero*/FD, or hybrid ZeResFDG.
+    guidance_mode: 'default' | 'RescaleCFG' | 'RescaleFDG' | 'CFGZero*' | 'CFGZeroFD' | 'ZeResFDG'
+    """
+    if guidance_mode == "default":
+        return model
+    m = model.clone()
+
+    # State for momentum and sigma normalization across steps
+    prev_delta = {"t": None}
+    sigma_seen = {"max": None, "min": None}
+    # Spectral switching/adaptive low state
+    spec_state = {"ema": None, "mode": "CFGZeroFD"}
+
+    def cfg_func(args):
+        cond = args["cond"]
+        uncond = args["uncond"]
+        cond_scale = args["cond_scale"]
+        sigma = args.get("sigma", None)
+        x_orig = args.get("input", None)
+
+        # Local spatial gain from CURRENT_ONNX_MASK_BCHW, resized to cond spatial size
+        def _local_gain_for(hw):
+            if not bool(use_local_mask):
+                return None
+            m = globals().get("CURRENT_ONNX_MASK_BCHW", None)
+            if m is None:
+                return None
+            try:
+                Ht, Wt = int(hw[0]), int(hw[1])
+                g = m.to(device=cond.device, dtype=cond.dtype)
+                if g.shape[-2] != Ht or g.shape[-1] != Wt:
+                    g = F.interpolate(g, size=(Ht, Wt), mode='bilinear', align_corners=False)
+                gi = float(mask_inside)
+                go = float(mask_outside)
+                gain = g * gi + (1.0 - g) * go  # [B,1,H,W]
+                return gain
+            except Exception:
+                return None
+
+        # Allow hybrid switch per-step
+        mode = guidance_mode
+        if guidance_mode == "ZeResFDG":
+            if bool(ze_adaptive):
+                try:
+                    delta_raw = args["cond"] - args["uncond"]
+                    frac_b = _fdg_energy_fraction(delta_raw, sigma=float(fdg_sigma), radius=1)  # [B,1,1,1]
+                    frac = float(frac_b.mean().clamp(0.0, 1.0).item())
+                except Exception:
+                    frac = 0.0
+                if spec_state["ema"] is None:
+                    spec_state["ema"] = frac
+                else:
+                    beta = float(max(0.0, min(0.99, fdg_ema_beta)))
+                    spec_state["ema"] = beta * float(spec_state["ema"]) + (1.0 - beta) * frac
+                r = float(spec_state["ema"])
+                # Hysteresis: switch up/down with two thresholds
+                if spec_state["mode"] == "CFGZeroFD" and r >= float(ze_r_switch_hi):
+                    spec_state["mode"] = "RescaleFDG"
+                elif spec_state["mode"] == "RescaleFDG" and r <= float(ze_r_switch_lo):
+                    spec_state["mode"] = "CFGZeroFD"
+                mode = spec_state["mode"]
+            else:
+                try:
+                    sigmas = args["model_options"]["transformer_options"]["sample_sigmas"]
+                    matched_idx = (sigmas == args["timestep"][0]).nonzero()
+                    if len(matched_idx) > 0:
+                        current_idx = matched_idx.item()
+                    else:
+                        current_idx = 0
+                except Exception:
+                    current_idx = 0
+                mode = "CFGZeroFD" if current_idx <= int(ze_zero_steps) else "RescaleFDG"
+
+        if mode in ("CFGZero*", "CFGZeroFD"):
+            # Optional zero-init for the first N steps
+            if use_zero_init and "model_options" in args and args.get("timestep") is not None:
+                try:
+                    sigmas = args["model_options"]["transformer_options"]["sample_sigmas"]
+                    matched_idx = (sigmas == args["timestep"][0]).nonzero()
+                    if len(matched_idx) > 0:
+                        current_idx = matched_idx.item()
+                    else:
+                        # fallback lookup
+                        current_idx = 0
+                    if current_idx <= int(zero_init_steps):
+                        return cond * 0.0
+                except Exception:
+                    pass
+            # Project cond onto uncond subspace (batch-wise alpha)
+            bsz = cond.shape[0]
+            pos_flat = cond.view(bsz, -1)
+            neg_flat = uncond.view(bsz, -1)
+            dot = torch.sum(pos_flat * neg_flat, dim=1, keepdim=True)
+            denom = torch.sum(neg_flat * neg_flat, dim=1, keepdim=True).clamp_min(1e-8)
+            alpha = (dot / denom).view(bsz, *([1] * (cond.dim() - 1)))
+            resid = cond - uncond * alpha
+            # Adaptive low gain if enabled
+            low_gain_eff = float(fdg_low)
+            if bool(fdg_low_adaptive) and spec_state["ema"] is not None:
+                s = float(spec_state["ema"])  # 0..1 fraction of high-frequency energy
+                lmin = float(fdg_low_min)
+                lmax = float(fdg_low_max)
+                low_gain_eff = max(0.0, min(2.0, lmin + (lmax - lmin) * s))
+            if mode == "CFGZeroFD":
+                resid = _fdg_filter(resid, low_gain=low_gain_eff, high_gain=fdg_high, sigma=float(fdg_sigma), radius=1)
+            # Apply local spatial gain to residual guidance
+            lg = _local_gain_for((cond.shape[-2], cond.shape[-1]))
+            if lg is not None:
+                resid = resid * lg.expand(-1, resid.shape[1], -1, -1)
+            noise_pred = uncond * alpha + cond_scale * resid
+            return noise_pred
+
+        # RescaleCFG/FDG path (with optional momentum/perp damping and S-curve shaping)
+        delta = cond - uncond
+        pd = float(max(0.0, min(1.0, perp_damp)))
+        if pd > 0.0 and (prev_delta["t"] is not None) and (prev_delta["t"].shape == delta.shape):
+            prev = prev_delta["t"]
+            denom = (prev * prev).sum(dim=(1,2,3), keepdim=True).clamp_min(1e-6)
+            coeff = ((delta * prev).sum(dim=(1,2,3), keepdim=True) / denom)
+            parallel = coeff * prev
+            delta = delta - pd * parallel
+        beta = float(max(0.0, min(0.95, momentum_beta)))
+        if beta > 0.0:
+            if prev_delta["t"] is None or prev_delta["t"].shape != delta.shape:
+                prev_delta["t"] = delta.detach()
+            delta = (1.0 - beta) * delta + beta * prev_delta["t"]
+            prev_delta["t"] = delta.detach()
+            cond = uncond + delta
+        else:
+            prev_delta["t"] = delta.detach()
+        # After momentum: optionally apply FDG and rebuild cond
+        if mode == "RescaleFDG":
+            # Adaptive low gain if enabled
+            low_gain_eff = float(fdg_low)
+            if bool(fdg_low_adaptive) and spec_state["ema"] is not None:
+                s = float(spec_state["ema"])  # 0..1
+                lmin = float(fdg_low_min)
+                lmax = float(fdg_low_max)
+                low_gain_eff = max(0.0, min(2.0, lmin + (lmax - lmin) * s))
+            delta_fdg = _fdg_filter(delta, low_gain=low_gain_eff, high_gain=fdg_high, sigma=float(fdg_sigma), radius=1)
+            # Optional mid-frequency emphasis (band-pass) blended on top
+            if bool(midfreq_enable) and abs(float(midfreq_gain)) > 1e-6:
+                lo, mid, hi = _fdg_split_three(delta, sigma_lo=float(midfreq_sigma_lo), sigma_hi=float(midfreq_sigma_hi), radius=1)
+                # Respect local mask gain if present
+                lg = _local_gain_for((cond.shape[-2], cond.shape[-1]))
+                if lg is not None:
+                    mid = mid * lg.expand(-1, mid.shape[1], -1, -1)
+                delta_fdg = delta_fdg + float(midfreq_gain) * mid
+            lg = _local_gain_for((cond.shape[-2], cond.shape[-1]))
+            if lg is not None:
+                delta_fdg = delta_fdg * lg.expand(-1, delta_fdg.shape[1], -1, -1)
+            cond = uncond + delta_fdg
+        else:
+            lg = _local_gain_for((cond.shape[-2], cond.shape[-1]))
+            if lg is not None:
+                delta = delta * lg.expand(-1, delta.shape[1], -1, -1)
+            cond = uncond + delta
+
+        cond_scale_eff = cond_scale
+        if cfg_curve > 0.0 and (sigma is not None):
+            s = sigma
+            if s.ndim > 1:
+                s = s.flatten()
+            s_max = float(torch.max(s).item())
+            s_min = float(torch.min(s).item())
+            if sigma_seen["max"] is None:
+                sigma_seen["max"] = s_max
+                sigma_seen["min"] = s_min
+            else:
+                sigma_seen["max"] = max(sigma_seen["max"], s_max)
+                sigma_seen["min"] = min(sigma_seen["min"], s_min)
+            lo = max(1e-6, sigma_seen["min"])
+            hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
+            t = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
+            t = t.clamp(0.0, 1.0)
+            k = 6.0 * float(cfg_curve)
+            s_curve = torch.tanh((t - 0.5) * k)
+            gain = 1.0 + 0.15 * float(cfg_curve) * s_curve
+            if gain.ndim > 0:
+                gain = gain.mean().item()
+            cond_scale_eff = cond_scale * float(gain)
+
+        # Epsilon scaling (exposure bias correction): early steps get multiplier closer to (1 + eps_scale)
+        eps_mult = 1.0
+        if bool(eps_scale_enable) and (sigma is not None):
+            try:
+                s = sigma
+                if s.ndim > 1:
+                    s = s.flatten()
+                s_max = float(torch.max(s).item())
+                s_min = float(torch.min(s).item())
+                if sigma_seen["max"] is None:
+                    sigma_seen["max"] = s_max
+                    sigma_seen["min"] = s_min
+                else:
+                    sigma_seen["max"] = max(sigma_seen["max"], s_max)
+                    sigma_seen["min"] = min(sigma_seen["min"], s_min)
+                lo = max(1e-6, sigma_seen["min"])
+                hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
+                t_lin = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
+                t_lin = t_lin.clamp(0.0, 1.0)
+                w_early = (1.0 - t_lin).mean().item()
+                eps_mult = float(1.0 + eps_scale * w_early)
+            except Exception:
+                eps_mult = float(1.0 + eps_scale)
+
+        if sigma is None or x_orig is None:
+            return uncond + cond_scale * (cond - uncond)
+        sigma_ = sigma.view(sigma.shape[:1] + (1,) * (cond.ndim - 1))
+        x = x_orig / (sigma_ * sigma_ + 1.0)
+        v_cond = ((x - (x_orig - cond)) * (sigma_ ** 2 + 1.0) ** 0.5) / (sigma_)
+        v_uncond = ((x - (x_orig - uncond)) * (sigma_ ** 2 + 1.0) ** 0.5) / (sigma_)
+        v_cfg = v_uncond + cond_scale_eff * (v_cond - v_uncond)
+        ro_pos = torch.std(v_cond, dim=(1, 2, 3), keepdim=True)
+        ro_cfg = torch.std(v_cfg, dim=(1, 2, 3), keepdim=True).clamp_min(1e-6)
+        v_rescaled = v_cfg * (ro_pos / ro_cfg)
+        v_final = float(rescale_multiplier) * v_rescaled + (1.0 - float(rescale_multiplier)) * v_cfg
+        eps = x_orig - (x - (v_final * eps_mult) * sigma_ / (sigma_ * sigma_ + 1.0) ** 0.5)
+        return eps
+
+    m.set_model_sampler_cfg_function(cfg_func, disable_cfg1_optimization=True)
+
+    # Optional directional post-mix inspired by Mahiro (global, no ONNX)
+    if bool(mahiro_plus_enable):
+        s_clamp = float(max(0.0, min(1.0, mahiro_plus_strength)))
+        mb_state = {"ema": None}
+
+        def _sqrt_sign(x: torch.Tensor) -> torch.Tensor:
+            return x.sign() * torch.sqrt(x.abs().clamp_min(1e-12))
+
+        def _hp_split(x: torch.Tensor, radius: int = 1, sigma: float = 1.0):
+            low = _gaussian_blur_nchw(x, sigma=sigma, radius=radius)
+            high = x - low
+            return low, high
+
+        def _sched_gain(args) -> float:
+            # Gentle mid-steps boost: triangle peak at the middle of schedule
+            try:
+                sigmas = args["model_options"]["transformer_options"]["sample_sigmas"]
+                idx_t = args.get("timestep", None)
+                if idx_t is None:
+                    return 1.0
+                matched = (sigmas == idx_t[0]).nonzero()
+                if len(matched) == 0:
+                    return 1.0
+                i = float(matched.item())
+                n = float(sigmas.shape[0])
+                if n <= 1:
+                    return 1.0
+                phase = i / (n - 1.0)
+                tri = 1.0 - abs(2.0 * phase - 1.0)
+                return float(0.6 + 0.4 * tri)  # 0.6 at edges -> 1.0 mid
+            except Exception:
+                return 1.0
+
+        def mahiro_plus_post(args):
+            try:
+                scale = args.get('cond_scale', 1.0)
+                cond_p = args['cond_denoised']
+                uncond_p = args['uncond_denoised']
+                cfg = args['denoised']
+
+                # Orthogonalize positive to negative direction (batch-wise)
+                bsz = cond_p.shape[0]
+                pos_flat = cond_p.view(bsz, -1)
+                neg_flat = uncond_p.view(bsz, -1)
+                dot = torch.sum(pos_flat * neg_flat, dim=1, keepdim=True)
+                denom = torch.sum(neg_flat * neg_flat, dim=1, keepdim=True).clamp_min(1e-8)
+                alpha = (dot / denom).view(bsz, *([1] * (cond_p.dim() - 1)))
+                c_orth = cond_p - uncond_p * alpha
+
+                leap_raw = float(scale) * c_orth
+                # Light high-pass emphasis for detail, protect low-frequency tone
+                low, high = _hp_split(leap_raw, radius=1, sigma=1.0)
+                leap = 0.35 * low + 1.00 * high
+
+                # Directional agreement (global cosine over flattened dims)
+                u_leap = float(scale) * uncond_p
+                merge = 0.5 * (leap + cfg)
+                nu = _sqrt_sign(u_leap).flatten(1)
+                nm = _sqrt_sign(merge).flatten(1)
+                sim = F.cosine_similarity(nu, nm, dim=1).mean()
+                a = torch.clamp((sim + 1.0) * 0.5, 0.0, 1.0)
+                # Small EMA for temporal smoothness
+                if mb_state["ema"] is None:
+                    mb_state["ema"] = float(a)
+                else:
+                    mb_state["ema"] = 0.8 * float(mb_state["ema"]) + 0.2 * float(a)
+                a_eff = float(mb_state["ema"])
+                w = a_eff * cfg + (1.0 - a_eff) * leap
+
+                # Gentle energy match to CFG
+                dims = tuple(range(1, w.dim()))
+                ro_w = torch.std(w, dim=dims, keepdim=True).clamp_min(1e-6)
+                ro_cfg = torch.std(cfg, dim=dims, keepdim=True).clamp_min(1e-6)
+                w_res = w * (ro_cfg / ro_w)
+
+                # Schedule gain over steps (mid stronger)
+                s_eff = s_clamp * _sched_gain(args)
+                out = (1.0 - s_eff) * cfg + s_eff * w_res
+                return out
+            except Exception:
+                return args['denoised']
+
+        try:
+            m.set_model_sampler_post_cfg_function(mahiro_plus_post)
+        except Exception:
+            pass
+
+    # Quantile clamp stabilizer (per-sample): soft range limit for denoised tensor
+    # Always on, under the hood. Helps prevent rare exploding values.
+    def _qclamp_post(args):
+        try:
+            x = args.get("denoised", None)
+            if x is None:
+                return args["denoised"]
+            dt = x.dtype
+            xf = x.to(dtype=torch.float32)
+            B = xf.shape[0]
+            lo_q, hi_q = 0.001, 0.999
+            out = []
+            for i in range(B):
+                t = xf[i].reshape(-1)
+                try:
+                    lo = torch.quantile(t, lo_q)
+                    hi = torch.quantile(t, hi_q)
+                except Exception:
+                    n = t.numel()
+                    k_lo = max(1, int(n * lo_q))
+                    k_hi = max(1, int(n * hi_q))
+                    lo = torch.kthvalue(t, k_lo).values
+                    hi = torch.kthvalue(t, k_hi).values
+                out.append(xf[i].clamp(min=lo, max=hi))
+            y = torch.stack(out, dim=0).to(dtype=dt)
+            return y
+        except Exception:
+            return args["denoised"]
+
+    try:
+        m.set_model_sampler_post_cfg_function(_qclamp_post)
+    except Exception:
+        pass
+
+    return m
+
+
+# --- AQClip-Lite: adaptive soft quantile clipping in latent space (tile overlap) ---
+@torch.no_grad()
+def _aqclip_lite(latent_bchw: torch.Tensor,
+                 tile: int = 32,
+                 stride: int = 16,
+                 alpha: float = 2.0,
+                 ema_state: dict | None = None,
+                 ema_beta: float = 0.8,
+                 H_override: torch.Tensor | None = None) -> tuple[torch.Tensor, dict]:
+    try:
+        z = latent_bchw
+        B, C, H, W = z.shape
+        dev, dt = z.device, z.dtype
+        ksize = max(8, min(int(tile), min(H, W)))
+        kstride = max(1, min(int(stride), ksize))
+
+        # Confidence map: attention entropy override or gradient proxy
+        if (H_override is not None) and isinstance(H_override, torch.Tensor):
+            hsrc = H_override.to(device=dev, dtype=dt)
+            if hsrc.dim() == 3:
+                hsrc = hsrc.unsqueeze(1)
+            gpool = F.avg_pool2d(hsrc, kernel_size=ksize, stride=kstride)
+        else:
+            zm = z.mean(dim=1, keepdim=True)
+            kx = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], device=dev, dtype=dt).view(1, 1, 3, 3)
+            ky = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], device=dev, dtype=dt).view(1, 1, 3, 3)
+            gx = F.conv2d(zm, kx, padding=1)
+            gy = F.conv2d(zm, ky, padding=1)
+            gmag = torch.sqrt(gx * gx + gy * gy)
+            gpool = F.avg_pool2d(gmag, kernel_size=ksize, stride=kstride)
+        gmax = gpool.amax(dim=(2, 3), keepdim=True).clamp_min(1e-6)
+        Hn = (gpool / gmax).squeeze(1)  # B,h',w'
+        L = Hn.shape[1] * Hn.shape[2]
+        Hn = Hn.reshape(B, L)
+
+        # Map confidence -> quantiles
+        ql = 0.5 * (Hn ** 2)
+        qh = 1.0 - 0.5 * ((1.0 - Hn) ** 2)
+
+        # Per-tile mean/std
+        unf = F.unfold(z, kernel_size=ksize, stride=kstride)  # B, C*ksize*ksize, L
+        M = unf.shape[1]
+        mu = unf.mean(dim=1).to(torch.float32)  # B,L
+        var = (unf.to(torch.float32) - mu.unsqueeze(1)).pow(2).mean(dim=1)
+        sigma = (var + 1e-12).sqrt()
+
+        # Normal inverse approximation: ndtri(q) = sqrt(2)*erfinv(2q-1)
+        def _ndtri(q: torch.Tensor) -> torch.Tensor:
+            return (2.0 ** 0.5) * torch.special.erfinv(q.mul(2.0).sub(1.0).clamp(-0.999999, 0.999999))
+        k_neg = _ndtri(ql).abs()
+        k_pos = _ndtri(qh).abs()
+        lo = mu - k_neg * sigma
+        hi = mu + k_pos * sigma
+
+        # EMA smooth
+        if ema_state is None:
+            ema_state = {}
+        b = float(max(0.0, min(0.999, ema_beta)))
+        if 'lo' in ema_state and 'hi' in ema_state and ema_state['lo'].shape == lo.shape:
+            lo = b * ema_state['lo'] + (1.0 - b) * lo
+            hi = b * ema_state['hi'] + (1.0 - b) * hi
+        ema_state['lo'] = lo.detach()
+        ema_state['hi'] = hi.detach()
+
+        # Soft tanh clip (vectorized in unfold domain)
+        mid = (lo + hi) * 0.5
+        half = (hi - lo) * 0.5
+        half = half.clamp_min(1e-6)
+        y = (unf.to(torch.float32) - mid.unsqueeze(1)) / half.unsqueeze(1)
+        y = torch.tanh(float(alpha) * y)
+        unf_clipped = mid.unsqueeze(1) + half.unsqueeze(1) * y
+        unf_clipped = unf_clipped.to(dt)
+
+        out = F.fold(unf_clipped, output_size=(H, W), kernel_size=ksize, stride=kstride)
+        ones = torch.ones((B, M, L), device=dev, dtype=dt)
+        w = F.fold(ones, output_size=(H, W), kernel_size=ksize, stride=kstride).clamp_min(1e-6)
+        out = out / w
+        return out, ema_state
+    except Exception:
+        return latent_bchw, (ema_state or {})
+
+class ComfyAdaptiveDetailEnhancer25:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("MODEL", {}),
+                "positive": ("CONDITIONING", {}),
+                "negative": ("CONDITIONING", {}),
+                "vae": ("VAE", {}),
+                "latent": ("LATENT", {}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF}),
+                "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step": 0.1}),
+                "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.0001}),
+                "sampler_name": (_sampler_names(), {"default": _sampler_names()[0]}),
+                "scheduler": (_scheduler_names(), {"default": _scheduler_names()[0]}),
+                "iterations": ("INT", {"default": 1, "min": 1, "max": 1000}),
+                "steps_delta": ("FLOAT", {"default": 0.0, "min": -1000.0, "max": 1000.0, "step": 0.01}),
+                "cfg_delta": ("FLOAT", {"default": 0.0, "min": -100.0, "max": 100.0, "step": 0.01}),
+                "denoise_delta": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.0001}),
+                "apply_sharpen": ("BOOLEAN", {"default": False}),
+                "apply_upscale": ("BOOLEAN", {"default": False}),
+                "apply_ids": ("BOOLEAN", {"default": False}),
+                "clip_clean": ("BOOLEAN", {"default": False}),
+                "ids_strength": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "upscale_method": (MagicUpscaleModule.upscale_methods, {"default": "lanczos"}),
+                "scale_by": ("FLOAT", {"default": 1.2, "min": 1.0, "max": 8.0, "step": 0.01}),
+                "scale_delta": ("FLOAT", {"default": 0.0, "min": -8.0, "max": 8.0, "step": 0.01}),
+                "noise_offset": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0.5, "step": 0.01}),
+                "threshold": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "RMS latent drift threshold (smaller = more damping)."}),
+            },
+            "optional": {
+                "Sharpnes_strenght": ("FLOAT", {"default": 0.300, "min": 0.0, "max": 1.0, "step": 0.001}),
+                "latent_compare": ("BOOLEAN", {"default": False, "tooltip": "Use latent drift to gently damp params (safer than overwriting latents)."}),
+                "accumulation": (["default", "fp32+fp16", "fp32+fp32"], {"default": "default", "tooltip": "Override SageAttention PV accumulation mode for this node run."}),
+                "reference_clean": ("BOOLEAN", {"default": False, "tooltip": "Use CLIP-Vision similarity to a reference image to stabilize output."}),
+                "reference_image": ("IMAGE", {}),
+                "clip_vision": ("CLIP_VISION", {}),
+                "ref_preview": ("INT", {"default": 224, "min": 64, "max": 512, "step": 16}),
+                "ref_threshold": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 0.2, "step": 0.001}),
+                "ref_cooldown": ("INT", {"default": 1, "min": 1, "max": 8}),
+
+                # ONNX detectors removed
+
+                # Guidance controls
+                "guidance_mode": (["default", "RescaleCFG", "RescaleFDG", "CFGZero*", "CFGZeroFD", "ZeResFDG"], {"default": "RescaleCFG", "tooltip": "Rescale (stable), RescaleFDG (spectral), CFGZero*, CFGZeroFD, or hybrid ZeResFDG."}),
+                "rescale_multiplier": ("FLOAT", {"default": 0.7, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Blend between rescaled and plain CFG (like comfy RescaleCFG)."}),
+                "momentum_beta": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0.95, "step": 0.01, "tooltip": "EMA momentum in eps-space for (cond-uncond), 0 to disable."}),
+                "cfg_curve": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "S-curve shaping of cond_scale across steps (0=flat)."}),
+                "perp_damp": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Remove a small portion of the component parallel to previous delta (0-1)."}),
+
+                # NAG (Normalized Attention Guidance) toggles
+                "use_nag": ("BOOLEAN", {"default": False, "tooltip": "Apply NAG inside CrossAttention (positive branch) during this node."}),
+                "nag_scale": ("FLOAT", {"default": 4.0, "min": 0.0, "max": 50.0, "step": 0.1}),
+                "nag_tau": ("FLOAT", {"default": 2.5, "min": 0.0, "max": 10.0, "step": 0.01}),
+                "nag_alpha": ("FLOAT", {"default": 0.25, "min": 0.0, "max": 1.0, "step": 0.01}),
+
+                # AQClip-Lite (adaptive latent clipping)
+                "aqclip_enable": ("BOOLEAN", {"default": False, "tooltip": "Adaptive soft tile clipping with overlap (reduces spikes on uncertain regions)."}),
+                "aq_tile": ("INT", {"default": 32, "min": 8, "max": 128, "step": 1}),
+                "aq_stride": ("INT", {"default": 16, "min": 4, "max": 128, "step": 1}),
+                "aq_alpha": ("FLOAT", {"default": 2.0, "min": 0.5, "max": 4.0, "step": 0.1}),
+                "aq_ema_beta": ("FLOAT", {"default": 0.8, "min": 0.0, "max": 0.99, "step": 0.01}),
+                "aq_attn": ("BOOLEAN", {"default": False, "tooltip": "Use attention entropy as confidence (requires patched attention)."}),
+
+                # CFGZero* extras
+                "use_zero_init": ("BOOLEAN", {"default": False, "tooltip": "For CFGZero*, zero out first few steps."}),
+                "zero_init_steps": ("INT", {"default": 0, "min": 0, "max": 20, "step": 1}),
+
+                # FDG controls (placed last to avoid reordering existing fields)
+                "fdg_low": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 2.0, "step": 0.01, "tooltip": "Low-frequency gain (<1 to restrain masses)."}),
+                "fdg_high": ("FLOAT", {"default": 1.3, "min": 0.5, "max": 2.5, "step": 0.01, "tooltip": "High-frequency gain (>1 to boost details)."}),
+                "fdg_sigma": ("FLOAT", {"default": 1.0, "min": 0.5, "max": 2.5, "step": 0.05, "tooltip": "Gaussian sigma for FDG low-pass split."}),
+                "ze_res_zero_steps": ("INT", {"default": 2, "min": 0, "max": 20, "step": 1, "tooltip": "Hybrid: number of initial steps to use CFGZeroFD before switching to RescaleFDG."}),
+
+                # Adaptive spectral switch (ZeRes) and adaptive low gain
+                "ze_adaptive": ("BOOLEAN", {"default": False, "tooltip": "Enable spectral switch: CFGZeroFD, RescaleFDG by HF/LF ratio (EMA)."}),
+                "ze_r_switch_hi": ("FLOAT", {"default": 0.60, "min": 0.10, "max": 0.95, "step": 0.01, "tooltip": "Switch to RescaleFDG when EMA fraction of high-frequency."}),
+                "ze_r_switch_lo": ("FLOAT", {"default": 0.45, "min": 0.05, "max": 0.90, "step": 0.01, "tooltip": "Switch back to CFGZeroFD when EMA fraction (hysteresis)."}),
+                "fdg_low_adaptive": ("BOOLEAN", {"default": False, "tooltip": "Adapt fdg_low by HF fraction (EMA)."}),
+                "fdg_low_min": ("FLOAT", {"default": 0.45, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Lower bound for adaptive fdg_low."}),
+                "fdg_low_max": ("FLOAT", {"default": 0.70, "min": 0.0, "max": 2.0, "step": 0.01, "tooltip": "Upper bound for adaptive fdg_low."}),
+                "fdg_ema_beta": ("FLOAT", {"default": 0.80, "min": 0.0, "max": 0.99, "step": 0.01, "tooltip": "EMA smoothing for spectral ratio (higher = smoother)."}),
+
+                # ONNX local guidance and keypoints removed
+
+                # Muse Blend global directional post-mix
+                "muse_blend": ("BOOLEAN", {"default": False, "tooltip": "Enable Muse Blend (Mahiro+): gentle directional positive blend (global)."}),
+                "muse_blend_strength": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Overall influence of Muse Blend over baseline CFG (0..1)."}),
+                # Exposure Bias Correction (epsilon scaling)
+                "eps_scale_enable": ("BOOLEAN", {"default": False, "tooltip": "Exposure Bias Correction: scale predicted noise early in schedule."}),
+                "eps_scale": ("FLOAT", {"default": 0.005, "min": -1.0, "max": 1.0, "step": 0.0005, "tooltip": "Signed scaling near early steps (recommended ~0.0045; use with care)."}),
+                # KV pruning (self-attention speedup)
+                "kv_prune_enable": ("BOOLEAN", {"default": False, "tooltip": "Speed: prune K/V tokens in self-attention by energy (safe on hi-res blocks)."}),
+                "kv_keep": ("FLOAT", {"default": 0.85, "min": 0.5, "max": 1.0, "step": 0.01, "tooltip": "Fraction of tokens to keep when KV pruning is enabled."}),
+                "kv_min_tokens": ("INT", {"default": 128, "min": 1, "max": 16384, "step": 1, "tooltip": "Minimum sequence length to apply KV pruning."}),
+                "clipseg_enable": ("BOOLEAN", {"default": False, "tooltip": "Use CLIPSeg to build a text-driven mask (e.g., 'eyes | hands | face')."}),
+                "clipseg_text": ("STRING", {"default": "", "multiline": False}),
+                "clipseg_preview": ("INT", {"default": 224, "min": 64, "max": 512, "step": 16}),
+                "clipseg_threshold": ("FLOAT", {"default": 0.40, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "clipseg_blur": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 15.0, "step": 0.1}),
+                "clipseg_dilate": ("INT", {"default": 4, "min": 0, "max": 10, "step": 1}),
+                "clipseg_gain": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01}),
+                "clipseg_blend": (["fuse", "replace", "intersect"], {"default": "fuse", "tooltip": "How to combine CLIPSeg with any pre-mask (if present)."}),
+                "clipseg_ref_gate": ("BOOLEAN", {"default": False, "tooltip": "If reference provided, boost mask when far from reference (CLIP-Vision)."}),
+                "clipseg_ref_threshold": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 0.2, "step": 0.001}),
+
+                # Polish mode (final hi-res refinement)
+                "polish_enable": ("BOOLEAN", {"default": False, "tooltip": "Polish: keep low-frequency shape from reference while allowing high-frequency details to refine."}),
+                "polish_keep_low": ("FLOAT", {"default": 0.4, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "How much low-frequency (global form, lighting) to take from reference image (0=use current, 1=use reference)."}),
+                "polish_edge_lock": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Edge lock strength: protects edges from sideways drift (0=off, 1=strong)."}),
+                "polish_sigma": ("FLOAT", {"default": 1.0, "min": 0.3, "max": 3.0, "step": 0.1, "tooltip": "Radius for low/high split: larger keeps bigger shapes as 'low' (global form)."}),
+                "polish_start_after": ("INT", {"default": 1, "min": 0, "max": 3, "step": 1, "tooltip": "Enable polish after N iterations (0=immediately)."}),
+                "polish_keep_low_ramp": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Starting share of low-frequency mix; ramps to polish_keep_low over remaining iterations."}),
+
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "IMAGE", "INT", "FLOAT", "FLOAT", "IMAGE")
+    RETURN_NAMES = ("LATENT", "IMAGE", "steps", "cfg", "denoise", "mask_preview")
+    FUNCTION = "apply_cade2"
+    CATEGORY = "MagicNodes"
+
+    def apply_cade2(self, model, vae, positive, negative, latent, seed, steps, cfg, denoise,
+                     sampler_name, scheduler, noise_offset, iterations=1, steps_delta=0.0,
+                     cfg_delta=0.0, denoise_delta=0.0, apply_sharpen=False,
+                     apply_upscale=False, apply_ids=False, clip_clean=False,
+                     ids_strength=0.5, upscale_method="lanczos", scale_by=1.2, scale_delta=0.0,
+                     Sharpnes_strenght=0.300, threshold=0.03, latent_compare=False, accumulation="default",
+                     reference_clean=False, reference_image=None, clip_vision=None, ref_preview=224, ref_threshold=0.03, ref_cooldown=1,
+                     guidance_mode="RescaleCFG", rescale_multiplier=0.7, momentum_beta=0.0, cfg_curve=0.0, perp_damp=0.0,
+                      use_nag=False, nag_scale=4.0, nag_tau=2.5, nag_alpha=0.25,
+                      aqclip_enable=False, aq_tile=32, aq_stride=16, aq_alpha=2.0, aq_ema_beta=0.8, aq_attn=False,
+                     use_zero_init=False, zero_init_steps=0,
+                     fdg_low=0.6, fdg_high=1.3, fdg_sigma=1.0, ze_res_zero_steps=2,
+                     ze_adaptive=False, ze_r_switch_hi=0.60, ze_r_switch_lo=0.45,
+                     fdg_low_adaptive=False, fdg_low_min=0.45, fdg_low_max=0.70, fdg_ema_beta=0.80,
+                     muse_blend=False, muse_blend_strength=0.5,
+                     eps_scale_enable=False, eps_scale=0.005,
+                     clipseg_enable=False, clipseg_text="", clipseg_preview=224,
+                     clipseg_threshold=0.40, clipseg_blur=7.0, clipseg_dilate=4,
+                     clipseg_gain=1.0, clipseg_blend="fuse", clipseg_ref_gate=False, clipseg_ref_threshold=0.03,
+                     polish_enable=False, polish_keep_low=0.4, polish_edge_lock=0.2, polish_sigma=1.0,
+                     polish_start_after=1, polish_keep_low_ramp=0.2,
+                     kv_prune_enable=False, kv_keep=0.85, kv_min_tokens=128):
+        # Hard reset of any sticky globals from prior runs
+        try:
+            global CURRENT_ONNX_MASK_BCHW
+            CURRENT_ONNX_MASK_BCHW = None
+        except Exception:
+            pass
+
+        image = safe_decode(vae, latent)
+
+        tuned_steps, tuned_cfg, tuned_denoise = AdaptiveSamplerHelper().tune(
+            image, steps, cfg, denoise)
+
+        current_steps = tuned_steps
+        current_cfg = tuned_cfg
+        current_denoise = tuned_denoise
+        # Work on a detached copy to avoid mutating input latent across runs
+        try:
+            current_latent = {"samples": latent["samples"].clone()}
+        except Exception:
+            current_latent = {"samples": latent["samples"]}
+        current_scale = scale_by
+
+        ref_embed = None
+        if reference_clean and (clip_vision is not None) and (reference_image is not None):
+            try:
+                ref_embed = _encode_clip_image(reference_image, clip_vision, ref_preview)
+            except Exception:
+                ref_embed = None
+
+        # Pre-disable any lingering NAG patch from previous runs and set PV accumulation for this node
+        try:
+            sa_patch.enable_crossattention_nag_patch(False)
+        except Exception:
+            pass
+        prev_accum = getattr(sa_patch, "CURRENT_PV_ACCUM", None)
+        sa_patch.CURRENT_PV_ACCUM = None if accumulation == "default" else accumulation
+        # Enable NAG patch if requested
+        try:
+            sa_patch.enable_crossattention_nag_patch(bool(use_nag), float(nag_scale), float(nag_tau), float(nag_alpha))
+        except Exception:
+            pass
+
+        # Enable attention-entropy probe for AQClip Attn-mode
+        try:
+            if hasattr(sa_patch, "enable_attention_entropy_capture"):
+                sa_patch.enable_attention_entropy_capture(bool(aq_attn), max_tokens=1024, max_heads=4)
+        except Exception:
+            pass
+
+        # Visual separation and start marker
+        try:
+            print("")
+        except Exception:
+            pass
+        try:
+            print("\x1b[32m==== Starting main job ====\x1b[0m")
+        except Exception:
+            pass
+
+        # Enable KV pruning (self-attention) if requested
+        try:
+            if hasattr(sa_patch, "set_kv_prune"):
+                sa_patch.set_kv_prune(bool(kv_prune_enable), float(kv_keep), int(kv_min_tokens))
+        except Exception:
+            pass
+
+        mask_last = None
+        try:
+            with torch.inference_mode():
+                __cade_noop = 0  # ensure non-empty with-block
+
+                # Preflight: reset sticky state and build external masks once (CPU-pinned)
+                try:
+                    CURRENT_ONNX_MASK_BCHW = None
+                except Exception:
+                    pass
+                pre_mask = None
+                pre_area = 0.0
+                # ONNX mask removed
+                # Build CLIPSeg mask once
+                if bool(clipseg_enable) and isinstance(clipseg_text, str) and clipseg_text.strip() != "":
+                    try:
+                        cmask = _clipseg_build_mask(image, clipseg_text, int(clipseg_preview), float(clipseg_threshold), float(clipseg_blur), int(clipseg_dilate), float(clipseg_gain), None, None, float(clipseg_ref_threshold))
+                        if cmask is not None:
+                            if pre_mask is None:
+                                pre_mask = cmask
+                            else:
+                                if clipseg_blend == "replace":
+                                    pre_mask = cmask
+                                elif clipseg_blend == "intersect":
+                                    pre_mask = (pre_mask * cmask).clamp(0, 1)
+                                else:
+                                    pre_mask = (1.0 - (1.0 - pre_mask) * (1.0 - cmask)).clamp(0, 1)
+                    except Exception:
+                        pass
+                if pre_mask is not None:
+                    mask_last = pre_mask
+                    om = pre_mask.movedim(-1, 1)
+                    pre_area = float(om.mean().item())
+                    # One-time gentle damping from area
+                    try:
+                        if pre_area > 0.005:
+                            damp = 1.0 - min(0.10, 0.02 + pre_area * 0.08)
+                            current_denoise = max(0.10, current_denoise * damp)
+                            current_cfg = max(1.0, current_cfg * (1.0 - 0.005))
+                    except Exception:
+                        pass
+                # Compact status
+                try:
+                    clipseg_status = "on" if bool(clipseg_enable) and isinstance(clipseg_text, str) and clipseg_text.strip() != "" else "off"
+                    # print preflight info only in debug sessions (muted by default)
+                    if False:
+                        print(f"[CADE2.5][preflight] clipseg={clipseg_status} device={'cpu' if _CLIPSEG_FORCE_CPU else _CLIPSEG_DEV} mask_area={pre_area:.4f}")
+                except Exception:
+                    pass
+                # Freeze per-iteration external mask rebuild
+                clipseg_enable = False
+                # Depth gate cache for micro-detail injection (reuse per resolution)
+                depth_gate_cache = {"size": None, "mask": None}
+                for i in range(iterations):
+                    if i % 2 == 0:
+                        clear_gpu_and_ram_cache()
+
+                    prev_samples = current_latent["samples"].clone().detach()
+
+                    iter_seed = seed + i * 7777
+                    if noise_offset > 0.0:
+                        # Deterministic noise offset tied to iter_seed
+                        fade = 1.0 - (i / max(1, iterations))
+                        try:
+                            gen = torch.Generator(device='cpu')
+                        except Exception:
+                            gen = torch.Generator()
+                        gen.manual_seed(int(iter_seed) & 0xFFFFFFFF)
+                        eps = torch.randn(
+                            size=current_latent["samples"].shape,
+                            dtype=current_latent["samples"].dtype,
+                            device='cpu',
+                            generator=gen,
+                        ).to(current_latent["samples"].device)
+                        current_latent["samples"] += (noise_offset * fade) * eps
+
+                    # ONNX pre-sampling detectors removed
+
+                    # CLIPSeg mask (optional)
+                    try:
+                        if bool(clipseg_enable) and isinstance(clipseg_text, str) and clipseg_text.strip() != "":
+                            img_prev2 = safe_decode(vae, current_latent)
+                            cmask = _clipseg_build_mask(img_prev2, clipseg_text, int(clipseg_preview), float(clipseg_threshold), float(clipseg_blur), int(clipseg_dilate), float(clipseg_gain), ref_embed if bool(clipseg_ref_gate) else None, clip_vision if bool(clipseg_ref_gate) else None, float(clipseg_ref_threshold))
+                            if cmask is not None:
+                                if mask_last is None:
+                                    fused = cmask
+                                else:
+                                    if clipseg_blend == "replace":
+                                        fused = cmask
+                                    elif clipseg_blend == "intersect":
+                                        fused = (mask_last * cmask).clamp(0, 1)
+                                    else:
+                                        fused = (1.0 - (1.0 - mask_last) * (1.0 - cmask)).clamp(0, 1)
+                                mask_last = fused
+                                om = fused.movedim(-1, 1)
+                                area = float(om.mean().item())
+                                if area > 0.005:
+                                    damp = 1.0 - min(0.10, 0.02 + area * 0.08)
+                                    current_denoise = max(0.10, current_denoise * damp)
+                                    current_cfg = max(1.0, current_cfg * (1.0 - 0.005))
+                                # No local guidance toggles here; keep optional mask hook clear
+                    except Exception:
+                        pass
+
+                    # Guidance override via cfg_func when requested
+                    sampler_model = _wrap_model_with_guidance(
+                          model, guidance_mode, rescale_multiplier, momentum_beta, cfg_curve, perp_damp,
+                          use_zero_init=bool(use_zero_init), zero_init_steps=int(zero_init_steps),
+                          fdg_low=float(fdg_low), fdg_high=float(fdg_high), fdg_sigma=float(fdg_sigma),
+                          midfreq_enable=bool(False), midfreq_gain=float(0.0), midfreq_sigma_lo=float(0.8), midfreq_sigma_hi=float(2.0),
+                          ze_zero_steps=int(ze_res_zero_steps),
+                          ze_adaptive=bool(ze_adaptive), ze_r_switch_hi=float(ze_r_switch_hi), ze_r_switch_lo=float(ze_r_switch_lo),
+                          fdg_low_adaptive=bool(fdg_low_adaptive), fdg_low_min=float(fdg_low_min), fdg_low_max=float(fdg_low_max), fdg_ema_beta=float(fdg_ema_beta),
+                          mahiro_plus_enable=bool(muse_blend), mahiro_plus_strength=float(muse_blend_strength),
+                          eps_scale_enable=bool(eps_scale_enable), eps_scale=float(eps_scale)
+                      )
+
+                    if str(scheduler) == "MGHybrid":
+                        try:
+                            # Build ZeSmart hybrid sigmas with safe defaults
+                            sigmas = _build_hybrid_sigmas(
+                                sampler_model, int(current_steps), str(sampler_name), "hybrid",
+                                mix=0.5, denoise=float(current_denoise), jitter=0.01, seed=int(iter_seed),
+                                _debug=False, tail_smooth=0.15, auto_hybrid_tail=True, auto_tail_strength=0.4,
+                            )
+                            # Prepare latent + noise like in MG_ZeSmartSampler
+                            lat_img = current_latent["samples"]
+                            lat_img = _sample.fix_empty_latent_channels(sampler_model, lat_img)
+                            batch_inds = current_latent.get("batch_index", None)
+                            noise = _sample.prepare_noise(lat_img, int(iter_seed), batch_inds)
+                            noise_mask = current_latent.get("noise_mask", None)
+                            callback = nodes.latent_preview.prepare_callback(sampler_model, int(current_steps))
+                            disable_pbar = not _utils.PROGRESS_BAR_ENABLED
+                            sampler_obj = _samplers.sampler_object(str(sampler_name))
+                            samples = _sample.sample_custom(
+                                sampler_model, noise, float(current_cfg), sampler_obj, sigmas,
+                                positive, negative, lat_img,
+                                noise_mask=noise_mask, callback=callback,
+                                disable_pbar=disable_pbar, seed=int(iter_seed)
+                            )
+                            current_latent = {**current_latent}
+                            current_latent["samples"] = samples
+                        except Exception as e:
+                            # Fallback to original path if anything goes wrong
+                            print(f"[CADE2.5][MGHybrid] fallback to common_ksampler due to: {e}")
+                            current_latent, = nodes.common_ksampler(
+                                sampler_model, iter_seed, int(current_steps), current_cfg, sampler_name, _scheduler_names()[0],
+                                positive, negative, current_latent, denoise=current_denoise)
+                    else:
+                        current_latent, = nodes.common_ksampler(
+                            sampler_model, iter_seed, int(current_steps), current_cfg, sampler_name, scheduler,
+                            positive, negative, current_latent, denoise=current_denoise)
+
+                    if bool(latent_compare):
+                        latent_diff = current_latent["samples"] - prev_samples
+                        rms = torch.sqrt(torch.mean(latent_diff * latent_diff))
+                        drift = float(rms.item())
+                        if drift > float(threshold):
+                            overshoot = max(0.0, drift - float(threshold))
+                            damp = 1.0 - min(0.15, overshoot * 2.0)
+                            current_denoise = max(0.20, current_denoise * damp)
+                            cfg_damp = 0.997 if damp > 0.9 else 0.99
+                            current_cfg = max(1.0, current_cfg * cfg_damp)
+
+                    # AQClip-Lite: adaptive soft clipping in latent space (before decode)
+                    try:
+                        if bool(aqclip_enable):
+                            if 'aq_state' not in locals():
+                                aq_state = None
+                            H_override = None
+                            if bool(aq_attn) and hasattr(sa_patch, "get_attention_entropy_map"):
+                                try:
+                                    Hm = sa_patch.get_attention_entropy_map(clear=False)
+                                    if Hm is not None:
+                                        H_override = F.interpolate(Hm, size=(current_latent["samples"].shape[-2], current_latent["samples"].shape[-1]), mode="bilinear", align_corners=False)
+                                except Exception:
+                                    H_override = None
+                            z_new, aq_state = _aqclip_lite(
+                                current_latent["samples"],
+                                tile=int(aq_tile), stride=int(aq_stride),
+                                alpha=float(aq_alpha), ema_state=aq_state, ema_beta=float(aq_ema_beta),
+                                H_override=H_override,
+                            )
+                            current_latent["samples"] = z_new
+                    except Exception:
+                        pass
+
+                    image = safe_decode(vae, current_latent)
+
+                    # Polish mode: keep global form (low frequencies) from reference while letting details refine
+                    if bool(polish_enable) and (i >= int(polish_start_after)):
+                        try:
+                            # Prepare tensors
+                            img = image
+                            ref = reference_image if (reference_image is not None) else img
+                            if ref.shape[1] != img.shape[1] or ref.shape[2] != img.shape[2]:
+                                # resize reference to match current image
+                                ref_n = ref.movedim(-1, 1)
+                                ref_n = F.interpolate(ref_n, size=(img.shape[1], img.shape[2]), mode='bilinear', align_corners=False)
+                                ref = ref_n.movedim(1, -1)
+                            x = img.movedim(-1, 1)
+                            r = ref.movedim(-1, 1)
+                            # Low/high split via Gaussian blur
+                            rad = max(1, int(round(float(polish_sigma) * 2)))
+                            low_x = _gaussian_blur_nchw(x, sigma=float(polish_sigma), radius=rad)
+                            low_r = _gaussian_blur_nchw(r, sigma=float(polish_sigma), radius=rad)
+                            high_x = x - low_x
+                            # Mix low from reference and current with ramp
+                            # a starts from polish_keep_low_ramp and linearly ramps to polish_keep_low over remaining iterations
+                            try:
+                                denom = max(1, int(iterations) - int(polish_start_after))
+                                t = max(0.0, min(1.0, (i - int(polish_start_after)) / denom))
+                            except Exception:
+                                t = 1.0
+                            a0 = float(polish_keep_low_ramp)
+                            at = float(polish_keep_low)
+                            a = a0 + (at - a0) * t
+                            low_mix = low_r * a + low_x * (1.0 - a)
+                            new = low_mix + high_x
+                            # Micro-detail injection on tail: very light HF boost gated by edges+depth
+                            try:
+                                phase = (i + 1) / max(1, int(iterations))
+                                # ramp starts late (>=0.70 of iterations), slightly earlier and wider
+                                ramp = max(0.0, min(1.0, (phase - 0.70) / 0.30))
+                                if ramp > 0.0:
+                                    # fine-scale high-pass
+                                    micro = x - _gaussian_blur_nchw(x, sigma=0.6, radius=1)
+                                    # edge gate: suppress near strong edges to avoid halos
+                                    gray = x.mean(dim=1, keepdim=True)
+                                    sobel_x = torch.tensor([[[-1,0,1],[-2,0,2],[-1,0,1]]], dtype=gray.dtype, device=gray.device).unsqueeze(1)
+                                    sobel_y = torch.tensor([[[-1,-2,-1],[0,0,0],[1,2,1]]], dtype=gray.dtype, device=gray.device).unsqueeze(1)
+                                    gx = F.conv2d(gray, sobel_x, padding=1)
+                                    gy = F.conv2d(gray, sobel_y, padding=1)
+                                    mag = torch.sqrt(gx*gx + gy*gy)
+                                    m_edge = (mag - mag.amin()) / (mag.amax() - mag.amin() + 1e-8)
+                                    g_edge = (1.0 - m_edge).clamp(0.0, 1.0).pow(0.65)  # prefer flats/meso-areas
+                                    # depth gate: prefer nearer surfaces when depth is available
+                                    try:
+                                        sz = (int(img.shape[1]), int(img.shape[2]))
+                                        if depth_gate_cache.get("size") != sz or depth_gate_cache.get("mask") is None:
+                                            model_path = os.path.join(os.path.dirname(__file__), '..', 'depth-anything', 'depth_anything_v2_vitl.pth')
+                                            dm = _cf_build_depth_map(img, res=512, model_path=model_path, hires_mode=True)
+                                            depth_gate_cache = {"size": sz, "mask": dm}
+                                        dm = depth_gate_cache.get("mask")
+                                        if dm is not None:
+                                            g_depth = (dm.movedim(-1, 1).clamp(0,1)) ** 1.35
+                                        else:
+                                            g_depth = torch.ones_like(g_edge)
+                                    except Exception:
+                                        g_depth = torch.ones_like(g_edge)
+                                    g = (g_edge * g_depth).clamp(0.0, 1.0)
+                                    micro_boost = 0.018 * ramp  # very gentle, slightly higher
+                                    new = new + micro_boost * (micro * g)
+                            except Exception:
+                                pass
+                            # Edge-lock: protect edges from drift by biasing toward low_mix along edges
+                            el = float(polish_edge_lock)
+                            if el > 1e-6:
+                                # Sobel edge magnitude on grayscale
+                                gray = x.mean(dim=1, keepdim=True)
+                                sobel_x = torch.tensor([[[-1,0,1],[-2,0,2],[-1,0,1]]], dtype=gray.dtype, device=gray.device).unsqueeze(1)
+                                sobel_y = torch.tensor([[[-1,-2,-1],[0,0,0],[1,2,1]]], dtype=gray.dtype, device=gray.device).unsqueeze(1)
+                                gx = F.conv2d(gray, sobel_x, padding=1)
+                                gy = F.conv2d(gray, sobel_y, padding=1)
+                                mag = torch.sqrt(gx*gx + gy*gy)
+                                m = (mag - mag.amin()) / (mag.amax() - mag.amin() + 1e-8)
+                                # Blend toward low_mix near edges
+                                new = new * (1.0 - el*m) + (low_mix) * (el*m)
+                            img2 = new.movedim(1, -1).clamp(0,1)
+                            # Feed back to latent for next steps
+                            current_latent = {"samples": safe_encode(vae, img2)}
+                            image = img2
+                        except Exception:
+                            pass
+
+                    # ONNX detectors removed
+
+                    if reference_clean and (ref_embed is not None) and (i % max(1, ref_cooldown) == 0):
+                        try:
+                            cur_embed = _encode_clip_image(image, clip_vision, ref_preview)
+                            dist = _clip_cosine_distance(cur_embed, ref_embed)
+                            if dist > ref_threshold:
+                                current_denoise = max(0.10, current_denoise * 0.9)
+                                current_cfg = max(1.0, current_cfg * 0.99)
+                        except Exception:
+                            pass
+
+                    if apply_upscale and current_scale != 1.0:
+                        current_latent, image = MagicUpscaleModule().process_upscale(
+                            current_latent, vae, upscale_method, current_scale)
+                        # After upscale at large sizes, add a tiny HF sprinkle gated by edges+depth
+                        try:
+                            H, W = int(image.shape[1]), int(image.shape[2])
+                            if max(H, W) > 1536:
+                                blur = _gaussian_blur(image, radius=1.0, sigma=0.8)
+                                hf = (image - blur).clamp(-1, 1)
+                                # Edge gate in image space (luma Sobel)
+                                lum = (0.2126 * image[..., 0] + 0.7152 * image[..., 1] + 0.0722 * image[..., 2])
+                                kx = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], device=lum.device, dtype=lum.dtype).view(1, 1, 3, 3)
+                                ky = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], device=lum.device, dtype=lum.dtype).view(1, 1, 3, 3)
+                                g = torch.sqrt(F.conv2d(lum.unsqueeze(1), kx, padding=1)**2 + F.conv2d(lum.unsqueeze(1), ky, padding=1)**2).squeeze(1)
+                                m = (g - g.amin()) / (g.amax() - g.amin() + 1e-8)
+                                g_edge = (1.0 - m).clamp(0,1).pow(0.5).unsqueeze(-1)
+                                # Depth gate (once per resolution)
+                                try:
+                                    sz = (H, W)
+                                    if depth_gate_cache.get("size") != sz or depth_gate_cache.get("mask") is None:
+                                        model_path = os.path.join(os.path.dirname(__file__), '..', 'depth-anything', 'depth_anything_v2_vitl.pth')
+                                        dm = _cf_build_depth_map(image, res=512, model_path=model_path, hires_mode=True)
+                                        depth_gate_cache = {"size": sz, "mask": dm}
+                                    dm = depth_gate_cache.get("mask")
+                                    if dm is not None:
+                                        g_depth = dm.clamp(0,1) ** 1.2
+                                    else:
+                                        g_depth = torch.ones_like(g_edge)
+                                except Exception:
+                                    g_depth = torch.ones_like(g_edge)
+                                g_tot = (g_edge * g_depth).clamp(0,1)
+                                image = (image + 0.045 * hf * g_tot).clamp(0,1)
+                        except Exception:
+                            pass
+                        current_cfg = max(4.0, current_cfg * (1.0 / current_scale))
+                        current_denoise = max(0.15, current_denoise * (1.0 / current_scale))
+
+                    current_steps = max(1, current_steps - steps_delta)
+                    current_cfg = max(0.0, current_cfg - cfg_delta)
+                    current_denoise = max(0.0, current_denoise - denoise_delta)
+                    current_scale = max(1.0, current_scale - scale_delta)
+
+                    if apply_upscale and current_scale != 1.0 and max(image.shape[1:3]) > 1024:
+                        current_latent = {"samples": safe_encode(vae, image)}
+
+        finally:
+            # Always disable NAG patch and clear local mask, even on errors
+            try:
+                sa_patch.enable_crossattention_nag_patch(False)
+            except Exception:
+                pass
+            try:
+                sa_patch.CURRENT_PV_ACCUM = prev_accum
+            except Exception:
+                pass
+            try:
+                CURRENT_ONNX_MASK_BCHW = None
+            except Exception:
+                pass
+
+        if apply_ids:
+            image, = IntelligentDetailStabilizer().stabilize(image, ids_strength)
+
+        if apply_sharpen:
+            image, = _sharpen_image(image, 2, 1.0, Sharpnes_strenght)
+
+        # Mask preview as IMAGE (RGB)
+        if mask_last is None:
+            mask_last = torch.zeros((image.shape[0], image.shape[1], image.shape[2], 1), device=image.device, dtype=image.dtype)
+        onnx_mask_img = mask_last.repeat(1, 1, 1, 3).clamp(0, 1)
+
+        # Final pass: remove isolated hot whites ("fireflies") without touching real edges/highlights
+        try:
+            image = _despeckle_fireflies(image, thr=0.998, max_iso=4.0/9.0, grad_gate=0.15)
+        except Exception:
+            pass
+
+        # Cleanup KV pruning state to avoid leaking into other nodes
+        try:
+            if hasattr(sa_patch, "set_kv_prune"):
+                sa_patch.set_kv_prune(False, 1.0, int(kv_min_tokens))
+        except Exception:
+            pass
+
+        return current_latent, image, int(current_steps), float(current_cfg), float(current_denoise), onnx_mask_img
+
+
+

mod/hard/mg_controlfusion.py

@@ -0,0 +1,519 @@
+import os
+import sys
+import math
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+import comfy.model_management as model_management
+
+
+_DEPTH_INIT = False
+_DEPTH_MODEL = None
+_DEPTH_PROC = None
+
+
+def _insert_aux_path():
+    try:
+        base = os.path.dirname(os.path.dirname(__file__))  # .../custom_nodes
+        aux_root = os.path.join(base, 'comfyui_controlnet_aux')
+        aux_src = os.path.join(aux_root, 'src')
+        for p in (aux_src, aux_root):
+            if os.path.isdir(p) and p not in sys.path:
+                sys.path.insert(0, p)
+    except Exception:
+        pass
+
+
+def _try_init_depth_anything(model_path: str):
+    global _DEPTH_INIT, _DEPTH_MODEL, _DEPTH_PROC
+    if _DEPTH_INIT:
+        return _DEPTH_MODEL is not None
+    _DEPTH_INIT = True
+    # Prefer our vendored implementation first
+    try:
+        from ...vendor.depth_anything_v2.dpt import DepthAnythingV2  # type: ignore
+        # Guess config from filename
+        fname = os.path.basename(model_path or '')
+        cfgs = {
+            'depth_anything_v2_vits.pth': dict(encoder='vits', features=64, out_channels=[48,96,192,384]),
+            'depth_anything_v2_vitb.pth': dict(encoder='vitb', features=128, out_channels=[96,192,384,768]),
+            'depth_anything_v2_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            'depth_anything_v2_vitg.pth': dict(encoder='vitg', features=384, out_channels=[1536,1536,1536,1536]),
+            'depth_anything_v2_metric_vkitti_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            'depth_anything_v2_metric_hypersim_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+        }
+        # fallback to vitl if unknown
+        cfg = cfgs.get(fname, cfgs['depth_anything_v2_vitl.pth'])
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        m = DepthAnythingV2(**cfg)
+        sd = torch.load(model_path, map_location='cpu')
+        m.load_state_dict(sd)
+        _DEPTH_MODEL = m.to(device).eval()
+        _DEPTH_PROC = True
+        return True
+    except Exception:
+        # Try local checkout of comfyui_controlnet_aux (if present)
+        _insert_aux_path()
+        try:
+            from custom_controlnet_aux.depth_anything_v2.dpt import DepthAnythingV2  # type: ignore
+            fname = os.path.basename(model_path or '')
+            cfgs = {
+                'depth_anything_v2_vits.pth': dict(encoder='vits', features=64, out_channels=[48,96,192,384]),
+                'depth_anything_v2_vitb.pth': dict(encoder='vitb', features=128, out_channels=[96,192,384,768]),
+                'depth_anything_v2_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+                'depth_anything_v2_vitg.pth': dict(encoder='vitg', features=384, out_channels=[1536,1536,1536,1536]),
+                'depth_anything_v2_metric_vkitti_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+                'depth_anything_v2_metric_hypersim_vitl.pth': dict(encoder='vitl', features=256, out_channels=[256,512,1024,1024]),
+            }
+            cfg = cfgs.get(fname, cfgs['depth_anything_v2_vitl.pth'])
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+            m = DepthAnythingV2(**cfg)
+            sd = torch.load(model_path, map_location='cpu')
+            m.load_state_dict(sd)
+            _DEPTH_MODEL = m.to(device).eval()
+            _DEPTH_PROC = True
+            return True
+        except Exception:
+            # Fallback: packaged auxiliary API
+            try:
+                from controlnet_aux.depth_anything import DepthAnythingDetector, DepthAnythingV2  # type: ignore
+                device = 'cuda' if torch.cuda.is_available() else 'cpu'
+                _DEPTH_MODEL = DepthAnythingV2(model_path=model_path, device=device)
+                _DEPTH_PROC = True
+                return True
+            except Exception:
+                _DEPTH_MODEL = None
+                _DEPTH_PROC = False
+                return False
+
+
+def _build_depth_map(image_bhwc: torch.Tensor, res: int, model_path: str, hires_mode: bool = True) -> torch.Tensor:
+    B, H, W, C = image_bhwc.shape
+    dev = image_bhwc.device
+    dtype = image_bhwc.dtype
+    # Choose target min-side for processing. In hires mode we allow higher caps and keep aspect.
+    # DepthAnything v2 can be memory-hungry on large inputs; cap min-side at 1024
+    cap = 1024
+    target = int(max(16, min(cap, res)))
+    if _try_init_depth_anything(model_path):
+        try:
+            # to CPU uint8
+            img = image_bhwc.detach().to('cpu')
+            x = img[0].movedim(-1, 0).unsqueeze(0)
+            # keep aspect ratio: scale so that min(H,W) == target
+            _, Cc, Ht, Wt = x.shape
+            min_side = max(1, min(Ht, Wt))
+            scale = float(target) / float(min_side)
+            out_h = max(1, int(round(Ht * scale)))
+            out_w = max(1, int(round(Wt * scale)))
+            x = F.interpolate(x, size=(out_h, out_w), mode='bilinear', align_corners=False)
+            # make channels-last and ensure contiguous layout for OpenCV
+            arr = (x[0].movedim(0, -1).contiguous().numpy() * 255.0).astype('uint8')
+            # Prefer direct DepthAnythingV2 inference if model has infer_image
+            if hasattr(_DEPTH_MODEL, 'infer_image'):
+                import cv2
+                # Drive input_size from desired depth resolution (min side), let DA keep aspect
+                input_sz = int(max(224, min(cap, res)))
+                depth = _DEPTH_MODEL.infer_image(cv2.cvtColor(arr, cv2.COLOR_RGB2BGR), input_size=input_sz, max_depth=20.0)
+                d = np.asarray(depth, dtype=np.float32)
+                # Normalize DepthAnythingV2 output (0..max_depth) to 0..1
+                d = d / 20.0
+            else:
+                depth = _DEPTH_MODEL(arr)
+                d = np.asarray(depth, dtype=np.float32)
+            if d.max() > 1.0:
+                d = d / 255.0
+            d = torch.from_numpy(d)[None, None]  # 1,1,h,w
+            d = F.interpolate(d, size=(H, W), mode='bilinear', align_corners=False)
+            d = d[0, 0].to(device=dev, dtype=dtype)
+            d = d.clamp(0, 1)
+            return d
+        except Exception:
+            pass
+    # Fallback pseudo-depth: luminance + gentle blur
+    lum = (0.2126 * image_bhwc[..., 0] + 0.7152 * image_bhwc[..., 1] + 0.0722 * image_bhwc[..., 2]).to(dtype=dtype)
+    x = lum.movedim(-1, 0).unsqueeze(0) if lum.ndim == 3 else lum.unsqueeze(0).unsqueeze(0)
+    x = F.interpolate(x, size=(H, W), mode='bilinear', align_corners=False)
+    x = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+    return x[0, 0].clamp(0, 1)
+
+
+def _pyracanny(image_bhwc: torch.Tensor,
+               low: int,
+               high: int,
+               res: int,
+               thin_iter: int = 0,
+               edge_boost: float = 0.0,
+               smart_tune: bool = False,
+               smart_boost: float = 0.2,
+               preserve_aspect: bool = True) -> torch.Tensor:
+    try:
+        import cv2
+    except Exception:
+        # Fallback: simple Sobel magnitude
+        x = image_bhwc.movedim(-1, 1)
+        xg = x.mean(dim=1, keepdim=True)
+        gx = F.conv2d(xg, torch.tensor([[[-1, 0, 1],[-2,0,2],[-1,0,1]]], dtype=x.dtype, device=x.device).unsqueeze(1), padding=1)
+        gy = F.conv2d(xg, torch.tensor([[[-1,-2,-1],[0,0,0],[1,2,1]]], dtype=x.dtype, device=x.device).unsqueeze(1), padding=1)
+        mag = torch.sqrt(gx*gx + gy*gy)
+        mag = (mag - mag.amin())/(mag.amax()-mag.amin()+1e-6)
+        return mag[0,0].clamp(0,1)
+    B,H,W,C = image_bhwc.shape
+    img = (image_bhwc.detach().to('cpu')[0].contiguous().numpy()*255.0).astype('uint8')
+    cap = 4096
+    target = int(max(64, min(cap, res)))
+    if preserve_aspect:
+        scale = float(target) / float(max(1, min(H, W)))
+        out_h = max(8, int(round(H * scale)))
+        out_w = max(8, int(round(W * scale)))
+        img_res = cv2.resize(img, (out_w, out_h), interpolation=cv2.INTER_LINEAR)
+    else:
+        img_res = cv2.resize(img, (target, target), interpolation=cv2.INTER_LINEAR)
+    gray = cv2.cvtColor(img_res, cv2.COLOR_RGB2GRAY)
+    pyr_scales = [1.0, 0.5, 0.25]
+    acc = None
+    for s in pyr_scales:
+        if preserve_aspect:
+            sz = (max(8, int(round(img_res.shape[1]*s))), max(8, int(round(img_res.shape[0]*s))))
+        else:
+            sz = (max(8, int(target*s)), max(8, int(target*s)))
+        g = cv2.resize(gray, sz, interpolation=cv2.INTER_AREA)
+        g = cv2.GaussianBlur(g, (5,5), 0)
+        e = cv2.Canny(g, threshold1=int(low*s), threshold2=int(high*s))
+        e = cv2.resize(e, (W, H), interpolation=cv2.INTER_LINEAR)
+        e = (e.astype(np.float32)/255.0)
+        acc = e if acc is None else np.maximum(acc, e)
+    # Estimate density and sharpness for smart tuning
+    edensity_pre = None
+    try:
+        edensity_pre = float(np.mean(acc)) if acc is not None else None
+    except Exception:
+        edensity_pre = None
+    lap_var = None
+    try:
+        g32 = gray.astype(np.float32) / 255.0
+        lap = cv2.Laplacian(g32, cv2.CV_32F)
+        lap_var = float(lap.var())
+    except Exception:
+        lap_var = None
+
+    # optional thinning
+    try:
+        thin_iter_eff = int(thin_iter)
+        if smart_tune:
+            # simple heuristic: more thinning on high res and dense edges
+            auto = 0
+            if target >= 1024:
+                auto += 1
+            if target >= 1400:
+                auto += 1
+            if edensity_pre is not None and edensity_pre > 0.12:
+                auto += 1
+            if edensity_pre is not None and edensity_pre < 0.05:
+                auto = max(0, auto - 1)
+            thin_iter_eff = max(thin_iter_eff, min(3, auto))
+        if thin_iter_eff > 0:
+            import cv2
+            if hasattr(cv2, 'ximgproc') and hasattr(cv2.ximgproc, 'thinning'):
+                th = acc.copy()
+                th = (th*255).astype('uint8')
+                th = cv2.ximgproc.thinning(th)
+                acc = th.astype(np.float32)/255.0
+            else:
+                # simple erosion-based thinning approximation
+                kernel = np.ones((3,3), np.uint8)
+                t = (acc*255).astype('uint8')
+                for _ in range(int(thin_iter_eff)):
+                    t = cv2.erode(t, kernel, iterations=1)
+                acc = t.astype(np.float32)/255.0
+    except Exception:
+        pass
+    # optional edge boost (unsharp on edge map)
+    # We fix a gentle boost for micro‑contrast; smart_tune may nudge it slightly
+    boost_eff = 0.10
+    if smart_tune:
+        try:
+            lv = 0.0 if lap_var is None else max(0.0, min(1.0, lap_var / 2.0))
+            dens = 0.0 if edensity_pre is None else float(max(0.0, min(1.0, edensity_pre)))
+            boost_eff = max(0.05, min(0.20, boost_eff + (1.0 - dens) * 0.05 + (1.0 - lv) * 0.02))
+        except Exception:
+            pass
+    if boost_eff and boost_eff != 0.0:
+        try:
+            import cv2
+            blur = cv2.GaussianBlur(acc, (0,0), sigmaX=1.0)
+            acc = np.clip(acc + float(boost_eff)*(acc - blur), 0.0, 1.0)
+        except Exception:
+            pass
+    ed = torch.from_numpy(acc).to(device=image_bhwc.device, dtype=image_bhwc.dtype)
+    return ed.clamp(0,1)
+
+
+def _blend(depth: torch.Tensor, edges: torch.Tensor, mode: str, factor: float) -> torch.Tensor:
+    depth = depth.clamp(0,1)
+    edges = edges.clamp(0,1)
+    if mode == 'max':
+        return torch.maximum(depth, edges)
+    if mode == 'edge_over_depth':
+        # edges override depth (edge=1) while preserving depth elsewhere
+        return (depth * (1.0 - edges) + edges).clamp(0,1)
+    # normal
+    f = float(max(0.0, min(1.0, factor)))
+    return (depth*(1.0-f) + edges*f).clamp(0,1)
+
+
+def _apply_controlnet_separate(positive, negative, control_net, image_bhwc: torch.Tensor,
+                               strength_pos: float, strength_neg: float,
+                               start_percent: float, end_percent: float, vae=None,
+                               apply_to_uncond: bool = False,
+                               stack_prev_control: bool = False):
+    control_hint = image_bhwc.movedim(-1,1)
+    out_pos = []
+    out_neg = []
+    # POS
+    for t in positive:
+        d = t[1].copy()
+        prev = d.get('control', None) if stack_prev_control else None
+        c_net = control_net.copy().set_cond_hint(control_hint, float(strength_pos), (start_percent, end_percent), vae=vae, extra_concat=[])
+        c_net.set_previous_controlnet(prev)
+        d['control'] = c_net
+        d['control_apply_to_uncond'] = bool(apply_to_uncond)
+        out_pos.append([t[0], d])
+    # NEG
+    for t in negative:
+        d = t[1].copy()
+        prev = d.get('control', None) if stack_prev_control else None
+        c_net = control_net.copy().set_cond_hint(control_hint, float(strength_neg), (start_percent, end_percent), vae=vae, extra_concat=[])
+        c_net.set_previous_controlnet(prev)
+        d['control'] = c_net
+        d['control_apply_to_uncond'] = bool(apply_to_uncond)
+        out_neg.append([t[0], d])
+    return out_pos, out_neg
+
+
+class MG_ControlFusion:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE", {"tooltip": "Input RGB image (B,H,W,3) in 0..1."}),
+                "positive": ("CONDITIONING", {"tooltip": "Positive conditioning to apply ControlNet to."}),
+                "negative": ("CONDITIONING", {"tooltip": "Negative conditioning to apply ControlNet to."}),
+                "control_net": ("CONTROL_NET", {"tooltip": "ControlNet module receiving the fused mask as hint."}),
+                "vae": ("VAE", {"tooltip": "VAE used by ControlNet when encoding the hint."}),
+            },
+            "optional": {
+                "enable_depth": ("BOOLEAN", {"default": True, "tooltip": "Enable depth map fusion (Depth Anything v2 if available)."}),
+                "depth_model_path": ("STRING", {"default": os.path.join(os.path.dirname(os.path.dirname(__file__)), 'MagicNodes','depth-anything','depth_anything_v2_vitl.pth') if False else os.path.join(os.path.dirname(__file__), '..','depth-anything','depth_anything_v2_vitl.pth'), "tooltip": "Path to Depth Anything v2 .pth weights (vits/vitb/vitl/vitg)."}),
+                "depth_resolution": ("INT", {"default": 768, "min": 64, "max": 1024, "step": 64, "tooltip": "Depth min-side resolution (cap 1024). In Hi‑Res mode drives DepthAnything input_size."}),
+                "enable_pyra": ("BOOLEAN", {"default": True, "tooltip": "Enable PyraCanny edge detector."}),
+                "pyra_low": ("INT", {"default": 109, "min": 0, "max": 255, "tooltip": "Canny low threshold (0..255)."}),
+                "pyra_high": ("INT", {"default": 147, "min": 0, "max": 255, "tooltip": "Canny high threshold (0..255)."}),
+                "pyra_resolution": ("INT", {"default": 1024, "min": 64, "max": 4096, "step": 64, "tooltip": "Working resolution for edges (min side, keeps aspect)."}),
+                "edge_thin_iter": ("INT", {"default": 0, "min": 0, "max": 10, "step": 1, "tooltip": "Thinning iterations for edges (skeletonize). 0 = off."}),
+                "edge_alpha": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Opacity for edges before blending (0..1)."}),
+                "edge_boost": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Deprecated: internal boost fixed (~0.10); use edge_alpha instead."}),
+                "smart_tune": ("BOOLEAN", {"default": False, "tooltip": "Auto-adjust thinning/boost from image edge density and sharpness."}),
+                "smart_boost": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Scale for auto edge boost when Smart Tune is on."}),
+                "blend_mode": (["normal","max","edge_over_depth"], {"default": "normal", "tooltip": "Depth+edges merge: normal (mix), max (strongest), edge_over_depth (edges overlay)."}),
+                "blend_factor": ("FLOAT", {"default": 0.02, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Blend strength for edges into depth (depends on mode)."}),
+                "strength_pos": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, "tooltip": "ControlNet strength for positive branch."}),
+                "strength_neg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01, "tooltip": "ControlNet strength for negative branch."}),
+                "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Start percentage along the sampling schedule."}),
+                "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "End percentage along the sampling schedule."}),
+                "preview_res": ("INT", {"default": 1024, "min": 256, "max": 2048, "step": 64, "tooltip": "Preview minimum side (keeps aspect ratio)."}),
+                "mask_brightness": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Preview brightness multiplier (visualization only)."}),
+                "preview_show_strength": ("BOOLEAN", {"default": True, "tooltip": "Multiply preview by ControlNet strength for visualization."}),
+                "preview_strength_branch": (["positive","negative","max","avg"], {"default": "max", "tooltip": "Which strength to reflect in preview (display only)."}),
+                "hires_mask_auto": ("BOOLEAN", {"default": True, "tooltip": "High‑res mask: keep aspect ratio, scale by minimal side for depth/edges, and drive DepthAnything with your depth_resolution (no 2K cap)."}),
+                "apply_to_uncond": ("BOOLEAN", {"default": False, "tooltip": "Apply ControlNet hint to the unconditional branch as well (stronger global hold on very large images)."}),
+                "stack_prev_control": ("BOOLEAN", {"default": False, "tooltip": "Chain with any previously attached ControlNet in the conditioning (advanced). Off = replace to avoid memory bloat."}),
+                # Split apply: chain Depth and Edges with separate schedules/strengths (fixed order: depth -> edges)
+                "split_apply": ("BOOLEAN", {"default": False, "tooltip": "Apply Depth and Edges as two chained ControlNets (fixed order: depth then edges)."}),
+                "edge_start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Edges start percent (when split is enabled)."}),
+                "edge_end_percent": ("FLOAT", {"default": 0.6, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Edges end percent (when split is enabled)."}),
+                "depth_start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Depth start percent (when split is enabled)."}),
+                "depth_end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Depth end percent (when split is enabled)."}),
+                "edge_strength_mul": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiply global strength for Edges when split is enabled."}),
+                "depth_strength_mul": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiply global strength for Depth when split is enabled."}),
+                # Extra edge controls (bottom)
+                "edge_width": ("FLOAT", {"default": 0.0, "min": -0.5, "max": 1.5, "step": 0.05, "tooltip": "Edge thickness adjust: negative thins, positive thickens."}),
+                "edge_smooth": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05, "tooltip": "Small smooth on edges to reduce pixelation (0..1)."}),
+                "edge_single_line": ("BOOLEAN", {"default": False, "tooltip": "Try to collapse double outlines into a single centerline."}),
+                "edge_single_strength": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Strength of single-line collapse (0..1). 0 = off, 1 = strong."}),
+                "edge_depth_gate": ("BOOLEAN", {"default": False, "tooltip": "Weigh edges by depth so distant lines are fainter."}),
+                "edge_depth_gamma": ("FLOAT", {"default": 1.5, "min": 0.2, "max": 4.0, "step": 0.1, "tooltip": "Gamma for depth gating: edges *= (1−depth)^gamma."}),
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING","CONDITIONING","IMAGE")
+    RETURN_NAMES = ("positive","negative","mask_preview")
+    FUNCTION = "apply"
+    CATEGORY = "MagicNodes"
+
+    def apply(self, image, positive, negative, control_net, vae,
+              enable_depth=True, depth_model_path="", depth_resolution=1024,
+              enable_pyra=True, pyra_low=109, pyra_high=147, pyra_resolution=1024,
+              edge_thin_iter=0, edge_alpha=1.0, edge_boost=0.0,
+              smart_tune=False, smart_boost=0.2,
+              blend_mode="normal", blend_factor=0.02,
+              strength_pos=1.0, strength_neg=1.0, start_percent=0.0, end_percent=1.0,
+              preview_res=1024, mask_brightness=1.0,
+              preview_show_strength=True, preview_strength_branch="max",
+              hires_mask_auto=True, apply_to_uncond=False, stack_prev_control=False,
+              edge_width=0.0, edge_smooth=0.0, edge_single_line=False, edge_single_strength=0.0,
+              edge_depth_gate=False, edge_depth_gamma=1.5,
+              split_apply=False, edge_start_percent=0.0, edge_end_percent=0.6,
+              depth_start_percent=0.0, depth_end_percent=1.0,
+              edge_strength_mul=1.0, depth_strength_mul=1.0):
+
+        dev = image.device
+        dtype = image.dtype
+        B,H,W,C = image.shape
+        # Build depth/edges
+        depth = None
+        edges = None
+        if enable_depth:
+            model_path = depth_model_path or os.path.join(os.path.dirname(__file__), '..','depth-anything','depth_anything_v2_vitl.pth')
+            depth = _build_depth_map(image, int(depth_resolution), model_path, bool(hires_mask_auto))
+        if enable_pyra:
+            edges = _pyracanny(image,
+                               int(pyra_low), int(pyra_high), int(pyra_resolution),
+                               int(edge_thin_iter), float(edge_boost),
+                               bool(smart_tune), float(smart_boost), bool(hires_mask_auto))
+        if depth is None and edges is None:
+            # Nothing to do: return inputs and zero preview
+            prev = torch.zeros((B, max(H,1), max(W,1), 3), device=dev, dtype=dtype)
+            return positive, negative, prev
+
+        if depth is None:
+            depth = torch.zeros_like(edges)
+        if edges is None:
+            edges = torch.zeros_like(depth)
+
+        # Edge post-process: width/single-line/smooth
+        def _edges_post(acc_t: torch.Tensor) -> torch.Tensor:
+            try:
+                import cv2, numpy as _np
+                acc = acc_t.detach().to('cpu').numpy()
+                img = (acc*255.0).astype(_np.uint8)
+                k = _np.ones((3,3), _np.uint8)
+                # Adjust thickness
+                w = float(edge_width)
+                if abs(w) > 1e-6:
+                    it = int(abs(w))
+                    frac = abs(w) - it
+                    op = cv2.dilate if w > 0 else cv2.erode
+                    y = img.copy()
+                    for _ in range(max(0, it)):
+                        y = op(y, k, iterations=1)
+                    if frac > 1e-6:
+                        y2 = op(y, k, iterations=1)
+                        y = ((1.0-frac)*y.astype(_np.float32) + frac*y2.astype(_np.float32)).astype(_np.uint8)
+                    img = y
+                # Collapse double lines to single centerline
+                if bool(edge_single_line) and float(edge_single_strength) > 1e-6:
+                    try:
+                        s = float(edge_single_strength)
+                        close = cv2.morphologyEx(img, cv2.MORPH_CLOSE, k, iterations=1)
+                        if hasattr(cv2, 'ximgproc') and hasattr(cv2.ximgproc, 'thinning'):
+                            sk = cv2.ximgproc.thinning(close)
+                        else:
+                            # limited-iteration morphological skeletonization
+                            iters = max(1, int(round(2 + 6*s)))
+                            sk = _np.zeros_like(close)
+                            src = close.copy()
+                            elem = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
+                            for _ in range(iters):
+                                er = cv2.erode(src, elem, iterations=1)
+                                op = cv2.morphologyEx(er, cv2.MORPH_OPEN, elem)
+                                tmp = cv2.subtract(er, op)
+                                sk = cv2.bitwise_or(sk, tmp)
+                                src = er
+                                if not _np.any(src):
+                                    break
+                        # Blend skeleton back with original according to strength
+                        img = ((_np.float32(1.0 - s) * img.astype(_np.float32)) + (_np.float32(s) * sk.astype(_np.float32))).astype(_np.uint8)
+                    except Exception:
+                        pass
+                # Smooth
+                if float(edge_smooth) > 1e-6:
+                    sigma = max(0.1, min(2.0, float(edge_smooth) * 1.2))
+                    img = cv2.GaussianBlur(img, (0,0), sigmaX=sigma)
+                out = torch.from_numpy((img.astype(_np.float32)/255.0)).to(device=acc_t.device, dtype=acc_t.dtype)
+                return out.clamp(0,1)
+            except Exception:
+                # Torch fallback: light blur-only
+                if float(edge_smooth) > 1e-6:
+                    s = max(1, int(round(float(edge_smooth)*2)))
+                    return F.avg_pool2d(acc_t.unsqueeze(0).unsqueeze(0), kernel_size=2*s+1, stride=1, padding=s)[0,0].clamp(0,1)
+                return acc_t
+
+        edges = _edges_post(edges)
+
+        # Depth gating of edges
+        if bool(edge_depth_gate):
+            # Inverted gating per feedback: use depth^gamma (nearer = stronger if depth is larger)
+            g = (depth.clamp(0,1)) ** float(edge_depth_gamma)
+            edges = (edges * g).clamp(0,1)
+
+        # Apply edge alpha before blending
+        edges = (edges * float(edge_alpha)).clamp(0,1)
+
+        fused = _blend(depth, edges, str(blend_mode), float(blend_factor))
+        # Apply as split (Edges then Depth) or single fused hint
+        if bool(split_apply):
+            # Fixed order for determinism: Depth first, then Edges
+            hint_edges = edges.unsqueeze(-1).repeat(1,1,1,3)
+            hint_depth = depth.unsqueeze(-1).repeat(1,1,1,3)
+            # Depth first
+            pos_mid, neg_mid = _apply_controlnet_separate(
+                positive, negative, control_net, hint_depth,
+                float(strength_pos) * float(depth_strength_mul),
+                float(strength_neg) * float(depth_strength_mul),
+                float(depth_start_percent), float(depth_end_percent), vae,
+                bool(apply_to_uncond), True
+            )
+            # Then edges
+            pos_out, neg_out = _apply_controlnet_separate(
+                pos_mid, neg_mid, control_net, hint_edges,
+                float(strength_pos) * float(edge_strength_mul),
+                float(strength_neg) * float(edge_strength_mul),
+                float(edge_start_percent), float(edge_end_percent), vae,
+                bool(apply_to_uncond), True
+            )
+        else:
+            hint = fused.unsqueeze(-1).repeat(1,1,1,3)
+            pos_out, neg_out = _apply_controlnet_separate(
+                positive, negative, control_net, hint,
+                float(strength_pos), float(strength_neg),
+                float(start_percent), float(end_percent), vae,
+                bool(apply_to_uncond), bool(stack_prev_control)
+            )
+        # Build preview: keep aspect ratio, set minimal side
+        prev_res = int(max(256, min(2048, preview_res)))
+        scale = prev_res / float(min(H, W))
+        out_h = max(1, int(round(H * scale)))
+        out_w = max(1, int(round(W * scale)))
+        prev = F.interpolate(fused.unsqueeze(0).unsqueeze(0), size=(out_h, out_w), mode='bilinear', align_corners=False)[0,0]
+        # Optionally reflect ControlNet strength in preview (display only)
+        if bool(preview_show_strength):
+            br = str(preview_strength_branch)
+            sp = float(strength_pos)
+            sn = float(strength_neg)
+            if br == 'negative':
+                s_vis = sn
+            elif br == 'max':
+                s_vis = max(sp, sn)
+            elif br == 'avg':
+                s_vis = 0.5 * (sp + sn)
+            else:
+                s_vis = sp
+            # clamp for display range
+            s_vis = max(0.0, min(1.0, s_vis))
+            prev = prev * s_vis
+        # Apply visualization brightness only for preview
+        prev = (prev * float(mask_brightness)).clamp(0.0, 1.0)
+        prev = prev.unsqueeze(-1).repeat(1,1,3).to(device=dev, dtype=dtype).unsqueeze(0)
+        return (pos_out, neg_out, prev)

mod/hard/mg_ids.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import numpy as np
+import torch
+
+try:
+    from scipy.ndimage import gaussian_filter as _scipy_gaussian_filter
+    _HAVE_SCIPY = True
+except Exception:
+    _HAVE_SCIPY = False
+
+
+def _torch_gaussian_blur(image: torch.Tensor, sigma: float) -> torch.Tensor:
+    # image: BHWC in [0,1]
+    if sigma <= 0.0:
+        return image
+    device = image.device
+    dtype = image.dtype
+    radius = max(1, int(3.0 * float(sigma)))
+    ksize = radius * 2 + 1
+    x = torch.arange(-radius, radius + 1, device=device, dtype=dtype)
+    g1 = torch.exp(-(x * x) / (2.0 * (sigma ** 2)))
+    g1 = (g1 / g1.sum()).view(1, 1, 1, -1)
+    g2 = g1.transpose(2, 3)
+    xch = image.movedim(-1, 1)  # BCHW
+    pad = (radius, radius, radius, radius)
+    out = torch.nn.functional.conv2d(torch.nn.functional.pad(xch, pad, mode="reflect"), g1.repeat(xch.shape[1], 1, 1, 1), groups=xch.shape[1])
+    out = torch.nn.functional.conv2d(torch.nn.functional.pad(out, pad, mode="reflect"), g2.repeat(out.shape[1], 1, 1, 1), groups=out.shape[1])
+    return out.movedim(1, -1)
+
+
+class IntelligentDetailStabilizer:
+    """Alias-preserving move of IDS into mod/ as mg_ids.py.
+    Keeps class/key name for backward compatibility.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE", {}),
+                "ids_strength": (
+                    "FLOAT",
+                    {"default": 0.5, "min": -1.0, "max": 1.0, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("IMAGE",)
+    FUNCTION = "stabilize"
+    CATEGORY = "MagicNodes"
+
+    def stabilize(self, image: torch.Tensor, ids_strength: float = 0.5):
+        sigma = max(float(ids_strength) * 2.0, 1e-3)
+        if _HAVE_SCIPY:
+            img_np = image.detach().cpu().numpy()
+            denoised = _scipy_gaussian_filter(img_np, sigma=(0, sigma, sigma, 0))
+            blurred = _scipy_gaussian_filter(denoised, sigma=(0, 1.0, 1.0, 0))
+            sharpen = denoised + ids_strength * (denoised - blurred)
+            sharpen = np.clip(sharpen, 0.0, 1.0)
+            out = torch.from_numpy(sharpen).to(image.device, dtype=image.dtype)
+        else:
+            denoised = _torch_gaussian_blur(image, sigma=sigma)
+            blurred = _torch_gaussian_blur(denoised, sigma=1.0)
+            out = (denoised + ids_strength * (denoised - blurred)).clamp(0, 1)
+        return (out,)

mod/hard/mg_upscale_module.py

@@ -0,0 +1,72 @@
+import comfy.utils
+import torch
+import gc
+import logging
+import comfy.model_management as model_management
+
+
+def clear_gpu_and_ram_cache():
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.ipc_collect()
+
+
+def _smart_decode(vae, latent, tile_size=512):
+    try:
+        images = vae.decode(latent["samples"])
+    except model_management.OOM_EXCEPTION:
+        logging.warning("VAE decode OOM, using tiled decode")
+        compression = vae.spacial_compression_decode()
+        images = vae.decode_tiled(
+            latent["samples"],
+            tile_x=tile_size // compression,
+            tile_y=tile_size // compression,
+            overlap=(tile_size // 4) // compression,
+        )
+    if len(images.shape) == 5:
+        images = images.reshape(-1, images.shape[-3], images.shape[-2], images.shape[-1])
+    return images
+
+
+class MagicUpscaleModule:
+    """Moved into mod/ as mg_upscale_module keeping class/key name."""
+    upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "lanczos"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "samples": ("LATENT", {}),
+                "vae": ("VAE", {}),
+                "upscale_method": (cls.upscale_methods, {"default": "bilinear"}),
+                "scale_by": ("FLOAT", {"default": 1.2, "min": 0.01, "max": 8.0, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT", "IMAGE")
+    RETURN_NAMES = ("LATENT", "Upscaled Image")
+    FUNCTION = "process_upscale"
+    CATEGORY = "MagicNodes"
+
+    def process_upscale(self, samples, vae, upscale_method, scale_by):
+        clear_gpu_and_ram_cache()
+        images = _smart_decode(vae, samples)
+        samples_t = images.movedim(-1, 1)
+        width = round(samples_t.shape[3] * scale_by)
+        height = round(samples_t.shape[2] * scale_by)
+        # Align to VAE stride to avoid border artifacts/shape drift
+        try:
+            stride = int(vae.spacial_compression_decode())
+        except Exception:
+            stride = 8
+        if stride <= 0:
+            stride = 8
+        def _align_up(x, s):
+            return int(((x + s - 1) // s) * s)
+        width_al = _align_up(width, stride)
+        height_al = _align_up(height, stride)
+        up = comfy.utils.common_upscale(samples_t, width_al, height_al, upscale_method, "disabled")
+        up = up.movedim(1, -1)
+        encoded = vae.encode(up[:, :, :, :3])
+        return ({"samples": encoded}, up)

mod/hard/mg_zesmart_sampler_v1_1.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn.functional as F  # noqa: F401
+
+import comfy.utils as _utils
+import comfy.sample as _sample
+import comfy.samplers as _samplers
+from comfy.k_diffusion import sampling as _kds
+
+import nodes  # latent preview callback
+
+
+def _smoothstep01(x: torch.Tensor) -> torch.Tensor:
+    return x * x * (3.0 - 2.0 * x)
+
+
+def _build_hybrid_sigmas(model, steps: int, base_sampler: str, mode: str,
+                         mix: float, denoise: float, jitter: float, seed: int,
+                         _debug: bool = False, tail_smooth: float = 0.0,
+                         auto_hybrid_tail: bool = True, auto_tail_strength: float = 0.35):
+    """Return 1D tensor of sigmas (len == steps+1), strictly descending and ending with 0.
+
+    mode: 'karras' | 'beta' | 'hybrid'. If 'hybrid', blend tail toward beta by `mix`.
+    We DO NOT apply 'drop penultimate' until the very end to preserve denoise math.
+    """
+    ms = model.get_model_object("model_sampling")
+    steps = int(steps)
+    assert steps >= 1
+
+    # --- base tracks ---
+    sig_k = _samplers.calculate_sigmas(ms, "karras", steps)
+    sig_b = _samplers.calculate_sigmas(ms, "beta",   steps)
+
+    mode = str(mode).lower()
+    if mode == "karras":
+        sig = sig_k
+    elif mode == "beta":
+        sig = sig_b
+    else:
+        n = sig_k.shape[0]
+        t = torch.linspace(0.0, 1.0, n, device=sig_k.device, dtype=sig_k.dtype)
+        m = float(max(0.0, min(1.0, mix)))
+        eps = 1e-6 if m < 1e-6 else m
+        w = torch.clamp((t - (1.0 - m)) / eps, 0.0, 1.0)
+        w = _smoothstep01(w)
+        sig = sig_k * (1.0 - w) + sig_b * w
+
+    # --- Comfy denoise semantics: recompute a "full" track and take the tail of desired length ---
+    sig_k_base = sig_k
+    sig_b_base = sig_b
+    if denoise is not None and 0.0 < float(denoise) < 0.999999:
+        new_steps = max(1, int(steps / max(1e-6, float(denoise))))
+        sk = _samplers.calculate_sigmas(ms, "karras", new_steps)
+        sb = _samplers.calculate_sigmas(ms, "beta",   new_steps)
+        if mode == "karras":
+            sig_full = sk
+        elif mode == "beta":
+            sig_full = sb
+        else:
+            n2 = sk.shape[0]
+            t2 = torch.linspace(0.0, 1.0, n2, device=sk.device, dtype=sk.dtype)
+            m = float(max(0.0, min(1.0, mix)))
+            eps = 1e-6 if m < 1e-6 else m
+            w2 = torch.clamp((t2 - (1.0 - m)) / eps, 0.0, 1.0)
+            w2 = _smoothstep01(w2)
+            sig_full = sk * (1.0 - w2) + sb * w2
+        need = steps + 1
+        if sig_full.shape[0] >= need:
+            sig = sig_full[-need:]
+            sig_k_base = sk[-need:]
+            sig_b_base = sb[-need:]
+        else:
+            # Worst case: trust what we got; we will still guarantee the last sigma is zero later
+            sig = sig_full
+            tail = min(need, sk.shape[0])
+            sig_k_base = sk[-tail:]
+            sig_b_base = sb[-tail:]
+
+    # --- auto-hybrid tail: blend beta into the tail when the steps become brittle ---
+    if bool(auto_hybrid_tail) and sig.numel() > 2:
+        n = sig.shape[0]
+        t = torch.linspace(0.0, 1.0, n, device=sig.device, dtype=sig.dtype)
+        m = float(max(0.0, min(1.0, mix)))
+        if mode == "hybrid":
+            eps = 1e-6 if m < 1e-6 else m
+            w_m = torch.clamp((t - (1.0 - m)) / eps, 0.0, 1.0)
+            w_m = _smoothstep01(w_m)
+        elif mode == "beta":
+            w_m = torch.ones_like(t)
+        else:
+            w_m = torch.zeros_like(t)
+        dif = (sig[1:] - sig[:-1]).abs() / sig[:-1].abs().clamp_min(1e-8)
+        dif = torch.cat([dif, dif[-1:]], dim=0)
+        dif = (dif - dif.min()) / (dif.max() - dif.min() + 1e-8)
+        ramp = _smoothstep01(torch.clamp((t - 0.7) / 0.3, 0.0, 1.0))
+        w_a = dif * ramp
+        g = float(max(0.0, min(1.0, auto_tail_strength)))
+        u = w_m + g * w_a - w_m * g * w_a
+        sig = sig_k_base * (1.0 - u) + sig_b_base * u
+
+    # --- tiny schedule jitter ---
+    j = float(max(0.0, min(0.1, float(jitter))))
+    if j > 0.0 and sig.numel() > 1:
+        gen = torch.Generator(device='cpu')
+        gen.manual_seed(int(seed) ^ 0x5EEDCAFE)
+        noise = torch.randn(sig.shape, generator=gen, device='cpu').to(sig.device, sig.dtype)
+        amp = j * float(sig[0].item() - sig[-1].item()) * 1e-3
+        sig = sig + noise * amp
+        sig, _ = torch.sort(sig, descending=True)
+
+    # --- hard guarantee of ending with exact zero ---
+    if sig[-1].abs() > 1e-12:
+        sig = torch.cat([sig[:-1], sig.new_zeros(1)], dim=0)
+
+    # --- and only now drop-penultimate for respective samplers ---
+    # --- gentle smoothing of sigma tail (adaptive, safe for monotonic decrease) ---
+    ts = float(max(0.0, min(1.0, tail_smooth)))
+    if ts > 0.0 and sig.numel() > 2:
+        s = sig.clone()
+        n = int(s.shape[0])
+        t = torch.linspace(0.0, 1.0, n, device=s.device, dtype=s.dtype)
+        w = (t.pow(2) * ts).clamp(0.0, 1.0)
+        for i in range(n - 2, -1, -1):
+            a = float(min(0.5, 0.5 * w[i].item()))
+            s[i] = (1.0 - a) * s[i] + a * s[i + 1]
+        sig = s
+
+    if base_sampler in _samplers.KSampler.DISCARD_PENULTIMATE_SIGMA_SAMPLERS and sig.numel() >= 2:
+        sig = torch.cat([sig[:-2], sig[-1:]], dim=0)
+
+    sig = sig.to(model.load_device)
+
+    # Lightweight debug: schedule summary
+    if _debug:
+        try:
+            desc_ok = bool((sig[:-1] > sig[1:]).all().item()) if sig.numel() > 1 else True
+            head = ", ".join(f"{float(v):.4g}" for v in sig[:3].tolist()) if sig.numel() >= 3 else \
+                   ", ".join(f"{float(v):.4g}" for v in sig.tolist())
+            tail = ", ".join(f"{float(v):.4g}" for v in sig[-3:].tolist()) if sig.numel() >= 3 else head
+            print(f"[ZeSmart][dbg] sigmas len={sig.numel()} desc={desc_ok} first={float(sig[0]):.6g} last={float(sig[-1]):.6g}")
+            print(f"[ZeSmart][dbg] head: [{head}]  tail: [{tail}]")
+        except Exception:
+            pass
+
+    return sig
+
+
+class MG_ZeSmartSampler:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("MODEL", {}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2**63-1, "control_after_generate": True}),
+                "steps": ("INT", {"default": 20, "min": 1, "max": 4096}),
+                "cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 50.0, "step": 0.1}),
+                "base_sampler": (_samplers.KSampler.SAMPLERS, {"default": "dpmpp_2m"}),
+                "schedule": (["karras", "beta", "hybrid"], {"default": "hybrid", "tooltip": "Sigma curve: karras — soft start; beta — stable tail; hybrid — their mix."}),
+                "positive": ("CONDITIONING", {}),
+                "negative": ("CONDITIONING", {}),
+                "latent": ("LATENT", {}),
+            },
+            "optional": {
+                "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Path shortening: 1.0 = full; <1.0 = take the last steps only. Useful for inpaint/mixing."}),
+                "hybrid_mix": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "For schedule=hybrid: tail fraction blended toward beta (0=karras, 1=beta)."}),
+                "jitter_sigma": ("FLOAT", {"default": 0.01, "min": 0.0, "max": 0.1, "step": 0.001, "tooltip": "Tiny sigma jitter to kill moiré/banding on backgrounds. 0–0.02 is usually enough."}),
+                "tail_smooth": ("FLOAT", {"default": 0.15, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Smooth the sigma tail — reduces wobble/banding. Too high may soften details."}),
+                "auto_hybrid_tail": ("BOOLEAN", {"default": True, "tooltip": "Auto‑blend beta on the tail when steps become brittle."}),
+                "auto_tail_strength": ("FLOAT", {"default": 0.4, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Strength of auto beta‑mix on the tail (0=off, 1=max)."}),
+                "debug_probe": ("BOOLEAN", {"default": False, "tooltip": "Print sigma summary (length, first/last, head/tail)."}),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    RETURN_NAMES = ("LATENT",)
+    FUNCTION = "apply"
+    CATEGORY = "MagicNodes/Experimental"
+
+    def apply(self, model, seed, steps, cfg, base_sampler, schedule,
+              positive, negative, latent, denoise=1.0, hybrid_mix=0.5,
+              jitter_sigma=0.02, tail_smooth=0.07,
+              auto_hybrid_tail=True, auto_tail_strength=0.3,
+              debug_probe=False):
+        # Prepare latent + noise
+        lat_img = latent["samples"]
+        lat_img = _sample.fix_empty_latent_channels(model, lat_img)
+        batch_inds = latent.get("batch_index", None)
+        noise = _sample.prepare_noise(lat_img, seed, batch_inds)
+        noise_mask = latent.get("noise_mask", None)
+
+        # Custom sigmas
+        sigmas = _build_hybrid_sigmas(model, int(steps), str(base_sampler), str(schedule),
+                                      float(hybrid_mix), float(denoise), float(jitter_sigma), int(seed),
+                                      _debug=bool(debug_probe), tail_smooth=float(tail_smooth),
+                                      auto_hybrid_tail=bool(auto_hybrid_tail),
+                                      auto_tail_strength=float(auto_tail_strength))
+
+        # Use native sampler; all tweaks happen in sigma schedule only.
+        sampler_obj = _samplers.sampler_object(str(base_sampler))
+        callback = nodes.latent_preview.prepare_callback(model, int(steps))
+        disable_pbar = not _utils.PROGRESS_BAR_ENABLED
+        samples = _sample.sample_custom(model, noise, float(cfg), sampler_obj, sigmas,
+                                        positive, negative, lat_img,
+                                        noise_mask=noise_mask, callback=callback,
+                                        disable_pbar=disable_pbar, seed=seed)
+        out = {**latent}
+        out["samples"] = samples
+        return (out,)

mod/mg_combinode.py

@@ -0,0 +1,448 @@
+import comfy.sd
+import comfy.clip_vision
+import folder_paths
+import comfy.utils
+import torch
+import random
+from datetime import datetime
+import random
+import gc
+import os
+import json
+import re
+
+from .hard.mg_upscale_module import clear_gpu_and_ram_cache
+
+# Module level caches to reuse loaded models and LoRAs between invocations
+_checkpoint_cache = {}
+_loaded_checkpoint = None
+_lora_cache = {}
+_active_lora_names = set()
+
+
+def _clear_unused_loras(active_names):
+    """Remove unused LoRAs from cache and clear GPU memory."""
+    unused = [n for n in _lora_cache if n not in active_names]
+    for n in unused:
+        del _lora_cache[n]
+    if unused:
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+
+def _load_checkpoint(path):
+    """Load checkpoint from cache or disk."""
+    if path in _checkpoint_cache:
+        return _checkpoint_cache[path]
+    model, clip, vae = comfy.sd.load_checkpoint_guess_config(
+        path,
+        output_vae=True,
+        output_clip=True,
+        embedding_directory=folder_paths.get_folder_paths("embeddings"),
+    )[:3]
+    _checkpoint_cache[path] = (model, clip, vae)
+    return model, clip, vae
+
+
+def _unload_old_checkpoint(current_path):
+    """Unload checkpoint if it's different from the current one."""
+    global _loaded_checkpoint
+    if _loaded_checkpoint and _loaded_checkpoint != current_path:
+        _checkpoint_cache.pop(_loaded_checkpoint, None)
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    _loaded_checkpoint = current_path
+
+
+
+class MagicNodesCombiNode:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+            
+
+
+            # --- Checkpoint ---
+            "use_checkpoint": ("BOOLEAN", {"default": True}),
+            "checkpoint": (folder_paths.get_filename_list("checkpoints"), {}),
+            "clear_cache": ("BOOLEAN", {"default": False}),
+
+            # --- LoRA 1 ---
+            "use_lora_1": ("BOOLEAN", {"default": True}),
+            "lora_1": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_1": ("FLOAT", {"default": 1.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_1": ("FLOAT", {"default": 1.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+
+            # --- LoRA 2 ---
+            "use_lora_2": ("BOOLEAN", {"default": False}),
+            "lora_2": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_2": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_2": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+
+            # --- LoRA 3 ---
+            "use_lora_3": ("BOOLEAN", {"default": False}),
+            "lora_3": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_3": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_3": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+
+            # --- LoRA 4 ---
+            "use_lora_4": ("BOOLEAN", {"default": False}),
+            "lora_4": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_4": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_4": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+
+            # --- LoRA 5 ---
+            "use_lora_5": ("BOOLEAN", {"default": False}),
+            "lora_5": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_5": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_5": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+
+            # --- LoRA 6 ---
+            "use_lora_6": ("BOOLEAN", {"default": False}),
+            "lora_6": (folder_paths.get_filename_list("loras"), {}),
+            "strength_model_6": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            "strength_clip_6": ("FLOAT", {"default": 0.0, "min": -1.5, "max": 1.5, "step": 0.01,}),
+            },
+            "optional": {
+            "model_in": ("MODEL", {}),
+            "clip_in": ("CLIP", {}),
+            "vae_in": ("VAE", {}),
+
+            # --- Prompts --- (controlled dynamic expansion inside node for determinism)
+            "positive_prompt": ("STRING", {"multiline": True, "default": "", "dynamicPrompts": False}),
+            "negative_prompt": ("STRING", {"multiline": True, "default": "", "dynamicPrompts": False}),
+
+            # Optional external conditioning (bypass internal text encode)
+            "positive_in": ("CONDITIONING", {}),
+            "negative_in": ("CONDITIONING", {}),
+
+            # --- CLIP Layers ---
+            "clip_set_last_layer_positive": ("INT", {"default": -2, "min": -20, "max": 0}),
+            "clip_set_last_layer_negative": ("INT", {"default": -2, "min": -20, "max": 0}),
+
+            # --- Recipes ---
+            "recipe_slot": (["Off", "Slot 1", "Slot 2", "Slot 3", "Slot 4"], {"default": "Off", "tooltip": "Choose slot to save/load assembled setup."}),
+            "recipe_save": ("BOOLEAN", {"default": False, "tooltip": "Save current setup into the selected slot."}),
+            "recipe_use": ("BOOLEAN", {"default": False, "tooltip": "Load and apply setup from the selected slot for this run."}),
+
+            # --- Standard pipeline (match classic node order for CLIP) ---
+            "standard_pipeline": ("BOOLEAN", {"default": False, "tooltip": "Use vanilla order for CLIP: Set Last Layer -> Load LoRA -> Encode (same CLIP logic as standard ComfyUI)."}),
+
+            # CLIP LoRA gains per branch (effective only when standard_pipeline=true)
+            "clip_lora_pos_gain": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiplier for CLIP-LoRA strength on positive branch (standard pipeline)."}),
+            "clip_lora_neg_gain": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.01, "tooltip": "Multiplier for CLIP-LoRA strength on negative branch (standard pipeline)."}),
+
+            # Deterministic dynamic prompts
+            "dynamic_pos": ("BOOLEAN", {"default": False, "tooltip": "Deterministically expand choices in positive prompt (uses dyn_seed)."}),
+            "dynamic_neg": ("BOOLEAN", {"default": False, "tooltip": "Deterministically expand choices in negative prompt (uses dyn_seed)."}),
+            "dyn_seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFF, "tooltip": "Seed for dynamic prompt expansion (same seed used for both prompts)."}),
+            "dynamic_break_freeze": ("BOOLEAN", {"default": True, "tooltip": "If enabled, do not expand choices before the first |BREAK| marker; dynamic applies only after it."}),
+            "show_expanded_prompts": ("BOOLEAN", {"default": False, "tooltip": "Print expanded Positive/Negative prompts to console when dynamic is enabled."}),
+            "save_expanded_prompts": ("BOOLEAN", {"default": False, "tooltip": "Save expanded prompts to mod/dynPrompt/SEED_dd_mm_yyyy.txt when dynamic is enabled."}),
+            }
+        }
+
+
+    RETURN_TYPES = ("MODEL", "CLIP", "CONDITIONING", "CONDITIONING", "VAE")
+    RETURN_NAMES = ("MODEL", "CLIP", "Positive", "Negative", "VAE")
+    #RETURN_TYPES = ("MODEL", "CONDITIONING", "CONDITIONING", "VAE")
+    #RETURN_NAMES = ("MODEL", "Positive", "Negative", "VAE")
+    FUNCTION = "apply_magic_node"
+    CATEGORY = "MagicNodes"
+
+    def apply_magic_node(self, model_in=None, clip_in=None, checkpoint=None,
+                     use_checkpoint=True, clear_cache=False,
+                     use_lora_1=True, lora_1=None, strength_model_1=1.0, strength_clip_1=1.0,
+                     use_lora_2=False, lora_2=None, strength_model_2=0.0, strength_clip_2=0.0,
+                     use_lora_3=False, lora_3=None, strength_model_3=0.0, strength_clip_3=0.0,
+                     use_lora_4=False, lora_4=None, strength_model_4=0.0, strength_clip_4=0.0,
+                     use_lora_5=False, lora_5=None, strength_model_5=0.0, strength_clip_5=0.0,
+                     use_lora_6=False, lora_6=None, strength_model_6=0.0, strength_clip_6=0.0,
+                     positive_prompt="", negative_prompt="",
+                     clip_set_last_layer_positive=-2, clip_set_last_layer_negative=-2,
+                     vae_in=None,
+                     recipe_slot="Off", recipe_save=False, recipe_use=False,
+                     standard_pipeline=False,
+                     clip_lora_pos_gain=1.0, clip_lora_neg_gain=1.0,
+                     positive_in=None, negative_in=None,
+                     dynamic_pos=False, dynamic_neg=False, dyn_seed=0, dynamic_break_freeze=True,
+                     show_expanded_prompts=False, save_expanded_prompts=False):
+
+        global _loaded_checkpoint
+
+        # hard scrub of checkpoint cache each call (prevent hidden state)
+        _checkpoint_cache.clear()
+        if clear_cache:
+            _lora_cache.clear()
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        # Recipe helpers
+        def _recipes_path():
+            base = os.path.join(os.path.dirname(__file__), "state")
+            os.makedirs(base, exist_ok=True)
+            return os.path.join(base, "combinode_recipes.json")
+        def _recipes_load():
+            try:
+                with open(_recipes_path(), "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        def _recipes_save(data: dict):
+            try:
+                with open(_recipes_path(), "w", encoding="utf-8") as f:
+                    json.dump(data, f, ensure_ascii=False, indent=2)
+            except Exception:
+                pass
+
+        # Apply recipe if requested
+        slot_idx = {"Off": 0, "Slot 1": 1, "Slot 2": 2, "Slot 3": 3, "Slot 4": 4}.get(str(recipe_slot), 0)
+        if slot_idx and bool(recipe_use):
+            rec = _recipes_load().get(str(slot_idx), None)
+            if rec is not None:
+                try:
+                    use_checkpoint = rec.get("use_checkpoint", use_checkpoint)
+                    checkpoint = rec.get("checkpoint", checkpoint)
+                    clip_set_last_layer_positive = rec.get("clip_pos", clip_set_last_layer_positive)
+                    clip_set_last_layer_negative = rec.get("clip_neg", clip_set_last_layer_negative)
+                    positive_prompt = rec.get("pos_text", positive_prompt)
+                    negative_prompt = rec.get("neg_text", negative_prompt)
+                    rls = rec.get("loras", [])
+                    if len(rls) >= 4:
+                        (use_lora_1, lora_1, strength_model_1, strength_clip_1) = rls[0]
+                        (use_lora_2, lora_2, strength_model_2, strength_clip_2) = rls[1]
+                        (use_lora_3, lora_3, strength_model_3, strength_clip_3) = rls[2]
+                        (use_lora_4, lora_4, strength_model_4, strength_clip_4) = rls[3]
+                    if len(rls) >= 5:
+                        (use_lora_5, lora_5, strength_model_5, strength_clip_5) = rls[4]
+                    if len(rls) >= 6:
+                        (use_lora_6, lora_6, strength_model_6, strength_clip_6) = rls[5]
+                    print(f"[CombiNode] Loaded recipe Slot {slot_idx}.")
+                except Exception:
+                    print(f"[CombiNode] Failed to apply recipe Slot {slot_idx}.")
+
+        # Prompt normalization helper (keeps '|' intact)
+        def _norm_prompt(s: str) -> str:
+            if not isinstance(s, str) or not s:
+                return s or ""
+            s2 = s.replace("\r", " ").replace("\n", " ")
+            s2 = re.sub(r"\s+", " ", s2)
+            s2 = re.sub(r"\s*,\s*", ", ", s2)
+            s2 = re.sub(r"(,\s*){2,}", ", ", s2)
+            return s2.strip()
+
+        # Deterministic dynamic prompt expansion: supports {...}, (...), [...] with '|' choices
+        def _expand_dynamic(text: str, seed_val: int, freeze_before_break: bool = True) -> str:
+            if not isinstance(text, str) or (text.find('|') < 0):
+                return text
+            # Honor |BREAK|: keep first segment intact when requested
+            if freeze_before_break and ('|BREAK|' in text):
+                pre, post = text.split('|BREAK|', 1)
+                return pre + '|BREAK|' + _expand_dynamic(post, seed_val, freeze_before_break=False)
+            rng = random.Random(int(seed_val) & 0xFFFFFFFF)
+            def _expand_pattern(t: str, pat: re.Pattern) -> str:
+                prev = None
+                cur = t
+                while prev != cur:
+                    prev = cur
+                    def repl(m):
+                        body = m.group(1)
+                        choices = [c.strip() for c in body.split('|') if c.strip()]
+                        if not choices:
+                            return m.group(0)
+                        return rng.choice(choices)
+                    cur = pat.sub(repl, cur)
+                return cur
+            for rx in (
+                re.compile(r"\{([^{}]+)\}"),
+                re.compile(r"\(([^()]+)\)"),
+                re.compile(r"\[([^\[\]]+)\]"),
+            ):
+                text = _expand_pattern(text, rx)
+            return text
+
+        # Precompute expanded (or original) texts once
+        pos_text_expanded = _norm_prompt(_expand_dynamic(positive_prompt, int(dyn_seed), bool(dynamic_break_freeze)) if bool(dynamic_pos) else positive_prompt)
+        neg_text_expanded = _norm_prompt(_expand_dynamic(negative_prompt, int(dyn_seed), bool(dynamic_break_freeze)) if bool(dynamic_neg) else negative_prompt)
+
+        if use_checkpoint and checkpoint:
+            checkpoint_path = folder_paths.get_full_path_or_raise("checkpoints", checkpoint)
+            _unload_old_checkpoint(checkpoint_path)
+            base_model, base_clip, vae = _load_checkpoint(checkpoint_path)
+            model = base_model.clone()
+            clip = base_clip.clone()
+            clip_clean = base_clip.clone()  # keep pristine CLIP for standard pipeline path
+
+        elif model_in and clip_in:
+            _unload_old_checkpoint(None)
+            model = model_in.clone()
+            clip = clip_in.clone()
+            clip_clean = clip_in.clone()
+            vae = vae_in
+        else:
+            raise Exception("No model selected!")
+
+        # single clear at start is enough; avoid double-clearing here
+
+        # Применение цепочки LoRA
+        loras = [
+            (use_lora_1, lora_1, strength_model_1, strength_clip_1),
+            (use_lora_2, lora_2, strength_model_2, strength_clip_2),
+            (use_lora_3, lora_3, strength_model_3, strength_clip_3),
+            (use_lora_4, lora_4, strength_model_4, strength_clip_4),
+            (use_lora_5, lora_5, strength_model_5, strength_clip_5),
+            (use_lora_6, lora_6, strength_model_6, strength_clip_6),
+        ]
+
+        active_lora_paths = []
+        lora_stack = []  # list of (lora_file, sc, sm)
+        defer_clip = bool(standard_pipeline)
+        for use_lora, lora_name, sm, sc in loras:
+            if use_lora and lora_name:
+                lora_path = folder_paths.get_full_path_or_raise("loras", lora_name)
+                active_lora_paths.append(lora_path)
+                # keep lora object to avoid reloading
+                if lora_path in _lora_cache:
+                    lora_file = _lora_cache[lora_path]
+                else:
+                    lora_file = comfy.utils.load_torch_file(lora_path, safe_load=True)
+                    _lora_cache[lora_path] = lora_file
+                lora_stack.append((lora_file, float(sc), float(sm)))
+                sc_apply = 0.0 if defer_clip else sc
+                model, clip = comfy.sd.load_lora_for_models(model, clip, lora_file, sm, sc_apply)
+
+        _clear_unused_loras(active_lora_paths)
+        # Warn about duplicate LoRA selections across slots
+        try:
+            counts = {}
+            for p in active_lora_paths:
+                counts[p] = counts.get(p, 0) + 1
+            dups = [p for p, c in counts.items() if c > 1]
+            if dups:
+                print(f"[CombiNode] Duplicate LoRA detected across slots: {len(dups)} file(s).")
+        except Exception:
+            pass
+
+        # Embeddings Positive и Negative
+        # Standard pipeline: optionally use a shared CLIP after clip_layer + CLIP-LoRA
+        # Select CLIP source for encoding: pristine when standard pipeline is enabled
+        src_clip = clip_clean if bool(standard_pipeline) else clip
+
+        pos_gain = float(clip_lora_pos_gain)
+        neg_gain = float(clip_lora_neg_gain)
+        skips_equal = int(clip_set_last_layer_positive) == int(clip_set_last_layer_negative)
+        # Use shared CLIP only if gains are equal and skips equal
+        use_shared = bool(standard_pipeline) and skips_equal and (abs(pos_gain - neg_gain) < 1e-6)
+
+        if (positive_in is None) and (negative_in is None) and use_shared:
+            shared_clip = src_clip.clone()
+            shared_clip.clip_layer(clip_set_last_layer_positive)
+            for lora_file, sc, sm in lora_stack:
+                try:
+                    _m_unused, shared_clip = comfy.sd.load_lora_for_models(model, shared_clip, lora_file, 0.0, sc * pos_gain)
+                except Exception:
+                    pass
+            tokens_pos = shared_clip.tokenize(pos_text_expanded)
+            cond_pos = shared_clip.encode_from_tokens_scheduled(tokens_pos)
+            tokens_neg = shared_clip.tokenize(neg_text_expanded)
+            cond_neg = shared_clip.encode_from_tokens_scheduled(tokens_neg)
+        else:
+            # CLIP Set Last Layer + Positive conditioning
+            clip_pos = src_clip.clone()
+            clip_pos.clip_layer(clip_set_last_layer_positive)
+            if bool(standard_pipeline):
+                for lora_file, sc, sm in lora_stack:
+                    try:
+                        _m_unused, clip_pos = comfy.sd.load_lora_for_models(model, clip_pos, lora_file, 0.0, sc * pos_gain)
+                    except Exception:
+                        pass
+            if positive_in is not None:
+                cond_pos = positive_in
+            else:
+                tokens_pos = clip_pos.tokenize(pos_text_expanded)
+                cond_pos = clip_pos.encode_from_tokens_scheduled(tokens_pos)
+
+            # CLIP Set Last Layer + Negative conditioning
+            clip_neg = src_clip.clone()
+            clip_neg.clip_layer(clip_set_last_layer_negative)
+            if bool(standard_pipeline):
+                for lora_file, sc, sm in lora_stack:
+                    try:
+                        _m_unused, clip_neg = comfy.sd.load_lora_for_models(model, clip_neg, lora_file, 0.0, sc * neg_gain)
+                    except Exception:
+                        pass
+            if negative_in is not None:
+                cond_neg = negative_in
+            else:
+                tokens_neg = clip_neg.tokenize(neg_text_expanded)
+                cond_neg = clip_neg.encode_from_tokens_scheduled(tokens_neg)
+
+        # Optional: show/save expanded prompts if dynamic used anywhere
+        dyn_used = bool(dynamic_pos) or bool(dynamic_neg)
+        if dyn_used and (bool(show_expanded_prompts) or bool(save_expanded_prompts)):
+            # Console print
+            if bool(show_expanded_prompts):
+                try:
+                    print(f"[CombiNode] Expanded prompts (dyn_seed={int(dyn_seed)}):")
+                    def _print_block(name, src, expanded):
+                        print(name + ":")
+                        if bool(dynamic_break_freeze) and ('|BREAK|' in src) and ((name=="Positive" and bool(dynamic_pos)) or (name=="Negative" and bool(dynamic_neg))):
+                            print("  static")
+                        print("  " + expanded)
+                    _print_block("Positive", positive_prompt, pos_text_expanded)
+                    _print_block("Negative", negative_prompt, neg_text_expanded)
+                except Exception:
+                    pass
+            # File save
+            if bool(save_expanded_prompts):
+                try:
+                    base = os.path.join(os.path.dirname(__file__), "dynPrompt")
+                    os.makedirs(base, exist_ok=True)
+                    now = datetime.now()
+                    fname = f"{int(dyn_seed)}_{now.day:02d}_{now.month:02d}_{now.year}.txt"
+                    path = os.path.join(base, fname)
+                    lines = []
+                    def _append_block(name, src, expanded):
+                        lines.append(name + ":\n")
+                        if bool(dynamic_break_freeze) and ('|BREAK|' in src) and ((name=="Positive" and bool(dynamic_pos)) or (name=="Negative" and bool(dynamic_neg))):
+                            lines.append("static\n")
+                        lines.append(expanded + "\n\n")
+                    _append_block("Positive", positive_prompt, pos_text_expanded)
+                    _append_block("Negative", negative_prompt, neg_text_expanded)
+                    with open(path, 'w', encoding='utf-8') as f:
+                        f.writelines(lines)
+                except Exception:
+                    pass
+
+        # Save recipe if requested
+        if slot_idx and bool(recipe_save):
+            data = _recipes_load()
+            data[str(slot_idx)] = {
+                "use_checkpoint": bool(use_checkpoint),
+                "checkpoint": checkpoint,
+                "clip_pos": int(clip_set_last_layer_positive),
+                "clip_neg": int(clip_set_last_layer_negative),
+                "pos_text": str(positive_prompt),
+                "neg_text": str(negative_prompt),
+                "loras": [
+                    [bool(use_lora_1), lora_1, float(strength_model_1), float(strength_clip_1)],
+                    [bool(use_lora_2), lora_2, float(strength_model_2), float(strength_clip_2)],
+                    [bool(use_lora_3), lora_3, float(strength_model_3), float(strength_clip_3)],
+                    [bool(use_lora_4), lora_4, float(strength_model_4), float(strength_clip_4)],
+                    [bool(use_lora_5), lora_5, float(strength_model_5), float(strength_clip_5)],
+                    [bool(use_lora_6), lora_6, float(strength_model_6), float(strength_clip_6)],
+                ],
+            }
+            _recipes_save(data)
+            print(f"[CombiNode] Saved recipe Slot {slot_idx}.")
+
+        # Return the CLIP instance consistent with encoding path
+        return (model, src_clip if bool(standard_pipeline) else clip, cond_pos, cond_neg, vae)
+
+
+
+