Upload 20 files

neutral_prompt_patched/.gitignore

@@ -0,0 +1 @@
+__pycache__/

neutral_prompt_patched/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ljleb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neutral_prompt_patched/README.md

@@ -0,0 +1,99 @@
+# sd-webui-neutral-prompt — Ultimate Edition
+
+> **Unified merge of the main experimental branches.**  
+> Most features from all branches are merged and work simultaneously.  
+> Some `life`/dev-only tooling (debug visualisations, mask images) was intentionally not carried over — only the production-safe subset is included.
+
+---
+
+## What's inside
+
+| Feature | Origin branch | Keyword / setting |
+|---|---|---|
+| Perpendicular projection | `main` | `AND_PERP` |
+| Saliency-guided mask | `main` | `AND_SALT` |
+| Semantic guidance top-k | `main` | `AND_TOPK` |
+| CFG rescale (mean-preserving) | `main` | CFG rescale φ slider |
+| XYZ-grid CFG rescale axis | `main` | XYZ-grid option |
+| External API override | `main` / `export_rescale_factor` | `override_cfg_rescale()` |
+| CFG rescale factor export | `export_rescale_factor` | `get_last_cfg_rescale_factor()` |
+| Affine spatial transforms | `affine` | `ROTATE / SLIDE / SCALE / SHEAR` prefix |
+| Soft alignment blend | `alignment_blend` | `AND_ALIGN_D_S` |
+| Binary alignment mask | `alignment_mask` | `AND_MASK_ALIGN_D_S` |
+| Sharpened saliency maps (k=20) | `life` (production-safe subset) | used automatically by `AND_SALT` |
+
+---
+
+## Prompt syntax
+
+```
+positive prompt text
+AND_PERP  negative-direction text :0.8
+AND_SALT  competing concept :1.0
+AND_TOPK  fine detail tweak :0.5
+AND_ALIGN_4_8  style blend :0.6
+AND_MASK_ALIGN_4_8  structure-preserving style :0.6
+AND_PERP ROTATE[0.125]  rotated perpendicular concept :1.0
+ROTATE[0.125] AND_PERP  rotated perpendicular concept :1.0
+AND_SALT SLIDE[0.05,0]  spatially shifted concept :1.0
+```
+
+### Affine transform keywords
+Affine keywords are supported in **either order** relative to the conciliation keyword:
+
+```
+AND_PERP ROTATE[0.125] vivid colors :0.8   ← affine after keyword
+ROTATE[0.125] AND_PERP vivid colors :0.8   ← affine before keyword (both work)
+```
+
+| Keyword | Parameter | Effect |
+|---|---|---|
+| `ROTATE[angle]` | angle in turns (0–1) | Rotate latent contribution |
+| `SLIDE[x,y]` | normalised offset | Translate latent contribution |
+| `SCALE[x,y]` | scale factors | Scale latent contribution |
+| `SHEAR[x,y]` | shear in turns | Shear latent contribution |
+
+Multiple transforms can be chained: `ROTATE[0.125] SLIDE[0.1,0]`
+
+### AND_ALIGN_D_S / AND_MASK_ALIGN_D_S
+- **D** = detail kernel size (small → fine detail)  
+- **S** = structure kernel size (large → global composition)  
+- The child prompt is blended in proportionally to how much it alters detail *without* changing structure.  
+- `AND_ALIGN` uses a soft weight; `AND_MASK_ALIGN` uses a binary 0/1 mask.  
+- Supported range: D, S ∈ [2, 32], D ≠ S.
+
+---
+
+## External API
+
+```python
+# In another extension or script:
+from lib_neutral_prompt.external_code import override_cfg_rescale, get_last_cfg_rescale_factor
+
+override_cfg_rescale(0.7)          # override for next step only
+factor = get_last_cfg_rescale_factor()  # read after generation
+```
+
+---
+
+## Installation
+
+1. Clone / copy this folder into `stable-diffusion-webui/extensions/`.
+2. Restart the webui.
+
+---
+
+## CFG Rescale φ
+
+When set to a value > 0 the extension rescales the CFG output to have the
+same mean and a partially rescaled standard deviation as the raw predicted x0.
+This reduces colour over-saturation at high CFG values without affecting
+prompt adherence as much as simply lowering CFG.
+
+The formula used is the **mean-preserving** variant from the `main` branch:
+
+```
+rescaled = rescale_mean + (cfg_cond − cfg_cond_mean) × rescale_factor
+```
+
+where `rescale_factor = φ × (std(cond)/std(cfg_cond) − 1) + 1`.

neutral_prompt_patched/lib_neutral_prompt/__init__.py

@@ -0,0 +1 @@
+# lib_neutral_prompt package

neutral_prompt_patched/lib_neutral_prompt/affine_transform.py

