@@ -213,20 +213,22 @@ def _cbp_to_xy(cbp: int, clen: int) -> tuple[int, int]:
     return (page % pages_per_row) * 64 + bx, (page // pages_per_row) * 32 + by
 
 
-def scan_ovl_cluts(code_dir: Path) -> dict[str, list[int]]:
-    """Map lowercase .xtx basename -> CBP palette-pointer candidates, read
-    from the OV*.OVL overlays' texture descriptors.
-
-    Each overlay that references a texture by path also holds 28-byte
-    descriptors {u32 u, v, w-1, h-1, 0, cbp, texslot} whose CBP is the
-    ground-truth palette location (see FORMATS.md). Descriptor->texture
-    binding needs runtime tracing, so every texture referenced by an
-    overlay gets that overlay's whole (deduped) CBP set as candidates —
-    the per-file plausibility check and scoring pick the right one.
+def scan_ovl_descriptors(code_dir: Path
+                         ) -> dict[str, list[tuple[int, int, int, int, int]]]:
+    """Map lowercase .xtx basename -> texture descriptors (u, v, w, h, cbp)
+    read from the OV*.OVL overlays that reference the texture by path.
+
+    Each overlay holds 28-byte descriptors {u32 u, v, w-1, h-1, 0, cbp,
+    texslot}: a rect in texture pixels plus the GS block address of the
+    CLUT that colours it (see FORMATS.md). Descriptor->texture binding is
+    runtime state, so every texture an overlay references gets the
+    overlay's whole descriptor list; ``decode_xtx`` keeps the descriptor
+    groups whose CBP lands on a CLUT tile parked beside the sheet's own
+    palette and which render their rects more coherently than it does.
     """
     import re
 
-    index: dict[str, list[int]] = {}
+    index: dict[str, list[tuple[int, int, int, int, int]]] = {}
     if not code_dir.is_dir():
         return index
     for ovl in sorted(code_dir.glob("OV*.OVL")):
@@ -236,18 +238,31 @@ def scan_ovl_cluts(code_dir: Path) -> dict[str, list[int]]:
                                       re.IGNORECASE)}
         if not names:
             continue
-        cbps = []
+        descs: list[tuple[int, int, int, int, int]] = []
         for off in range(0, len(data) - 28, 4):
             u, v, w, h, zero, cbp, slot = struct.unpack_from("<7I", data, off)
             if (zero == 0 and 0 < cbp < 0x800 and u < 1024 and v < 1024
-                    and 0 < w + 1 <= 1024 and 0 < h + 1 <= 1024 and slot < 32
-                    and cbp not in cbps):
-                cbps.append(cbp)
-        if not cbps:
+                    and 0 < w + 1 <= 1024 and 0 < h + 1 <= 1024 and slot < 32):
+                d = (u, v, w + 1, h + 1, cbp)
+                if d not in descs:
+                    descs.append(d)
+        if not descs:
             continue
         for name in names:
             merged = index.setdefault(name, [])
-            merged += [c for c in cbps if c not in merged]
+            merged += [d for d in descs if d not in merged]
+    return index
+
+
+def scan_ovl_cluts(code_dir: Path) -> dict[str, list[int]]:
+    """Map lowercase .xtx basename -> CBP palette-pointer candidates: the
+    distinct CBPs of ``scan_ovl_descriptors``, in first-seen order."""
+    index: dict[str, list[int]] = {}
+    for name, descs in scan_ovl_descriptors(code_dir).items():
+        cbps = index.setdefault(name, [])
+        for d in descs:
+            if d[4] not in cbps:
+                cbps.append(d[4])
     return index
 
 
@@ -393,6 +408,7 @@ def lex_materials(lex: bytes) -> list[tuple[int, int, int, int, int, int]]:
 
 def decode_xtx(data: bytes, lex: bytes | list[bytes] = b"",
                cbp_candidates: Optional[list[int]] = None,
+               ovl_rects: Optional[list[tuple[int, int, int, int, int]]] = None,
                ) -> Optional[tuple[int, int, bytes, str]]:
     """(width, height, RGBA, palette_source) of the composed texture, or None.
 
@@ -404,6 +420,9 @@ def decode_xtx(data: bytes, lex: bytes | list[bytes] = b"",
     ``cbp_candidates`` — CLUT base pointers from the consuming overlay's
     texture descriptors (``scan_ovl_cluts``); when one of them lands on a
     plausible palette tile it is ground truth and wins over guessing.
+    ``ovl_rects`` — the full descriptors (``scan_ovl_descriptors``): for a
+    model-less UI sheet they are its materials, each rect painted with
+    its own parked palette (card pips vs court cards vs card back).
     palette_source is one of "embedded", "lex", "ovl", "scan", "gray".
     """
     if data[:4] != b"XTX\x00" or len(data) < 0x24:
@@ -522,10 +541,13 @@ def decode_xtx(data: bytes, lex: bytes | list[bytes] = b"",
     # 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.
+    # for other sub-images. When the first conventional-spot palette
+    # renders at least half 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. (v1.1.0 required < 95 % opaque, which
+    # left the fully opaque casino gallery sketches and the slot sheet
+    # with a monotone palette the coherence score prefers — the ratio is
+    # biased toward washed-out palettes, see _region_noise.)
     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):
@@ -536,8 +558,8 @@ def decode_xtx(data: bytes, lex: bytes | list[bytes] = b"",
                 # 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):
+                if 0.5 <= opq_f 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
@@ -584,6 +606,81 @@ def paint(pal, u0, u1, v0, v1):
         paint(pal, u0, u1, v0, v1)
         painted.append((u0, u1, v0, v1))
 
+    # UI sheets (no model) consumed by an overlay: the overlay's texture
+    # descriptors are the sheet's materials — a rect in texture pixels plus
+    # the CBP of the CLUT that colours it (the card sheets draw pips, court
+    # cards and the card back from three parked palettes; the slot sheet
+    # keys nine UI elements to a column of nine). Every texture the
+    # overlay references gets the same descriptor list, so a descriptor is
+    # trusted only as part of a GROUP (all rects sharing one CBP) that
+    # (1) lands on a CLUT tile parked beside the sheet's own palette —
+    # chained within 32 px of the base tile, the way artists park a
+    # sheet's palette strip — and (2) renders its rects clearly smoother
+    # than the base palette does (median adjacent/far ratio <= 0.9 of the
+    # base's) without hiding them (median opacity >= half the base's;
+    # text strips legitimately turn their background transparent).
+    # Measured on OV11: true groups score 0.31-0.85, the same descriptors
+    # applied to the wrong sheet 0.99-12 (poker pay table, exchange, BG).
+    used_tiles: set[tuple[int, int]] = set()  # accepted groups' CLUT tiles
+    if (not lexes and ovl_rects and base_pal is not None
+            and pal_xy is not None):
+        groups: dict[tuple[int, int], list[tuple[int, int, int, int]]] = {}
+        for u, v, w, h, cbp in ovl_rects:
+            u0, v0, u1, v1 = u, v, min(W, u + w), min(H, v + h)
+            if u0 >= W or v0 >= H or u1 - u0 < 8 or v1 - v0 < 8:
+                continue
+            tile = _cbp_to_xy(cbp, clen)
+            if tile == pal_xy or not _clut_tile_like(canvas, clen, *tile):
+                continue
+            groups.setdefault(tile, []).append((u0, u1, v0, v1))
+        parked = {pal_xy}
+        grown = True
+        while grown:
+            grown = False
+            for t in groups:
+                if t not in parked and any(abs(t[0] - q[0]) <= 32
+                                           and abs(t[1] - q[1]) <= 32
+                                           for q in parked):
+                    parked.add(t)
+                    grown = True
+        accepted: list[tuple[int, int, int, int, int, list[bytes]]] = []
+        for tile, rects in groups.items():
+            if tile not in parked:
+                continue
+            pal = _clut_at(canvas, clen, *tile)
+            if not _plausible_clut(pal) or pal == base_pal:
+                continue
+            ratios: list[float] = []
+            opqs: list[float] = []
+            measured = []
+            for u0, u1, v0, v1 in rects:
+                mn, mo = _region_noise(idx, W, pal, u0, u1, v0, v1)
+                bn, bo = _region_noise(idx, W, base_pal, u0, u1, v0, v1)
+                measured.append((u0, u1, v0, v1, mn, mo))
+                if mn != float("inf") and bn != float("inf") and bn > 0:
+                    ratios.append(mn / bn)
+                if bo > 0:
+                    opqs.append(mo / bo)
+            if not ratios:
+                continue
+            ratios.sort()
+            opqs.sort()
+            if (ratios[len(ratios) // 2] > 0.9
+                    or (opqs and opqs[len(opqs) // 2] < 0.5)):
+                continue
+            for u0, u1, v0, v1, mn, mo in measured:
+                # a rect the palette renders as one flat opaque colour is
+                # no evidence either way; leave it to the base palette
+                if mn == float("inf") and mo > 0.05:
+                    continue
+                accepted.append(((u1 - u0) * (v1 - v0), u0, u1, v0, v1, pal))
+            used_tiles.add(tile)
+            source = "ovl"
+        accepted.sort(key=lambda a: -a[0])  # big rects first: specific win
+        for _area, u0, u1, v0, v1, pal in accepted:
+            paint(pal, u0, u1, v0, v1)
+            painted.append((u0, u1, v0, v1))
+
     # regions no parsed material covers (their materials hide in the VIF
     # vertex streams): per 64px block, if some known palette renders it
     # clearly smoother than the base palette, use it — this un-garbles the
@@ -716,7 +813,7 @@ def paint(pal, u0, u1, v0, v1):
         if len(cluster) * 32 * 32 > W * H * 0.06:
             cluster = set()  # parked CLUTs are a sliver of a big canvas;
             # on a small texture the "tile" is likelier art — leave it
-        for tx, ty in cluster:
+        for tx, ty in cluster | used_tiles:
             px0, py0 = tx * 2, ty * 2
             for y in range(max(0, py0), min(H, py0 + 32)):
                 drow = y * W * 4
@@ -1166,7 +1263,13 @@ def bump(key: str, n: int = 1) -> None:
 
         tdir = browse / "textures_png"
         srcs = list(_dump_files(dump, (".xtx",)))
-        cbp_index = scan_ovl_cluts(browse / "code")  # {} without extract --code
+        rect_index = scan_ovl_descriptors(browse / "code")  # {} w/o --code
+        cbp_index: dict[str, list[int]] = {}
+        for name, descs in rect_index.items():
+            cbps = cbp_index.setdefault(name, [])
+            for d in descs:
+                if d[4] not in cbps:
+                    cbps.append(d[4])
         seen: dict[str, str] = {}  # sha1 of XTX bytes -> written PNG (dedup)
         log(f"textures: decoding {len(srcs)} .xtx -> PNG "
             f"({len(cbp_index)} with overlay palette hints) ...")
@@ -1194,7 +1297,8 @@ def bump(key: str, n: int = 1) -> None:
             for extra in sorted(companions.get(src, [])):
                 lex.append(_load(extra, bump))
             cbps = cbp_index.get(src.name.lower())
-            decoded = decode_xtx(data, lex, cbps) if data else None
+            rects = rect_index.get(src.name.lower())
+            decoded = decode_xtx(data, lex, cbps, rects) if data else None
             if decoded is None:
                 bump("textures_undecodable")
                 continue
 
@@ -124,14 +124,28 @@ two middle 8-entry runs of each 32). PS2 alpha is 7-bit: scale
 
 1. Dedicated 16x16 sub-image in the same file.
 2. Paired `.lex` model materials (below).
-3. Overlay descriptors (`scan_ovl_cluts`): the consuming overlay addresses
-   the CLUT by GS block pointer (CBP) in 28-byte texture descriptors
-   `{u32 u, v, w-1, h-1, 0, CBP, texslot}` — OV11.OVL (casino) references
-   `data\tanaka\*.xtx` by path string. Mapping: `page = cbp/32`, pages laid
-   canvas_width/64 per row (64x32 px), block within page via the PSMCT32
-   block table (8x8 px blocks). Descriptor->texture binding would need
-   runtime tracing, so each referenced texture gets the overlay's whole CBP
-   set as candidates and the least-noisy render wins (below).
+3. Overlay descriptors (`scan_ovl_descriptors` / `scan_ovl_cluts`): the
+   consuming overlay addresses the CLUT by GS block pointer (CBP) in
+   28-byte texture descriptors `{u32 u, v, w-1, h-1, 0, CBP, texslot}` —
+   OV11.OVL (casino) references `data\tanaka\*.xtx` by path string.
+   Mapping: `page = cbp/32`, pages laid canvas_width/64 per row (64x32
+   px), block within page via the PSMCT32 block table (8x8 px blocks).
+   Descriptor->texture binding would need runtime tracing, so each
+   referenced texture gets the overlay's whole descriptor list. The
+   distinct CBPs are base-palette candidates (least-noisy render wins,
+   below) and the descriptors are the sheet's *materials*: a UI sheet is
+   multi-palette by design (OV11's card grid draws the 81x121 pip cards
+   from CBP 1016, the J/Q/K/Joker from 1020 and the card back from
+   1004; the slot sheet keys nine elements to a column of nine CLUTs at
+   canvas x=112). `decode_xtx` paints a descriptor *group* (every rect
+   sharing one CBP) when its tile is CLUT-like and parked within 32 px
+   (chained) of the sheet's base tile, and the group's rects render with
+   a median adjacent/far ratio <= 0.9x the base palette's at >= half its
+   opacity (text strips legitimately go transparent). Measured on OV11:
+   true groups score 0.31-0.85; the same descriptors applied to a sheet
+   they do not belong to (poker pay table, exchange, BG — which park
+   CLUT-like tiles at the same corner) score 0.99-12. Big rects paint
+   first so specific ones win; accepted tiles are blanked from output.
 4. Corner-scan: menu/backdrop textures park CLUT tiles in unused canvas
    corners. Scan 16x16 tiles (all raw alpha <= 0x80, >= 64 distinct
    colours), conventional spots first: (0,224), (240,240), (224,240),
 
@@ -3,6 +3,58 @@
 Newest first. Each entry lists what changed, why, and what you have to do
 to benefit from it.
 
+## 2026-10-14 — casino sheets: overlay descriptors as materials
+
+The casino UI sheets were the last textures the decoder got visibly
+wrong, and both residuals turned out to be the same fact: a UI sheet is
+**multi-palette by design**, and OV11.OVL's texture descriptors say
+which parked CLUT colours which rect — the overlay equivalent of a
+`.lex` model's materials.
+
+* **Card sheets** (`tanaka/clover`, `dia`, `heart`, `spade`): pip cards,
+  court cards and the card back each have their own palette parked in
+  the bottom-right corner. One palette can't render all three — v1.1.0
+  showed the court cards in a pink cast with correct pips, or correct
+  court cards with sepia pips. Now every card renders right (black and
+  red pips, KOS-MOS/Shion/Jr./chaos/Ziggy court art, the red ornate
+  back).
+* **Slot sheet** (`tanaka/base`): keys nine UI elements (reel symbols,
+  "Gets down" panels, digits, text strips) to a column of nine CLUTs.
+  v1.1.0 rendered it through one dark monotone palette with half the
+  sheet blanked; now each element draws from its own.
+* **Casino gallery sketches** (`tanaka/02_Y2`, `03_W2`, `08_W3`,
+  `12_W2`, `12_W3`, `15_W2`, `19_W1`, `19_W3`, `19_W4`): the pencil
+  concept art the dataviewer shows rendered as near-transparent line
+  noise because the conventional-spot rule from v1.1.0 only applied to
+  sheets under 95 % opaque. Lifting the cap gives clean sketches on
+  white.
+
+How it works (`browse.py`): `scan_ovl_descriptors` keeps the full
+`(u, v, w, h, cbp)` descriptors, not just the CBP set. For a sheet with
+no `.lex`, `decode_xtx` groups the descriptors by CBP and paints a
+group only when its tile is a CLUT parked beside the sheet's own
+palette (chained within 32 px) **and** its rects render clearly more
+coherently than under the base palette (median ratio <= 0.9, opacity
+kept). The second test is what stops the card descriptors — which every
+OV11 texture receives — from repainting the poker pay table or the
+exchange screen, whose corners park CLUT-like tiles at the same spots
+(true groups score 0.31–0.85, foreign ones 0.99–12). `docs/FORMATS.md`
+§ Palettes has the numbers.
+
+Still open on the slot sheet: the two reel-symbol strips (texture
+x < 224, y < 250) are covered by no descriptor — the reels are drawn by
+another code path — so they render under the sheet's base palette with
+a red/blue fringe; the column parks three CLUTs no descriptor claims
+(canvas (112,0), (112,16), (112,48)) and one of those is probably the
+reel palette (per-machine colour variants?).
+
+Verified by rendering all 245 lex-less `.xtx` with the previous and new
+code (`docs/research/lexless_render.py`, 35 s instead of a 40-minute
+full browse): exactly 15 files change — the 14 above, all better, plus
+`texture/fm8011`, which is dither noise under every candidate palette
+before and after (its real format is still unknown). Model-bound
+textures are untouched (the pass is gated on "no `.lex`").
+
 ## 2026-09-24 — scene-archive textures: the "undecodable variant" was ARX
 
 The ~500 embedded XTX hits the sweep reported as *undecodable* (all in