pkgviewer.py

#!/usr/bin/env python3
"""PKG Viewer - PS2/PS3 (ISO) + PS3 (PKG/folder) + PS4 + PS5 (FIH/CNT) + Switch (NSP/PFS0, XCI/HFS0). Clean dark UI (tkinter) + CLI --info mode."""
import io
import json
import os
import struct
import sys

APP_VERSION = "v1.20.1-pre1"  # bump on every release - the updater compares this
UPDATE_REPO = "Loopayeh/pkg-viewer"
SUPPORT_ADDR = "0x839a30D52Ef7D2b53e818b9931efd7FE6F472e50"  # USDT (BEP-20)
SUPPORT_URL = ("https://link.trustwallet.com/send?coin=20000714&address="
               "0x839a30D52Ef7D2b53e818b9931efd7FE6F472e50"
               "&token_id=0x55d398326f99059fF775485246999027B3197955")


def _settings_path():
    """User settings file. Never raises."""
    try:
        if sys.platform.startswith("win"):
            base = os.environ.get("APPDATA") or os.path.expanduser("~")
            d = os.path.join(base, "PKGViewer")
        else:
            d = os.path.join(os.path.expanduser("~"), ".config", "pkgviewer")
        os.makedirs(d, exist_ok=True)
        return os.path.join(d, "settings.json")
    except Exception:
        return None


def _load_settings():
    try:
        p = _settings_path()
        if p and os.path.isfile(p):
            with open(p, "r", encoding="utf-8-sig") as f:
                d = json.load(f)
            return d if isinstance(d, dict) else {}
    except Exception:
        pass
    return {}


def _save_settings(patch):
    try:
        p = _settings_path()
        if not p:
            return
        d = _load_settings()
        d.update(patch or {})
        with open(p, "w", encoding="utf-8") as f:
            json.dump(d, f)
    except Exception:
        pass

# ---------------- rounded buttons (PIL face on a real tk.Button) ----------------
try:
    import tkinter as _tk
    from tkinter import font as _tkfont
    from tkinter import ttk as _ttk
    _TK_OK = True
except ImportError:
    _tk = None
    _tkfont = None
    _ttk = None
    _TK_OK = False
try:
    from PIL import Image as _PILImage, ImageDraw as _PILDraw, ImageTk as _PILImageTk
    _PIL_OK = True
except ImportError:
    _PILImage = _PILDraw = _PILImageTk = None
    _PIL_OK = False

_RBTN_RADIUS = 4
_RBTN_PAD = {"accent": (16, 9), "ghost": (12, 7), "mini": (10, 4),
             "mini_accent": (10, 4)}
_RBTN_FACE = {
    "accent": {"face": "#4f8ef7", "hover": "#6fa8ff", "pressed": "#3b70c9",
               "fg": "#171717", "disabled_face": "#2a2a2a", "disabled_fg": "#8b93a5"},
    "ghost": {"face": "#404040", "hover": "#2c3342", "pressed": "#333a44",
              "fg": "#f1f3f8", "disabled_face": "#2a2a2a", "disabled_fg": "#8b93a5"},
    "mini": {"face": "#404040", "hover": "#2c3342", "pressed": "#333a44",
             "fg": "#f1f3f8", "disabled_face": "#2a2a2a", "disabled_fg": "#8b93a5"},
    "mini_accent": {"face": "#4f8ef7", "hover": "#6fa8ff", "pressed": "#3b70c9",
                    "fg": "#171717", "disabled_face": "#2a2a2a", "disabled_fg": "#8b93a5"},
}
_RBTN_DEFAULT_BG = "#171717"
_RBTN_DEFAULT_FONT = ("Segoe UI", 10)


def _rbtn_kind_of(style):
    if style and "Ghost" in style:
        return "ghost"
    return "accent"


def _rbtn_face_image(w, h, radius, color):
    s = 3
    img = _PILImage.new("RGBA", (w * s, h * s), (0, 0, 0, 0))
    _PILDraw.Draw(img).rounded_rectangle([0, 0, w * s - 1, h * s - 1],
                                         radius=radius * s, fill=color)
    return img.resize((w, h), _PILImage.LANCZOS)


class RoundedButton(_tk.Button):
    """tk.Button with a rounded-rectangle face rendered by PIL.

    Drop-in for the ttk.Button call sites in run_gui: same text /
    textvariable / command options, same pack/grid/place API, plus
    .config(text=...), .config(style=...) and .config(state=...).
    See mkbtn for the PIL-missing fallback.
    """

    def __init__(self, parent, text="", textvariable=None, style="Accent.TButton",
                 kind=None, command=None, bg=_RBTN_DEFAULT_BG,
                 font=_RBTN_DEFAULT_FONT, radius=_RBTN_RADIUS,
                 cursor="hand2", **kw):
        self._kind = kind or _rbtn_kind_of(style)
        self._text = text
        self._var = textvariable
        self._radius = radius
        self._font = _tkfont.Font(font=font)
        self._padx, self._pady = _RBTN_PAD[self._kind]
        self._pal = _RBTN_FACE[self._kind]
        self._imgs = {}
        self._pil = {}
        self._pressed = False
        self._hovered = False
        super().__init__(parent, text=text, textvariable=textvariable,
                         font=font, fg=self._pal["fg"],
                         activeforeground=self._pal["fg"],
                         disabledforeground=self._pal["disabled_fg"],
                         bg=bg, activebackground=bg,
                         borderwidth=0, relief="flat", highlightthickness=0,
                         overrelief="flat", padx=0, pady=0, cursor=cursor,
                         compound="center", command=command, **kw)
        self._refresh()
        self.bind("<Enter>", lambda _e: self._set_hover(True))
        self.bind("<Leave>", lambda _e: self._set_hover(False))
        self.bind("<ButtonPress-1>", lambda _e: self._set_pressed(True))
        self.bind("<ButtonRelease-1>", lambda _e: self._set_pressed(False))
        self._watch_var()

    # -- internals --
    def _watch_var(self):
        if self._var is not None:
            try:
                self._var.trace_add("write", lambda *_a: self._refresh())
            except Exception:
                pass

    def _label(self):
        try:
            if self._var is not None:
                return self._var.get()
        except Exception:
            pass
        return self._text

    def _refresh(self):
        label = self._label()
        tw = self._font.measure(label) if label else 0
        lh = self._font.metrics("linespace")
        w = max(tw + 2 * self._padx, 2 * self._radius + 12)
        h = lh + 2 * self._pady
        pal = self._pal
        self._pil = {k: _rbtn_face_image(w, h, self._radius, pal[c])
                     for k, c in (("normal", "face"), ("hover", "hover"),
                                   ("pressed", "pressed"),
                                   ("disabled", "disabled_face"))}
        self._imgs = {k: _PILImageTk.PhotoImage(im)
                      for k, im in self._pil.items()}
        try:
            super().configure(width=w, height=h)
        except Exception:
            pass
        self._show(self._current_face())

    def _current_face(self):
        try:
            st = super().cget("state")
        except Exception:
            st = "normal"
        if st == "disabled":
            return "disabled"
        if self._pressed:
            return "pressed"
        if self._hovered:
            return "hover"
        return "normal"

    def _show(self, which):
        try:
            super().configure(image=self._imgs[which])
        except Exception:
            pass

    def _set_hover(self, on):
        self._hovered = on
        self._show(self._current_face())

    def _set_pressed(self, on):
        self._pressed = on
        self._show(self._current_face())

    # -- ttk-compatible option API --
    def configure(self, cnf=None, **kw):
        if cnf is None and not kw:
            return super().configure()
        if isinstance(cnf, dict):
            kw = dict(cnf, **kw)
            cnf = None
        if isinstance(cnf, str) and not kw:
            if cnf == "text":
                return self._text
            return super().configure(cnf)
        opts = dict(kw)
        dirty = False
        if "style" in opts:
            kind = _rbtn_kind_of(opts.pop("style"))
            if kind != self._kind:
                self._kind = kind
                self._padx, self._pady = _RBTN_PAD[kind]
                self._pal = _RBTN_FACE[kind]
                try:
                    super().configure(fg=self._pal["fg"],
                                      activeforeground=self._pal["fg"])
                except Exception:
                    pass
                dirty = True
        if "kind" in opts:
            kind = opts.pop("kind")
            if kind in _RBTN_FACE and kind != self._kind:
                self._kind = kind
                self._padx, self._pady = _RBTN_PAD[kind]
                self._pal = _RBTN_FACE[kind]
                dirty = True
        if "textvariable" in opts:
            self._var = opts.pop("textvariable")
            opts["textvariable"] = self._var
            self._watch_var()
            dirty = True
        if "text" in opts:
            self._text = opts.pop("text")
            opts["text"] = self._text
            dirty = True
        if "bg" in opts or "background" in opts:
            opts["activebackground"] = opts.get("bg", opts.get("background"))
        if opts:
            try:
                super().configure(**opts)
            except Exception:
                pass
        if dirty or "state" in opts:
            self._refresh()
        return None

    config = configure

    def cget(self, key):
        if key == "text":
            return self._text
        return super().cget(key)

    def __setitem__(self, key, value):
        self.configure(**{key: value})

    def __getitem__(self, key):
        return self.cget(key)


def mkbtn(parent, text="", textvariable=None, style="Accent.TButton",
          command=None, bg=_RBTN_DEFAULT_BG, font=_RBTN_DEFAULT_FONT, **kw):
    """Make a rounded button; falls back to ttk.Button without PIL."""
    if _TK_OK and _PIL_OK:
        return RoundedButton(parent, text=text, textvariable=textvariable,
                             style=style, command=command, bg=bg, font=font,
                             **kw)
    from tkinter import ttk as _ttk
    return _ttk.Button(parent, text=text, textvariable=textvariable,
                       style=style, command=command, **kw)


class PillLabel(_tk.Label):
    """tk.Label with a rounded-pill face rendered by PIL (for badges).

    Same palette, just rounded. Supports .config(text=...), .config(bg=...)
    (face color) and textvariable; parent_bg paints the corners.
    Falls back to a plain label only via mkpill(has_pil=False) path.
    """

    def __init__(self, parent, text="", textvariable=None, bg="#2a2a2a",
                 fg="#171717", font=_RBTN_DEFAULT_FONT, padx=8, pady=3,
                 radius=8, parent_bg="#202020", **kw):
        self._text = text
        self._var = textvariable
        self._face = bg
        self._parent_bg = parent_bg
        self._font = _tkfont.Font(font=font)
        self._padx, self._pady = padx, pady
        self._radius = radius
        self._img = None
        self._pil = None
        super().__init__(parent, text=text, textvariable=textvariable,
                         font=font, fg=fg, bg=parent_bg,
                         borderwidth=0, highlightthickness=0,
                         padx=0, pady=0, **kw)
        self._refresh()
        if self._var is not None:
            try:
                self._var.trace_add("write", lambda *_a: self._refresh())
            except Exception:
                pass

    def _label(self):
        try:
            if self._var is not None:
                return self._var.get()
        except Exception:
            pass
        return self._text

    def _refresh(self):
        label = self._label()
        tw = self._font.measure(label) if label else 0
        lh = self._font.metrics("linespace")
        w = max(tw + 2 * self._padx, 2 * self._radius + 10)
        h = lh + 2 * self._pady
        self._pil = _rbtn_face_image(w, h, self._radius, self._face)
        self._img = _PILImageTk.PhotoImage(self._pil)
        try:
            super().configure(image=self._img, compound="center",
                              width=w, height=h)
        except Exception:
            pass

    def configure(self, cnf=None, **kw):
        if cnf is None and not kw:
            return super().configure()
        if isinstance(cnf, dict):
            kw = dict(cnf, **kw)
            cnf = None
        if isinstance(cnf, str) and not kw:
            if cnf == "text":
                return self._text
            return super().configure(cnf)
        opts = dict(kw)
        dirty = False
        if "text" in opts:
            self._text = opts.pop("text")
            opts["text"] = self._text
            dirty = True
        if "textvariable" in opts:
            self._var = opts.pop("textvariable")
            opts["textvariable"] = self._var
            if self._var is not None:
                try:
                    self._var.trace_add("write",
                                        lambda *_a: self._refresh())
                except Exception:
                    pass
            dirty = True
        if "bg" in opts or "background" in opts:
            self._face = opts.pop("bg", opts.pop("background", self._face))
            dirty = True
        if "fg" in opts or "foreground" in opts:
            # badge text color must follow (e.g. white on Nintendo red);
            # plain tk.Label draws text over the pill image in this color.
            _fg = opts.pop("fg", opts.pop("foreground", None))
            if _fg is not None:
                try:
                    super().configure(fg=_fg)
                except Exception:
                    pass
        if opts:
            try:
                super().configure(**opts)
            except Exception:
                pass
        if dirty:
            self._refresh()
        return None

    config = configure

    def cget(self, key):
        if key == "text":
            return self._text
        if key in ("bg", "background"):
            return self._face
        return super().cget(key)


def mkpill(parent, text="", textvariable=None, bg="#2a2a2a", fg="#171717",
           font=_RBTN_DEFAULT_FONT, parent_bg="#202020", **kw):
    """Make a rounded pill badge; falls back to tk.Label without PIL."""
    if _TK_OK and _PIL_OK:
        return PillLabel(parent, text=text, textvariable=textvariable, bg=bg,
                         fg=fg, font=font, parent_bg=parent_bg, **kw)
    return _tk.Label(parent, text=text, textvariable=textvariable, bg=bg,
                     fg=fg, font=font, **dict({"padx": 8, "pady": 3}, **kw))

CNT_MAGIC = b"\x7fCNT"
FIH_MAGIC = b"\x7fFIH"
LIH_MAGIC = b"\x7fLIH"
PS3_MAGIC = b"\x7fPKG"
PFS0_MAGIC = b"PFS0"
HFS0_MAGIC = b"HFS0"
XCI_MAGIC = b"HEAD"

# PS3 NPDRM (from PyKG / ps3 pkg tools: fixed key, CTR with riv; debug = SHA1-XOR)
PS3_KEY = bytes.fromhex("2e7b71d7c9c9a14ea3221f188828b8f8")
PS3_HDR_FMT = ">4sHHIIIIQQQ48s16s16s"
PS3_ITEM_FMT = ">IIQQII"
PS3_DIR_FLAG = 0x04
try:
    from cryptography.hazmat.primitives.ciphers import Cipher as _Cipher
    from cryptography.hazmat.primitives.ciphers import algorithms as _Algos
    from cryptography.hazmat.primitives.ciphers import modes as _Modes
    HAS_PS3_AES = True
except ImportError:
    HAS_PS3_AES = False

# ---------------- parsing (verified on samples) ----------------

def u32be(b, o):
    return struct.unpack_from(">I", b, o)[0]


def u64be(b, o):
    return struct.unpack_from(">Q", b, o)[0]


def u64le(b, o):
    return struct.unpack_from("<Q", b, o)[0]


def parse_cnt_entries(f, base, entry_count, entry_table_off):
    f.seek(base + entry_table_off)
    raw = f.read(entry_count * 32)
    ents = []
    for i in range(entry_count):
        e = raw[i * 32:(i + 1) * 32]
        if len(e) < 32:
            break
        v = struct.unpack(">8I", e)
        ents.append({"id": v[0], "name_off": v[1], "f1": v[2], "f2": v[3],
                     "off": v[4], "size": v[5]})
    return ents


def read_name_table(f, base, ents):
    nt_entry = next((e for e in ents if e["id"] == 512), None)
    if not nt_entry:
        return b""
    f.seek(base + nt_entry["off"])
    return f.read(nt_entry["size"])


def entry_name(nt, off):
    end = nt.find(b"\x00", off)
    if end < 0:
        return ""
    return nt[off:end].decode("ascii", errors="replace")


def parse_sfo(data):
    out = {}
    try:
        if data[:4] != b"\x00PSF":
            return {"_error": "bad magic %r" % data[:4]}
        ver, key_off, data_off, count = struct.unpack_from("<4I", data, 4)
        for i in range(count):
            eo = 20 + i * 16
            key_rel, fmt, dlen, dmax, doff = struct.unpack_from("<HHIII", data, eo)
            ks = key_off + key_rel
            ke = data.find(b"\x00", ks)
            key = data[ks:ke].decode("utf-8", errors="replace")
            val_off = data_off + doff
            if fmt == 0x0204:
                ve = data.find(b"\x00", val_off, val_off + dmax)
                if ve < 0:
                    ve = val_off + dlen
                out[key] = data[val_off:ve].decode("utf-8", errors="replace")
            elif fmt == 0x0404:
                out[key] = struct.unpack_from("<I", data, val_off)[0]
            else:
                out[key] = data[val_off:val_off + dlen].hex(" ")
        return out
    except Exception as e:
        return {"_error": str(e)}


REGION_NAMES = {"EP": "Europe", "UP": "Americas", "JP": "Japan", "HP": "Asia"}
PS4_CAT_TYPES = {"gd": "Base Game", "ac": "DLC", "gp": "Update"}


def content_region(cid):
    """Region from content-ID prefix (EP0002-... -> Europe)."""
    try:
        pre = (cid or "").split("-")[0][:2].upper()
        return REGION_NAMES.get(pre, pre or "-")
    except Exception:
        return "-"


def _tid_from_cid(cid):
    """Title ID from a PlayStation Content ID.

    UP0949-CUSA04195_00-BRAWLHALLA111315 -> CUSA04195. Used as a fallback
    when param.sfo is unreadable (partial/corrupt download) so the Title ID
    row is still shown. Never raises.
    """
    try:
        return (cid or "").split("-")[1].split("_")[0].strip().upper()
    except Exception:
        return ""


def _tid_from_filename(path):
    """Title ID from a file name (CUSA04195_BRAWLHALLA_... -> CUSA04195)."""
    try:
        import re as _re
        m = _re.search(r"(CUSA\d{5})",
                        os.path.basename(path or ""), _re.IGNORECASE)
        return m.group(1).upper() if m else ""
    except Exception:
        return ""


def fmt_fw32(v):
    """Decode 32-bit Sony fw int (SFO SYSTEM_VER, e.g. 0x05010000)
    nibble-BCD -> '5.01'. Real fw versions are major.minor only,
    so the low word is not a version part. Passes anything else
    through untouched."""
    try:
        if isinstance(v, int):
            n = v
        else:
            s = str(v or "").strip()
            if s in ("", "-"):
                return "-"
            if not s.lstrip("+-").isdigit():
                return s  # already dotted ("05.050.000", "4.80", ...)
            n = int(s, 0)
    except Exception:
        return str(v)
    try:
        if n == 0:
            return "-"
        if not (0x01000000 <= n <= 0xFFFFFFFF):
            return str(v)
        hi, lo = (n >> 24) & 0xFF, (n >> 16) & 0xFF
        if (hi >> 4) > 9 or (hi & 0xF) > 9 or \
           (lo >> 4) > 9 or (lo & 0xF) > 9:
            return str(v)  # not BCD -> don't invent a version
        major = f"{hi:02X}".lstrip("0") or "0"
        return f"{major}.{lo:02X}"
    except Exception:
        return str(v)


def fmt_fw(v):
    """Decode PS5 fw hex (0x0250...) -> '2.50'. Passes other values through."""
    if v is None or v == "":
        return "-"
    try:
        n = v if isinstance(v, int) else int(str(v).strip(), 0)
        top = (n >> 48) & 0xFFFF
        if not top:
            return fmt_fw32(n)  # 32-bit Sony fw/SDK int, not raw text
        return f"{(top >> 8) & 0xFF:X}.{top & 0xFF:02X}"
    except Exception:
        return str(v)


def ps4_pkg_type(cat):
    if not cat:
        return "-"
    lab = PS4_CAT_TYPES.get(str(cat).lower())
    return lab if lab else str(cat)


def _sdk_fw_text(raw):
    """SDK version from a PS4 param.sfo value -> '5.05' ('' when unknown).

    SDK_VER is a 32-bit BCD fw int (0x05050000); PUBTOOLINFO carries the
    same number as bare hex (sdk_ver=05050000), so base 16 is needed there
    (int("05050000", 0) would reject the leading zero).
    """
    try:
        if isinstance(raw, int):
            return fmt_fw32(raw)
        s = str(raw or "").strip()
        if not s or s == "-":
            return ""
        if s.lower().startswith("0x"):
            return fmt_fw32(int(s, 16))
        if s.isdigit() and len(s) <= 8:
            return fmt_fw32(int(s, 16))
        return ""
    except Exception:
        return ""


def ps4_sdk_version(sfo):
    """PS4 SDK version: SDK_VER field, else PUBTOOLINFO sdk_ver=...

    Backported PKGs are rebuilt with an older SDK, so this is the row that
    gives a backport away; it used to be visible only in the raw dump.
    """
    if not isinstance(sfo, dict):
        return ""
    for key in ("SDK_VER", "SDK_VERSION"):
        if key in sfo:
            v = _sdk_fw_text(sfo.get(key))
            if v and v != "-":
                return v
    try:
        import re as _re
        m = _re.search(r"sdk_ver\s*=\s*([0-9A-Fa-f]+)",
                       str(sfo.get("PUBTOOLINFO", "") or ""))
        if m:
            v = _sdk_fw_text(m.group(1))
            if v and v != "-":
                return v
    except Exception:
        pass
    return ""


def cnt_package_type(hdr):
    """FPKG vs retail for PS4 CNT: bit 31 of pkg_type @0x04 (big-endian).

    Per psdevwiki/UnPKG: FILE_TYPE_FLAGS_RETAIL = 1 << 31. Retail PKGs
    have pkg_type like 0x83000001/0x81000001; fpkg builds (even DUPLEX,
    which carry non-zero digest bytes at 0x100..0x200) have it clear
    (e.g. 0x00000001/0x40000001). The 0x100..0x200 area holds SHA256
    digests, NOT an RSA signature, so zero-testing it is wrong.
    """
    try:
        if len(hdr) >= 8:
            ptype = struct.unpack_from(">I", hdr, 0x04)[0]
            if ptype & 0x80000000:
                return "OFC (Official)"
            return "FPKG (Fake)"
    except Exception:
        pass
    return "-"


def lman_summary(meta_kind, rd):
    """Bottom-bar summary à la LMAN: Type (Fake) (REGION) - vVER - System SYS."""
    try:
        typ = str(rd.get("Type", "") or "")
        pkg = str(rd.get("Package", "") or rd.get("Signature", ""))
        if not typ:
            # encrypted stubs / table-less kinds have no Type row: use
            # the Package label base (e.g. "OFC (Official)" -> "OFC").
            typ = pkg
        base = typ.split("(")[0].strip() or typ or "-"
        fake = ""
        if "fake" in pkg.lower() or "fpkg" in pkg.lower():
            fake = " (Fake)"
        elif "official" in pkg.lower() or pkg.lower().startswith("ofc"):
            fake = " (Official)"
        region = str(rd.get("Region", "") or "")
        short = REGION_SHORT.get(region, region[:2].upper() if region else "-")
        ver = (rd.get("Version", "") or rd.get("Content Ver", "") or "-")
        ver = str(ver).strip() or "-"
        if ver != "-" and not ver.lower().startswith("v"):
            ver = "v" + ver
        sysv = str(rd.get("Min. System", "") or "").strip()
        out = f"{base}{fake} ({short}) - {ver}"
        if sysv and sysv != "-":
            out += f" - System {sysv}"
        return out
    except Exception:
        return ""


def _param_json_meta(meta):
    lp = meta.get("localizedParameters", {})
    lang = lp.get("defaultLanguage", "en-US")
    title = (lp.get(lang) or {}).get("titleName", "")
    cid = meta.get("contentId", "")
    cn = meta.get("applicationCategoryType")
    ptype = "Application (APP)" if cn == 0 else (f"Type {cn}" if cn is not None else "-")
    drm = meta.get("applicationDrmType", "")
    extra = [("Title ID", meta.get("titleId", "")),
             ("Content ID", cid),
             ("Region", content_region(cid)),
             ("Type", ptype),
             ("Content Ver", meta.get("contentVersion", "")),
             ("Master Ver", meta.get("masterVersion", "")),
             ("Concept ID", meta.get("conceptId", "")),
             ("Min. System", fmt_fw(meta.get("requiredSystemSoftwareVersion"))),
             ("DRM", str(drm).capitalize() if drm else "-"),
             ("SDK", fmt_fw(meta.get("sdkVersion")))]
    return title, extra


def _switch_title_from_filename(path):
    """(title, tid, ver) from Switch naming: Name [TID16][vN]... .nsp/.xci."""
    import re as _re
    base = os.path.basename(path)
    stem, _ = os.path.splitext(base)
    tid, ver = "", ""
    m = _re.search(r"\[([0-9A-Fa-f]{16})\]", stem)
    if m:
        tid = m.group(1).upper()
    m = _re.search(r"\[v(\d+)\]", stem, _re.IGNORECASE)
    if m:
        ver = m.group(1)
    title = _re.sub(r"\[[^\]]*\]", "", stem).strip(" -_.")
    title = _re.sub(r"\s{2,}", " ", title)
    return title or stem, tid, ver


def _parse_cnmt_xml(data):
    """Minimal *.cnmt.xml -> dict(Id, Version, Type, RequiredSystemVersion,
    PatchId, contents=[{Type, Id, Size}]). Never raises."""
    out = {"contents": []}
    try:
        import xml.etree.ElementTree as _et
        root = _et.fromstring(data)
        def _txt(tag):
            try:
                el = root.find(tag)
                return (el.text or "").strip() if el is not None else ""
            except Exception:
                return ""
        for k in ("Type", "Id", "Version", "RequiredDownloadSystemVersion",
                  "RequiredSystemVersion", "PatchId", "Digest",
                  "KeyGenerationMin"):
            v = _txt(k)
            if v:
                out[k] = v
        for c in root.findall("Content"):
            try:
                def _ct(t):
                    el = c.find(t)
                    return (el.text or "").strip() if el is not None else ""
                out["contents"].append({"Type": _ct("Type"), "Id": _ct("Id"),
                                       "Size": _ct("Size")})
            except Exception:
                continue
    except Exception:
        pass
    return out


# ---------------- Switch NCA decrypt (prod.keys) -> NACP title + icon ----------------
# Needs the `cryptography` package (already required for PS3 PKG AES).
# All helpers never raise: they return None/{} when keys or the package
# cannot provide decrypted data. No key material is ever stored in results.

_SWITCH_KEYS_CACHE = {"once": False, "keys": None}

NACP_LANGS = ("AmericanEnglish", "BritishEnglish", "Japanese", "French",
              "German", "LatinAmericanSpanish", "Spanish", "Italian",
              "Dutch", "CanadianFrench", "Portuguese", "Russian", "Korean",
              "TraditionalChinese", "SimplifiedChinese", "BrazilianPortuguese")


def _find_switch_keys():
    """Load Switch prod.keys once -> dict or None. Never raises."""
    try:
        if _SWITCH_KEYS_CACHE["once"]:
            return _SWITCH_KEYS_CACHE["keys"]
        _SWITCH_KEYS_CACHE["once"] = True
        cands = []
        try:
            ev = (os.environ.get("SWITCH_PROD_KEYS")
                  or os.environ.get("PROD_KEYS") or "")
            if ev and os.path.isfile(ev):
                cands.append(ev)
        except Exception:
            pass
        try:
            here = os.path.dirname(os.path.abspath(__file__))
            cands.append(os.path.join(here, "prod.keys"))
            cands.append(os.path.join(os.getcwd(), "prod.keys"))
        except Exception:
            pass
        try:
            if sys.platform.startswith("win"):
                base = os.environ.get("APPDATA") or os.path.expanduser("~")
                cands.append(os.path.join(base, "PKGViewer", "prod.keys"))
            else:
                cands.append(os.path.join(os.path.expanduser("~"),
                                           ".switch", "prod.keys"))
        except Exception:
            pass
        path = next((p for p in cands if p and os.path.isfile(p)), None)
        if not path:
            return None
        raw = {}
        with open(path, "r", encoding="utf-8", errors="replace") as fh:
            for line in fh:
                line = line.strip()
                if not line or line.startswith("#") or "=" not in line:
                    continue
                k, v = line.split("=", 1)
                try:
                    raw[k.strip()] = bytes.fromhex(v.strip())
                except Exception:
                    continue
        if len(raw.get("header_key", b"")) != 32:
            return None
        import re as _re
        keys = {"header_key": raw["header_key"], "kaek": {},
                "titlekek": {}}
        for k, v in raw.items():
            m = _re.match(r"^key_area_key_(application|ocean|system)_"
                          r"([0-9a-fA-F]{2})$", k)
            if m and len(v) == 16:
                keys["kaek"][(m.group(1), int(m.group(2), 16))] = v
                continue
            m = _re.match(r"^titlekek_([0-9a-fA-F]{2})$", k)
            if m and len(v) == 16:
                keys["titlekek"][int(m.group(1), 16)] = v
        if not keys["kaek"]:
            return None
        _SWITCH_KEYS_CACHE["keys"] = keys
        return keys
    except Exception:
        return None


def _sw_aes_ecb_dec(key, data):
    from cryptography.hazmat.primitives.ciphers import Cipher as _C
    from cryptography.hazmat.primitives.ciphers import algorithms as _A
    from cryptography.hazmat.primitives.ciphers import modes as _M
    d = _C(_A.AES(key), _M.ECB()).decryptor()
    return d.update(data) + d.finalize()


def _sw_aes_xts_dec(key, tweak, data):
    from cryptography.hazmat.primitives.ciphers import Cipher as _C
    from cryptography.hazmat.primitives.ciphers import algorithms as _A
    from cryptography.hazmat.primitives.ciphers import modes as _M
    d = _C(_A.AES(key), _M.XTS(tweak)).decryptor()
    return d.update(data) + d.finalize()


def _switch_nca_control_info(nsp_path, nca_abs_off, tik_bytes, keys):
    """Decrypt a Control NCA -> {title, publisher, display_ver, titles,
    icon, icon_name} or None. Reads only header + RomFS tables + NACP +
    one icon (fast). Never raises, never returns key material."""
    import struct as _st
    try:
        if not keys or nca_abs_off < 0:
            return None
        with open(nsp_path, "rb") as f:
            f.seek(nca_abs_off)
            raw_hdr = f.read(0xC00)
        if len(raw_hdr) < 0xC00:
            return None
        # header: AES-XTS, BE sector tweak (hactool-compatible)
        full = b"".join(
            _sw_aes_xts_dec(keys["header_key"], s.to_bytes(16, "big"),
                            raw_hdr[s * 0x200:(s + 1) * 0x200])
            for s in range(6))
        if full[0x200:0x204] not in (b"NCA3", b"NCA2"):
            return None
        if full[0x205] != 2:  # not a Control NCA
            return None
        crypto = max(full[0x206], full[0x220])
        if crypto:
            crypto -= 1
        rights = full[0x230:0x240]
        if any(rights):
            if not tik_bytes or len(tik_bytes) < 0x1CF:
                return None
            tk = keys["titlekek"].get(crypto)
            if tk is None:
                return None
            sec_key = _sw_aes_ecb_dec(tk, tik_bytes[0x1BF:0x1CF])
        else:
            kaek_ind = full[0x207]
            kind = {0: "application", 1: "ocean",
                    2: "system"}.get(kaek_ind, "application")
            kak = keys["kaek"].get((kind, crypto))
            if kak is None:
                return None
            area = _sw_aes_ecb_dec(kak, full[0x300:0x340])
            sec_key = area[32:48]
        from cryptography.hazmat.primitives.ciphers import Cipher as _C
        from cryptography.hazmat.primitives.ciphers import algorithms as _A
        from cryptography.hazmat.primitives.ciphers import modes as _M

        def _sec_read(f, secoff, iv_int, rel_off, size):
            if size <= 0 or size > 16_000_000:
                return b""
            lo = rel_off & ~0xF
            nblocks = ((rel_off - lo) + size + 15) // 16
            c0 = iv_int + (lo >> 4)
            e = _C(_A.AES(sec_key), _M.ECB()).encryptor()
            ks = e.update(b"".join((c0 + i).to_bytes(16, "big")
                                   for i in range(nblocks))) + e.finalize()
            f.seek(secoff + lo)
            ct = f.read(nblocks * 16)
            if len(ct) < nblocks * 16:
                return b""
            pt = bytes(a ^ b for a, b in zip(ct, ks))
            skip = rel_off - lo
            return pt[skip:skip + size]

        with open(nsp_path, "rb") as f:
            for i in range(4):
                start, _end = _st.unpack_from("<II", full, 0x240 + i * 16)
                if not start:
                    continue
                fsh = full[0x400 + i * 0x200:0x400 + (i + 1) * 0x200]
                if len(fsh) < 0x200 or fsh[3] != 3 or fsh[4] != 3:
                    continue  # need RomFS (3) + AES-CTR (3)
                if fsh[0x8:0xC] != b"IVFC":
                    continue
                secoff_rel = start * 0x200
                secoff = nca_abs_off + secoff_rel
                sctr = fsh[0x140:0x148]
                iv_int = int.from_bytes(
                    bytes(reversed(sctr))
                    + (secoff_rel >> 4).to_bytes(8, "big"), "big")
                romfs_rel = _st.unpack_from("<Q", fsh,
                                            0x8 + 0x10 + 5 * 0x18)[0]
                if romfs_rel > 2_000_000_000:
                    continue
                rh = _sec_read(f, secoff, iv_int, romfs_rel, 0x50)
                if len(rh) < 0x50:
                    continue
                vals = _st.unpack("<10Q", rh)
                if vals[0] != 0x50:
                    continue
                _hs, _dho, _dhs, dmo, dms, _fho, _fhs, fmo, fms, data_off = vals
                if dms > 1_000_000 or fms > 5_000_000:
                    continue
                dirs = _sec_read(f, secoff, iv_int, romfs_rel + dmo, dms)
                files = _sec_read(f, secoff, iv_int, romfs_rel + fmo, fms)
                if len(dirs) < 24 or not files:
                    continue
                # walk root + one subdir level: [(path, data_off, size)]
                found = []

                def _files_at(tbl_off):
                    out, o, seen = [], tbl_off, set()
                    while (o != 0xFFFFFFFF and o not in seen
                           and o + 32 <= len(files)):
                        seen.add(o)
                        try:
                            _pa, sib, fo, fs, _h, nl = _st.unpack_from(
                                "<IIQQII", files, o)
                        except Exception:
                            break
                        if nl > 512 or o + 32 + nl > len(files):
                            break
                        try:
                            nm = files[o + 32:o + 32 + nl].decode("utf-8")
                        except Exception:
                            break
                        if fo + fs < fo:  # overflow guard
                            break
                        out.append((nm, fo, fs))
                        o = sib
                    return out

                try:
                    root_file = _st.unpack_from("<I", dirs, 12)[0]
                except Exception:
                    continue
                for nm, fo, fs in _files_at(root_file):
                    found.append(("", nm, fo, fs))
                # one subdir level (some titles nest control data)
                try:
                    _pa, _sib, child, _fi, _h, _nl = _st.unpack_from(
                        "<6I", dirs, 0)
                except Exception:
                    child = 0xFFFFFFFF
                seen_d, stack = set(), [child]
                while stack:
                    do = stack.pop()
                    if do == 0xFFFFFFFF or do in seen_d or do + 24 > len(dirs):
                        continue
                    seen_d.add(do)
                    try:
                        _p, sib, ch, fi, _hh, nll = _st.unpack_from(
                            "<6I", dirs, do)
                        dn = dirs[do + 24:do + 24 + nll].decode("utf-8")
                    except Exception:
                        continue
                    for nm, fo, fs in _files_at(fi):
                        found.append((dn, nm, fo, fs))
                    if ch != 0xFFFFFFFF:
                        stack.append(ch)
                    if sib != 0xFFFFFFFF:
                        stack.append(sib)
                low = [(d, n, fo, fs) for d, n, fo, fs in found]
                nacp_hit = next((x for x in low
                                 if x[1].lower() == "control.nacp"), None)
                if nacp_hit is None:
                    continue
                _dd, _nn, nacp_off, nacp_size = nacp_hit
                nacp = _sec_read(f, secoff, iv_int,
                                 romfs_rel + data_off + nacp_off,
                                 min(nacp_size, 0x4000))
                if len(nacp) < 0x3080:
                    continue
                titles, pubs = {}, {}
                for li in range(16):
                    try:
                        nm = nacp[li * 0x300:li * 0x300 + 0x200
                                  ].split(b"\x00")[0].decode("utf-8").strip()
                        pb = nacp[li * 0x300 + 0x200:li * 0x300 + 0x300
                                  ].split(b"\x00")[0].decode("utf-8").strip()
                    except Exception:
                        continue
                    if nm:
                        titles[NACP_LANGS[li]] = nm
                    if pb:
                        pubs[NACP_LANGS[li]] = pb
                if not titles:
                    continue
                try:
                    disp = nacp[0x3060:0x3070].split(b"\x00")[0
                             ].decode("utf-8").strip()
                except Exception:
                    disp = ""
                icons = [(d, n, fo, fs) for d, n, fo, fs in low
                         if n.lower().startswith("icon_")
                         and n.lower().endswith(".dat")
                         and 1024 <= fs <= 8_000_000]
                icon_bytes, icon_name = b"", ""
                for pref in ("icon_AmericanEnglish.dat",
                             "icon_BritishEnglish.dat",
                             "icon_Japanese.dat"):
                    hit = next((x for x in icons if x[1] == pref), None)
                    if hit is not None:
                        icons = [hit]
                        break
                if icons:
                    _dd, _nn, ioff, isz = icons[0]
                    icon_bytes = _sec_read(f, secoff, iv_int,
                                           romfs_rel + data_off + ioff, isz)
                    if icon_bytes[:2] != b"\xff\xd8":
                        icon_bytes = b""
                    else:
                        icon_name = icons[0][1]
                return {"titles": titles, "publisher": pubs,
                        "display_ver": disp,
                        "icon": icon_bytes, "icon_name": icon_name}
        return None
    except Exception:
        return None


def _switch_decrypt_nca_header(nsp_path, nca_abs_off, keys):
    """AES-XTS (BE sector tweak) decrypt an NCA header -> 0xC00 bytes or None."""
    import struct as _st
    try:
        if not keys or nca_abs_off is None or nca_abs_off < 0:
            return None
        with open(nsp_path, "rb") as f:
            f.seek(nca_abs_off)
            raw = f.read(0xC00)
        if len(raw) < 0xC00:
            return None
        full = b"".join(
            _sw_aes_xts_dec(keys["header_key"], s.to_bytes(16, "big"),
                            raw[s * 0x200:(s + 1) * 0x200])
            for s in range(6))
        if full[0x200:0x204] not in (b"NCA3", b"NCA2"):
            return None
        return full
    except Exception:
        return None


def _switch_nca_section_key(full, tik_bytes, keys):
    """Section data key for an NCA: titlekey (rights) or key-area [2].
    Returns bytes or None. Never raises."""
    try:
        crypto = max(full[0x206], full[0x220])
        if crypto:
            crypto -= 1
        rights = full[0x230:0x240]
        if any(rights):
            if not tik_bytes or len(tik_bytes) < 0x1CF:
                return None
            tk = keys["titlekek"].get(crypto)
            if tk is None:
                return None
            return _sw_aes_ecb_dec(tk, tik_bytes[0x1BF:0x1CF])
        kaek_ind = full[0x207]
        kind = {0: "application", 1: "ocean",
                2: "system"}.get(kaek_ind, "application")
        kak = keys["kaek"].get((kind, crypto))
        if kak is None:
            return None
        return _sw_aes_ecb_dec(kak, full[0x300:0x340])[32:48]
    except Exception:
        return None


def _switch_ctr_reader(sec_key, secoff_rel):
    """Range reader for an AES-CTR NCA section.

    read(f, secoff_abs, rel_off, size, sctr) -> bytes (b"" on failure).
    Counter base = section NCA-relative offset (hactool-compatible).
    Never raises."""

    def _read(f, secoff_abs, rel_off, size, sctr):
        try:
            from cryptography.hazmat.primitives.ciphers import Cipher as _C
            from cryptography.hazmat.primitives.ciphers import algorithms as _A
            from cryptography.hazmat.primitives.ciphers import modes as _M
            if size <= 0 or size > 16_000_000:
                return b""
            base = int.from_bytes(
                bytes(reversed(sctr))
                + (secoff_rel >> 4).to_bytes(8, "big"), "big")
            lo = rel_off & ~0xF
            nblocks = ((rel_off - lo) + size + 15) // 16
            c0 = base + (lo >> 4)
            e = _C(_A.AES(sec_key), _M.ECB()).encryptor()
            ks = e.update(b"".join((c0 + i).to_bytes(16, "big")
                                   for i in range(nblocks))) + e.finalize()
            f.seek(secoff_abs + lo)
            ct = f.read(nblocks * 16)
            if len(ct) < nblocks * 16:
                return b""
            pt = bytes(a ^ b for a, b in zip(ct, ks))
            skip = rel_off - lo
            return pt[skip:skip + size]
        except Exception:
            return b""

    return _read


_SWITCH_NCA_TYPES = {0: "Program", 1: "Meta", 2: "Control", 3: "Manual",
                     4: "Data", 5: "PublicData"}
_SWITCH_CNMT_TYPES = {0x01: "System", 0x02: "SystemData",
                      0x03: "SystemUpdate", 0x80: "Application",
                      0x81: "Patch", 0x82: "AddOnContent"}


def _switch_read_cnmt_bin(nsp_path, meta_abs_off, tik_bytes, keys):
    """Parse binary CNMT from a Meta (*.cnmt.nca) NCA -> dict or None.
    {tid, ver, type, sysver, contents: [{nca_id, type}]}. Never raises."""
    import struct as _st
    try:
        full = _switch_decrypt_nca_header(nsp_path, meta_abs_off, keys)
        if full is None or full[0x205] != 1:
            return None
        sec_key = _switch_nca_section_key(full, tik_bytes, keys)
        if sec_key is None:
            return None
        with open(nsp_path, "rb") as f:
            for i in range(4):
                start, _end = _st.unpack_from("<II", full, 0x240 + i * 16)
                if not start:
                    continue
                fsh = full[0x400 + i * 0x200:0x400 + (i + 1) * 0x200]
                if len(fsh) < 0x200 or fsh[3] != 2:
                    continue  # need PFS0 section
                enc = fsh[4]
                if enc not in (1, 3):
                    continue
                secoff_rel = start * 0x200
                secoff = meta_abs_off + secoff_rel
                poff, psz = _st.unpack_from("<QQ", fsh, 0x8 + 0x38)
                if poff > 64_000_000 or psz > 64_000_000 or psz < 16:
                    continue

                def _raw(soff, size):
                    f.seek(secoff + soff)
                    return f.read(size)

                if enc == 3:
                    sctr = fsh[0x140:0x148]
                    read = _switch_ctr_reader(sec_key, secoff_rel)

                    def _get(soff, size):
                        return read(f, secoff, soff, size, sctr)
                else:
                    def _get(soff, size):
                        return _raw(soff, size)

                hdr = _get(poff, 16)
                if len(hdr) < 16 or hdr[:4] != b"PFS0":
                    continue
                num, sts = _st.unpack_from("<II", hdr, 4)
                if not (1 <= num <= 64) or sts > 1_000_000:
                    continue
                tab = _get(poff + 16, num * 24)
                stb = _get(poff + 16 + num * 24, sts)
                if len(tab) < num * 24 or len(stb) < sts:
                    continue
                base = poff + 16 + num * 24 + sts
                for j in range(num):
                    try:
                        off, sz, soff, _p = _st.unpack_from("<QQII", tab,
                                                           j * 24)
                    except Exception:
                        continue
                    if soff >= len(stb):
                        continue
                    en = stb.find(b"\x00", soff)
                    if en < 0:
                        continue
                    try:
                        nm = stb[soff:en].decode("utf-8", errors="replace")
                    except Exception:
                        continue
                    if not nm.lower().endswith(".cnmt") or sz > 100_000:
                        continue
                    data = _get(base + off, min(sz, 0x2000))
                    if len(data) < 0x20:
                        continue
                    tid, ver = _st.unpack_from("<QI", data, 0)
                    if not tid:
                        continue
                    ctype = data[0xC]
                    toff, ccnt, mcnt = _st.unpack_from("<HHH", data, 0xE)
                    try:
                        sysver = _st.unpack_from("<I", data, 0x18)[0]
                    except Exception:
                        sysver = 0
                    if ccnt > 128:
                        continue
                    contents = []
                    for k in range(ccnt):
                        bo = 0x20 + toff + k * 0x38
                        if bo + 0x38 > len(data):
                            # records may extend past first read; fetch more
                            data = _get(base + off,
                                        min(sz, bo + mcnt * 0x10 + 0x38))
                            if bo + 0x38 > len(data):
                                break
                        try:
                            nid = data[bo + 0x20:bo + 0x30].hex()
                            ctp = data[bo + 0x36]
                        except Exception:
                            break
                        contents.append({"nca_id": nid, "type": ctp})
                    return {"tid": "%016X" % tid, "ver": str(ver),
                            "type": _SWITCH_CNMT_TYPES.get(
                                ctype, "Type %#x" % ctype),
                            "sysver": str(sysver) if sysver else "",
                            "contents": contents}
        return None
    except Exception:
        return None


def _switch_decode_fw(v):
    """HOS packed system version (major<<26|minor<<20|micro<<16) -> '16.0.3'.

    Used for NSP RequiredSystemVersion / CNMT required versions.
    Returns "" on any doubt (caller falls back to the raw number)."""
    try:
        n = v if isinstance(v, int) else int(str(v).strip(), 0)
        if not (0 < n < 0xFFFFFFFF):
            return ""
        maj, mno, mic = (n >> 26) & 0x3F, (n >> 20) & 0x3F, (n >> 16) & 0xF
        if not (1 <= maj <= 40):
            return ""
        return f"{maj}.{mno}.{mic}"
    except Exception:
        return ""


def _switch_nca_detail(nsp_path, nca_abs_off, keys):
    """Per-NCA facts from its header: {ctype, crypto, rights} or None.

    crypto = master-key revision index (matches prod.keys *_0X suffixes).
    Needs header_key only for the header itself. Never raises."""
    try:
        full = _switch_decrypt_nca_header(nsp_path, nca_abs_off, keys)
        if full is None:
            return None
        crypto = max(full[0x206], full[0x220])
        if crypto:
            crypto -= 1
        return {"ctype": full[0x205], "crypto": crypto,
                "rights": bool(any(full[0x230:0x240]))}
    except Exception:
        return None


def _switch_tag_control(e):
    """Set an entry's codec base to Control, preserving any ' · suffix'."""
    try:
        cur = str(e.get("codec") or "")
        sfx = cur.split(" · ", 1)[1] if " · " in cur else ""
        e["codec"] = "Control" + (" · " + sfx if sfx else "")
    except Exception:
        pass


def _parse_pfs0_entries(f, size):
    """PFS0 at offset 0 -> (entries, strtab, base) or (None, err). Never raises."""
    try:
        f.seek(0)
        hdr = f.read(16)
        if len(hdr) < 16 or hdr[:4] != PFS0_MAGIC:
            return None, "not PFS0"
        import struct as _st
        num, str_size, _rsv = _st.unpack_from("<III", hdr, 4)
        if not (1 <= num <= 100000):
            return None, f"bad file count {num}"
        if str_size > 20_000_000:
            return None, "string table too large"
        raw = f.read(num * 24)
        if len(raw) < num * 24:
            return None, "truncated file table"
        strtab = f.read(str_size)
        if len(strtab) < str_size:
            return None, "truncated string table"
        base = 16 + num * 24 + str_size
        if base > size:
            return None, "header beyond EOF"
        items = []
        for i in range(num):
            off, sz, soff, _pad = _st.unpack_from("<QQII", raw, i * 24)
            if soff >= len(strtab):
                return None, f"bad name offset #{i}"
            end = strtab.find(b"\x00", soff)
            if end < 0:
                return None, f"unterminated name #{i}"
            try:
                name = strtab[soff:end].decode("utf-8", errors="replace")
            except Exception:
                name = ""
            if off + sz > size - base + (1 << 20):
                # allow slight overrun (padding) but not wild values
                if off > size:
                    return None, f"bad data offset #{i}"
            items.append({"off": off, "size": sz, "name": name})
        return (items, strtab, base), ""
    except Exception as e:
        return None, str(e)


def parse_nsp(path):
    """Nintendo Switch NSP (PFS0): file list + TitleID/version from name and
    *.cnmt.xml. With prod.keys (PKGViewer folder): official NACP title +
    icon from the Control NCA. Raw extraction needs no keys. Never raises."""
    import re as _re
    try:
        size = os.path.getsize(path)
    except OSError as e:
        return {"error": str(e)}
    try:
        with open(path, "rb") as f:
            parsed, err = _parse_pfs0_entries(f, size)
            if parsed is None:
                return {"error": f"not a PFS0/NSP ({err})"}
            items, _strtab, base = parsed
            ents = []
            for i, it in enumerate(items):
                ents.append({"id": i, "name": it["name"], "size": it["size"],
                             "off": base + it["off"],
                             "abs_off": base + it["off"]})
            # cnmt.xml (plaintext, <100KB): title/version/type source
            cnmt = {}
            for e in ents:
                if e["name"].lower().endswith(".cnmt.xml") and 0 < e["size"] < 200_000:
                    try:
                        f.seek(e["abs_off"])
                        cnmt = _parse_cnmt_xml(f.read(e["size"]))
                        cnmt["_file"] = e["name"]
                    except Exception:
                        cnmt = {}
                    break
            nca_type = {}
            for c in cnmt.get("contents", []):
                try:
                    if c.get("Id"):
                        nca_type[str(c["Id"]).lower()] = c.get("Type", "")
                except Exception:
                    continue
            for e in ents:
                try:
                    ln = e["name"].lower()
                    if ln.endswith(".cnmt.nca"):
                        _cid = os.path.basename(ln)[:-len(".cnmt.nca")]
                        _t = nca_type.get(_cid, "")
                        if _t:
                            e["codec"] = _t
                    elif ln.endswith(".nca"):
                        _cid = os.path.splitext(os.path.basename(ln))[0]
                        _t = nca_type.get(_cid, "")
                        if _t:
                            e["codec"] = _t
                    elif ln.endswith((".tik", ".cert")):
                        e["codec"] = "ticket" if ln.endswith(".tik") else "cert"
                except Exception:
                    pass
            fname_title, fname_tid, fname_ver = _switch_title_from_filename(path)
            # prod.keys + ticket bytes once (titlekey-crypto NCAs need both)
            _skeys, _tikb = None, None
            try:
                _skeys = _find_switch_keys()
            except Exception:
                _skeys = None
            if _skeys is not None:
                try:
                    _tik = next((e for e in ents
                                 if e["name"].lower().endswith(".tik")
                                 and 0 < e["size"] <= 8192), None)
                    if _tik is not None:
                        f.seek(_tik["abs_off"])
                        _tikb = f.read(_tik["size"])
                except Exception:
                    _tikb = None
            # binary CNMT fallback when *.cnmt.xml is absent (needs keys):
            # Meta NCA holds "<title>.cnmt" with id/version/type + contents.
            _cnmt_bin = None
            if not cnmt.get("Id") and _skeys is not None:
                try:
                    _meta = next((e for e in ents
                                  if e["name"].lower().endswith(".cnmt.nca")),
                                 None)
                    if _meta is not None:
                        _cnmt_bin = _switch_read_cnmt_bin(
                            path, _meta["abs_off"], _tikb, _skeys)
                except Exception:
                    _cnmt_bin = None
            _hdr_types = {}
            if _skeys is not None:
                # Authoritative per-NCA types from NCA headers (cheap: 3KB
                # XTS each) + crypto facts for the Files tab. CNMT record
                # type bytes are NOT used (unreliable across titles).
                for e in ents:
                    try:
                        ln = e["name"].lower()
                        if ln.endswith(".cnmt.nca"):
                            _cid = os.path.basename(ln)[:-len(".cnmt.nca")]
                        elif ln.endswith(".nca"):
                            _cid = os.path.splitext(os.path.basename(ln))[0]
                        else:
                            continue
                        _det = _switch_nca_detail(path, e["abs_off"], _skeys)
                        if _det is None:
                            continue
                        e["nca_detail"] = (
                            "keygen %d, %s crypto" % (
                                _det["crypto"],
                                "titlekey" if _det["rights"] else "standard"))
                        _sfx = ("tk" if _det["rights"]
                                else "k%d" % _det["crypto"])
                        _htn = _SWITCH_NCA_TYPES.get(_det["ctype"], "NCA")
                        _hdr_types[_cid] = _htn
                        if not e.get("codec"):
                            # xml already tagged precise names (LegalInformation
                            # etc.); headers fill the rest
                            e["codec"] = _htn
                        if " · " not in str(e.get("codec")):
                            e["codec"] = "%s · %s" % (e["codec"], _sfx)
                    except Exception:
                        continue
            tid = ""
            try:
                tid = str(cnmt.get("Id", "") or "").strip()
                if tid.lower().startswith("0x"):
                    tid = tid[2:].upper()
                else:
                    tid = tid.upper()
            except Exception:
                tid = ""
            if not tid and _cnmt_bin:
                tid = str(_cnmt_bin.get("tid", "") or "").upper()
            if not tid:
                tid = fname_tid
            ver = str(cnmt.get("Version", "") or "").strip()
            if not ver and _cnmt_bin:
                ver = str(_cnmt_bin.get("ver", "") or "").strip()
            if not ver:
                ver = fname_ver
            ctype = str(cnmt.get("Type", "") or "").strip()
            if not ctype and _cnmt_bin:
                ctype = str(_cnmt_bin.get("type", "") or "").strip()
            ctype = ctype or "-"
            sysver = str(cnmt.get("RequiredSystemVersion", "") or "").strip()
            if not sysver and _cnmt_bin:
                sysver = str(_cnmt_bin.get("sysver", "") or "").strip()
            sysver = sysver or "-"
            if sysver == "0":
                sysver = "-"
            _sysrow = _switch_decode_fw(sysver) if sysver != "-" else ""
            _sysrow = _sysrow or sysver
            has_tik = any(e["name"].lower().endswith(".tik") for e in ents)
            has_cert = any(e["name"].lower().endswith(".cert") for e in ents)
            n_nca = sum(1 for e in ents if e["name"].lower().endswith(".nca"))
            content_kinds = sorted({c.get("Type", "") for c in cnmt.get("contents", []) if c.get("Type")})
            if not content_kinds and _hdr_types:
                try:
                    content_kinds = sorted(set(_hdr_types.values()))
                except Exception:
                    content_kinds = []
            rows = [("Platform", "Nintendo Switch (NSP/PFS0)"),
                    ("Title ID", tid or "-"),
                    ("Version", f"v{ver}" if ver not in ("", "-") else "-"),
                    ("Type", ctype),
                    ("Required System", _sysrow),
                    ("Contents", (", ".join(content_kinds) if content_kinds
                                   else f"{n_nca} NCA") or "-"),
                    ("Ticket/Cert", f"{'tik+' if has_tik else ''}{'cert' if has_cert else ''}".strip("+") or "-"),
                    ("Size", fmt_size(size)),
                    ("Entries", str(len(ents)))]
            title = fname_title or os.path.basename(path)
            meta = {"TitleId": tid, "Version": ver, "Kind": ctype,
                    "RequiredSystemVersion": sysver, "cnmt_file": cnmt.get("_file", ""),
                    "cnmt": cnmt, "nca_count": n_nca,
                    "has_ticket": has_tik, "has_cert": has_cert}
            if _cnmt_bin:
                meta["cnmt_bin"] = {"tid": _cnmt_bin.get("tid"),
                                    "ver": _cnmt_bin.get("ver"),
                                    "type": _cnmt_bin.get("type"),
                                    "contents": _cnmt_bin.get("contents")}
                if not meta["cnmt_file"]:
                    meta["cnmt_file"] = "(binary CNMT in Meta NCA)"
            icon_entry = ""
            # NACP official title + icon via Control NCA (needs prod.keys;
            # silent fallback to filename info when keys are absent).
            try:
                if _skeys is not None:
                    _ctrl = next((e for e in ents
                                  if str(e.get("codec") or "").split(" · ")[0] == "Control"
                                  and e["name"].lower().endswith(".nca")),
                                 None)
                    if _ctrl is None:
                        # header scan: 0xC00 XTS per NCA, cheap even on huge NSPs
                        # (CNMT record type bytes are not trusted for this)
                        for e in ents:
                            try:
                                if not e["name"].lower().endswith(".nca"):
                                    continue
                                _h = _switch_decrypt_nca_header(
                                    path, e["abs_off"], _skeys)
                            except Exception:
                                _h = None
                            if _h is not None and _h[0x205] == 2:
                                _ctrl = e
                                _switch_tag_control(e)
                                break
                    if _ctrl is not None:
                        _nacp = _switch_nca_control_info(
                            path, _ctrl["abs_off"], _tikb, _skeys)
                        if _nacp:
                            _titles = _nacp.get("titles") or {}
                            _official = (_titles.get("AmericanEnglish")
                                         or _titles.get("BritishEnglish")
                                         or next(iter(_titles.values()), ""))
                            if _official:
                                title = _official
                            _pubs = _nacp.get("publisher") or {}
                            _pub = (_pubs.get("AmericanEnglish")
                                    or _pubs.get("BritishEnglish")
                                    or next(iter(_pubs.values()), ""))
                            if _pub:
                                rows.insert(2, ("Publisher", _pub))
                            if _nacp.get("display_ver"):
                                rows.insert(3, ("Display Version",
                                               _nacp["display_ver"]))
                                # human version wins: Version = display
                                # (1.2.1), raw title version -> own row
                                try:
                                    _dv = str(_nacp["display_ver"]).strip()
                                    _dvv = _dv[1:] if _dv[:1].lower() == "v" else _dv
                                    for _vi, (_vk, _vv) in enumerate(rows):
                                        if _vk == "Version":
                                            rows[_vi] = ("Version", "v" + _dvv)
                                            try:
                                                _rawv = int(str(ver).strip())
                                                if _rawv:
                                                    rows.insert(_vi + 1, (
                                                        "Title Version",
                                                        "%d (%#x)" % (_rawv, _rawv)))
                                            except Exception:
                                                pass
                                            break
                                    ver = _dvv
                                except Exception:
                                    pass
                            meta["nacp_titles"] = _titles
                            meta["nacp_display_ver"] = _nacp.get("display_ver", "")
                            if _nacp.get("icon"):
                                _inm = "icon.jpg"
                                ents.append({"id": len(ents), "name": _inm,
                                             "size": len(_nacp["icon"]),
                                             "off": -2, "abs_off": -2,
                                             "cached": bytes(_nacp["icon"]),
                                             "codec": "JPEG"})
                                rows[-1] = ("Entries", str(len(ents)))
                                icon_entry = _inm
                else:
                    rows.append(("NACP Title/Icon",
                                 "needs prod.keys (PKGViewer folder)"))
            except Exception:
                pass
            return {"ok": True, "kind": "nsp", "path": path, "size": size,
                    "title": title, "rows": rows, "entries": ents,
                    "meta": meta, "icon_entry": icon_entry,
                    "patch_tid": tid, "own_ver": ver}
    except Exception as e:
        return {"error": f"NSP parse failed: {e}"}


def _parse_hfs0_at(f, hfs0_off, size, prefix=""):
    """HFS0 partition at hfs0_off -> entries [{name, size, abs_off}]. Minimal,
    validated; [] on any doubt. Never raises."""
    import struct as _st
    try:
        if hfs0_off < 0 or hfs0_off + 16 > size:
            return []
        f.seek(hfs0_off)
        hdr = f.read(16)
        if len(hdr) < 16 or hdr[:4] != HFS0_MAGIC:
            return []
        num, str_size, _rsv = _st.unpack_from("<III", hdr, 4)
        if not (0 <= num <= 100000) or str_size > 20_000_000:
            return []
        raw = f.read(num * 64)
        if len(raw) < num * 64:
            return []
        strtab = f.read(str_size)
        if len(strtab) < str_size:
            return []
        # string table is 00-padded to media-unit boundary; raw data follows
        data_start = hfs0_off + 16 + num * 64 + len(strtab)
        out = []
        for i in range(num):
            try:
                off, sz, name_off = _st.unpack_from("<QQI", raw, i * 64)
            except Exception:
                continue
            if name_off >= len(strtab):
                continue
            end = strtab.find(b"\x00", name_off)
            if end < 0:
                continue
            try:
                name = strtab[name_off:end].decode("utf-8", errors="replace")
            except Exception:
                continue
            if not name or off + sz > size:
                # keep listing even if slightly out of range? no — skip wild
                if off < 0 or off > size:
                    continue
            full = f"{prefix}/{name}" if prefix else name
            out.append({"_off": off, "_size": sz, "_name": name,
                        "_hfs0_data": data_start, "_full": full})
        # resolve absolute offsets
        res = []
        for j, e in enumerate(out):
            res.append({"id": j, "name": e["_full"], "size": e["_size"],
                        "off": e["_hfs0_data"] + e["_off"],
                        "abs_off": e["_hfs0_data"] + e["_off"]})
        return res
    except Exception:
        return []


def parse_xci(path):
    """Nintendo Switch XCI (gamecard): root HFS0 -> update/normal/secure/logo
    partitions, each an HFS0 file list. Bodies (NCA) stay encrypted.
    Never raises."""
    import struct as _st
    try:
        size = os.path.getsize(path)
    except OSError as e:
        return {"error": str(e)}
    try:
        with open(path, "rb") as f:
            f.seek(0)
            head = f.read(0x200)
            if len(head) < 0x200 or head[0x100:0x104] != XCI_MAGIC:
                return {"error": "not an XCI (missing HEAD magic at 0x100)"}
            try:
                hfs0_off, hfs0_size = _st.unpack_from("<QQ", head, 0x130)
            except Exception:
                hfs0_off, hfs0_size = 0, 0
            if not hfs0_off or hfs0_off + 16 > size:
                # some dumps place root HFS0 at fixed 0x10000
                hfs0_off = 0x10000 if size > 0x10010 else 0
            root = _parse_hfs0_at(f, hfs0_off, size)
            parts = [e["name"] for e in root] or []
            # root entries point to sub-partitions (raw blobs); parse each
            ents, data_bases = [], {}
            for r in root:
                try:
                    data_bases[r["name"]] = r["abs_off"]
                except Exception:
                    continue
            eid = 0
            for pname in ("update", "normal", "secure", "logo"):
                if pname not in data_bases:
                    continue
                sub = _parse_hfs0_at(f, data_bases[pname], size, prefix=pname)
                for s in sub:
                    s["id"] = eid
                    eid += 1
                    # tag NCAs like NSP
                    try:
                        if s["name"].lower().endswith(".nca"):
                            s["codec"] = "NCA"
                    except Exception:
                        pass
                    ents.append(s)
            if not ents:
                # header-only view (partitions unreadable): still show something
                fname_title, fname_tid, fname_ver = _switch_title_from_filename(path)
                rows = [("Platform", "Nintendo Switch (XCI/Gamecard)"),
                        ("Title ID", fname_tid or "-"),
                        ("Version", f"v{fname_ver}" if fname_ver else "-"),
                        ("Root partitions", ", ".join(parts) or "-"),
                        ("Size", fmt_size(size)),
                        ("Note", "partition data unreadable (encrypted/header-only)")]
                return {"ok": True, "kind": "xci", "path": path, "size": size,
                        "title": fname_title, "rows": rows, "entries": [],
                        "meta": {"partitions": parts}, "icon_entry": "",
                        "patch_tid": fname_tid, "own_ver": fname_ver}
            fname_title, fname_tid, fname_ver = _switch_title_from_filename(path)
            try:
                _ct = head[0x10D] if len(head) > 0x10D else 0
            except Exception:
                _ct = 0
            _cart = {0xFA: "1GB", 0xF8: "2GB", 0xF0: "4GB",
                     0xE0: "8GB", 0xE1: "16GB", 0xE2: "32GB"}.get(_ct, "")
            rows = [("Platform", "Nintendo Switch (XCI/Gamecard)"),
                    ("Title ID", fname_tid or "-"),
                    ("Version", f"v{fname_ver}" if fname_ver else "-")]
            if _cart:
                rows.append(("Cartridge", _cart))
            rows += [("Partitions", ", ".join(sorted(data_bases.keys())) or "-"),
                     ("Size", fmt_size(size)),
                     ("Entries", str(len(ents)))]
            title = fname_title or os.path.basename(path)
            meta = {"partitions": sorted(data_bases.keys())}
            if _cart:
                meta["cartridge"] = _cart
            icon_entry = ""
            # base-title metadata from secure/*.cnmt.nca (binary CNMT) +
            # official title/icon from the secure Control NCA (needs keys)
            try:
                _skeys = _find_switch_keys()
            except Exception:
                _skeys = None
            if _skeys is not None:
                try:
                    _secm = [e for e in ents
                             if e["name"].lower().startswith("secure/")
                             and e["name"].lower().endswith(".cnmt.nca")]
                    _base_bin = None
                    for _me in _secm[:1]:
                        try:
                            _base_bin = _switch_read_cnmt_bin(
                                path, _me["abs_off"], None, _skeys)
                        except Exception:
                            _base_bin = None
                        if _base_bin:
                            break
                    if _base_bin:
                        try:
                            rows[1] = ("Title ID",
                                       str(_base_bin.get("tid", "") or "").upper()
                                       or fname_tid or "-")
                            rows.insert(3, ("Type", _base_bin.get("type", "-")))
                            meta["cnmt_bin"] = {
                                "tid": _base_bin.get("tid"),
                                "ver": _base_bin.get("ver"),
                                "type": _base_bin.get("type")}
                        except Exception:
                            pass
                    # per-NCA facts for secure partition (few files, NCA
                    # headers are authoritative) + Control discovery
                    _ctrl = None
                    for e in ents:
                        try:
                            if not (e["name"].lower().startswith("secure/")
                                    and e["name"].lower().endswith(".nca")):
                                continue
                            _det = _switch_nca_detail(path, e["abs_off"], _skeys)
                            if _det is not None:
                                e["nca_detail"] = (
                                    "keygen %d, %s crypto" % (
                                        _det["crypto"],
                                        "titlekey" if _det["rights"] else "standard"))
                                _sfx = ("tk" if _det["rights"]
                                        else "k%d" % _det["crypto"])
                                _cur = e.get("codec") or ""
                                _tn = (_SWITCH_NCA_TYPES.get(_det["ctype"], "NCA")
                                       if _cur in ("", "NCA") else _cur)
                                if " · " not in str(e.get("codec") or ""):
                                    e["codec"] = "%s · %s" % (_tn, _sfx)
                                if _ctrl is None and _det["ctype"] == 2:
                                    _ctrl = e
                                    _switch_tag_control(e)
                        except Exception:
                            continue
                    if _ctrl is not None:
                        try:
                            _nacp = _switch_nca_control_info(
                                path, _ctrl["abs_off"], None, _skeys)
                        except Exception:
                            _nacp = None
                        if _nacp:
                            _titles = _nacp.get("titles") or {}
                            _official = (_titles.get("AmericanEnglish")
                                         or _titles.get("BritishEnglish")
                                         or next(iter(_titles.values()), ""))
                            if _official:
                                title = _official
                            _pubs = _nacp.get("publisher") or {}
                            _pub = (_pubs.get("AmericanEnglish")
                                    or _pubs.get("BritishEnglish")
                                    or next(iter(_pubs.values()), ""))
                            if _pub:
                                rows.insert(2, ("Publisher", _pub))
                            if _nacp.get("display_ver"):
                                try:
                                    _dv = str(_nacp["display_ver"]).strip()
                                    _dvv = (_dv[1:] if _dv[:1].lower() == "v"
                                             else _dv)
                                    for _vi, (_vk, _vv) in enumerate(rows):
                                        if _vk == "Version":
                                            rows[_vi] = ("Version", "v" + _dvv)
                                            if _base_bin and _base_bin.get("ver"):
                                                try:
                                                    _rv = int(str(_base_bin["ver"]).strip())
                                                    if _rv:
                                                        rows.insert(_vi + 1, (
                                                            "Title Version",
                                                            "%d (%#x)" % (_rv, _rv)))
                                                except Exception:
                                                    pass
                                            break
                                    rows.insert(3, ("Display Version", _dv))
                                except Exception:
                                    pass
                            meta["nacp_titles"] = _titles
                            meta["nacp_display_ver"] = _nacp.get("display_ver", "")
                            if _nacp.get("icon"):
                                _inm = "icon.jpg"
                                ents.append({"id": len(ents), "name": _inm,
                                             "size": len(_nacp["icon"]),
                                             "off": -2, "abs_off": -2,
                                             "cached": bytes(_nacp["icon"]),
                                             "codec": "JPEG"})
                                rows[-1] = ("Entries", str(len(ents)))
                                icon_entry = _inm
                except Exception:
                    pass
            return {"ok": True, "kind": "xci", "path": path, "size": size,
                    "title": title or os.path.basename(path),
                    "rows": rows, "entries": ents,
                    "meta": meta,
                    "icon_entry": icon_entry, "patch_tid": fname_tid,
                    "own_ver": fname_ver}
    except Exception as e:
        return {"error": f"XCI parse failed: {e}"}


def parse_pkg(path):
    if os.path.isdir(path):
        if _ps3_folder_base(path):
            return parse_ps3_folder(path)
        _gt, _gc = _god_layout(path)
        if _gc:
            return parse_god_folder(path)
        if _x360_folder_xex(path):
            return parse_x360_folder(path)
        if _wiiu_tmd_path(path):
            return parse_wiiu_folder(path)
        return parse_app_folder(path)
    size = os.path.getsize(path)
    low = path.lower()
    if low.endswith(".iso"):
        if _xdvdfs_is_xiso(path):
            return parse_x360_iso(path)
        return parse_disc_iso(path)
    if low.endswith(".nsp"):
        return parse_nsp(path)
    if low.endswith(".xci"):
        return parse_xci(path)
    if low.endswith(".ffpfsc"):
        return parse_ffpfsc_image(path)
    if low.endswith(".ffpkg"):
        return parse_ffpkg_image(path)
    with open(path, "rb") as f:
        magic = f.read(4)
        if magic == b"\x01CD0":
            return parse_disc_iso(path)
        if magic == b"XEX2":
            return parse_x360_xex_file(path, size)
        if magic in STFS_MAGIC:
            return parse_stfs_file(path, size)
        if magic == PFS0_MAGIC:
            return parse_nsp(path)
        f.seek(0x100)
        if f.read(4) == XCI_MAGIC:
            return parse_xci(path)
        if magic == PS3_MAGIC:
            return parse_ps3_pkg(path)
        if magic != FIH_MAGIC and magic != LIH_MAGIC \
                and magic != CNT_MAGIC:
            f.seek(0)
            if f.read(11)[3:11] == b"EXFAT   ":
                return parse_exfat_image(path)
        f.seek(0)
        if magic == FIH_MAGIC or magic == LIH_MAGIC:
            hdr = f.read(256)
            # FIH stores the CNT container offset at 0x58, LIH (backport
            # wrapper) at 0x30; both then parse as standard CNT.
            emb = u64le(hdr, 0x58 if magic == FIH_MAGIC else 0x30)
            signed = hdr[5]
            pfs_off = u64le(hdr, 0x10)
            pfs_size = u64le(hdr, 0x18)
            f.seek(emb)
            chdr = f.read(0x80)
            if chdr[:4] != CNT_MAGIC:
                if magic == LIH_MAGIC:
                    return {"error": "LIH container is not CNT"}
                return parse_ps5_retail_stub(path, size, hdr)
            n = u32be(chdr, 0x10)
            et = u32be(chdr, 0x18)
            cid = chdr[0x40:0x40 + 48].split(b"\x00")[0].decode("ascii", errors="replace")
            ents = parse_cnt_entries(f, emb, n, et)
            nt = read_name_table(f, emb, ents)
            for e in ents:
                e["name"] = entry_name(nt, e["name_off"]) if nt else ""
                e["abs_off"] = emb + e["off"]
            pj = next((e for e in ents if e["name"] == "param.json" or e["id"] == 8192), None)
            meta, title, extra = {}, "", []
            if pj and pj["size"] and pj["size"] < 100_000:
                f.seek(emb + pj["off"])
                try:
                    meta = json.loads(f.read(pj["size"]).decode("utf-8"))
                    title, extra = _param_json_meta(meta)
                except Exception as e:
                    meta = {"_error": str(e)}
            rows = [("Platform", "PS5 (finalized FIH)"),
                    ("Package", "OFC (Official)" if signed == 0x80 else "FPKG (Fake)"),
                    ("Signature", "official" if signed == 0x80 else "debug / fake"),
                    ("Size", fmt_size(size)),
                    ("PFS image", f"{fmt_size(pfs_size)} @ {pfs_off:#x}"),
                    ("Entries", str(len(ents)))]
            if magic == LIH_MAGIC:
                # LIH is a scene backport wrapper (no retail issuer):
                # label the container honestly, keep the CNT rows below.
                rows = [("Platform", "PS5 (LIH backport)"),
                        ("Package", "Backport (LIH)"),
                        ("Signature", "debug / fake"),
                        ("Size", fmt_size(size)),
                        ("Entries", str(len(ents)))]
            rows += extra
            if not any(k == "Content ID" for k, _ in rows):
                rows.insert(2, ("Content ID", cid))
            return {"ok": True, "kind": "ps5", "path": path, "size": size,
                    "title": title or os.path.basename(path),
                    "rows": rows, "entries": ents, "meta": meta, "icon_entry": "icon0.png",
                    "patch_tid": meta.get("titleId", "") if isinstance(meta, dict) else "",
                    "own_ver": meta.get("contentVersion", "") if isinstance(meta, dict) else ""}
        elif magic == CNT_MAGIC:
            hdr = f.read(0x500)
            n = u32be(hdr, 0x10)
            sc = struct.unpack_from(">H", hdr, 0x14)[0]
            et = u32be(hdr, 0x18)
            body_off = u64be(hdr, 0x20)
            cid = hdr[0x40:0x40 + 48].split(b"\x00")[0].decode("ascii", errors="replace")
            ents = parse_cnt_entries(f, 0, n, et)
            nt = read_name_table(f, 0, ents)
            for e in ents:
                e["name"] = entry_name(nt, e["name_off"]) if nt else ""
                e["abs_off"] = e["off"]
            sfo_entry = next((e for e in ents if e["id"] == 4096 or e["name"] == "param.sfo"), None)
            sfo = {}
            if sfo_entry and sfo_entry["size"]:
                f.seek(sfo_entry["off"])
                sfo = parse_sfo(f.read(sfo_entry["size"]))
            pj = next((e for e in ents if e["name"] == "param.json" or e["id"] == 8192), None)
            meta, title, extra = {}, "", []
            _ver4 = ""
            if sfo and not sfo.get("_error"):
                title = sfo.get("TITLE", "")
                _cid4 = sfo.get("CONTENT_ID", cid)
                _cat4 = sfo.get("CATEGORY", "")
                # update PKGs (gp): VERSION = base it applies to,
                # APP_VER = the actual patch version -> show APP_VER
                _ver4 = sfo.get("VERSION", "")
                if str(_cat4).lower() == "gp" and sfo.get("APP_VER"):
                    _ver4 = sfo.get("APP_VER")
                # languages: TITLE, TITLE_02..TITLE_29 (non-empty count)
                _langs = 0
                try:
                    for _k, _v in sfo.items():
                        if (_k == "TITLE" or _k.startswith("TITLE_")) and str(_v or "").strip():
                            _langs += 1
                except Exception:
                    pass
                # build date from PUBTOOLINFO c_date=YYYYMMDD
                _built = "-"
                try:
                    import re as _re
                    _m = _re.search(r"c_date=(\d{4})(\d{2})(\d{2})",
                                    str(sfo.get("PUBTOOLINFO", "")))
                    if _m:
                        _built = f"{_m.group(1)}-{_m.group(2)}-{_m.group(3)}"
                except Exception:
                    pass
                extra = [("Title ID",
                           sfo.get("TITLE_ID", "") or _tid_from_cid(_cid4)),
                         ("Content ID", _cid4),
                         ("Region", content_region(_cid4)),
                         ("Type", ps4_pkg_type(_cat4)),
                         ("Version", _ver4)]
                # patch PKGs: also show the base game version it applies to
                if str(_cat4).lower() == "gp" and sfo.get("VERSION"):
                    extra.append(("Base Version", sfo.get("VERSION", "")))
                extra += [("Min. System", fmt_fw32(sfo.get("SYSTEM_VER", "-")))]
                _sdk4 = ps4_sdk_version(sfo)
                if _sdk4:
                    extra.append(("SDK", _sdk4))
                extra += [("Languages", str(_langs) if _langs else "-"),
                          ("Built", _built)]
                # FPKG hint: which passcode full-extract needs
                try:
                    _pt = struct.unpack_from(">I", hdr, 0x04)[0]
                    if not (_pt & 0x80000000):
                        extra.append(("Passcode", "zeros (FPKG default)"))
                except Exception:
                    pass
            elif pj and pj["size"] and pj["size"] < 100_000:
                f.seek(pj["off"])
                try:
                    meta = json.loads(f.read(pj["size"]).decode("utf-8"))
                    title, extra = _param_json_meta(meta)
                except Exception as e:
                    meta = {"_error": str(e)}
            kind = "PS4" if sfo and not sfo.get("_error") else "CNT"
            rows = [("Platform", f"{kind} (CNT metadata)"),
                    ("Package", cnt_package_type(hdr)),
                    ("Size", fmt_size(size)),
                     ("Entries", f"{n} ({sc} sys)")]
            rows += extra
            if not any(k == "Content ID" for k, _ in rows):
                rows.insert(2, ("Content ID",
                                sfo.get("CONTENT_ID", cid) if sfo else cid))
            if not any(k == "Title ID" and str(v or "").strip() not in ("", "-")
                       for k, v in rows):
                # param.sfo unreadable (partial/corrupt download) or without
                # TITLE_ID: still show the ID from Content ID / file name so
                # the Title ID row never silently disappears.
                _ftid = _tid_from_cid(cid) or _tid_from_filename(path)
                if _ftid:
                    rows.insert(2, ("Title ID", _ftid))
            _ptch = (sfo.get("TITLE_ID", "") if isinstance(sfo, dict) else "") \
                or _tid_from_cid(cid) or _tid_from_filename(path)
            return {"ok": True, "kind": "ps4", "path": path, "size": size,
                    "title": title or os.path.basename(path),
                    "rows": rows, "entries": ents, "meta": meta or sfo,
                    "icon_entry": "icon0.png",
                    "patch_tid": _ptch,
                    "own_ver": _ver4 if sfo and not sfo.get("_error") else "",
                    "body_off": body_off}
        else:
            # split retail part without header? resolve via sibling _0.
            stub = _split_part_stub(path, size)
            if stub:
                return stub
            return {"error": f"unknown magic {magic!r}"}


# ---------------- PS3 NPDRM PKG (verified: Doodle God retail + 2 debug FIX) ----------------

def _ps3_debug_keystream(qa, block_index):
    import hashlib
    qa0, qa1 = qa[:8], qa[8:16]
    buf = bytearray(64)
    buf[0:8] = qa0
    buf[8:16] = qa0
    buf[16:24] = qa1
    buf[24:32] = qa1
    buf[56:64] = struct.pack(">Q", block_index)
    return hashlib.sha1(bytes(buf)).digest()[:16]


def _ps3_decrypt(f, data_off, retail, keymat, pos, size):
    """Decrypt a data-stream range (offsets relative to data_off). b"" on failure."""
    if size <= 0 or pos < 0:
        return b""
    bs = pos & ~0xF
    pre = pos - bs
    nb = (pre + size + 15) // 16
    if nb > 1 << 24:
        return b""
    f.seek(data_off + bs)
    enc = f.read(nb * 16)
    if len(enc) < nb * 16:
        return b""
    out = bytearray()
    if not retail:
        bi = bs // 16
        for i in range(nb):
            ks = _ps3_debug_keystream(keymat, bi + i)
            out += bytes(a ^ b for a, b in zip(enc[i * 16:(i + 1) * 16], ks))
    else:
        if not HAS_PS3_AES:
            return b""
        e = _Cipher(_Algos.AES(PS3_KEY), _Modes.ECB()).encryptor()
        ctr0 = (int.from_bytes(keymat, "big") + bs // 16) & ((1 << 128) - 1)
        for i in range(nb):
            ks = e.update(((ctr0 + i) & ((1 << 128) - 1)).to_bytes(16, "big"))
            out += bytes(a ^ b for a, b in zip(enc[i * 16:(i + 1) * 16], ks))
    return bytes(out[pre:pre + size])


PS3_TID_REGION = {"NPEB": "Europe", "BCES": "Europe", "BLES": "Europe",
                  "NPHB": "Asia", "BCAS": "Asia", "BLAS": "Asia",
                  "NPJB": "Japan", "BCJS": "Japan", "BLJS": "Japan",
                  "NPUB": "Americas", "BCUS": "Americas", "BLUS": "Americas"}


def _ps3_title_id_from_cid(cid):
    try:
        return cid.split("-")[1].split("_")[0]
    except Exception:
        return ""


def _ps3_folder_base(path):
    """Root of PS3 game data: dir itself (NPDRM extract) or PS3_GAME/ (disc extract). '' = not PS3."""
    if os.path.isfile(os.path.join(path, "PS3_GAME", "PARAM.SFO")):
        return os.path.join(path, "PS3_GAME")
    if os.path.isfile(os.path.join(path, "PARAM.SFO")) and any(
            os.path.exists(os.path.join(path, d)) for d in
            ("USRDIR", "TROPDIR", "PS3_GAME", "PS3_UPDATE")):
        return path
    return ""


def parse_ps3_folder(path):
    base = _ps3_folder_base(path)
    sfo = {}
    try:
        with open(os.path.join(base, "PARAM.SFO"), "rb") as fh:
            raw = fh.read(1_000_000)
        if raw[:4] == b"\x00PSF":
            sfo = parse_sfo(raw)
    except OSError:
        pass
    total, nfiles = 0, 0
    for _dp, _dn, fns in os.walk(path):
        nfiles += len(fns)
        for fn in fns:
            try:
                total += os.path.getsize(os.path.join(_dp, fn))
            except OSError:
                pass
    title = sfo.get("TITLE", "") if sfo else ""
    tid = (sfo.get("TITLE_ID", "") if sfo else "") or os.path.basename(path.rstrip("/\\"))
    ver = sfo.get("VERSION", "") or sfo.get("APP_VER", "") if sfo else ""
    rows = [("Platform", "PS3 folder"),
            ("Title ID", sfo.get("TITLE_ID", "-") if sfo else "-"),
            ("Region", PS3_TID_REGION.get(
                ((sfo.get("TITLE_ID", "") if sfo else "") or "")[:4].upper(), "-")),
            ("Version", ver or "-"),
            ("Min. System", fmt_fw32(sfo.get("PS3_SYSTEM_VER", "-")) if sfo else "-"),
            ("Size", f"{fmt_size(total)} ({nfiles} files)")]
    ents, _eid = [], 0
    try:
        for fn in sorted(os.listdir(base)):
            if not fn.lower().endswith(".png"):
                continue
            fp = os.path.join(base, fn)
            if not os.path.isfile(fp):
                continue
            try:
                sz = os.path.getsize(fp)
            except OSError:
                continue
            if sz <= 0:
                continue
            ents.append({"id": _eid, "name": fn, "size": sz,
                         "abs_off": -1, "local_path": fp})
            _eid += 1
    except OSError:
        pass
    # PS3 trophy packs (TROPDIR/NPWRxxxxx_00/TROPHY.TRP) for the Trophies tab
    try:
        _tropdir = os.path.join(base, "TROPDIR")
        if os.path.isdir(_tropdir):
            for _np in sorted(os.listdir(_tropdir)):
                _npd = os.path.join(_tropdir, _np)
                if not os.path.isdir(_npd):
                    continue
                for _fn in sorted(os.listdir(_npd)):
                    if not _fn.lower().endswith(".trp"):
                        continue
                    _fp = os.path.join(_npd, _fn)
                    if not os.path.isfile(_fp):
                        continue
                    try:
                        _sz = os.path.getsize(_fp)
                    except OSError:
                        continue
                    if _sz <= 0 or _sz >= 300_000_000:
                        continue
                    ents.append({"id": _eid, "name": f"TROPDIR/{_np}/{_fn}",
                                 "size": _sz, "abs_off": -1,
                                 "local_path": _fp})
                    _eid += 1
    except OSError:
        pass
    icon = next((e["name"] for e in ents if e["name"].upper() == "ICON0.PNG"), "")
    return {"ok": True, "kind": "ps3", "path": path, "size": total,
            "title": title or tid,
            "rows": rows, "entries": ents, "meta": sfo,
            "icon_entry": icon or "icon0.png"}


ISO_SECTOR = 2048


def _iso_clean_name(raw):
    """ISO9660 file/dir identifier -> display name ('PARAM.SFO;1' -> 'PARAM.SFO')."""
    try:
        s = bytes(raw).decode("utf-8", errors="replace")
    except Exception:
        return ""
    s = s.split(";")[0]
    if s.endswith("."):
        s = s[:-1]
    return s.strip()


def parse_ps3_iso(path):
    """PS3 disc ISO (ISO9660, 2048-byte sectors): file list + PARAM.SFO meta.

    Walks the Primary Volume Descriptor + directory records directly, so no
    mount or extra dependency is needed. Files are contiguous extents, so
    entries use plain abs_off offsets and stream-extract like other kinds.
    Returns {"error": ...} when the image is not a PS3 disc. Never raises.
    """
    import struct as _st
    try:
        size = os.path.getsize(path)
    except OSError as e:
        return {"error": str(e)}
    if size < 17 * ISO_SECTOR:
        return {"error": "too small for ISO"}
    try:
        with open(path, "rb") as f:
            f.seek(16 * ISO_SECTOR)
            pvd = f.read(ISO_SECTOR)
            if len(pvd) < ISO_SECTOR or pvd[0] != 1 or pvd[1:6] != b"CD001":
                return {"error": "not an ISO9660 image"}
            try:
                vol = pvd[40:72].decode("ascii", errors="replace").strip()
            except Exception:
                vol = ""
            if len(pvd) < 190 or pvd[156] < 34:
                return {"error": "bad ISO root record"}
            root_ext = _st.unpack_from("<I", pvd, 156 + 2)[0]
            root_size = _st.unpack_from("<I", pvd, 156 + 10)[0]
            if not root_ext or not root_size or root_size > 64 << 20:
                return {"error": "bad ISO root directory"}
            ents = []
            seen_dirs = set()

            def _walk(ext, sz, prefix, depth):
                if depth > 16 or not ext or not sz or sz > 64 << 20:
                    return
                key = (ext, prefix)
                if key in seen_dirs:
                    return
                seen_dirs.add(key)
                try:
                    f.seek(ext * ISO_SECTOR)
                    data = f.read(sz)
                except OSError:
                    return
                if len(data) < sz:
                    return
                off = 0
                while off < len(data):
                    if data[off] == 0:
                        nxt = ((off // ISO_SECTOR) + 1) * ISO_SECTOR
                        if nxt >= len(data):
                            break
                        off = nxt
                        continue
                    ll = data[off]
                    if ll < 33 or off + ll > len(data):
                        break
                    rec = data[off:off + ll]
                    try:
                        flags = rec[25]
                        rex = _st.unpack_from("<I", rec, 2)[0]
                        rsz = _st.unpack_from("<I", rec, 10)[0]
                        nlen = rec[32]
                        nm_raw = rec[33:33 + nlen]
                    except Exception:
                        break
                    off += ll
                    if nm_raw in (b"\x00", b"\x01"):
                        continue
                    nm = _iso_clean_name(nm_raw)
                    if not nm:
                        continue
                    full = nm if not prefix else prefix + "/" + nm
                    if flags & 0x02:
                        _walk(rex, rsz, full, depth + 1)
                    else:
                        if len(ents) >= 200000:
                            return
                        ents.append({"id": len(ents), "name": full,
                                     "size": rsz,
                                     "abs_off": rex * ISO_SECTOR})
            _walk(root_ext, root_size, "", 0)
            if not ents:
                return {"error": "empty ISO"}
            ups = {e["name"].upper() for e in ents}
            if "PS3_GAME/PARAM.SFO" not in ups \
                    and "PS3_DISC.SFB" not in ups \
                    and "PS3_GAME" not in ups:
                return {"error": "not a PS3 disc ISO"}
            sfo = {}
            for e in ents:
                if e["name"].upper() == "PS3_GAME/PARAM.SFO" \
                        and 0 < e["size"] < 1_000_000:
                    try:
                        f.seek(e["abs_off"])
                        raw = f.read(e["size"])
                    except OSError:
                        break
                    if raw[:4] == b"\x00PSF":
                        sfo = parse_sfo(raw)
                    break
    except Exception as e:
        return {"error": str(e)}
    title = sfo.get("TITLE", "") if sfo else ""
    tid = (sfo.get("TITLE_ID", "") if sfo else "") or vol \
        or os.path.splitext(os.path.basename(path))[0]
    ver = (sfo.get("VERSION", "") or sfo.get("APP_VER", "")) if sfo else ""
    _cat = (sfo.get("CATEGORY", "") if sfo else "") or ""
    _cat_lab = {"DG": "Disc Game", "HG": "HDD Game"}.get(_cat.strip().upper())
    _upd = next((e for e in ents
                 if e["name"].upper().startswith("PS3_UPDATE/") and e["size"] > 0),
                None)
    rows = [("Platform", "PS3 ISO (disc)"),
            ("Title ID", sfo.get("TITLE_ID", "-") if sfo else "-"),
            ("Region", PS3_TID_REGION.get(
                ((sfo.get("TITLE_ID", "") if sfo else "") or "")[:4].upper(), "-")),
            ("Category", f"{_cat_lab} ({_cat.strip()})" if _cat_lab
             else (_cat.strip() or "-")),
            ("Version", ver or "-"),
            ("App Ver", sfo.get("APP_VER", "-") if sfo else "-"),
            ("Min. System", fmt_fw32(sfo.get("PS3_SYSTEM_VER", "-")) if sfo else "-"),
            ("Parental Level", str(sfo.get("PARENTAL_LEVEL", "-")) if sfo else "-"),
            ("Resolution", str(sfo.get("RESOLUTION", "-")) if sfo else "-"),
            ("Sound Format", str(sfo.get("SOUND_FORMAT", "-")) if sfo else "-"),
            ("Trophy ID", sfo.get("NP_COMMUNICATION_ID", "-") if sfo else "-"),
            ("Update", f"{os.path.basename(_upd['name'])} "
             f"({fmt_size(_upd['size'])})" if _upd else "-"),
            ("Volume", vol or "-"),
            ("Size", f"{fmt_size(size)} ({len(ents)} files)")]
    icon = next((e["name"] for e in ents
                 if e["name"].upper() == "PS3_GAME/ICON0.PNG"), "")
    return {"ok": True, "kind": "ps3", "path": path, "size": size,
            "title": title or tid,
            "rows": rows, "entries": ents, "meta": sfo,
            "icon_entry": icon or "icon0.png"}


PS2_SERIAL_REGION = {"U": "Americas", "E": "Europe", "J": "Japan",
                     "P": "Japan", "A": "Asia", "H": "Asia",
                     "K": "Korea", "C": "China"}


def _ps2_normalize_serial(raw):
    """'SCUS_973.99' -> 'SCUS-97399'. '' when unparseable. Never raises."""
    try:
        import re as _re
        m = _re.search(r"([A-Za-z]{4})[_-]?(\d{3})[._]?(\d{2})",
                       str(raw or ""))
        if not m:
            return ""
        return (m.group(1).upper() + "-" + m.group(2) + m.group(3))
    except Exception:
        return ""


def _ps2_region(serial, vmode=""):
    """Serial 3rd-letter map (SCUS->Americas, SLES->Europe, SLPS->Japan...).

    Falls back to VMODE (PAL->Europe) when the serial is unknown.
    """
    try:
        s = str(serial or "").strip().upper()
        if len(s) >= 3:
            hit = PS2_SERIAL_REGION.get(s[2])
            if hit:
                return hit
        v = str(vmode or "").strip().upper()
        if "PAL" in v:
            return "Europe"
        if "NTSC" in v:
            return "Americas / Japan (NTSC)"
    except Exception:
        pass
    return "-"


def _ps2_title_from_filename(path, vol=""):
    """PS2 discs embed no title: derive it from the file name.

    'SCUS-97399 God of War.iso' -> 'God of War'. Falls back to the
    ISO volume label, then the bare stem. Never raises.
    """
    try:
        import re as _re
        stem = os.path.splitext(os.path.basename(path or ""))[0].strip()
        t = _re.sub(r"^[A-Za-z]{4}[-_ ]?\d{3}[._]?\d{2}\s*[-_.\s]*",
                    "", stem).strip(" -_.")
        if t:
            return t
        if vol:
            return vol
        return stem
    except Exception:
        return vol or ""


def parse_ps2_iso(path):
    """PS2 disc ISO (ISO9660, 2048-byte sectors): file list + SYSTEM.CNF meta.

    Same sector-walk as parse_ps3_iso, no mount needed. Detects via
    SYSTEM.CNF with a cdrom0:\\ BOOT2 executable entry. Title comes
    from the file name (discs embed none). Never raises.
    """
    import struct as _st
    try:
        size = os.path.getsize(path)
    except OSError as e:
        return {"error": str(e)}
    if size < 17 * ISO_SECTOR:
        return {"error": "too small for ISO"}
    try:
        with open(path, "rb") as f:
            f.seek(16 * ISO_SECTOR)
            pvd = f.read(ISO_SECTOR)
            if len(pvd) < ISO_SECTOR or pvd[0] != 1 or pvd[1:6] != b"CD001":
                return {"error": "not an ISO9660 image"}
            try:
                vol = pvd[40:72].decode("ascii", errors="replace").strip()
            except Exception:
                vol = ""
            if len(pvd) < 190 or pvd[156] < 34:
                return {"error": "bad ISO root record"}
            root_ext = _st.unpack_from("<I", pvd, 156 + 2)[0]
            root_size = _st.unpack_from("<I", pvd, 156 + 10)[0]
            if not root_ext or not root_size or root_size > 64 << 20:
                return {"error": "bad ISO root directory"}
            ents = []
            seen_dirs = set()

            def _walk(ext, sz, prefix, depth):
                if depth > 16 or not ext or not sz or sz > 64 << 20:
                    return
                key = (ext, prefix)
                if key in seen_dirs:
                    return
                seen_dirs.add(key)
                try:
                    f.seek(ext * ISO_SECTOR)
                    data = f.read(sz)
                except OSError:
                    return
                if len(data) < sz:
                    return
                off = 0
                while off < len(data):
                    if data[off] == 0:
                        nxt = ((off // ISO_SECTOR) + 1) * ISO_SECTOR
                        if nxt >= len(data):
                            break
                        off = nxt
                        continue
                    ll = data[off]
                    if ll < 33 or off + ll > len(data):
                        break
                    rec = data[off:off + ll]
                    try:
                        flags = rec[25]
                        rex = _st.unpack_from("<I", rec, 2)[0]
                        rsz = _st.unpack_from("<I", rec, 10)[0]
                        nlen = rec[32]
                        nm_raw = rec[33:33 + nlen]
                    except Exception:
                        break
                    off += ll
                    if nm_raw in (b"\x00", b"\x01"):
                        continue
                    nm = _iso_clean_name(nm_raw)
                    if not nm:
                        continue
                    full = nm if not prefix else prefix + "/" + nm
                    if flags & 0x02:
                        _walk(rex, rsz, full, depth + 1)
                    else:
                        if len(ents) >= 200000:
                            return
                        ents.append({"id": len(ents), "name": full,
                                     "size": rsz,
                                     "abs_off": rex * ISO_SECTOR})
            _walk(root_ext, root_size, "", 0)
            if not ents:
                return {"error": "empty ISO"}
            ups = {e["name"].upper() for e in ents}
            if "SYSTEM.CNF" not in ups:
                return {"error": "not a PS2 disc ISO"}
            cnf = {}
            for e in ents:
                if e["name"].upper() == "SYSTEM.CNF" \
                        and 0 < e["size"] < 100_000:
                    try:
                        f.seek(e["abs_off"])
                        raw = f.read(e["size"])
                    except OSError:
                        break
                    try:
                        txt = raw.decode("utf-8", errors="replace")
                    except Exception:
                        txt = ""
                    for line in txt.replace("\r", "\n").split("\n"):
                        line = line.strip()
                        if not line or "=" not in line:
                            continue
                        k, _, v = line.partition("=")
                        cnf[k.strip().upper()] = v.strip()
                    break
            boot = str(cnf.get("BOOT2", "") or "").strip()
            if not boot.lower().startswith("cdrom0:"):
                return {"error": "not a PS2 disc ISO"}
    except Exception as e:
        return {"error": str(e)}
    serial = _ps2_normalize_serial(boot)
    if not serial:
        serial = _ps2_normalize_serial(os.path.basename(path))
    ver = str(cnf.get("VER", "") or "").strip() or "-"
    vmode = str(cnf.get("VMODE", "") or "").strip() or "-"
    boot_disp = boot.replace("cdrom0:\\", "").replace("cdrom0:",
                                                      "").split(";")[0]
    title = _ps2_title_from_filename(path, vol)
    tid = serial or os.path.splitext(os.path.basename(path))[0]
    rows = [("Platform", "PS2 ISO (disc)"),
            ("Title ID", serial or "-"),
            ("Region", _ps2_region(serial, vmode)),
            ("Version", ("v" + ver) if ver not in ("", "-") else "-"),
            ("VMODE", vmode),
            ("Boot", boot_disp or "-"),
            ("Volume", vol or "-"),
            ("Size", f"{fmt_size(size)} ({len(ents)} files)")]
    return {"ok": True, "kind": "ps2", "path": path, "size": size,
            "title": title or tid,
            "rows": rows, "entries": ents, "meta": cnf,
            "icon_entry": "", "ps2_serial": serial}


def parse_disc_iso(path):
    """PS3 disc ISO first, PS2 disc ISO second. Returns {"error": ...} if neither."""
    r = parse_ps3_iso(path)
    if r.get("ok"):
        return r
    r2 = parse_ps2_iso(path)
    if r2.get("ok"):
        return r2
    # report the more specific error (PS2 check ran last, PS3 first)
    if "not a PS" in str(r.get("error", "")) and "not a PS" in str(r2.get("error", "")):
        return {"error": "not a PS2/PS3 disc ISO"}
    return r2 if r2.get("error") != "not a PS2 disc ISO" else r


# ---------------- Xbox 360 STFS / GOD (verified: Forza Horizon 2 GOD) ----------------
# STFS header is plaintext: magic "CON "/"LIVE"/"PIRS" at 0x0, content
# type BE-u32 at 0x344, Media ID at 0x354, Title ID at 0x360,
# UTF-16BE display name at 0x411, 64x64 PNG thumbnail at 0x171A
# (exact length via PNG chunk walk to IEND). GOD data lives in
# <hash>.data/DataNNNN parts next to the header file.

STFS_MAGIC = (b"CON ", b"LIVE", b"PIRS")

STFS_CONTENT_TYPES = {0x1: "Saved Game", 0x2: "Marketplace",
                      0x3: "Publisher", 0x1000: "Xbox 360 Title",
                      0x7000: "Games on Demand"}


def _stfs_thumb(raw, maxlen=5_000_000):
    """PNG bytes at 0x171A (chunk-walked to IEND), or b"". Never raises."""
    try:
        import struct as _st
        if len(raw) < 0x171A + 8 or raw[0x171A:0x171A + 8] != \
                b"\x89PNG\r\n\x1a\n":
            return b""
        off = 0x171A + 8
        while off + 8 <= len(raw) and off - 0x171A < maxlen:
            ln = _st.unpack_from(">I", raw, off)[0]
            if ln > 10 << 20:
                return b""
            typ = raw[off + 4:off + 8]
            off += 12 + ln
            if typ == b"IEND":
                return raw[0x171A:off]
        return b""
    except Exception:
        return b""


def parse_stfs_header(path):
    """STFS fields from a header/package file. {"error":...} if not STFS."""
    import struct as _st
    try:
        with open(path, "rb") as f:
            raw = f.read(0x20000)
    except OSError as e:
        return {"error": str(e)}
    if len(raw) < 0x1800 or raw[:4] not in STFS_MAGIC:
        return {"error": "not an STFS package"}
    try:
        ctype = _st.unpack_from(">I", raw, 0x344)[0]
        media = _st.unpack_from(">I", raw, 0x354)[0]
        tid = _st.unpack_from(">I", raw, 0x360)[0]
    except Exception as e:
        return {"error": str(e)}
    name = ""
    try:
        name = raw[0x411:0x411 + 256].decode(
            "utf-16-be", errors="replace").split(chr(0))[0].strip()
    except Exception:
        pass
    return {"magic": raw[:4].decode("ascii", errors="replace").strip(),
            "content_type": ctype,
            "media_id": "%08X" % media, "title_id": "%08X" % tid,
            "name": name, "thumb": _stfs_thumb(raw)}


def _god_layout(path):
    """(tid_dir, ctype_dir) for a GOD tree, or ("",""). Never raises.

    Accepts the game root ("Forza 2"), the Title-ID dir ("4D530AA4")
    or the content-type dir ("00007000") itself.
    """
    import re as _re
    try:
        if not os.path.isdir(path):
            return "", ""
        if os.path.basename(path) == "00007000" and \
                os.path.isdir(os.path.join(path, "..")):
            return os.path.dirname(path), path
        c = os.path.join(path, "00007000")
        if os.path.isdir(c):
            return path, c
        try:
            subs = sorted(os.listdir(path))
        except OSError:
            return "", ""
        for s in subs:
            if not _re.match(r"^[0-9A-Fa-f]{8}$", s):
                continue
            t = os.path.join(path, s)
            c = os.path.join(t, "00007000")
            if os.path.isdir(c):
                return t, c
        return "", ""
    except Exception:
        return "", ""


def parse_god_folder(path):
    """Xbox 360 GOD folder (TitleID/00007000/header + .data parts)."""
    import re as _re
    tid_dir, cdir = _god_layout(path)
    if not cdir:
        return {"error": "not a GOD folder"}
    hdr_path, hdr = "", None
    try:
        for fn in sorted(os.listdir(cdir)):
            fp = os.path.join(cdir, fn)
            if not os.path.isfile(fp):
                continue
            if fn.lower().endswith(".data"):
                continue
            h = parse_stfs_header(fp)
            if not h.get("error"):
                hdr_path, hdr = fp, h
                break
    except OSError as e:
        return {"error": str(e)}
    if not hdr:
        return {"error": "no STFS header in GOD folder"}
    try:
        folder_tid = os.path.basename(tid_dir).upper()
        if not _re.match(r"^[0-9A-F]{8}$", folder_tid):
            folder_tid = ""
    except Exception:
        folder_tid = ""
    tid = hdr["title_id"] or folder_tid
    data_dir = hdr_path + ".data"
    ents, total, nparts = [], 0, 0
    try:
        if os.path.isdir(data_dir):
            for fn in sorted(os.listdir(data_dir)):
                fp = os.path.join(data_dir, fn)
                if not os.path.isfile(fp):
                    continue
                try:
                    sz = os.path.getsize(fp)
                except OSError:
                    continue
                if sz <= 0:
                    continue
                ents.append({"id": len(ents), "name": "data/" + fn,
                             "size": sz, "abs_off": -1,
                             "local_path": fp})
                total += sz
                nparts += 1
    except OSError:
        pass
    try:
        hsz = os.path.getsize(hdr_path)
    except OSError:
        hsz = 0
    title = hdr["name"] or os.path.basename(
        os.path.dirname(tid_dir.rstrip("/\\"))).strip() or tid
    ctype = STFS_CONTENT_TYPES.get(hdr["content_type"],
                                   "type %#x" % hdr["content_type"])
    rows = [("Platform", "Xbox 360 GOD"),
            ("Title ID", tid or "-"),
            ("Media ID", hdr["media_id"]),
            ("Content", "%s (%s)" % (ctype, hdr["magic"])),
            ("Parts", str(nparts) if nparts else "-"),
            ("Size", "%s (%d data parts)" % (fmt_size(total + hsz), nparts)
             if nparts else fmt_size(hsz))]
    meta = {"magic": hdr["magic"], "content_type": hdr["content_type"],
            "title_id": tid, "media_id": hdr["media_id"],
            "name": hdr["name"]}
    icon = ""
    if hdr["thumb"]:
        ents.insert(0, {"id": 0, "name": "thumbnail.png",
                        "size": len(hdr["thumb"]), "off": -2,
                        "abs_off": -2, "cached": bytes(hdr["thumb"]),
                        "codec": "PNG"})
        for i, e in enumerate(ents):
            e["id"] = i
        icon = "thumbnail.png"
    return {"ok": True, "kind": "x360", "path": path,
            "size": total + hsz, "title": title or tid,
            "rows": rows, "entries": ents, "meta": meta,
            "icon_entry": icon, "x360_tid": tid}


def parse_stfs_file(path, size=0):
    """Standalone STFS package file (GOD header, LIVE/PIRS arcade...)."""
    hdr = parse_stfs_header(path)
    if hdr.get("error"):
        return hdr
    try:
        size = size or os.path.getsize(path)
    except OSError:
        size = 0
    tid = hdr["title_id"]
    title = hdr["name"] or os.path.splitext(
        os.path.basename(path))[0] or tid
    ctype = STFS_CONTENT_TYPES.get(hdr["content_type"],
                                   "type %#x" % hdr["content_type"])
    rows = [("Platform", "Xbox 360 STFS"),
            ("Title ID", tid or "-"),
            ("Media ID", hdr["media_id"]),
            ("Content", "%s (%s)" % (ctype, hdr["magic"])),
            ("Size", fmt_size(size))]
    ents, icon = [], ""
    if hdr["thumb"]:
        ents.append({"id": 0, "name": "thumbnail.png",
                     "size": len(hdr["thumb"]), "off": -2,
                     "abs_off": -2, "cached": bytes(hdr["thumb"]),
                     "codec": "PNG"})
        icon = "thumbnail.png"
    return {"ok": True, "kind": "x360", "path": path, "size": size,
            "title": title or tid, "rows": rows, "entries": ents,
            "meta": {"magic": hdr["magic"],
                     "content_type": hdr["content_type"],
                     "title_id": tid, "media_id": hdr["media_id"],
                     "name": hdr["name"]},
            "icon_entry": icon, "x360_tid": tid}


# ---------------- Xbox 360 ISO (XDVDFS) + extracted (JTAG rip) ----------------
# XDVDFS volume descriptor lives in sector 32 ("MICROSOFT*XBOX*MEDIA",
# root table sector/size at +0x14/+0x18 LE). Directory tables are
# binary trees of (left.u16, right.u16, sector.u32, size.u32,
# attr.u8, namelen.u8, name); attr 0x10 = dir, 0xFFFF = no child.
# Title/Media IDs come from default.xex (XEX2 header 0x40006).

XDVDFS_MAGIC = b"MICROSOFT*XBOX*MEDIA"


def _xex_exec_info(get_bytes):
    """(media, tid, ver, base, disc_num, disc_in) hex/ints from default.xex.

    get_bytes(off, size) -> bytes. Only the header is touched
    (plaintext). ""/0 on failure. Never raises.
    """
    try:
        import struct as _st
        head = get_bytes(0, 0x20)
        if len(head) < 0x18 or head[:4] != b"XEX2":
            return "", "", 0, 0, 0, 0
        n = _st.unpack_from(">I", head, 0x14)[0]
        if n <= 0 or n > 256:
            return "", "", 0, 0, 0, 0
        tab = get_bytes(0x18, n * 8)
        if len(tab) < n * 8:
            return "", "", 0, 0, 0, 0
        for i in range(n):
            hid, hoff = _st.unpack_from(">II", tab, i * 8)
            if hid == 0x40006:
                ex = get_bytes(hoff, 20)
                if len(ex) < 16:
                    return "", "", 0, 0, 0, 0
                media, ver, base, tid = _st.unpack(">IIII", ex[:16])
                dn = ex[18] if len(ex) > 18 else 0
                di = ex[19] if len(ex) > 19 else 0
                return ("%08X" % media, "%08X" % tid, ver, base,
                        dn, di)
        return "", "", 0, 0, 0, 0
    except Exception:
        return "", "", 0, 0, 0, 0


def _x360_tu_present_folder(path):
    """'tu00000001_00000000' style name under $TitleUpdate, or ''. """
    try:
        tu = os.path.join(path, "$TitleUpdate")
        if not os.path.isdir(tu):
            return ""
        for tid_dir in sorted(os.listdir(tu)):
            td = os.path.join(tu, tid_dir)
            if not os.path.isdir(td):
                continue
            for fn in sorted(os.listdir(td)):
                if fn.lower().startswith("tu") and os.path.isfile(
                        os.path.join(td, fn)):
                    return fn
        return ""
    except Exception:
        return ""


_X360_TU_MEM = {}


def fetch_x360_latest_tu(tid, media=""):
    """(latest_ver, count) of Title Updates from XboxUnity. ("",0) on failure."""
    try:
        t = str(tid or "").strip().upper()
        m = str(media or "").strip().upper()
    except Exception:
        return "", 0
    key = (t, m)
    if key in _X360_TU_MEM:
        return _X360_TU_MEM[key]
    import re as _re
    if not _re.match(r"^[0-9A-F]{8}$", t):
        _X360_TU_MEM[key] = ("", 0)
        return "", 0
    if not _proxy_url() and not _host_up("xboxunity.net"):
        return "", 0
    try:
        import json as _json
        raw = _http_get(XBOXUNITY_BASE + "/TitleUpdateInfo.php?titleid=" + t,
                        tries=2, headers={
                            "X-Requested-With": "XMLHttpRequest",
                            "Referer": "https://xboxunity.net/"})
        data = _json.loads(raw.decode("utf-8", "replace"))
        best, count = "", 0
        if isinstance(data, dict):
            for grp in data.get("MediaIDS") or []:
                ups = grp.get("Updates") or []
                count += len(ups)
                if m and str(grp.get("MediaID", "")).upper() != m:
                    continue
                for u in ups:
                    v = str(u.get("Version", "") or "")
                    if v and (not best or int(v) > int(best or 0)):
                        best = v
            if not best:
                # media mismatch: fall back to newest across all media
                for grp in data.get("MediaIDS") or []:
                    for u in grp.get("Updates") or []:
                        v = str(u.get("Version", "") or "")
                        if v and (not best or int(v) > int(best or 0)):
                            best = v
        _X360_TU_MEM[key] = (best, count)
        return best, count
    except Exception:
        try:
            _X360_TU_MEM[key] = ("", 0)
        except Exception:
            pass
        return "", 0


def _x360_clean_title(path):
    """'Minecraft (RF) (JTAGRip).iso' -> 'Minecraft'. Never raises."""
    try:
        import re as _re
        stem = os.path.splitext(os.path.basename(path or ""))[0]
        stem = _re.sub(r"\[[^\]]*\]", " ", stem)
        stem = _re.sub(r"\([^)]*\)", " ", stem)
        stem = _re.sub(r"\s+", " ", stem).strip(" -_.")
        return stem or os.path.splitext(
            os.path.basename(path or ""))[0]
    except Exception:
        return os.path.basename(path or "")


def _x360_region_from_name(path):
    """Region from filename tags: (RF)/(PAL)/(NTSC-U)... ''. Never raises."""
    try:
        import re as _re
        up = str(path or "").upper()
        if "REGION FREE" in up or "(RF)" in up or "[RF]" in up:
            return "Region Free"
        m = _re.search(r"\((NTSC(?:-[UJ])?|PAL|J|U|E|JPN|USA|EUR)\)", up)
        if m:
            return {"NTSC-U": "Americas", "NTSC-J": "Japan",
                    "NTSC": "Americas / Japan (NTSC)", "PAL": "Europe",
                    "U": "Americas", "USA": "Americas", "J": "Japan",
                    "JPN": "Japan", "E": "Europe",
                    "EUR": "Europe"}.get(m.group(1), "")
        return ""
    except Exception:
        return ""


def _xdvdfs_parse_node(data, off, img_size):
    """One GDF dirent at off -> dict or None. Strict validation.

    Real-world tables (JTAG tools) often carry garbage left/right
    pointers, so every field is sanity-checked and callers never
    trust pointers blindly. Never raises.
    """
    import struct as _st
    try:
        if off < 0 or off + 14 > len(data):
            return None
        left, right = _st.unpack_from("<HH", data, off)
        fsec, fsz = _st.unpack_from("<II", data, off + 4)
        attr, nlen = data[off + 12], data[off + 13]
        if nlen == 0 or nlen > 255 or off + 14 + nlen > len(data):
            return None
        if attr not in (0x10, 0x20, 0x80, 0xA0, 0x21, 0x11):
            if not (attr & 0x10 or attr & 0x20 or attr == 0x80):
                return None
        try:
            name = bytes(data[off + 14:off + 14 + nlen]).decode(
                "utf-8", errors="strict").strip()
        except Exception:
            return None
        if not name or any(ord(c) < 32 or ord(c) == 127 for c in name):
            return None
        if fsec == 0 and fsz == 0:
            return None
        if fsec * 2048 >= img_size and fsz:
            return None
        if fsz > img_size:
            return None
        return {"off": off, "left": left, "right": right,
                "sec": fsec, "size": fsz, "dir": bool(attr & 0x10),
                "name": name,
                "span": (off, off + ((14 + nlen + 3) // 4) * 4)}
    except Exception:
        return None


def _x360_ver_disc_rows(ver, base, dn, di):
    """Version + multidisc rows from XEX execution info. Never raises."""
    rows = []
    try:
        if ver:
            rows.append(("Version", "v%d" % ver if not base or base == ver
                         else "v%d (base v%d)" % (ver, base)))
        if di and int(di) > 1:
            rows.append(("Disc", "%d/%d" % (dn, di)))
    except Exception:
        pass
    return rows


def _xdvdfs_walk_table(f, sector, size, prefix, ents, depth=0):
    """Collect (name, sector, size, is_dir) records of one directory.

    Tree pointers first (validated), then a linear sweep catches
    orphaned entries from tools with broken pointers. Never raises.
    """
    if depth > 16 or sector <= 0 or size <= 0 or size > 64 << 20:
        return
    try:
        img_size = os.fstat(f.fileno()).st_size
    except Exception:
        img_size = 1 << 60
    try:
        f.seek(sector * 2048)
        data = f.read(size)
    except OSError:
        return
    if len(data) < min(size, 14):
        return
    found, seen_off = {}, set()

    def _add(node):
        if node is None:
            return
        for s, e, _n in found.values():
            if not (node["span"][1] <= s or node["span"][0] >= e):
                return
        found[node["off"]] = (node["span"][0], node["span"][1],
                               node)

    def _visit(off):
        if off in seen_off or off + 14 > len(data):
            return
        seen_off.add(off)
        node = _xdvdfs_parse_node(data, off, img_size)
        if node is None:
            return
        _add(node)
        if node["left"] not in (0xFFFF,) and node["left"] != off:
            _visit(node["left"])
        if node["right"] not in (0xFFFF,) and node["right"] != off:
            _visit(node["right"])

    _visit(0)
    if size <= 4 << 20:
        # linear sweep: catches orphans from broken-pointer tables.
        # (Big tables trust the tree; sweeping them would be slow.)
        off = 0
        while off + 14 <= len(data):
            _add(_xdvdfs_parse_node(data, off, img_size))
            off += 4
    for off in sorted(found):
        _, _, node = found[off]
        full = node["name"] if not prefix else prefix + "/" + node["name"]
        ents.append((full, node["sec"], node["size"], node["dir"]))
    for off in sorted(found):
        _, _, node = found[off]
        if not node["dir"]:
            continue
        full = node["name"] if not prefix else prefix + "/" + node["name"]
        _xdvdfs_walk_table(f, node["sec"], node["size"], full,
                           ents, depth + 1)


def _xdvdfs_is_xiso(path):
    """True if sector 32 holds the XDVDFS magic. Never raises."""
    try:
        with open(path, "rb") as f:
            f.seek(32 * 2048)
            return f.read(20) == XDVDFS_MAGIC
    except Exception:
        return False


def parse_x360_iso(path):
    """Xbox 360 disc ISO (XDVDFS): file list + default.xex IDs."""
    import struct as _st
    try:
        size = os.path.getsize(path)
    except OSError as e:
        return {"error": str(e)}
    try:
        with open(path, "rb") as f:
            f.seek(32 * 2048)
            sec = f.read(2048)
            if len(sec) < 0x1C or sec[:20] != XDVDFS_MAGIC:
                return {"error": "not an Xbox 360 ISO"}
            rsec, rsz = _st.unpack_from("<II", sec, 0x14)
            if not rsec or not rsz or rsz > 64 << 20:
                return {"error": "bad XDVDFS root"}
            raw = []
            _xdvdfs_walk_table(f, rsec, rsz, "", raw)
            files = [(n, s, z) for n, s, z, d in raw if not d]
            dxex = next((e for e in files
                         if e[0].upper() == "DEFAULT.XEX"), None)

            def _rd(off, ln):
                f.seek(off)
                return f.read(ln)
            media, tid, ver, base, dn, di = ("", "", 0, 0, 0, 0)
            if dxex:
                base = dxex[1] * 2048
                media, tid, ver, base, dn, di = _xex_exec_info(
                    lambda o, ln: _rd(base + o, ln))
    except Exception as e:
        return {"error": str(e)}
    if not files:
        return {"error": "empty Xbox 360 ISO"}
    title = _x360_clean_title(path)
    region = _x360_region_from_name(path) or "-"
    tu = next((n.split("/")[-1] for n, _s, _z in files
               if n.upper().startswith("$TITLEUPDATE/") and
               n.split("/")[-1].lower().startswith("tu")), "")
    rows = [("Platform", "Xbox 360 ISO"),
            ("Title ID", tid or "-"),
            ("Media ID", media or "-"),
            ("Region", region)]
    rows += _x360_ver_disc_rows(ver, base, dn, di)
    rows += [("Update", tu if tu else "-"),
             ("Size", "%s (%d files)" % (fmt_size(size), len(files)))]
    ents = [{"id": i, "name": n, "size": z, "abs_off": s * 2048}
            for i, (n, s, z) in enumerate(files)]
    return {"ok": True, "kind": "x360", "path": path, "size": size,
            "title": title or tid or os.path.basename(path),
            "rows": rows, "entries": ents,
            "meta": {"title_id": tid, "media_id": media,
                     "own_ver": ("v%d" % ver) if ver else ""},
            "icon_entry": "", "x360_tid": tid}


def _x360_folder_xex(path):
    """default.xex path inside an extracted Xbox 360 folder, or ''. """
    try:
        if not os.path.isdir(path):
            return ""
        for fn in sorted(os.listdir(path)):
            if fn.lower() == "default.xex" and os.path.isfile(
                    os.path.join(path, fn)):
                return os.path.join(path, fn)
        return ""
    except Exception:
        return ""


def parse_x360_folder(path):
    """Extracted Xbox 360 folder (JTAG rip): full file list + XEX IDs."""
    xex = _x360_folder_xex(path)
    if not xex:
        return {"error": "no default.xex"}
    try:
        with open(xex, "rb") as fh:
            blob = fh.read()
        media, tid, ver, base, dn, di = _xex_exec_info(
            lambda o, ln: blob[o:o + ln])
    except OSError as e:
        return {"error": str(e)}
    ents, total = [], 0
    try:
        for dp, _dn, fns in os.walk(path):
            for fn in sorted(fns):
                fp = os.path.join(dp, fn)
                try:
                    sz = os.path.getsize(fp)
                except OSError:
                    continue
                if sz <= 0:
                    continue
                rel = os.path.relpath(fp, path).replace(os.sep, "/")
                ents.append({"id": len(ents), "name": rel, "size": sz,
                             "abs_off": -1, "local_path": fp})
                total += sz
                if len(ents) >= 200000:
                    break
            if len(ents) >= 200000:
                break
    except OSError:
        pass
    title = _x360_clean_title(path)
    region = _x360_region_from_name(path) or "-"
    tu = _x360_tu_present_folder(path)
    rows = [("Platform", "Xbox 360 folder"),
            ("Title ID", tid or "-"),
            ("Media ID", media or "-"),
            ("Region", region)]
    rows += _x360_ver_disc_rows(ver, base, dn, di)
    rows += [("Update", tu if tu else "-"),
             ("Size", "%s (%d files)" % (fmt_size(total), len(ents)))]
    return {"ok": True, "kind": "x360", "path": path, "size": total,
            "title": title or tid or os.path.basename(path),
            "rows": rows, "entries": ents,
            "meta": {"title_id": tid, "media_id": media,
                     "own_ver": ("v%d" % ver) if ver else ""},
            "icon_entry": "", "x360_tid": tid}


def parse_x360_xex_file(path, size=0):
    """Standalone default.xex: IDs only, no file list."""
    media, tid, ver, base, dn, di = _xex_exec_info(
        lambda o, ln: _xex_file_range(path, o, ln))
    if not tid and not media:
        return {"error": "no XEX execution info"}
    try:
        size = size or os.path.getsize(path)
    except OSError:
        size = 0
    title = _x360_clean_title(path)
    rows = [("Platform", "Xbox 360 XEX"),
            ("Title ID", tid or "-"),
            ("Media ID", media or "-"),
            ("Region", _x360_region_from_name(path) or "-")]
    rows += _x360_ver_disc_rows(ver, base, dn, di)
    rows += [("Size", fmt_size(size))]
    return {"ok": True, "kind": "x360", "path": path, "size": size,
            "title": title or tid, "rows": rows, "entries": [],
            "meta": {"title_id": tid, "media_id": media,
                     "own_ver": ("v%d" % ver) if ver else ""},
            "icon_entry": "", "x360_tid": tid}


def _xex_file_range(path, off, ln):
    try:
        with open(path, "rb") as f:
            f.seek(off)
            return f.read(ln)
    except Exception:
        return b""


# ---------------- Wii U NUS folders (tmd + 8-hex content files) ----------------
# Plaintext TMD: sigtype u32, signature, header at the next 64-byte
# boundary (Nintendo pads the sig area). Header: issuer[64], ids at
# fixed offsets; content records (id.u32, index.u16, type.u16,
# size.u64, sha1.20 = 0x30 bytes) live further down — located by
# scanning for the index-0 record whose size matches a sibling file,
# since tools insert gaps. Verified: DuckTales Remastered (EUR NUS).

WIIU_TITLE_TYPES = {0x1: "System", 0x100: "Game", 0x101: "System",
                    0x102: "Update", 0x103: "Demo", 0x104: "DLC"}


def _wiiu_tmd_path(path):
    """TMD file inside a Wii U NUS folder, or ''. Never raises."""
    try:
        if not os.path.isdir(path):
            return ""
        cands = []
        try:
            fns = sorted(os.listdir(path))
        except OSError:
            return ""
        for fn in fns:
            low = fn.lower()
            fp = os.path.join(path, fn)
            if not os.path.isfile(fp):
                continue
            if low in ("title.tmd", "tmd") or (
                    low.startswith("tmd.") and
                    low[4:].isdigit()):
                cands.append(fp)
        return cands[0] if cands else ""
    except Exception:
        return ""


def _wiiu_parse_tmd(raw):
    """(info, records). info has title_id/version/type/count. Never raises."""
    import struct as _st
    info, recs = {}, []
    try:
        if len(raw) < 0x200:
            return info, recs
        sigtype = _st.unpack_from(">I", raw, 0)[0]
        siglen = {0x10000: 0x200, 0x10001: 0x100, 0x10002: 0x3C,
                  0x10003: 0x40, 0x10004: 0x100}.get(sigtype, 0)
        if not siglen:
            return info, recs
        h = ((4 + siglen + 63) // 64) * 64
        if h + 0xA4 > len(raw):
            # unaligned/odd dumps: fall back to the issuer string
            try:
                h = raw.index(b"Root-CA")
            except ValueError:
                return info, recs
        if h + 0xA4 > len(raw):
            return info, recs
        tid = raw[h + 0x4C:h + 0x54]
        if len(tid) != 8:
            return info, recs
        count = _st.unpack_from(">H", raw, h + 0x9E)[0]
        if count <= 0 or count > 4096:
            return info, recs
        ver = _st.unpack_from(">H", raw, h + 0x9C)[0]
        typ = _st.unpack_from(">I", raw, h + 0x54)[0]
        info = {"title_id": tid.hex().upper(), "version": ver,
                "type": typ, "count": count}
        # records: scan for index-0..N run (tools insert gaps)
        max_off = min(len(raw), 4 << 20)
        off = 0
        cands = []
        while off + 0x30 <= max_off:
            try:
                cid, idx, ctyp = _st.unpack_from(">IHH", raw, off)
                size = _st.unpack_from(">Q", raw, off + 8)[0]
            except Exception:
                off += 4
                continue
            if cid <= 0xFFFFFF and idx < 4096 and size < 1 << 44 and \
                    ctyp in (0x1, 0x8001, 0x2001, 0x2003, 0x4001,
                             0x4003, 0xC001, 0xC003):
                cands.append((off, cid, idx, ctyp, size))
            off += 4
        # longest sequential-index run starting at a plausible header
        best, cur = [], []
        for c in cands:
            if cur and c[2] == cur[-1][2] + 1 and \
                    c[0] == cur[-1][0] + 0x30:
                cur.append(c)
            else:
                if len(cur) > len(best):
                    best = cur
                cur = [c]
        if len(cur) > len(best):
            best = cur
        if best and best[0][2] == 0 and len(best) >= min(count, 2):
            recs = [{"id": "%08X" % c[1], "index": c[2],
                     "type": c[3], "size": c[4]} for c in best]
        return info, recs
    except Exception:
        return {}, []


def parse_wiiu_folder(path):
    """Wii U NUS dump folder: TMD meta + content files as entries."""
    tmd = _wiiu_tmd_path(path)
    if not tmd:
        return {"error": "no TMD"}
    try:
        with open(tmd, "rb") as f:
            raw = f.read(4 << 20)
    except OSError as e:
        return {"error": str(e)}
    info, recs = _wiiu_parse_tmd(raw)
    if not info:
        return {"error": "bad TMD"}
    sizes = {}
    for r in recs:
        sizes[r["id"]] = r["size"]
    ents, total = [], 0
    try:
        for fn in sorted(os.listdir(path)):
            fp = os.path.join(path, fn)
            if not os.path.isfile(fp):
                continue
            if fp == tmd:
                continue
            try:
                sz = os.path.getsize(fp)
            except OSError:
                continue
            if sz <= 0:
                continue
            import re as _re
            tag = ""
            if _re.match(r"^[0-9A-Fa-f]{8}$", fn):
                tag = "content %s" % fn.upper()
                if fn.upper() in sizes and sizes[fn.upper()] != sz:
                    tag += " (size differs from TMD)"
            ents.append({"id": len(ents), "name": fn, "size": sz,
                         "abs_off": -1, "local_path": fp,
                         "kind": tag})
            total += sz
    except OSError:
        pass
    title = _x360_clean_title(path)
    region = _x360_region_from_name(path)
    if not region:
        try:
            up = os.path.basename(path).upper()
            if "EUROPE" in up or "(EU)" in up or "[EU]" in up:
                region = "Europe"
            elif "JAPAN" in up or "(JP)" in up or "[JP]" in up:
                region = "Japan"
            elif "USA" in up or "(US)" in up or "[US]" in up:
                region = "Americas"
        except Exception:
            region = ""
    ttype = WIIU_TITLE_TYPES.get(info["type"], "type %#x" % info["type"])
    rows = [("Platform", "Wii U (NUS folder)"),
            ("Title ID", info["title_id"]),
            ("Type", ttype),
            ("Version", "v%d" % info["version"]),
            ("Contents", "%d in TMD" % info["count"]),
            ("Region", region or "-"),
            ("Size", "%s (%d files)" % (fmt_size(total), len(ents)))]
    return {"ok": True, "kind": "wiiu", "path": path, "size": total,
            "title": title or info["title_id"],
            "rows": rows, "entries": ents,
            "meta": {"title_id": info["title_id"],
                     "version": info["version"],
                     "contents": [
                         "%s idx=%d type=%#x size=%d" % (
                             r["id"], r["index"], r["type"], r["size"])
                         for r in recs]},
            "icon_entry": "", "wiiu_tid": info["title_id"]}


# Wii U icon art: Nintendo's official IDBE CDN (same icons the eShop
# used). Encrypted AES-CBC; keys + IV are public homebrew knowledge
# (Pretendo docs), payload is SHA256-verified, TGA extracted to PNG.
# 128x128 official art, cached on disk like the other covers.
IDBE_BASE = "https://idbe-wup.cdn.nintendo.net/icondata"
IDBE_KEYS = {0: "4ab9a40e146975a84bb1b4f3ecefc47b",
             1: "90a0bb1e0e864ae87d13a6a03d28c9b8",
             2: "ffbb57c14e98ec6975b384fcf40786b5",
             3: "80923799b41f36a6a75fb8b48c95f66f"}
IDBE_IV = "a46987ae47d82bb4fa8abc0450285fa4"
_WIIU_ICON_MEM = {}


def fetch_wiiu_icon(tid):
    """Official 128x128 icon PNG for a Wii U Title ID, or b"". Never raises."""
    try:
        t = str(tid or "").strip().upper()
    except Exception:
        return b""
    if t in _WIIU_ICON_MEM:
        return _WIIU_ICON_MEM[t]
    import re as _re
    if not _re.match(r"^[0-9A-F]{16}$", t):
        _WIIU_ICON_MEM[t] = b""
        return b""
    try:
        d = _covers_dir()
        if d:
            _fp = os.path.join(d, t + ".png")
            try:
                if os.path.isfile(_fp) and os.path.getsize(_fp) > 1024:
                    with open(_fp, "rb") as fh:
                        _raw = fh.read(5_000_000)
                    if _raw[:8] == b"\x89PNG\r\n\x1a\n":
                        _WIIU_ICON_MEM[t] = _raw
                        return _raw
            except Exception:
                pass
    except Exception:
        pass
    if not HAS_PS3_AES:
        return b""
    if not _proxy_url() and not _host_up("idbe-wup.cdn.nintendo.net"):
        return b""
    try:
        import hashlib as _hl
        sub = "%02X" % ((int(t, 16) >> 8) & 0xFF)
        raw = _http_get("%s/%s/%s.idbe" % (IDBE_BASE, sub, t),
                        tries=2, insecure_fallback=True)
        if len(raw) < 0x2100 or raw[0] != 0 or \
                raw[1] not in IDBE_KEYS:
            raise ValueError("bad idbe")
        from cryptography.hazmat.primitives.ciphers import (
            Cipher as _Cipher, algorithms as _Algos, modes as _Modes)
        dec = _Cipher(
            _Algos.AES(bytes.fromhex(IDBE_KEYS[raw[1]])),
            _Modes.CBC(bytes.fromhex(IDBE_IV))).decryptor()
        pt = dec.update(raw[2:]) + dec.finalize()
        if _hl.sha256(pt[0x20:]).digest() != pt[:0x20]:
            raise ValueError("sha mismatch")
        if pt[0x20:0x28].hex().upper() != t:
            raise ValueError("tid mismatch")
        tga = pt[0x2050:0x2050 + 0x1002C]
        if len(tga) != 0x1002C:
            raise ValueError("no icon")
        try:
            from PIL import Image as _Im
            import io as _io
            buf = _io.BytesIO()
            _Im.open(_io.BytesIO(tga)).save(buf, "PNG")
            png = buf.getvalue()
        except Exception:
            raise ValueError("bad tga")
        if len(png) < 1024:
            raise ValueError("icon too small")
        _WIIU_ICON_MEM[t] = png
        try:
            d = _covers_dir()
            if d:
                with open(os.path.join(d, t + ".png"), "wb") as out:
                    out.write(png)
        except Exception:
            pass
        return png
    except Exception:
        _WIIU_ICON_MEM[t] = b""
        return b""


def _split_part_stub(path, size):
    """Part N>0 of a split set: reuse sibling _0 header to confirm, then stub."""
    import re as _re
    m = _re.search(r"^(.*)_\d+\.pkg$", os.path.basename(path), _re.IGNORECASE)
    if not m:
        return None
    p0 = os.path.join(os.path.dirname(path), m.group(1) + "_0.pkg")
    try:
        with open(p0, "rb") as f:
            mg = f.read(4)
            if mg == CNT_MAGIC:
                return _split_part_ps4(path, size, p0)
            if mg != FIH_MAGIC:
                return None
            hdr = f.read(252)
    except OSError:
        return None
    return parse_ps5_retail_stub(path, size, mg + hdr)


def _split_part_ps4(path, size, p0):
    """PS4 split part: metadata lives in _0 — parse it, relabel part/size."""
    import glob as _glob
    import re as _re
    r = parse_pkg(p0)
    if not r.get("ok"):
        return r
    base = os.path.basename(path)
    sibs = sorted(_glob.glob(os.path.join(os.path.dirname(path), base.rsplit("_", 1)[0] + "_*.pkg")))
    sibs = [p for p in sibs if _re.search(r"_\d+\.pkg$", p, _re.IGNORECASE)]
    sibs.sort(key=lambda p: int(_re.search(r"_(\d+)\.pkg$", p, _re.IGNORECASE).group(1)))
    idx = next((i for i, p in enumerate(sibs) if os.path.basename(p) == base), 0)
    try:
        total = sum(os.path.getsize(p) for p in sibs) if len(sibs) > 1 else size
    except OSError:
        total = size
    rows = []
    for k, v in r["rows"]:
        if k == "Size":
            v = f"{fmt_size(size)} (joined {fmt_size(total)})"
        rows.append((k, v))
    rows.append(("Part", f"{idx + 1} of {len(sibs)}" if len(sibs) > 1 else "single"))
    r["rows"] = rows
    return r


_STORE_CACHE = {}
_STORE_LOCALE = {"UP": "en-us", "EP": "en-gb", "JP": "ja-jp", "HP": "en-hk"}


_BROWSER_HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/126.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
}

_NET_DOWN_UNTIL = {}


def _host_up(host, port=443, timeout=3, cache=60):
    """Fast offline check: True if TCP connects. Failures cached `cache` s
    so offline mode never hangs on full HTTP timeouts. Never raises."""
    import socket as _so
    import time as _tm
    now = _tm.time()
    k = (host, port)
    try:
        if _NET_DOWN_UNTIL.get(k, 0) > now:
            return False
    except Exception:
        pass
    try:
        _so.create_connection((host, port), timeout=timeout).close()
        return True
    except Exception:
        try:
            _NET_DOWN_UNTIL[k] = now + cache
        except Exception:
            pass
        return False


def _proxy_url():
    """Configured HTTP proxy URL, or "". Settings first, env fallback."""
    try:
        s = _load_settings() or {}
        v = str(s.get("proxy", "") or "").strip()
        if v:
            return v if v.startswith("http") else "http://" + v
    except Exception:
        pass
    try:
        for k in ("HTTPS_PROXY", "https_proxy",
                  "HTTP_PROXY", "http_proxy"):
            v = str(os.environ.get(k, "") or "").strip()
            if v:
                return v
    except Exception:
        pass
    return ""


def _http_get(url, timeout=25, tries=2, headers=None,
              insecure_fallback=False):
    """GET bytes via proxy when configured (else direct). Raises on failure.

    insecure_fallback: on CERTIFICATE_VERIFY_FAILED only, retry once
    without verification (some CDNs, e.g. Nintendo's IDBE, serve a
    chain that fails behind intercepting proxies; the payload itself
    is hash-verified by callers, and images are re-validated).
    """
    import urllib.request as _ureq
    import ssl as _ssl

    def _cert_fail(e):
        seen = 0
        while e is not None and seen < 4:
            if isinstance(e, _ssl.SSLError) and \
                    "CERTIFICATE_VERIFY_FAILED" in str(e):
                return True
            e = getattr(e, "reason", None)
            seen += 1
        return False

    err = None
    hdrs = {"User-Agent": "Mozilla/5.0"}
    try:
        if headers:
            hdrs.update(headers)
    except Exception:
        pass
    for _ in range(max(1, tries)):
        try:
            px = _proxy_url()
            if px:
                op = _ureq.build_opener(
                    _ureq.ProxyHandler({"http": px, "https": px}))
            else:
                op = _ureq.build_opener(_ureq.ProxyHandler({}))
            req = _ureq.Request(url, headers=hdrs)
            with op.open(req, timeout=timeout) as r:
                return r.read(5_000_000)
        except Exception as e:
            err = e
            if insecure_fallback and _cert_fail(e):
                try:
                    ctx = _ssl.create_default_context()
                    ctx.check_hostname = False
                    ctx.verify_mode = _ssl.CERT_NONE
                    op = _ureq.build_opener(
                        _ureq.ProxyHandler(
                            {"http": px, "https": px}) if px
                        else _ureq.ProxyHandler({}),
                        _ureq.HTTPSHandler(context=ctx))
                    req = _ureq.Request(url, headers=hdrs)
                    with op.open(req, timeout=timeout) as r:
                        return r.read(5_000_000)
                except Exception as e2:
                    err = e2
    raise err


def fetch_store_cover(cid):
    """(name, cover_url, release, tagline) from PlayStation Store. Square MASTER art preferred."""
    import re as _re
    import urllib.request as _ureq
    if not cid or "-" not in cid:
        return None, None, None, None
    if cid in _STORE_CACHE:
        return _STORE_CACHE[cid]
    if not _host_up("store.playstation.com"):
        return None, None, None, None
    loc = _STORE_LOCALE.get(cid.split("-")[0][:2].upper(), "en-us")
    url = "https://store.playstation.com/%s/product/%s" % (loc, cid)
    try:
        req = _ureq.Request(url, headers={"User-Agent": "Mozilla/5.0"})
        with _ureq.urlopen(req, timeout=10) as r:
            html = r.read().decode("utf-8", "replace")
    except Exception:
        _STORE_CACHE[cid] = (None, None, None, None)
        return None, None, None, None
    arts = {}
    for m in _re.finditer(r'"role":"([A-Z_0-9]+)"[^}]{0,400}?"url":"(https://[^"]+)"', html):
        arts.setdefault(m.group(1), m.group(2))
    for m in _re.finditer(r'"url":"(https://[^"]+)"[^}]{0,400}?"role":"([A-Z_0-9]+)"', html):
        arts.setdefault(m.group(2), m.group(1))
    cover = arts.get("MASTER") or arts.get("GAMEHUB_COVER_ART")
    mn = _re.search(r'"__typename":"Concept","name":"([^"]+)"', html)
    name = mn.group(1) if mn else None
    mr = _re.search(r'"releaseDate":"(\d{4}-\d{2}-\d{2})', html)
    rel = mr.group(1) if mr else None
    md = _re.search(r'"description":"([^"]{10,160})"', html)
    tag = md.group(1) if md else None
    _STORE_CACHE[cid] = (name, cover, rel, tag)
    return name, cover, rel, tag


def download_url_bytes(url, timeout=30):
    import urllib.request as _ureq
    req = _ureq.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    with _ureq.urlopen(req, timeout=timeout) as r:
        return r.read()


# PS3 cover art: GameTDB box-front (square-ish 160px), keyed by
# Title ID without dash (BCUS98111). Region folders: US/EN/JA.
# Same disk cache as PS2 covers, so art survives offline.
PS3_COVER_BASE = "https://art.gametdb.com/ps3/cover"
PS3_COVER_REGION = {"AMERICAS": "US", "EUROPE": "EN", "JAPAN": "JA",
                    "ASIA": "JA", "KOREA": "KO", "CHINA": "EN"}
_PS3_COVER_MEM = {}


def fetch_ps3_cover(tid, region=""):
    """Square box-front bytes (JPEG) for a PS3 Title ID, or b"". Never raises."""
    try:
        t = str(tid or "").strip().upper()
        rg = str(region or "").strip().upper()
    except Exception:
        return b""
    if t in _PS3_COVER_MEM:
        return _PS3_COVER_MEM[t]
    import re as _re
    if not _re.match(r"^[A-Z]{4}\d{5}$", t):
        _PS3_COVER_MEM[t] = b""
        return b""
    try:
        d = _covers_dir()
        if d:
            _fp = os.path.join(d, t + ".jpg")
            try:
                if os.path.isfile(_fp) and os.path.getsize(_fp) > 1024:
                    with open(_fp, "rb") as fh:
                        _raw = fh.read(5_000_000)
                    if _raw[:2] == b"\xff\xd8":
                        _PS3_COVER_MEM[t] = _raw
                        return _raw
            except Exception:
                pass
    except Exception:
        pass
    if not _proxy_url() and not _host_up("art.gametdb.com"):
        return b""
    _order = [PS3_COVER_REGION.get(rg, ""), "US", "EN", "JA"]
    _seen = []
    for _rg in _order:
        if _rg and _rg not in _seen:
            _seen.append(_rg)
    for _rg in _seen:
        try:
            raw = _http_get("%s/%s/%s.jpg" % (PS3_COVER_BASE, _rg, t),
                            tries=2)
            if raw[:2] != b"\xff\xd8":
                continue
            _PS3_COVER_MEM[t] = raw
            try:
                d = _covers_dir()
                if d:
                    with open(os.path.join(d, t + ".jpg"), "wb") as out:
                        out.write(raw)
            except Exception:
                pass
            return raw
        except Exception:
            continue
    _PS3_COVER_MEM[t] = b""
    return b""


# Xbox 360 cover art: XboxUnity (same source Aurora/PS5X360 use).
# CoverInfo.php lists covers per TitleID -> best official/highest
# rated -> Cover.php large (900x600 flat). No key needed.
XBOXUNITY_BASE = "https://xboxunity.net/Resources/Lib"
_X360_COVER_MEM = {}


def fetch_x360_cover(tid):
    """Flat box-art bytes (JPEG/PNG) for an Xbox 360 Title ID, or b""."""
    try:
        t = str(tid or "").strip().upper()
    except Exception:
        return b""
    if t in _X360_COVER_MEM:
        return _X360_COVER_MEM[t]
    import re as _re
    if not _re.match(r"^[0-9A-F]{8}$", t):
        _X360_COVER_MEM[t] = b""
        return b""
    try:
        d = _covers_dir()
        if d:
            for _ext in (".jpg", ".png"):
                _fp = os.path.join(d, t + _ext)
                try:
                    if os.path.isfile(_fp) and os.path.getsize(_fp) > 1024:
                        with open(_fp, "rb") as fh:
                            _raw = fh.read(5_000_000)
                        if _raw[:8] == b"\x89PNG\r\n\x1a\n" \
                                or _raw[:2] == b"\xff\xd8":
                            _X360_COVER_MEM[t] = _raw
                            return _raw
                except Exception:
                    pass
    except Exception:
        pass
    if not _proxy_url() and not _host_up("xboxunity.net"):
        return b""
    try:
        import json as _json
        _xu = {"X-Requested-With": "XMLHttpRequest",
               "Referer": "https://xboxunity.net/"}
        raw = _http_get(XBOXUNITY_BASE + "/CoverInfo.php?titleid=" + t,
                        tries=2, headers=_xu)
        covs = (_json.loads(raw.decode("utf-8", "replace")) or {}
                ).get("Covers", []) or []
        if not covs:
            raise ValueError("no covers")
        covs.sort(key=lambda c: (
            str(c.get("Official", "")) == "1",
            float(c.get("Rating") or 0)), reverse=True)
        cid = str(covs[0].get("CoverID", "") or "")
        if not cid:
            raise ValueError("no cover id")
        img = _http_get(XBOXUNITY_BASE + "/Cover.php?cid=" + cid +
                        "&size=large", tries=2, headers=_xu)
        if not (img[:8] == b"\x89PNG\r\n\x1a\n"
                or img[:2] == b"\xff\xd8"):
            raise ValueError("bad image")
        img = _x360_front_only(img)
        _X360_COVER_MEM[t] = img
        try:
            d = _covers_dir()
            if d:
                _ext = ".png" if img[:8] == b"\x89PNG\r\n\x1a\n" else ".jpg"
                with open(os.path.join(d, t + _ext), "wb") as out:
                    out.write(img)
        except Exception:
            pass
        return img
    except Exception:
        _X360_COVER_MEM[t] = b""
        return b""


def _x360_front_only(img_bytes):
    """Crop the front panel from a flat (back+spine+front) cover.

    Portrait art passes through. DVD keep-case flats have a fixed
    physical geometry (front = right ~48% at aspect ~1.49), which is
    scale-invariant across scans — so a true flat (aspect 1.35-1.65)
    is cut at 0.52W. Anything else passes through untouched.
    Never raises.
    """
    try:
        if not (img_bytes[:8] == b"\x89PNG\r\n\x1a\n"
                or img_bytes[:2] == b"\xff\xd8"):
            return img_bytes
        from PIL import Image as _Im
        import io as _io
        im = _Im.open(_io.BytesIO(img_bytes)).convert("RGB")
        w, h = im.size
        if w < h or not (1.35 <= w / max(1, h) <= 1.65):
            return img_bytes
        cut = int(w * 0.52)
        front = im.crop((cut, 0, w, h))
        buf = _io.BytesIO()
        front.save(buf, "JPEG", quality=92)
        out = buf.getvalue()
        return out if len(out) > 4096 else img_bytes
    except Exception:
        return img_bytes


def _ps3_cover_key(result):
    """(tid, region) for PS3 results with a valid Title ID, else None."""
    try:
        if not isinstance(result, dict) or result.get("kind") != "ps3":
            return None
        rd = dict(result.get("rows") or [])
        tid = str(rd.get("Title ID", "") or "").strip().upper()
        import re as _re
        if not _re.match(r"^[A-Z]{4}\d{5}$", tid):
            return None
        return (tid, str(rd.get("Region", "") or ""))
    except Exception:
        return None


# PS2 cover art: xlenore/ps2-covers (same repo PCSX2's own Cover
# Downloader uses). No key needed: covers/default/<SERIAL>.jpg
# (flat) with covers/3d/<SERIAL>.png fallback. Serial = dash form
# (SCUS-97399). Downloads are cached on disk, so covers survive offline.
PS2_COVER_BASE = ("https://raw.githubusercontent.com/xlenore/ps2-covers"
                  "/main/covers")
_PS2_COVER_MEM = {}


def _covers_dir():
    """On-disk cover cache dir (%APPDATA%/PKGViewer/covers). '' on failure."""
    try:
        p = _settings_path()
        if not p:
            return ""
        d = os.path.join(os.path.dirname(p), "covers")
        os.makedirs(d, exist_ok=True)
        return d
    except Exception:
        return ""


def fetch_ps2_cover(serial):
    """Cover bytes (JPEG/PNG) for a PS2 serial, or b"". Never raises."""
    try:
        s = str(serial or "").strip().upper()
    except Exception:
        return b""
    if not s:
        return b""
    if s in _PS2_COVER_MEM:
        return _PS2_COVER_MEM[s]
    import re as _re
    if not _re.match(r"^[A-Z]{4}-\d{5}$", s):
        _PS2_COVER_MEM[s] = b""
        return b""
    try:
        d = _covers_dir()
        if d:
            for _ext in (".jpg", ".png"):
                _fp = os.path.join(d, s + _ext)
                try:
                    if os.path.isfile(_fp) and os.path.getsize(_fp) > 1024:
                        with open(_fp, "rb") as fh:
                            _raw = fh.read(5_000_000)
                        if _raw[:8] == b"\x89PNG\r\n\x1a\n" \
                                or _raw[:2] == b"\xff\xd8":
                            _PS2_COVER_MEM[s] = _raw
                            return _raw
                except Exception:
                    pass
    except Exception:
        pass
    if not _proxy_url() and not _host_up("raw.githubusercontent.com"):
        return b""
    for _tail in ("default/%s.jpg" % s, "3d/%s.png" % s):
        try:
            raw = _http_get(PS2_COVER_BASE + "/" + _tail, tries=2)
            if not (raw[:8] == b"\x89PNG\r\n\x1a\n"
                    or raw[:2] == b"\xff\xd8"):
                continue
            _PS2_COVER_MEM[s] = raw
            try:
                d = _covers_dir()
                if d:
                    _ext = ".png" if raw[:8] == b"\x89PNG\r\n\x1a\n" else ".jpg"
                    with open(os.path.join(d, s + _ext), "wb") as out:
                        out.write(raw)
            except Exception:
                pass
            return raw
        except Exception:
            continue
    _PS2_COVER_MEM[s] = b""
    return b""


def ps2_cover_crop(im):
    """Drop the black "PlayStation 2" header from a PS2 box-front cover.

    The scans in xlenore/ps2-covers are whole box fronts: a ~9-12% black
    band with the PlayStation 2 wordmark sits on top of the artwork.
    Cropping it makes the PS2 cover line up with every other platform's
    cover (PS3/PS4 game art has no console header).

    Only runs when the band is really there - detected by the saturated
    "PS" logo in the top-right corner - so covers that were already
    cropped, 3D box art (RGBA) and every non-PS2 image pass through
    untouched. The crop line comes from the strongest horizontal edge in
    the top 13%, falling back to a fixed 11% when the artwork behind the
    band is too dark for an edge to stand out. A solid black strip at the
    very bottom (some scans have one) is trimmed the same way. Never
    raises.
    """
    try:
        from PIL import Image, ImageChops
        w, h = im.size
        if w < 64 or h < 160 or im.mode not in ("RGB", "L"):
            return im
        # PlayStation 2 branding: saturated logo in the top-right corner
        strip = im.crop((int(w * 0.72), 0, w, int(h * 0.13))).convert("HSV")
        sat = strip.getchannel("S").point(lambda v: 255 if v > 90 else 0)
        if sum(1 for px in sat.tobytes() if px) < 120:
            return im
        g = im.convert("L")
        diff = ImageChops.difference(g.crop((0, 1, w, h)),
                                    g.crop((0, 0, w, h - 1)))
        edges = list(diff.resize((1, h - 1), Image.BOX).tobytes())
        lo, hi = int(h * 0.02), int(h * 0.13)
        y = max(range(lo, hi), key=lambda i: edges[i])
        if edges[y] < 30 or y < int(h * 0.08):
            y = int(round(h * 0.11))
        # bottom: only a strip that is black across the whole width (art
        # bottoms are never that flat, so logos/ESRB badges stay intact)
        bot = h
        solid = list(g.point(lambda v: 255 if v < 25 else 0)
                     .resize((1, h), Image.BOX).tobytes())
        n = 0
        while n < int(h * 0.12) and solid[h - 1 - n] >= 250:
            n += 1
        if n >= 8:
            bot = h - n
        return im.crop((0, y + 1, w, bot))
    except Exception:
        return im


_PATCH_CACHE = {}
_PATCH_HOST = {"PPSA": "https://prosperopatches.com",
               "CUSA": "https://orbispatches.com"}


def _ago(date_str):
    """'2024-11-21...' -> '8 mo ago'. '' on parse failure."""
    import datetime as _dt
    import re as _re
    m = _re.search(r"(\d{4})-(\d{2})-(\d{2})", date_str or "")
    if not m:
        return ""
    try:
        d = _dt.date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
        days = (_dt.date.today() - d).days
    except ValueError:
        return ""
    if days < 0:
        return ""
    if days == 0:
        return "today"
    if days < 30:
        return f"{days} day{'s' if days > 1 else ''} ago"
    months = days // 30
    if months < 12:
        return f"{months} mo ago"
    years = months // 12
    rem = months % 12
    return f"{years}y {rem}m ago" if rem else f"{years}y ago"


def fetch_latest_patch(tid):
    """(latest_ver, patch_count, date_str) from patch trackers. Cached per session."""
    import json as _json
    import re as _re
    import urllib.request as _ureq
    if not tid:
        return None, 0, ""
    tid = tid.upper()
    if tid in _PATCH_CACHE:
        return _PATCH_CACHE[tid]
    host = _PATCH_HOST.get(tid[:4])
    if not host:
        _PATCH_CACHE[tid] = (None, 0, "")
        return None, 0, ""
    import urllib.parse as _up
    try:
        if not _host_up(_up.urlparse(host).hostname or ""):
            return None, 0, ""
    except Exception:
        return None, 0, ""
    try:
        req = _ureq.Request(host + "/" + tid, headers={"User-Agent": "Mozilla/5.0"})
        with _ureq.urlopen(req, timeout=10) as r:
            html = r.read().decode("utf-8", "replace")
        m = _re.search(r'dynpatch"\s+data-titleid="%s"\s+data-key="([0-9a-f]{64})"' % tid, html)
        if not m:
            m = _re.search(r"data-loadparams=\"\{\s*'titleid':\s*'%s',\s*'key':\s*'([0-9a-f]{64})'" % tid, html)
        if not m:
            m = _re.search(r'data-key="([0-9a-f]{64})"', html)
        if not m:
            _PATCH_CACHE[tid] = (None, 0, "")
            return None, 0, ""
        body = _json.dumps({"titleid": tid, "key": m.group(1)}).encode()
        req2 = _ureq.Request(host + "/api/internal/loadpatches", data=body,
                             headers={"User-Agent": "Mozilla/5.0",
                                      "Content-Type": "application/json"})
        with _ureq.urlopen(req2, timeout=10) as r2:
            j = _json.loads(r2.read())
        patches = j.get("patches", []) if j.get("success") else []
        pick = next((p for p in patches if p.get("is_latest")), None)
        if not pick and patches:
            pick = patches[0]
        latest = (pick.get("content_ver") or pick.get("version")) if pick else None
        date = (pick.get("import_date") or pick.get("creation_date") or "") if pick else ""
        _PATCH_CACHE[tid] = (latest, len(patches), date)
        return latest, len(patches), date
    except Exception:
        _PATCH_CACHE[tid] = (None, 0, "")
        return None, 0, ""


def parse_ps5_retail_stub(path, size, hdr):
    """Retail (encrypted) PS5 PKG: metadata unreadable. Info from filename + split set."""
    import glob as _glob
    import re as _re
    base = os.path.basename(path)
    m = _re.search(r"([A-Z]{2}\d{3,4}-[A-Z]{4}\d{5}_[0-9A-Z\-]+)", base)
    cid = m.group(1) if m else ""
    tid = _ps3_title_id_from_cid(cid) if cid else ""
    parts, total = [path], size
    m2 = _re.search(r"^(.*)_\d+\.pkg$", base, _re.IGNORECASE)
    if m2:
        sibs = sorted(_glob.glob(os.path.join(os.path.dirname(path), m2.group(1) + "_*.pkg")))
        sibs = [p for p in sibs if _re.search(r"_\d+\.pkg$", p, _re.IGNORECASE)]
        sibs.sort(key=lambda p: int(_re.search(r"_(\d+)\.pkg$", p, _re.IGNORECASE).group(1)))
        if len(sibs) > 1:
            parts = sibs
            try:
                total = sum(os.path.getsize(p) for p in parts)
            except OSError:
                pass
    idx = next((i for i, p in enumerate(parts)
                if os.path.basename(p) == base), 0)
    rows = [("Platform", "PS5 retail (encrypted)"),
            ("Package", "OFC (Official)" if len(hdr) > 5 and hdr[5] == 0x80
             else "FPKG (Fake)"),
            ("Content ID", cid or "-"),
            ("Title ID", tid or "-"),
            ("Region", content_region(cid)),
            ("Part", f"{idx + 1} of {len(parts)}" if len(parts) > 1 else "single"),
            ("Size", f"{fmt_size(size)} (joined {fmt_size(total)})" if len(parts) > 1
             else fmt_size(size)),
            ("Note", "metadata encrypted — title/files unavailable")]
    return {"ok": True, "kind": "ps5", "path": path, "size": size,
            "title": tid or base, "rows": rows, "entries": [],
            "meta": {}, "icon_entry": "icon0.png", "store_cid": cid or "",
            "patch_tid": tid or "", "own_ver": ""}


def parse_ps3_pkg(path):
    size = os.path.getsize(path)
    with open(path, "rb") as f:
        hdr = f.read(128)
        if len(hdr) < 128:
            return {"error": "too small for PS3 PKG"}
        magic, rev, typ, _mo, _mc, _hs, n, _tot, doff, dsz, cidraw, qa, riv = \
            struct.unpack(PS3_HDR_FMT, hdr)
        if magic != PS3_MAGIC:
            return {"error": "bad PS3 magic"}
        if typ != 1:
            return {"error": f"not PS3 NPDRM (type {typ:#x})"}
        cid = cidraw.split(b"\x00")[0].decode("ascii", errors="replace")
        retail = (rev == 0x8000)
        keymat = riv if retail else qa
        sfo, ents = {}, []
        if n and n < 1_000_000 and doff and dsz:
            try:
                tab = _ps3_decrypt(f, doff, retail, keymat, 0, n * 32)
                if len(tab) == n * 32:
                    recs = []
                    for i in range(n):
                        no, ns, fo, fs, fl, _pad = struct.unpack_from(PS3_ITEM_FMT, tab, i * 32)
                        if ns > dsz or no + ns > dsz or fo + fs > dsz:
                            continue
                        nm = ""
                        if ns:
                            nm = _ps3_decrypt(f, doff, retail, keymat, no, ns)
                            nm = nm.rstrip(b"\x00").decode("utf-8", errors="replace")
                        recs.append((nm, fo, fs, fl))
                    for i, (nm, fo, fs, fl) in enumerate(recs):
                        if not nm:
                            continue
                        ents.append({"id": i, "name": nm, "size": fs,
                                     "abs_off": ("ps3", retail, keymat, doff, fo)})
                    for nm, fo, fs, _fl in recs:
                        if nm.upper().endswith("PARAM.SFO") and 0 < fs < 1_000_000:
                            raw = _ps3_decrypt(f, doff, retail, keymat, fo, fs)
                            if raw[:4] == b"\x00PSF":
                                sfo = parse_sfo(raw)
                            break
            except Exception:
                pass
    title = sfo.get("TITLE", "") if sfo else ""
    tid = (sfo.get("TITLE_ID", "") if sfo else "") or _ps3_title_id_from_cid(cid)
    ver = ""
    if sfo:
        ver = sfo.get("VERSION", "") or sfo.get("APP_VER", "")
    rows = [("Platform", "PS3 NPDRM (%s)" % ("retail" if retail else "debug")),
            ("Content ID", cid or "-"),
            ("Title ID", tid or "-"),
            ("Region", content_region(cid) if "-" in (cid or "")
             else PS3_TID_REGION.get((tid or "")[:4].upper(), "-")),
            ("Version", ver or "-"),
            ("Min. System", fmt_fw32(sfo.get("PS3_SYSTEM_VER", "-")) if sfo else "-"),
            ("Size", fmt_size(size)),
            ("Files", str(len(ents)) if ents else f"{n} (encrypted)")]
    if not ents:
        rows.append(("Note", "listing unavailable (AES lib missing)" if retail and not HAS_PS3_AES
                     else "file table unreadable"))
    icon = next((e["name"] for e in ents if e["name"].upper() == "ICON0.PNG"), "")
    return {"ok": True, "kind": "ps3", "path": path, "size": size,
            "title": title or tid or os.path.basename(path),
            "rows": rows, "entries": ents, "meta": sfo,
            "icon_entry": icon or "icon0.png"}


# AMPR/LZ4 asset containers (LIZARD-style PS5 app dumps: AMPRPAK4/AMPRDAT3/...)
AMPR_MAGICS = (b"AMPRPAK4", b"AMPRDAT3", b"AMPRIDX3", b"AMPRCRC1", b"AMPRCFG1")
_UNITY_SIG = b"UnityFS\x00"
_UNITY_COMP = {0: "raw", 1: "LZMA", 2: "LZ4", 3: "LZ4HC"}
_UNITY_MARKERS = (b"2022.3.57f1", b"CAB-", b"AssetBundle", b".resS",
                  b"globalgamemanagers")


def _unity_comp_at(buf, pos):
    """Parse a UnityFS header at buf-relative pos → comp name or ''."""
    try:
        p = pos + 8 + 4
        e1 = buf.find(b"\x00", p)
        if e1 < 0:
            return ""
        e2 = buf.find(b"\x00", e1 + 1)
        if e2 < 0:
            return ""
        p = e2 + 1 + 8 + 4 + 4
        fl = struct.unpack_from(">I", buf, p)[0]
        return _UNITY_COMP.get(fl & 0x3F, "")
    except Exception:
        return ""


def _probe_pak_lz4(fp, size):
    """Strided probe of an AMPR .pak → 'LZ4HC' / 'LZ4' / 'Unity' / ''.

    Reads 1MB windows every 16MB (small files read fully), parses any
    UnityFS header (flags&0x3F: 2=LZ4, 3=LZ4HC), else falls back to lz4
    tokens / Unity bundle markers. Early-exits on LZ4HC.
    """
    try:
        f = open(fp, "rb")
    except OSError:
        return ""
    comps = []
    seen_lz4 = False
    seen_unity = False
    try:
        if size <= 32 << 20:
            offs = [0]
            wn = int(size)
        else:
            step = 16 << 20
            wn = 1 << 20
            offs = list(range(0, size - wn + 1, step))
            if offs[-1] != size - wn:
                offs.append(size - wn)
        for off in offs:
            try:
                f.seek(off)
                buf = f.read(wn + 256)
            except OSError:
                continue
            if not buf:
                continue
            i = 0
            while True:
                i = buf.find(_UNITY_SIG, i)
                if i < 0 or len(comps) >= 3:
                    break
                c = _unity_comp_at(buf, i)
                if c:
                    comps.append(c)
                    if c == "LZ4HC":
                        f.close()
                        return "LZ4HC"
                i += 1
            low = buf.lower()
            if b"lz4" in low:
                seen_lz4 = True
            if not seen_unity:
                for m in _UNITY_MARKERS:
                    if m in buf:
                        seen_unity = True
                        break
    finally:
        try:
            f.close()
        except Exception:
            pass
    if any(c == "LZ4" for c in comps):
        return "LZ4"
    if any(c == "LZMA" for c in comps):
        return "LZMA"
    if seen_lz4:
        return "LZ4"
    if seen_unity or comps:
        return "Unity"
    return ""


def _scan_ampr(path):
    """Top-level AMPR container files: [(name, size, magic, codec)] or []."""
    out = []
    try:
        for fn in sorted(os.listdir(path)):
            fp = os.path.join(path, fn)
            if not os.path.isfile(fp):
                continue
            ln = fn.lower()
            if not (ln.startswith("ampr_") or ln.endswith((".pak", ".index",
                                                            ".crc", ".runtime"))):
                continue
            try:
                with open(fp, "rb") as fh:
                    magic = fh.read(8)
            except OSError:
                continue
            if magic in AMPR_MAGICS:
                try:
                    sz = os.path.getsize(fp)
                except OSError:
                    continue
                codec = _probe_pak_lz4(fp, sz) if magic == b"AMPRDAT3" else ""
                out.append((fn, sz, magic.decode("ascii"), codec))
    except OSError:
        pass
    return out


def parse_app_folder(path):
    """PS5 app dump folder: sce_sys/param.json + icon0.png, no container."""
    pj = os.path.join(path, "sce_sys", "param.json")
    icon = os.path.join(path, "sce_sys", "icon0.png")
    meta, title, extra = {}, "", []
    if os.path.isfile(pj):
        try:
            with open(pj, "r", encoding="utf-8") as fh:
                meta = json.load(fh)
            title, extra = _param_json_meta(meta)
        except Exception as e:
            meta = {"_error": str(e)}
    total = 0
    nfiles = 0
    for _dp, _dn, fns in os.walk(path):
        nfiles += len(fns)
        for fn in fns:
            try:
                total += os.path.getsize(os.path.join(_dp, fn))
            except OSError:
                pass
    rows = [("Platform", "PS5 app folder"),
            ("Size", f"{fmt_size(total)} ({nfiles} files)")]
    ampr = _scan_ampr(path)
    if ampr:
        _lz4 = sum(1 for t in ampr if t[3] == "LZ4")
        _hc = sum(1 for t in ampr if t[3] == "LZ4HC")
        _albl = f"{len(ampr)} AMPR containers ({fmt_size(sum(s for _, s, _, _ in ampr))})"
        _codecs = []
        if _lz4:
            _codecs.append(f"LZ4 x{_lz4}" if _lz4 > 1 else "LZ4")
        if _hc:
            _codecs.append(f"LZ4HC x{_hc}" if _hc > 1 else "LZ4HC")
        if _codecs:
            _albl += " \u00b7 " + " \u00b7 ".join(_codecs)
        rows.append(("Assets", _albl))
    rows += extra
    ents = []
    if os.path.isfile(icon):
        try:
            ents.append({"id": 0, "name": "icon0.png", "size": os.path.getsize(icon),
                         "abs_off": -1, "local_path": icon})
        except OSError:
            pass
    # every other PNG in sce_sys (pic0, icon variants, ...) for the gallery
    try:
        _sce = os.path.join(path, "sce_sys")
        _eid = 1
        for _fn in sorted(os.listdir(_sce)):
            if _fn == "icon0.png" or not _fn.lower().endswith(".png"):
                continue
            _fp = os.path.join(_sce, _fn)
            if not os.path.isfile(_fp):
                continue
            try:
                _sz = os.path.getsize(_fp)
            except OSError:
                continue
            if _sz <= 0:
                continue
            ents.append({"id": _eid, "name": _fn, "size": _sz,
                         "abs_off": -1, "local_path": _fp})
            _eid += 1
    except OSError:
        pass
    # trophy packs anywhere in the dump (sce_sys/trophy, Image0, ...)
    # so the Trophies tab auto-fills for folders too
    try:
        _eid = max([e["id"] for e in ents], default=0) + 1
        for _dp, _dn, _fns in os.walk(path):
            for _fn in sorted(_fns):
                _ln = _fn.lower()
                if not (_ln.endswith(".trp") or _ln.endswith(".ucp")):
                    continue
                _fp = os.path.join(_dp, _fn)
                try:
                    _sz = os.path.getsize(_fp)
                except OSError:
                    continue
                if _sz <= 0 or _sz >= 300_000_000:
                    continue
                _rel = os.path.relpath(_fp, path).replace("\\", "/")
                ents.append({"id": _eid, "name": _rel, "size": _sz,
                             "abs_off": -1, "local_path": _fp})
                _eid += 1
    except OSError:
        pass
    # AMPR/LZ4 asset containers in the Files tab (name + size + codec)
    try:
        _eid = max([e["id"] for e in ents], default=0) + 1
        for _fn, _sz, _magic, _codec in ampr:
            _nm = f"{_fn}  [{_codec}]" if _codec else _fn
            ents.append({"id": _eid, "name": _nm, "size": _sz,
                         "abs_off": -1, "local_path": os.path.join(path, _fn),
                         "ampr": _magic, "codec": _codec or "-"})
            _eid += 1
    except OSError:
        pass
    r = {"ok": True, "kind": "ps5", "path": path, "size": total,
         "title": title or os.path.basename(path.rstrip("/\\")),
         "rows": rows, "entries": ents, "meta": meta, "icon_entry": "icon0.png"}
    if ampr:
        r["ampr_lines"] = [f"{_fn} = {_mg}" + (f" / {_cd}" if _cd else "")
                           for _fn, _sz, _mg, _cd in ampr]
    if os.path.isfile(icon):
        r["folder_icon"] = icon
    return r


class _Exfat:
    """Minimal read-only exFAT: boot sector, FAT walk, dir scan."""

    def __init__(self, path_or_file):
        if hasattr(path_or_file, "read"):
            self.path = getattr(path_or_file, "name", "<view>")
            self.f = path_or_file
            self._own = False
            pos = self.f.tell()
            self.f.seek(0, 2)
            self._img_size = self.f.tell()
            self.f.seek(0)
        else:
            self.path = path_or_file
            self.f = open(path_or_file, "rb")
            self._own = True
            self.f.seek(0, 2)
            self._img_size = self.f.tell()
            self.f.seek(0)
        bs = self.f.read(512)
        if bs[3:11] != b"EXFAT   " or bs[510] != 0x55 or bs[511] != 0xAA:
            raise ValueError("not an exFAT image")
        self.bps = 1 << bs[108]
        self.spc = 1 << bs[109]
        self.clus_bytes = self.bps * self.spc
        fat_off = struct.unpack_from("<I", bs, 80)[0]
        data_off = struct.unpack_from("<I", bs, 88)[0]
        root_clus = struct.unpack_from("<I", bs, 96)[0]
        self.fat_sec = fat_off
        self.data_sec = data_off
        self.root_clus = root_clus

    def close(self):
        if getattr(self, "_own", True):
            try:
                self.f.close()
            except Exception:
                pass

    def _clus_off(self, clus):
        return (self.data_sec + (clus - 2) * self.spc) * self.bps

    def _fat_next(self, clus):
        self.f.seek(self.fat_sec * self.bps + clus * 4)
        v = struct.unpack("<I", self.f.read(4))[0]
        return None if v >= 0xFFFFFFF8 else v

    def read_chain(self, first, size):
        out = bytearray()
        clus = first
        while clus is not None and len(out) < size:
            self.f.seek(self._clus_off(clus))
            out += self.f.read(min(self.clus_bytes, size - len(out)))
            nxt = self._fat_next(clus)
            # Builder writes files contiguously but leaves FAT zeroed:
            # fall through to the next cluster instead of stopping.
            clus = nxt if nxt not in (None, 0) else clus + 1
            if self._clus_off(clus) >= self._img_size:
                break
        return bytes(out[:size])

    def _iter_dir(self, first, size, nofat):
        if nofat:
            self.f.seek(self._clus_off(first))
            raw = self.f.read(size)
        else:
            raw = self.read_chain(first, size)
        return raw

    def list_dir(self, first, size, nofat, want=None):
        """List dir entries; if want is set, stop early once found (faster).

        Reads are capped (16MB): a miss must not stream the whole image
        (root scan on a 200GB USB image would take minutes).
        """
        cap = min(size, 1 << 24)
        if nofat:
            self.f.seek(self._clus_off(first))
            raw = self.f.read(min(size, 1 << 20))
            return self._parse_dir(raw, want)
        out = bytearray()
        clus = first
        while clus is not None and len(out) < cap:
            self.f.seek(self._clus_off(clus))
            out += self.f.read(min(self.clus_bytes, size - len(out)))
            if want:
                items = self._parse_dir(bytes(out), want)
                if any(n.lower() == want for n, *_ in items):
                    return items
            nxt = self._fat_next(clus)
            clus = nxt if nxt not in (None, 0) else clus + 1
            if self._clus_off(clus) >= self._img_size:
                break
        return self._parse_dir(bytes(out[:size]), want)

    def _parse_dir(self, raw, want=None):
        items = []
        i = 0
        pending = None
        while i + 32 <= len(raw):
            etype = raw[i]
            if etype == 0x00:
                break
            if etype == 0x85 and i + 32 <= len(raw):
                nsec = raw[i + 1]
                pending = {"attrs": struct.unpack_from("<H", raw, i + 4)[0],
                           "names": [], "nsec": nsec}
            elif etype == 0xC0 and pending is not None:
                flags = struct.unpack_from("<H", raw, i + 2)[0]
                pending["nofat"] = bool(flags & 0x02)
                pending["first"] = struct.unpack_from("<I", raw, i + 20)[0]
                pending["size"] = struct.unpack_from("<Q", raw, i + 24)[0]
            elif etype == 0xC1 and pending is not None:
                chars = struct.unpack_from("<15H", raw, i + 2)
                pending["names"].append("".join(
                    chr(c) for c in chars if c).rstrip("\x00"))
                if len(pending["names"]) >= pending.get("nsec", 1) - 1:
                    name = "".join(pending["names"])
                    items.append((name, pending.get("attrs", 0),
                                  pending.get("first", 0),
                                  pending.get("size", 0),
                                  pending.get("nofat", False)))
                    pending = None
                    if want and name.lower() == want:
                        break
            i += 32
        return items

    def find(self, parts):
        clus, size, nofat = self.root_clus, 1 << 30, False
        for depth, part in enumerate(parts):
            if depth == 0 and (part == "" or part.lower().endswith(".exfat")):
                continue
            found = None
            want = part.lower() if depth < len(parts) else None
            for name, attrs, first, sz, nf in self.list_dir(clus, size, nofat,
                                                            want=want):
                if name.lower() == part.lower():
                    found = (attrs, first, sz, nf)
                    break
            if found is None:
                return None
            attrs, first, sz, nf = found
            if depth == len(parts) - 1:
                return {"first": first, "size": sz, "nofat": nf,
                        "is_dir": bool(attrs & 0x10)}
            if not (attrs & 0x10):
                return None
            clus, size, nofat = first, sz, nf
        return None

    def list_path(self, parts):
        """List names in a subdir given as path parts; [] on error."""
        clus, size, nofat = self.root_clus, 1 << 30, False
        for depth, part in enumerate(parts):
            if depth == 0 and (part == "" or part.lower().endswith(".exfat")):
                continue
            found = None
            want = part.lower() if depth < len(parts) else None
            for name, attrs, first, sz, nf in self.list_dir(clus, size, nofat,
                                                            want=want):
                if name.lower() == part.lower():
                    found = (attrs, first, sz, nf)
                    break
            if found is None:
                return []
            attrs, first, sz, nf = found
            if depth == len(parts) - 1:
                if not (attrs & 0x10):
                    return []
                return [{"name": n, "first": f, "size": s, "nofat": nf2,
                         "is_dir": bool(a & 0x10)}
                        for n, a, f, s, nf2 in self.list_dir(first, sz, nf)]
            if not (attrs & 0x10):
                return []
            clus, size, nofat = first, sz, nf
        return []


def _open_ffpfsc_view(path):
    """Open inner exFAT view of an .ffpfsc via mkpfs. Returns (view, fh, name).

    Caller must close fh. Raises RuntimeError if mkpfs is missing.
    """
    try:
        from pathlib import Path as _P
        from mkpfs.pfs import open_inner_file_view as _oiv
    except ImportError:
        raise RuntimeError("mkpfs not installed (pip install mkpfs)")
    r = _oiv(_P(path))
    if not r:
        raise ValueError("no single inner file in ffpfsc")
    return r


def parse_exfat_image(path):
    """PS5 exFAT game image: pull sce_sys/param.json + icon0.png via FAT walk."""
    size = os.path.getsize(path)
    fs = _Exfat(path)
    try:
        return _exfat_result(fs, path, size, "PS5 exFAT image")
    finally:
        fs.close()


def parse_ffpfsc_image(path):
    """Compressed PFS (.ffpfsc): inner file via mkpfs (exFAT, or a
    nested .ffpkg UFS2 image like PPSA20560-app.ffpkg)."""
    size = os.path.getsize(path)
    view, fh, inner = _open_ffpfsc_view(path)
    try:
        if str(inner or "").lower().endswith(".ffpkg"):
            return _ffpfsc_nested_ffpkg(view, fh, path, size, inner)
        fs = _Exfat(view)
        try:
            r = _exfat_result(fs, path, size, "PS5 ffpfsc image",
                              inner_name=inner)
        finally:
            fs.close()
        # Cache the icon bytes now; the PFS view closes with fh.
        for e in r.get("entries", []):
            try:
                fs2 = _Exfat(view)
                try:
                    first = e["abs_off"][1]
                    fsize = e["abs_off"][2]
                    nofat = e["abs_off"][3]
                    if nofat:
                        fs2.f.seek(fs2._clus_off(first))
                        e["cached"] = fs2.f.read(fsize)
                    else:
                        e["cached"] = fs2.read_chain(first, fsize)
                finally:
                    fs2.close()
            except Exception:
                pass
            e["abs_off"] = -2
        return r
    finally:
        try:
            fh.close()
        except Exception:
            pass


def _ffpfsc_nested_ffpkg(view, fh, path, size, inner):
    """ffpfsc wrapping a .ffpkg (UFS2): pytsk3 over the inner view.

    The inner file can be sparse/huge (191 GB logical); the view maps
    it without extracting, so nothing is copied. Caller keeps fh open
    semantics: closed here on every path. Never raises with a raw
    exception — returns an error dict instead.
    """
    try:
        import pytsk3
    except ImportError:
        try:
            fh.close()
        except Exception:
            pass
        return {"error": "pytsk3 not installed (pip install pytsk3)"
                " - needed for nested .ffpkg"}
    try:
        try:
            view.seek(0, 2)
            _isz = view.tell()
            view.seek(0)
        except Exception:
            _isz = size
        if not _isz or _isz <= 0:
            return {"error": "empty inner file: %s" % (inner or "?")}

        class _ViewImg(pytsk3.Img_Info):
            def __init__(self, f, n):
                self._f = f
                self._n = n
                super().__init__(url="", type=pytsk3.TSK_IMG_TYPE_RAW)

            def close(self):
                pass

            def get_size(self):
                return self._n

            def read(self, off, ln):
                self._f.seek(off)
                return self._f.read(ln)

        img = _ViewImg(view, _isz)
        try:
            fs = pytsk3.FS_Info(img)
        except Exception as e:
            return {"error": "not a filesystem image: %s" % e}
        try:
            r = _ffpkg_read(fs, path, _isz)
        finally:
            try:
                img.close()
            except Exception:
                pass
        if isinstance(r, dict) and r.get("ok"):
            try:
                _rows = list(r.get("rows", []))
                # outer container wins the label: the file IS ffpfsc,
                # ffpkg lives only inside (documented in Inner file)
                _rows = [(k, ("PS5 ffpfsc image" if k == "Platform" else v))
                         for k, v in _rows]
                _rows.insert(1, ("Inner file", "%s" % (inner or "?")))
                r["rows"] = _rows
            except Exception:
                pass
        return r
    finally:
        try:
            fh.close()
        except Exception:
            pass


def parse_ffpkg_image(path):
    """UFS2 game image (.ffpkg): read sce_sys/param.json + PNGs via pytsk3.

    All PNG bytes are cached in memory so the image handle closes
    immediately (like ffpfsc). Raises informative error if pytsk3 missing.
    """
    size = os.path.getsize(path)
    try:
        import pytsk3
    except ImportError:
        return {"error": "pytsk3 not installed (pip install pytsk3) - needed for .ffpkg"}
    img = pytsk3.Img_Info(path)
    try:
        fs = pytsk3.FS_Info(img)
    except Exception as e:
        return {"error": f"not a filesystem image: {e}"}
    try:
        return _ffpkg_read(fs, path, size)
    finally:
        try:
            img.close()
        except Exception:
            pass


def _ffpkg_read(fs, path, size):
    """Read param.json + PNGs from an open pytsk3 FS. Caller closes img."""
    try:
        _pjf = fs.open("/sce_sys/param.json")
        _pjsz = _pjf.info.meta.size if _pjf.info.meta else 0
        if _pjsz <= 0 or _pjsz > 100_000:
            return {"error": "sce_sys/param.json bad size"}
        raw = _pjf.read_random(0, _pjsz)
    except Exception as e:
        return {"error": f"sce_sys/param.json not found: {e}"}
    try:
        meta = json.loads(raw.decode("utf-8"))
    except Exception as e:
        return {"error": f"bad param.json: {e}"}
    title, extra = _param_json_meta(meta)
    ents = []
    try:
        d = fs.open_dir(path="/sce_sys")
        names = []
        for e in d:
            try:
                nm = e.info.name.name.decode()
            except Exception:
                continue
            if nm in (".", ".."):
                continue
            if not nm.lower().endswith(".png"):
                continue
            sz = e.info.meta.size if e.info.meta else 0
            if sz <= 0 or sz > 32_000_000:
                continue
            names.append((nm, sz))
    except Exception:
        names = []
    names.sort(key=lambda t: (t[0] != "icon0.png", t[0]))
    for i, (nm, sz) in enumerate(names):
        try:
            data = fs.open("/sce_sys/" + nm).read_random(0, sz)
        except Exception:
            continue
        if data[:8] != b"\x89PNG\r\n\x1a\n":
            continue
        ents.append({"id": i, "name": nm, "size": len(data),
                     "abs_off": -2, "cached": bytes(data)})
    rows = [("Platform", "PS5 ffpkg image"),
            ("Size", fmt_size(size))] + extra
    return {"ok": True, "kind": "ps5", "path": path, "size": size,
            "title": title or os.path.basename(path),
            "rows": rows, "entries": ents, "meta": meta,
            "icon_entry": "icon0.png", "ffpkg": True}


def _exfat_scan_packs(fs, max_dirs=500):
    """Find trophy packs (.trp/.ucp) anywhere in an exFAT image.

    Fast path first: the known trophy dirs (direct lookup, no walk).
    Full directory walk only as fallback (slow on big USB images).
    Directory walk only (no file data read): [(relpath, first, size,
    nofat)]. Never raises.
    """
    out = []
    try:
        for _cand in (["sce_sys", "trophy"], ["sce_sys", "trophy2"],
                      ["trophy"], ["trophy2"]):
            try:
                for _it in fs.list_path(_cand):
                    if _it["is_dir"]:
                        continue
                    _ln = _it["name"].lower()
                    if ( _ln.endswith(".trp") or _ln.endswith(".ucp")) \
                            and 0 < _it["size"] < 300_000_000:
                        out.append(("/".join(_cand + [_it["name"]]),
                                    _it["first"], _it["size"], _it["nofat"]))
            except Exception:
                continue
        if out:
            return out
        stack = [([], fs.root_clus, 1 << 30, False)]
        seen = 0
        while stack and seen < max_dirs:
            parts, clus, size, nofat = stack.pop()
            seen += 1
            try:
                items = fs.list_dir(clus, size, nofat)
            except Exception:
                continue
            for name, attrs, first, sz, nf in items:
                if not name or name in (".", ".."):
                    continue
                if attrs & 0x10:
                    if len(parts) < 5:
                        stack.append((parts + [name], first, sz, nf))
                else:
                    ln = name.lower()
                    if (ln.endswith(".trp") or ln.endswith(".ucp")) \
                            and 0 < sz < 300_000_000:
                        out.append(("/".join(parts + [name]), first, sz, nf))
    except Exception:
        pass
    return out


def _exfat_result(fs, path, size, platform, inner_name=None):
    pj = fs.find(["sce_sys", "param.json"])
    meta, title, extra = {}, "", []
    if pj and not pj["is_dir"] and pj["size"] < 100_000:
        try:
            if pj["nofat"]:
                fs.f.seek(fs._clus_off(pj["first"]))
                raw = fs.f.read(pj["size"])
            else:
                raw = fs.read_chain(pj["first"], pj["size"])
            meta = json.loads(raw.decode("utf-8"))
            title, extra = _param_json_meta(meta)
        except Exception as e:
            meta = {"_error": str(e)}
    icon = fs.find(["sce_sys", "icon0.png"])
    ents = []
    if icon and not icon["is_dir"] and icon["size"] > 0:
        ents.append({"id": 0, "name": "icon0.png", "size": icon["size"],
                     "abs_off": ("exfat", icon["first"], icon["size"],
                                 icon["nofat"])})
    # every other PNG in sce_sys (pic0, icon variants, ...) for the gallery
    try:
        _seen = {"icon0.png"}
        _eid = 1
        for _it in fs.list_path(["sce_sys"]):
            _nm = _it["name"]
            if (_it["is_dir"] or _nm in _seen or not _nm.lower().endswith(".png")
                    or _it["size"] <= 0 or _it["size"] > 32_000_000):
                continue
            _seen.add(_nm)
            ents.append({"id": _eid, "name": _nm, "size": _it["size"],
                         "abs_off": ("exfat", _it["first"], _it["size"],
                                     _it["nofat"])})
            _eid += 1
    except Exception:
        pass
    # trophy packs anywhere in the image (sce_sys/trophy, ...) for the
    # Trophies tab — read on demand via the exfat tuple reader
    try:
        for _rel, _first, _sz, _nf in _exfat_scan_packs(fs):
            ents.append({"id": _eid, "name": _rel, "size": _sz,
                         "abs_off": ("exfat", _first, _sz, _nf)})
            _eid += 1
    except Exception:
        pass
    rows = [("Platform", platform),
            ("Size", fmt_size(size))]
    if inner_name:
        rows.append(("Inner file", inner_name))
    rows += extra
    return {"ok": True, "kind": "ps5", "path": path, "size": size,
            "title": title or os.path.basename(path),
            "rows": rows, "entries": ents, "meta": meta,
            "icon_entry": "icon0.png", "exfat": True}


def parse_trp(data):
    """Inner files of a trophy00.trp (PS4/PS5): [{name, off, size}] or [].

    Layout (verified on retail TRP): u32 magic DCA24D00, u32be count @4,
    u64be total @8, u32be header 0x4d @0x10, u32be entry-size 0x40 @0x14,
    32-byte digest @0x18, entries @0x38: {u64 unk, u64be off, u64be size,
    u64 flags, u64 unk, char name[24]}. Strict validation — [] on doubt.
    """
    try:
        if not data or len(data) < 0x38 or data[:4] != b"\xdc\xa2M\x00":
            return []
        import struct as _st
        count = _st.unpack_from(">I", data, 4)[0]
        total = _st.unpack_from(">Q", data, 8)[0]
        esize = _st.unpack_from(">I", data, 0x14)[0]
        if not (1 <= count <= 10000) or total != len(data):
            return []
        if esize != 0x40:
            return []
        hsize = 0x38  # entries start after the 32-byte digest
        out = []
        for i in range(count):
            eo = hsize + i * esize
            if eo + esize > len(data):
                return []
            off = _st.unpack_from(">Q", data, eo + 8)[0]
            size = _st.unpack_from(">Q", data, eo + 16)[0]
            nm = data[eo + 40:eo + 64].split(b"\x00")[0].decode(
                "ascii", errors="replace")
            if not nm or off + size > len(data):
                return []
            out.append({"name": nm, "off": off, "size": size})
        return out
    except Exception:
        return []


# PS4/PS5 trophy ESFM decryption (psdevwiki: public Trophy_Key; per-title
# NPcommID like NPWR13863_00). Verified on L.A. Noire DUPLEX dump.
TRP_TROPHY_KEY = bytes([0x21, 0xF4, 0x1A, 0x6B, 0xAD, 0x8A, 0x1D, 0x3E,
                        0xCA, 0x7A, 0xD5, 0x86, 0xC1, 0x01, 0xB7, 0xA9])


def decrypt_esfm(blob, npcommid):
    """Decrypt one ESFM file -> XML bytes, or None. Never raises."""
    try:
        from cryptography.hazmat.primitives.ciphers import (
            Cipher as _Cipher, algorithms as _Algos, modes as _Modes)
    except Exception:
        return None
    try:
        if not blob or len(blob) < 32 or len(blob) % 16:
            return None
        npid = (npcommid.encode()[:16]
                if isinstance(npcommid, str) else bytes(npcommid[:16]))
        npid = npid.ljust(16, b"\x00")
        enc = _Cipher(_Algos.AES(TRP_TROPHY_KEY),
                      _Modes.CBC(bytes(16))).encryptor()
        ckey = enc.update(npid) + enc.finalize()
        dec = _Cipher(_Algos.AES(ckey), _Modes.CBC(blob[:16])).decryptor()
        pt = dec.update(blob[16:]) + dec.finalize()
        pad = pt[-1]
        if not (1 <= pad <= 16) or pt[-pad:] != bytes([pad]) * pad:
            return None
        pt = pt[:-pad]
        head = pt[:200].lower()
        if b"trophy" not in head:
            return None
        if sum(1 for b in pt if 32 <= b < 127 or b in (9, 10, 13)) < len(pt) * 0.7:
            return None
        return pt
    except Exception:
        return None


def bruteforce_npid(blob, start=0, end=100000):
    """Find NPWRxxxxx_00 for an ESFM blob -> (npid, xml) or (None, None)."""
    try:
        from cryptography.hazmat.primitives.ciphers import (
            Cipher as _Cipher, algorithms as _Algos, modes as _Modes)
    except Exception:
        return None, None
    try:
        if not blob or len(blob) < 32:
            return None, None
        ct = blob[16:32]
        for i in range(start, end):
            npid = ("NPWR%05d_00" % i).encode().ljust(16, b"\x00")
            enc = _Cipher(_Algos.AES(TRP_TROPHY_KEY),
                          _Modes.CBC(bytes(16))).encryptor()
            ckey = enc.update(npid) + enc.finalize()
            dec = _Cipher(_Algos.AES(ckey),
                          _Modes.CBC(blob[:16])).decryptor()
            if (dec.update(ct) + dec.finalize())[:1] != b"<":
                continue
            xml = decrypt_esfm(blob, npid.rstrip(b"\x00").decode())
            if xml:
                return npid.rstrip(b"\x00").decode(), xml
        return None, None
    except Exception:
        return None, None


def parse_trophy_xml(xml):
    """TROP.SFM XML -> [{id, name, detail, type, hidden}]. Never raises."""
    try:
        import xml.etree.ElementTree as _ET
        root = _ET.fromstring(xml)
        out = []
        for t in root.iter("trophy"):
            try:
                out.append({"id": t.get("id", "?"),
                            "name": (t.findtext("name") or "").strip(),
                            "detail": (t.findtext("detail") or "").strip(),
                            "type": (t.get("ttype") or "?").upper(),
                            "hidden": (t.get("hidden") or "").lower() == "yes"})
            except Exception:
                continue
        return out
    except Exception:
        return []


def carve_trp_icons(data):
    """Raw PNGs hidden in a TRP (trophy icons + title banners).

    Not in the entry table — carved by magic. Returns [{off, size, w, h}]
    with dims from IHDR (no image decode). Strict: drops anything odd.
    Trophy icons are 240x240 in trophy-id order; 320x176 ones are banners.
    """
    try:
        import struct as _st
        if not data or len(data) < 100:
            return []
        out = []
        _at = 0
        while True:
            _s = data.find(b"\x89PNG\r\n\x1a\n", _at)
            if _s < 0:
                break
            _at = _s + 1
            if _s + 33 > len(data):
                continue
            if data[_s + 12:_s + 16] != b"IHDR":
                continue
            _w, _h = _st.unpack_from(">2I", data, _s + 16)
            if _w <= 0 or _h <= 0 or _w > 2048 or _h > 2048:
                continue
            _en = data.find(b"IEND", _s) + 8
            if _en <= 8 or _en - _s > 10_000_000 or _en > len(data):
                continue
            out.append({"off": _s, "size": _en - _s, "w": _w, "h": _h})
            if len(out) > 2000:
                break
        return out
    except Exception:
        return []


def parse_ucp(data):
    """PS5 trophy00.ucp archive (newer dumps use this instead of .trp).

    64-byte big-endian records @0x40: u32 ?, u32 offset, u32 ?,
    u32 size, 16 reserved bytes, 32-byte null-padded name.
    Payload is raw (PNG icons + tropmeta_*.json), 16-byte aligned.
    Returns [{name, off, size}] or []. Never raises.
    """
    try:
        import struct as _st
        if not data or len(data) < 0x80 or data[:4] != b"\xb2(\xc6\n":
            return []
        out = []
        base = 0x40
        while base + 64 <= len(data):
            f0, off, f2, size = _st.unpack_from(">4I", data, base)
            nm = data[base + 32:base + 64].split(b"\x00")[0]
            if not nm:
                break  # padding / end of table
            try:
                name = nm.decode("ascii")
            except Exception:
                break  # binary = ran into payload
            if not name or off + size > len(data) or size <= 0:
                # tombstone/empty slot (e.g. zero-size icon0): keep name only
                if name and size == 0 and off == 0:
                    base += 64
                    continue
                break
            out.append({"name": name, "off": off, "size": size})
            base += 64
            if len(out) > 10000:
                break
        return out
    except Exception:
        return []


def ucp_trophies(data):
    """UCP bytes -> (npid, [{id, name, detail}], {icon_name: bytes}).

    Language pick: en-US -> en-GB -> first tropmeta_*.json.
    Never raises; ([], {}, None) on failure.
    """
    try:
        import json as _json
        files = parse_ucp(data)
        if not files:
            return None, [], {}
        blobs = {}
        for f in files:
            blobs[f["name"]] = data[f["off"]:f["off"] + f["size"]]
        metas = sorted(n for n in blobs if n.startswith("tropmeta_")
                       and n.endswith(".json"))
        pick = next((n for n in ("tropmeta_en-US.json", "tropmeta_en-GB.json")
                     if n in blobs), None) or (metas[0] if metas else None)
        npid, trs = None, []
        title = ""
        if pick:
            try:
                o = _json.loads(blobs[pick].decode("utf-8"))
                npid = o.get("trophyNpCommId")
                md = o.get("metadata") or {}
                try:
                    title = str((md.get("titleMetadata") or {}).get("name", "")
                                or "")
                except Exception:
                    title = ""
                for t in md.get("trophyMetadata", []):
                    trs.append({"id": str(t.get("id", "?")),
                                "name": str(t.get("name", "") or ""),
                                "detail": str(t.get("detail", "") or "")})
            except Exception:
                pass
        icons = {n: b for n, b in blobs.items()
                 if n.lower().endswith(".png") and b[:4] == b"\x89PNG"}
        return npid, title, trs, icons
    except Exception:
        return None, "", [], {}


_EXO_GRADES = {}


def _norm_name(s):
    """Lowercase ASCII-folded name for cross-source trophy matching."""
    try:
        import unicodedata as _ud
        s = _ud.normalize("NFKD", str(s or ""))
        s = "".join(c for c in s if not _ud.combining(c))
        return "".join(c for c in s.lower() if c.isalnum())
    except Exception:
        return str(s or "").lower()


def fetch_exophase_grades(title):
    """{normname: P/G/S/B} from Exophase trophy list. {} on any failure.

    Slug is derived from the game title (ghost-of-yotei-psn); names are
    matched ASCII-folded. Cached per session. Never raises.
    Exophase blocks plain-URL clients (403), so browser headers are sent.
    """
    import re as _re
    import urllib.request as _ureq
    if not title or not str(title).strip():
        return {}
    key = _norm_name(title)
    if key in _EXO_GRADES:
        return _EXO_GRADES[key]
    if not _host_up("www.exophase.com"):
        return {}
    out = {}
    try:
        # fold diacritics but KEEP word separators for the slug
        import unicodedata as _ud
        _fold = "".join(
            c for c in _ud.normalize("NFKD", str(title))
            if not _ud.combining(c)).lower()
        slug = _re.sub(r"[^a-z0-9]+", "-", _fold).strip("-")
        if not slug:
            return out
        for cand in (slug + "-psn", slug + "-ps5", slug):
            url = "https://www.exophase.com/game/%s/trophies/" % cand
            try:
                req = _ureq.Request(url, headers=_BROWSER_HEADERS)
                with _ureq.urlopen(req, timeout=8) as r:
                    html = r.read().decode("utf-8", "replace")
            except Exception:
                continue
            titles = _re.findall(
                r'fw-bolder">\s*<a[^>]*>([^<]+)</a>', html)
            grades = _re.findall(
                r'exo-icon-trophy-(platinum|gold|silver|bronze)', html)
            if not titles or len(titles) != len(grades):
                continue
            _gm = {"platinum": "P", "gold": "G",
                   "silver": "S", "bronze": "B"}
            for n, g in zip(titles, grades):
                out[_norm_name(n)] = _gm[g]
            if out:
                break
            out = {}
    except Exception:
        out = {}
    _EXO_GRADES[key] = out
    return out


def _ucp_ring(png):
    """Classify a UCP trophy icon ring: gold/gray/copper/''.

    Ring art differs per game (Ghost bronze=copper, Astro bronze=gray),
    so this returns the raw color class; the caller maps the majority
    class to Bronze. Never raises.
    """
    try:
        import colorsys as _cs
        import math as _math
        import statistics as _st
        from PIL import Image as _Img
        import io as _io
        im = _Img.open(_io.BytesIO(png)).convert("RGB")
        w, h = im.size
        if w < 64 or h < 64:
            return ""
        cx, cy = w / 2, h / 2
        px = im.load()
        best_sat = (0, 0, 0)   # (sat, hue, val)
        best_gray = 0          # brightest low-sat ring radius value
        rr = 0.30
        while rr <= 0.485:
            ss, hs, vs = [], [], []
            a = 0
            while a < 360:
                x = int(cx + rr * w * _math.cos(_math.radians(a)))
                y = int(cy + rr * w * _math.sin(_math.radians(a)))
                try:
                    R, G, B = px[x, y]
                except IndexError:
                    a += 15
                    continue
                H, S, V = _cs.rgb_to_hsv(R / 255, G / 255, B / 255)
                hs.append(H * 360)
                ss.append(S)
                vs.append(V)
                a += 15
            if ss:
                ms, mh, mv = _st.median(ss), _st.median(hs), _st.median(vs)
                if ms > best_sat[0]:
                    best_sat = (ms, mh, mv)
                if ms < 0.25 and mv > best_gray:
                    best_gray = mv
            rr += 0.02
        ms, mh, mv = best_sat
        if ms > 0.30 and 32 <= mh <= 55:
            return "gold"
        if best_gray > 0.45:
            return "gray"
        if ms > 0.30 and (mh <= 25 or mh >= 340):
            return "copper"
        return ""
    except Exception:
        return ""


def _ucp_grade(png, tid, detail):
    """Legacy single-icon guess (kept for compatibility)."""
    ring = _ucp_ring(png) if png else ""
    if str(tid or "").strip() in ("0000", "0"):
        return "P"
    return {"gold": "G", "gray": "S", "copper": "B"}.get(ring, "")


def read_entry_bytes(path, abs_off, size, limit=32_000_000):
    if isinstance(abs_off, tuple) and abs_off and abs_off[0] == "ps3":
        _, retail, keymat, doff, fo = abs_off
        if size <= 0 or size > limit:
            return b""
        with open(path, "rb") as f:
            return _ps3_decrypt(f, doff, retail, keymat, fo, size)
    if isinstance(abs_off, tuple) and abs_off and abs_off[0] == "exfat":
        _, first, fsize, nofat = abs_off
        if fsize <= 0 or fsize > limit:
            return b""
        fs = _Exfat(path)
        try:
            if nofat:
                fs.f.seek(fs._clus_off(first))
                return fs.f.read(fsize)
            return fs.read_chain(first, fsize)
        finally:
            fs.close()
    if isinstance(abs_off, int) and abs_off < 0:
        return b""
    if size <= 0 or size > limit:
        return b""
    with open(path, "rb") as f:
        f.seek(abs_off)
        return f.read(size)


def fmt_size(n):
    if n >= 1e9:
        return f"{n / 1e9:.2f} GB"
    if n >= 1e6:
        return f"{n / 1e6:.1f} MB"
    if n >= 1e3:
        return f"{n / 1e3:.1f} KB"
    return f"{n} B"


def build_entry_tree(entries):
    """Flat entry names -> folder tree for the Files tab.

    Names may carry a path ("PS3_GAME/USRDIR/EBOOT.BIN"); names without
    one stay at the root. A name ending in "/" is a folder with no file.
    Files that repeat a folder name stay next to it (both are visible).
    Node: {name, path, kids {part: node}, files [...], size, count}.
    """
    root = {"name": "", "path": "", "kids": {}, "files": [],
            "size": 0, "count": 0}
    for idx, e in enumerate(entries or []):
        name = str((e or {}).get("name") or "").strip()
        if not name:
            continue
        norm = name.replace("\\", "/")
        is_dir = norm.endswith("/")
        parts = [p for p in norm.split("/") if p not in ("", ".", "..")]
        if not parts:
            continue
        size = int(e.get("size") or 0)
        node = root
        # folders: every component but the last one + an explicit "dir/" name
        for part in parts[:-1]:
            kid = node["kids"].get(part)
            if kid is None:
                kid = {"name": part,
                       "path": (node["path"] + "/" + part).lstrip("/"),
                       "kids": {}, "files": [], "size": 0, "count": 0}
                node["kids"][part] = kid
            node = kid
            if not is_dir:  # folders are not files: keep counts honest
                node["size"] += size
                node["count"] += 1
        leaf = parts[-1]
        if is_dir:
            if leaf not in node["kids"]:
                node["kids"][leaf] = {
                    "name": leaf,
                    "path": (node["path"] + "/" + leaf).lstrip("/"),
                    "kids": {}, "files": [], "size": 0, "count": 0}
            continue
        node["files"].append({"name": leaf, "idx": idx, "size": size,
                              "codec": (e or {}).get("codec", "")})
    return root


TRP_INLINE_MAX = 300_000_000


def populate_entry_tree(tree, result, trp_children=None, open_depth=1):
    """Render result["entries"] as folders in the Files Treeview.

    Files keep the historical iid "e<idx>" (extract and trophy lookup
    depend on it); folders get "d<n>". Folders above open_depth start
    collapsed. trp_children is filled exactly like the flat listing did.
    Returns {dir_iid: path}. Never raises for odd entry names.
    """
    entries = list((result or {}).get("entries") or [])
    trp_children = trp_children if trp_children is not None else {}
    root = build_entry_tree(entries)
    dirs = {}
    seq = [0]

    def _add_trp(idx, e, parent):
        try:
            if not (e.get("name") or "").lower().endswith((".trp", ".ucp")):
                return
            if not (0 < (e.get("size") or 0) < TRP_INLINE_MAX):
                return
            data = None
            if e.get("cached") is not None:
                data = bytes(e["cached"])
            elif e.get("local_path") and os.path.isfile(e["local_path"]):
                with open(e["local_path"], "rb") as fh:
                    data = fh.read(TRP_INLINE_MAX)
            elif e.get("abs_off") is not None:
                data = read_entry_bytes((result or {}).get("path"),
                                        e["abs_off"], e["size"],
                                        limit=TRP_INLINE_MAX)
            is_ucp = (e.get("name") or "").lower().endswith(".ucp")
            inner = ((parse_ucp(data) if is_ucp else parse_trp(data))
                     if data else [])
        except Exception:
            return
        for j, it in enumerate(inner):
            iid = "e%dc%d" % (idx, j)
            trp_children[iid] = (idx, it)
            tree.insert(parent, "end", iid=iid, text="↳ " + it["name"],
                        values=("", fmt_size(it["size"]), "trp"))

    def _render(node, parent, depth):
        for kid in sorted(node["kids"].values(),
                          key=lambda n: n["name"].lower()):
            seq[0] += 1
            iid = "d%d" % seq[0]
            dirs[iid] = kid["path"]
            n = kid["count"]
            tree.insert(parent, "end", iid=iid, text=kid["name"],
                        values=("", fmt_size(kid["size"]),
                                "1 file" if n == 1 else "%d files" % n),
                        open=depth < open_depth)
            _render(kid, iid, depth + 1)
        for f in sorted(node["files"], key=lambda x: x["name"].lower()):
            idx = f["idx"]
            e = entries[idx]
            tree.insert(parent, "end", iid="e%d" % idx, text=f["name"],
                        values=(e.get("id", ""), fmt_size(f["size"]),
                                f.get("codec", "") or ""))
            _add_trp(idx, e, "e%d" % idx)

    _render(root, "", 0)
    return dirs


def sanitize_pkg_path(name):
    """Entry name -> safe relative path (keeps subdirs, kills .. / drive)."""
    parts = []
    for p in (name or "").replace("\\", "/").split("/"):
        p = p.strip()
        if not p or p in (".", ".."):
            continue
        p = "".join(c for c in p if c not in '<>:"|?*')
        if p:
            parts.append(p)
    return "/".join(parts)


def extract_pkg_structured(pkg_path, entries, dest, progress=None):
    """Extract entries preserving folder structure. Returns (ok, fail, gp4_path)."""
    import shutil
    ok, fail = 0, 0
    for e in entries:
        rel = sanitize_pkg_path(e.get("name") or "")
        if not rel or e.get("size", 0) <= 0:
            continue
        out = os.path.join(dest, *rel.split("/"))
        try:
            os.makedirs(os.path.dirname(out) or dest, exist_ok=True)
            if e.get("local_path") and os.path.isfile(e["local_path"]):
                shutil.copyfile(e["local_path"], out)
            elif e.get("cached") is not None:
                with open(out, "wb") as fw:
                    fw.write(e["cached"])
            elif isinstance(e.get("abs_off"), int) and e["abs_off"] >= 0:
                with open(pkg_path, "rb") as fh, open(out, "wb") as fw:
                    fh.seek(e["abs_off"])
                    left = e["size"]
                    while left > 0:
                        buf = fh.read(min(64 * 1024 * 1024, left))
                        if not buf:
                            break
                        fw.write(buf)
                        left -= len(buf)
            else:  # PS3-crypto / exfat chains
                data = read_entry_bytes(pkg_path, e["abs_off"], e["size"],
                                        limit=2_000_000_000)
                if not data:
                    raise OSError("unreadable entry")
                with open(out, "wb") as fw:
                    fw.write(data)
            ok += 1
        except Exception:
            fail += 1
        if progress:
            try:
                progress(rel)
            except Exception:
                pass
    return ok, fail


def write_gp4(result, extracted_dir, gp4_path):
    """Write a minimal .gp4 project for orbis-pub-gen from parsed metadata."""
    import xml.sax.saxutils as _sx
    meta = result.get("meta") or {}
    rows = dict(result.get("rows", []))
    cid = (meta.get("CONTENT_ID", "") if isinstance(meta, dict) else "") or rows.get("Content ID", "")
    tid = (meta.get("TITLE_ID", "") if isinstance(meta, dict) else "") or rows.get("Title ID", "")
    cat = (meta.get("CATEGORY", "") if isinstance(meta, dict) else "") or "gd"
    ver = (meta.get("APP_VER", "") or meta.get("VERSION", "") or rows.get("Version", "01.00")
           if isinstance(meta, dict) else rows.get("Version", "01.00"))
    title = (meta.get("TITLE", "") if isinstance(meta, dict) else "") or result.get("title", tid)
    files = []
    for dp, _dn, fns in os.walk(extracted_dir):
        for fn in sorted(fns):
            fp = os.path.join(dp, fn)
            rel = os.path.relpath(fp, extracted_dir).replace(os.sep, "/")
            if rel.lower() == os.path.basename(gp4_path).lower():
                continue
            sz = os.path.getsize(fp)
            files.append((rel, sz))
    flines = "\n".join(
        '    <file targ_path="%s" orig_path="%s"/>' % (_sx.escape(r), _sx.escape(r))
        for r, _s in files)
    gp4 = ('<?xml version="1.0" encoding="utf-8"?>\n'
           '<psproject fmt="gp4" version="1000">\n'
           '  <volume>\n'
           '    <volume_type>pkg_ps4_app</volume_type>\n'
           '    <volume_id>PS4VOLUME</volume_id>\n'
           '    <volume_ts>2024-01-01 00:00:00</volume_ts>\n'
           '    <package content_id="%s" passcode="00000000000000000000000000000000"/>\n'
           '    <chunk_info chunk_count="1" scenario_count="1"/>\n'
           '  </volume>\n'
           '  <contents>\n%s\n  </contents>\n'
           '  <chunks>\n    <chunk id="0" label="Chunk #0">\n%s\n    </chunk>\n'
           '  </chunks>\n'
           '  <scenarios default_id="0">\n'
           '    <scenario id="0" type="sp" initial_chunk_count="1" label="Single Play">\n'
           '      <chunk idref="0"/>\n'
           '    </scenario>\n'
           '  </scenarios>\n'
           '</psproject>\n' % (
               _sx.escape(cid or "UP0000-%s_00-0000000000000000" % tid),
               flines,
               "\n".join('      <file idref="%s"/>' % _sx.escape(r) for r, _s in files)))
    with open(gp4_path, "w", encoding="utf-8") as f:
        f.write(gp4)
    return gp4_path


def find_orbis_tool():
    """orbis-pub-chk / orbis-pub-gen / gp4 binary on PATH, or ''."""
    import shutil as _sh
    for n in ("orbis-pub-chk", "orbis-pub-chk.exe", "orbis-pub-gen",
              "orbis-pub-gen.exe", "gengp4", "gengp4.exe"):
        p = _sh.which(n)
        if p:
            return p
    return ""


CURATED_SFO = ["TITLE", "TITLE_ID", "CATEGORY", "VERSION", "CONTENT_ID", "FORMAT"]
# (key in param.json, friendly label shown in Details; None = decode via fmt_fw)
CURATED_JSON = [("titleId", "Title ID"),
                ("contentId", "Content ID"),
                ("contentVersion", "Content Version"),
                ("masterVersion", "Master Version"),
                ("conceptId", "Concept ID"),
                ("applicationDrmType", "DRM"),
                ("requiredSystemSoftwareVersion", "Min. System"),
                ("sdkVersion", "SDK")]


def friendly_json_value(key, v):
    if key in ("sdkVersion", "requiredSystemSoftwareVersion"):
        return fmt_fw(v)
    if isinstance(v, int):
        return str(v)
    return str(v)


def curated_meta_lines(kind, meta):
    """Short useful subset of param.sfo / param.json."""
    lines = []
    if not isinstance(meta, dict):
        return lines
    if kind == "ps5":
        lp = meta.get("localizedParameters", {}) or {}
        lang = lp.get("defaultLanguage", "en-US")
        t = (lp.get(lang) or {}).get("titleName", "")
        if t:
            lines.append(f"Title = {t}")
        for k, label in CURATED_JSON:
            if k in meta:
                lines.append(f"{label} = {friendly_json_value(k, meta[k])}")
    elif kind in ("nsp", "xci"):
        # Switch: NACP localized titles + CNMT source (spec grid has the rest)
        titles = meta.get("nacp_titles") or {}
        if isinstance(titles, dict) and titles:
            first = next(iter(titles.values()), "")
            if first:
                lines.append(f"Title = {first}")
            if len(titles) > 1:
                for lang, name in titles.items():
                    if name and name != first:
                        lines.append(f"Title [{lang}] = {name}")
        if meta.get("nacp_display_ver"):
            lines.append(f"Display Version = {meta['nacp_display_ver']}")
        if meta.get("cnmt_file"):
            lines.append(f"CNMT = {meta['cnmt_file']}")
    else:
        # Show less: short useful subset in fixed order (Show all = full table).
        order = ["TITLE", "TITLE_ID", "CATEGORY", "CONTENT_ID",
                 "VERSION", "APP_VER", "SYSTEM_VER", "FORMAT",
                 "PARENTAL_LEVEL", "RESOLUTION", "SOUND_FORMAT",
                 "NP_COMMUNICATION_ID", "BOOTABLE"]
        titles = sorted(k for k in meta
                        if k.startswith("TITLE_") and k[6:].isdigit())
        collapsed = False
        if len(titles) > 1:
            groups = {}
            for k in titles:
                groups.setdefault(str(meta[k]), []).append(k)
            if len(groups) < len(titles):
                collapsed = True
                for val, ks in sorted(groups.items(),
                                      key=lambda kv: kv[1][0]):
                    ks = sorted(ks)
                    if len(ks) == 1:
                        lines.append(f"{ks[0]} = {val}")
                    else:
                        lines.append(f"{ks[0]}..{ks[-1]} "
                                     f"({len(ks)} langs) = {val}")
        for k in order:
            if k not in meta:
                continue
            if k == "TITLE" and collapsed:
                continue  # localized titles already shown above
            v = meta[k]
            if isinstance(v, str) and not v.strip():
                continue
            if k in ("SYSTEM_VER", "PS3_SYSTEM_VER"):
                v = fmt_fw32(v)
            lines.append(f"{k} = {v}")
    return lines


def full_meta_lines(meta):
    lines = []
    if isinstance(meta, dict):
        for k in sorted(meta.keys()):
            if k.startswith("_"):
                continue
            v = meta[k]
            if k in ("SYSTEM_VER", "PS3_SYSTEM_VER"):
                v = fmt_fw32(v)
            if isinstance(v, dict):
                v = json.dumps(v, ensure_ascii=False)[:300]
            lines.append(f"{k} = {str(v)[:200]}")
    return lines


def sanitize_filename_part(s, limit=120):
    """Make a string safe for a Windows file/folder name. Never raises."""
    try:
        s = str(s or "")
    except Exception:
        return ""
    s = "".join(ch if ch not in '<>:"/\\|?*' and ord(ch) >= 32 else " " for ch in s)
    s = " ".join(s.split())
    s = s.strip(" .")
    if len(s) > limit:
        s = s[:limit].rstrip(" .")
    return s


REGION_SHORT = {"Europe": "EU", "Americas": "US", "Japan": "JP", "Asia": "AS"}


def normalize_version(ver):
    """Clean version for filenames: '04.040.100' -> '4.40.100'.

    First segment always unpadded; other segments only unpadded when
    longer than 2 chars (keeps conventional '1.06' / '1.00'). Never raises.
    """
    try:
        segs = str(ver).strip().split(".")
        out = []
        for i, s in enumerate(segs):
            s = s.strip()
            if s.isdigit() and (i == 0 or len(s) > 2):
                s = str(int(s))
            if s != "":
                out.append(s)
        return ".".join(out)
    except Exception:
        try:
            return str(ver).strip()
        except Exception:
            return ""


NAME_PARTS = (("title", "Title"), ("tid", "Title ID"),
               ("ver", "Version"), ("region", "Region"))


# Canonical spec-grid order for every format: identity first, then
# versions, then system, then package details. Unknown keys keep
# their relative order at the end. Matched case-insensitively.
GRID_ORDER = ["Title ID", "Media ID", "Concept ID", "Category",
              "Version", "Base Version", "Content Ver", "Master Ver",
              "App Ver", "Min. System", "VMODE", "Boot", "Disc",
              "Parental Level", "Resolution",
              "Sound Format", "Trophy ID", "Update", "Volume", "SDK", "DRM",
              "Signature", "Languages", "Built", "Entries", "Files",
              "PFS image", "Assets", "Inner file", "Part", "Passcode",
              "Note"]


# PS4 engine: LibOrbisPkg via PkgEditor (see orbis_full.py).


def _disk_free(path):
    """Free bytes on the drive holding path, or -1 when unknown."""
    try:
        import shutil as _sh
        return _sh.disk_usage(os.path.abspath(path or ".")).free
    except Exception:
        pass
    try:
        import shutil as _sh2
        return _sh2.disk_usage(".").free
    except Exception:
        return -1


def _fs_type(path):
    """Filesystem name (e.g. NTFS/exFAT/FAT32) for path's drive, else ''."""
    try:
        import ctypes as _ct
        _k32 = _ct.windll.kernel32
        _drive = os.path.splitdrive(os.path.abspath(path or "."))[0] + "\\"
        _fs = _ct.create_unicode_buffer(260)
        if _k32.GetVolumeInformationW(_drive, None, 0, None, None,
                                      None, _fs, 260):
            return _fs.value or ""
    except Exception:
        pass
    return ""


def _du_size(path):
    """Data size of a file or folder. Slow on huge trees — call it in
    a thread. Never raises."""
    try:
        if os.path.isfile(path):
            return os.path.getsize(path)
        _total = 0
        for _dp, _dn, _fns in os.walk(path):
            for _fn in _fns:
                try:
                    _total += os.path.getsize(os.path.join(_dp, _fn))
                except Exception:
                    pass
        return _total
    except Exception:
        return 0


def _kill_tree(pid):
    """Kill a worker process and every child it spawned.
    Never raises."""
    try:
        import ctypes as _ct
        _k32 = _ct.windll.kernel32
        _kids = {}
        try:
            _snap = _k32.CreateToolhelp32Snapshot(0x2, 0)
            if _snap and int(_snap) != -1:
                try:
                    class _PE(_ct.Structure):
                        _fields_ = [
                            ("dwSize", _ct.c_ulong),
                            ("cntUsage", _ct.c_ulong),
                            ("th32ProcessID", _ct.c_ulong),
                            ("th32DefaultHeapID", _ct.c_void_p),
                            ("th32ModuleID", _ct.c_ulong),
                            ("cntThreads", _ct.c_ulong),
                            ("th32ParentProcessID", _ct.c_ulong),
                            ("pcPriClassBase", _ct.c_long),
                            ("dwFlags", _ct.c_ulong),
                            ("szExeFile", _ct.c_wchar * 260)]
                    _pe = _PE()
                    _pe.dwSize = _ct.sizeof(_PE)
                    _ok = _k32.Process32FirstW(_snap, _ct.byref(_pe))
                    while _ok:
                        try:
                            _kids.setdefault(
                                _pe.th32ParentProcessID,
                                []).append(_pe.th32ProcessID)
                        except Exception:
                            pass
                        _ok = _k32.Process32NextW(_snap, _ct.byref(_pe))
                finally:
                    _k32.CloseHandle(_snap)
        except Exception:
            pass
        _dead = set()

        def _kill(_p):
            if _p in _dead:
                return
            _dead.add(_p)
            for _c in _kids.get(_p, []):
                _kill(_c)
            try:
                _h = _k32.OpenProcess(0x0001, False, _p)
                if _h:
                    try:
                        _k32.TerminateProcess(_h, 1)
                    finally:
                        _k32.CloseHandle(_h)
            except Exception:
                pass
        _kill(int(pid))
    except Exception:
        pass


def build_clean_name(result, parts=None):
    """Clean uniform file/folder base name from parsed PKG info.

    Format: Title - TID - vVersion - Region (empty parts dropped).
    parts: optional {title, tid, ver, region} bools to pick components
    (rename dialog ticks). All on by default.
    Returns "" if neither Title ID nor title is available.
    """
    _pon = {"title": True, "tid": True, "ver": True, "region": True}
    if parts:
        try:
            _pon.update(parts)
        except Exception:
            pass
    try:
        rd = dict(result.get("rows") or [])
    except Exception:
        rd = {}
    try:
        title = str(result.get("title") or "").strip()
    except Exception:
        title = ""
    tid = str(rd.get("Title ID", "") or "").strip()
    ver = str(rd.get("Version", "") or rd.get("Content Ver", "") or "").strip()
    if ver[:1].lower() == "v":
        ver = ver[1:]
    ver = normalize_version(ver)
    region = str(rd.get("Region", "") or "").strip()
    region = REGION_SHORT.get(region, region)
    out = []
    if title and _pon.get("title"):
        out.append(title)
    if tid and tid != title and _pon.get("tid"):
        out.append(tid)
    if ver and ver != "-" and _pon.get("ver"):
        out.append("v" + ver)
    if region and region != "-" and _pon.get("region"):
        out.append(region)
    # non-base packages (Update/DLC) get a suffix so base+update of the
    # same version don't collide on one name (e.g. Crysis 2 v1.01 twice)
    _ptype = str(rd.get("Type", "") or "").strip()
    if _ptype.lower() in ("update", "dlc"):
        out.append(_ptype)
    if not out:
        return ""
    return sanitize_filename_part(" - ".join(out))


# Rename presets: (id, label, pattern). pattern None = the clean-name ticks.
BATCH_PRESETS = (
    ("clean", "Clean name (Title - Title ID - vVersion - Region)", None),
    ("tid", "Title ID only", "{tid}"),
    ("cid", "Content ID", "{cid}"),
    ("append", "Append [Title ID] to original", "{orig} [{tid}]"),
)
BATCH_CUSTOM_LABEL = "Custom pattern"
NAME_TOKENS = ("title", "tid", "cid", "version", "region", "type", "orig")


def preset_labels():
    return [p[1] for p in BATCH_PRESETS] + [BATCH_CUSTOM_LABEL]


def preset_id_for_label(label):
    if label == BATCH_CUSTOM_LABEL:
        return "custom"
    for pid, lab, _pat in BATCH_PRESETS:
        if lab == label:
            return pid
    return "clean"


def preset_label_for_id(pid):
    if pid == "custom":
        return BATCH_CUSTOM_LABEL
    for _pid, lab, _pat in BATCH_PRESETS:
        if _pid == pid:
            return lab
    return BATCH_PRESETS[0][1]


def preset_pattern(pid):
    for _pid, _lab, pat in BATCH_PRESETS:
        if _pid == pid:
            return pat
    return None


def pattern_for_preset(pid, custom_text=""):
    """Preset id + custom text -> pattern (None clean, "" custom-empty)."""
    if pid == "custom":
        return str(custom_text or "").strip()
    return preset_pattern(pid)


def suggest_base_name(result, pattern, include=None, path=""):
    """Base name (no extension) for one result under a pattern/preset."""
    if pattern:
        try:
            orig = os.path.splitext(os.path.basename(path))[0]
        except Exception:
            orig = ""
        return format_name(result, pattern, orig_base=orig)
    return build_clean_name(result, parts=include), []


def load_rename_prefs():
    """Saved rename choices: ({part: bool}, preset_id, custom pattern)."""
    inc = {k: True for k, _ in NAME_PARTS}
    pid, pat = "clean", ""
    try:
        s = _load_settings() or {}
        saved = s.get("rename_include")
        if isinstance(saved, dict):
            for k in inc:
                if isinstance(saved.get(k), bool):
                    inc[k] = saved[k]
        _pid = str(s.get("rename_preset") or "clean")
        if _pid == "custom" or any(_pid == _p[0] for _p in BATCH_PRESETS):
            pid = _pid
        _pat = s.get("rename_pattern")
        if isinstance(_pat, str):
            pat = _pat
        if pid == "custom" and not pat.strip():
            pid = "clean"  # empty custom = not a usable choice
    except Exception:
        pass
    return inc, pid, pat


def save_rename_prefs(include=None, preset=None, pattern=None):
    """Persist only the values given (settings.json merge). Never raises."""
    patch = {}
    try:
        if include is not None:
            patch["rename_include"] = {k: bool(include.get(k, True))
                                       for k, _ in NAME_PARTS}
        if preset is not None:
            patch["rename_preset"] = str(preset)
        if pattern is not None:
            patch["rename_pattern"] = str(pattern)
        if patch:
            _save_settings(patch)
    except Exception:
        pass


def format_name(result, pattern, orig_base="", parts=None):
    """Render a rename pattern from parsed file info.

    Tokens: {title} {tid} {cid} {version} {region} {type} {orig}
    ({version} is the bare number "1.06", {orig} the current name without
    its extension). Empty tokens are dropped with their separators, so a
    missing Title ID never leaves "Title -  - v1.06" behind.
    Returns (base_name, missing_token_labels); "" when nothing is left.
    """
    import re as _re
    if not pattern:
        return build_clean_name(result, parts=parts), []
    try:
        rd = dict(result.get("rows") or [])
    except Exception:
        rd = {}
    title = str(result.get("title") or "").strip()
    tid = str(rd.get("Title ID", "") or "").strip()
    cid = str(rd.get("Content ID", "") or "").strip()
    ver = str(rd.get("Version", "") or rd.get("Content Ver", "") or "").strip()
    if ver[:1].lower() == "v":
        ver = ver[1:]
    ver = normalize_version(ver)
    region = str(rd.get("Region", "") or "").strip()
    region = REGION_SHORT.get(region, region)
    ptype = str(rd.get("Type", "") or "").strip()
    if ptype.lower() not in ("update", "dlc"):
        ptype = ""
    vals = {
        "title": title,
        "tid": "" if tid == "-" else tid,
        "cid": "" if cid == "-" else cid,
        "version": ver if ver and ver != "-" else "",
        "region": "" if region == "-" else region,
        "type": ptype,
        "orig": str(orig_base or "").strip(),
    }
    low = pattern.lower()
    missing = [k.upper() for k, v in vals.items()
               if not v and ("{" + k + "}") in low]
    name = _re.sub(r"\{([a-zA-Z]+)\}",
                   lambda m: vals.get(m.group(1).lower(), m.group(0)),
                   pattern)
    # empty token + its separators would leave "[]", " - - v", etc.
    name = _re.sub(r"[\[\(\{]\s*[\]\)\}]", "", name)
    name = _re.sub(r"(?:\s*-\s*){2,}", " - ", name)
    name = _re.sub(r"^\s*-\s*|[-\s]+$", "", name)
    name = _re.sub(r"^\s*-\s*", "", name)
    name = _re.sub(r"\s{2,}", " ", name).strip(" -_.")
    return sanitize_filename_part(name), missing


BATCH_EXTS = (".pkg", ".ffpkg", ".ffpfsc", ".exfat", ".nsp", ".xci", ".iso")


def split_set_siblings(path):
    """All parts of a split set (game_0.pkg, game_1.pkg, ...) or [path].

    Only .pkg uses the _N convention. Never raises.
    """
    import re as _re
    try:
        d = os.path.dirname(path)
        base = os.path.basename(path)
        if not base.lower().endswith(".pkg"):
            return [path]
        m = _re.search(r"^(.*)_(\d+)\.pkg$", base, _re.IGNORECASE)
        if not m:
            return [path]
        import glob as _glob
        sibs = sorted(_glob.glob(os.path.join(d, m.group(1) + "_*.pkg")))
        sibs = [p for p in sibs if _re.search(r"_\d+\.pkg$", p, _re.IGNORECASE)]
        sibs.sort(key=lambda p: int(
            _re.search(r"_(\d+)\.pkg$", p, _re.IGNORECASE).group(1)))
        if len(sibs) > 1 and any(
                os.path.normcase(p) == os.path.normcase(path) for p in sibs):
            return sibs
    except Exception:
        pass
    return [path]


def collect_batch_files(inputs, recursive=False):
    """Expand files/folders into a deduped file list (batch extensions only)."""
    seen, out = set(), []
    for inp in inputs or []:
        try:
            if os.path.isdir(inp):
                if recursive:
                    for _dp, _dn, fns in os.walk(inp):
                        for fn in fns:
                            _fp = os.path.join(_dp, fn)
                            _k = os.path.normcase(os.path.abspath(_fp))
                            if _fp.lower().endswith(BATCH_EXTS) and _k not in seen:
                                seen.add(_k)
                                out.append(_fp)
                else:
                    for fn in sorted(os.listdir(inp)):
                        _fp = os.path.join(inp, fn)
                        _k = os.path.normcase(os.path.abspath(_fp))
                        if os.path.isfile(_fp) and _fp.lower().endswith(BATCH_EXTS) \
                                and _k not in seen:
                            seen.add(_k)
                            out.append(_fp)
            elif os.path.isfile(inp):
                _k = os.path.normcase(os.path.abspath(inp))
                if _k not in seen:
                    seen.add(_k)
                    out.append(inp)
        except Exception:
            continue
    return out


def preview_batch(files, include=None, pattern=None):
    """Build a rename plan for files. Split sets stay together (one entry).

    Each item: {files, new_files, new_base, status, reason}.
    status: 'ok' | 'skip'. Never renames anything.
    include: optional name-component ticks, passed to build_clean_name.
    pattern: optional format_name() pattern (e.g. "{orig} [{tid}]");
             None keeps the historical clean-name behaviour.
    """
    import re as _re
    plan, seen_sets, seen_targets = [], set(), set()
    for fp in files or []:
        try:
            parts = split_set_siblings(fp)
        except Exception:
            parts = [fp]
        setkey = os.path.normcase(os.path.abspath(parts[0]))
        if setkey in seen_sets:
            continue
        seen_sets.add(setkey)
        item = {"files": parts, "new_files": [],
                "new_base": "", "status": "skip", "reason": ""}
        try:
            r = parse_pkg(parts[0])
        except Exception as e:
            item["reason"] = f"parse error: {e}"
            plan.append(item)
            continue
        if not r.get("ok"):
            item["reason"] = r.get("error", "unrecognized file")
            plan.append(item)
            continue
        orig_base = ""
        try:
            orig_base = os.path.splitext(os.path.basename(parts[0]))[0]
            if len(parts) > 1:
                orig_base = _re.sub(r"_\d+$", "", orig_base)
        except Exception:
            orig_base = ""
        if pattern:
            base, _missing = format_name(r, pattern, orig_base=orig_base)
        else:
            base, _missing = build_clean_name(r, parts=include), []
        if not base:
            item["reason"] = (("missing " + ", ".join(_missing))
                              if _missing else "not enough info for a name")
            plan.append(item)
            continue
        item["new_base"] = base
        d = os.path.dirname(parts[0])
        if len(parts) == 1:
            _root, ext = os.path.splitext(os.path.basename(parts[0]))
            item["new_files"] = [os.path.join(d, base + ext)]
        else:
            for p in parts:
                m = _re.search(r"_(\d+)(\.[^.]+)$", os.path.basename(p))
                num, ext = (m.group(1), m.group(2)) if m else ("0", ".pkg")
                item["new_files"] = item.get("new_files", []) + \
                    [os.path.join(d, f"{base}_{num}{ext}")]
        problems = []
        for old, new in zip(item["files"], item["new_files"]):
            if os.path.normcase(old) == os.path.normcase(new):
                continue
            _nk = os.path.normcase(os.path.abspath(new))
            if os.path.exists(new):
                problems.append(f"target exists: {os.path.basename(new)}")
            elif _nk in seen_targets:
                problems.append(f"duplicate target: {os.path.basename(new)}")
        if problems:
            item["reason"] = "; ".join(problems)
            plan.append(item)
            continue
        for new in item["new_files"]:
            seen_targets.add(os.path.normcase(os.path.abspath(new)))
        if all(os.path.normcase(o) == os.path.normcase(n)
               for o, n in zip(item["files"], item["new_files"])):
            item["reason"] = (("missing " + ", ".join(_missing))
                              if _missing else "name unchanged")
            plan.append(item)
            continue
        item["status"] = "ok"
        plan.append(item)
    return plan


def apply_batch(plan, log_path=None, only_ok=True):
    """Execute a preview_batch plan. Returns (renamed, skipped, log_path).

    renamed: [(old, new)], skipped: [(old, reason)]. Writes a revert log.
    """
    import datetime as _dt
    renamed, skipped = [], []
    lines = [f"# PKGViewer batch rename {_dt.datetime.now():%Y-%m-%d %H:%M:%S}"]
    for item in plan or []:
        if item.get("status") != "ok" and only_ok:
            for f in item.get("files", []):
                skipped.append((f, item.get("reason", "skipped")))
            continue
        if item.get("status") != "ok":
            continue
        for old, new in zip(item["files"], item["new_files"]):
            if os.path.normcase(old) == os.path.normcase(new):
                continue
            if os.path.exists(new):
                skipped.append((old, f"target exists: {os.path.basename(new)}"))
                continue
            try:
                os.rename(old, new)
            except Exception as e:
                skipped.append((old, str(e)))
                continue
            renamed.append((old, new))
            lines.append(f"{old}\t{new}")
    lp = None
    if log_path and renamed:
        try:
            with open(log_path, "w", encoding="utf-8") as f:
                f.write("\n".join(lines) + "\n")
            lp = log_path
        except Exception:
            lp = None
    return renamed, skipped, lp


def default_batch_log():
    import datetime as _dt
    return os.path.abspath(
        f"batch_rename_{_dt.datetime.now():%Y%m%d_%H%M%S}.log")


def parse_revert_log(path):
    """Read a batch_rename_*.log file. Returns [(current, restore)].

    Each log line is "old\\trestore-target". Revert walks it backwards:
    current = the name after renaming, restore = the original name.
    Comment (#) and malformed lines are skipped. Never raises.
    """
    pairs = []
    try:
        with open(path, encoding="utf-8", errors="replace") as f:
            for line in f:
                line = line.rstrip("\n")
                if not line or line.startswith("#"):
                    continue
                parts = line.split("\t")
                if len(parts) != 2:
                    continue
                old, new = parts[0].strip(), parts[1].strip()
                if not old or not new:
                    continue
                pairs.append((new, old))
    except Exception:
        return []
    return pairs


def apply_revert(pairs, only_existing=True):
    """Rename current names back to originals. Returns (reverted, skipped).

    reverted: [(current, restore)], skipped: [(current, reason)].
    Never raises.
    """
    reverted, skipped = [], []
    for current, restore in pairs or []:
        if os.path.normcase(current) == os.path.normcase(restore):
            continue
        if only_existing and not os.path.exists(current):
            skipped.append((current, "current file not found"))
            continue
        if os.path.exists(restore):
            skipped.append((current,
                            f"target exists: {os.path.basename(restore)}"))
            continue
        try:
            os.rename(current, restore)
        except Exception as e:
            skipped.append((current, str(e)))
            continue
        reverted.append((current, restore))
    return reverted, skipped


def print_batch(inputs, recursive=False, apply=False, pattern=None):
    try:
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    except Exception:
        pass
    files = collect_batch_files(inputs, recursive=recursive)
    if not files:
        print("No game files found.")
        return
    plan = preview_batch(files, pattern=pattern)
    n_ok = sum(1 for i in plan if i["status"] == "ok")
    for item in plan:
        if item["new_files"]:
            for old, new in zip(item["files"], item["new_files"]):
                tag = "OK  " if item["status"] == "ok" else "SKIP"
                extra = "" if item["status"] == "ok" \
                    else f"  ({item['reason']})"
                print(f"[{tag}] {os.path.basename(old)}  ->  "
                      f"{os.path.basename(new)}{extra}")
        else:
            print(f"[SKIP] {os.path.basename(item['files'][0])}  "
                  f"({item['reason']})")
    print(f"--- {n_ok} of {len(plan)} ready ---")
    if not apply:
        print("Dry run. Re-run with --apply to rename.")
        return
    log = default_batch_log()
    renamed, skipped, lp = apply_batch(plan, log_path=log)
    print(f"Renamed {len(renamed)}, skipped {len(skipped)}."
          + (f" Log: {lp}" if lp else ""))


def copy_image_to_clipboard(pil_img):
    """Copy PIL image to Windows clipboard as DIB (ctypes only). None = ok."""
    try:
        from PIL import Image as _I
        import ctypes
        from ctypes import wintypes
        import io as _io
        img = pil_img if pil_img.mode in ("RGB", "RGBA") else pil_img.convert("RGB")
        if img.mode == "RGBA":
            bg = _I.new("RGB", img.size, (255, 255, 255))
            bg.paste(img, mask=img.split()[3])
            img = bg
        buf = _io.BytesIO()
        img.save(buf, "BMP")
        dib = buf.getvalue()[14:]
        kernel32 = ctypes.windll.kernel32
        user32 = ctypes.windll.user32
        kernel32.GlobalAlloc.argtypes = [wintypes.UINT, ctypes.c_size_t]
        kernel32.GlobalAlloc.restype = ctypes.c_void_p
        kernel32.GlobalLock.argtypes = [ctypes.c_void_p]
        kernel32.GlobalLock.restype = ctypes.c_void_p
        kernel32.GlobalUnlock.argtypes = [ctypes.c_void_p]
        kernel32.GlobalUnlock.restype = wintypes.BOOL
        kernel32.GlobalFree.argtypes = [ctypes.c_void_p]
        kernel32.GlobalFree.restype = ctypes.c_void_p
        user32.OpenClipboard.argtypes = [ctypes.c_void_p]
        user32.OpenClipboard.restype = wintypes.BOOL
        user32.EmptyClipboard.restype = wintypes.BOOL
        user32.SetClipboardData.argtypes = [wintypes.UINT, ctypes.c_void_p]
        user32.SetClipboardData.restype = ctypes.c_void_p
        user32.CloseClipboard.restype = wintypes.BOOL
        h = kernel32.GlobalAlloc(0x0002, len(dib))
        if not h:
            return "GlobalAlloc failed"
        p = kernel32.GlobalLock(h)
        if not p:
            kernel32.GlobalFree(h)
            return "GlobalLock failed"
        ctypes.memmove(p, dib, len(dib))
        kernel32.GlobalUnlock(h)
        if not user32.OpenClipboard(None):
            kernel32.GlobalFree(h)
            return "OpenClipboard failed"
        user32.EmptyClipboard()
        if not user32.SetClipboardData(8, h):
            user32.CloseClipboard()
            kernel32.GlobalFree(h)
            return "SetClipboardData failed"
        user32.CloseClipboard()
        return None
    except Exception as e:
        return str(e)


def print_info(path):
    try:
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    except Exception:
        pass
    r = parse_pkg(path)
    if "error" in r and not r.get("ok"):
        print("ERROR:", r["error"]); return
    print("FILE:", os.path.basename(path))
    print("TITLE:", r["title"])
    for k, v in r["rows"]:
        print(f"{k}: {v}")
    print(f"--- entries ({len(r['entries'])}) ---")
    for e in r["entries"]:
        _cd = e.get("codec")
        _tag = f" [{_cd}]" if _cd and _cd != "-" else ""
        print(f"  id={e['id']} size={e['size']} name={e['name']!r}{_tag}")
    for _al in r.get("ampr_lines", []):
        print(f"  AMPR: {_al}")


# ---------------- GUI ----------------
BG, CARD, CARD2, ACCENT = "#171717", "#202020", "#2a2a2a", "#4f8ef7"
TEXT, MUTED = "#f1f3f8", "#8b93a5"
FONT = ("Segoe UI", 10)
FONT_BIG = ("Segoe UI", 18, "bold")
FONT_MID = ("Segoe UI", 11, "bold")
FONT_SMALL = ("Segoe UI", 9)
FONT_BADGE = ("Segoe UI", 9, "bold")


if _TK_OK:
    class NamePatternBar(_tk.Frame):
        """Preset + token pattern + include ticks for the rename dialogs.

        Shared by the single rename and the batch dialog so both behave the
        same. The last choice is saved in settings.json: the preset, the
        custom pattern and the Title / Title ID / Version / Region ticks.
        """

        def __init__(self, parent, on_change=None, with_include=True):
            _tk.Frame.__init__(self, parent, bg=BG)
            inc, pid, pat = load_rename_prefs()
            self._on_change = on_change
            self._job = None
            self._custom_text = str(pat or "").strip()
            self._checks = []
            self._inc_vars = {}

            row = _tk.Frame(self, bg=BG)
            row.pack(fill="x")
            _tk.Label(row, text="Name:", bg=BG, fg=MUTED,
                      font=FONT_SMALL).pack(side="left")
            self._preset_var = _tk.StringVar(value=preset_label_for_id(pid))
            self._preset_box = _ttk.Combobox(
                row, textvariable=self._preset_var, state="readonly",
                values=preset_labels(), width=38, font=FONT_SMALL)
            self._preset_box.pack(side="left", padx=(8, 0))
            self._pat_var = _tk.StringVar(
                value=(self._custom_text if pid == "custom"
                       else (preset_pattern(pid) or "")))
            self._pat_entry = _tk.Entry(
                row, textvariable=self._pat_var, width=24, bg=CARD, fg=TEXT,
                insertbackground=TEXT, disabledbackground=CARD,
                disabledforeground=MUTED, relief="flat",
                highlightthickness=0, font=FONT_SMALL)
            self._pat_entry.pack(side="left", padx=(8, 0))

            chiprow = _tk.Frame(self, bg=BG)
            chiprow.pack(fill="x", pady=(3, 0))
            for tok in NAME_TOKENS:
                chip = _tk.Label(chiprow, text="{" + tok + "}", bg=CARD2,
                                 fg=TEXT, font=FONT_SMALL, padx=5, pady=1,
                                 cursor="hand2")
                chip.pack(side="left", padx=(0, 5))
                chip.bind("<Button-1>",
                          lambda _e, t=tok: self._insert_token(t))
                chip.bind("<Enter>", lambda _e, c=chip: c.config(bg=CARD))
                chip.bind("<Leave>", lambda _e, c=chip: c.config(bg=CARD2))

            self._hint_var = _tk.StringVar(value="")
            self._hint = _tk.Label(self, textvariable=self._hint_var, bg=BG,
                                   fg=MUTED, font=FONT_SMALL, anchor="w",
                                   justify="left")
            self._hint.pack(fill="x", pady=(2, 0))

            if with_include:
                part = _tk.Frame(self, bg=BG)
                part.pack(fill="x", pady=(4, 0))
                _tk.Label(part, text="Include:", bg=BG, fg=MUTED,
                          font=FONT_SMALL).pack(side="left")
                for key, lbl in NAME_PARTS:
                    var = _tk.BooleanVar(value=bool(inc.get(key, True)))
                    self._inc_vars[key] = var
                    chk = _tk.Checkbutton(
                        part, text=lbl, variable=var, bg=BG, fg=TEXT,
                        selectcolor=CARD2, activebackground=BG,
                        activeforeground=TEXT, font=FONT_SMALL,
                        command=self._on_check)
                    chk.pack(side="left", padx=(8, 0))
                    self._checks.append(chk)

            self._preset_box.bind("<<ComboboxSelected>>", self._on_preset)
            self._pat_entry.bind("<KeyRelease>", self._on_typed)
            self._sync_states()

        # -- public --
        def preset_id(self):
            return preset_id_for_label(self._preset_var.get())

        def pattern(self):
            pid = self.preset_id()
            if pid == "custom":
                return self._pat_var.get().strip()
            return preset_pattern(pid)

        def include(self):
            return {k: v.get() for k, v in self._inc_vars.items()}

        def unknown_tokens(self):
            import re as _re
            _pat = self.pattern() or ""
            return [t for t in _re.findall(r"\{([A-Za-z]+)\}", _pat)
                    if t.lower() not in NAME_TOKENS]

        def set_hint(self, text="", color=None):
            try:
                self._hint_var.set(text or "")
                self._hint.config(fg=color or MUTED)
            except Exception:
                pass

        # -- events --
        def _sync_states(self):
            pid = self.preset_id()
            try:
                self._pat_entry.config(
                    state="normal" if pid == "custom" else "disabled")
            except Exception:
                pass
            for chk in self._checks:
                try:
                    chk.config(state="normal" if pid == "clean"
                               else "disabled")
                except Exception:
                    pass

        def _emit(self):
            if self._on_change:
                try:
                    self._on_change()
                except Exception:
                    pass

        def _on_preset(self, _ev=None):
            pid = self.preset_id()
            if pid == "custom":
                if not self._custom_text.strip():
                    self._custom_text = "{title} - {tid}"
                self._pat_var.set(self._custom_text)
            else:
                self._pat_var.set(preset_pattern(pid) or "")
            self._sync_states()
            if pid == "custom":
                save_rename_prefs(preset=pid, pattern=self._custom_text)
            else:
                save_rename_prefs(preset=pid)
            if pid == "custom":
                try:
                    self._pat_entry.focus_set()
                    self._pat_entry.icursor("end")
                except Exception:
                    pass
            self._emit()

        def _on_check(self):
            save_rename_prefs(include=self.include())
            self._emit()

        def _insert_token(self, tok):
            # chips switch to Custom on first click so they always work
            try:
                if self.preset_id() != "custom":
                    self._preset_var.set(BATCH_CUSTOM_LABEL)
                    self._custom_text = ""
                    self._pat_var.set("")
                    self._sync_states()
                self._pat_entry.focus_set()
                self._pat_entry.insert("insert", "{%s}" % tok)
                self._custom_text = self._pat_var.get()
                save_rename_prefs(preset="custom",
                                  pattern=self._custom_text)
                self._emit()
            except Exception:
                pass

        def _on_typed(self, _ev=None):
            self._custom_text = self._pat_var.get()
            # typing is cheap; rebuilding the preview is not
            try:
                if self._job:
                    self.after_cancel(self._job)
            except Exception:
                pass
            self._job = self.after(400, self._commit_typed)

        def _commit_typed(self):
            self._job = None
            save_rename_prefs(pattern=self._custom_text)
            self._emit()
else:
    NamePatternBar = None


def _global_ctrl_keys(event, root, statusvar):
    """Layout-independent Ctrl+A / Ctrl+C (uses keycode, not keysym).
    Works with Persian/Arabic layouts where keysym differs."""
    import tkinter as tk
    if not (event.state & 0x4):
        return None
    kc = event.keycode
    ks = (event.keysym or "").lower()
    is_a = (kc == 65 or ks == "a")
    is_c = (kc == 67 or ks == "c")
    if not (is_a or is_c):
        return None
    try:
        w = root.focus_get()
    except Exception:
        return None
    try:
        if isinstance(w, tk.Text):
            if is_a:
                w.tag_add("sel", "1.0", "end-1c")
                w.mark_set("insert", "end-1c")
                w.see("insert")
                return "break"
            try:
                sel = w.get("sel.first", "sel.last")
            except Exception:
                return None
            w.clipboard_clear()
            w.clipboard_append(sel)
            try:
                w.update()
            except Exception:
                pass
            statusvar.set("Text copied")
            return "break"
        elif isinstance(w, tk.Entry):
            if is_a:
                w.select_range(0, "end")
                return "break"
            if not w.selection_present():
                return None
            sel = w.selection_get()
            w.clipboard_clear()
            w.clipboard_append(sel)
            try:
                w.update()
            except Exception:
                pass
            statusvar.set("Text copied")
            return "break"
    except Exception:
        return None
    return None


def _local_logo(size=(40, 40)):
    """Load local assets/logo.png if present (gitignored, never committed)."""
    try:
        from PIL import Image as _I
        here = os.path.dirname(os.path.abspath(__file__))
        cands = [os.path.join(os.getcwd(), "assets", "logo.png"),
                 os.path.join(here, "assets", "logo.png")]
        if getattr(sys, "frozen", False):
            cands.insert(0, os.path.join(os.path.dirname(sys.executable),
                                         "assets", "logo.png"))
            cands.insert(0, os.path.join(sys._MEIPASS, "assets", "logo.png"))
        for p in cands:
            if os.path.isfile(p):
                im = _I.open(p).convert("RGBA")
                im.thumbnail(size, _I.LANCZOS)
                return im
        return None
    except Exception:
        return None


def _format_icon_image(name, size=(28, 28)):
    """Load assets/icons/<name>.ico (pkg/exfat/ffpfsc/ffpkg) for in-app badge."""
    try:
        from PIL import Image as _I
        here = os.path.dirname(os.path.abspath(__file__))
        cands = [os.path.join(os.getcwd(), "assets", "icons", name + ".ico"),
                 os.path.join(here, "assets", "icons", name + ".ico")]
        if getattr(sys, "frozen", False):
            cands.insert(0, os.path.join(sys._MEIPASS, "assets", "icons", name + ".ico"))
            cands.insert(0, os.path.join(os.path.dirname(sys.executable),
                                         "assets", "icons", name + ".ico"))
        for p in cands:
            if os.path.isfile(p):
                im = _I.open(p).convert("RGBA")
                im.thumbnail(size, _I.LANCZOS)
                return im
        return None
    except Exception:
        return None


def run_gui(start_path=None):
    import tkinter as tk
    from tkinter import filedialog, messagebox, ttk
    try:
        from PIL import Image, ImageTk
        has_pil = True
    except ImportError:
        has_pil = False

    state = {"result": None, "photo": None, "pil": None,
             "img_name": "", "show_all": False}

    root = None
    has_dnd = False
    try:
        from tkinterdnd2 import DND_FILES, TkinterDnD
        root = TkinterDnD.Tk()
        has_dnd = True
    except ImportError:
        root = tk.Tk()
    try:
        # hide until layout is applied:
        # avoids white flash + resize jump on startup
        root.withdraw()
    except Exception:
        pass
    root.title("PKG Viewer %s — PS2/PS3/PS4/PS5/Switch/WiiU/Xbox360" % APP_VERSION)
    root.geometry("880x410")
    root.configure(bg=BG)
    root.minsize(880, 410)
    try:
        _ic = os.path.join(getattr(sys, "_MEIPASS", os.path.dirname(sys.executable)
                            if getattr(sys, "frozen", False) else "."), "assets", "logo.ico")
        if os.path.isfile(_ic):
            root.iconbitmap(_ic)
    except Exception:
        pass

    style = ttk.Style(root)
    try:
        style.theme_use("clam")
    except Exception:
        pass
    style.configure("TFrame", background=BG)
    style.configure("Card.TFrame", background=CARD)
    style.configure("Card2.TFrame", background=CARD2)
    style.configure("TLabel", background=BG, foreground=TEXT, font=FONT)
    style.configure("Card.TLabel", background=CARD, foreground=TEXT, font=FONT)
    style.configure("Muted.Card.TLabel", background=CARD, foreground=MUTED, font=FONT_SMALL)
    style.configure("Title.Card.TLabel", background=CARD, foreground=TEXT, font=FONT_BIG)
    style.configure("Badge.TLabel", background=CARD2, foreground=TEXT, font=FONT_BADGE,
                    padding=(10, 4))
    style.configure("SpecKey.TLabel", background=CARD, foreground=MUTED, font=FONT_SMALL)
    style.configure("SpecVal.TLabel", background=CARD, foreground=TEXT, font=FONT_MID)
    style.configure("Accent.TButton", background=ACCENT, foreground="#171717", font=FONT,
                    borderwidth=0, padding=(16, 9))
    style.map("Accent.TButton", background=[("active", "#6fa8ff")])
    style.configure("TNotebook", background=BG, borderwidth=0,
                    lightcolor=BG, darkcolor=BG, bordercolor=BG)
    style.configure("TNotebook.Tab", background=CARD, foreground=MUTED, padding=(12, 5), font=FONT,
                    borderwidth=0, lightcolor=CARD, darkcolor=CARD, bordercolor=CARD)
    style.map("TNotebook.Tab", background=[("selected", CARD2)],
              foreground=[("selected", TEXT)],
              lightcolor=[("selected", CARD2)], darkcolor=[("selected", CARD2)])
    style.configure("Treeview", background=CARD, fieldbackground=CARD, foreground=TEXT,
                    font=FONT, rowheight=26, borderwidth=0, relief="flat",
                    lightcolor=CARD, darkcolor=CARD, bordercolor=CARD)
    style.configure("Treeview.Heading", background=CARD2, foreground=MUTED, font=FONT_SMALL,
                    relief="flat", borderwidth=0,
                    lightcolor=CARD2, darkcolor=CARD2)
    style.map("Treeview.Heading", background=[("active", CARD2)])
    style.map("Treeview", background=[("selected", ACCENT)])
    style.configure("Vertical.TScrollbar", background=CARD2, troughcolor=BG,
                    bordercolor=BG, lightcolor=CARD2, darkcolor=CARD2,
                    arrowcolor=MUTED, relief="flat", borderwidth=0,
                    arrowsize=13)
    style.map("Vertical.TScrollbar", background=[("active", "#3b70c9")],
              arrowcolor=[("active", TEXT)])
    style.configure("TCombobox", fieldbackground=CARD2, background=CARD2, foreground=TEXT,
                    arrowcolor=MUTED)
    style.map("TCombobox",
              fieldbackground=[("readonly", CARD2), ("disabled", CARD2)],
              foreground=[("readonly", TEXT), ("disabled", MUTED)],
              background=[("readonly", CARD2)],
              arrowcolor=[("disabled", MUTED)],
              selectbackground=[("readonly", ACCENT)],
              selectforeground=[("readonly", "#171717")])
    root.option_add("*TCombobox*Listbox.background", CARD)
    root.option_add("*TCombobox*Listbox.foreground", TEXT)
    root.option_add("*TCombobox*Listbox.selectBackground", ACCENT)
    root.option_add("*TCombobox*Listbox.selectForeground", "#171717")
    root.option_add("*TCombobox*Entry.background", CARD2)
    root.option_add("*TCombobox*Entry.foreground", TEXT)
    root.option_add("*TCombobox*Entry.readonlybackground", CARD2)
    root.option_add("*TCombobox*Entry.selectBackground", ACCENT)
    root.option_add("*TCombobox*Entry.selectForeground", "#171717")
    root.option_add("*TCombobox*Entry.insertBackground", TEXT)
    style.configure("Ghost.TButton", background="#404040", foreground=TEXT, font=FONT,
                    borderwidth=0, padding=(12, 7))
    style.map("Ghost.TButton", background=[("active", "#2c3342")])

    # header: slim toolbar (About/updates live at bottom-right now)
    header = ttk.Frame(root, padding=(10, 4))
    header.pack(fill="x")
    try:
        _lg = _local_logo((36, 36))
        if _lg is not None:
            from PIL import ImageTk as _ITk
            _lph = _ITk.PhotoImage(_lg)
            state["logo_photo"] = _lph
            tk.Label(header, image=_lph, bg=BG).pack(side="left", padx=(0, 12))
    except Exception:
        pass
    mkbtn(header, text="Open", style="Accent.TButton",
               command=lambda: pick()).pack(side="left")
    renamebtn = mkbtn(header, text="Rename", style="Ghost.TButton",
                      command=lambda: show_rename())
    renamebtn.pack(side="left", padx=(8, 0))
    try:
        renamebtn.config(state="disabled")
    except Exception:
        pass
    batchbtn = mkbtn(header, text="Batch", style="Ghost.TButton",
                     command=lambda: pick_many())
    batchbtn.pack(side="left", padx=(8, 0))
    undobtn = mkbtn(header, text="Undo", style="Ghost.TButton",
                    command=lambda: undo_last_rename())
    undobtn.pack(side="left", padx=(8, 0))
    try:
        undobtn.config(state="disabled")
    except Exception:
        pass
    def _open_tools_menu():
        # Top "Tools" dropdown: actions registered later (extract/build...).
        import tkinter as _tk2
        m = _tk2.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                      activebackground=ACCENT, activeforeground="#171717")
        acts = state.get("tools_actions") or []
        r = state.get("result") or {}
        # Tools are per file: PS4 PKGs get the built-in engine.
        # PS5 files are view-only (no extract/build, no outside tools).
        _path = r.get("path") or ""
        _isfile = os.path.isfile(_path)
        _is_ps4pkg = (r.get("kind") == "ps4") and _isfile
        _is_ps5 = (r.get("kind") == "ps5")
        if not r:
            # nothing loaded: only tools that ask for their own input
            m.add_command(label="Extract (PS4)...",
                          command=lambda: extract_ps4_pick())
            m.add_command(label="Build from .gp4...",
                          command=lambda: build_pkg())
        elif _is_ps4pkg:
            if isinstance(acts, dict):
                for _group, _items in acts.items():
                    for _lbl, _fn in (_items or []):
                        m.add_command(label=_lbl, command=_fn)
            else:
                for _lbl, _fn in acts:
                    m.add_command(label=_lbl, command=_fn)
        elif _is_ps5:
            m.add_command(label="(PS5 is view-only)",
                          command=lambda: statusvar.set(
                              "PS5 files are view-only (no extract/build)"))
        else:
            m.add_command(label="(no tools for this file type)",
                          command=lambda: statusvar.set("Extract/Build is PS4 only"))
        try:
            x, y = toolsbtn.winfo_rootx(), toolsbtn.winfo_rooty() + toolsbtn.winfo_height() + 4
            m.tk_popup(x, y)
        finally:
            try:
                m.grab_release()
            except Exception:
                pass
    toolsbtn = mkbtn(header, text="Tools \u25be", style="Ghost.TButton",
                     command=lambda: _open_tools_menu())
    toolsbtn.pack(side="left", padx=(8, 0))
    def toggle_pin(force=None):
        # always-on-top toggle (Pin button, header right)
        try:
            cur = bool(root.attributes("-topmost"))
        except Exception:
            cur = False
        on = (not cur) if force is None else bool(force)
        try:
            root.attributes("-topmost", on)
        except Exception:
            return
        state["pinned"] = on
        try:
            pinbtn.config(text="Pinned" if on else "Pin")
        except Exception:
            pass
        try:
            _save_settings({"pinned": on})
        except Exception:
            pass
    pinbtn = mkbtn(header, text="Pin", style="Ghost.TButton",
                   command=lambda: toggle_pin())
    pinbtn.pack(side="right", padx=(0, 8))
    state["pinbtn"] = pinbtn
    def toggle_cover(force=None):
        # coverless mode: hide the whole left column (cover + title +
        # format) and shrink the window down to the right column, so no
        # empty space is left behind. Saved.
        try:
            hidden = bool(state.get("cover_hidden"))
        except Exception:
            hidden = False
        hide = (not hidden) if force is None else bool(force)
        try:
            if hide:
                try:
                    _cw, _ch = root.winfo_width(), root.winfo_height()
                    if _cw > 100 and _ch > 100:
                        state["cover_saved_geo"] = (_cw, _ch)
                except Exception:
                    pass
                left.grid_remove()
                # file path drops to a wrapped row under the buttons
                try:
                    _pl = state.get("pathlabel")
                    _sh = state.get("subheader")
                    if _pl is not None:
                        _pl.pack_forget()
                    if _sh is not None:
                        _sh.pack(fill="x", padx=12, pady=(0, 4), before=body)
                except Exception:
                    pass
                try:
                    if root.winfo_viewable():
                        # shrink-wrap like the old compact mode: the right
                        # column fills, so req alone never shrinks — cap it
                        root.update_idletasks()
                        _w = min(max(root.winfo_reqwidth(), 360), 620)
                        _h = min(max(root.winfo_reqheight(), 280), 430)
                        root.geometry("%dx%d" % (_w, _h))
                        root.minsize(_w, _h)
                except Exception:
                    pass
            else:
                left.grid()
                # file path back into the header button row
                try:
                    _pl = state.get("pathlabel")
                    _sh = state.get("subheader")
                    if _sh is not None:
                        _sh.pack_forget()
                    if _pl is not None:
                        _pl.pack(side="left", padx=(14, 0))
                except Exception:
                    pass
                try:
                    if root.winfo_viewable():
                        root.update_idletasks()
                        _sg = state.get("cover_saved_geo")
                        if _sg and _sg[0] > 100 and _sg[1] > 100:
                            root.geometry("%dx%d" % _sg)
                            root.minsize(_sg[0], _sg[1])
                        else:
                            root.geometry("880x410")
                            root.minsize(880, 410)
                except Exception:
                    pass
        except Exception:
            return
        state["cover_hidden"] = hide
        try:
            coverbtn.config(text="Show cover" if hide else "Hide cover")
        except Exception:
            pass
        try:
            _save_settings({"cover_hidden": hide})
        except Exception:
            pass
    coverbtn = mkbtn(header, text="Hide cover", style="Ghost.TButton",
                   command=lambda: toggle_cover())
    coverbtn.pack(side="right", padx=(0, 8))
    state["coverbtn"] = coverbtn
    pathvar = tk.StringVar(value="Drop a .pkg / .iso / .exfat / .ffpfsc / .ffpkg / .nsp / .xci file or app folder here")
    pathlabel = ttk.Label(header, textvariable=pathvar, font=FONT_SMALL, foreground=MUTED)
    pathlabel.pack(side="left", padx=(14, 0))
    state["pathlabel"] = pathlabel
    # second header row for coverless mode: the file path moves down
    # here (wrapped) instead of being clipped in the narrow window.
    # (Tk can't reparent a widget, so two labels share one textvar.)
    subheader = ttk.Frame(root)
    state["subheader"] = subheader
    subpathlabel = ttk.Label(subheader, textvariable=pathvar,
                             font=FONT_SMALL, foreground=MUTED,
                             wraplength=590, justify="left")
    subpathlabel.pack(anchor="w", fill="x")

    # bottom bar FIRST (packed before body) so it stays pinned at the
    # bottom no matter how small the window gets
    bottombar = ttk.Frame(root)
    bottombar.pack(fill="x", side="bottom")
    statusvar = tk.StringVar(value="Ready")
    _status_lbl = tk.Label(bottombar, textvariable=statusvar, bg=BG, fg=MUTED,
                           font=FONT_SMALL, anchor="w", justify="left",
                           padx=12, pady=3)
    _status_lbl.pack(side="left", fill="x", expand=True)
    # small About / updates buttons, bottom-right (PKG Sender style)
    updatebtn = mkbtn(bottombar, text="Check updates", style="Ghost.TButton",
                      bg=BG, font=(FONT[0], 8),
                      command=lambda: check_updates(manual=True))
    updatebtn.pack(side="right", padx=(0, 8), pady=2)
    mkbtn(bottombar, text="About", style="Ghost.TButton", bg=BG,
          font=(FONT[0], 8),
          command=lambda: show_about()).pack(side="right", padx=(0, 4), pady=2)
    # wrap status text on narrow windows instead of clipping it
    bottombar.bind("<Configure>",
                   lambda e: _status_lbl.config(wraplength=max(200, e.width - 24)))

    def _kill_children():
        # worker jobs (extract/build) must not outlive the app —
        # including children they spawned (Sony SDK tools)
        try:
            for q in list(state.get("child_procs") or []):
                try:
                    if q.poll() is None:
                        try:
                            _kill_tree(q.pid)
                        except Exception:
                            pass
                        if q.poll() is None:
                            q.kill()
                except Exception:
                    pass
            state["child_procs"] = []
        except Exception:
            pass

    def _on_app_close():
        _kill_children()
        try:
            root.destroy()
        except Exception:
            pass
    try:
        root.protocol("WM_DELETE_WINDOW", _on_app_close)
    except Exception:
        pass

    # body
    body = ttk.Frame(root, padding=(10, 2))
    body.pack(fill="both", expand=True)
    body.columnconfigure(1, weight=1)
    body.rowconfigure(0, weight=1)

    # ---- hero: cover + title/badges (left) ----
    left = ttk.Frame(body, style="Card.TFrame", padding=8)
    left.grid(row=0, column=0, sticky="ns", padx=(0, 10))
    imgframe = tk.Frame(left, bg=CARD, width=240, height=240)
    imgframe.pack(pady=(6, 0))
    imgframe.pack_propagate(False)
    state["imgframe"] = imgframe
    imglabel = tk.Label(imgframe, bg=CARD, fg=MUTED,
                        text="Drop a file or folder here\n\nor click Open",
                        font=FONT_MID, justify="center")
    imglabel.place(relx=0.5, rely=0.5, anchor="center")
    titlerow = tk.Frame(left, bg=CARD)
    titlerow.pack(pady=(6, 4), anchor="w", fill="x")
    state["titlerow"] = titlerow
    fmtlabel = tk.Label(titlerow, bg=CARD, fg=MUTED, text="")
    fmtlabel.pack(side="left", padx=(0, 8), anchor="n")
    state["fmtlabel"] = fmtlabel
    # selectable + wrapping title: read-only Text (Entry can't wrap,
    # Label can't be selected)
    _titletext = tk.Text(titlerow, bg=CARD, fg=TEXT,
                         font=(FONT[0], 11, "bold"),
                         wrap="word", height=2, width=24,
                         relief="flat", borderwidth=0,
                         highlightthickness=0,
                         selectbackground=ACCENT,
                         selectforeground="#171717",
                         insertbackground=TEXT)
    _titletext.pack(side="left", anchor="w", fill="x", expand=True)
    _titletext.insert("1.0", "—")

    def _title_value():
        try:
            v = _titletext.get("1.0", "end-1c").strip()
        except Exception:
            v = ""
        return "" if v in ("", "—", "-") else v

    def _copy_title(whole=False):
        # Ctrl+C / right-click: copy the selected part, or the whole game
        # name when there is no selection
        try:
            txt = ""
            if not whole:
                try:
                    txt = _titletext.get("sel.first", "sel.last")
                except Exception:
                    txt = ""
            if not txt.strip():
                txt = _title_value()
            if not txt:
                return "break"
            root.clipboard_clear()
            root.clipboard_append(txt)
            statusvar.set("Title copied")
        except Exception as ex:
            try:
                statusvar.set(f"Copy failed: {ex}")
            except Exception:
                pass
        return "break"

    def _select_title():
        try:
            _titletext.tag_add("sel", "1.0", "end-1c")
            _titletext.mark_set("insert", "1.0")
        except Exception:
            pass
        return "break"

    def _titlekey(ev):
        # read-only: arrows pass, Ctrl+C / Ctrl+A handled here, everything
        # else blocked. keycode-based so Persian/Arabic layouts (where the
        # C keysym differs) still copy.
        try:
            if (ev.state & 0x4) != 0:
                kc = getattr(ev, "keycode", 0)
                ks = (ev.keysym or "").lower()
                if kc == 67 or ks == "c":
                    return _copy_title()
                if kc == 65 or ks == "a":
                    return _select_title()
                return "break"
        except Exception:
            pass
        if (ev.keysym or "") in ("Left", "Right", "Up", "Down",
                                 "Home", "End", "Prior", "Next"):
            return None
        return "break"
    _titletext.bind("<KeyPress>", _titlekey)
    # right-click menu on the title (the widget is read-only, so there was
    # nothing to click before; selection still works with the mouse)
    _titlectx = tk.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                        activebackground=ACCENT, activeforeground="#171717")
    _titlectx.add_command(label="Copy", command=_copy_title)
    _titlectx.add_command(label="Copy whole title",
                          command=lambda: _copy_title(whole=True))
    _titlectx.add_command(label="Select all", command=_select_title)

    def _titlemenu(ev):
        try:
            _titletext.focus_set()
        except Exception:
            pass
        try:
            _titlectx.tk_popup(ev.x_root, ev.y_root)
        finally:
            try:
                _titlectx.grab_release()
            except Exception:
                pass
        return "break"
    _titletext.bind("<Button-3>", _titlemenu)
    _titletext.bind("<Control-Button-1>", _titlemenu)  # mac right-click
    def _fit_title_height():
        # Recompute visible lines at the CURRENT widget width. The width
        # can change after load (window resize, DPI, late geometry), so a
        # one-time measurement goes stale and wraps extra lines into an
        # invisible scroll. Never raises; no-op when height is already right
        # (this guard also stops <Configure> feedback loops).
        # NOTE: count -displaylines up to "end-1c" counts WRAPS (one short);
        # up to "end" it counts true display lines (wraps + final newline).
        try:
            _titletext.update_idletasks()
            try:
                _nl = _titletext.count("1.0", "end", "displaylines")
                _nl = _nl[0] if isinstance(_nl, tuple) else int(_nl or 1)
            except Exception:
                _nl = 1
            _h = min(4, max(1, _nl))
            try:
                _cur = int(_titletext.cget("height"))
            except Exception:
                _cur = -1
            if _cur != _h:
                _titletext.config(height=_h)
        except Exception:
            pass
    # refit whenever the widget width changes (debounced to idle)
    _titletext.bind("<Configure>",
                    lambda _e: _titletext.after_idle(_fit_title_height))
    def _set_title(t):
        try:
            _titletext.delete("1.0", "end")
            _titletext.insert("1.0", t or "—")
            # auto-height (1-4 lines) so a short title doesn't leave
            # empty lines below it, while long game names stay fully
            # visible instead of clipping into an invisible scroll
            _fit_title_height()
            try:
                _titletext.yview_moveto(0.0)
            except Exception:
                pass
        except Exception:
            pass
    state["titletext"] = _titletext
    badgevars = [tk.StringVar(value="") for _ in range(5)]
    state["badges"] = badgevars
    state["badge_labels"] = []
    # image stepping helper (Images tab buttons use this)
    state["imgnames"] = []
    def _step_image(d):
        vals = list(state.get("imgnames") or [])
        if not vals:
            return
        try:
            i = vals.index(state.get("img_name"))
        except ValueError:
            i = 0
        i = (i + d) % len(vals)
        show_image(vals[i])

    # right column
    right = ttk.Frame(body)
    right.grid(row=0, column=1, sticky="nsew")
    right.rowconfigure(1, weight=1)
    right.columnconfigure(0, weight=1)

    state["spec_cells"] = []

    nb = ttk.Notebook(right)
    nb.pack(fill="both", expand=True)
    state["notebook"] = nb
    tab_entries = ttk.Frame(nb)
    tab_info = ttk.Frame(nb)
    nb.add(tab_info, text="  Info  ")
    nb.add(tab_entries, text="  Files  ")
    # Info tab (merged Specs+Details): scrollable; CONTENT ID bar,
    # CONTENT ID bar, update banner, spec grid, details text.
    # Nothing is shown twice.
    infocanvas = tk.Canvas(tab_info, bg=CARD, borderwidth=0,
                           highlightthickness=0)
    infoscroll = ttk.Scrollbar(tab_info, orient="vertical",
                               command=infocanvas.yview)
    infocanvas.configure(yscrollcommand=infoscroll.set)
    infoscroll.pack(side="right", fill="y")
    infocanvas.pack(side="left", fill="both", expand=True)
    infobody = ttk.Frame(infocanvas, style="Card.TFrame")
    _info_win = infocanvas.create_window((0, 0), window=infobody, anchor="nw")

    def _info_region(_ev=None):
        try:
            infocanvas.configure(scrollregion=infocanvas.bbox("all"))
        except Exception:
            pass
    infobody.bind("<Configure>", _info_region)

    def _info_width(ev):
        try:
            # stretch the body to the viewport height so the
            # bottom-anchored section sits at the bottom when short
            infocanvas.itemconfig(_info_win, width=ev.width,
                                  height=max(infobody.winfo_reqheight(),
                                             ev.height))
        except Exception:
            pass
    infocanvas.bind("<Configure>", _info_width)

    def _info_wheel(ev):
        try:
            infocanvas.yview_scroll(-1 * (ev.delta // 120), "units")
        except Exception:
            pass
        return "break"
    infobody.bind("<Enter>",
                  lambda _e: infocanvas.bind_all("<MouseWheel>", _info_wheel))
    infobody.bind("<Leave>",
                  lambda _e: infocanvas.unbind_all("<MouseWheel>"))
    tab_specs = ttk.Frame(infobody, style="Card.TFrame")
    tab_specs.pack(side="top", fill="x")
    # bottom-anchored section: badges + details stay glued to the
    # bottom of the tab even when the spec grid above is short
    tab_bottom = ttk.Frame(infobody, style="Card.TFrame")
    tab_bottom.pack(side="bottom", fill="x")
    tab_meta = ttk.Frame(tab_bottom, style="Card.TFrame")
    tab_meta.pack(fill="x")
    # CONTENT ID bar on top: full value on its own row (never
    # truncated) with a tiny copy button just for it
    cidrow = ttk.Frame(tab_specs, style="Card.TFrame")
    cidrow.pack(fill="x", pady=(0, 2))
    ttk.Label(cidrow, text="CONTENT ID", style="SpecKey.TLabel").pack(
        side="left", padx=(6, 6))
    state["cidvar"] = tk.StringVar(value="")
    cidentry = tk.Entry(cidrow, textvariable=state["cidvar"], bg=CARD2,
                        fg=TEXT, font=("Consolas", 9), relief="flat",
                        readonlybackground=CARD2, highlightthickness=0,
                        state="readonly")
    cidentry.pack(side="left", fill="x", expand=True)
    def _copy_cid():
        try:
            v = state.get("cidvar", tk.StringVar(value="")).get()
            if not v:
                return
            root.clipboard_clear()
            root.clipboard_append(v)
            statusvar.set("Content ID copied")
        except Exception:
            pass
    mkbtn(cidrow, text="Copy", style="Ghost.TButton", bg=CARD,
          kind="mini", font=(FONT[0], 9),
          command=_copy_cid).pack(side="left", padx=(6, 8))
    state["cidrow"] = cidrow
    # Specs tab: the classic 2-column grid (PACKAGE/SIGNATURE/...)
    # for whoever wants the fine details at a glance
    specbox = ttk.Frame(tab_specs, style="Card.TFrame", padding=(6, 2, 6, 2))
    specbox.pack(fill="x", pady=(0, 2))
    state["specbox"] = specbox
    state["spec_cells"] = []  # rebuilt per file (see load())
    # Update banner below the grid (patch status). Hidden until
    # patch info arrives (see refresh_details).
    updrow = ttk.Frame(tab_specs, style="Card.TFrame")
    updrow.pack(fill="x", pady=(0, 2))
    ttk.Label(updrow, text="UPDATES", style="SpecKey.TLabel").pack(
        side="left", padx=(6, 6))
    state["updvar"] = tk.StringVar(value="")
    updentry = tk.Entry(updrow, textvariable=state["updvar"], bg=CARD2,
                        fg="#f0b429", font=FONT_SMALL, relief="flat",
                        readonlybackground=CARD2, highlightthickness=0,
                        state="readonly")
    updentry.pack(side="left", fill="x", expand=True)
    state["updentry"] = updentry
    mkbtn(updrow, text="Copy link", style="Ghost.TButton", bg=CARD,
          kind="mini", font=(FONT[0], 9),
          command=lambda: copy_update_link()).pack(side="left", padx=(6, 8))
    state["updrow"] = updrow
    updrow.pack_forget()  # shown once patch info arrives
    # badge strip: top of the bottom-anchored section (above details)
    detbadgerow = ttk.Frame(tab_bottom, style="TFrame")
    detbadgerow.pack(fill="x", before=tab_meta)
    _blabs = []
    for _bv in state["badges"]:
        _lb = mkpill(detbadgerow, textvariable=_bv, parent_bg=BG,
                     font=(FONT[0], 9, "bold"), padx=10, pady=3)
        # start hidden (empty): load() packs only the non-empty ones
        _lb.pack_forget()
        _blabs.append(_lb)
    state["badge_labels"] = _blabs
    tab_troph = ttk.Frame(nb)
    tab_images = ttk.Frame(nb)
    nb.add(tab_images, text="  Images  ")
    nb.add(tab_troph, text="  Trophies  ")
    state["troph_tab"] = tab_troph
    state["images_tab"] = tab_images
    # Images tab: button row on TOP (always visible), preview below it.
    # (Buttons used to sit at the bottom, where a tall image pushed
    # them out of view — this tab has no scrollbar.)
    _imgbody = ttk.Frame(tab_images, style="Card.TFrame")
    _imgbody.pack(fill="both", expand=True)
    _imgbar = ttk.Frame(_imgbody, style="Card.TFrame")
    _imgbar.pack(fill="x", pady=(0, 6))
    mkbtn(_imgbar, text="< Prev", style="Ghost.TButton", bg=CARD,
          command=lambda: _step_image(-1)).pack(side="left")
    mkbtn(_imgbar, text="Next >", style="Ghost.TButton", bg=CARD,
          command=lambda: _step_image(1)).pack(side="left", padx=(6, 0))
    state["imgcombo"] = tk.StringVar(value="")
    imgcombo = ttk.Combobox(_imgbar, textvariable=state["imgcombo"],
                            state="readonly", width=16)
    imgcombo.pack(side="left", padx=(6, 0))
    imgcombo.bind("<<ComboboxSelected>>",
                  lambda _e: show_image(state["imgcombo"].get()))
    state["imgcombo_w"] = imgcombo
    mkbtn(_imgbar, text="Save", style="Ghost.TButton", bg=CARD,
          command=lambda: save_current_image()).pack(side="left", padx=(6, 0))
    mkbtn(_imgbar, text="Copy", style="Ghost.TButton", bg=CARD,
          command=lambda: copy_current_image()).pack(side="left", padx=(6, 0))
    state["imgtabcount"] = tk.StringVar(value="No images")
    tk.Label(_imgbar, textvariable=state["imgtabcount"], bg=CARD, fg=MUTED,
             font=FONT_SMALL).pack(side="right")
    imgtablabel = tk.Label(_imgbody, bg=CARD, fg=MUTED, font=FONT_MID,
                           text="(no image)")
    imgtablabel.pack(fill="both", expand=True)
    state["imgtablabel"] = imgtablabel
    def _sync_imgtab():
        # mirror the current cover into the Images tab preview
        try:
            lbl = state.get("imgtablabel")
            if lbl is None:
                return
            pil = state.get("pil")
            if pil is None:
                lbl.config(image="", text="(no image)")
                return
            try:
                from PIL import ImageTk as _ITk
            except Exception:
                lbl.config(image="", text="(no preview)")
                return
            im = pil.copy()
            try:
                _w0, _h0 = pil.size
            except Exception:
                _w0 = _h0 = 0
            # square covers (icon0 etc.) stretch to all the space the
            # tab offers; wide/tall banners keep their fixed boxes
            try:
                _ratio = (_w0 / _h0) if _h0 else 1.0
            except Exception:
                _ratio = 1.0
            if 0.9 <= _ratio <= 1.1:
                try:
                    lbl.update_idletasks()
                    _aw, _ah = lbl.winfo_width(), lbl.winfo_height()
                except Exception:
                    _aw = _ah = 0
                if _aw < 50 or _ah < 50:
                    _box = (300, 300)
                else:
                    _box = (max(_aw - 8, 200), max(_ah - 8, 200))
            elif _ratio > 1.1:
                _box = (480, 270)
            else:
                _box = (260, 340)
            im.thumbnail(_box)
            ph = _ITk.PhotoImage(im)
            state["imgtabphoto"] = ph
            lbl.config(image=ph, text="")
            lbl.image = ph
        except Exception:
            pass
    def _fill_imgtab(names):
        try:
            cb = state.get("imgcombo_w")
            if cb is None:
                return
            cb["values"] = list(names or [])
            if names:
                state["imgcombo"].set(names[0])
            else:
                state["imgcombo"].set("")
            state["imgtabcount"].set(
                f"{len(names)} images" if len(names) != 1 else "1 image")
        except Exception:
            pass
    trophsumvar = tk.StringVar(value="No trophies loaded")
    state["trophsumvar"] = trophsumvar
    _trophbar = ttk.Frame(tab_troph, style="Card.TFrame")
    _trophbar.pack(fill="x", pady=(0, 4))
    tk.Label(_trophbar, textvariable=trophsumvar, bg=CARD, fg=MUTED,
             font=FONT_SMALL, anchor="w", padx=10, pady=6).pack(side="left",
                                                                fill="x",
                                                                expand=True)
    mkbtn(_trophbar, text="Save icons...", style="Ghost.TButton", bg=CARD,
          command=lambda: save_trophy_icons()).pack(side="right",
                                                    padx=(0, 8))
    _tbody = ttk.Frame(tab_troph, style="Card.TFrame")
    _tbody.pack(fill="both", expand=True)
    trotv = ttk.Treeview(_tbody, columns=("id", "grade", "name"),
                         show="headings", height=14)
    trotv.heading("id", text="ID")
    trotv.heading("grade", text="Grade")
    trotv.heading("name", text="Name")
    trotv.column("id", width=40, anchor="center")
    trotv.column("grade", width=55, anchor="center")
    trotv.column("name", width=260)
    trotv.pack(side="left", fill="both", expand=True)
    _troprev = ttk.Frame(_tbody, style="Card.TFrame", width=175)
    _troprev.pack(side="right", fill="y", padx=(8, 0))
    _troprev.pack_propagate(False)
    # scrollable preview: banner + icon never get clipped on short windows
    _trocanvas = tk.Canvas(_troprev, bg=CARD, borderwidth=0,
                           highlightthickness=0, width=150)
    _troscroll = ttk.Scrollbar(_troprev, orient="vertical",
                               command=_trocanvas.yview)
    _trocanvas.configure(yscrollcommand=_troscroll.set)
    _troscroll.pack(side="right", fill="y")
    _trocanvas.pack(side="left", fill="both", expand=True)
    _troinner = tk.Frame(_trocanvas, bg=CARD)
    _trocanvas.create_window((0, 0), window=_troinner, anchor="nw")

    def _tro_scrollregion(_ev=None):
        try:
            _trocanvas.configure(scrollregion=_trocanvas.bbox("all"))
        except Exception:
            pass

    _troinner.bind("<Configure>", _tro_scrollregion)
    _trocanvas.bind("<MouseWheel>",
                    lambda _ev: _trocanvas.yview_scroll(
                        -1 * (_ev.delta // 120), "units"))
    trobanlbl = tk.Label(_troinner, bg=CARD, borderwidth=0,
                         highlightthickness=0)
    trobanlbl.pack(pady=(0, 4))
    # no fixed width/height: the label sizes to the image (no cropping)
    troimglbl = tk.Label(_troinner, bg=CARD, fg=MUTED, font=FONT_SMALL,
                         text="(no icon)")
    troimglbl.pack(pady=(0, 4))
    state["trotv"] = trotv
    state["troimglbl"] = troimglbl
    state["trobanlbl"] = trobanlbl
    trodetvar = tk.StringVar(value="Select a trophy for details")
    state["trodetvar"] = trodetvar
    tk.Label(tab_troph, textvariable=trodetvar, bg=CARD, fg=TEXT,
             font=FONT_SMALL, anchor="w", justify="left",
             wraplength=640, padx=10, pady=6).pack(fill="x", pady=(4, 0))
    state["trophy_path"] = None
    state["trophy_data"] = None

    tree = ttk.Treeview(tab_entries, columns=("id", "size", "codec"), show="tree headings")
    tree.heading("#0", text="name", anchor="w")
    tree.heading("id", text="id", anchor="w")
    tree.heading("size", text="size", anchor="e")
    tree.heading("codec", text="codec", anchor="w")
    tree.column("#0", width=300)
    tree.column("id", width=60)
    tree.column("size", width=110, anchor="e")
    tree.column("codec", width=120)
    sb = ttk.Scrollbar(tab_entries, orient="vertical", command=tree.yview)
    tree.configure(yscrollcommand=sb.set)
    sb.pack(side="right", fill="y")
    tree.pack(side="left", fill="both", expand=True)

    def _srcdir():
        # default save/extract folder: next to the opened file/folder
        try:
            _p = (state.get("result") or {}).get("path") or ""
            if _p:
                _d = os.path.abspath(_p)
                if os.path.isfile(_d):
                    _d = os.path.dirname(_d)
                if os.path.isdir(_d):
                    return _d
        except Exception:
            pass
        return "."

    def extract_single():
        # Extract one Files-tab entry with rename (save-as dialog), streamed.
        import threading as _th
        from tkinter import filedialog as _fd
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        sel = tree.selection()
        if not sel:
            statusvar.set("Select a file in the Files tab")
            return
        _iid = sel[0]
        # trophy-inner file: slice it out of the parent TRP entry
        if _iid in (state.get("trp_children") or {}):
            try:
                _pi, _in = state["trp_children"][_iid]
                _pe = r["entries"][_pi]
                _td = None
                if _pe.get("cached") is not None:
                    _td = bytes(_pe["cached"])
                elif isinstance(_pe.get("abs_off"), int) and _pe["abs_off"] >= 0:
                    _td = read_entry_bytes(r["path"], _pe["abs_off"],
                                           _pe["size"], limit=300_000_000)
                if not _td:
                    raise OSError("unreadable TRP")
                out = _fd.asksaveasfilename(title="Extract file as",
                                            initialdir=_srcdir(),
                                            initialfile=_in["name"],
                                            filetypes=[("All files", "*.*")])
                if not out:
                    return
                with open(out, "wb") as fw:
                    fw.write(_td[_in["off"]:_in["off"] + _in["size"]])
                statusvar.set(f"Extracted {_in['name']} "
                              f"({fmt_size(_in['size'])})")
            except Exception as ex:
                statusvar.set(f"Extract failed: {ex}")
            return
        if not (_iid[:1] == "e" and _iid[1:].isdigit()):
            statusvar.set("Select a file (a folder is selected)")
            return
        try:
            e = r["entries"][int(_iid[1:])]
        except Exception:
            statusvar.set("Bad selection")
            return
        nm = (e.get("name") or "").strip() or f"entry_{e.get('id', 0)}"
        if e.get("size", 0) <= 0:
            statusvar.set("Empty entry — nothing to extract")
            return
        safe = nm.replace("/", "_").replace("\\", "_")
        out = _fd.asksaveasfilename(title="Extract file as",
                                    initialdir=_srcdir(),
                                    initialfile=safe,
                                    filetypes=[("All files", "*.*")])
        if not out:
            return

        def _work():
            try:
                total = e.get("size", 0)
                if e.get("local_path") and os.path.isfile(e["local_path"]):
                    with open(e["local_path"], "rb") as fh:
                        data = fh.read()
                    with open(out, "wb") as fw:
                        fw.write(data)
                    done = len(data)
                elif e.get("cached") is not None:
                    with open(out, "wb") as fw:
                        fw.write(e["cached"])
                    done = len(e["cached"])
                elif isinstance(e.get("abs_off"), int) and e["abs_off"] >= 0:
                    done = 0
                    with open(r["path"], "rb") as fh, open(out, "wb") as fw:
                        fh.seek(e["abs_off"])
                        left = total
                        while left > 0:
                            buf = fh.read(min(64 * 1024 * 1024, left))
                            if not buf:
                                break
                            fw.write(buf)
                            done += len(buf)
                            left -= len(buf)
                else:  # PS3-crypto / exfat chains: whole-read fallback
                    data = read_entry_bytes(r["path"], e["abs_off"], total,
                                            limit=2_000_000_000)
                    if not data:
                        raise OSError("unreadable entry")
                    with open(out, "wb") as fw:
                        fw.write(data)
                    done = len(data)
                root.after(0, statusvar.set,
                           f"Extracted {safe} ({fmt_size(done)})")
            except Exception as ex:
                root.after(0, statusvar.set, f"Extract failed: {ex}")

        statusvar.set(f"Extracting {safe}...")
        _th.Thread(target=_work, daemon=True).start()

    filectx = tk.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                      activebackground=ACCENT, activeforeground="#171717")
    filectx.add_command(label="Extract...",
                        command=lambda: extract_single())
    filectx.add_command(label="View trophies",
                        command=lambda: show_trophies())
    dirctx = tk.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                     activebackground=ACCENT, activeforeground="#171717")

    def _dir_set_open(open_it):
        try:
            sel = tree.selection()
            if sel and sel[0][:1] == "d":
                tree.item(sel[0], open=bool(open_it))
        except Exception:
            pass

    dirctx.add_command(label="Expand", command=lambda: _dir_set_open(True))
    dirctx.add_command(label="Collapse", command=lambda: _dir_set_open(False))

    def _tree_menu(ev):
        _iid = tree.identify_row(ev.y)
        if not _iid:
            return
        tree.selection_set(_iid)
        (_dirctx if _iid[:1] == "d" else filectx).tk_popup(ev.x_root, ev.y_root)

    tree.bind("<Button-3>", _tree_menu)
    tree.bind("<Double-Button-1>", lambda ev: _tree_activate())

    def _tree_activate():
        # double-click a folder -> expand/collapse; a .trp pack -> trophy
        # list; anything else -> extract
        try:
            sel = tree.selection()
            if sel and sel[0][:1] == "d":
                _iid = sel[0]
                tree.item(_iid, open=not bool(tree.item(_iid, "open")))
                return
            if sel and sel[0][:1] == "e" and sel[0][1:].isdigit():
                _iid = sel[0]
                _e = state.get("result", {}).get("entries", [])[int(_iid[1:])]
                if (_e.get("name") or "").lower().endswith((".trp", ".ucp")):
                    show_trophies()
                    return
        except Exception:
            pass
        extract_single()

    def _trophy_reset(msg="No trophies loaded"):
        try:
            state["trotv"].delete(*state["trotv"].get_children())
        except Exception:
            pass
        for _k, _v in (("trophsumvar", msg),
                       ("trodetvar", "Select a trophy for details")):
            try:
                state[_k].set(_v)
            except Exception:
                pass
        try:
            state["troimglbl"].config(image="", text="(no icon)")
            state["trobanlbl"].config(image="")
        except Exception:
            pass
        state["trophy_data"] = None

    def _trophy_start(entry, result):
        # decrypt worker for one TRP/UCP entry; fills Trophies tab on done
        import threading as _th

        def _work():
            try:
                if entry.get("cached") is not None:
                    _td = bytes(entry["cached"])
                elif entry.get("local_path") and os.path.isfile(
                        entry["local_path"]):
                    with open(entry["local_path"], "rb") as _fh:
                        _td = _fh.read(300_000_000)
                else:
                    _td = read_entry_bytes(result["path"], entry["abs_off"],
                                           entry["size"], limit=300_000_000)
                if not _td:
                    raise OSError("unreadable trophy pack")
                if (entry.get("name") or "").lower().endswith(".ucp"):
                    _npid, _title, _trs, _icons = ucp_trophies(_td)
                    # online grades (background thread, never blocks UI);
                    # ring-color heuristic is the offline fallback.
                    # Guard: use online grades only if most UCP names match.
                    _grades = fetch_exophase_grades(_title)
                    if _grades:
                        try:
                            _hit = sum(1 for _t in _trs
                                       if _norm_name(_t.get("name", ""))
                                       in _grades)
                            if _hit * 2 < len(_trs):
                                _grades = {}
                        except Exception:
                            _grades = {}
                    root.after(0, lambda: _trophy_fill_ucp(
                        entry.get("name", ""), _npid, _trs, _icons, _grades))
                    return
                _inner = parse_trp(_td)
                _cands = [t for t in _inner
                          if t["name"].upper().startswith("TROP")
                          and t["name"].upper().endswith(".ESFM")
                          and t["size"] > 0]
                # language files (TROP_00.ESFM) carry names/details;
                # bare TROP.ESFM only has id/type/hidden skeleton
                def _tkey(t):
                    _un = t["name"].upper()
                    if _un == "TROP.ESFM":
                        return (1, _un)
                    if _un == "TROPCONF.ESFM":
                        return (2, _un)
                    return (0, _un)
                _cands.sort(key=_tkey)
                _npid, _xml, _fallback = None, None, None
                for _t in _cands:
                    _blob = _td[_t["off"]:_t["off"] + _t["size"]]
                    _n, _x = bruteforce_npid(_blob)
                    if _x and _fallback is None:
                        _fallback = (_n, _x)
                    if _x:
                        _ts = parse_trophy_xml(_x)
                        if any(_t2.get("name") for _t2 in _ts):
                            _npid, _xml = _n, _x
                            break
                if _xml is None and _fallback is not None:
                    _npid, _xml = _fallback
                _icons = carve_trp_icons(_td)
                root.after(0, lambda: _trophy_fill(
                    entry.get("name", ""), _npid, _xml, _icons, _td))
            except Exception as ex:
                root.after(0, statusvar.set, f"Trophy failed: {ex}")
                try:
                    root.after(0, state.update, {"trophy_loading": None})
                except Exception:
                    pass

        state["trophy_path"] = result["path"]
        _trophy_reset("Decrypting trophies (finding NP ID)...")
        state["trophy_loading"] = result["path"]
        statusvar.set("Decrypting trophies (finding NP ID)...")
        _th.Thread(target=_work, daemon=True).start()

    def _trophy_pick(entries):
        # prefer real trophy packs (trophy*.trp/ucp) over misc packs (uds*.ucp)
        cands = [x for x in (entries or [])
                 if (x.get("name") or "").lower().endswith((".trp", ".ucp"))
                 and x.get("size", 0) > 0]
        if not cands:
            return None
        cands.sort(key=lambda x: ("trophy" not in (x.get("name") or "").lower(),
                                  (x.get("name") or "")))
        return cands[0]

    def show_trophies():
        # jump to the Trophies tab (auto-filled on load); start the
        # worker here too if the tab isn't filled for this file yet.
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        if state.get("trophy_loading") == r["path"]:
            try:
                nb.select(state["troph_tab"])
            except Exception:
                pass
            return
        sel = tree.selection()
        _e = None
        if sel:
            _iid = sel[0]
            if _iid.startswith("e") and "c" not in _iid:
                try:
                    _e = r["entries"][int(_iid[1:])]
                except Exception:
                    _e = None
        if _e is None or not (_e.get("name") or "").lower().endswith((".trp", ".ucp")):
            _e = _trophy_pick(r["entries"])
        try:
            nb.select(state["troph_tab"])
        except Exception:
            pass
        if _e is None:
            _trophy_reset("No trophy pack in this file")
            return
        if state.get("trophy_path") == r["path"] and state.get("trophy_data"):
            return
        _trophy_start(_e, r)

    def _sync_leftcover():
        # Images tab open -> left cover box shows image info text instead
        # of the same picture twice. Same box size: tabs never jump.
        try:
            if nb.select() == str(state.get("images_tab") or "") and \
                    state.get("pil") is not None:
                _nm = str(state.get("img_name") or "")
                try:
                    _w, _h = state["pil"].size
                except Exception:
                    _w = _h = 0
                _pos = ""
                try:
                    _vals = state.get("imgnames") or []
                    _pos = f"{_vals.index(state.get('img_name')) + 1}" \
                        f"/{len(_vals)}"
                except Exception:
                    pass
                _txt = _nm + (f"\n{_w}x{_h}" if _w else "") + \
                    (f"\n{_pos}" if _pos else "")
                imglabel.config(image="", text=_txt or "(no image)")
                return
            _ph = state.get("photo")
            if _ph is not None:
                imglabel.config(image=_ph, text="")
        except Exception:
            pass

    def _on_troph_tab(_ev=None):
        # lazy load: worker starts only when the Trophies tab is opened.
        try:
            _sel = nb.select()
        except Exception:
            return
        try:
            _sync_leftcover()
        except Exception:
            pass
        try:
            # Images tab just opened (or window resized): refit the
            # square preview to the space available
            if _sel == str(state.get("images_tab") or "") and \
                    state.get("pil") is not None:
                _sync_imgtab()
        except Exception:
            pass
        try:
            if _sel != str(state["troph_tab"]):
                return
        except Exception:
            return
        r = state.get("result")
        if not r or state.get("trophy_data"):
            return
        if state.get("trophy_loading") == r["path"]:
            return
        _e = _trophy_pick(r["entries"])
        if _e is None:
            _trophy_reset("No trophy pack in this file")
            return
        _trophy_start(_e, r)

    try:
        nb.bind("<<NotebookTabChanged>>", _on_troph_tab)
    except Exception:
        pass

    def save_trophy_icons():
        # Export every trophy icon (raw PNG bytes from the TRP) to a folder.
        # Files are named "000_Platinum_Trophy.png" etc.
        import threading as _th
        from tkinter import filedialog as _fd
        _dd = state.get("trophy_data") or {}
        _trs, _sq, _td = _dd.get("trs", []), _dd.get("sq", []), _dd.get("td")
        if not _trs or not _sq or _td is None:
            statusvar.set("No trophy icons loaded")
            return
        dest = _fd.askdirectory(title="Save trophy icons to folder",
                                  initialdir=_srcdir())
        if not dest:
            return
        # save into a game-named subfolder, not loose files
        try:
            _rr = state.get("result") or {}
            _gdir = (build_clean_name(_rr)
                     or sanitize_filename_part(_rr.get("title") or "")
                     or os.path.splitext(os.path.basename(_rr.get("path") or ""))[0]
                     or "trophies")
            dest = os.path.join(dest, _gdir)
            os.makedirs(dest, exist_ok=True)
        except Exception as ex:
            statusvar.set(f"Cannot create folder: {ex}")
            return

        def _work():
            try:
                ok, skip = 0, 0
                for _idx, _t in enumerate(_trs):
                    if _idx >= len(_sq) or not _sq[_idx]:
                        skip += 1
                        continue
                    _ic = _sq[_idx]
                    _blob = _td[_ic["off"]:_ic["off"] + _ic["size"]]
                    if _blob[:8] != b"\x89PNG\r\n\x1a\n":
                        skip += 1
                        continue
                    _nm = sanitize_filename_part(
                        f"{_t['id']}_{_t['name'] or 'trophy'}") or f"trophy_{_idx}"
                    with open(os.path.join(dest, _nm + ".png"), "wb") as _fw:
                        _fw.write(_blob)
                    ok += 1
                root.after(0, statusvar.set,
                           f"Saved {ok} trophy icons to {dest}" +
                           (f" ({skip} skipped)" if skip else ""))
            except Exception as ex:
                root.after(0, statusvar.set, f"Save icons failed: {ex}")

        statusvar.set("Saving trophy icons...")
        _th.Thread(target=_work, daemon=True).start()

    def _trophy_fill_ucp(ucp_name, npid, trs, icons, grades=None):
        # fill the Trophies tab from a PS5 .ucp pack (no grades in UCP json).
        # Grade: online lookup first, ring-color heuristic as offline fallback.
        # Packs icon bytes into one blob so the shared preview/export code
        # (td + sq offsets) works unchanged.
        state["trophy_loading"] = None
        if not trs:
            _trophy_reset("No trophies parsed (UCP)")
            return
        _blob = bytearray()
        _sq = []
        for _t in trs:
            # UCP convention (verified vs official PSN art): trop0000 is the
            # trophy SET (title) art; trophy id N -> trop(N+1).png
            # 1:1 with trs (None = no icon) so names never shift out of sync
            _png = None
            try:
                _png = (icons or {}).get(f"trop{int(_t['id']) + 1:04d}.png")
            except Exception:
                _png = (icons or {}).get(f"trop{_t['id']}.png")
            _ok = False
            if _png is not None:
                try:
                    import struct as _st
                    _w, _h = _st.unpack_from(">2I", _png, 16)
                    _sq.append({"off": len(_blob), "size": len(_png),
                                "w": _w, "h": _h})
                    _blob += _png
                    _ok = True
                except Exception:
                    pass
            if not _ok:
                _sq.append(None)
        _td = bytes(_blob)
        _ban = [ic for ic in _sq if ic and ic["w"] != ic["h"]]
        # trop0000 (set/title art) as the preview banner when present
        _setart = (icons or {}).get("trop0000.png")
        if _setart and _setart[:4] == b"\x89PNG":
            try:
                import struct as _st
                _sw, _sh = _st.unpack_from(">2I", _setart, 16)
                _ban = ([{"off": len(_td), "size": len(_setart),
                          "w": _sw, "h": _sh}] + _ban)
                _td = _td + _setart
            except Exception:
                pass
        for _i, _t in enumerate(trs):
            _t["hidden"] = False
            _png = None
            try:
                _png = (icons or {}).get(f"trop{int(_t['id']) + 1:04d}.png")
            except Exception:
                pass
            # online grade first; else ring color with per-pack majority
            # calibration (bronze is always the biggest group)
            _g = (grades or {}).get(_norm_name(_t.get("name", ""))) or ""
            if _g not in ("P", "G", "S", "B"):
                _g = "RING:" + (_ucp_ring(_png) if _png else "")
            _t["type"] = _g
        try:
            from collections import Counter as _Counter
            _votes = _Counter(_t["type"] for _t in trs
                              if str(_t["type"]).startswith("RING:")
                              and _t["type"] != "RING:")
            _big = _votes.most_common(1)
            _big = _big[0][0] if _big else ""
            _rmap = {"RING:gold": "G", "RING:": ""}
            for _rc, _gg in (("RING:gray", "S"), ("RING:copper", "B")):
                if _big and _rc != _big:
                    _rmap[_rc] = _gg
            if _big in ("RING:gray", "RING:copper"):
                _rmap[_big] = "B"
            for _t in trs:
                if str(_t["type"]).startswith("RING:"):
                    _t["type"] = _rmap.get(_t["type"], "")
        except Exception:
            for _t in trs:
                if str(_t["type"]).startswith("RING:"):
                    _t["type"] = ""
        for _t in trs:
            if str(_t["id"]).strip() in ("0000", "0"):
                _t["type"] = "P"
        _have = sum(1 for ic in _sq if ic)
        _imap_note = ""
        if _have != len(trs):
            _imap_note = f" — icons {_have}/{len(trs)}"
        _trophy_reset(f"{len(trs)} trophies (UCP) — {npid or '?'}"
                      f"{_imap_note}")
        # NOTE: set AFTER _trophy_reset (it clears trophy_data)
        state["trophy_data"] = {"trs": trs, "sq": _sq, "td": _td,
                                "npid": npid, "thumbs": []}
        _tv = state["trotv"]
        try:
            _tv.bind("<<TreeviewSelect>>", _tro_on_sel)
        except Exception:
            pass
        try:
            import io as _io
            from PIL import Image as _Img, ImageTk as _ImgTk
            _has_pil = True
        except Exception:
            _has_pil = False
        for _idx, _t in enumerate(trs):
            _gtext = {"P": "Platinum", "G": "Gold",
                      "S": "Silver", "B": "Bronze"}.get(
                          _t["type"], _t["type"]) or "—"
            _kw = {"values": (_t["id"], _gtext, _t["name"])}
            if _has_pil and _idx < len(_sq) and _sq[_idx]:
                try:
                    _ic = _sq[_idx]
                    _tim = _Img.open(_io.BytesIO(
                        _td[_ic["off"]:_ic["off"] + _ic["size"]])).convert(
                        "RGBA")
                    _tim.thumbnail((28, 28))
                    _tph = _ImgTk.PhotoImage(_tim)
                    state["trophy_data"]["thumbs"].append(_tph)
                    _kw["image"] = _tph
                except Exception:
                    pass
            _tv.insert("", "end", **_kw)
        if _ban and _td:
            try:
                import io as _io
                from PIL import Image as _Img, ImageTk as _ImgTk
                _b = _ban[0]
                _bim = _Img.open(_io.BytesIO(
                    _td[_b["off"]:_b["off"] + _b["size"]])).convert("RGB")
                _bim.thumbnail((150, 84))
                _bph = _ImgTk.PhotoImage(_bim)
                state["trobanlbl"].config(image=_bph)
                state["trobanlbl"].image = _bph
            except Exception:
                pass
        try:
            _first = _tv.get_children()[0]
            _tv.selection_set(_first)
            _tro_on_sel()
        except Exception:
            pass

    def _trophy_fill(trp_name, npid, xml, icons=None, td=None):
        # fill the Trophies tab (main thread). Icon label has no fixed
        # size: it wraps the image instead of cropping it.
        state["trophy_loading"] = None
        if not xml:
            try:
                import cryptography  # noqa
                _trophy_reset("NP ID not found (tried NPWR00000-99999_00)")
                statusvar.set("NP ID not found (tried NPWR00000-99999_00)")
            except Exception:
                _trophy_reset("cryptography lib missing — can't decrypt")
                statusvar.set("cryptography lib missing — can't decrypt")
            return
        _trs = parse_trophy_xml(xml)
        if not _trs:
            _trophy_reset("No trophies parsed")
            return
        _grades = {}
        for _t in _trs:
            _grades[_t["type"]] = _grades.get(_t["type"], 0) + 1
        _hid = sum(1 for _t in _trs if _t["hidden"])
        _gtext = " ".join(f"{_grades.get(g, 0)}{g}"
                          for g in ("P", "G", "S", "B") if _grades.get(g))
        # square icons map to trophies in order; wide ones are title banners
        _sq = [ic for ic in (icons or []) if ic["w"] == ic["h"]]
        _ban = [ic for ic in (icons or []) if ic["w"] != ic["h"]]
        _imap_note = ""
        if _sq and len(_sq) != len(_trs):
            _imap_note = f" — icons {len(_sq)}/{len(_trs)} (order-mapped)"
        state["trophy_data"] = {"trs": _trs, "sq": _sq, "td": td,
                                "npid": npid}
        _trophy_reset(f"{len(_trs)} trophies ({_gtext}) — "
                      f"{_hid} hidden — {npid or '?'}"
                      f"{_imap_note}")
        state["trophy_data"] = {"trs": _trs, "sq": _sq, "td": td,
                                "npid": npid}
        _tv = state["trotv"]
        try:
            _tv.bind("<<TreeviewSelect>>", _tro_on_sel)
        except Exception:
            pass
        _GRADE = {"P": "Platinum", "G": "Gold",
                  "S": "Silver", "B": "Bronze"}
        for _t in _trs:
            _nm = _t["name"] + (" (hidden)" if _t["hidden"] else "")
            _tv.insert("", "end",
                       values=(_t["id"],
                               _GRADE.get(_t["type"], _t["type"]), _nm))
        # title banner on top of the preview pane, if the TRP has one
        if _ban and td:
            try:
                import io as _io
                from PIL import Image as _Img, ImageTk as _ImgTk
                _b = _ban[0]
                _bim = _Img.open(_io.BytesIO(
                    td[_b["off"]:_b["off"] + _b["size"]])).convert("RGB")
                _bim.thumbnail((150, 84))
                _bph = _ImgTk.PhotoImage(_bim)
                state["trobanlbl"].config(image=_bph)
                state["trobanlbl"].image = _bph
            except Exception:
                pass
        try:
            _first = _tv.get_children()[0]
            _tv.selection_set(_first)
            _tro_on_sel()
        except Exception:
            pass

    def _tro_on_sel(_ev=None):
        try:
            _tv = state["trotv"]
            _s = _tv.selection()
            if not _s:
                return
            _dd = state.get("trophy_data") or {}
            _trs = _dd.get("trs", [])
            _idx = _tv.index(_s[0])
            _t = _trs[_idx]
            state["trodetvar"].set(
                f"[{_t['id']}] {_t['name']}: {_t['detail'] or '—'}")
            _imglbl = state["troimglbl"]
            _sq = _dd.get("sq", [])
            _td = _dd.get("td")
            if not _sq or _td is None or _idx >= len(_sq) or not _sq[_idx]:
                _imglbl.config(image="", text="(no icon)")
                return
            import io as _io
            from PIL import Image as _Img, ImageTk as _ImgTk
            _ic = _sq[_idx]
            _im = _Img.open(_io.BytesIO(
                _td[_ic["off"]:_ic["off"] + _ic["size"]])).convert("RGBA")
            _im.thumbnail((150, 150))
            _ph = _ImgTk.PhotoImage(_im)
            _imglbl.config(image=_ph, text="")
            _imglbl.image = _ph
        except Exception:
            pass

    # (badge strip lives at bottom of Info tab, below the grid)
    metabar = ttk.Frame(tab_meta, style="Card.TFrame")
    metabar.pack(fill="x", pady=(0, 4))
    detailvar = tk.StringVar(value="Show all")
    mkbtn(metabar, text="Extract all", style="Ghost.TButton", bg=CARD,
          kind="mini", font=(FONT[0], 9),
          command=lambda: extract_all()).pack(side="left")
    mkbtn(metabar, text="Copy info", style="Ghost.TButton", bg=CARD,
          kind="mini", font=(FONT[0], 9),
          command=lambda: copy_all_info()).pack(side="left", padx=(8, 0))
    detailbtn = mkbtn(metabar, textvariable=detailvar, style="Accent.TButton", bg=CARD,
                      kind="mini_accent", font=(FONT[0], 9),
                      command=lambda: toggle_details())
    detailbtn.pack(side="right")
    metatext = tk.Text(tab_meta, bg=CARD, fg=TEXT, font=("Consolas", 8),
                       wrap="word", borderwidth=0, highlightthickness=0, padx=8, pady=6,
                        height=8, selectbackground=ACCENT,
                        selectforeground="#171717", insertbackground=TEXT)
    metatext.pack(fill="both", expand=True)
    metatext.pack_forget()  # shown by refresh_details only when lines exist
    metatext.tag_config("updates", foreground="#f0b429")
    root.bind_all("<KeyPress>", lambda e: _global_ctrl_keys(e, root, statusvar))
    ctxmenu = tk.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                      activebackground=ACCENT, activeforeground="#171717")
    ctxmenu.add_command(label="Copy",
                        command=lambda: copy_text_selection(metatext))
    ctxmenu.add_command(label="Select all",
                        command=lambda: select_all_text(metatext))
    metatext.bind("<Button-3>", lambda e: ctxmenu.tk_popup(e.x_root, e.y_root))

    # (bottombar created up top, before body, so it stays pinned)
    def _set_status(base=None):
        # persistent base (e.g. file entries) + update note, shown together
        try:
            if base is not None:
                state["status_base"] = base
            _b = state.get("status_base", "")
            _n = state.get("update_note", "")
            if _b and _n:
                statusvar.set(_b + "  •  " + _n)
            else:
                statusvar.set(_b or _n or "Ready")
        except Exception:
            pass

    def show_about():
        import webbrowser as _wb
        _ab = tk.Toplevel(root)
        _ab.title("About PKG Viewer")
        _ab.configure(bg=CARD)
        _ab.transient(root)
        _ab.grab_set()
        _ab.resizable(False, False)
        _logo = None
        try:
            from PIL import Image as _Img, ImageTk as _ImgTk
            import os as _os
            _base = getattr(sys, "_MEIPASS", _os.path.dirname(
                _os.path.abspath(__file__)))
            _p = _os.path.join(_base, "assets_about.png")
            if _os.path.exists(_p):
                _im = _Img.open(_p).convert("RGB")
                try:
                    _avg = sum(_im.resize((1, 1)).getpixel((0, 0))) // 3
                except Exception:
                    _avg = 255
                if _avg < 128:
                    # dark-theme logo (black rounded square): show as-is,
                    # smaller than the old light mark
                    _im = _Img.open(_p).convert("RGBA")
                    _w = 120
                    _h = max(1, round(_im.size[1] * _w / _im.size[0]))
                    _logo = _ImgTk.PhotoImage(_im.resize((_w, _h),
                                                         _Img.LANCZOS))
                else:
                    _im = _im.convert("L")
                    # crop to the dark mark, drop the white page background
                    _bbox = _im.point(lambda v: 255 if v < 128 else 0).getbbox()
                    if _bbox:
                        _im = _im.crop(_bbox)
                    # dark mark -> near-white, background -> transparent
                    _a = _im.point(lambda v: 255 - v)
                    _im = _Img.merge("RGBA", (_Img.new("L", _im.size, 0xf1),
                                              _Img.new("L", _im.size, 0xf3),
                                              _Img.new("L", _im.size, 0xf8), _a))
                    _w = 190
                    _h = max(1, round(_im.size[1] * _w / _im.size[0]))
                    _logo = _ImgTk.PhotoImage(_im.resize((_w, _h),
                                                         _Img.LANCZOS))
        except Exception:
            _logo = None
        if _logo is not None:
            tk.Label(_ab, image=_logo, bg=CARD).pack(padx=36, pady=(20, 0))
            _ab._logo_ref = _logo
        tk.Label(_ab, text="PKG Viewer %s" % APP_VERSION,
                 bg=CARD, fg=TEXT, font=FONT).pack(padx=36, pady=(12, 0))
        tk.Label(_ab, text="by Loopayeh",
                 bg=CARD, fg=MUTED, font=FONT_SMALL).pack(pady=(2, 0))
        tk.Label(_ab, text="View PS2 / PS3 / PS4 / PS5 / Switch / Wii U / Xbox 360 package info and cover art.",
                 bg=CARD, fg=TEXT, font=FONT_SMALL).pack(padx=36,
                                                         pady=(12, 0))
        tk.Label(_ab, text="If you enjoy what I build and want to support my work,\n"
                              "you can donate",
                 bg=CARD, fg=TEXT, font=FONT_SMALL, justify="center").pack(padx=36,
                                                                          pady=(12, 0))
        tk.Label(_ab, text="Every bit of support means a lot.\U0001F499",
                 bg=CARD, fg=TEXT, font=FONT_SMALL).pack(pady=(2, 0))
        tk.Label(_ab, text="USDT (BEP-20) — click address to copy:",
                 bg=CARD, fg=MUTED, font=FONT_SMALL).pack(pady=(8, 0))
        _addr = tk.Label(_ab, text=SUPPORT_ADDR,
                         bg=CARD, fg=TEXT, font=FONT_SMALL, cursor="hand2")
        _addr.pack(pady=(2, 0))

        def _copy_addr(_e=None):
            try:
                _ab.clipboard_clear()
                _ab.clipboard_append(SUPPORT_ADDR)
                _addr.config(text="copied ✓")
                _ab.after(1200, lambda: _addr.config(text=SUPPORT_ADDR))
            except Exception:
                pass
        _addr.bind("<Button-1>", _copy_addr)
        _links = ttk.Frame(_ab, style="Card.TFrame")
        _links.pack(pady=(14, 0))
        mkbtn(_links, text="Links  ↗", style="Ghost.TButton", bg=CARD,
               command=lambda: _wb.open(
                   "https://loopayeh.github.io/")).pack(side="left", ipadx=10, ipady=4)
        mkbtn(_links, text="Support  ↗", style="Ghost.TButton", bg=CARD,
               command=lambda: _wb.open(SUPPORT_URL)).pack(side="left", ipadx=10, ipady=4)
        mkbtn(_links, text="☕ حمایت تومانی  ↗", style="Ghost.TButton", bg=CARD,
               command=lambda: _wb.open(
                   "https://coffeebede.com/loopayeh")).pack(side="left", ipadx=10, ipady=4)
        tk.Label(_ab, text="PS4 engine: LibOrbisPkg by maxton (via PkgEditor)\n"
                              ".ffpfsc reading: mkpfs by PSBrew (GPLv3)",
                 bg=CARD, fg=MUTED, font=FONT_SMALL, justify="center").pack(padx=36,
                                                                           pady=(10, 0))
        mkbtn(_ab, text="Close", style="Accent.TButton", bg=CARD,
               command=_ab.destroy).pack(pady=(16, 20))
        # center over main window instead of top-left corner
        try:
            _ab.update_idletasks()
            _rx, _ry = root.winfo_x(), root.winfo_y()
            _rw, _rh = root.winfo_width(), root.winfo_height()
            _aw, _ah = _ab.winfo_width(), _ab.winfo_height()
            _ab.geometry("+%d+%d" % (_rx + (_rw - _aw) // 2,
                                     _ry + (_rh - _ah) // 2))
        except Exception:
            pass

    def check_updates(manual=False):
        """Check GitHub releases for a newer build (stdlib only)."""
        try:
            import updater as _up
        except Exception as e:
            if manual:
                statusvar.set("Update check failed: %s" % e)
            return
        if manual:
            statusvar.set("Checking for updates...")

        def _done(info):
            def _ui():
                if not info:
                    if manual:
                        statusvar.set("No releases found (or offline)")
                    return
                try:
                    newer = _up.is_newer(info.get("tag", ""), APP_VERSION)
                except Exception:
                    newer = False
                if newer:
                    try:
                        updatebtn.config(text="⬆ Update available",
                                         style="Accent.TButton")
                    except Exception:
                        pass
                    state["update_note"] = "Update available: %s" % info.get("tag", "")
                    _set_status()
                    if manual:
                        _show_update_dialog(info)
                elif manual:
                    state["update_note"] = "Up to date (%s)" % APP_VERSION
                    _set_status()
                    try:
                        messagebox.showinfo(
                            "No updates",
                            "You're up to date (%s)." % APP_VERSION,
                            parent=root)
                    except Exception:
                        pass
            try:
                root.after(0, _ui)
            except Exception:
                pass
        _up.check_in_background(UPDATE_REPO, _done)

    def _show_update_dialog(info):
        try:
            import updater as _up
        except Exception:
            return
        tag = info.get("tag", "")
        dlg = tk.Toplevel(root)
        dlg.title("Update available")
        dlg.configure(bg=BG)
        try:
            dlg.transient(root)
            dlg.grab_set()
        except Exception:
            pass
        tk.Label(dlg, text="A new version is available:", bg=BG, fg=MUTED,
                 font=FONT_SMALL).pack(anchor="w", padx=16, pady=(14, 2))
        tk.Label(dlg, text="%s  (you have %s)" % (info.get("name", tag),
                                                  APP_VERSION),
                 bg=BG, fg=TEXT, font=FONT).pack(anchor="w", padx=16)
        _body = (info.get("body", "") or "").strip().split("\n")
        _notes = "\n".join(_body[:12])
        if _notes:
            _tx = tk.Text(dlg, bg=CARD, fg=TEXT, font=FONT_SMALL,
                          wrap="word", borderwidth=0, highlightthickness=0,
                          padx=10, pady=10,
                          height=8, width=60)
            _tx.pack(fill="both", expand=True, padx=16, pady=(10, 0))
            _tx.insert("end", _notes)
            _tx.config(state="disabled")
        _prog = tk.StringVar(value="")
        tk.Label(dlg, textvariable=_prog, bg=BG, fg=MUTED,
                 font=FONT_SMALL).pack(anchor="w", padx=16, pady=(6, 0))
        _btns = tk.Frame(dlg, bg=BG)
        _btns.pack(fill="x", padx=16, pady=14)

        def _reenable():
            for _b in _btns.winfo_children():
                try:
                    _b.config(state="normal")
                except Exception:
                    pass

        def _dl_linux():
            try:
                _asset = _up.pick_deb_asset(info)
            except Exception:
                _asset = None
            if not _asset:
                _prog.set("No .deb found in this release")
                return
            _prog.set("Downloading %s..." % _asset["name"])
            for _b in _btns.winfo_children():
                try:
                    _b.config(state="disabled")
                except Exception:
                    pass

            def _work():
                try:
                    import tempfile as _tf
                    _tmp = _tf.mkdtemp(prefix="update_")
                    _dest = os.path.join(_tmp, _asset["name"])

                    def _pg(got, total):
                        if total:
                            root.after(0, _prog.set,
                                       "Downloading... %d%%"
                                       % (got * 100 // total))
                    _up.download(_asset["url"], _dest, progress=_pg)
                except Exception as e:
                    root.after(0, _prog.set, "Download failed: %s" % e)
                    root.after(0, _reenable)
                    return
                root.after(0, _prog.set,
                           "Installing update — confirm the password prompt...")
                try:
                    ok, msg = _up.install_deb(_dest)
                except Exception as e:
                    ok, msg = False, str(e)
                if ok:
                    def _rst():
                        _prog.set("Installed — restarting...")
                        try:
                            _up.relaunch_linux_app()
                        except Exception:
                            pass
                        try:
                            dlg.destroy()
                        except Exception:
                            pass
                        root.after(300, root.destroy)
                    root.after(0, _rst)
                else:
                    root.after(0, _prog.set,
                               "Install failed: %s (%s)" % (msg, _dest))
                    root.after(0, _reenable)
            import threading as _th
            _th.Thread(target=_work, daemon=True).start()

        def _dl():
            # installed builds only: Windows needs the Setup installer,
            # Linux installs the .deb (handled in _dl_linux).
            if sys.platform.startswith("linux"):
                _dl_linux()
                return
            try:
                _asset = _up.pick_setup_asset(info)
            except Exception:
                _asset = None
            if _asset is None:
                _prog.set("No installer found in this release")
                return
            _prog.set("Downloading %s..." % _asset["name"])
            for _b in _btns.winfo_children():
                try:
                    _b.config(state="disabled")
                except Exception:
                    pass

            def _work():
                try:
                    import tempfile as _tf
                    _tmp = _tf.mkdtemp(prefix="update_")
                    _dest = os.path.join(_tmp, _asset["name"])

                    def _pg(got, total):
                        if total:
                            root.after(0, _prog.set,
                                       "Downloading... %d%%"
                                       % (got * 100 // total))
                    _up.download(_asset["url"], _dest, progress=_pg)
                except Exception as e:
                    root.after(0, _prog.set, "Download failed: %s" % e)
                    return

                def _fin():
                    try:
                        root.after(0, _prog.set,
                                   "Installing update, app will restart...")
                        if _up.run_setup_and_exit(_dest):
                            try:
                                dlg.destroy()
                            except Exception:
                                pass
                            root.after(300, root.destroy)
                        else:
                            _prog.set("Update failed: cannot launch installer")
                    except Exception as e:
                        _prog.set("Update failed: %s" % e)
                root.after(0, _fin)
            import threading as _th
            _th.Thread(target=_work, daemon=True).start()
        mkbtn(_btns, text="Download + Install",
                   style="Accent.TButton", command=_dl).pack(side="left")
        mkbtn(_btns, text="Later", style="Ghost.TButton",
              command=dlg.destroy).pack(side="left", padx=(8, 0))
        _center_on_root(dlg)

    def _set_rename_enabled(on):
        try:
            renamebtn.config(state="normal" if on else "disabled")
        except Exception:
            pass

    def _set_undo_enabled(on):
        try:
            undobtn.config(state="normal" if on else "disabled")
        except Exception:
            pass

    def _refresh_path_after_move(old, new):
        r = state.get("result")
        if r and os.path.normcase(r.get("path") or "") == os.path.normcase(old):
            r["path"] = new
            try:
                pathvar.set(os.path.basename(new))
            except Exception:
                pass

    def undo_last_rename():
        pair = state.get("last_rename")
        if not pair:
            statusvar.set("Nothing to undo")
            return
        old_path, new_path = pair
        if not os.path.exists(new_path):
            statusvar.set("Undo failed: renamed file not found")
            state["last_rename"] = None
            _set_undo_enabled(False)
            return
        if os.path.exists(old_path):
            statusvar.set("Undo failed: original name is taken")
            return
        try:
            os.rename(new_path, old_path)
        except Exception as ex:
            statusvar.set(f"Undo failed: {ex}")
            return
        _refresh_path_after_move(new_path, old_path)
        state["last_rename"] = None
        _set_undo_enabled(False)
        _set_status(f"Undone: back to {os.path.basename(old_path)}")

    def _center_on_root(dlg, w=None, h=None):
        """Center a dialog over the main window (else screen center)."""
        try:
            dlg.update_idletasks()
            try:
                root.update_idletasks()
                rx, ry = root.winfo_rootx(), root.winfo_rooty()
                rw, rh = root.winfo_width(), root.winfo_height()
            except Exception:
                rx, ry, rw, rh = 0, 0, 0, 0
            dw = w or dlg.winfo_reqwidth()
            dh = h or dlg.winfo_reqheight()
            if rw > 1 and rh > 1:
                x = rx + max(0, (rw - dw) // 2)
                y = ry + max(0, (rh - dh) // 2)
            else:
                x = max(0, (dlg.winfo_screenwidth() - dw) // 2)
                y = max(0, (dlg.winfo_screenheight() - dh) // 2)
            if w and h:
                dlg.geometry("%dx%d+%d+%d" % (w, h, x, y))
            else:
                dlg.geometry("+%d+%d" % (x, y))
        except Exception:
            pass

    def show_rename():
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        old_path = r.get("path") or ""
        if not old_path or not os.path.exists(old_path):
            statusvar.set("Original file not found")
            return
        is_dir = os.path.isdir(old_path)
        _root, ext = (os.path.splitext(os.path.basename(old_path))
                      if not is_dir else ("", ""))
        # the saved preset/pattern also drives the first suggestion
        _inc0, _pid0, _cpat0 = load_rename_prefs()
        _pat0 = pattern_for_preset(_pid0, _cpat0)
        _base, _miss0 = suggest_base_name(r, _pat0, _inc0, old_path)
        dlg = tk.Toplevel(root)
        dlg.title("Rename file")
        dlg.configure(bg=BG)
        dlg.transient(root)
        dlg.grab_set()
        dlg.resizable(False, False)
        tk.Label(dlg, text="Old name:", bg=BG, fg=MUTED,
                 font=FONT_SMALL, anchor="w").pack(fill="x", padx=14, pady=(12, 0))
        tk.Label(dlg, text=os.path.basename(old_path), bg=BG, fg=TEXT,
                 font=FONT, anchor="w", wraplength=440,
                 justify="left").pack(fill="x", padx=14)
        tk.Label(dlg, text="New name:", bg=BG, fg=MUTED,
                 font=FONT_SMALL, anchor="w").pack(fill="x", padx=14, pady=(10, 0))
        namevar = tk.StringVar(
            value=((_base + ext) if _base else os.path.basename(old_path)))
        entry = tk.Entry(dlg, textvariable=namevar, bg=CARD2, fg=TEXT,
                         font=FONT_MID, width=52, insertbackground=TEXT)
        entry.pack(fill="x", padx=14, pady=(2, 4))

        def _refresh_name(*_a):
            _pat = bar.pattern()
            _bad = bar.unknown_tokens()
            if _bad:
                bar.set_hint("unknown token: " +
                             ", ".join("{%s}" % t for t in _bad), "#e17b7b")
                return
            if bar.preset_id() == "custom" and _pat == "":
                bar.set_hint("Type a pattern or click a token — "
                             "e.g. {title} - {tid}")
                return
            _b, _miss = suggest_base_name(r, _pat, bar.include(), old_path)
            if _b:
                namevar.set((_b + ("" if is_dir else ext)).strip())
                bar.set_hint("")
            else:
                bar.set_hint(("missing " + ", ".join(_miss)) if _miss
                             else "not enough info for this pattern",
                             "#e9b36a")

        bar = NamePatternBar(dlg, on_change=_refresh_name)
        bar.pack(fill="x", padx=14, pady=(2, 0))
        bar.set_hint(("missing " + ", ".join(_miss0)) if _miss0 else "")
        msgvar = tk.StringVar(value="")
        tk.Label(dlg, textvariable=msgvar, bg=BG, fg="#e17b7b",
                 font=FONT_SMALL, anchor="w").pack(fill="x", padx=14)
        entry.focus_set()
        entry.select_range(0, "end")

        def _do_copy():
            try:
                root.clipboard_clear()
                root.clipboard_append(namevar.get().strip())
                msgvar.set("Copied to clipboard")
            except Exception as ex:
                msgvar.set(f"Copy failed: {ex}")

        def _do_rename():
            new_name = sanitize_filename_part(namevar.get(), limit=200)
            if not new_name:
                msgvar.set("Name is empty")
                return
            if not is_dir and "." not in new_name and ext:
                new_name += ext
            new_path = os.path.join(os.path.dirname(old_path), new_name)
            if os.path.normcase(new_path) == os.path.normcase(old_path):
                msgvar.set("Name unchanged")
                return
            if os.path.exists(new_path):
                msgvar.set("A file with this name already exists")
                return
            try:
                os.rename(old_path, new_path)
            except Exception as ex:
                msgvar.set(f"Error: {ex}")
                return
            r["path"] = new_path
            pathvar.set(os.path.basename(new_path))
            state["last_rename"] = (old_path, new_path)
            _set_undo_enabled(True)
            _set_status(f"Renamed to {os.path.basename(new_path)}")
            dlg.destroy()

        btns = tk.Frame(dlg, bg=BG)
        btns.pack(fill="x", padx=14, pady=(6, 14))
        mkbtn(btns, text="Rename", style="Accent.TButton",
              command=_do_rename).pack(side="left")
        mkbtn(btns, text="Copy", style="Ghost.TButton",
              command=_do_copy).pack(side="left", padx=(8, 0))
        mkbtn(btns, text="Cancel", style="Ghost.TButton",
              command=dlg.destroy).pack(side="right")
        _center_on_root(dlg)
        dlg.bind("<Return>", lambda _e: _do_rename())
        dlg.bind("<Escape>", lambda _e: dlg.destroy())

    def show_batch(files):        # single app folder / non-package file keeps the old load behavior —
        # unless the folder actually holds game files (then batch-scan it)
        if len(files) == 1:
            _p = files[0]
            if os.path.isdir(_p):
                try:
                    _has = any(fn.lower().endswith(BATCH_EXTS)
                               for fn in os.listdir(_p))
                except Exception:
                    _has = False
                if not _has:
                    load(_p)
                    return
            else:
                # single dropped/picked file always opens directly —
                # split-set siblings (_0.._N) are a batch-rename concern,
                # not a reason to hijack a single-file drop into batch.
                load(_p)
                return
        files = collect_batch_files(files)
        if not files:
            statusvar.set("No game files dropped")
            return
        if len(files) == 1 and len(split_set_siblings(files[0])) == 1:
            load(files[0])
            return
        # saved preset/pattern (and ticks) also drive the first plan
        _inc0, _pid0, _cpat0 = load_rename_prefs()
        _pat0 = pattern_for_preset(_pid0, _cpat0)
        if _pat0 == "":
            _pat0 = None
        try:
            statusvar.set(f"Scanning {len(files)} files...")
            root.update_idletasks()
            plan = preview_batch(files,
                                 include=(_inc0 if _pat0 is None else None),
                                 pattern=_pat0)
        except Exception as ex:
            statusvar.set(f"Error: {ex}")
            return
        dlg = tk.Toplevel(root)
        dlg.title(f"Batch rename ({len(plan)} items)")
        dlg.configure(bg=BG)
        dlg.transient(root)
        dlg.grab_set()
        dlg.geometry("860x600")
        _center_on_root(dlg, 860, 600)
        dlg.minsize(700, 480)
        try:
            dlg.resizable(True, True)
        except Exception:
            pass
        # bottom bar packed first so buttons never get pushed out of view
        btns = tk.Frame(dlg, bg=BG)
        btns.pack(side="bottom", fill="x", padx=14, pady=(6, 14))
        msgvar = tk.StringVar(value="All ready rows are selected. "
                                    "Double-click a row to exclude it.")
        _msg = tk.Label(dlg, textvariable=msgvar, bg=BG, fg=MUTED,
                        font=FONT_SMALL, anchor="w")
        _msg.pack(side="bottom", fill="x", padx=14)
        # name preset / custom token pattern / include ticks (shared widget)
        bar = NamePatternBar(dlg, on_change=lambda: _on_parts())
        bar.pack(side="top", fill="x", padx=12, pady=(12, 0))
        cols = ("use", "old", "new", "status")
        tv = ttk.Treeview(dlg, columns=cols, show="headings", height=14)
        tv.heading("use", text="✓")
        tv.heading("old", text="current name")
        tv.heading("new", text="new name")
        tv.heading("status", text="status")
        tv.column("use", width=36, anchor="center")
        tv.column("old", width=240)
        tv.column("new", width=240)
        tv.column("status", width=180)
        sb = ttk.Scrollbar(dlg, orient="vertical", command=tv.yview)
        tv.configure(yscrollcommand=sb.set)
        sb.pack(side="right", fill="y")
        tv.pack(side="top", fill="both", expand=True, padx=12, pady=(12, 6))
        checked = set()
        rows = []  # (plan_idx, old, new_or_None)

        def _rebuild_rows():
            del rows[:]
            checked.clear()
            for idx, item in enumerate(plan):
                if item["new_files"]:
                    for old, new in zip(item["files"], item["new_files"]):
                        rows.append((idx, old, new))
                else:
                    rows.append((idx, item["files"][0], None))
                if item["status"] == "ok":
                    checked.add(idx)

        def _hint_from_plan():
            # example name / warning line under the pattern (custom only)
            try:
                if bar.preset_id() != "custom":
                    bar.set_hint("")
                    return
                _bad = bar.unknown_tokens()
                if _bad:
                    bar.set_hint("unknown token: " +
                                 ", ".join("{%s}" % t for t in _bad),
                                 "#e17b7b")
                    return
                if bar.pattern() == "":
                    bar.set_hint("Type a pattern or click a token — "
                                 "e.g. {title} - {tid}")
                    return
                _first = next((it for it in plan
                               if it.get("status") == "ok"
                               and it.get("new_files")), None)
                if _first:
                    bar.set_hint("e.g. " +
                                 os.path.basename(_first["new_files"][0]))
                else:
                    _skip = next((it for it in plan if it.get("reason")), None)
                    bar.set_hint(_skip["reason"] if _skip
                                 else "Nothing to rename with this pattern",
                                 "#e9b36a")
            except Exception:
                pass

        def _on_parts():
            _pat = bar.pattern()
            if _pat == "" and bar.preset_id() == "custom":
                # custom selected but empty: never fall back to clean names
                plan[:] = []
                _rebuild_rows()
                _fill_rows()
                _hint_from_plan()
                return
            _inc = bar.include() if _pat is None else None
            try:
                plan[:] = preview_batch(files, include=_inc, pattern=_pat)
            except Exception as ex:
                msgvar.set(f"Error: {ex}")
                return
            try:
                dlg.title(f"Batch rename ({len(plan)} items)")
            except Exception:
                pass
            _rebuild_rows()
            _fill_rows()
            _hint_from_plan()

        _rebuild_rows()

        def _status_text(idx):
            item = plan[idx]
            if item["status"] == "ok":
                return "renamed" if idx not in checked and \
                    item.get("_done") else "ready"
            return item["reason"] or "skip"

        def _fill_rows():
            for _iid in list(tv.get_children()):
                tv.delete(_iid)
            for idx, old, new in rows:
                tv.insert("", "end", iid=f"{idx}.{len(tv.get_children())}",
                          values=("✓" if idx in checked else "",
                                  os.path.basename(old),
                                  os.path.basename(new) if new else "—",
                                  _status_text(idx)))

        _fill_rows()
        _hint_from_plan()

        def _toggle(_e=None):
            sel = tv.selection()
            if not sel:
                return
            try:
                idx = int(str(sel[0]).split(".")[0])
            except Exception:
                return
            if plan[idx]["status"] != "ok":
                return
            if idx in checked:
                checked.discard(idx)
            else:
                checked.add(idx)
            _fill_rows()

        tv.bind("<Double-Button-1>", _toggle)

        def _select_all():
            for idx, item in enumerate(plan):
                if item["status"] == "ok":
                    checked.add(idx)
            _fill_rows()

        def _select_none():
            checked.clear()
            _fill_rows()

        def _do_copy():
            try:
                lines = []
                for idx, item in enumerate(plan):
                    if item["new_files"]:
                        for old, new in zip(item["files"], item["new_files"]):
                            lines.append(f"{os.path.basename(old)}  ->  "
                                         f"{os.path.basename(new)}")
                root.clipboard_clear()
                root.clipboard_append("\n".join(lines))
                msgvar.set("Copied to clipboard")
            except Exception as ex:
                msgvar.set(f"Copy failed: {ex}")

        def _do_rename():
            sel = [plan[i] for i in sorted(checked)
                   if plan[i]["status"] == "ok"]
            if not sel:
                msgvar.set("Nothing selected")
                return
            renamed, skipped, lp = apply_batch(sel, log_path=default_batch_log())
            if lp:
                state["last_batch_log"] = lp
            state["last_rename"] = None
            _set_undo_enabled(False)
            for old, new in renamed:
                r = state.get("result")
                if r and os.path.normcase(r.get("path") or "") == \
                        os.path.normcase(old):
                    r["path"] = new
                    pathvar.set(os.path.basename(new))
            try:
                _set_status(f"Batch: renamed {len(renamed)}, "
                            f"skipped {len(skipped)}"
                            + (f" — log: {os.path.basename(lp)}" if lp else ""))
            except Exception:
                pass
            msgvar.set(f"Renamed {len(renamed)}, skipped {len(skipped)}."
                       + (f" Log: {lp}" if lp else ""))
            for item in sel:
                item["_done"] = True
            checked.clear()
            _fill_rows()

        # btns frame was packed at the bottom up-front; just add buttons
        mkbtn(btns, text="Rename selected", style="Accent.TButton",
              command=_do_rename).pack(side="left")
        mkbtn(btns, text="All", style="Ghost.TButton",
              command=_select_all).pack(side="left", padx=(8, 0))
        mkbtn(btns, text="None", style="Ghost.TButton",
              command=_select_none).pack(side="left", padx=(8, 0))
        mkbtn(btns, text="Copy list", style="Ghost.TButton",
              command=_do_copy).pack(side="left", padx=(8, 0))
        mkbtn(btns, text="Revert...", style="Ghost.TButton",
              command=lambda: show_revert()).pack(side="left", padx=(8, 0))
        mkbtn(btns, text="Close", style="Ghost.TButton",
              command=dlg.destroy).pack(side="right")

    def show_revert(log_path=None):
        """Pick a batch_rename_*.log, preview it, revert selected rows."""
        if not log_path:
            _init = os.path.dirname(state.get("last_batch_log") or "") or "."
            log_path = filedialog.askopenfilename(
                title="Select revert log",
                initialdir=_init,
                filetypes=[("Revert log", "batch_rename_*.log"),
                           ("Log files", "*.log"),
                           ("All files", "*.*")])
            if not log_path:
                return
        pairs = parse_revert_log(log_path)
        if not pairs:
            statusvar.set(f"Revert: no valid entries in "
                          f"{os.path.basename(log_path)}")
            return
        try:
            from tkinter import messagebox as _mb
        except Exception:
            _mb = None
        rdlg = tk.Toplevel(root)
        rdlg.title(f"Revert ({len(pairs)} entries)")
        rdlg.configure(bg=BG)
        rdlg.transient(root)
        rdlg.grab_set()
        rdlg.geometry("840x480")
        _center_on_root(rdlg, 840, 480)
        rdlg.minsize(680, 380)
        try:
            rdlg.resizable(True, True)
        except Exception:
            pass
        rbtns = tk.Frame(rdlg, bg=BG)
        rbtns.pack(side="bottom", fill="x", padx=14, pady=(6, 14))
        rmsg = tk.StringVar(value=f"From: {os.path.basename(log_path)} — "
                                  "double-click a row to exclude it.")
        tk.Label(rdlg, textvariable=rmsg, bg=BG, fg=MUTED,
                 font=FONT_SMALL, anchor="w").pack(side="bottom", fill="x",
                                                   padx=14)
        rcols = ("use", "current", "restore", "status")
        rtv = ttk.Treeview(rdlg, columns=rcols, show="headings", height=14)
        rtv.heading("use", text="✓")
        rtv.heading("current", text="current name")
        rtv.heading("restore", text="restore to")
        rtv.heading("status", text="status")
        rtv.column("use", width=36, anchor="center")
        rtv.column("current", width=240)
        rtv.column("restore", width=240)
        rtv.column("status", width=180)
        rsb = ttk.Scrollbar(rdlg, orient="vertical", command=rtv.yview)
        rtv.configure(yscrollcommand=rsb.set)
        rsb.pack(side="right", fill="y")
        rtv.pack(side="top", fill="both", expand=True, padx=12, pady=(12, 6))
        rchecked = set(range(len(pairs)))

        def _rstatus(i):
            cur, rst = pairs[i]
            if not os.path.exists(cur):
                return "missing"
            if os.path.exists(rst):
                return "target exists"
            return "ready"

        def _rfill():
            for _iid in list(rtv.get_children()):
                rtv.delete(_iid)
            for i, (cur, rst) in enumerate(pairs):
                rtv.insert("", "end", iid=str(i),
                           values=("✓" if i in rchecked else "",
                                   os.path.basename(cur),
                                   os.path.basename(rst),
                                   _rstatus(i)))

        _rfill()

        def _rtoggle(_e=None):
            sel = rtv.selection()
            if not sel:
                return
            try:
                i = int(str(sel[0]))
            except Exception:
                return
            if i in rchecked:
                rchecked.discard(i)
            else:
                rchecked.add(i)
            _rfill()

        rtv.bind("<Double-Button-1>", _rtoggle)

        def _rall():
            rchecked.update(range(len(pairs)))
            _rfill()

        def _rnone():
            rchecked.clear()
            _rfill()

        def _rdo():
            sel = [(pairs[i][0], pairs[i][1]) for i in sorted(rchecked)
                   if _rstatus(i) == "ready"]
            if not sel:
                rmsg.set("Nothing ready selected")
                return
            if _mb is not None:
                try:
                    if not _mb.askyesno(
                            "Confirm revert",
                            f"Rename {len(sel)} file(s) back to their "
                            f"original names?"):
                        return
                except Exception:
                    pass
            rev, skip = apply_revert(sel)
            for cur, rst in rev:
                _refresh_path_after_move(cur, rst)
            try:
                _set_status(f"Revert: restored {len(rev)}, "
                            f"skipped {len(skip)}")
            except Exception:
                pass
            rmsg.set(f"Restored {len(rev)}, skipped {len(skip)}.")
            rdlg.destroy()

        mkbtn(rbtns, text="Revert selected", style="Accent.TButton",
              command=_rdo).pack(side="left")
        mkbtn(rbtns, text="All", style="Ghost.TButton",
              command=_rall).pack(side="left", padx=(8, 0))
        mkbtn(rbtns, text="None", style="Ghost.TButton",
              command=_rnone).pack(side="left", padx=(8, 0))
        mkbtn(rbtns, text="Close", style="Ghost.TButton",
              command=rdlg.destroy).pack(side="right")

    # logic
    def pick():
        # files only — folders come in via drag & drop
        p = filedialog.askopenfilename(title="Select PKG / ISO / image file",
                                       filetypes=[("Game files", "*.pkg *.iso *.exfat *.ffpfsc *.ffpkg *.nsp *.xci"),
                                                  ("PKG", "*.pkg"),
                                                  ("PS3 ISO", "*.iso"),
                                                  ("exFAT image", "*.exfat"),
                                                  ("Switch", "*.nsp *.xci"),
                                                  ("all", "*.*")])
        if p:
            load(p)

    def pick_many():
        # files only — folders come in via drag & drop
        ps = filedialog.askopenfilenames(title="Select files for batch rename",
                                         filetypes=[("Game files", "*.pkg *.iso *.exfat *.ffpfsc *.ffpkg *.nsp *.xci"),
                                                    ("all", "*.*")])
        if ps:
            show_batch(list(ps))

    def show_tab(idx):
        # Extra > List Contents (Files) / Package Update note (Details).
        try:
            nbw = state.get("notebook")
            if nbw is not None:
                nbw.select(idx)
        except Exception:
            pass

    def check_integrity():
        # LMAN-style "Check Integrity": entry bounds vs real file size.
        import os as _os
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        try:
            fsize = _os.path.getsize(r["path"]) if _os.path.isfile(r["path"]) else r.get("size", 0)
        except OSError:
            fsize = r.get("size", 0)
        bad = []
        for e in r.get("entries", []):
            off, sz = e.get("abs_off"), e.get("size", 0)
            if isinstance(off, int) and off >= 0 and sz > 0:
                if off < 0 or off + sz > fsize:
                    bad.append(e.get("name") or str(e.get("id")))
        if bad:
            statusvar.set(f"Integrity: {len(bad)} bad entries ({', '.join(bad[:3])})")
        else:
            n = len([e for e in r.get("entries", []) if e.get("name")])
            statusvar.set(f"Integrity OK - {n} entries within bounds")

    def show_properties():
        # LMAN-style "Properties" popup: full Param = Value table.
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        win = tk.Toplevel(root)
        win.title("Properties - %s" % os.path.basename(r.get("path", "")))
        win.configure(bg=CARD)
        win.transient(root)
        rows = list(r.get("rows", []))
        txt = tk.Text(win, bg=CARD, fg=TEXT, font=("Consolas", 9),
                      borderwidth=0, highlightthickness=0, padx=12, pady=12,
                      height=min(max(len(rows) + 2, 10), 30), width=70)
        txt.pack(fill="both", expand=True)
        for k, v in rows:
            txt.insert("end", f"{k} = {v}\n")
        txt.config(state="disabled")
        mkbtn(win, text="Close", style="Accent.TButton", bg=CARD,
              command=win.destroy).pack(pady=(0, 12))

    def extract_all():
        # LMAN-style "Extract Package": dump every listed entry to a folder.
        from tkinter import filedialog as _fd
        r = state.get("result")
        if not r or not r.get("entries"):
            statusvar.set("Nothing to extract")
            return
        dest = _fd.askdirectory(title="Extract package to folder",
                                  initialdir=_srcdir())
        if not dest:
            return
        # extract into a game-named subfolder, not loose files
        try:
            _gdir = (build_clean_name(r)
                     or sanitize_filename_part(r.get("title") or "")
                     or os.path.splitext(os.path.basename(r.get("path") or ""))[0]
                     or "extract")
            dest = os.path.join(dest, _gdir)
            os.makedirs(dest, exist_ok=True)
        except Exception as ex:
            statusvar.set(f"Cannot create folder: {ex}")
            return
        ok, fail = 0, 0
        for e in r["entries"]:
            nm = (e.get("name") or "").strip()
            if not nm or e.get("size", 0) <= 0:
                continue
            safe = nm.replace("/", "_").replace("\\", "_")
            try:
                if e.get("local_path") and os.path.isfile(e["local_path"]):
                    with open(e["local_path"], "rb") as fh:
                        data = fh.read()
                elif e.get("cached") is not None:
                    data = e["cached"]
                else:
                    data = read_entry_bytes(r["path"], e["abs_off"], e["size"],
                                            limit=2_000_000_000)
                if not data:
                    fail += 1
                    continue
                with open(os.path.join(dest, safe), "wb") as out:
                    out.write(data)
                ok += 1
            except Exception:
                fail += 1
        statusvar.set(f"Extracted {ok} files" + (f" ({fail} skipped)" if fail else ""))

    def _run_worker_dialog(title, worker_args, on_done):
        # Progress dialog for long orbis jobs: live log + file counter +
        # elapsed time, indeterminate bar, Pause/Resume + Cancel.
        import subprocess as _sp
        import threading as _th
        import time as _time
        dlg = tk.Toplevel(root)
        dlg.title(title)
        dlg.transient(root)
        try:
            root.update_idletasks()
            _rx, _ry = root.winfo_rootx(), root.winfo_rooty()
            _rw, _rh = root.winfo_width(), root.winfo_height()
            _dw, _dh = 460, 210
            _dx = _rx + max((_rw - _dw) // 2, 0)
            _dy = _ry + max((_rh - _dh) // 2, 0)
            dlg.geometry(f"{_dw}x{_dh}+{_dx}+{_dy}")
        except Exception:
            dlg.geometry("460x210")
        dlg.grab_set()
        try:
            dlg.configure(bg=CARD)
        except Exception:
            pass
        _tvar = tk.StringVar(value=title + "...")
        tk.Label(dlg, textvariable=_tvar, bg=CARD, fg=TEXT,
                 font=(FONT[0], 10, "bold"), wraplength=420,
                 justify="left").pack(fill="x", padx=14, pady=(12, 4))
        _fvar = tk.StringVar(value="")
        tk.Label(dlg, textvariable=_fvar, bg=CARD, fg=MUTED,
                 font=(FONT[0], 9)).pack(fill="x", padx=14)
        try:
            _bar = ttk.Progressbar(dlg, mode="indeterminate")
            _bar.pack(fill="x", padx=14, pady=10)
            _bar.start(30)
        except Exception:
            _bar = None
        _t0 = _time.time()

        def _progress_line(n):
            el = _time.time() - _t0
            try:
                s = max(0, int(el))
                clock = f"{s // 60:02d}:{s % 60:02d}"
            except Exception:
                clock = "--:--"
            return f"{n} files  •  {clock} elapsed"
        _brow = ttk.Frame(dlg)
        _brow.pack(pady=(0, 12))
        _pvar = tk.StringVar(value="Pause")
        _st = {"proc": None, "paused": False, "done": False}

        def _suspend(pid, on):
            try:
                import ctypes as _ct
                _k32 = _ct.windll.kernel32
                _nt = _ct.windll.ntdll
                h = _k32.OpenProcess(0x0800, False, pid)
                if not h:
                    return False
                try:
                    r = (_nt.NtSuspendProcess if on else _nt.NtResumeProcess)(h)
                    return int(r) == 0
                finally:
                    _k32.CloseHandle(h)
            except Exception:
                return False

        def _toggle_pause():
            p = _st["proc"]
            if not p or _st["done"]:
                return
            want = not _st["paused"]
            if _suspend(p.pid, want):
                _st["paused"] = want
                _pvar.set("Resume" if want else "Pause")
                _tvar.set((title + " (paused)") if want else (title + "..."))
                try:
                    if _bar is not None:
                        _bar.stop() if want else _bar.start(30)
                except Exception:
                    pass

        def _cancel():
            p = _st["proc"]
            _st["done"] = True
            try:
                if p and p.poll() is None:
                    if _st["paused"]:
                        _suspend(p.pid, False)
                    try:
                        _kill_tree(p.pid)
                    except Exception:
                        pass
                    if p.poll() is None:
                        p.kill()
            except Exception:
                pass
            try:
                dlg.grab_release()
            except Exception:
                pass
            try:
                dlg.destroy()
            except Exception:
                pass
            statusvar.set(title + " cancelled")

        mkbtn(_brow, textvariable=_pvar, style="Ghost.TButton",
              bg=CARD, command=lambda: _toggle_pause()).pack(side="left")
        mkbtn(_brow, text="Cancel", style="Accent.TButton",
              command=lambda: _cancel()).pack(side="left", padx=(8, 0))
        dlg.protocol("WM_DELETE_WINDOW", lambda: _cancel())

        def _reader():
            try:
                import shutil as _sh
                if getattr(sys, "frozen", False):
                    # Frozen exe: sys.executable IS the GUI itself, so it
                    # must NOT be used as the python interpreter (that bug
                    # just reopened an empty app window). Find a real python.
                    _py = (_sh.which("python") or _sh.which("py")
                           or "python")
                    _base = getattr(sys, "_MEIPASS", None) or ""
                    _wrk = os.path.join(_base, "orbis_full.py")
                    if not _base or not os.path.isfile(_wrk):
                        # dev fallback: script next to the exe
                        _wrk = os.path.join(
                            os.path.dirname(sys.executable),
                            "orbis_full.py")
                else:
                    _py = sys.executable or "python"
                    _wrk = os.path.join(
                        os.path.dirname(os.path.abspath(__file__)),
                        "orbis_full.py")
                if not os.path.isfile(_wrk):
                    root.after(0, statusvar.set,
                               f"{title} failed: worker script not found")
                    root.after(0, dlg.destroy)
                    return
                _argv = [_py, "-u", _wrk] + list(worker_args)
                _cf = 0
                try:
                    import subprocess as _sp2
                    _cf = _sp2.CREATE_NO_WINDOW
                except Exception:
                    _cf = 0
                if _st["done"]:
                    # cancelled (or app closing) before spawn: don't start
                    return
                p = _sp.Popen(_argv,
                              stdout=_sp.PIPE, stderr=_sp.STDOUT,
                              text=True, bufsize=1,
                              creationflags=_cf)
                _st["proc"] = p
                if _st["done"]:
                    # cancelled while spawning: kill the whole tree at once
                    try:
                        _kill_tree(p.pid)
                    except Exception:
                        pass
                    try:
                        if p.poll() is None:
                            p.kill()
                    except Exception:
                        pass
                    return
                try:
                    _jobs = state.setdefault("child_procs", [])
                    _jobs.append(p)
                    state["child_procs"] = [q for q in _jobs
                                            if q.poll() is None]
                except Exception:
                    pass
                _res, _err = "", ""
                _all = []
                try:
                    for _ln in p.stdout:
                        _ln = _ln.rstrip("\n")
                        _all.append(_ln)
                        if len(_all) > 5000:
                            del _all[:4000]
                        if _ln.startswith("LOG "):
                            _tx = _ln[4:][:120]
                            root.after(0, _tvar.set, _tx)
                        elif _ln.startswith("FILES "):
                            _fc = _ln[6:].strip()
                            try:
                                _n = int(_fc)
                            except Exception:
                                _n = 0
                            root.after(0, _fvar.set, _progress_line(_n))
                        elif _ln.startswith("RESULT "):
                            _res = _ln[7:].strip()
                        elif _ln.startswith("ERROR "):
                            _err = _ln[6:].strip()
                        elif _ln.strip():
                            _tx2 = _ln.strip()[:120]
                            root.after(0, _tvar.set, _tx2)
                except Exception:
                    pass
                try:
                    p.wait(timeout=30)
                except Exception:
                    pass
                if _st["done"]:
                    return
                _st["done"] = True
                try:
                    state["child_procs"] = [
                        q for q in (state.get("child_procs") or [])
                        if q is not p and q.poll() is None]
                except Exception:
                    pass

                def _finish():
                    try:
                        dlg.grab_release()
                    except Exception:
                        pass
                    try:
                        dlg.destroy()
                    except Exception:
                        pass
                    if _err or (p.returncode not in (0, None) and not _res):
                        _tail = [_l.strip() for _l in _all
                                 if _l.strip()][-8:]
                        _msg = (_err or ('exit %s' % p.returncode))
                        if _tail and not _err:
                            _msg = f"{_msg} — {'; '.join(_tail)[:1500]}"
                        _msg = _msg[:2000]
                        statusvar.set(f"{title} failed: {_msg[:200]}")
                        try:
                            _logp = os.path.join(
                                os.environ.get("TEMP", os.path.expanduser("~")),
                                "PKGViewer_last_error.txt")
                            with open(_logp, "w", encoding="utf-8") as _lf:
                                _lf.write(f"{title} failed\n{_msg}\n"
                                          f"\n--- full output ---\n"
                                          + "\n".join(_all[-500:]))
                        except Exception:
                            _logp = ""
                        try:
                            from tkinter import messagebox as _mb
                            _mb.showerror(
                                f"{title} failed",
                                f"{_msg[:800]}"
                                + (f"\n\nFull log: {_logp}" if _logp else ""))
                        except Exception:
                            pass
                    else:
                        try:
                            on_done(_res)
                        except Exception as ex:
                            statusvar.set(f"{title} done, callback failed: {ex}")
                            return
                        # Success confirmation: short summary popup so it is
                        # clear the job actually finished (not just silence).
                        try:
                            _detail = _res or ""
                            if os.path.isfile(_res):
                                _detail = (f"{_res}\n"
                                           f"({fmt_size(os.path.getsize(_res))})")
                            elif os.path.isdir(_res):
                                _n = sum(len(fns) for _dp, _dn, fns
                                         in os.walk(_res))
                                _detail = f"{_res}\n({_n} files)"
                            from tkinter import messagebox as _mb2
                            _mb2.showinfo(f"{title} done",
                                          f"Completed successfully.\n\n{_detail}")
                        except Exception:
                            pass
                root.after(0, _finish)
            except Exception as ex:
                root.after(0, statusvar.set, f"{title} failed: {ex}")
                root.after(0, lambda: (_cancel()))

        _th.Thread(target=_reader, daemon=True).start()

    def _ask_passcode():
        # Modal passcode prompt: defaults to 32 zeros (16 bytes, FPKG
        # standard), editable for PKGs with a custom passcode.
        # Returns the hex string, or None if cancelled.
        _res = {"code": None}
        _d = tk.Toplevel(root)
        _d.title("Passcode")
        _d.transient(root)
        try:
            root.update_idletasks()
            _rx, _ry = root.winfo_rootx(), root.winfo_rooty()
            _rw, _rh = root.winfo_width(), root.winfo_height()
            _dw, _dh = 380, 150
            _d.geometry(f"{_dw}x{_dh}"
                        f"+{_rx + max((_rw - _dw) // 2, 0)}"
                        f"+{_ry + max((_rh - _dh) // 2, 0)}")
        except Exception:
            _d.geometry("380x150")
        _d.grab_set()
        try:
            _d.configure(bg=CARD)
        except Exception:
            pass
        tk.Label(_d, text="PKG passcode (hex, 16 bytes):", bg=CARD, fg=TEXT,
                 font=(FONT[0], 10)).pack(padx=14, pady=(12, 4), anchor="w")
        _var = tk.StringVar(value="0" * 32)
        _ent = tk.Entry(_d, textvariable=_var, font=("Consolas", 10),
                        width=36, bg=CARD2, fg=TEXT, insertbackground=TEXT)
        _ent.pack(padx=14, pady=(0, 4), fill="x")
        _ent.selection_range(0, "end")
        _ent.focus_set()
        tk.Label(_d, text="Default zeros = FPKG. Retail PKGs need their own.",
                 bg=CARD, fg=MUTED, font=(FONT[0], 8)).pack(padx=14, anchor="w")
        _brow = ttk.Frame(_d, style="Card.TFrame")
        _brow.pack(pady=8)

        def _ok():
            _c = (_var.get() or "").strip()
            if len(_c) != 32 or any(ch not in "0123456789abcdefABCDEF"
                                    for ch in _c):
                statusvar.set("Passcode must be 32 hex chars")
                return
            _res["code"] = _c
            try:
                _d.grab_release()
            except Exception:
                pass
            _d.destroy()

        def _no():
            try:
                _d.grab_release()
            except Exception:
                pass
            _d.destroy()

        mkbtn(_brow, text="OK", style="Accent.TButton",
              bg=CARD, command=lambda: _ok()).pack(side="left")
        mkbtn(_brow, text="Cancel", style="Ghost.TButton",
              bg=CARD, command=lambda: _no()).pack(side="left", padx=(8, 0))
        _d.protocol("WM_DELETE_WINDOW", lambda: _no())
        _d.bind("<Return>", lambda _e: _ok())
        _d.bind("<Escape>", lambda _e: _no())
        root.wait_window(_d)
        return _res["code"]

    def extract_ps4_pick():
        # Empty-state PS4 extract: pick a PKG, load it into the app,
        # then run the normal loaded-file flow.
        from tkinter import filedialog as _fd
        p = _fd.askopenfilename(title="Select PS4 PKG to extract",
                                initialdir=_srcdir(),
                                filetypes=[("PS4 packages", "*.pkg"),
                                           ("All files", "*.*")])
        if not p:
            return
        load(p)
        r2 = state.get("result") or {}
        if not r2.get("ok") or r2.get("kind") != "ps4":
            statusvar.set("That is not a PS4 PKG")
            return
        extract_structured()

    def extract_structured():
        # FULL extract via LibOrbisPkg (same engine as PkgEditor):
        # decrypts inner PFS -> all real files + .gp4 project.
        from tkinter import filedialog as _fd
        r = state.get("result")
        if not r or not r.get("ok"):
            statusvar.set("Open a PKG first")
            return
        if r.get("kind") == "ps3":
            statusvar.set("PS3 uses Files-tab extract (no PFS)")
            return
        dest = _fd.askdirectory(title="Extract FULL package to folder",
                                  initialdir=_srcdir())
        if not dest:
            return
        # extract into a game-named subfolder, not loose files
        try:
            _gdir = (build_clean_name(r)
                     or sanitize_filename_part(r.get("title") or "")
                     or os.path.splitext(os.path.basename(r.get("path") or ""))[0]
                     or "extract")
            dest = os.path.join(dest, _gdir)
            os.makedirs(dest, exist_ok=True)
        except Exception as ex:
            statusvar.set(f"Cannot create folder: {ex}")
            return
        code = _ask_passcode()
        if not code:
            statusvar.set("Extract cancelled")
            return

        def _done(res):
            try:
                n = sum(len(fns) for _dp, _dn, fns in os.walk(dest))
            except Exception:
                n = 0
            gp4 = os.path.basename(res) if res else ""
            statusvar.set(f"Full extract: {n} files"
                          + (f" + {gp4}" if gp4 else ""))

        _run_worker_dialog("Full extract",
                           ["extract", r["path"], dest, code], _done)

    def build_pkg():
        # Rebuild FPKG from a .gp4 project via LibOrbisPkg (no SDK needed).
        from tkinter import filedialog as _fd
        gp4 = _fd.askopenfilename(title="Select .gp4 project",
                                  initialdir=_srcdir(),
                                  filetypes=[("GP4 projects", "*.gp4")])
        if not gp4:
            return
        _gdir = os.path.dirname(os.path.abspath(gp4))
        out = _fd.asksaveasfilename(title="Save PKG as",
                                    defaultextension=".pkg",
                                    initialdir=_gdir,
                                    initialfile=os.path.splitext(
                                        os.path.basename(gp4))[0] + ".pkg",
                                    filetypes=[("PKG files", "*.pkg")])
        if not out:
            return

        def _done(res):
            statusvar.set(
                f"Built {os.path.basename(out)} ({fmt_size(os.path.getsize(out))})")

        _run_worker_dialog("Build PKG", ["build", gp4, out], _done)

    state["tools_actions"] = {
        "PKG": [
            ("Extract...", lambda: extract_structured()),
            ("Build from .gp4...", lambda: build_pkg()),
        ],
    }

    def copy_update_link():
        # LMAN-style "CopyLinks": copy the patch-tracker page for this
        # title (direct Sony links are blocked; orbispatches needs a
        # browser session for its Download buttons, so deep-link it).
        r = state.get("result")
        tid = (r.get("patch_tid") or "").upper() if r else ""
        if not tid:
            statusvar.set("No title ID for update link")
            return
        host = _PATCH_HOST.get(tid[:4], "https://orbispatches.com")
        url = host.rstrip("/") + "/" + tid
        try:
            root.clipboard_clear()
            root.clipboard_append(url)
            statusvar.set(f"Update page copied: {url}")
        except Exception as ex:
            statusvar.set(f"Copy failed: {ex}")

    def copy_all_info():
        # Copy everything about the open file: header rows + Details text.
        r = state.get("result")
        if not r:
            statusvar.set("Open a file first")
            return
        try:
            parts = [f"File = {r.get('path', '')}", ""]
            for k, v in r.get("rows", []):
                parts.append(f"{k} = {v}")
            try:
                det = metatext.get("1.0", "end-1c").strip()
            except Exception:
                det = ""
            if det:
                parts += ["", "-- Details --", det]
            root.clipboard_clear()
            root.clipboard_append("\n".join(parts))
            statusvar.set("Info copied to clipboard")
        except Exception as ex:
            statusvar.set(f"Copy failed: {ex}")

    def load(p):
        statusvar.set("Reading...")
        root.update_idletasks()
        try:
            r = parse_pkg(p)
        except Exception as e:
            statusvar.set(f"Error: {e}")
            _set_rename_enabled(False)
            return
        if not r.get("ok"):
            statusvar.set("Error: " + r.get("error", "?"))
            _set_rename_enabled(False)
            return
        state["result"] = r
        state["show_all"] = False
        detailvar.set("Show all")
        pathvar.set(os.path.basename(p))
        _set_title(r["title"])
        try:
            _ext = os.path.splitext(p)[1].lower()
            _fmt = {".ffpkg": "ffpkg", ".ffpfsc": "ffpfsc",
                    ".exfat": "exfat", ".pkg": "pkg",
                    ".nsp": "nsp", ".xci": "xci"}.get(_ext, "")
            _fl = state.get("fmtlabel")
            if _fl is not None:
                if _fmt and has_pil:
                    _fim = _format_icon_image(_fmt, (28, 28))
                    if _fim is not None:
                        _fph = ImageTk.PhotoImage(_fim)
                        state["fmt_photo"] = _fph
                        _fl.config(image=_fph, text="")
                    else:
                        state["fmt_photo"] = None
                        _fl.config(image="", text="")
                else:
                    state["fmt_photo"] = None
                    _fl.config(image="", text="")
        except Exception:
            pass
        plat = r["rows"][0][1] if r["rows"] else ""
        _rd = dict(r["rows"])
        badges = state.get("badges", [])
        _blabs = state.get("badge_labels", [])
        _type = _rd.get("Type", "")
        _has_lz4 = "LZ4" in _rd.get("Assets", "")
        _b0 = "LZ4" if _has_lz4 else plat
        _pkg = _rd.get("Package", "")
        _pl2 = _pkg.lower()
        if "fake" in _pl2 or "fpkg" in _pl2:
            _pkg_short, _pkg_col = "FPKG", "#e17b7b"
        elif "official" in _pl2 or _pl2.startswith("ofc"):
            _pkg_short, _pkg_col = "OFC", "#10b981"
        else:
            _pkg_short, _pkg_col = "", "#6b7280"
        _bvals = [_b0,
                  _rd.get("Region", ""),
                  f"{fmt_size(r['size'])}",
                  _type,
                  _pkg_short]
        _pl = plat.lower()
        if _has_lz4:
            _plat_col = "#6fd3c9"
        elif "ffpkg" in _pl:
            _plat_col = "#9b6ddb"
        elif "ffpfsc" in _pl:
            _plat_col = "#f2b84b"
        elif "exfat" in _pl:
            _plat_col = "#3dd6b0"
        elif "x360" in _pl or "xbox" in _pl:
            _plat_col = "#107C10"
        elif "wii" in _pl:
            _plat_col = "#009AC7"
        elif "ps2" in _pl:
            _plat_col = "#3b7dd8"
        elif "ps3" in _pl:
            _plat_col = "#e8a34c"
        elif "ps4" in _pl or _pl.startswith("cnt"):
            _plat_col = "#5fa8ff"
        elif "ps5" in _pl:
            _plat_col = "#f1f3f8"
        elif "switch" in _pl or "nsp" in _pl or "xci" in _pl:
            _plat_col = "#e60012"
        else:
            _plat_col = "#6b7280"
        _tl = _type.lower()
        _type_col = ("#5fa8ff" if "update" in _tl
                     else "#f59e5b" if ("dlc" in _tl or "patch" in _tl)
                     else "#10b981" if _type else "#6b7280")
        _bcolors = [_plat_col, "#e17b7b", "#6b7280", _type_col, _pkg_col]
        for i, (bv, val, lb, col) in enumerate(zip(badges, _bvals, _blabs, _bcolors)):
            bv.set(val or "")
            try:
                # white text on Nintendo red, dark text everywhere else
                _fg = "#f1f3f8" if (i == 0 and col == "#e60012") else "#171717"
                lb.config(bg=col, fg=_fg)
            except Exception:
                pass
            # dumps (e.g. PS5 folders) have no Package row: hide the
            # empty pill instead of leaving a blank badge
            try:
                if val:
                    lb.pack(side="left", padx=(0, 8), pady=2)
                else:
                    lb.pack_forget()
            except Exception:
                pass
        _flat = [(k, v) for (k, v) in r["rows"]
                 if k not in ("Platform", "Size", "Region",
                              "Content ID", "Type", "Package")
                 and str(v or "").strip() not in ("", "-")]
        # logical order for every format (identity → versions →
        # system → package); unknown keys stay at the end as parsed
        try:
            _prio = {k.lower(): i for i, k in enumerate(GRID_ORDER)}
            _flat = [kv for _, kv in
                     sorted(enumerate(_flat),
                            key=lambda t: (_prio.get(t[1][0].lower(), 999), t[0]))]
        except Exception:
            pass
        # CONTENT ID lives on its own bar above the grid: full + copyable
        try:
            _cid = str(_rd.get("Content ID", "") or "").strip()
            state.get("cidvar", tk.StringVar(value="")).set(_cid)
            if _cid and _cid != "-":
                state["cidrow"].pack(fill="x", pady=(0, 2))
            else:
                state["cidrow"].pack_forget()
        except Exception:
            pass
        # dynamic grid: one cell per row-item (2 columns), so nothing
        # gets cut (PS5 has 13+: ..., Min. System, DRM, SDK).
        _box = state.get("specbox")
        try:
            for _ch in _box.winfo_children():
                _ch.destroy()
        except Exception:
            pass
        cells = []
        # right-click any spec row -> copy it (this grid is read-only, so
        # nothing was selectable/copyable before; Details below already was)
        specctx = tk.Menu(root, tearoff=0, bg=CARD, fg=TEXT,
                          activebackground=ACCENT, activeforeground="#171717")
        specpick = {"k": "", "v": ""}

        def _spec_copy(with_label=False):
            try:
                _txt = (f"{specpick['k']}: {specpick['v']}" if with_label
                        else specpick["v"])
                root.clipboard_clear()
                root.clipboard_append(_txt)
                statusvar.set("Copied " + (specpick["k"] or "value"))
            except Exception as ex:
                statusvar.set(f"Copy failed: {ex}")

        specctx.add_command(label="Copy value",
                            command=lambda: _spec_copy(False))
        specctx.add_command(label="Copy label: value",
                            command=lambda: _spec_copy(True))
        try:
            for _i in range(0, len(_flat), 2):
                _row = ttk.Frame(_box, style="Card.TFrame")
                _row.pack(fill="x")
                _row.columnconfigure(0, weight=1)
                _row.columnconfigure(1, weight=1)
                for _col in (0, 1):
                    _cell = ttk.Frame(_row, style="Card.TFrame")
                    _cell.grid(row=0, column=_col, sticky="w", padx=(0, 12))
                    _k = ttk.Label(_cell, text="", style="SpecKey.TLabel",
                                   font=(FONT[0], 8))
                    _k.pack(anchor="w")
                    _v = tk.Entry(_cell, bg=CARD, fg=TEXT,
                                  font=(FONT[0], 9, "bold"),
                                  relief="flat", readonlybackground=CARD,
                                  highlightthickness=0,
                                  state="readonly", width=34)
                    _v.pack(anchor="w")

                    def _spec_menu(_ev, _kk=_k, _vv=_v):
                        try:
                            specpick["k"] = _kk.cget("text") or ""
                            specpick["v"] = _vv.get()
                        except Exception:
                            pass
                        specctx.tk_popup(_ev.x_root, _ev.y_root)

                    _k.bind("<Button-3>", _spec_menu)
                    _v.bind("<Button-3>", _spec_menu)
                    cells.append((_k, _v))
        except Exception:
            pass
        state["spec_cells"] = cells
        for (k, v), (kl, vl) in zip(_flat, cells):
            kl.config(text=k.upper())
            vl.config(state="normal")
            vl.delete(0, "end")
            vl.insert(0, str(v))
            try:
                vl.config(width=max(20, min(60, len(str(v)) + 2)))
            except Exception:
                pass
            vl.config(state="readonly")
        tree.delete(*tree.get_children())
        state["trp_children"] = {}
        # entries with paths (PS3 disc/folders, ISOs) become folders;
        # flat entries stay at the root, exactly like the old listing
        state["tree_dirs"] = populate_entry_tree(
            tree, r, state["trp_children"], open_depth=1)
        # Trophies tab: lazy — loads only when the tab is opened
        # (no trophy work during file load)
        state["trophy_path"] = None
        state["trophy_loading"] = None
        _trophy_reset("Open the Trophies tab to load")
        metatext.delete("1.0", "end")
        refresh_details()
        # image choices: png entries (+ switch jpeg icons).
        # PS3 discs/folders bury ~200 game-texture PNGs in USRDIR — the
        # Image tab only wants the XMB backdrop set (icon + PIC0/1/2).
        pngs = [e["name"] for e in r["entries"]
                if e["name"].lower().endswith((".png", ".jpg", ".jpeg")) and e["size"] > 0]
        if r.get("kind") == "ps3":
            _mains = [n for n in pngs if os.path.basename(n).upper()
                      in ("ICON0.PNG", "PIC0.PNG", "PIC1.PNG", "PIC2.PNG")]
            if _mains:
                pngs = _mains
        state["imgnames"] = pngs
        _fill_imgtab(pngs)
        if pngs:
            _bases = {os.path.basename(n).lower(): n for n in pngs}
            first = _bases.get("icon0.png", _bases.get("icon.jpg", pngs[0]))
            show_image(first)
            _ps3 = _ps3_cover_key(r)
            if _ps3:
                fetch_ps3_async(*_ps3)
            elif r.get("x360_tid"):
                fetch_x360_async(r["x360_tid"])
        elif r.get("store_cid"):
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="Fetching cover...")
            fetch_store_async(r["store_cid"])
        elif r.get("ps2_serial"):
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="Fetching cover...")
            fetch_ps2_async(r["ps2_serial"])
        elif _ps3_cover_key(r):
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="Fetching cover...")
            fetch_ps3_async(*_ps3_cover_key(r))
        elif r.get("x360_tid"):
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="Fetching cover...")
            fetch_x360_async(r["x360_tid"])
        elif r.get("wiiu_tid"):
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="Fetching icon...")
            fetch_wiiu_async(r["wiiu_tid"])
        else:
            state["pil"] = None
            _sync_imgtab()
            _fill_imgtab([])
            imglabel.config(image="", text="(no image)")
        if r.get("patch_tid"):
            fetch_patch_async(r["patch_tid"], r.get("own_ver", ""))
        if r.get("kind") == "x360" and r.get("x360_tid"):
            try:
                _mm = r.get("meta") or {}
                fetch_x360_tu_async(r["x360_tid"],
                                    _mm.get("media_id", ""),
                                    _mm.get("own_ver", ""))
            except Exception:
                pass
        _set_rename_enabled(True)
        _summ = lman_summary(r.get("kind"), dict(r["rows"]))
        _set_status((_summ + f"  •  {len(r['entries'])} entries") if _summ else
                    f"OK - {len(r['entries'])} entries")

    def refresh_details():
        r = state.get("result")
        metatext.delete("1.0", "end")
        if not r:
            return
        if state.get("show_all"):
            lines = full_meta_lines(r.get("meta"))
        else:
            lines = curated_meta_lines(r.get("kind"), r.get("meta"))
            # Show less: hide localized titles (TITLE_xx) — back with Show all
            _clean = []
            for _ln in lines:
                _kk = _ln.partition("=")[0].strip()
                if _kk.lower().startswith("title_") and _kk[6:7].isdigit():
                    continue
                _clean.append(_ln)
            lines = _clean
        # dedup: drop detail lines whose key OR value already appears
        # in the spec grid rows (Title/ID/Version etc. shown twice otherwise).
        # Show all is the raw dump, so Title/TITLE_ID are kept there.
        _ROWKEYS = {"package", "signature", "type", "title", "title_id",
                    "titleid", "content_id", "contentid", "version",
                    "app_ver", "appver", "system_ver", "systemver",
                    "category", "format", "parental_level", "parental",
                    "region", "size", "platform", "sdk", "drm",
                    "min. system", "min system", "passcode"}
        try:
            rowvals = set()
            for (_k, _v) in (r.get("rows") or []):
                _s = str(_v or "").strip().lower()
                if _s:
                    rowvals.add(_s)
                    try:
                        rowvals.add(normalize_version(_s))
                    except Exception:
                        pass
            if rowvals:
                kept = []
                for ln in lines:
                    if "=" in ln and not ln.startswith("--"):
                        _key, _, _val = ln.partition("=")
                        _key = _key.strip().lower()
                        _val = _val.strip().lower()
                        # localized titles (TITLE_xx) carry per-language
                        # info — never dedup them, even if the value
                        # matches the grid's Title row
                        _suf = _key[6:].strip() if _key.startswith("title_") else ""
                        if _suf[:1].isdigit():
                            kept.append(ln)
                            continue
                        # raw dump keeps TITLE / TITLE_ID (grid shows both)
                        if state.get("show_all") and _key in (
                                "title", "title_id", "titleid"):
                            kept.append(ln)
                            continue
                        if _key in _ROWKEYS:
                            continue
                        if _val and (_val in rowvals or normalize_version(_val) in rowvals):
                            continue
                    kept.append(ln)
                lines = kept
        except Exception:
            pass
        if r.get("ampr_lines"):
            lines = list(lines) + ["", "-- AMPR containers --"] + list(r["ampr_lines"])
        if r.get("store_lines"):
            lines = list(lines) + ([""] if lines else []) + \
                ["-- PlayStation Store --"] + list(r["store_lines"])
        _rd = dict(r.get("rows", []))
        # Entries/Built/Passcode now live in the grid above; the techy
        # Body offset stays here, but only in Show all (and only when
        # it exists).
        _layout = []
        if state.get("show_all") and r.get("kind") == "ps4" and r.get("body_off") is not None:
            try:
                _layout.append(f"Body @ {r['body_off']:#x}")
            except Exception:
                pass
        if _layout:
            lines = list(lines) + ([""] if lines else []) + \
                ["-- Layout --"] + _layout
        # Updates live in the banner at the top (not in this text),
        # so they are never buried below the fold.
        try:
            _pl = r.get("patch_lines") or []
            if _pl:
                _uptxt = "  •  ".join(_pl)
                state["updvar"].set(_uptxt)
                try:
                    state["updentry"].config(
                        fg="#10b981" if "up to date" in _uptxt.lower()
                        else "#f0b429")
                except Exception:
                    pass
                state["updrow"].pack(fill="x", pady=(0, 2))
            else:
                state["updrow"].pack_forget()
        except Exception:
            pass
        metatext.insert("end", "\n".join(lines) + ("\n" if lines else ""))
        # auto-height: the text box fits its content (no big empty
        # box when lines are few); hidden entirely when there is
        # nothing to show, so the buttons stay last at the bottom.
        try:
            if lines:
                metatext.pack(fill="both", expand=True)
                metatext.config(height=max(4, min(30, len(lines) + 1)))
            else:
                metatext.pack_forget()
        except Exception:
            pass

    def toggle_details():
        state["show_all"] = not state.get("show_all")
        detailvar.set("Show less" if state["show_all"] else "Show all")
        refresh_details()
        # Hint that there is more content below: grow the window a bit
        # on Show all, restore it on Show less.
        try:
            if state["show_all"]:
                if "win_h_before_expand" not in state:
                    state["win_h_before_expand"] = root.winfo_height()
                _w = root.winfo_width()
                _h = root.winfo_height()
                _sh = root.winfo_screenheight()
                _nh = min(_h + 140, max(_h + 40, _sh - 80))
                if _nh > _h:
                    root.geometry("%dx%d" % (_w, _nh))
                # nudge the Info scroll so the cut-off bottom row peeks in
                try:
                    infocanvas.update_idletasks()
                    infocanvas.yview_scroll(2, "units")
                    root.after(250, lambda: infocanvas.yview_scroll(-2, "units"))
                except Exception:
                    pass
            else:
                _prev = state.pop("win_h_before_expand", None)
                if _prev:
                    _w = root.winfo_width()
                    root.geometry("%dx%d" % (_w, int(_prev)))
                try:
                    infocanvas.yview_moveto(0.0)
                except Exception:
                    pass
        except Exception:
            pass

    def copy_text_selection(widget):
        try:
            sel = widget.get("sel.first", "sel.last")
        except Exception:
            sel = widget.get("1.0", "end-1c")
        root.clipboard_clear()
        root.clipboard_append(sel)
        statusvar.set("Text copied")
        return "break"

    def select_all_text(widget):
        widget.tag_add("sel", "1.0", "end-1c")
        return "break"

    def save_current_image():
        r = state.get("result")
        name = state.get("img_name")
        if not r or not name:
            statusvar.set("No image selected")
            return
        e = next((x for x in r["entries"] if x["name"] == name), None)
        data = state.get("store_bytes") if (not e and name == "cover.jpg") else None
        if data is None:
            if not e:
                return
            data = e.get("cached")
        if data is None:
            data = read_entry_bytes(r["path"], e["abs_off"], e["size"])
        if data[:8] != b"\x89PNG\r\n\x1a\n" and data[:2] != b"\xff\xd8":
            statusvar.set("Not an image")
            return
        dest = filedialog.asksaveasfilename(
            title="Save image", defaultextension=".png",
            initialdir=_srcdir(),
            initialfile=name.replace("/", "_"),
            filetypes=[("PNG", "*.png"), ("all", "*.*")])
        if not dest:
            return
        try:
            with open(dest, "wb") as out:
                out.write(data)
            statusvar.set(f"Saved {os.path.basename(dest)}")
        except Exception as ex:
            statusvar.set(f"Error: {ex}")

    def copy_current_image():
        pil = state.get("pil")
        if pil is None:
            statusvar.set("No image to copy")
            return
        err = copy_image_to_clipboard(pil)
        statusvar.set("Copied to clipboard" if err is None else f"Copy failed: {err}")

    def display_pil(im, label):
        """Render a PIL image on the fixed canvas. Returns None or error str."""
        try:
            state["pil"] = im.copy()
            state["img_name"] = label
            im.thumbnail((260, 260))
            canvas = Image.new("RGB", (280, 280), CARD)
            canvas.paste(im, ((280 - im.size[0]) // 2,
                              (280 - im.size[1]) // 2))
            ph = ImageTk.PhotoImage(canvas)
            state["photo"] = ph
            imglabel.config(image=ph, text="")
            imglabel.image = ph
            _sync_imgtab()
            _sync_leftcover()
            return None
        except Exception as ex:
            return str(ex)

    def fetch_store_async(cid):
        """Background: store cover + title → display via root.after."""
        def _work():
            try:
                name, url, rel, tag = fetch_store_cover(cid)
            except Exception:
                name, url, rel, tag = None, None, None, None
            data = b""
            if url:
                try:
                    data = download_url_bytes(url) or b""
                except Exception:
                    data = b""
            try:
                root.after(0, lambda: _store_done(name, data, rel, tag))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _store_done(name, data, rel, tag):
        r = state.get("result")
        if not r or not r.get("store_cid"):
            return
        if name and name != r["title"]:
            _set_title(name)
            r["title"] = name
        lines = []
        if name:
            lines.append(f"Title = {name}")
        if rel:
            lines.append(f"Release = {rel}")
        if tag:
            lines.append(f"Tagline = {tag}")
        if lines:
            r["store_lines"] = lines
            refresh_details()
        state["store_bytes"] = data if data[:8] == b"\x89PNG\r\n\x1a\n" or \
            data[:2] == b"\xff\xd8" else b""
        if not state["store_bytes"]:
            imglabel.config(image="", text="(cover unavailable)")
            return
        if not has_pil:
            imglabel.config(text="(Pillow not installed)")
            return
        try:
            im = Image.open(io.BytesIO(state["store_bytes"]))
        except Exception:
            imglabel.config(image="", text="(bad image)")
            return
        err = display_pil(im, "cover.jpg")
        if err:
            imglabel.config(text="(bad image)")
            statusvar.set(f"Error: {err}")
        else:
            state["imgnames"] = ["cover.jpg"]
            _fill_imgtab(["cover.jpg"])
            statusvar.set("OK - store cover")

    def fetch_ps2_async(serial):
        """Background: PS2 cover (ps2-covers) → display via root.after."""
        def _work():
            try:
                data = fetch_ps2_cover(serial) or b""
            except Exception:
                data = b""
            try:
                root.after(0, lambda: _ps2_cover_done(serial, data))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _ps2_cover_done(serial, data):
        r = state.get("result")
        if not r or r.get("ps2_serial") != serial:
            return
        state["store_bytes"] = data if data[:8] == b"\x89PNG\r\n\x1a\n" or \
            data[:2] == b"\xff\xd8" else b""
        if not state["store_bytes"]:
            imglabel.config(image="", text="(cover unavailable)")
            return
        if not has_pil:
            imglabel.config(text="(Pillow not installed)")
            return
        try:
            im = Image.open(io.BytesIO(state["store_bytes"]))
        except Exception:
            imglabel.config(image="", text="(bad image)")
            return
        # strip the PS2 header band; re-encode so Save/Copy match the view
        _cropped = ps2_cover_crop(im)
        if _cropped.size != im.size:
            im = _cropped
            try:
                _buf = io.BytesIO()
                im.convert("RGB").save(_buf, "JPEG", quality=92)
                state["store_bytes"] = _buf.getvalue()
            except Exception:
                pass
        err = display_pil(im, "cover.jpg")
        if err:
            imglabel.config(text="(bad image)")
            statusvar.set(f"Error: {err}")
        else:
            state["imgnames"] = ["cover.jpg"]
            _fill_imgtab(["cover.jpg"])
            statusvar.set("OK - PS2 cover")

    def fetch_wiiu_async(tid):
        """Background: Wii U official icon (IDBE) → display via root.after."""
        def _work():
            try:
                data = fetch_wiiu_icon(tid) or b""
            except Exception:
                data = b""
            try:
                root.after(0, lambda: _wiiu_icon_done(tid, data))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _wiiu_icon_done(tid, data):
        r = state.get("result")
        if not r or r.get("wiiu_tid") != tid:
            return
        state["store_bytes"] = data if data[:8] == b"\x89PNG\r\n\x1a\n" \
            else b""
        if not state["store_bytes"]:
            imglabel.config(image="", text="(cover unavailable)")
            return
        if not has_pil:
            imglabel.config(text="(Pillow not installed)")
            return
        try:
            im = Image.open(io.BytesIO(state["store_bytes"]))
        except Exception:
            imglabel.config(image="", text="(bad image)")
            return
        err = display_pil(im, "cover.jpg")
        if err:
            imglabel.config(text="(bad image)")
            statusvar.set(f"Error: {err}")
        else:
            state["imgnames"] = ["cover.jpg"]
            _fill_imgtab(["cover.jpg"])
            statusvar.set("OK - Wii U icon")

    def fetch_ps3_async(tid, region):
        """Background: PS3 square cover (GameTDB) → display via root.after."""
        def _work():
            try:
                data = fetch_ps3_cover(tid, region) or b""
            except Exception:
                data = b""
            try:
                root.after(0, lambda: _ps3_cover_done(tid, data))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _ps3_cover_done(tid, data):
        # Square box-front goes FIRST: hero shows it, Image tab lists
        # cover.jpg before the embedded rectangles (ICON0/PIC0...).
        r = state.get("result")
        if not r or r.get("kind") != "ps3":
            return
        try:
            _rd = dict(r.get("rows") or [])
            if str(_rd.get("Title ID", "") or "").strip().upper() != tid:
                return
        except Exception:
            pass
        state["store_bytes"] = data if data[:2] == b"\xff\xd8" else b""
        if not state["store_bytes"]:
            return  # keep the embedded art, if any
        if not has_pil:
            return
        try:
            im = Image.open(io.BytesIO(state["store_bytes"]))
        except Exception:
            return
        err = display_pil(im, "cover.jpg")
        if err:
            statusvar.set(f"Error: {err}")
        else:
            names = ["cover.jpg"] + [n for n in state.get("imgnames", [])
                                     if n != "cover.jpg"]
            state["imgnames"] = names
            _fill_imgtab(names)
            statusvar.set("OK - PS3 cover")

    def fetch_x360_async(tid):
        """Background: Xbox 360 flat cover (XboxUnity) → tab via root.after."""
        def _work():
            try:
                data = fetch_x360_cover(tid) or b""
            except Exception:
                data = b""
            try:
                root.after(0, lambda: _x360_cover_done(tid, data))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _x360_cover_done(tid, data):
        # Online flat cover becomes the hero + first in tab (like PS2/PS3):
        # the tiny embedded logo stays in the tab behind it.
        r = state.get("result")
        if not r or r.get("x360_tid") != tid:
            return
        if not (data[:8] == b"\x89PNG\r\n\x1a\n"
                or data[:2] == b"\xff\xd8"):
            return
        state["store_bytes"] = data
        if not has_pil:
            return
        try:
            im = Image.open(io.BytesIO(data))
        except Exception:
            return
        err = display_pil(im, "cover.jpg")
        if err:
            statusvar.set(f"Error: {err}")
        else:
            names = ["cover.jpg"] + [n for n in state.get("imgnames", [])
                                     if n != "cover.jpg"]
            state["imgnames"] = names
            _fill_imgtab(names)
            statusvar.set("OK - Xbox cover")

    def fetch_x360_tu_async(tid, media, own_ver):
        """Background: latest Xbox 360 TU → banner via root.after."""
        def _work():
            try:
                latest, count = fetch_x360_latest_tu(tid, media)
            except Exception:
                latest, count = "", 0
            try:
                root.after(0, lambda: _x360_tu_done(
                    tid, own_ver, latest, count))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _x360_tu_done(tid, own_ver, latest, count):
        r = state.get("result")
        if not r or r.get("x360_tid") != tid:
            return
        if not latest:
            return
        line1 = f"Latest TU = v{latest} ({count} known)"
        if own_ver:
            line1 += (" — up to date"
                      if own_ver.strip().lower() == ("v" + latest).lower()
                      else " — behind latest")
        else:
            line1 += " — XEX version unknown"
        r["patch_lines"] = [line1]
        refresh_details()

    def fetch_patch_async(tid, own_ver):
        """Background: latest patch version → Details via root.after."""
        def _work():
            try:
                latest, count, date = fetch_latest_patch(tid)
            except Exception:
                latest, count, date = None, 0, ""
            try:
                root.after(0, lambda: _patch_done(tid, own_ver, latest, count, date))
            except Exception:
                pass
        import threading as _th
        _th.Thread(target=_work, daemon=True).start()

    def _patch_done(tid, own_ver, latest, count, date):
        r = state.get("result")
        if not r or r.get("patch_tid") != tid:
            return
        if not latest:
            return
        ago = _ago(date)
        line1 = f"Latest patch = {latest} ({count} known)"
        if date:
            line1 += f" — {date[:10]}" + (f" ({ago})" if ago else "")
        # verdict only: the PKG version itself already lives in the
        # grid (VERSION), so repeating it here would duplicate it.
        if own_ver:
            line1 += (" — up to date" if own_ver.strip() == latest.strip()
                      else " — behind latest")
        else:
            line1 += " — PKG version unknown (encrypted)"
        r["patch_lines"] = [line1]
        refresh_details()

    def show_image(name):
        r = state.get("result")
        if not r:
            return
        e = next((x for x in r["entries"] if x["name"] == name), None)
        if not e and name != "cover.jpg":
            return
        if not e:
            # virtual entry: fetched online cover lives in store_bytes
            data = state.get("store_bytes") or b""
            if not data:
                imglabel.config(image="", text="(cover unavailable)")
                return
        else:
            statusvar.set(f"Extracting {name}...")
            root.update_idletasks()
            try:
                if e.get("local_path") and os.path.isfile(e["local_path"]):
                    with open(e["local_path"], "rb") as fh:
                        data = fh.read()
                elif e.get("cached") is not None:
                    data = e["cached"]
                else:
                    data = read_entry_bytes(r["path"], e["abs_off"], e["size"])
            except Exception as ex:
                statusvar.set(f"Error: {ex}")
                return
        if data[:8] != b"\x89PNG\r\n\x1a\n" and data[:2] != b"\xff\xd8":
            imglabel.config(image="", text="(not an image)")
            statusvar.set("OK")
            return
        if not has_pil:
            imglabel.config(text=f"PNG {fmt_size(len(data))}\n(Pillow not installed)")
            statusvar.set("OK")
            return
        try:
            im = Image.open(io.BytesIO(data))
            state["pil"] = im.copy()
            state["img_name"] = name
            im.thumbnail((260, 260))
            # fixed-size canvas: pad with card bg so layout never shifts
            canvas = Image.new("RGB", (280, 280), CARD)
            canvas.paste(im, ((280 - im.size[0]) // 2,
                              (280 - im.size[1]) // 2))
            ph = ImageTk.PhotoImage(canvas)
            state["photo"] = ph
            imglabel.config(image=ph, text="")
            imglabel.image = ph
            _sync_imgtab()
            _sync_leftcover()
            statusvar.set(f"OK - {name} ({im.size[0]}x{im.size[1]})")
        except Exception as ex:
            imglabel.config(text="(bad image)")
            statusvar.set(f"Error: {ex}")

    if start_path and os.path.exists(start_path):
        root.after(200, lambda: load(start_path))
    if has_dnd:
        def _on_drop(ev):
            import re as _re
            data = (ev.data or "").strip()
            if not data:
                return
            if data.startswith("{"):
                paths = [p.strip().strip("{}") for p in
                         _re.split(r"}\s+{", data)]
            else:
                paths = [data]
            paths = [p for p in paths if p and os.path.exists(p)]
            if paths:
                try:
                    try:
                        _grab = root.grab_current()
                    except Exception:
                        _grab = None
                    if _grab:
                        statusvar.set("Close the open dialog first, "
                                      "then drop again")
                    else:
                        show_batch(paths)  # single file falls through to load()
                except Exception as ex:
                    try:
                        statusvar.set(f"Drop failed: {ex}")
                    except Exception:
                        pass
        try:
            root.drop_target_register(DND_FILES)
            root.dnd_bind("<<Drop>>", _on_drop)
        except Exception as ex:
            statusvar.set(f"Drop disabled: {ex}")
    root.after(2500, lambda: check_updates())
    try:
        if _load_settings().get("pinned"):
            toggle_pin(True)
    except Exception:
        pass
    def _restore_cover_state():
        # runs after deiconify (withdrawn window has no real size yet)
        try:
            if _load_settings().get("cover_hidden"):
                toggle_cover(True)
        except Exception:
            pass
    root.after(150, _restore_cover_state)
    if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
        _startup = sys.argv[1]
        root.after(100, lambda: load(_startup))
    # First launch (or installer --first-install): show About (support links).
    _first_install = any(a == "--first-install" for a in sys.argv[1:])
    try:
        _about_done = bool(_load_settings().get("about_shown"))
    except Exception:
        _about_done = False
    if _first_install or not _about_done:
        try:
            _save_settings({"about_shown": True})
        except Exception:
            pass
        root.after(600, lambda: show_about())
    try:
        # show once, already at final size — no white flash / shrink jump
        root.update_idletasks()
        root.deiconify()
        root.update()  # full pump: the first map must complete for a valid HWND
        try:
            # Dark native title bar (Windows 10 20H1+ / 11): same family
            # look as the Avalonia apps. winfo_id() is the Tk client child,
            # so the frame HWND is its parent (verified: FindWindow match).
            # Must run after deiconify (withdrawn window has no HWND).
            # Native frame stays: snap + min/max/close work.
            import ctypes as _ct
            _hwnd = _ct.windll.user32.GetParent(root.winfo_id())
            _dark = _ct.c_int(1)
            # 20 = DWMWA_USE_IMMERSIVE_DARK_MODE (Win11), 19 = older value
            if _ct.windll.dwmapi.DwmSetWindowAttribute(
                    _hwnd, 20, _ct.byref(_dark), _ct.sizeof(_dark)) != 0:
                _ct.windll.dwmapi.DwmSetWindowAttribute(
                    _hwnd, 19, _ct.byref(_dark), _ct.sizeof(_dark))
        except Exception:
            pass
    except Exception:
        pass
    root.mainloop()


if __name__ == "__main__":
    if len(sys.argv) >= 3 and sys.argv[1] == "--info":
        print_info(sys.argv[2])
    elif len(sys.argv) >= 3 and sys.argv[1] == "--batch-rename":
        _args = sys.argv[2:]
        _apply = "--apply" in _args
        _rec = "--recursive" in _args
        _pattern = None
        _inputs = []
        _i = 0
        while _i < len(_args):
            if _args[_i] == "--name-pattern" and _i + 1 < len(_args):
                _pattern = _args[_i + 1]
                _i += 2
                continue
            if not _args[_i].startswith("--"):
                _inputs.append(_args[_i])
            _i += 1
        if not _inputs:
            print("usage: pkgviewer.py --batch-rename <file|folder> [...] "
                  "[--recursive] [--apply] [--name-pattern \"{tid}\"]")
        else:
            print_batch(_inputs, recursive=_rec, apply=_apply,
                        pattern=_pattern)
    elif len(sys.argv) >= 3 and sys.argv[1] == "--revert":
        _args = sys.argv[2:]
        _apply = "--apply" in _args
        _logs = [a for a in _args if not a.startswith("--")]
        import glob as _glob
        _expanded = []
        for _l in _logs:
            _g = _glob.glob(_l) if ("*" in _l or "?" in _l) else [_l]
            _expanded.extend(_g or [_l])
        _logs = _expanded
        if not _logs:
            print("usage: pkgviewer.py --revert <batch_rename_*.log> [--apply]")
        else:
            for _log in _logs:
                _pairs = parse_revert_log(_log)
                if not _pairs:
                    print(f"{_log}: no valid entries (bad log or empty).")
                    continue
                if not _apply:
                    print(f"{_log}: dry run, {len(_pairs)} entries "
                          f"(re-run with --apply to revert):")
                    for _cur, _rst in _pairs:
                        print(f"  [REVERT] {os.path.basename(_cur)}  ->  "
                              f"{os.path.basename(_rst)}")
                    continue
                _rev, _skip = apply_revert(_pairs)
                print(f"{_log}: reverted {len(_rev)}, skipped {len(_skip)}.")
                for _cur, _reason in _skip:
                    print(f"  [SKIP] {os.path.basename(_cur)} ({_reason})")
    elif len(sys.argv) >= 2 and os.path.exists(sys.argv[1]):
        run_gui(sys.argv[1])
    elif len(sys.argv) >= 2 and sys.argv[1] == "--info":
        print("usage: pkgviewer.py --info <file.pkg/.iso/.nsp/.xci>")
    else:
        run_gui()