@@ -0,0 +1,83 @@
+"""
+Affine spatial transform utilities for latent tensors.
+Extracted from the `affine` branch so that cfg_denoiser_hijack can stay lean.
+
+Provides:
+  apply_affine_transform()        – apply a 2×3 affine grid to a C×H×W tensor
+  apply_masked_transform()        – apply affine + cosine-feathered mask blending
+  create_cosine_feathered_mask()  – smooth circular weight mask
+"""
+
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+
+def apply_affine_transform(
+    tensor: torch.Tensor,
+    affine: torch.Tensor,
+    mode: str = 'bilinear',
+) -> torch.Tensor:
+    """
+    Apply a 2×3 affine transform to a C×H×W tensor, preserving aspect ratio.
+
+    :param tensor: Input tensor of shape [C, H, W].
+    :param affine: 2×3 float32 affine matrix.
+    :param mode: Interpolation mode for grid_sample ('bilinear' default).
+                 The original affine branch used bilinear for the pre-noise
+                 inverse path (smoother) and nearest for post-combine.
+                 Bilinear is the better default for both.
+    :return: Transformed tensor of shape [C, H, W].
+    """
+    affine = affine.clone().to(tensor.device)
+    aspect_ratio = tensor.shape[-2] / tensor.shape[-1]
+    affine[0, 1] *= aspect_ratio
+    affine[1, 0] /= aspect_ratio
+
+    grid = F.affine_grid(affine.unsqueeze(0), tensor.unsqueeze(0).size(), align_corners=False)
+    return F.grid_sample(tensor.unsqueeze(0), grid, mode=mode, align_corners=False).squeeze(0)
+
+
+def apply_masked_transform(
+    tensor: torch.Tensor,
+    affine: torch.Tensor,
+    weight: float,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Apply an affine transform with a cosine-feathered spatial weight mask.
+
+    The mask channel is appended to the tensor before transformation so that
+    the same spatial warp is applied to both content and mask consistently.
+
+    :param tensor: C×H×W latent tensor.
+    :param affine: 2×3 affine matrix.
+    :param weight: Global scalar weight for the mask.
+    :return: (transformed_content [C, H, W], transformed_mask [H, W])
+    """
+    mask = create_cosine_feathered_mask(tensor.shape[-2:], weight).unsqueeze(0).to(tensor.device)
+    tensor_with_mask = torch.cat([tensor, mask], dim=0)          # [C+1, H, W]
+    transformed = apply_affine_transform(tensor_with_mask, affine)
+    return transformed[:-1], transformed[-1]                      # content, mask
+
+
+def create_cosine_feathered_mask(size: Tuple[int, int], weight: float) -> torch.Tensor:
+    """
+    Create a circularly-clipped cosine-feathered mask of shape [H, W].
+
+    Values at the centre approach `weight`; values outside the unit circle
+    are exactly 0, with a smooth cosine fall-off in between.
+
+    :param size: (H, W) tuple.
+    :param weight: Peak mask value at the centre.
+    :return: Float32 mask tensor of shape [H, W].
+    """
+    y, x = torch.meshgrid(
+        torch.linspace(-1, 1, size[0]),
+        torch.linspace(-1, 1, size[1]),
+        indexing='ij',
+    )
+    dist = torch.sqrt(x ** 2 + y ** 2)
+    mask = 0.5 * (1.0 + torch.cos(torch.pi * dist))
+    mask[dist > 1] = 0.0
+    return mask.float() * weight

neutral_prompt_patched/lib_neutral_prompt/cfg_denoiser_hijack.py

@@ -0,0 +1,646 @@
+"""
+Unified CFG Denoiser Hijack
+===========================
+Combines features from all sd-webui-neutral-prompt branches:
+
+  • Core PERP / SALT / TOPK strategies            (main branch)
+  • cfg_rescale with mean-preserving formula       (main branch – better than multiplicative)
+  • cfg_rescale_override (XYZ-grid / API support)  (main branch)
+  • CFGRescaleFactorSingleton export               (export_rescale_factor branch)
+  • Affine spatial transforms per-prompt           (affine branch)
+  • AND_ALIGN_D_S  – soft alignment blend          (alignment_blend branch)
+  • AND_MASK_ALIGN_D_S – binary alignment mask     (alignment_mask branch)
+  • Improved salience with sharpness parameter k   (life branch – production-safe subset)
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+import re
+import sys
+import textwrap
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn.functional as F
+
+from lib_neutral_prompt import affine_transform as affine_mod
+from lib_neutral_prompt import global_state, hijacker, neutral_prompt_parser
+from modules import script_callbacks, sd_samplers, shared
+
+
+# ---------------------------------------------------------------------------
+# Pre-noise affine hook  (affine branch)
+#
+# Applied BEFORE each CFG denoising step: the noisy latent slice for every
+# cond prompt is warped by the INVERSE of that prompt's affine transform.
+# This means the UNet sees the latent in the "locally-rotated" frame of each
+# prompt.  combine_denoised then applies the FORWARD transform to the
+# resulting cond delta, restoring it to the global frame.
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class _PreNoiseArgs:
+    x: torch.Tensor
+    cond_indices: List[Tuple[int, float]]
+
+
+class _GlobalToLocalAffineVisitor:
+    """Build a {cond_index: inverse_affine} dict for every leaf prompt."""
+
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _PreNoiseArgs,
+        index: int,
+    ) -> Dict[int, torch.Tensor]:
+        cond_index = args.cond_indices[index][0]
+        if that.local_transform is not None:
+            # 2×3 → 3×3 → invert → back to 2×3
+            m3 = torch.vstack([that.local_transform,
+                               torch.tensor([0.0, 0.0, 1.0])])
+            inv = torch.linalg.inv(m3)[:-1]
+        else:
+            inv = torch.eye(3)[:-1]
+        return {cond_index: inv}
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _PreNoiseArgs,
+        index: int,
+    ) -> Dict[int, torch.Tensor]:
+        inv_transforms: Dict[int, torch.Tensor] = {}
+
+        for child in that.children:
+            inv_transforms.update(child.accept(_GlobalToLocalAffineVisitor(), args, index))
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+        # Compose parent transform on top of all children
+        if that.local_transform is not None:
+            m3 = torch.vstack([that.local_transform,
+                               torch.tensor([0.0, 0.0, 1.0])])
+            parent_inv = torch.linalg.inv(m3)
+            for inv in inv_transforms.values():
+                # inv is 2×3; extend to 3×3, multiply, trim back
+                inv3 = torch.vstack([inv, torch.tensor([0.0, 0.0, 1.0])])
+                inv[:] = (parent_inv @ inv3)[:-1]
+
+        return inv_transforms
+
+
+def _on_cfg_denoiser(params: script_callbacks.CFGDenoiserParams) -> None:
+    """Pre-noise hook: warp each cond latent slice by the inverse affine."""
+    if not global_state.is_enabled:
+        return
+
+    for prompt, cond_indices in zip(global_state.prompt_exprs,
+                                    global_state.batch_cond_indices):
+        args = _PreNoiseArgs(params.x, cond_indices)
+        inv_transforms = prompt.accept(_GlobalToLocalAffineVisitor(), args, 0)
+        for cond_index, _ in cond_indices:
+            params.x[cond_index] = affine_mod.apply_affine_transform(
+                params.x[cond_index], inv_transforms[cond_index]
+            )
+
+
+script_callbacks.on_cfg_denoiser(_on_cfg_denoiser)
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def combine_denoised_hijack(
+    x_out: torch.Tensor,
+    batch_cond_indices: List[List[Tuple[int, float]]],
+    text_uncond: torch.Tensor,
+    cond_scale: float,
+    original_function,
+) -> torch.Tensor:
+    if not global_state.is_enabled:
+        return original_function(x_out, batch_cond_indices, text_uncond, cond_scale)
+
+    denoised = _get_webui_denoised(x_out, batch_cond_indices, text_uncond, cond_scale, original_function)
+    uncond = x_out[-text_uncond.shape[0]:]
+
+    for batch_i, (prompt, cond_indices) in enumerate(zip(global_state.prompt_exprs, batch_cond_indices)):
+        args = _DenoiseArgs(x_out, uncond[batch_i], cond_indices)
+        cond_delta = prompt.accept(_CondDeltaVisitor(), args, 0)
+        aux_cond_delta = prompt.accept(_AuxCondDeltaVisitor(), args, cond_delta, 0)
+
+        # Apply per-prompt affine transform to both deltas (affine branch)
+        if prompt.local_transform is not None:
+            cond_delta = affine_mod.apply_affine_transform(cond_delta, prompt.local_transform)
+            aux_cond_delta = affine_mod.apply_affine_transform(aux_cond_delta, prompt.local_transform)
+
+        cfg_cond = denoised[batch_i] + aux_cond_delta * cond_scale
+        denoised[batch_i] = _cfg_rescale(cfg_cond, uncond[batch_i] + cond_delta + aux_cond_delta)
+
+    return denoised
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _get_webui_denoised(
+    x_out: torch.Tensor,
+    batch_cond_indices: List[List[Tuple[int, float]]],
+    text_uncond: torch.Tensor,
+    cond_scale: float,
+    original_function,
+) -> torch.Tensor:
+    uncond = x_out[-text_uncond.shape[0]:]
+    sliced_batch_x_out: List[torch.Tensor] = []
+    sliced_batch_cond_indices: List[List[Tuple[int, float]]] = []
+
+    for batch_i, (prompt, cond_indices) in enumerate(zip(global_state.prompt_exprs, batch_cond_indices)):
+        args = _DenoiseArgs(x_out, uncond[batch_i], cond_indices)
+        sliced_x_out, sliced_indices = _gather_webui_conds(prompt, args, 0, len(sliced_batch_x_out))
+        if sliced_indices:
+            sliced_batch_cond_indices.append(sliced_indices)
+        sliced_batch_x_out.extend(sliced_x_out)
+
+    sliced_batch_x_out += list(uncond)
+    return original_function(
+        torch.stack(sliced_batch_x_out, dim=0),
+        sliced_batch_cond_indices,
+        text_uncond,
+        cond_scale,
+    )
+
+
+def _cfg_rescale(cfg_cond: torch.Tensor, cond: torch.Tensor) -> torch.Tensor:
+    """
+    Mean-preserving CFG rescale (main branch formula).
+    Override is applied first so XYZ-grid / external API overrides are never silently skipped.
+    Also stores the computed rescale factor in CFGRescaleFactorSingleton.
+    """
+    # Clear last step's factor so get() returns None if rescaling is skipped
+    # this step (stale value bug fix).
+    global_state.CFGRescaleFactorSingleton.clear()
+
+    # Apply one-shot override BEFORE the early-exit check, otherwise a 0→nonzero
+    # override (from the external API) would be silently discarded.
+    global_state.apply_and_clear_cfg_rescale_override()
+
+    if global_state.cfg_rescale == 0:
+        return cfg_cond
+
+    cfg_std = cfg_cond.std()
+    if cfg_std == 0:
+        # Degenerate case: constant tensor – rescaling is a no-op.
+        return cfg_cond
+
+    cfg_cond_mean = cfg_cond.mean()
+    rescale_mean = (
+        (1 - global_state.cfg_rescale) * cfg_cond_mean
+        + global_state.cfg_rescale * cond.mean()
+    )
+    rescale_factor = global_state.cfg_rescale * (cond.std() / cfg_std - 1) + 1
+
+    # Export for external consumers (export_rescale_factor branch)
+    global_state.CFGRescaleFactorSingleton.set(
+        rescale_factor.item() if isinstance(rescale_factor, torch.Tensor) else float(rescale_factor)
+    )
+
+    return rescale_mean + (cfg_cond - cfg_cond_mean) * rescale_factor
+
+
+@dataclasses.dataclass
+class _DenoiseArgs:
+    x_out: torch.Tensor
+    uncond: torch.Tensor
+    cond_indices: List[Tuple[int, float]]
+
+
+# ---------------------------------------------------------------------------
+# Gather webui-style conditions (needed for the webui's own CFG path)
+# ---------------------------------------------------------------------------
+
+def _gather_webui_conds(
+    prompt: neutral_prompt_parser.CompositePrompt,
+    args: _DenoiseArgs,
+    index_in: int,
+    index_out: int,
+) -> Tuple[List[torch.Tensor], List[Tuple[int, float]]]:
+    sliced_x_out: List[torch.Tensor] = []
+    sliced_cond_indices: List[Tuple[int, float]] = []
+
+    for child in prompt.children:
+        if child.conciliation is None:
+            if isinstance(child, neutral_prompt_parser.LeafPrompt) and child.local_transform is None:
+                child_x_out = args.x_out[args.cond_indices[index_in][0]]
+                child_weight = child.weight
+            else:
+                child_x_out, child_weight = _get_cond_delta_and_weight(child, args, index_in)
+                child_x_out = child_x_out + args.uncond
+
+            index_offset = index_out + len(sliced_x_out)
+            sliced_x_out.append(child_x_out)
+            sliced_cond_indices.append((index_offset, child_weight))
+
+        index_in += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+    return sliced_x_out, sliced_cond_indices
+
+
+def _get_cond_delta_and_weight(
+    prompt: neutral_prompt_parser.PromptExpr,
+    args: _DenoiseArgs,
+    index: int,
+) -> Tuple[torch.Tensor, float]:
+    """Compute cond delta and effective weight, applying affine transform if present."""
+    cond_delta = prompt.accept(_CondDeltaVisitor(), args, index)
+    cond_delta = cond_delta + prompt.accept(_AuxCondDeltaVisitor(), args, cond_delta, index)
+    weight = prompt.weight
+
+    if prompt.local_transform is not None:
+        transformed, weight_tensor = affine_mod.apply_masked_transform(
+            cond_delta + args.uncond,
+            prompt.local_transform,
+            prompt.weight,
+        )
+        cond_delta = transformed - args.uncond
+        weight = weight_tensor  # type: ignore[assignment]
+
+    return cond_delta, weight
+
+
+# ---------------------------------------------------------------------------
+# Visitor: CondDelta  – weighted sum of leaf cond − uncond
+# ---------------------------------------------------------------------------
+
+class _CondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _DenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        cond_info = args.cond_indices[index]
+        if that.weight != cond_info[1]:
+            _console_warn(f'''
+                An unexpected noise weight was encountered at prompt #{index}
+                Expected :{that.weight}, but got :{cond_info[1]}
+                This is likely due to another extension also monkey patching `combine_denoised`.
+                Please open a bug report: https://github.com/ljleb/sd-webui-neutral-prompt/issues
+            ''')
+        return args.x_out[cond_info[0]] - args.uncond
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _DenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        cond_delta = torch.zeros_like(args.x_out[0])
+        for child in that.children:
+            if child.conciliation is None:
+                child_delta, child_weight = _get_cond_delta_and_weight(child, args, index)
+                cond_delta = cond_delta + child_weight * child_delta
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+        return cond_delta
+
+
+# ---------------------------------------------------------------------------
+# Visitor: AuxCondDelta – all conciliation strategies
+# ---------------------------------------------------------------------------
+
+class _AuxCondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _DenoiseArgs,
+        cond_delta: torch.Tensor,
+        index: int,
+    ) -> torch.Tensor:
+        return torch.zeros_like(args.x_out[0])
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _DenoiseArgs,
+        cond_delta: torch.Tensor,
+        index: int,
+    ) -> torch.Tensor:
+        aux_cond_delta = torch.zeros_like(args.x_out[0])
+        salient_cond_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT  k=20
+        salient_wide_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT_WIDE k=1
+        salient_blob_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT_BLOB k=20 + morphology
+        align_blend_deltas: List[Tuple[torch.Tensor, float, int, int]] = []
+        mask_align_deltas: List[Tuple[torch.Tensor, float, int, int]] = []
+
+        for child in that.children:
+            if child.conciliation is not None:
+                child_delta, child_weight = _get_cond_delta_and_weight(child, args, index)
+                strat = child.conciliation
+
+                if strat == neutral_prompt_parser.ConciliationStrategy.PERPENDICULAR:
+                    aux_cond_delta = aux_cond_delta + child_weight * _get_perpendicular_component(cond_delta, child_delta)
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK:
+                    salient_cond_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK_WIDE:
+                    salient_wide_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK_BLOB:
+                    salient_blob_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SEMANTIC_GUIDANCE:
+                    aux_cond_delta = aux_cond_delta + child_weight * _filter_abs_top_k(child_delta, 0.05)
+
+                else:
+                    # AND_ALIGN_D_S  (soft alignment blend)
+                    m = re.match(r'AND_ALIGN_(\d+)_(\d+)', strat.value)
+                    if m:
+                        align_blend_deltas.append((child_delta, child_weight, int(m.group(1)), int(m.group(2))))
+                    else:
+                        # AND_MASK_ALIGN_D_S  (binary alignment mask)
+                        m = re.match(r'AND_MASK_ALIGN_(\d+)_(\d+)', strat.value)
+                        if m:
+                            mask_align_deltas.append((child_delta, child_weight, int(m.group(1)), int(m.group(2))))
+
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+        aux_cond_delta = aux_cond_delta + _salient_blend(cond_delta, salient_cond_deltas, child_k=20)
+        aux_cond_delta = aux_cond_delta + _salient_blend(cond_delta, salient_wide_deltas,  child_k=1)
+        aux_cond_delta = aux_cond_delta + _salient_blend_blob(cond_delta, salient_blob_deltas)
+        aux_cond_delta = aux_cond_delta + _alignment_blend(cond_delta, align_blend_deltas)
+        aux_cond_delta = aux_cond_delta + _alignment_mask_blend(cond_delta, mask_align_deltas)
+        return aux_cond_delta
+
+
+# ---------------------------------------------------------------------------
+# Strategy implementations
+# ---------------------------------------------------------------------------
+
+def _get_perpendicular_component(normal: torch.Tensor, vector: torch.Tensor) -> torch.Tensor:
+    if (normal == 0).all():
+        if shared.state.sampling_step <= 0:
+            _warn_projection_not_found()
+        return vector
+    return vector - normal * torch.sum(normal * vector) / torch.norm(normal) ** 2
+
+
+def _salient_blend(
+    normal: torch.Tensor,
+    vectors: List[Tuple[torch.Tensor, float]],
+    child_k: float = 20.0,
+) -> torch.Tensor:
+    """
+    Saliency-guided blend: each child prompt wins in the latent regions
+    where its absolute activation magnitude is strongest.
+
+    child_k controls how sharp/selective the child salience mask is:
+      child_k=20  → very sharp, 1-2 peak pixels  (AND_SALT  — life-branch style)
+      child_k=1   → broad, ~55% of pixels        (AND_SALT_WIDE — original main-branch)
+    Parent always uses k=1 (diffuse reference).
+    """
+    if not vectors:
+        return torch.zeros_like(normal)
+
+    salience_maps = [_get_salience(normal, k=1)] + [_get_salience(v, k=child_k) for v, _ in vectors]
+    mask = torch.argmax(torch.stack(salience_maps, dim=0), dim=0)
+
+    result = torch.zeros_like(normal)
+    for mask_i, (vector, weight) in enumerate(vectors, start=1):
+        vector_mask = (mask == mask_i).float()
+        result = result + weight * vector_mask * (vector - normal)
+    return result
+
+
+def _salient_blend_blob(
+    normal: torch.Tensor,
+    vectors: List[Tuple[torch.Tensor, float]],
+) -> torch.Tensor:
+    """
+    AND_SALT_BLOB: life-branch dev.py algorithm (cleaned of debug scaffolding).
+
+    Pipeline per child:
+      1. k=20 softmax → very sharp salience seed (1-2 pixels)
+      2. _life_erode  ×6 → erode to spatially dense core
+      3. _life_thickify ×2 → grow outward into a smooth blob
+      4. result += weight × blob_mask × (child − parent)
+
+    This is what the life-branch author was iterating toward in dev.py.
+    """
+    if not vectors:
+        return torch.zeros_like(normal)
+
+    salience_maps = [_get_salience(normal, k=1)] + [_get_salience(v, k=20) for v, _ in vectors]
+    mask = torch.argmax(torch.stack(salience_maps, dim=0), dim=0)
+
+    result = torch.zeros_like(normal)
+    for mask_i, (vector, weight) in enumerate(vectors, start=1):
+        vector_mask = (mask == mask_i).float()
+        for _ in range(6):
+            vector_mask = _life_step(vector_mask, _erode_rule)
+        for _ in range(2):
+            vector_mask = _life_step(vector_mask, _thickify_rule)
+        result = result + weight * vector_mask * (vector - normal)
+    return result
+
+
+def _life_step(board: torch.Tensor, rule) -> torch.Tensor:
+    """
+    One step of a cellular-automaton morphology on a C×H×W binary mask.
+
+    The conv3d trick from dev.py: concatenate [board, board[:-1]] along the
+    channel axis so a single 3-D convolution simultaneously sums the 3×3
+    spatial neighbourhood across *all* C channels.  This keeps the operation
+    GPU-friendly and avoids an explicit loop over channels.
+
+    neighbors[c,h,w] = Σ_{dc,dh,dw} board_padded[c+dc, h+dh, w+dw]
+                       minus the center pixel itself (board is subtracted).
+    """
+    C = board.shape[0]
+    kernel = torch.ones((C, 3, 3), dtype=board.dtype, device=board.device)
+    kernel = kernel.unsqueeze(0).unsqueeze(0)   # [1, 1, C, 3, 3]
+
+    # Pad spatially (left/right/top/bottom) but not along channel axis
+    padded = torch.cat([board.clone(), board[:-1].clone()], dim=0)          # [2C-1, H, W]
+    padded = torch.nn.functional.pad(padded, (1, 1, 1, 1, 0, 0), value=0)  # [2C-1, H+2, W+2]
+
+    neighbors = torch.nn.functional.conv3d(
+        padded.unsqueeze(0).unsqueeze(0),   # [1, 1, 2C-1, H+2, W+2]
+        kernel,                              # [1, 1,    C,   3,   3]
+        padding=0,
+    ).squeeze(0).squeeze(0)                 # [C, H, W]
+
+    neighbors = neighbors - board           # subtract center pixel
+    return rule(board, neighbors).float()
+
+
+def _erode_rule(board: torch.Tensor, neighbors: torch.Tensor) -> torch.Tensor:
+    """Keep a pixel only if it is set AND its C-channel neighbourhood is dense.
+    Threshold C*5 matches dev.py: for C=4 that means ≥20 out of 36 possible."""
+    C = board.shape[0]
+    return (board == 1) & (neighbors >= C * 5)
+
+
+def _thickify_rule(board: torch.Tensor, neighbors: torch.Tensor) -> torch.Tensor:
+    """Grow: keep existing pixels OR add any pixel adjacent to the core.
+    population ≥ 4 ensures only pixels touching at least one set neighbour grow."""
+    population = board + neighbors
+    return (board == 1) | (population >= 4)
+
+
+def _get_salience(vector: torch.Tensor, k: float = 1.0) -> torch.Tensor:
+    """Softmax-based salience map.  k > 1 → sharper, more selective mask."""
+    return torch.softmax(k * torch.abs(vector).flatten(), dim=0).reshape_as(vector)
+
+
+def _filter_abs_top_k(vector: torch.Tensor, k_ratio: float) -> torch.Tensor:
+    """Keep only the top k_ratio fraction of activations by absolute value."""
+    k = int(torch.numel(vector) * (1 - k_ratio))
+    k = max(1, k)  # kthvalue requires k >= 1
+    threshold, _ = torch.kthvalue(torch.abs(vector.flatten()), k)
+    return vector * (torch.abs(vector) >= threshold).to(vector.dtype)
+
+
+# ---------------------------------------------------------------------------
+# Alignment blend  (alignment_blend branch)
+# ---------------------------------------------------------------------------
+
+def _compute_subregion_similarity_map(
+    child_vector: torch.Tensor,
+    parent_vector: torch.Tensor,
+    region_size: int = 2,
+) -> torch.Tensor:
+    """
+    Compute local average cosine similarity of (region_size × region_size) regions.
+    Returns a map of shape [C, H, W] with values in [-1, 1].
+    """
+    C, H, W = child_vector.shape
+    parent = parent_vector.unsqueeze(0)   # [1, C, H, W]
+    child  = child_vector.unsqueeze(0)
+
+    region_radius = region_size // 2
+    if region_size % 2 == 1:
+        pad_size = (region_radius,) * 4
+    else:
+        pad_size = (region_radius - 1, region_radius) * 2
+
+    parent_reg = F.unfold(F.pad(parent, pad_size, 'constant', 0), kernel_size=region_size)
+    child_reg  = F.unfold(F.pad(child,  pad_size, 'constant', 0), kernel_size=region_size)
+
+    # [H*W, C, region_size, region_size]
+    # .contiguous() is required before .view() because .permute() produces a
+    # non-contiguous tensor and .view() raises RuntimeError on non-contiguous input.
+    parent_reg = parent_reg.view(1, C, region_size**2, H*W).permute(3, 1, 2, 0).contiguous().view(H*W, C, region_size, region_size)
+    child_reg  = child_reg.view( 1, C, region_size**2, H*W).permute(3, 1, 2, 0).contiguous().view(H*W, C, region_size, region_size)
+
+    unfold2 = torch.nn.Unfold(kernel_size=2)
+    parent_sub = unfold2(parent_reg).view(H*W, C, 4, (region_size - 1)**2)
+    child_sub  = unfold2(child_reg ).view(H*W, C, 4, (region_size - 1)**2)
+
+    parent_sub = F.normalize(parent_sub, p=2, dim=2)
+    child_sub  = F.normalize(child_sub,  p=2, dim=2)
+    sim = (parent_sub * child_sub).sum(dim=2)                        # [H*W, C, (r-1)^2]
+    return sim.mean(dim=2).permute(1, 0).contiguous().view(C, H, W) # [C, H, W]
+
+
+def _alignment_blend(
+    parent: torch.Tensor,
+    children: List[Tuple[torch.Tensor, float, int, int]],
+) -> torch.Tensor:
+    """
+    Soft alignment blend (AND_ALIGN_D_S).
+    Child contribution is weighted by max(0, structure_alignment − detail_alignment).
+    High weight where child changes detail without breaking structure.
+    """
+    result = torch.zeros_like(parent)
+    for child, weight, detail_size, structure_size in children:
+        detail_sim    = _compute_subregion_similarity_map(child, parent, detail_size)
+        structure_sim = _compute_subregion_similarity_map(child, parent, structure_size)
+
+        # Normalise by absolute max so that all-negative maps (anti-correlated prompts
+        # such as 'black' vs 'white') don't blow up to ±1e7 and clamp incorrectly to 1.
+        # Dividing by positive max would invert the sign ordering when all values are
+        # negative; dividing by abs-max preserves relative ordering in both cases.
+        d_abs_max = detail_sim.abs().max().clamp(min=1e-8)
+        s_abs_max = structure_sim.abs().max().clamp(min=1e-8)
+        detail_sim    = detail_sim    / d_abs_max
+        structure_sim = structure_sim / s_abs_max
+
+        alignment_weight = torch.clamp(structure_sim - detail_sim, min=0.0, max=1.0)
+        result = result + (child - parent) * weight * alignment_weight
+    return result
+
+
+def _alignment_mask_blend(
+    parent: torch.Tensor,
+    children: List[Tuple[torch.Tensor, float, int, int]],
+) -> torch.Tensor:
+    """
+    Binary alignment mask (AND_MASK_ALIGN_D_S).
+    Child receives full weight where structure_alignment > detail_alignment, zero elsewhere.
+    """
+    result = torch.zeros_like(parent)
+    for child, weight, detail_size, structure_size in children:
+        detail_sim    = _compute_subregion_similarity_map(child, parent, detail_size)
+        structure_sim = _compute_subregion_similarity_map(child, parent, structure_size)
+
+        d_abs_max = detail_sim.abs().max().clamp(min=1e-8)
+        s_abs_max = structure_sim.abs().max().clamp(min=1e-8)
+        detail_sim    = detail_sim    / d_abs_max
+        structure_sim = structure_sim / s_abs_max
+
+        alignment_mask = (structure_sim > detail_sim).to(child)
+        result = result + (child - parent) * weight * alignment_mask
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Sampler hijack
+# ---------------------------------------------------------------------------
+
+sd_samplers_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=sd_samplers,
+    hijacker_attribute='__neutral_prompt_hijacker',
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+
+@sd_samplers_hijacker.hijack('create_sampler')
+def create_sampler_hijack(name: str, model, original_function):
+    sampler = original_function(name, model)
+    if not hasattr(sampler, 'model_wrap_cfg') or not hasattr(sampler.model_wrap_cfg, 'combine_denoised'):
+        if global_state.is_enabled:
+            _warn_unsupported_sampler()
+        return sampler
+
+    sampler.model_wrap_cfg.combine_denoised = functools.partial(
+        combine_denoised_hijack,
+        original_function=sampler.model_wrap_cfg.combine_denoised,
+    )
+    return sampler
+
+
+# ---------------------------------------------------------------------------
+# Warnings / logging
+# ---------------------------------------------------------------------------
+
+def _warn_unsupported_sampler() -> None:
+    _console_warn('''
+        Neutral prompt relies on composition via AND, which the webui does not support
+        when using any of the DDIM, PLMS and UniPC samplers.
+        The sampler will NOT be patched – falling back on the original implementation.
+    ''')
+
+
+def _warn_projection_not_found() -> None:
+    _console_warn('''
+        Could not find a projection for one or more AND_PERP prompts.
+        These prompts will NOT be made perpendicular.
+    ''')
+
+
+def _console_warn(message: str) -> None:
+    if not global_state.verbose:
+        return
+    print(f'\n[sd-webui-neutral-prompt]{textwrap.dedent(message)}', file=sys.stderr)

