@@ -321,6 +321,24 @@ def _rgba_noise(buf, stride: int, u0: int, u1: int, v0: int, v1: int) -> float:
     return (adj / adjn) / fbar
 
 
+def _far_contrast(idx: bytearray, W: int, pal: list[bytes],
+                  u0: int, u1: int, v0: int, v1: int) -> float:
+    """Mean L1 RGB distance between opaque pixels 16 apart (rows sampled)
+    under a palette — the absolute contrast the coherence ratio divides
+    by. Near zero means the palette renders the region as a flat sheet."""
+    far = farn = 0
+    for v in range(v0, v1, 4):
+        irow = v * W
+        for u in range(u0, u1 - 16, 2):
+            p = pal[idx[irow + u]]
+            q = pal[idx[irow + u + 16]]
+            if p[3] and q[3]:
+                far += (abs(p[0] - q[0]) + abs(p[1] - q[1])
+                        + abs(p[2] - q[2]))
+                farn += 1
+    return far / farn if farn else 0.0
+
+
 def _candidate_score(idx: bytearray, W: int, H: int, pal: list[bytes]) -> float:
     """Whole-image score for a BASE-palette candidate: coherence ratio plus
     a stiff penalty for transparency, so a palette cannot win by hiding
@@ -498,6 +516,30 @@ def decode_xtx(data: bytes, lex: bytes | list[bytes] = b"",
             tried += 1
             if tried >= 24 or best < 0.45:
                 break
+    # UI sheets (no model): the artists park the sheet's own CLUT at one of
+    # the conventional corner spots, and the sheet often has transparent
+    # cut-outs (slot-reel windows, the window frame). The ranking above
+    # penalises transparency — right for character atlases, where a wrong
+    # palette hides garbage behind alpha 0, wrong here: on the casino slot
+    # frame and window sheet it preferred washed-out grey palettes parked
+    # for other sub-images. When the first conventional-spot palette is
+    # a frame-like render (50-95 % opaque) and, penalty aside, about as
+    # coherent as the ranked winner, keep it — the v1.0.0 first-hit
+    # behaviour that was right on those sheets.
+    if not lexes and base_pal is not None and source in ("ovl", "scan"):
+        for cand, xy in _scan_for_clut(canvas, clen):
+            if not _plausible_clut(cand):
+                continue
+            if cand != base_pal:
+                ratio_f, opq_f = _region_noise(idx, W, cand, 0, W, 0, H)
+                ratio_b, _ = _region_noise(idx, W, base_pal, 0, W, 0, H)
+                # a ranked winner that renders the sheet nearly flat (the
+                # window sheet's pick was near-black) is no evidence at all
+                flat_b = _far_contrast(idx, W, base_pal, 0, W, 0, H) < 12.0
+                if 0.5 <= opq_f < 0.95 and (ratio_f <= ratio_b * 1.25
+                                             or flat_b):
+                    base_pal, pal_xy, source = cand, xy, "scan"
+            break
     base_lut = ([bytes(p) for p in base_pal] if base_pal
                 else [bytes((i, i, i, 255)) for i in range(256)])
 
 
@@ -138,6 +138,14 @@ two middle 8-entry runs of each 32). PS2 alpha is 7-bit: scale
    (176,240), (112,64), (128,0); then the 16px grid bottom-right first;
    then the 8px grid (CBPs can address half-block-aligned tiles).
 
+For textures without a `.lex` (UI sheets) the first conventional-spot
+candidate wins over the ranked one when it renders 50–95 % opaque and
+is, transparency penalty aside, about as coherent as the winner (or the
+winner renders the sheet nearly flat): frame-like sheets park their own
+CLUT at a corner spot, and the penalty below otherwise hands them a
+washed-out palette meant for another sub-image (casino slot frame,
+window, pay table; 2026-09-25).
+
 Choosing between palette candidates uses a noise metric
 (`_region_noise`): mean L1 RGB distance between horizontally adjacent
 opaque pixels — the correct palette renders coherent art (low), a wrong
 
@@ -37,9 +37,31 @@ compressed stream, while its pixels do not exist until decompression.
   is the ARX bit stream (the entry-level sweep works because the hair
   words are stream literals).
 
-## 2026-09-25 — v1.1.1: casino slot regression, block rescue gated
-
-The v1.1.0 release still repainted one tile of the casino slot machine
+## 2026-09-25 — v1.1.0 verification pass: casino palettes and rescues
+
+Proving issue #1 against the July build (v1.0.0 renders decoded from
+the tagged `browse.py`) turned up three things the interim decoders
+had got wrong on the lex-less UI sheets. All folded into v1.1.0.
+
+### UI sheets keep their conventional-spot palette
+
+The candidate ranking penalises transparency (right for character
+atlases, where a wrong palette hides garbage behind alpha 0). UI frames
+legitimately have transparent cut-outs — slot-reel windows, the window
+frame — so on those sheets the ranking preferred washed-out grey
+palettes parked for other sub-images over the sheet's own CLUT at a
+conventional corner spot, which v1.0.0's first-hit rule had picked
+correctly. For textures without a `.lex`, the first conventional-spot
+palette is now kept when it renders 50–95 % opaque and is, penalty
+aside, about as coherent as the ranked winner (or the winner renders
+the sheet nearly flat). Changes exactly six sheets, all for the
+better: `tanaka/slot_2` (slot frame), `poker_2` (pay table), `w1`
+(neon reel labels), `window`, `carddata/card_Rare` (rarity labels),
+`texture/fm8009` (the Elsa deck map).
+
+### Block-rescue pass gated
+
+The interim build still repainted one tile of the casino slot machine
 (`tanaka/slot_1`, an orange square) that v1.0.0 rendered black. Cause:
 the 64-px **block-rescue** pass (a wrong palette "explains" a near-black
 noise block better than the base palette). Checked across every
@@ -58,7 +80,7 @@ libraries (`simajiri/esd/eve017.esd`, `eve107.esd`, `boss0185.esd`,
 `scene/cf0680.a`) as PSMT4 from the character VRAM slot with CLUT
 pointers 14400/14401 — palettes those effects bring themselves.
 
-### Casino regression fixed (raw-CT32 pass gated)
+### Raw-CT32 pass gated
 
 Verifying issue #1 against the July build turned up a regression from
 the 2026-08-21 decoder: the raw-CT32 pass (which draws true-colour