neutral_prompt_patched/lib_neutral_prompt/external_code/__init__.py

@@ -0,0 +1,23 @@
+import contextlib
+
+
+@contextlib.contextmanager
+def fix_path():
+    import sys
+    from pathlib import Path
+
+    extension_path = str(Path(__file__).parent.parent.parent)
+    added = False
+    if extension_path not in sys.path:
+        sys.path.insert(0, extension_path)
+        added = True
+
+    yield
+
+    if added:
+        sys.path.remove(extension_path)
+
+
+with fix_path():
+    del fix_path, contextlib
+    from .api import *

neutral_prompt_patched/lib_neutral_prompt/external_code/api.py

@@ -0,0 +1,27 @@
+"""
+External API for sd-webui-neutral-prompt.
+
+Provides thin helpers that external extensions / scripts can import via:
+
+    from lib_neutral_prompt.external_code import override_cfg_rescale, get_last_cfg_rescale_factor
+"""
+
+from typing import Optional
+
+from lib_neutral_prompt import global_state
+
+
+def override_cfg_rescale(cfg_rescale: float) -> None:
+    """
+    Override the CFG rescale value for the *next* generation step only.
+    After the step runs the value is automatically cleared.
+    """
+    global_state.cfg_rescale_override = cfg_rescale
+
+
+def get_last_cfg_rescale_factor() -> Optional[float]:
+    """
+    Return the CFG rescale factor computed during the most recent denoising
+    step, or None if rescaling was not active.
+    """
+    return global_state.CFGRescaleFactorSingleton.get()

neutral_prompt_patched/lib_neutral_prompt/global_state.py

@@ -0,0 +1,75 @@
+"""
+Global mutable state shared across the extension.
+
+Combines:
+  - is_enabled / prompt_exprs / verbose  (all branches)
+  - cfg_rescale + cfg_rescale_override mechanism  (main branch)
+  - batch_cond_indices  (affine branch – needed by on_cfg_denoiser pre-noise hook)
+  - CFGRescaleFactorSingleton – exposes the last computed rescale factor
+    to external callers / API users  (export_rescale_factor branch)
+"""
+
+import threading
+from typing import List, Optional, Tuple
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+# ---------------------------------------------------------------------------
+# Runtime state
+# ---------------------------------------------------------------------------
+
+is_enabled: bool = False
+prompt_exprs: List[neutral_prompt_parser.PromptExpr] = []
+# Populated by reconstruct_multicond_batch hook; used by the pre-noise
+# affine transform hook (on_cfg_denoiser) to know which latent slices
+# correspond to which prompt child.
+batch_cond_indices: List[List[Tuple[int, float]]] = []
+cfg_rescale: float = 0.0
+verbose: bool = False  # matches UI default; UI syncs this on settings load
+
+# Set to a float value by XYZ-grid or external API to override cfg_rescale
+# for a single generation step, then auto-cleared.
+cfg_rescale_override: Optional[float] = None
+
+
+def apply_and_clear_cfg_rescale_override() -> None:
+    """Apply a one-shot cfg_rescale override and immediately clear it."""
+    global cfg_rescale, cfg_rescale_override
+    if cfg_rescale_override is not None:
+        cfg_rescale = cfg_rescale_override
+        cfg_rescale_override = None
+
+
+# ---------------------------------------------------------------------------
+# CFG Rescale Factor Singleton  (export_rescale_factor branch)
+#
+# Stores the last computed rescale factor so that external tools / scripts
+# can read it without re-deriving it.
+#
+# Uses threading.local() so concurrent API workers each get their own slot.
+# clear() must be called at the start of every _cfg_rescale() call so that
+# get() correctly returns None when rescaling was skipped this step.
+# ---------------------------------------------------------------------------
+
+class CFGRescaleFactorSingleton:
+    """Thread-local store for the most recently computed CFG rescale factor.
+
+    Lifecycle per denoising step:
+      1. _cfg_rescale() calls clear() at entry — value becomes None.
+      2. If rescaling is active, set() stores the computed factor.
+      3. External code calls get() after the step; receives the factor or None.
+    """
+
+    _state = threading.local()
+
+    @classmethod
+    def set(cls, value: float) -> None:
+        cls._state.cfg_rescale_factor = value
+
+    @classmethod
+    def get(cls) -> Optional[float]:
+        return getattr(cls._state, 'cfg_rescale_factor', None)
+
+    @classmethod
+    def clear(cls) -> None:
+        cls._state.cfg_rescale_factor = None

neutral_prompt_patched/lib_neutral_prompt/hijacker.py

@@ -0,0 +1,34 @@
+import functools
+
+
+class ModuleHijacker:
+    def __init__(self, module):
+        self.__module = module
+        self.__original_functions = dict()
+
+    def hijack(self, attribute):
+        if attribute not in self.__original_functions:
+            self.__original_functions[attribute] = getattr(self.__module, attribute)
+
+        def decorator(function):
+            setattr(self.__module, attribute, functools.partial(function, original_function=self.__original_functions[attribute]))
+            return function
+
+        return decorator
+
+    def reset_module(self):
+        for attribute, original_function in self.__original_functions.items():
+            setattr(self.__module, attribute, original_function)
+
+        self.__original_functions.clear()
+
+    @staticmethod
+    def install_or_get(module, hijacker_attribute, on_uninstall=lambda _callback: None):
+        if not hasattr(module, hijacker_attribute):
+            module_hijacker = ModuleHijacker(module)
+            setattr(module, hijacker_attribute, module_hijacker)
+            on_uninstall(lambda: delattr(module, hijacker_attribute))
+            on_uninstall(module_hijacker.reset_module)
+            return module_hijacker
+        else:
+            return getattr(module, hijacker_attribute)

neutral_prompt_patched/lib_neutral_prompt/neutral_prompt_parser.py

@@ -0,0 +1,382 @@
+"""
+Unified Neutral Prompt Parser
+Combines:
+  - Core AND / AND_PERP / AND_SALT / AND_TOPK strategies (main branch)
+  - Affine spatial transforms: ROTATE / SLIDE / SCALE / SHEAR (affine branch)
+  - Local alignment blend: AND_ALIGN_D_S / AND_MASK_ALIGN_D_S  (alignment_blend branch)
+"""
+
+import abc
+import dataclasses
+import math
+import re
+from enum import Enum
+from itertools import product
+from typing import Any, List, Optional, Tuple
+
+import torch
+
+
+# ---------------------------------------------------------------------------
+# Keyword registry
+# ---------------------------------------------------------------------------
+
+# Base conciliation keywords
+_BASE_KEYWORD_MAP = {
+    'AND_PERP':      'PERPENDICULAR',
+    'AND_SALT':      'SALIENCE_MASK',       # k=20 sharp mask  (life-branch style)
+    'AND_SALT_WIDE': 'SALIENCE_MASK_WIDE',  # k=1  broad mask  (original main-branch behaviour)
+    'AND_SALT_BLOB': 'SALIENCE_MASK_BLOB',  # k=20 + erode + thickify → smooth blob (dev.py intent)
+    'AND_TOPK':      'SEMANTIC_GUIDANCE',
+}
+
+# Alignment blend: AND_ALIGN_D_S  (soft weight, structure > detail)
+_ALIGN_KEYWORD_MAP = {
+    f'AND_ALIGN_{i}_{j}': f'ALIGNMENT_BLEND_{i}_{j}'
+    for i, j in product(range(2, 33), repeat=2) if i != j
+}
+
+# Alignment mask: AND_MASK_ALIGN_D_S  (binary mask, structure > detail)
+_MASK_ALIGN_KEYWORD_MAP = {
+    f'AND_MASK_ALIGN_{i}_{j}': f'ALIGNMENT_MASK_BLEND_{i}_{j}'
+    for i, j in product(range(2, 33), repeat=2) if i != j
+}
+
+keyword_mapping = _BASE_KEYWORD_MAP | _ALIGN_KEYWORD_MAP | _MASK_ALIGN_KEYWORD_MAP
+
+PromptKeyword = Enum('PromptKeyword', {'AND': 'AND', **{k: k for k in keyword_mapping}})
+ConciliationStrategy = Enum('ConciliationStrategy', {v: k for k, v in keyword_mapping.items()})
+
+# Lists kept for ordered iteration (tokenize uses list order for regex priority)
+prompt_keywords = [e.value for e in PromptKeyword]
+conciliation_strategies = [e.value for e in ConciliationStrategy]
+
+# Sets for O(1) membership checks in parser hot-loops (1864-item list = 230x slower)
+_prompt_keywords_set = frozenset(prompt_keywords)
+_conciliation_strategies_set = frozenset(conciliation_strategies)
+
+
+# ---------------------------------------------------------------------------
+# Affine transform definitions  (from affine branch)
+# ---------------------------------------------------------------------------
+
+affine_transforms = {
+    'ROTATE': lambda t, angle=0, *_: t @ torch.tensor([
+        [math.cos(angle * 2 * math.pi), -math.sin(angle * 2 * math.pi), 0],
+        [math.sin(angle * 2 * math.pi),  math.cos(angle * 2 * math.pi), 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SLIDE': lambda t, x=0, y=0, *_: t @ torch.tensor([
+        [1, 0, float(x)],
+        [0, 1, float(y)],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SCALE': lambda t, x=1, y=None, *_: t @ torch.tensor([
+        [float(x), 0, 0],
+        [0, float(y) if y is not None else float(x), 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SHEAR': lambda t, x=0, y=None, *_: t @ torch.tensor([
+        [1, math.tan(float(x) * 2 * math.pi), 0],
+        [math.tan(float(y if y is not None else x) * 2 * math.pi), 1, 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+}
+
+
+# ---------------------------------------------------------------------------
+# AST node types
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class PromptExpr(abc.ABC):
+    weight: float
+    conciliation: Optional[ConciliationStrategy]
+    local_transform: Optional[torch.Tensor]  # 2×3 affine tensor or None
+
+    @abc.abstractmethod
+    def accept(self, visitor, *args, **kwargs) -> Any:
+        pass
+
+
+@dataclasses.dataclass
+class LeafPrompt(PromptExpr):
+    prompt: str
+
+    def accept(self, visitor, *args, **kwargs):
+        return visitor.visit_leaf_prompt(self, *args, **kwargs)
+
+
+@dataclasses.dataclass
+class CompositePrompt(PromptExpr):
+    children: List[PromptExpr]
+
+    def accept(self, visitor, *args, **kwargs):
+        return visitor.visit_composite_prompt(self, *args, **kwargs)
+
+
+class FlatSizeVisitor:
+    def visit_leaf_prompt(self, that: LeafPrompt) -> int:
+        return 1
+
+    def visit_composite_prompt(self, that: CompositePrompt) -> int:
+        return sum(child.accept(self) for child in that.children) if that.children else 0
+
+
+# ---------------------------------------------------------------------------
+# Parser
+# ---------------------------------------------------------------------------
+
+def parse_root(string: str) -> CompositePrompt:
+    tokens = tokenize(string)
+    prompts = parse_prompts(tokens)
+    return CompositePrompt(1.0, None, None, prompts)
+
+
+def parse_prompts(tokens: List[str], *, nested: bool = False) -> List[PromptExpr]:
+    prompts = [parse_prompt(tokens, first=True, nested=nested)]
+    while tokens:
+        if nested and tokens[0] == ']':
+            break
+        prompts.append(parse_prompt(tokens, first=False, nested=nested))
+    return prompts
+
+
+def _compose_affine(
+    a: Optional[torch.Tensor],
+    b: Optional[torch.Tensor],
+) -> Optional[torch.Tensor]:
+    """
+    Compose two 2×3 affine matrices (a applied first, then b).
+    Returns None if both are None; returns the non-None one if only one exists.
+    """
+    if a is None:
+        return b
+    if b is None:
+        return a
+    # Lift to 3×3, multiply, trim back to 2×3
+    a3 = torch.vstack([a, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32)])
+    b3 = torch.vstack([b, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32)])
+    return (b3 @ a3)[:-1]
+
+
+def _looks_like_leading_affine_prompt(tokens: List[str]) -> bool:
+    """
+    Return True if `tokens` starts with one or more affine keywords followed
+    immediately by a prompt keyword, e.g.:
+        ROTATE[0.125] AND_PERP ...
+        SLIDE[0.05,0] AND_SALT ...
+        ROTATE[0.125] SLIDE[0.05,0] AND_PERP ...
+
+    This is a pure structural scan — it does NOT compute any affine matrices,
+    so it is safe to call as a look-ahead probe without mock-torch issues.
+
+    Used in two places:
+      - parse_prompt()         → consume leading affine before keyword
+      - _parse_prompt_text()   → stop current segment before this boundary
+    """
+    pos = 0
+    n = len(tokens)
+    # skip a leading whitespace-only token
+    if pos < n and not tokens[pos].strip():
+        pos += 1
+    # must start with an affine keyword
+    if pos >= n or tokens[pos] not in affine_transforms:
+        return False
+    # consume one or more  KEYWORD [ args ] blocks
+    while pos < n and tokens[pos] in affine_transforms:
+        pos += 1                          # skip keyword
+        if pos >= n or tokens[pos] != '[':
+            return False
+        pos += 1                          # skip '['
+        if pos < n and tokens[pos] != ']':
+            pos += 1                      # skip args (may contain commas)
+        if pos >= n or tokens[pos] != ']':
+            return False
+        pos += 1                          # skip ']'
+        if pos < n and not tokens[pos].strip():
+            pos += 1                      # skip optional whitespace
+    # the very next token must be a prompt keyword
+    return pos < n and tokens[pos] in _prompt_keywords_set
+
+
+def parse_prompt(tokens: List[str], *, first: bool, nested: bool = False) -> PromptExpr:
+    # Support two affine-keyword orderings:
+    #   (A) AND_PERP ROTATE[0.25] text   ← trailing affine (original syntax)
+    #   (B) ROTATE[0.25] AND_PERP text   ← leading affine (documented syntax)
+    #
+    # Note: we check _looks_like_leading_affine_prompt unconditionally (not
+    # gated on `not first`) so that a prompt starting with e.g.
+    # "ROTATE[0.125] AND_PERP text" is handled correctly even as the first
+    # segment.
+    leading_affine: Optional[torch.Tensor] = None
+    if _looks_like_leading_affine_prompt(tokens):
+        probe = tokens.copy()
+        leading_affine = _parse_affine_transform(probe)
+        tokens[:] = probe
+
+    # After consuming a leading affine the next token is a keyword; accept it.
+    # We also accept a keyword as the very first token (first=True) without a
+    # leading affine — e.g. "AND_PERP vivid" at the start of a string should
+    # produce a single PERP child, not an empty default child followed by a PERP
+    # child.  The original `not first` guard was an artefact of earlier grammar;
+    # all existing tests pass without it.
+    if tokens and tokens[0] in _prompt_keywords_set:
+        prompt_type = tokens.pop(0)
+    else:
+        prompt_type = PromptKeyword.AND.value
+
+    conciliation = ConciliationStrategy(prompt_type) if prompt_type in _conciliation_strategies_set else None
+
+    # Parse optional trailing affine transform chain (original syntax)
+    trailing_affine = _parse_affine_transform(tokens)
+    affine_transform = _compose_affine(leading_affine, trailing_affine)
+
+    # Try composite (bracketed) form
+    tokens_copy = tokens.copy()
+    if tokens_copy and tokens_copy[0] == '[':
+        tokens_copy.pop(0)
+        prompts = parse_prompts(tokens_copy, nested=True)
+        if tokens_copy:
+            assert tokens_copy.pop(0) == ']'
+        if len(prompts) > 1:
+            tokens[:] = tokens_copy
+            weight = _parse_weight(tokens)
+            return CompositePrompt(weight, conciliation, affine_transform, prompts)
+
+    prompt_text, weight = _parse_prompt_text(tokens, nested=nested)
+    return LeafPrompt(weight, conciliation, affine_transform, prompt_text)
+
+
+def _parse_prompt_text(tokens: List[str], *, nested: bool = False) -> Tuple[str, float]:
+    text = ''
+    depth = 0
+    weight = 1.0
+    while tokens:
+        tok = tokens[0]
+        if tok == ']':
+            if depth == 0:
+                if nested:
+                    break
+            else:
+                depth -= 1
+        elif tok == '[':
+            depth += 1
+        elif tok == ':':
+            if len(tokens) >= 2 and _is_float(tokens[1].strip()):
+                if len(tokens) < 3 or tokens[2] in _prompt_keywords_set or (tokens[2] == ']' and depth == 0):
+                    tokens.pop(0)
+                    weight = float(tokens.pop(0).strip())
+                    break
+        elif tok in _prompt_keywords_set:
+            break
+        # Stop before a leading-affine-then-keyword boundary, e.g.
+        #   ROTATE[0.125] AND_PERP text
+        # so the affine is consumed by the *next* parse_prompt call, not
+        # swallowed as raw text by the current segment.
+        elif depth == 0 and _looks_like_leading_affine_prompt(tokens):
+            break
+        text += tokens.pop(0)
+    return text, weight
+
+
+def _parse_affine_transform(tokens: List[str]) -> Optional[torch.Tensor]:
+    """
+    Consume optional affine keywords like ROTATE[0.25] SLIDE[0.1,0] from the token stream.
+    Returns a 2×3 float32 tensor, or None if no affine tokens were found.
+    """
+    tokens_copy = tokens.copy()
+    if tokens_copy and not tokens_copy[0].strip():
+        tokens_copy.pop(0)
+
+    affine_funcs = []
+
+    while tokens_copy and tokens_copy[0] in affine_transforms:
+        func = affine_transforms[tokens_copy.pop(0)]
+        args: List[float] = []
+
+        if not (tokens_copy and tokens_copy[0] == '['):
+            break
+        tokens_copy.pop(0)  # consume '['
+
+        if tokens_copy and tokens_copy[0] != ']':
+            if tokens_copy[0].strip():
+                try:
+                    args = [float(a.strip()) for a in tokens_copy.pop(0).split(',')]
+                except ValueError:
+                    break
+            else:
+                tokens_copy.pop(0)
+
+        if not (tokens_copy and tokens_copy[0] == ']'):
+            break
+        tokens_copy.pop(0)  # consume ']'
+
+        affine_funcs.append(lambda t, f=func, a=args: f(t, *a))
+        if tokens_copy and not tokens_copy[0].strip():
+            tokens_copy.pop(0)
+        tokens[:] = tokens_copy
+
+    if not affine_funcs:
+        return None
+
+    transform = torch.eye(3, dtype=torch.float32)[:-1]  # 2×3
+    for fn in reversed(affine_funcs):
+        transform = fn(transform)
+    return transform
+
+
+def _parse_weight(tokens: List[str]) -> float:
+    if len(tokens) >= 2 and tokens[0] == ':' and _is_float(tokens[1]):
+        tokens.pop(0)
+        return float(tokens.pop(0))
+    return 1.0
+
+
+def tokenize(s: str) -> List[str]:
+    # Use general patterns for AND_ALIGN / AND_MASK_ALIGN families instead of
+    # enumerating all 1800+ combinations - that regex is 41k chars and 500x slower.
+    # Order matters: longer/more-specific patterns must come first.
+    # Use (?<!\w) / (?!\w) instead of \b because _ counts as \w in Python's \b,
+    # which would cause 'AND' to match inside 'XAND' (no boundary between \w chars).
+    affine_kw_pattern = '|'.join(
+        rf'(?<!\w){kw}(?!\w)' for kw in affine_transforms
+    )
+    keyword_pattern = (
+        r'(?<!\w)AND_MASK_ALIGN_\d+_\d+(?!\w)'   # must come before AND_ALIGN and AND
+        r'|(?<!\w)AND_ALIGN_\d+_\d+(?!\w)'
+        r'|(?<!\w)AND_PERP(?!\w)'
+        r'|(?<!\w)AND_SALT_WIDE(?!\w)'            # must come before AND_SALT
+        r'|(?<!\w)AND_SALT_BLOB(?!\w)'            # must come before AND_SALT
+        r'|(?<!\w)AND_SALT(?!\w)'
+        r'|(?<!\w)AND_TOPK(?!\w)'
+        r'|(?<!\w)AND(?!\w)'
+    )
+    return [t for t in re.split(rf'(\[|\]|:|{keyword_pattern}|{affine_kw_pattern})', s) if t.strip()]
+
+
+def _is_float(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Quick smoke-test
+# ---------------------------------------------------------------------------
+if __name__ == '__main__':
+    res = parse_root('''
+    hello
+    AND_PERP [
+        arst
+        AND defg : 2
+        AND_SALT [
+            very nested huh? what do you say :.0
+        ]
+    ]
+    AND_ALIGN_4_8 watercolor style :0.5
+    ROTATE[0.125] AND_PERP vibrant colors
+    ''')
+    print(res)

neutral_prompt_patched/lib_neutral_prompt/prompt_parser_hijack.py

@@ -0,0 +1,86 @@
+import re
+from typing import List
+
+from lib_neutral_prompt import hijacker, global_state, neutral_prompt_parser
+from modules import script_callbacks, prompt_parser
+
+# ---------------------------------------------------------------------------
+# Fix: prompt_parser_fixed escapes standalone '&' as a multicond separator.
+# neutral_prompt_parser does NOT treat '&' as AND — it keeps it as literal text.
+# So a leaf like  "cat & dog"  transpiles to  "cat & dog :1.0",
+# and the patched prompt_parser splits that into 3 multicond branches instead of 1,
+# which shifts all batch_cond_indices and breaks PERP/SALT/affine.
+#
+# Solution: escape any standalone '&' inside leaf text with '\&' before handing
+# the string to the webui parser. The patched prompt_parser correctly unescapes
+# '\&' back to '&' during conditioning, so the model sees the original text.
+#
+# "Standalone &" = surrounded by whitespace (or at start/end of string).
+# Examples:
+#   "cat & dog"  ->  "cat \& dog"     <- was splitting, now safe
+#   "R&D"        ->  "R&D"            <- was NOT splitting, unchanged
+#   "\&"         ->  "\&"             <- already escaped, not double-escaped
+# ---------------------------------------------------------------------------
+_STANDALONE_AMP = re.compile(r'(?<!\\)(?<!\S)&(?!\S)')
+
+
+def _escape_leaf_ampersands(text: str) -> str:
+    """Escape standalone '&' in a leaf prompt so patched prompt_parser
+    does not treat it as a multicond AND separator."""
+    if not text or '&' not in text:
+        return text
+    return _STANDALONE_AMP.sub(r'\\&', text)
+
+
+prompt_parser_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=prompt_parser,
+    hijacker_attribute='__neutral_prompt_hijacker',
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+
+@prompt_parser_hijacker.hijack('get_multicond_prompt_list')
+def get_multicond_prompt_list_hijack(prompts, original_function):
+    if not global_state.is_enabled:
+        return original_function(prompts)
+
+    global_state.prompt_exprs = parse_prompts(prompts)
+    webui_prompts = transpile_exprs(global_state.prompt_exprs)
+    if isinstance(prompts, getattr(prompt_parser, 'SdConditioning', type(None))):
+        webui_prompts = prompt_parser.SdConditioning(webui_prompts, copy_from=prompts)
+
+    return original_function(webui_prompts)
+
+
+def parse_prompts(prompts: List[str]) -> List[neutral_prompt_parser.PromptExpr]:
+    exprs = []
+    for prompt in prompts:
+        expr = neutral_prompt_parser.parse_root(prompt)
+        exprs.append(expr)
+    return exprs
+
+
+def transpile_exprs(exprs: neutral_prompt_parser.PromptExpr):
+    webui_prompts = []
+    for expr in exprs:
+        webui_prompts.append(expr.accept(WebuiPromptVisitor()))
+    return webui_prompts
+
+
+class WebuiPromptVisitor:
+    def visit_leaf_prompt(self, that: neutral_prompt_parser.LeafPrompt) -> str:
+        # Escape standalone '&' so patched prompt_parser doesn't split the leaf
+        # into extra multicond branches. '\&' is correctly unescaped downstream.
+        prompt = _escape_leaf_ampersands(that.prompt)
+        return f'{prompt} :{that.weight}'
+
+    def visit_composite_prompt(self, that: neutral_prompt_parser.CompositePrompt) -> str:
+        return ' AND '.join(child.accept(self) for child in that.children)
+
+
+@prompt_parser_hijacker.hijack('reconstruct_multicond_batch')
+def reconstruct_multicond_batch_hijack(*args, original_function, **kwargs):
+    """Store batch_cond_indices for the pre-noise affine hook (affine branch)."""
+    res = original_function(*args, **kwargs)
+    global_state.batch_cond_indices = res[0]
+    return res

neutral_prompt_patched/lib_neutral_prompt/ui.py

@@ -0,0 +1,196 @@
+"""
+Gradio UI for sd-webui-neutral-prompt (unified).
+
+Combines:
+  - Core prompt types + tooltip             (main branch)
+  - AND_ALIGN / AND_MASK_ALIGN entries      (alignment_blend branch)
+  - elem_id on dropdown                     (main branch)
+  - CFG Rescale infotext / paste support    (all branches)
+  - Affine-transform hint in tooltip        (affine branch)
+"""
+
+from __future__ import annotations
+
+from itertools import product
+from typing import Callable, Dict, List, Tuple
+
+import dataclasses
+import gradio as gr
+
+from lib_neutral_prompt import global_state, neutral_prompt_parser
+from modules import script_callbacks, shared
+
+
+txt2img_prompt_textbox = None
+img2img_prompt_textbox = None
+
+
+# ---------------------------------------------------------------------------
+# Prompt-type registry shown in the UI dropdown
+# ---------------------------------------------------------------------------
+
+prompt_types: Dict[str, str] = {
+    'Perpendicular (AND_PERP)':               neutral_prompt_parser.PromptKeyword.AND_PERP.value,
+    'Saliency sharp (AND_SALT)':              neutral_prompt_parser.PromptKeyword.AND_SALT.value,
+    'Saliency blob (AND_SALT_BLOB)':          neutral_prompt_parser.PromptKeyword.AND_SALT_BLOB.value,
+    'Saliency wide / classic (AND_SALT_WIDE)':neutral_prompt_parser.PromptKeyword.AND_SALT_WIDE.value,
+    'Semantic guidance top-k (AND_TOPK)':     neutral_prompt_parser.PromptKeyword.AND_TOPK.value,
+}
+
+# Add AND_ALIGN_D_S entries for commonly-used kernel size pairs
+for _d, _s in ((2, 4), (2, 8), (4, 8), (4, 16), (8, 16), (8, 32)):
+    _key = f'Alignment blend  detail={_d}  structure={_s}  (AND_ALIGN_{_d}_{_s})'
+    prompt_types[_key] = getattr(neutral_prompt_parser.PromptKeyword, f'AND_ALIGN_{_d}_{_s}').value
+
+# Add AND_MASK_ALIGN_D_S entries
+for _d, _s in ((2, 4), (2, 8), (4, 8), (4, 16), (8, 16), (8, 32)):
+    _key = f'Alignment mask   detail={_d}  structure={_s}  (AND_MASK_ALIGN_{_d}_{_s})'
+    prompt_types[_key] = getattr(neutral_prompt_parser.PromptKeyword, f'AND_MASK_ALIGN_{_d}_{_s}').value
+
+prompt_types_tooltip = '\n'.join([
+    'AND               – add all prompt features equally (webui built-in)',
+    'AND_PERP          – reduce contradicting prompt features via perpendicular projection',
+    'AND_SALT          – sharp saliency mask: child wins only at its 1-2 peak pixels (surgical)',
+    'AND_SALT_BLOB     – blob saliency mask: peak pixels eroded to core, then grown to smooth blob',
+    'AND_SALT_WIDE     – broad saliency mask: child wins ~55% of pixels (classic main-branch)',
+    'AND_TOPK          – small targeted changes (semantic guidance top-k)',
+    'AND_ALIGN_D_S     – soft blend: child adds details without breaking structure',
+    'AND_MASK_ALIGN_D_S– binary mask blend: stricter version of AND_ALIGN',
+    '',
+    'Affine transforms (supported in either order for auxiliary segments):',
+    '  ROTATE[angle]  SLIDE[x,y]  SCALE[x,y]  SHEAR[x,y]',
+    '  e.g.:  ROTATE[0.125] AND_PERP vibrant colors :0.8',
+    '  e.g.:  AND_PERP ROTATE[0.125] vibrant colors :0.8',
+])
+
+
+# ---------------------------------------------------------------------------
+# UI component class
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class AccordionInterface:
+    get_elem_id: Callable[[str], str]
+
+    def __post_init__(self):
+        self.is_rendered = False
+
+        self.cfg_rescale = gr.Slider(
+            label='CFG rescale φ',
+            minimum=0, maximum=1, value=0,
+            info='0 = disabled. Rescales the CFG output towards the predicted x0 to reduce over-saturation.',
+        )
+        self.neutral_prompt = gr.Textbox(
+            label='Neutral prompt',
+            show_label=False,
+            lines=3,
+            placeholder=(
+                'Neutral / auxiliary prompt  '
+                '(press "Apply to prompt" to append with the chosen strategy keyword)'
+            ),
+        )
+        self.neutral_cond_scale = gr.Slider(
+            label='Prompt weight',
+            minimum=-3, maximum=3, value=1,
+        )
+        self.aux_prompt_type = gr.Dropdown(
+            label='Prompt type',
+            choices=list(prompt_types.keys()),
+            value=next(iter(prompt_types.keys())),
+            tooltip=prompt_types_tooltip,
+            elem_id=self.get_elem_id('formatter_prompt_type'),
+        )
+        self.append_to_prompt_button = gr.Button(value='Apply to prompt')
+
+    # ------------------------------------------------------------------
+
+    def arrange_components(self, is_img2img: bool) -> None:
+        if self.is_rendered:
+            return
+
+        with gr.Accordion(label='Neutral Prompt', open=False):
+            self.cfg_rescale.render()
+            with gr.Accordion(label='Prompt formatter', open=False):
+                self.neutral_prompt.render()
+                self.neutral_cond_scale.render()
+                self.aux_prompt_type.render()
+                self.append_to_prompt_button.render()
+
+    def connect_events(self, is_img2img: bool) -> None:
+        if self.is_rendered:
+            return
+
+        prompt_textbox = img2img_prompt_textbox if is_img2img else txt2img_prompt_textbox
+        self.append_to_prompt_button.click(
+            fn=lambda init_prompt, prompt, scale, prompt_type: (
+                f'{init_prompt}\n{prompt_types[prompt_type]} {prompt} :{scale}',
+                '',
+            ),
+            inputs=[prompt_textbox, self.neutral_prompt, self.neutral_cond_scale, self.aux_prompt_type],
+            outputs=[prompt_textbox, self.neutral_prompt],
+        )
+
+    def set_rendered(self, value: bool = True) -> None:
+        self.is_rendered = value
+
+    # ------------------------------------------------------------------
+    # Script interface (args / infotext / paste)
+
+    def get_components(self) -> Tuple[gr.components.Component, ...]:
+        return (self.cfg_rescale,)
+
+    def get_infotext_fields(self) -> Tuple[Tuple[gr.components.Component, str], ...]:
+        return tuple(zip(self.get_components(), ('CFG Rescale phi',)))
+
+    def get_paste_field_names(self) -> List[str]:
+        return ['CFG Rescale phi']
+
+    def get_extra_generation_params(self, args: Dict) -> Dict:
+        return {'CFG Rescale phi': args['cfg_rescale']}
+
+    def unpack_processing_args(self, cfg_rescale: float) -> Dict:
+        return {'cfg_rescale': cfg_rescale}
+
+
+# ---------------------------------------------------------------------------
+# Settings & callbacks
+# ---------------------------------------------------------------------------
+
+def on_ui_settings() -> None:
+    section = ('neutral_prompt', 'Neutral Prompt')
+    shared.opts.add_option(
+        'neutral_prompt_enabled',
+        shared.OptionInfo(True, 'Enable neutral-prompt extension', section=section),
+    )
+    global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+    shared.opts.onchange('neutral_prompt_enabled', _update_enabled)
+
+    shared.opts.add_option(
+        'neutral_prompt_verbose',
+        shared.OptionInfo(False, 'Enable verbose debugging for neutral-prompt', section=section),
+    )
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+    shared.opts.onchange('neutral_prompt_verbose', _update_verbose)
+
+
+script_callbacks.on_ui_settings(on_ui_settings)
+
+
+def _update_enabled() -> None:
+    global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+
+
+def _update_verbose() -> None:
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+
+
+def on_after_component(component, **_kwargs) -> None:
+    global txt2img_prompt_textbox, img2img_prompt_textbox
+    eid = getattr(component, 'elem_id', None)
+    if eid == 'txt2img_prompt':
+        txt2img_prompt_textbox = component
+    elif eid == 'img2img_prompt':
+        img2img_prompt_textbox = component
+
+
+script_callbacks.on_after_component(on_after_component)

neutral_prompt_patched/lib_neutral_prompt/xyz_grid.py

@@ -0,0 +1,42 @@
+import sys
+from types import ModuleType
+from typing import Optional
+from modules import scripts
+from lib_neutral_prompt import global_state
+
+
+def patch():
+    xyz_module = find_xyz_module()
+    if xyz_module is None:
+        print("[sd-webui-neutral-prompt]", "xyz_grid.py not found.", file=sys.stderr)
+        return
+
+    xyz_module.axis_options.extend([
+        xyz_module.AxisOption("[Neutral Prompt] CFG Rescale", int_or_float, apply_cfg_rescale()),
+    ])
+
+
+class XyzFloat(float):
+    is_xyz: bool = True
+
+
+def apply_cfg_rescale():
+    def callback(_p, v, _vs):
+        global_state.cfg_rescale = XyzFloat(v)
+
+    return callback
+
+
+def int_or_float(string):
+    try:
+        return int(string)
+    except ValueError:
+        return float(string)
+
+
+def find_xyz_module() -> Optional[ModuleType]:
+    for data in scripts.scripts_data:
+        if data.script_class.__module__ in {"xyz_grid.py", "xy_grid.py"} and hasattr(data, "module"):
+            return data.module
+
+    return None

neutral_prompt_patched/scripts/neutral_prompt.py

@@ -0,0 +1,94 @@
+from lib_neutral_prompt import global_state, hijacker, neutral_prompt_parser, prompt_parser_hijack, cfg_denoiser_hijack, ui, xyz_grid
+from modules import scripts, processing, shared
+from typing import Dict
+import functools
+
+
+class NeutralPromptScript(scripts.Script):
+    def __init__(self):
+        self.accordion_interface = None
+        self._is_img2img = False
+
+    @property
+    def is_img2img(self):
+        return self._is_img2img
+
+    @is_img2img.setter
+    def is_img2img(self, is_img2img):
+        self._is_img2img = is_img2img
+        if self.accordion_interface is None:
+            self.accordion_interface = ui.AccordionInterface(self.elem_id)
+
+    def title(self) -> str:
+        return "Neutral Prompt"
+
+    def show(self, is_img2img: bool):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img: bool):
+        self.hijack_composable_lora(is_img2img)
+
+        self.accordion_interface.arrange_components(is_img2img)
+        self.accordion_interface.connect_events(is_img2img)
+        self.infotext_fields = self.accordion_interface.get_infotext_fields()
+        self.paste_field_names = self.accordion_interface.get_paste_field_names()
+        self.accordion_interface.set_rendered()
+        return self.accordion_interface.get_components()
+
+    def process(self, p: processing.StableDiffusionProcessing, *args):
+        args = self.accordion_interface.unpack_processing_args(*args)
+
+        self.update_global_state(args)
+        if global_state.is_enabled:
+            p.extra_generation_params.update(self.accordion_interface.get_extra_generation_params(args))
+
+    def update_global_state(self, args: Dict):
+        if shared.state.job_no == 0:
+            global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+
+        for k, v in args.items():
+            try:
+                getattr(global_state, k)
+            except AttributeError:
+                continue
+
+            if getattr(getattr(global_state, k), 'is_xyz', False):
+                xyz_attr = getattr(global_state, k)
+                xyz_attr.is_xyz = False
+                args[k] = xyz_attr
+                continue
+
+            if shared.state.job_no > 0:
+                continue
+
+            setattr(global_state, k, v)
+
+    def hijack_composable_lora(self, is_img2img):
+        if self.accordion_interface.is_rendered:
+            return
+
+        lora_script = None
+        script_runner = scripts.scripts_img2img if is_img2img else scripts.scripts_txt2img
+
+        for script in script_runner.alwayson_scripts:
+            if script.title().lower() == "composable lora":
+                lora_script = script
+                break
+
+        if lora_script is not None:
+            lora_script.process = functools.partial(composable_lora_process_hijack, original_function=lora_script.process)
+
+
+def composable_lora_process_hijack(p: processing.StableDiffusionProcessing, *args, original_function, **kwargs):
+    if not global_state.is_enabled:
+        return original_function(p, *args, **kwargs)
+
+    exprs = prompt_parser_hijack.parse_prompts(p.all_prompts)
+    all_prompts, p.all_prompts = p.all_prompts, prompt_parser_hijack.transpile_exprs(exprs)
+    res = original_function(p, *args, **kwargs)
+    # restore original prompts
+    p.all_prompts = all_prompts
+    return res
+
+
+xyz_grid.patch()

neutral_prompt_patched/test/perp_parser/test_affine_keyword_order.py

@@ -0,0 +1,133 @@
+"""
+Tests for affine-keyword ordering in parse_prompt.
+
+Both orderings must work correctly:
+  (A) AND_PERP ROTATE[0.125] vivid colors   ← trailing affine (original)
+  (B) ROTATE[0.125] AND_PERP vivid colors   ← leading affine  (documented)
+"""
+import unittest
+
+from lib_neutral_prompt import neutral_prompt_parser as p
+from lib_neutral_prompt.neutral_prompt_parser import ConciliationStrategy
+
+
+class TestAffineKeywordOrder(unittest.TestCase):
+
+    # ------------------------------------------------------------------ #
+    # trailing affine  (AND_PERP ROTATE[...] text)                        #
+    # ------------------------------------------------------------------ #
+
+    def test_trailing_affine_basic(self):
+        root = p.parse_root("base AND_PERP ROTATE[0.125] vivid colors :0.8")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[0].prompt.strip(), "base")
+        self.assertIsNone(root.children[0].local_transform)
+        self.assertIsNotNone(root.children[1].local_transform)
+        self.assertEqual(root.children[1].conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertAlmostEqual(root.children[1].weight, 0.8)
+
+    # ------------------------------------------------------------------ #
+    # leading affine  (ROTATE[...] AND_PERP text)                         #
+    # ------------------------------------------------------------------ #
+
+    def test_leading_affine_mid_prompt(self):
+        """ROTATE[...] AND_PERP must NOT be consumed into the previous prompt's text."""
+        root = p.parse_root("base ROTATE[0.125] AND_PERP vivid colors :0.8")
+        self.assertEqual(len(root.children), 2,
+            f"Expected 2 children, got {len(root.children)}: "
+            f"{[getattr(c,'prompt','composite') for c in root.children]}")
+        first, second = root.children
+        # first segment = "base " with no transform
+        self.assertIn("base", first.prompt)
+        self.assertNotIn("ROTATE", first.prompt)
+        self.assertIsNone(first.local_transform)
+        # second segment gets the transform
+        self.assertIsNotNone(second.local_transform)
+        self.assertEqual(second.conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertAlmostEqual(second.weight, 0.8)
+
+    def test_leading_affine_at_start(self):
+        """ROTATE[...] AND_PERP as first (and only non-AND) segment."""
+        root = p.parse_root("ROTATE[0.125] AND_PERP vivid colors :0.8")
+        self.assertEqual(len(root.children), 1)
+        child = root.children[0]
+        self.assertIsNotNone(child.local_transform)
+        self.assertEqual(child.conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertIn("vivid", child.prompt)
+        self.assertNotIn("ROTATE", child.prompt)
+
+    def test_leading_affine_with_and_salt(self):
+        root = p.parse_root("portrait SLIDE[0.05,0] AND_SALT vibrant :1.2")
+        self.assertEqual(len(root.children), 2)
+        second = root.children[1]
+        self.assertIsNotNone(second.local_transform)
+        self.assertEqual(second.conciliation, ConciliationStrategy.SALIENCE_MASK)
+
+    # ------------------------------------------------------------------ #
+    # Composed / chained affine                                            #
+    # ------------------------------------------------------------------ #
+
+    def test_leading_and_trailing_compose(self):
+        """ROTATE[a] AND_PERP SCALE[b,b] text — both affines composed."""
+        root = p.parse_root("base AND_PERP ROTATE[0.125] AND_PERP SCALE[1.5,1.5] vivid")
+        # Just check no crash and all children parse
+        self.assertGreaterEqual(len(root.children), 1)
+
+    # ------------------------------------------------------------------ #
+    # CFGRescaleFactorSingleton lifecycle                                   #
+    # ------------------------------------------------------------------ #
+
+    def test_cfg_rescale_singleton_clear(self):
+        from lib_neutral_prompt.global_state import CFGRescaleFactorSingleton as S
+        S.clear()
+        self.assertIsNone(S.get())
+        S.set(1.23)
+        self.assertAlmostEqual(S.get(), 1.23)
+        S.clear()
+        self.assertIsNone(S.get())
+
+    def test_cfg_rescale_singleton_thread_local(self):
+        import threading
+        from lib_neutral_prompt.global_state import CFGRescaleFactorSingleton as S
+        results = {}
+        def worker(val, key):
+            S.clear()
+            S.set(val)
+            import time; time.sleep(0.01)
+            results[key] = S.get()
+        threads = [threading.Thread(target=worker, args=(i * 10.0, i)) for i in range(3)]
+        for t in threads: t.start()
+        for t in threads: t.join()
+        for i in range(3):
+            self.assertAlmostEqual(results[i], i * 10.0,
+                msg=f"Thread {i} got {results[i]} expected {i*10.0}")
+
+    # ------------------------------------------------------------------ #
+    # New AND_SALT variants parse correctly                                #
+    # ------------------------------------------------------------------ #
+
+    def test_and_salt_wide_parsed(self):
+        root = p.parse_root("base AND_SALT_WIDE vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[1].conciliation,
+                         p.ConciliationStrategy.SALIENCE_MASK_WIDE)
+
+    def test_and_salt_blob_parsed(self):
+        root = p.parse_root("base AND_SALT_BLOB vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[1].conciliation,
+                         p.ConciliationStrategy.SALIENCE_MASK_BLOB)
+
+    def test_and_align_parsed(self):
+        root = p.parse_root("base AND_ALIGN_4_8 vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertIn('AND_ALIGN_4_8', root.children[1].conciliation.value)
+
+    def test_and_mask_align_parsed(self):
+        root = p.parse_root("base AND_MASK_ALIGN_4_8 vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertIn('AND_MASK_ALIGN_4_8', root.children[1].conciliation.value)
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_affine_pipeline.py

@@ -0,0 +1,217 @@
+"""
+Integration smoke tests for the pre-noise affine pipeline.
+
+Requires PyTorch.  If torch is not installed the entire module is skipped via
+``unittest.skipUnless``, so ``unittest discover`` still exits cleanly.
+
+Mocked: A1111 modules only (modules.script_callbacks, modules.sd_samplers,
+        modules.shared).  torch itself is real — no sys.modules replacement.
+
+Tests:
+  1. Hook is a no-op when global_state.is_enabled = False.
+  2. Identity transform (angle=0) leaves x numerically unchanged.
+  3. Non-identity transform calls apply_affine_transform (verified by spy).
+  4. Prompts with no affine leave x unchanged.
+  5. Empty state does not crash.
+  6. Batch with multiple prompts does not crash.
+"""
+
+import dataclasses
+import importlib
+import math
+import sys
+import types
+import unittest
+
+# ---------------------------------------------------------------------------
+# Detect torch availability — skip the whole module if absent
+# ---------------------------------------------------------------------------
+try:
+    import importlib.util as _ilu
+    _spec = _ilu.find_spec('torch')
+    _TORCH_AVAILABLE = _spec is not None and getattr(_spec, 'origin', None) is not None
+except (ValueError, ModuleNotFoundError):
+    _TORCH_AVAILABLE = False
+
+
+# ---------------------------------------------------------------------------
+# A1111 module stubs  (installed unconditionally so cfg_denoiser_hijack can
+# be imported even when running the skip path)
+# ---------------------------------------------------------------------------
+
+def _stub(name):
+    m = types.ModuleType(name)
+    sys.modules.setdefault(name, m)
+    return sys.modules[name]
+
+for _mod_name in ('modules', 'modules.script_callbacks', 'modules.sd_samplers',
+                  'modules.shared', 'modules.prompt_parser', 'gradio'):
+    _stub(_mod_name)
+
+import modules.script_callbacks as _sc
+if not hasattr(_sc, 'on_cfg_denoiser'):
+    _sc.on_cfg_denoiser    = lambda fn: None
+if not hasattr(_sc, 'on_script_unloaded'):
+    _sc.on_script_unloaded = lambda fn: None
+
+import modules.shared as _sh
+if not hasattr(_sh, 'opts'):
+    _sh.opts = types.SimpleNamespace(
+        data={},
+        add_option=lambda *a, **k: None,
+        onchange=lambda *a, **k: None,
+        OptionInfo=lambda *a, **k: None,
+    )
+
+import modules.sd_samplers as _ss
+if not hasattr(_ss, 'cfg_denoiser'):
+    _ss.cfg_denoiser   = None
+# cfg_denoiser_hijack installs a hijack on create_sampler at import time
+if not hasattr(_ss, 'create_sampler'):
+    _ss.create_sampler = lambda *a, **k: None
+
+
+# ---------------------------------------------------------------------------
+# Repo root on sys.path
+# ---------------------------------------------------------------------------
+
+from pathlib import Path
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+
+# ---------------------------------------------------------------------------
+# Conditional imports (only when torch is available)
+# ---------------------------------------------------------------------------
+
+if _TORCH_AVAILABLE:
+    import torch
+    from lib_neutral_prompt import global_state, neutral_prompt_parser
+    from lib_neutral_prompt.cfg_denoiser_hijack import _on_cfg_denoiser
+    import lib_neutral_prompt.affine_transform as _at_mod
+
+    # -----------------------------------------------------------------------
+    # Helpers
+    # -----------------------------------------------------------------------
+
+    def _leaf(text, angle=None):
+        """LeafPrompt, optionally with a ROTATE affine (angle in turns)."""
+        transform = None
+        if angle is not None:
+            c = math.cos(angle * 2 * math.pi)
+            s = math.sin(angle * 2 * math.pi)
+            transform = torch.tensor([[c, -s, 0.0], [s, c, 0.0]])
+        return neutral_prompt_parser.LeafPrompt(1.0, None, transform, text)
+
+    def _comp(*children):
+        return neutral_prompt_parser.CompositePrompt(1.0, None, None, list(children))
+
+    @dataclasses.dataclass
+    class _FakeParams:
+        x: torch.Tensor
+
+
+# ---------------------------------------------------------------------------
+# Test class
+# ---------------------------------------------------------------------------
+
+@unittest.skipUnless(_TORCH_AVAILABLE, 'PyTorch is not installed — skipping pipeline tests')
+class TestOnCfgDenoiserSmokeTest(unittest.TestCase):
+
+    def setUp(self):
+        global_state.is_enabled = True
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+
+    def tearDown(self):
+        global_state.is_enabled = False
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+
+    # 1. disabled → x untouched
+    def test_disabled_leaves_x_unchanged(self):
+        global_state.is_enabled = False
+        x = torch.zeros(2, 4, 8, 8)
+        x[0] = 1.0
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0.125))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.equal(params.x, orig), "Disabled hook must not modify x")
+
+    # 2. identity transform → x numerically unchanged
+    def test_identity_transform_no_change(self):
+        x = torch.randn(2, 4, 8, 8)
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.allclose(params.x, orig, atol=1e-5),
+                        "Identity affine must not change x")
+
+    # 3. non-identity → apply_affine_transform is called (spy)
+    def test_nonidentity_calls_apply_affine_transform(self):
+        x = torch.zeros(2, 4, 8, 8)
+        x[1] = torch.randn(4, 8, 8)
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0.25))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+
+        _real = _at_mod.apply_affine_transform
+        calls = []
+        def _spy(tensor, affine, mode='bilinear'):
+            calls.append(True)
+            return _real(tensor, affine, mode)
+
+        _at_mod.apply_affine_transform = _spy
+        try:
+            _on_cfg_denoiser(params)
+        finally:
+            _at_mod.apply_affine_transform = _real
+
+        self.assertGreater(len(calls), 0,
+                           "apply_affine_transform must be called for non-identity transform")
+
+    # 4. no affine on any child → x unchanged
+    def test_no_affine_no_change(self):
+        x = torch.randn(2, 4, 8, 8)
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp"))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.allclose(params.x, orig, atol=1e-5),
+                        "No affine → x must not change")
+
+    # 5. empty state → no crash
+    def test_empty_state_no_crash(self):
+        params = _FakeParams(x=torch.randn(1, 4, 8, 8))
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+        try:
+            _on_cfg_denoiser(params)
+        except Exception as e:
+            self.fail(f"_on_cfg_denoiser raised with empty state: {e}")
+
+    # 6. two batch entries → no crash
+    def test_batch_multiple_prompts_no_crash(self):
+        params = _FakeParams(x=torch.zeros(4, 4, 8, 8))
+        global_state.prompt_exprs = [
+            _comp(_leaf("base_a"), _leaf("perp_a", 0.25)),
+            _comp(_leaf("base_b"), _leaf("perp_b", 0.125)),
+        ]
+        global_state.batch_cond_indices = [
+            [(0, 1.0), (1, 1.0)],
+            [(2, 1.0), (3, 1.0)],
+        ]
+        try:
+            _on_cfg_denoiser(params)
+        except Exception as e:
+            self.fail(f"Multi-prompt batch raised: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_basic_parser.py

@@ -0,0 +1,122 @@
+import unittest
+import pathlib
+import sys
+sys.path.append(str(pathlib.Path(__file__).parent.parent.parent))
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+class TestPromptParser(unittest.TestCase):
+    def setUp(self):
+        self.simple_prompt = neutral_prompt_parser.parse_root("hello :1.0")
+        self.and_prompt = neutral_prompt_parser.parse_root("hello AND goodbye :2.0")
+        self.and_perp_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_PERP goodbye :2.0")
+        self.and_salt_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_SALT goodbye :2.0")
+        self.nested_and_perp_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_PERP [goodbye :2.0 AND_PERP welcome :3.0]")
+        self.nested_and_salt_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_SALT [goodbye :2.0 AND_SALT welcome :3.0]")
+        self.invalid_weight = neutral_prompt_parser.parse_root("hello :not_a_float")
+
+    def test_simple_prompt_child_count(self):
+        self.assertEqual(len(self.simple_prompt.children), 1)
+
+    def test_simple_prompt_child_weight(self):
+        self.assertEqual(self.simple_prompt.children[0].weight, 1.0)
+
+    def test_simple_prompt_child_prompt(self):
+        self.assertEqual(self.simple_prompt.children[0].prompt, "hello ")
+
+    def test_square_weight_prompt(self):
+        prompt = "a [b c d e : f g h :1.5]"
+        parsed = neutral_prompt_parser.parse_root(prompt)
+        self.assertEqual(parsed.children[0].prompt, prompt)
+
+        composed_prompt = f"{prompt} AND_PERP other prompt"
+        parsed = neutral_prompt_parser.parse_root(composed_prompt)
+        self.assertEqual(parsed.children[0].prompt, prompt)
+
+    def test_and_prompt_child_count(self):
+        self.assertEqual(len(self.and_prompt.children), 2)
+
+    def test_and_prompt_child_weights_and_prompts(self):
+        self.assertEqual(self.and_prompt.children[0].weight, 1.0)
+        self.assertEqual(self.and_prompt.children[0].prompt, "hello ")
+        self.assertEqual(self.and_prompt.children[1].weight, 2.0)
+        self.assertEqual(self.and_prompt.children[1].prompt, " goodbye ")
+
+    def test_and_perp_prompt_child_count(self):
+        self.assertEqual(len(self.and_perp_prompt.children), 2)
+
+    def test_and_perp_prompt_child_types(self):
+        self.assertIsInstance(self.and_perp_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.and_perp_prompt.children[1], neutral_prompt_parser.LeafPrompt)
+
+    def test_and_perp_prompt_nested_child(self):
+        nested_child = self.and_perp_prompt.children[1]
+        self.assertEqual(nested_child.weight, 2.0)
+        self.assertEqual(nested_child.prompt.strip(), "goodbye")
+
+    def test_nested_and_perp_prompt_child_count(self):
+        self.assertEqual(len(self.nested_and_perp_prompt.children), 2)
+
+    def test_nested_and_perp_prompt_child_types(self):
+        self.assertIsInstance(self.nested_and_perp_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.nested_and_perp_prompt.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_nested_and_perp_prompt_nested_child_types(self):
+        nested_child = self.nested_and_perp_prompt.children[1].children[0]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+        nested_child = self.nested_and_perp_prompt.children[1].children[1]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+
+    def test_nested_and_perp_prompt_nested_child(self):
+        nested_child = self.nested_and_perp_prompt.children[1].children[1]
+        self.assertEqual(nested_child.weight, 3.0)
+        self.assertEqual(nested_child.prompt.strip(), "welcome")
+
+    def test_invalid_weight_child_count(self):
+        self.assertEqual(len(self.invalid_weight.children), 1)
+
+    def test_invalid_weight_child_weight(self):
+        self.assertEqual(self.invalid_weight.children[0].weight, 1.0)
+
+    def test_invalid_weight_child_prompt(self):
+        self.assertEqual(self.invalid_weight.children[0].prompt, "hello :not_a_float")
+
+    def test_and_salt_prompt_child_count(self):
+        self.assertEqual(len(self.and_salt_prompt.children), 2)
+
+    def test_and_salt_prompt_child_types(self):
+        self.assertIsInstance(self.and_salt_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.and_salt_prompt.children[1], neutral_prompt_parser.LeafPrompt)
+
+    def test_and_salt_prompt_nested_child(self):
+        nested_child = self.and_salt_prompt.children[1]
+        self.assertEqual(nested_child.weight, 2.0)
+        self.assertEqual(nested_child.prompt.strip(), "goodbye")
+
+    def test_nested_and_salt_prompt_child_count(self):
+        self.assertEqual(len(self.nested_and_salt_prompt.children), 2)
+
+    def test_nested_and_salt_prompt_child_types(self):
+        self.assertIsInstance(self.nested_and_salt_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.nested_and_salt_prompt.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_nested_and_salt_prompt_nested_child_types(self):
+        nested_child = self.nested_and_salt_prompt.children[1].children[0]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+        nested_child = self.nested_and_salt_prompt.children[1].children[1]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+
+    def test_nested_and_salt_prompt_nested_child(self):
+        nested_child = self.nested_and_salt_prompt.children[1].children[1]
+        self.assertEqual(nested_child.weight, 3.0)
+        self.assertEqual(nested_child.prompt.strip(), "welcome")
+
+    def test_start_with_prompt_editing(self):
+        prompt = "[(long shot:1.2):0.1] detail.."
+        res = neutral_prompt_parser.parse_root(prompt)
+        self.assertEqual(res.children[0].weight, 1.0)
+        self.assertEqual(res.children[0].prompt, prompt)
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_malicious_parser.py

@@ -0,0 +1,182 @@
+import unittest
+import pathlib
+import sys
+sys.path.append(str(pathlib.Path(__file__).parent.parent.parent))
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+class TestMaliciousPromptParser(unittest.TestCase):
+    def setUp(self):
+        self.parser = neutral_prompt_parser
+
+    def test_empty(self):
+        result = self.parser.parse_root("")
+        self.assertEqual(result.children[0].prompt, "")
+        self.assertEqual(result.children[0].weight, 1.0)
+
+    def test_zero_weight(self):
+        result = self.parser.parse_root("hello :0.0")
+        self.assertEqual(result.children[0].weight, 0.0)
+
+    def test_mixed_positive_and_negative_weights(self):
+        result = self.parser.parse_root("hello :1.0 AND goodbye :-2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].weight, -2.0)
+
+    def test_debalanced_square_brackets(self):
+        prompt = "a [ b " * 100
+        result = self.parser.parse_root(prompt)
+        self.assertEqual(result.children[0].prompt, prompt)
+
+        prompt = "a ] b " * 100
+        result = self.parser.parse_root(prompt)
+        self.assertEqual(result.children[0].prompt, prompt)
+
+        repeats = 10
+        prompt = "a [ [ b AND c ] " * repeats
+        result = self.parser.parse_root(prompt)
+        self.assertEqual([x.prompt for x in result.children], ["a [[ b ", *[" c ] a [[ b "] * (repeats - 1), " c ]"])
+
+        repeats = 10
+        prompt = "a [ b AND c ] ] " * repeats
+        result = self.parser.parse_root(prompt)
+        self.assertEqual([x.prompt for x in result.children], ["a [ b ", *[" c ]] a [ b "] * (repeats - 1), " c ]]"])
+
+    def test_erroneous_syntax(self):
+        result = self.parser.parse_root("hello :1.0 AND_PERP [goodbye :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, "[goodbye ")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP goodbye :2.0]")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, " goodbye ")
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP goodbye] :2.0")
+        self.assertEqual(result.children[1].prompt, " goodbye]")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP a [ goodbye :2.0")
+        self.assertEqual(result.children[1].weight, 2.0)
+        self.assertEqual(result.children[1].prompt, " a [ goodbye ")
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP AND goodbye :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[2].prompt, " goodbye ")
+
+    def test_huge_number_of_prompt_parts(self):
+        result = self.parser.parse_root(" AND ".join(f"hello{i} :{i}" for i in range(10**4)))
+        self.assertEqual(len(result.children), 10**4)
+
+    def test_prompt_ending_with_weight(self):
+        result = self.parser.parse_root("hello :1.0 AND :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, "")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+    def test_huge_input_string(self):
+        big_string = "hello :1.0 AND " * 10**4
+        result = self.parser.parse_root(big_string)
+        self.assertEqual(len(result.children), 10**4 + 1)
+
+    def test_deeply_nested_prompt(self):
+        deeply_nested_prompt = "hello :1.0" + " AND_PERP [goodbye :2.0" * 100 + "]" * 100
+        result = self.parser.parse_root(deeply_nested_prompt)
+        self.assertIsInstance(result.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_complex_nested_prompts(self):
+        complex_prompt = "hello :1.0 AND goodbye :2.0 AND_PERP [welcome :3.0 AND farewell :4.0 AND_PERP greetings:5.0]"
+        result = self.parser.parse_root(complex_prompt)
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].weight, 2.0)
+        self.assertEqual(result.children[2].children[0].weight, 3.0)
+        self.assertEqual(result.children[2].children[1].weight, 4.0)
+        self.assertEqual(result.children[2].children[2].weight, 5.0)
+
+    def test_string_with_random_characters(self):
+        random_chars = "ASDFGHJKL:@#$/.,|}{><~`12[3]456AND_PERP7890"
+        try:
+            self.parser.parse_root(random_chars)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with random characters.")
+
+    def test_string_with_unexpected_symbols(self):
+        unexpected_symbols = "hello :1.0 AND $%^&*()goodbye :2.0"
+        try:
+            self.parser.parse_root(unexpected_symbols)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unexpected symbols.")
+
+    def test_string_with_unconventional_structure(self):
+        unconventional_structure = "hello :1.0 AND_PERP :2.0 AND [goodbye]"
+        try:
+            self.parser.parse_root(unconventional_structure)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unconventional structure.")
+
+    def test_string_with_mixed_alphabets_and_numbers(self):
+        mixed_alphabets_and_numbers = "123hello :1.0 AND goodbye456 :2.0"
+        try:
+            self.parser.parse_root(mixed_alphabets_and_numbers)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with mixed alphabets and numbers.")
+
+    def test_string_with_nested_brackets(self):
+        nested_brackets = "hello :1.0 AND [goodbye :2.0 AND [[welcome :3.0]]]"
+        try:
+            self.parser.parse_root(nested_brackets)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with nested brackets.")
+
+    def test_unmatched_opening_braces(self):
+        unmatched_opening_braces = "hello [[[[[[[[[ :1.0 AND_PERP goodbye :2.0"
+        try:
+            self.parser.parse_root(unmatched_opening_braces)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unmatched opening braces.")
+
+    def test_unmatched_closing_braces(self):
+        unmatched_closing_braces = "hello :1.0 AND_PERP goodbye ]]]]]]]]] :2.0"
+        try:
+            self.parser.parse_root(unmatched_closing_braces)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unmatched closing braces.")
+
+    def test_repeating_colons(self):
+        repeating_colons = "hello ::::::: :1.0 AND_PERP goodbye :::: :2.0"
+        try:
+            self.parser.parse_root(repeating_colons)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating colons.")
+
+    def test_excessive_whitespace(self):
+        excessive_whitespace = "hello    :1.0  AND_PERP     goodbye  :2.0"
+        try:
+            self.parser.parse_root(excessive_whitespace)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with excessive whitespace.")
+
+    def test_repeating_AND_keyword(self):
+        repeating_AND_keyword = "hello :1.0 AND AND AND AND AND goodbye :2.0"
+        try:
+            self.parser.parse_root(repeating_AND_keyword)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating AND keyword.")
+
+    def test_repeating_AND_PERP_keyword(self):
+        repeating_AND_PERP_keyword = "hello :1.0 AND_PERP AND_PERP AND_PERP AND_PERP goodbye :2.0"
+        try:
+            self.parser.parse_root(repeating_AND_PERP_keyword)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating AND_PERP keyword.")
+
+    def test_square_weight_prompt(self):
+        prompt = "AND_PERP [weighted] you thought it was the end"
+        try:
+            self.parser.parse_root(prompt)
+        except Exception:
+            self.fail("parse_root couldn't handle a string starting with a square-weighted sub-prompt.")
+
+
+if __name__ == '__main__':
+    unittest.main()