rl-item-mod 1.0.0

package/python/rl_upk_editor.py

@@ -0,0 +1,3859 @@
+#!/usr/bin/env python3
+import argparse
+import base64
+import concurrent.futures
+import ctypes
+import hashlib
+import io
+import os
+import struct
+import sys
+import threading
+import traceback
+import zlib
+from dataclasses import dataclass, field
+import re
+import zipfile
+from pathlib import Path
+from typing import BinaryIO, Dict, List, Optional, Tuple
+
+import tkinter as tk
+from tkinter import filedialog, messagebox, simpledialog, ttk
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+PACKAGE_FILE_TAG = 0x9E2A83C1
+COMPRESS_NONE = 0x00
+COMPRESS_ZLIB = 0x01
+PKG_COOKED = 0x00000008
+DEFAULT_KEY = bytes([
+    0xC7, 0xDF, 0x6B, 0x13, 0x25, 0x2A, 0xCC, 0x71,
+    0x47, 0xBB, 0x51, 0xC9, 0x8A, 0xD7, 0xE3, 0x4B,
+    0x7F, 0xE5, 0x00, 0xB7, 0x7F, 0xA5, 0xFA, 0xB2,
+    0x93, 0xE2, 0xF2, 0x4E, 0x6B, 0x17, 0xE7, 0x79,
+])
+HEX_PREVIEW_LIMIT = 65536
+COMPACT_INDEX_DEPRECATED = 178
+NUMBER_ADDED_TO_NAME = 343
+ENUM_NAME_ADDED_TO_BYTE_PROPERTY_TAG = 633
+BOOL_VALUE_TO_BYTE_FOR_BOOL_PROPERTY_TAG = 673
+
+
+class BinaryReader:
+    def __init__(self, fh: BinaryIO):
+        self.fh = fh
+
+    def tell(self) -> int:
+        return self.fh.tell()
+
+    def seek(self, offset: int, whence: int = os.SEEK_SET) -> int:
+        return self.fh.seek(offset, whence)
+
+    def read_exact(self, size: int) -> bytes:
+        data = self.fh.read(size)
+        if len(data) != size:
+            raise EOFError(f"Expected {size} bytes, got {len(data)}")
+        return data
+
+    def read_i32(self) -> int:
+        return struct.unpack("<i", self.read_exact(4))[0]
+
+    def read_u32(self) -> int:
+        return struct.unpack("<I", self.read_exact(4))[0]
+
+    def read_u64(self) -> int:
+        return struct.unpack("<Q", self.read_exact(8))[0]
+
+    def read_u16(self) -> int:
+        return struct.unpack("<H", self.read_exact(2))[0]
+
+    def read_i64(self) -> int:
+        return struct.unpack("<q", self.read_exact(8))[0]
+
+    def read_u8(self) -> int:
+        return struct.unpack("<B", self.read_exact(1))[0]
+
+    def read_i8(self) -> int:
+        return struct.unpack("<b", self.read_exact(1))[0]
+
+    def read_f32(self) -> float:
+        return struct.unpack("<f", self.read_exact(4))[0]
+
+    def remaining(self) -> int:
+        cur = self.tell()
+        self.seek(0, os.SEEK_END)
+        end = self.tell()
+        self.seek(cur)
+        return end - cur
+
+    def read_fstring(self) -> str:
+        length = self.read_i32()
+        if length == 0:
+            return ""
+        if length < 0:
+            char_count = -length
+            raw = self.read_exact(char_count * 2)
+            return raw[:-2].decode("utf-16-le", errors="ignore")
+        raw = self.read_exact(length - 1)
+        self.read_exact(1)
+        # UE3 positive length strings are ANSI/Windows-1252, not UTF-8
+        return raw.decode("windows-1252", errors="ignore")
+
+
+@dataclass
+class FNameRef:
+    name_index: int
+    instance_number: int
+
+
+@dataclass
+class NameEntry:
+    index: int
+    name: str
+    flags: int
+
+
+@dataclass
+class ImportEntry:
+    table_index: int
+    class_package: FNameRef
+    class_name: FNameRef
+    outer_index: int
+    object_name: FNameRef
+
+
+@dataclass
+class ExportEntry:
+    table_index: int
+    class_index: int
+    super_index: int
+    outer_index: int
+    object_name: FNameRef
+    archetype_index: int
+    object_flags: int
+    serial_size: int
+    serial_offset: int
+    export_flags: int
+    net_objects: List[int]
+    package_guid: Tuple[int, int, int, int]
+    package_flags: int
+
+
+@dataclass
+class FCompressedChunk:
+    uncompressed_offset: int
+    uncompressed_size: int
+    compressed_offset: int
+    compressed_size: int
+
+
+@dataclass
+class FileSummary:
+    tag: int = 0
+    file_version: int = 0
+    licensee_version: int = 0
+    total_header_size: int = 0
+    folder_name: str = ""
+    package_flags_flags_offset: int = 0
+    package_flags: int = 0
+    name_count: int = 0
+    name_offset: int = 0
+    export_count: int = 0
+    export_offset: int = 0
+    import_count: int = 0
+    import_offset: int = 0
+    depends_offset: int = 0
+    import_export_guids_offset: int = 0
+    import_guids_count: int = 0
+    export_guids_count: int = 0
+    thumbnail_table_offset: int = 0
+    guid: Tuple[int, int, int, int] = (0, 0, 0, 0)
+    generations: List[Tuple[int, int, int]] = field(default_factory=list)
+    engine_version: int = 0
+    cooker_version: int = 0
+    compression_flags_offset: int = 0
+    compression_flags: int = 0
+    compressed_chunks: List[FCompressedChunk] = field(default_factory=list)
+
+
+@dataclass
+class FileCompressionMetaData:
+    garbage_size: int
+    compressed_chunks_offset: int
+    last_block_size: int
+
+
+@dataclass
+class ParsedPackage:
+    file_path: Path
+    summary: FileSummary
+    names: List[NameEntry]
+    imports: List[ImportEntry]
+    exports: List[ExportEntry]
+    file_bytes: bytes
+
+    def object_data(self, export: ExportEntry) -> bytes:
+        start = export.serial_offset
+        end = start + export.serial_size
+        if start < 0 or end < start or end > len(self.file_bytes):
+            return b""
+        return self.file_bytes[start:end]
+
+    def resolve_name(self, ref: FNameRef) -> str:
+        if 0 <= ref.name_index < len(self.names):
+            base = self.names[ref.name_index].name
+        else:
+            base = f"<Name#{ref.name_index}>"
+        return f"{base}_{ref.instance_number}" if ref.instance_number > 0 else base
+
+    def resolve_object_ref(self, index: int) -> str:
+        if index == 0:
+            return "None"
+        if index > 0:
+            export_index = index - 1
+            if 0 <= export_index < len(self.exports):
+                exp = self.exports[export_index]
+                return f"Export[{export_index}] {self.resolve_name(exp.object_name)}"
+            return f"Export[{export_index}] <invalid>"
+        import_index = -index - 1
+        if 0 <= import_index < len(self.imports):
+            imp = self.imports[import_index]
+            return f"Import[{import_index}] {self.resolve_name(imp.object_name)}"
+        return f"Import[{import_index}] <invalid>"
+
+    def resolve_object_path(self, index: int, seen: Optional[set] = None) -> str:
+        if index == 0:
+            return "None"
+        if seen is None:
+            seen = set()
+        if index in seen:
+            return "<cycle>"
+        seen.add(index)
+        if index > 0:
+            exp = self.exports[index - 1]
+            name = self.resolve_name(exp.object_name)
+            if exp.outer_index == 0:
+                return name
+            return f"{self.resolve_object_path(exp.outer_index, seen)}.{name}"
+        imp = self.imports[-index - 1]
+        name = self.resolve_name(imp.object_name)
+        if imp.outer_index == 0:
+            return name
+        return f"{self.resolve_object_path(imp.outer_index, seen)}.{name}"
+
+    def export_class_name(self, export: ExportEntry) -> str:
+        if export.class_index == 0:
+            return "Class"
+        if export.class_index > 0:
+            target = self.exports[export.class_index - 1]
+            return self.resolve_name(target.object_name)
+        target = self.imports[-export.class_index - 1]
+        return self.resolve_name(target.object_name)
+
+    def is_placeholder_export(self, export: ExportEntry) -> bool:
+        # An export is a placeholder/garbage slot if its class is the meta
+        # 'Class' (class_index == 0), its name resolves to literal 'None'
+        # (name table index 0 in UE3), it has no outer, no serial body, and
+        # no flags set. UE Explorer filters these out of its class list using
+        # essentially the same predicate (ClassIndex == 0 && Name == 'None').
+        # We additionally require zero size/offset/flags to avoid false
+        # positives on rare native objects whose class index is 0.
+        if export.class_index != 0:
+            return False
+        name = self.resolve_name(export.object_name)
+        if name.lower() != "none":
+            return False
+        if export.outer_index != 0:
+            return False
+        if export.serial_size != 0 or export.serial_offset != 0:
+            return False
+        if export.object_flags != 0 or export.export_flags != 0:
+            return False
+        return True
+
+    def resolve_export_class_candidates(self, export: ExportEntry) -> List[str]:
+        raw = self.export_class_name(export)
+        candidates = [raw]
+        for prefix in ("A", "U", "F"):
+            candidates.append(f"{prefix}{raw}")
+        return candidates
+
+
+@dataclass
+class SDKField:
+    name: str
+    type_name: str
+    offset: int
+    size: int
+    owner: str
+
+
+@dataclass
+class SDKType:
+    name: str
+    kind: str
+    super_name: Optional[str]
+    fields: List[SDKField] = field(default_factory=list)
+
+
+@dataclass
+class ParsedProperty:
+    index: int
+    name: str
+    tag_type: str
+    size: int
+    array_index: int
+    tag_offset: int
+    value_offset: int
+    value: str
+    declared_type: str = "?"
+    owner_type: str = "?"
+    struct_name: Optional[str] = None
+    enum_name: Optional[str] = None
+    bool_value: Optional[bool] = None
+    raw_hex: str = ""
+
+
+class RLSDKDatabase:
+    def __init__(self):
+        self.types: Dict[str, SDKType] = {}
+
+    def get_type(self, name: str) -> Optional[SDKType]:
+        if name in self.types:
+            return self.types[name]
+        for candidate in (name, f"A{name}", f"U{name}", f"F{name}"):
+            if candidate in self.types:
+                return self.types[candidate]
+        return None
+
+    def resolve_field(self, owner_name: str, field_name: str) -> Tuple[Optional[SDKField], Optional[str]]:
+        seen = set()
+        cur = self.get_type(owner_name)
+        while cur and cur.name not in seen:
+            seen.add(cur.name)
+            for field in cur.fields:
+                if field.name == field_name:
+                    return field, cur.name
+            cur = self.get_type(cur.super_name) if cur.super_name else None
+        return None, None
+
+
+def parse_rlsdk_database(zip_path: Path) -> RLSDKDatabase:
+    db = RLSDKDatabase()
+    class_re = re.compile(r"//\s+(?:Class|ScriptStruct)\s+[^\n]+\n//[^\n]*\n(?:class|struct)\s+(\w+)(?:\s*:\s*public\s+(\w+))?\s*\{(.*?)\n\};", re.S)
+    field_re = re.compile(r"^\s*(.+?)\s+(\w+)(?:\[[^\]]+\])?;\s*//\s*0x([0-9A-Fa-f]+)\s*\(0x([0-9A-Fa-f]+)\)", re.M)
+    with zipfile.ZipFile(zip_path) as zf:
+        for name in zf.namelist():
+            if not name.endswith(("_classes.hpp", "_structs.hpp")):
+                continue
+            text = zf.read(name).decode("utf-8", errors="ignore")
+            kind = "class" if name.endswith("_classes.hpp") else "struct"
+            for m in class_re.finditer(text):
+                type_name, super_name, body = m.groups()
+                sdk_type = db.types.get(type_name)
+                if sdk_type is None:
+                    sdk_type = SDKType(name=type_name, kind=kind, super_name=super_name)
+                    db.types[type_name] = sdk_type
+                else:
+                    sdk_type.kind = kind
+                    sdk_type.super_name = super_name
+                fields: List[SDKField] = []
+                for fm in field_re.finditer(body):
+                    type_name_raw, field_name, offset_hex, size_hex = fm.groups()
+                    fields.append(SDKField(
+                        name=field_name,
+                        type_name=" ".join(type_name_raw.split()),
+                        offset=int(offset_hex, 16),
+                        size=int(size_hex, 16),
+                        owner=type_name,
+                    ))
+                sdk_type.fields = fields
+    return db
+
+
+COMMON_STRUCT_DECODERS = {
+    "FVector": lambda r: f"({r.read_f32():.6g}, {r.read_f32():.6g}, {r.read_f32():.6g})",
+    "FVector2D": lambda r: f"({r.read_f32():.6g}, {r.read_f32():.6g})",
+    "FRotator": lambda r: f"({r.read_i32()}, {r.read_i32()}, {r.read_i32()})",
+    "FColor": lambda r: f"RGBA({r.read_u8()}, {r.read_u8()}, {r.read_u8()}, {r.read_u8()})",
+    "FLinearColor": lambda r: f"({r.read_f32():.6g}, {r.read_f32():.6g}, {r.read_f32():.6g}, {r.read_f32():.6g})",
+    "FQuat": lambda r: f"({r.read_f32():.6g}, {r.read_f32():.6g}, {r.read_f32():.6g}, {r.read_f32():.6g})",
+    "FGuid": lambda r: f"{r.read_u32():08X}-{r.read_u32():08X}-{r.read_u32():08X}-{r.read_u32():08X}",
+}
+
+
+def parse_tarray_inner_type(type_name: str) -> Optional[str]:
+    m = re.search(r"TArray<(.+)>", type_name)
+    if not m:
+        return None
+    return " ".join(m.group(1).split())
+
+
+def clean_cpp_type_name(type_name: str) -> str:
+    t = type_name.replace("class ", "").replace("struct ", "").strip()
+    return t.rstrip("*").strip()
+
+
+def decode_name_ref(raw: bytes, package: ParsedPackage) -> str:
+    if not raw:
+        return ""
+    bio = io.BytesIO(raw)
+    r = BinaryReader(bio)
+    ref = read_fname_pkg(r, package)
+    return package.resolve_name(ref)
+
+
+def decode_object_ref(raw: bytes, package: ParsedPackage) -> str:
+    if not raw:
+        return ""
+    bio = io.BytesIO(raw)
+    r = BinaryReader(bio)
+    index = read_index_pkg(r, package)
+    return f"{index} ({package.resolve_object_ref(index)})"
+
+
+def decode_array_preview(raw: bytes, inner_type: Optional[str], package: ParsedPackage) -> str:
+    if len(raw) < 4:
+        return raw.hex(" ").upper()
+    bio = io.BytesIO(raw)
+    r = BinaryReader(bio)
+    count = read_index_pkg(r, package)
+    if count < 0:
+        return f"count={count} (invalid)"
+    if count == 0:
+        return "count=0"
+    if not inner_type:
+        return f"count={count}, data={raw[4:36].hex(' ').upper()}"
+    inner_clean = clean_cpp_type_name(inner_type)
+    preview = []
+    try:
+        for _ in range(min(count, 4)):
+            if inner_clean in ("int32_t", "INT", "DWORD") and r.remaining() >= 4:
+                preview.append(str(r.read_i32()))
+            elif inner_clean == "float" and r.remaining() >= 4:
+                preview.append(f"{r.read_f32():.6g}")
+            elif inner_clean in ("FName", "class FName") and r.remaining() >= 8:
+                preview.append(package.resolve_name(read_fname_pkg(r, package)))
+            elif inner_clean.startswith("U") and r.remaining() >= 4:
+                preview.append(package.resolve_object_ref(read_index_pkg(r, package)))
+            elif inner_clean in COMMON_STRUCT_DECODERS:
+                preview.append(COMMON_STRUCT_DECODERS[inner_clean](r))
+            else:
+                break
+    except Exception:
+        pass
+    if preview:
+        return f"count={count}, preview=[{', '.join(preview)}]"
+    return f"count={count}, data={raw[4:36].hex(' ').upper()}"
+
+
+def decode_property_value(tag_type: str, raw: bytes, package: ParsedPackage, declared_type: str = "", struct_name: Optional[str] = None, enum_name: Optional[str] = None, bool_value: Optional[bool] = None) -> str:
+    try:
+        if tag_type == "BoolProperty":
+            if bool_value is not None:
+                return "True" if bool_value else "False"
+            if raw:
+                return "True" if raw[0] else "False"
+            return "False"
+        if tag_type == "IntProperty" and len(raw) >= 4:
+            return str(struct.unpack("<i", raw[:4])[0])
+        if tag_type == "FloatProperty" and len(raw) >= 4:
+            return f"{struct.unpack('<f', raw[:4])[0]:.6g}"
+        if tag_type in ("ObjectProperty", "ClassProperty", "ComponentProperty", "InterfaceProperty"):
+            return decode_object_ref(raw, package)
+        if tag_type == "NameProperty":
+            return decode_name_ref(raw, package)
+        if tag_type == "StrProperty":
+            return BinaryReader(io.BytesIO(raw)).read_fstring()
+        if tag_type == "ByteProperty":
+            if enum_name and len(raw) >= 8:
+                return decode_name_ref(raw, package)
+            if raw:
+                return str(raw[0])
+        if tag_type == "StructProperty":
+            if struct_name in COMMON_STRUCT_DECODERS:
+                return COMMON_STRUCT_DECODERS[struct_name](BinaryReader(io.BytesIO(raw)))
+            return f"{struct_name or '?'} ({len(raw)} bytes)"
+        if tag_type == "ArrayProperty":
+            return decode_array_preview(raw, parse_tarray_inner_type(declared_type), package)
+        if tag_type == "QWordProperty" and len(raw) >= 8:
+            return str(struct.unpack("<Q", raw[:8])[0])
+        if tag_type == "StringRefProperty" and len(raw) >= 4:
+            return str(struct.unpack("<I", raw[:4])[0])
+        if tag_type == "DelegateProperty":
+            if raw:
+                rr = BinaryReader(io.BytesIO(raw))
+                obj = read_index_pkg(rr, package)
+                func = package.resolve_name(read_fname_pkg(rr, package))
+                return f"obj={package.resolve_object_ref(obj)}, func={func}"
+        if raw:
+            return raw[:32].hex(" ").upper()
+        return ""
+    except Exception as exc:
+        return f"<decode error: {exc}>"
+
+
+VALID_PROPERTY_TYPES = {
+    "ByteProperty", "IntProperty", "BoolProperty", "FloatProperty", "ObjectProperty",
+    "NameProperty", "DelegateProperty", "ClassProperty", "ArrayProperty", "StructProperty",
+    "VectorProperty", "RotatorProperty", "StrProperty", "MapProperty", "FixedArrayProperty",
+    "InterfaceProperty", "ComponentProperty", "QWordProperty", "PointerProperty",
+    "StringRefProperty", "BioMask4Property", "GuidProperty"
+}
+
+
+def _valid_name_ref(ref: FNameRef, package: ParsedPackage) -> bool:
+    return 0 <= ref.name_index < len(package.names) and ref.instance_number >= -1
+
+
+def _parse_property_tag_at(package: ParsedPackage, raw: bytes, offset: int, index: int) -> Tuple[Optional[ParsedProperty], int, bool]:
+    if offset < 0 or offset + 8 > len(raw):
+        return None, offset, False
+    r = BinaryReader(io.BytesIO(raw))
+    r.seek(offset)
+    try:
+        tag_offset = offset
+        name_ref = read_fname_pkg(r, package)
+        if not _valid_name_ref(name_ref, package):
+            return None, offset, False
+        name = package.resolve_name(name_ref)
+        if name == "None":
+            return None, r.tell(), True
+
+        type_ref = read_fname_pkg(r, package)
+        if not _valid_name_ref(type_ref, package):
+            return None, offset, False
+        tag_type = package.resolve_name(type_ref)
+        if tag_type not in VALID_PROPERTY_TYPES:
+            return None, offset, False
+
+        size = r.read_i32()
+        array_index = r.read_i32()
+        if size < 0 or array_index < 0:
+            return None, offset, False
+
+        struct_name = None
+        enum_name = None
+        bool_value = None
+        declared_type = "?"
+
+        if tag_type == "StructProperty":
+            sref = read_fname_pkg(r, package)
+            if not _valid_name_ref(sref, package):
+                return None, offset, False
+            struct_name = package.resolve_name(sref)
+            declared_type = struct_name
+        elif tag_type == "ByteProperty":
+            if package.summary.file_version >= ENUM_NAME_ADDED_TO_BYTE_PROPERTY_TAG:
+                eref = read_fname_pkg(r, package)
+                if not _valid_name_ref(eref, package):
+                    return None, offset, False
+                enum_name = package.resolve_name(eref)
+                declared_type = enum_name or "Byte"
+            else:
+                declared_type = "Byte"
+        elif tag_type == "ArrayProperty":
+            declared_type = "TArray"
+        elif tag_type == "BoolProperty":
+            if package.summary.file_version >= BOOL_VALUE_TO_BYTE_FOR_BOOL_PROPERTY_TAG:
+                bool_value = bool(r.read_u8())
+            declared_type = "bool"
+        else:
+            declared_type = {
+                "IntProperty": "int",
+                "FloatProperty": "float",
+                "ObjectProperty": "UObject*",
+                "ClassProperty": "UClass*",
+                "ComponentProperty": "UObject*",
+                "InterfaceProperty": "UObject*",
+                "NameProperty": "FName",
+                "StrProperty": "FString",
+                "DelegateProperty": "FScriptDelegate",
+                "QWordProperty": "uint64",
+                "PointerProperty": "pointer",
+                "StringRefProperty": "uint32",
+                "MapProperty": "TMap",
+                "FixedArrayProperty": "array",
+                "GuidProperty": "FGuid",
+                "BioMask4Property": "BioMask4",
+            }.get(tag_type, tag_type)
+
+        value_offset = r.tell()
+        if value_offset + size > len(raw):
+            return None, offset, False
+        value_raw = raw[value_offset:value_offset + size]
+        value = decode_property_value(tag_type, value_raw, package, declared_type, struct_name, enum_name, bool_value)
+        prop = ParsedProperty(
+            index=index,
+            name=name,
+            tag_type=tag_type,
+            size=size,
+            array_index=array_index,
+            tag_offset=tag_offset,
+            value_offset=value_offset,
+            value=value,
+            declared_type=declared_type,
+            owner_type="SerializedTag",
+            struct_name=struct_name,
+            enum_name=enum_name,
+            bool_value=bool_value,
+            raw_hex=value_raw[:64].hex(" ").upper(),
+        )
+        return prop, value_offset + size, False
+    except Exception:
+        return None, offset, False
+
+
+def _try_parse_property_stream(package: ParsedPackage, raw: bytes, start_offset: int) -> Tuple[int, List[ParsedProperty], bool]:
+    props: List[ParsedProperty] = []
+    offset = start_offset
+    seen = set()
+    ended = False
+    for i in range(4096):
+        if offset in seen:
+            break
+        seen.add(offset)
+        prop, next_offset, hit_end = _parse_property_tag_at(package, raw, offset, i)
+        if hit_end:
+            ended = True
+            offset = next_offset
+            break
+        if prop is None:
+            break
+        props.append(prop)
+        offset = next_offset
+    return offset, props, ended
+
+
+def _find_best_property_stream_offset(package: ParsedPackage, raw: bytes, class_type: Optional[SDKType] = None, sdk_db: Optional[RLSDKDatabase] = None) -> Tuple[int, List[ParsedProperty]]:
+    del class_type, sdk_db
+    if len(raw) < 24:
+        return 0, []
+
+    best_offset = 0
+    best_props: List[ParsedProperty] = []
+    best_score = -1
+    max_scan = max(0, len(raw) - 24)
+    for start in range(max_scan + 1):
+        name_index = struct.unpack_from('<i', raw, start)[0]
+        if not (0 <= name_index < len(package.names)):
+            continue
+        end_off, props, ended = _try_parse_property_stream(package, raw, start)
+        if not props:
+            continue
+        score = len(props) * 1000
+        if ended:
+            score += 250
+        score += min(end_off - start, 512)
+        score -= start
+        if score > best_score:
+            best_score = score
+            best_offset = start
+            best_props = props
+    return best_offset, best_props
+
+
+def parse_serialized_properties(package: ParsedPackage, export: ExportEntry, sdk_db: Optional[RLSDKDatabase]) -> List[ParsedProperty]:
+    del sdk_db
+    raw = package.object_data(export)
+    if not raw:
+        return []
+    _, props = _find_best_property_stream_offset(package, raw, None, None)
+    return props
+
+class DecryptionProvider:
+    def __init__(self, key_file_path: Optional[str] = None):
+        if key_file_path is None:
+            self.decryption_keys = [DEFAULT_KEY]
+        else:
+            if not os.path.exists(key_file_path):
+                raise FileNotFoundError(f"Failed to load the key file: {key_file_path}")
+            with open(key_file_path, "r", encoding="utf-8") as fh:
+                self.decryption_keys = [
+                    base64.b64decode(line.strip())
+                    for line in fh
+                    if line.strip()
+                ]
+
+    @staticmethod
+    def decrypt_ecb(key: bytes, data: bytes) -> bytes:
+        cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+        decryptor = cipher.decryptor()
+        return decryptor.update(data) + decryptor.finalize()
+
+    @staticmethod
+    def encrypt_ecb(key: bytes, data: bytes) -> bytes:
+        cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+        encryptor = cipher.encryptor()
+        return encryptor.update(data) + encryptor.finalize()
+
+
+def find_valid_key(encrypted_path: Path, provider: DecryptionProvider) -> Tuple[FileSummary, FileCompressionMetaData, bytes, bytes]:
+    with encrypted_path.open("rb") as src:
+        summary = parse_file_summary(src)
+        meta = parse_file_compression_metadata(src)
+        encrypted_size = summary.total_header_size - meta.garbage_size - summary.name_offset
+        if encrypted_size < 0:
+            raise ValueError(
+                f"Computed encrypted region size is negative ({encrypted_size}). "
+                f"summary.total_header_size={summary.total_header_size}, "
+                f"meta.garbage_size={meta.garbage_size}, "
+                f"summary.name_offset={summary.name_offset}. "
+                f"This usually indicates a corrupted or already-edited package header."
+            )
+        encrypted_size = (encrypted_size + 15) & ~15
+        src.seek(summary.name_offset)
+        encrypted_data = src.read(encrypted_size)
+        if len(encrypted_data) != encrypted_size:
+            raise ValueError(
+                f"Failed to read encrypted region: expected {encrypted_size} bytes "
+                f"at offset {summary.name_offset}, got {len(encrypted_data)} (file truncated?)"
+            )
+    for key in provider.decryption_keys:
+        if verify_decryptor(summary, meta, key, encrypted_data):
+            return summary, meta, encrypted_data, key
+    raise ValueError("Unknown Decryption key")
+
+
+def serialize_rl_chunk_table(chunks: List[FCompressedChunk]) -> bytes:
+    out = bytearray()
+    out += struct.pack("<i", len(chunks))
+    for chunk in chunks:
+        out += struct.pack("<q", chunk.uncompressed_offset)
+        out += struct.pack("<i", chunk.uncompressed_size)
+        out += struct.pack("<q", chunk.compressed_offset)
+        out += struct.pack("<i", chunk.compressed_size)
+    return bytes(out)
+
+
+def compress_chunk_payload(uncompressed: bytes, block_size: int = 0x20000, level: int = 6) -> bytes:
+    out = bytearray()
+    out += struct.pack("<I", PACKAGE_FILE_TAG)
+    out += struct.pack("<i", block_size)
+    blocks = []
+    total_compressed = 0
+    for i in range(0, len(uncompressed), block_size):
+        piece = uncompressed[i:i + block_size]
+        comp = zlib.compress(piece, level)
+        blocks.append((comp, len(piece)))
+        total_compressed += len(comp)
+    out += struct.pack("<ii", total_compressed, len(uncompressed))
+    for comp, uncomp_size in blocks:
+        out += struct.pack("<ii", len(comp), uncomp_size)
+    for comp, _ in blocks:
+        out += comp
+    return bytes(out)
+
+
+def _find_file_compression_metadata_offsets(stream: BinaryIO) -> Dict[str, int]:
+    parse_file_summary(stream)
+    meta_offset = stream.tell()
+    r = BinaryReader(stream)
+    garbage_size_offset = meta_offset
+    r.read_i32()
+    compressed_chunks_offset_offset = stream.tell()
+    r.read_i32()
+    last_block_size_offset = stream.tell()
+    r.read_i32()
+    return {
+        "meta_offset": meta_offset,
+        "garbage_size_offset": garbage_size_offset,
+        "compressed_chunks_offset_offset": compressed_chunks_offset_offset,
+        "last_block_size_offset": last_block_size_offset,
+    }
+
+
+def find_key_for_encrypted_upk(encrypted_path: Path, provider: DecryptionProvider) -> bytes:
+    """Return the first key from *provider* that successfully decrypts *encrypted_path*.
+
+    Raises ValueError if no key in the provider works.
+    """
+    _, _, _, key = find_valid_key(encrypted_path, provider)
+    return key
+
+
+def build_reencrypted_package(original_encrypted_path: Path, modified_decrypted_bytes: bytes, provider: DecryptionProvider, output_path: Path, *, override_key: Optional[bytes] = None) -> Path:
+    summary, meta, original_encrypted_data, valid_key = find_valid_key(original_encrypted_path, provider)
+    # If the caller wants to encrypt with a different key (e.g. sourced from a
+    # donor encrypted UPK), use that key for the output instead of the key that
+    # was used to decrypt the original package.
+    if override_key is not None:
+        valid_key = override_key
+    modified_summary = parse_file_summary(io.BytesIO(modified_decrypted_bytes))
+    original_plain = bytearray(DecryptionProvider.decrypt_ecb(valid_key, original_encrypted_data))
+    original_chunks = parse_rl_compressed_chunks(bytes(original_plain), meta.compressed_chunks_offset)
+    if not original_chunks:
+        raise ValueError("No compressed chunks were found in original encrypted header")
+
+    new_chunk_table_offset = modified_summary.depends_offset - modified_summary.name_offset
+    patch_limit = max(0, new_chunk_table_offset)
+    chunk_shift = modified_summary.depends_offset - original_chunks[0].uncompressed_offset
+
+    rebuilt_chunks: List[FCompressedChunk] = []
+    rebuilt_chunk_payloads: List[bytes] = []
+    chunk_table_placeholder = serialize_rl_chunk_table([
+        FCompressedChunk(0, 0, 0, 0) for _ in original_chunks
+    ])
+    required_plain_len = new_chunk_table_offset + len(chunk_table_placeholder)
+    encrypted_plain_len = (required_plain_len + 15) & ~15
+    header_plain = bytearray(encrypted_plain_len)
+    copy_len = min(len(original_plain), encrypted_plain_len)
+    header_plain[:copy_len] = original_plain[:copy_len]
+
+    new_total_header_size = modified_summary.name_offset + encrypted_plain_len + meta.garbage_size
+    current_compressed_offset = new_total_header_size
+    for i, chunk in enumerate(original_chunks):
+        start = chunk.uncompressed_offset + chunk_shift
+        if i + 1 < len(original_chunks):
+            end = original_chunks[i + 1].uncompressed_offset + chunk_shift
+            if end > len(modified_decrypted_bytes):
+                raise ValueError("Modified decrypted package changed size too early for the rebuilt chunk layout")
+        else:
+            end = len(modified_decrypted_bytes)
+        if end < start:
+            raise ValueError("Invalid rebuilt chunk bounds")
+        payload = compress_chunk_payload(modified_decrypted_bytes[start:end])
+        rebuilt_chunk_payloads.append(payload)
+        rebuilt_chunks.append(FCompressedChunk(
+            uncompressed_offset=start,
+            uncompressed_size=end - start,
+            compressed_offset=current_compressed_offset,
+            compressed_size=len(payload),
+        ))
+        current_compressed_offset += len(payload)
+
+    if patch_limit > len(header_plain):
+        raise ValueError("Modified decrypted header exceeds encrypted header capacity")
+    if patch_limit > 0:
+        header_plain[:patch_limit] = modified_decrypted_bytes[summary.name_offset:modified_summary.depends_offset]
+
+    chunk_table = serialize_rl_chunk_table(rebuilt_chunks)
+    table_end = new_chunk_table_offset + len(chunk_table)
+    if table_end > len(header_plain):
+        raise ValueError("Rebuilt compressed chunk table does not fit inside encrypted header")
+    header_plain[new_chunk_table_offset:table_end] = chunk_table
+    encrypted_header = DecryptionProvider.encrypt_ecb(valid_key, bytes(header_plain))
+
+    original_bytes = Path(original_encrypted_path).read_bytes()
+    prefix = bytearray(original_bytes[:summary.name_offset])
+    summary_offsets = _find_summary_offsets(modified_decrypted_bytes)
+    patch_i32_le(prefix, summary_offsets["total_header_size_offset"], new_total_header_size)
+    patch_i32_le(prefix, summary_offsets["name_count_offset"], modified_summary.name_count)
+    patch_i32_le(prefix, summary_offsets["name_offset_offset"], modified_summary.name_offset)
+    patch_i32_le(prefix, summary_offsets["export_count_offset"], modified_summary.export_count)
+    patch_i32_le(prefix, summary_offsets["export_offset_offset"], modified_summary.export_offset)
+    patch_i32_le(prefix, summary_offsets["import_count_offset"], modified_summary.import_count)
+    patch_i32_le(prefix, summary_offsets["import_offset_offset"], modified_summary.import_offset)
+    patch_i32_le(prefix, summary_offsets["depends_offset_offset"], modified_summary.depends_offset)
+    patch_i32_le(prefix, summary_offsets["import_export_guids_offset_offset"], modified_summary.import_export_guids_offset)
+    if "thumbnail_table_offset_offset" in summary_offsets:
+        patch_i32_le(prefix, summary_offsets["thumbnail_table_offset_offset"], modified_summary.thumbnail_table_offset)
+    _patch_generation_counts(prefix, summary_offsets, modified_summary.export_count, modified_summary.name_count)
+    with original_encrypted_path.open("rb") as src:
+        meta_offsets = _find_file_compression_metadata_offsets(src)
+    patch_i32_le(prefix, meta_offsets["compressed_chunks_offset_offset"], new_chunk_table_offset)
+    if rebuilt_chunks:
+        patch_i32_le(prefix, meta_offsets["last_block_size_offset"], rebuilt_chunks[-1].uncompressed_size)
+
+    output = bytearray()
+    output += prefix
+    output += encrypted_header
+    gap_start = modified_summary.name_offset + len(encrypted_header)
+    original_gap_start = summary.name_offset + len(original_encrypted_data)
+    original_gap_end = original_chunks[0].compressed_offset
+    gap_bytes = original_bytes[original_gap_start:original_gap_end]
+    if len(gap_bytes) != meta.garbage_size:
+        gap_bytes = original_bytes[original_gap_end - meta.garbage_size:original_gap_end]
+    output += gap_bytes
+    for payload in rebuilt_chunk_payloads:
+        output += payload
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(output)
+    return output_path
+
+
+def _pack_fname_value(package: ParsedPackage, text: str) -> bytes:
+    text = text.strip()
+    # Allow either "#<index>" to pick a name table entry by raw index, or a
+    # plain base/base_<N> string to match by name. Instance suffixes are
+    # split off so users can write things like "Foo_3" and have it round-trip
+    # through the version-aware serialize_fname adjustment.
+    base_text, instance_number = _split_name_instance(text)
+    match = None
+    if base_text.startswith("#"):
+        try:
+            idx = int(base_text[1:])
+            if 0 <= idx < len(package.names):
+                match = package.names[idx]
+        except Exception:
+            pass
+    if match is None:
+        for entry in package.names:
+            if entry.name == base_text:
+                match = entry
+                break
+    if match is None:
+        # Fall back to the original full string (for the legacy case where a
+        # name literally contained '_<digits>').
+        for entry in package.names:
+            if entry.name == text:
+                match = entry
+                instance_number = 0
+                break
+    if match is None:
+        raise ValueError(f"FName not found in package name table: {text}")
+    # instance_number == 0 from _split_name_instance means "no suffix typed",
+    # which corresponds to in-memory -1 for >= NUMBER_ADDED_TO_NAME packages
+    # (so serialize_fname writes 0 on disk). Translate appropriately.
+    if package.summary.file_version >= NUMBER_ADDED_TO_NAME and instance_number == 0:
+        in_memory_instance = -1
+    else:
+        in_memory_instance = instance_number
+    return serialize_fname(FNameRef(match.index, in_memory_instance), package.summary)
+
+
+def _parse_struct_numbers(text: str) -> List[float]:
+    parts = [p.strip() for p in text.replace("(", "").replace(")", "").split(",") if p.strip()]
+    return [float(p) for p in parts]
+
+
+
+def get_export_entry_offsets(package: ParsedPackage) -> List[int]:
+    bio = io.BytesIO(package.file_bytes)
+    bio.seek(package.summary.export_offset)
+    r = BinaryReader(bio)
+    offsets: List[int] = []
+    generation_count = len(package.summary.generations)
+    for _ in range(package.summary.export_count):
+        offsets.append(bio.tell())
+        parse_export_entry(r, len(offsets) - 1, generation_count, package.summary)
+    return offsets
+
+
+def patch_i32_le(data: bytearray, offset: int, value: int) -> None:
+    data[offset:offset + 4] = struct.pack("<i", value)
+
+
+def patch_i64_le(data: bytearray, offset: int, value: int) -> None:
+    data[offset:offset + 8] = struct.pack("<q", value)
+
+
+def apply_property_edit_bytes(package: ParsedPackage, export: ExportEntry, prop: ParsedProperty, text: str) -> bytes:
+    rel_offset, replacement = encode_property_value(package, prop, text)
+    abs_offset = export.serial_offset + rel_offset
+    size_delta = len(replacement) - prop.size
+    target_offset = prop.value_offset - 1 if prop.tag_type == "BoolProperty" and prop.bool_value is not None else prop.value_offset
+
+    if size_delta == 0:
+        data = bytearray(package.file_bytes)
+        data[abs_offset:abs_offset + len(replacement)] = replacement
+        return bytes(data)
+
+    if prop.tag_type != "StrProperty":
+        raise ValueError("Variable-size edits are currently supported for StrProperty only")
+
+    if export.serial_offset < 0 or export.serial_size < 0:
+        raise ValueError("Invalid export serial bounds")
+    export_end = export.serial_offset + export.serial_size
+    if export_end > len(package.file_bytes):
+        raise ValueError("Export serial data exceeds package size")
+
+    value_abs_offset = export.serial_offset + target_offset
+    tag_size_abs_offset = export.serial_offset + prop.tag_offset + 16
+
+    new_data = bytearray()
+    new_data += package.file_bytes[:value_abs_offset]
+    new_data += replacement
+    new_data += package.file_bytes[value_abs_offset + prop.size:]
+
+    export_entry_offsets = get_export_entry_offsets(package)
+    if export.table_index >= len(export_entry_offsets):
+        raise ValueError("Export table index out of range")
+
+    entry_offset = export_entry_offsets[export.table_index]
+    patch_i32_le(new_data, tag_size_abs_offset, len(replacement))
+    patch_i32_le(new_data, entry_offset + 32, export.serial_size + size_delta)
+
+    export_shift_point = export.serial_offset
+    for idx, other in enumerate(package.exports):
+        if idx == export.table_index:
+            continue
+        if other.serial_offset > export_shift_point:
+            other_entry_offset = export_entry_offsets[idx]
+            patch_i64_le(new_data, other_entry_offset + 36, other.serial_offset + size_delta)
+
+    return bytes(new_data)
+
+
+def encode_property_value(package: ParsedPackage, prop: ParsedProperty, text: str) -> Tuple[int, bytes]:
+    text = text.strip()
+    if text.lower().startswith("hex:"):
+        raw = bytes.fromhex(text[4:].strip())
+        target_offset = prop.value_offset - 1 if prop.tag_type == "BoolProperty" and prop.bool_value is not None else prop.value_offset
+        expected = 1 if prop.tag_type == "BoolProperty" and prop.bool_value is not None else prop.size
+        if len(raw) != expected:
+            raise ValueError(f"hex payload must be exactly {expected} bytes")
+        return target_offset, raw
+    if prop.tag_type == "BoolProperty":
+        v = text.lower()
+        if v in ("1", "true", "yes", "on"):
+            return prop.value_offset - 1, b"
"
+        if v in ("0", "false", "no", "off"):
+            return prop.value_offset - 1, b"\x00"
+        raise ValueError("BoolProperty expects true/false")
+    if prop.tag_type == "IntProperty":
+        return prop.value_offset, struct.pack("<i", int(text, 0))
+    if prop.tag_type == "FloatProperty":
+        return prop.value_offset, struct.pack("<f", float(text))
+    if prop.tag_type == "QWordProperty":
+        return prop.value_offset, struct.pack("<Q", int(text, 0))
+    if prop.tag_type == "StringRefProperty":
+        return prop.value_offset, struct.pack("<I", int(text, 0))
+    if prop.tag_type in ("ObjectProperty", "ClassProperty", "ComponentProperty", "InterfaceProperty"):
+        resolved = resolve_object_index_by_text(package, text)
+        if resolved is None:
+            raise ValueError("Object reference not found in exports/imports; use an index like -12 or a full object path")
+        return prop.value_offset, struct.pack("<i", resolved)
+    if prop.tag_type == "NameProperty":
+        return prop.value_offset, _pack_fname_value(package, text)
+    if prop.tag_type == "ByteProperty":
+        if prop.enum_name:
+            return prop.value_offset, _pack_fname_value(package, text)
+        return prop.value_offset, struct.pack("<B", int(text, 0) & 0xFF)
+    if prop.tag_type == "StrProperty":
+        encoded = write_fstring_bytes(text)
+        return prop.value_offset, encoded
+    if prop.tag_type == "StructProperty":
+        if prop.struct_name == "FVector":
+            vals = _parse_struct_numbers(text)
+            if len(vals) != 3:
+                raise ValueError("FVector expects x,y,z")
+            return prop.value_offset, struct.pack("<fff", *vals)
+        if prop.struct_name == "FVector2D":
+            vals = _parse_struct_numbers(text)
+            if len(vals) != 2:
+                raise ValueError("FVector2D expects x,y")
+            return prop.value_offset, struct.pack("<ff", *vals)
+        if prop.struct_name == "FRotator":
+            vals = [int(v) for v in _parse_struct_numbers(text)]
+            if len(vals) != 3:
+                raise ValueError("FRotator expects pitch,yaw,roll")
+            return prop.value_offset, struct.pack("<iii", *vals)
+        if prop.struct_name == "FColor":
+            vals = [int(v) for v in _parse_struct_numbers(text)]
+            if len(vals) != 4:
+                raise ValueError("FColor expects r,g,b,a")
+            return prop.value_offset, bytes(v & 0xFF for v in vals)
+        if prop.struct_name == "FLinearColor":
+            vals = _parse_struct_numbers(text)
+            if len(vals) != 4:
+                raise ValueError("FLinearColor expects r,g,b,a")
+            return prop.value_offset, struct.pack("<ffff", *vals)
+        if prop.struct_name == "FGuid":
+            cleaned = text.replace('-', '').replace('{', '').replace('}', '').strip()
+            if len(cleaned) != 32:
+                raise ValueError("FGuid expects 32 hex digits or a dashed guid")
+            vals = [int(cleaned[i:i+8], 16) for i in range(0, 32, 8)]
+            return prop.value_offset, struct.pack("<IIII", *vals)
+    raise ValueError(f"Editing is not implemented for {prop.tag_type}")
+
+def write_fstring_bytes(text: str) -> bytes:
+    if not text:
+        return struct.pack('<i', 0)
+    try:
+        # If it's pure ASCII, serialize as 1-byte ANSI (positive length)
+        encoded = text.encode('ascii') + b'\x00'
+        return struct.pack('<i', len(encoded)) + encoded
+    except UnicodeEncodeError:
+        # If it contains non-ASCII characters, serialize as 2-byte UTF-16LE (negative length)
+        encoded = text.encode('utf-16-le') + b'\x00\x00'
+        char_count = len(text) + 1
+        return struct.pack('<i', -char_count) + encoded
+
+def serialize_fname(ref: FNameRef, summary: Optional["FileSummary"] = None) -> bytes:
+    # Mirror the version-aware adjustment in read_fname: for >= NUMBER_ADDED_TO_NAME
+    # the on-disk stored value is (instance_number + 1), so we add 1 here.
+    # When summary is None (legacy callers), fall back to writing the raw
+    # in-memory value, which preserves prior behaviour for any code path
+    # that hasn't been threaded through.
+    if summary is not None and summary.file_version >= NUMBER_ADDED_TO_NAME:
+        stored_instance = ref.instance_number + 1
+    else:
+        stored_instance = ref.instance_number
+    return struct.pack("<ii", ref.name_index, stored_instance)
+
+
+def serialize_name_entry(entry: NameEntry) -> bytes:
+    return write_fstring_bytes(entry.name) + struct.pack("<Q", entry.flags)
+
+
+def serialize_import_entry(entry: ImportEntry, summary: Optional["FileSummary"] = None) -> bytes:
+    return b"".join([
+        serialize_fname(entry.class_package, summary),
+        serialize_fname(entry.class_name, summary),
+        struct.pack("<i", entry.outer_index),
+        serialize_fname(entry.object_name, summary),
+    ])
+
+
+def serialize_export_entry(entry: ExportEntry, summary: Optional["FileSummary"] = None) -> bytes:
+    out = bytearray()
+    out += struct.pack("<i", entry.class_index)
+    out += struct.pack("<i", entry.super_index)
+    out += struct.pack("<i", entry.outer_index)
+    out += serialize_fname(entry.object_name, summary)
+    out += struct.pack("<i", entry.archetype_index)
+    out += struct.pack("<Q", entry.object_flags)
+    out += struct.pack("<i", entry.serial_size)
+    out += struct.pack("<q", entry.serial_offset)
+    out += struct.pack("<i", entry.export_flags)
+    out += struct.pack("<i", len(entry.net_objects))
+    for value in entry.net_objects:
+        out += struct.pack("<i", value)
+    out += struct.pack("<IIII", *entry.package_guid)
+    out += struct.pack("<i", entry.package_flags)
+    return bytes(out)
+
+
+def _find_summary_offsets(data: bytes) -> Dict[str, int]:
+    bio = io.BytesIO(data)
+    r = BinaryReader(bio)
+    if r.read_u32() != PACKAGE_FILE_TAG:
+        raise ValueError("Not a valid Unreal Engine package")
+    r.read_u16()
+    r.read_u16()
+    total_header_size_offset = bio.tell()
+    r.read_i32()
+    r.read_fstring()
+    package_flags_offset = bio.tell()
+    r.read_u32()
+    name_count_offset = bio.tell()
+    r.read_i32()
+    name_offset_offset = bio.tell()
+    r.read_i32()
+    export_count_offset = bio.tell()
+    r.read_i32()
+    export_offset_offset = bio.tell()
+    r.read_i32()
+    import_count_offset = bio.tell()
+    r.read_i32()
+    import_offset_offset = bio.tell()
+    r.read_i32()
+    depends_offset_offset = bio.tell()
+    r.read_i32()
+    import_export_guids_offset_offset = bio.tell()
+    r.read_i32()
+    r.read_i32()
+    r.read_i32()
+    thumbnail_table_offset_offset = bio.tell()
+    r.read_i32()
+    read_guid(r)
+    generations_count_offset = bio.tell()
+    gen_count = r.read_i32()
+    generation_entries_offset = bio.tell()
+    return {
+        "total_header_size_offset": total_header_size_offset,
+        "package_flags_offset": package_flags_offset,
+        "name_count_offset": name_count_offset,
+        "name_offset_offset": name_offset_offset,
+        "export_count_offset": export_count_offset,
+        "export_offset_offset": export_offset_offset,
+        "import_count_offset": import_count_offset,
+        "import_offset_offset": import_offset_offset,
+        "depends_offset_offset": depends_offset_offset,
+        "import_export_guids_offset_offset": import_export_guids_offset_offset,
+        "thumbnail_table_offset_offset": thumbnail_table_offset_offset,
+        "generations_count_offset": generations_count_offset,
+        "generation_entries_offset": generation_entries_offset,
+        "generation_count": gen_count,
+    }
+
+
+def _patch_generation_counts(data: bytearray, offsets: Dict[str, int], export_count: int, name_count: int) -> None:
+    gen_count = offsets.get("generation_count", 0)
+    if gen_count <= 0:
+        return
+    base = offsets["generation_entries_offset"] + (gen_count - 1) * 12
+    if base + 8 > len(data):
+        return
+    patch_i32_le(data, base, export_count)
+    patch_i32_le(data, base + 4, name_count)
+
+
+def _replace_header_tables(package: ParsedPackage, names: List[NameEntry], imports: List[ImportEntry]) -> bytes:
+    summary = package.summary
+    offsets = _find_summary_offsets(package.file_bytes)
+    old_depends_offset = summary.depends_offset
+
+    prefix = bytearray(package.file_bytes[:summary.name_offset])
+    patched_exports: List[ExportEntry] = []
+    for x in package.exports:
+        patched_exports.append(ExportEntry(
+            table_index=x.table_index,
+            class_index=x.class_index,
+            super_index=x.super_index,
+            outer_index=x.outer_index,
+            object_name=FNameRef(x.object_name.name_index, x.object_name.instance_number),
+            archetype_index=x.archetype_index,
+            object_flags=x.object_flags,
+            serial_size=x.serial_size,
+            serial_offset=x.serial_offset,
+            export_flags=x.export_flags,
+            net_objects=list(x.net_objects),
+            package_guid=x.package_guid,
+            package_flags=x.package_flags,
+        ))
+
+    names_blob = b"".join(serialize_name_entry(x) for x in names)
+    imports_blob = b"".join(serialize_import_entry(x, summary) for x in imports)
+    export_offset = summary.name_offset + len(names_blob) + len(imports_blob)
+    depends_offset = export_offset + sum(len(serialize_export_entry(x, summary)) for x in patched_exports)
+    delta = depends_offset - old_depends_offset
+
+    if delta != 0:
+        for exp in patched_exports:
+            if exp.serial_offset >= old_depends_offset:
+                exp.serial_offset += delta
+
+    exports_blob = b"".join(serialize_export_entry(x, summary) for x in patched_exports)
+    depends_offset = export_offset + len(exports_blob)
+    delta = depends_offset - old_depends_offset
+
+    header_blob = prefix + names_blob + imports_blob + exports_blob
+    patch_i32_le(header_blob, offsets["name_count_offset"], len(names))
+    patch_i32_le(header_blob, offsets["name_offset_offset"], summary.name_offset)
+    patch_i32_le(header_blob, offsets["export_count_offset"], len(patched_exports))
+    patch_i32_le(header_blob, offsets["export_offset_offset"], export_offset)
+    patch_i32_le(header_blob, offsets["import_count_offset"], len(imports))
+    patch_i32_le(header_blob, offsets["import_offset_offset"], summary.name_offset + len(names_blob))
+    patch_i32_le(header_blob, offsets["depends_offset_offset"], depends_offset)
+
+    import_export_guids_offset = summary.import_export_guids_offset
+    if import_export_guids_offset >= old_depends_offset and import_export_guids_offset != 0:
+        import_export_guids_offset += delta
+    patch_i32_le(header_blob, offsets["import_export_guids_offset_offset"], import_export_guids_offset)
+
+    thumbnail_table_offset = summary.thumbnail_table_offset
+    if thumbnail_table_offset >= old_depends_offset and thumbnail_table_offset != 0:
+        thumbnail_table_offset += delta
+    if "thumbnail_table_offset_offset" in offsets:
+        patch_i32_le(header_blob, offsets["thumbnail_table_offset_offset"], thumbnail_table_offset)
+
+    # NOTE: total_header_size is intentionally written back UNCHANGED. In a
+    # decrypted RL package this field carries over the value from the original
+    # encrypted file (unpack_package copies the encrypted prefix verbatim into
+    # the decrypted output and never adjusts this field). The encrypted-save
+    # path (build_reencrypted_package) computes its own correct value from
+    # name_offset + encrypted_plain_len + garbage_size and patches it
+    # independently, so the value we write here only matters for
+    # 'Save Decrypted UPK' where preserving the original-encrypted semantics
+    # is the right behaviour. An earlier attempt to "fix" this by adding the
+    # names+imports growth delta produced corrupt encrypted files because the
+    # delta concept doesn't apply to the encrypted-layout meaning of this field.
+    patch_i32_le(header_blob, offsets["total_header_size_offset"], summary.total_header_size)
+    _patch_generation_counts(header_blob, offsets, len(patched_exports), len(names))
+
+    new_data = bytearray()
+    new_data += header_blob
+    new_data += package.file_bytes[old_depends_offset:]
+    return bytes(new_data)
+
+
+def _split_name_instance(text: str) -> Tuple[str, int]:
+    if '_' in text:
+        base, suffix = text.rsplit('_', 1)
+        if suffix.isdigit():
+            return base, int(suffix)
+    return text, 0
+
+
+def _find_existing_name_ref(names: List[NameEntry], text: str) -> Optional[FNameRef]:
+    base, instance = _split_name_instance(text)
+    for entry in names:
+        if entry.name == base:
+            return FNameRef(entry.index, instance)
+    return None
+
+
+def _ensure_name_entry(names: List[NameEntry], text: str, flags: int = 0) -> FNameRef:
+    found = _find_existing_name_ref(names, text)
+    if found is not None:
+        return found
+    base, instance = _split_name_instance(text)
+    names.append(NameEntry(index=len(names), name=base, flags=flags))
+    return FNameRef(len(names) - 1, instance)
+
+
+def import_donor_names(package: ParsedPackage, donor_package: ParsedPackage, selected_names: Optional[List[str]] = None) -> ParsedPackage:
+    names = [NameEntry(index=n.index, name=n.name, flags=n.flags) for n in package.names]
+    wanted = None if not selected_names else set(selected_names)
+    added = 0
+    for entry in donor_package.names:
+        if wanted is not None and entry.name not in wanted:
+            continue
+        if _find_existing_name_ref(names, entry.name) is None:
+            names.append(NameEntry(index=len(names), name=entry.name, flags=entry.flags))
+            added += 1
+    if added == 0:
+        result = ParsedPackage(package.file_path, package.summary, names, package.imports, package.exports, package.file_bytes)
+        setattr(result, '_merge_added_names', 0)
+        return result
+    patched = _replace_header_tables(package, names, package.imports)
+    temp_path = package.file_path.with_name(package.file_path.stem + '_names_merged.upk')
+    temp_path.write_bytes(patched)
+    result = parse_decrypted_package(temp_path)
+    setattr(result, '_merge_added_names', added)
+    return result
+
+
+def _collect_existing_import_paths(package: ParsedPackage) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for i in range(len(package.imports)):
+        out[package.resolve_object_path(-(i + 1))] = -(i + 1)
+    return out
+
+
+def _class_package_and_name_for_ref(package: ParsedPackage, class_index: int) -> Tuple[str, str]:
+    if class_index == 0:
+        return "Core", "Class"
+    path = package.resolve_object_path(class_index)
+    parts = [p for p in path.split('.') if p and p != 'None']
+    if not parts:
+        return "Core", "Class"
+    if len(parts) == 1:
+        return "Core", parts[-1]
+    return parts[-2], parts[-1]
+
+
+def _derive_donor_package_name(donor_package: ParsedPackage, override: Optional[str] = None) -> str:
+    """Return the package name UE will use to LoadPackage the donor at runtime.
+
+    Priority:
+      1. Explicit override from the caller (e.g. user typed it in).
+      2. The donor file's stem (e.g. 'MyDonorAssets.upk' -> 'MyDonorAssets').
+         This is what the engine resolves through its package search paths,
+         so it must match how the file is actually deployed in the game's
+         cooked content directory.
+      3. The donor's embedded summary.folder_name. Often empty in cooked
+         RL packages but used as a last resort.
+
+    Raises ValueError if no usable name can be derived.
+    """
+    if override and override.strip():
+        return override.strip()
+    stem = donor_package.file_path.stem
+    # Strip our own '_decrypted' / '_decompressed' suffixes that resolve_input_package
+    # appends when it produces a working copy - the file the game loads has the
+    # original stem.
+    for suffix in ("_decrypted", "_decompressed"):
+        if stem.endswith(suffix):
+            stem = stem[: -len(suffix)]
+            break
+    if stem:
+        return stem
+    folder = (donor_package.summary.folder_name or "").strip()
+    if folder:
+        return folder
+    raise ValueError("Could not determine donor package name; pass it explicitly")
+
+
+def merge_donor_exports_as_imports(target_package: ParsedPackage, donor_package: ParsedPackage, donor_package_name: Optional[str] = None) -> ParsedPackage:
+    # The donor's package name is what the engine will look up at runtime to
+    # locate and LoadPackage the donor .upk. Every donor export we re-import
+    # MUST be rooted under a Core.Package import with this name, otherwise
+    # the engine has no way to know which file to open to resolve the
+    # reference. Previously donor root exports were imported with
+    # outer_index=0 (i.e. as if they themselves were top-level packages),
+    # which left the engine unable to resolve them.
+    resolved_donor_name = _derive_donor_package_name(donor_package, donor_package_name)
+
+    names = [NameEntry(index=n.index, name=n.name, flags=n.flags) for n in target_package.names]
+    imports = [ImportEntry(table_index=i, class_package=FNameRef(x.class_package.name_index, x.class_package.instance_number), class_name=FNameRef(x.class_name.name_index, x.class_name.instance_number), outer_index=x.outer_index, object_name=FNameRef(x.object_name.name_index, x.object_name.instance_number)) for i, x in enumerate(target_package.imports)]
+    existing_paths = _collect_existing_import_paths(target_package)
+    donor_cache: Dict[int, int] = {}
+
+    def ensure_package_root(package_name: str) -> int:
+        existing = existing_paths.get(package_name)
+        if existing is not None:
+            return existing
+        cp = _ensure_name_entry(names, 'Core')
+        cn = _ensure_name_entry(names, 'Package')
+        on = _ensure_name_entry(names, package_name)
+        imports.append(ImportEntry(len(imports), cp, cn, 0, on))
+        idx = -len(imports)
+        existing_paths[package_name] = idx
+        return idx
+
+    # Pre-create the donor package import up front. Even if no donor exports
+    # ended up needing it (e.g. all collisions with existing imports), having
+    # this entry guarantees the engine will attempt to load the donor file
+    # when the target is loaded, which is what users typically want when
+    # they "import donor exports".
+    donor_root_index = ensure_package_root(resolved_donor_name)
+
+    def ensure_donor_object(index: int) -> int:
+        if index == 0:
+            return 0
+        if index in donor_cache:
+            return donor_cache[index]
+        path = donor_package.resolve_object_path(index)
+        # When matching against existing target imports, prepend the donor
+        # package name so a donor export "Foo" doesn't collide with an
+        # unrelated existing import literally named "Foo". For donor
+        # imports we keep the original path because those refer to the same
+        # external packages (Engine, Core, etc.) the target may also
+        # reference, and we WANT to share those.
+        scoped_path = f"{resolved_donor_name}.{path}" if index > 0 else path
+        if scoped_path in existing_paths:
+            donor_cache[index] = existing_paths[scoped_path]
+            return existing_paths[scoped_path]
+        if index > 0:
+            obj = donor_package.exports[index - 1]
+            obj_name = donor_package.resolve_name(obj.object_name)
+            outer_index = ensure_donor_object(obj.outer_index) if obj.outer_index else 0
+            if outer_index == 0:
+                # Root donor export: parent it to the donor package import so
+                # the engine knows to LoadPackage(donor_name) to resolve it.
+                outer_index = donor_root_index
+            class_pkg_name, class_name_name = _class_package_and_name_for_ref(donor_package, obj.class_index)
+        else:
+            obj = donor_package.imports[-index - 1]
+            obj_name = donor_package.resolve_name(obj.object_name)
+            outer_index = ensure_donor_object(obj.outer_index) if obj.outer_index else 0
+            class_pkg_name = donor_package.resolve_name(obj.class_package)
+            class_name_name = donor_package.resolve_name(obj.class_name)
+        cp = _ensure_name_entry(names, class_pkg_name)
+        cn = _ensure_name_entry(names, class_name_name)
+        on = _ensure_name_entry(names, obj_name)
+        imports.append(ImportEntry(len(imports), cp, cn, outer_index, on))
+        new_index = -len(imports)
+        donor_cache[index] = new_index
+        existing_paths[scoped_path] = new_index
+        return new_index
+
+    imported = 0
+    for i in range(1, len(donor_package.exports) + 1):
+        before = len(imports)
+        ensure_donor_object(i)
+        if len(imports) != before:
+            imported += 1
+
+    patched = _replace_header_tables(target_package, names, imports)
+    result = parse_decrypted_package_bytes(target_package.file_path, patched)
+    setattr(result, '_merge_added_imports', len(imports) - len(target_package.imports))
+    setattr(result, '_merge_added_names', len(names) - len(target_package.names))
+    setattr(result, '_merge_donor_export_count', len(donor_package.exports))
+    setattr(result, '_merge_donor_package_name', resolved_donor_name)
+    return result
+
+
+
+def replace_export_with_donor_export(target_package: ParsedPackage, donor_package: ParsedPackage, target_export_path: str, donor_export_path: str) -> ParsedPackage:
+    merged = import_donor_names(target_package, donor_package, None)
+    merged = merge_donor_exports_as_imports(merged, donor_package)
+
+    target_index = resolve_object_index_by_text(merged, target_export_path)
+    donor_index = resolve_object_index_by_text(donor_package, donor_export_path)
+    if target_index is None or target_index <= 0:
+        raise ValueError(f"Target export not found: {target_export_path}")
+    if donor_index is None or donor_index <= 0:
+        raise ValueError(f"Donor export not found: {donor_export_path}")
+
+    target_export = merged.exports[target_index - 1]
+    donor_export = donor_package.exports[donor_index - 1]
+
+    target_class = merged.export_class_name(target_export)
+    donor_class = donor_package.export_class_name(donor_export)
+    if target_class != donor_class:
+        raise ValueError(f"Class mismatch: target is {target_class}, donor is {donor_class}")
+
+    donor_bytes = donor_package.object_data(donor_export)
+    if not donor_bytes:
+        raise ValueError("Donor export has no serial data")
+
+    size_delta = len(donor_bytes) - target_export.serial_size
+    new_data = bytearray()
+    new_data += merged.file_bytes[:target_export.serial_offset]
+    new_data += donor_bytes
+    new_data += merged.file_bytes[target_export.serial_offset + target_export.serial_size:]
+
+    export_entry_offsets = get_export_entry_offsets(merged)
+    entry_offset = export_entry_offsets[target_index - 1]
+    patch_i32_le(new_data, entry_offset + 32, len(donor_bytes))
+
+    for idx, other in enumerate(merged.exports):
+        if idx == target_index - 1:
+            continue
+        if other.serial_offset > target_export.serial_offset:
+            other_entry_offset = export_entry_offsets[idx]
+            patch_i64_le(new_data, other_entry_offset + 36, other.serial_offset + size_delta)
+
+    result = parse_decrypted_package_bytes(merged.file_path, bytes(new_data))
+    setattr(result, '_replace_target_export_path', target_export_path)
+    setattr(result, '_replace_donor_export_path', donor_export_path)
+    setattr(result, '_replace_note', 'Raw donor serial data copied into target export. Name/index remapping inside arbitrary native data is not performed.')
+    return result
+
+
+def rename_export_fname(package: ParsedPackage, export: ExportEntry, new_name_text: str) -> ParsedPackage:
+    """Rename the FName (object_name) of a single export.
+
+    Accepts either a bare base name ("MyName") or a base+instance form ("MyName_3").
+    If the base name already exists in the package's name table, the export entry
+    is patched in place (8 bytes at object_name field). If the base name is new,
+    it is appended to the name table via _replace_header_tables, and the export's
+    FName field is then patched to point at the newly added name.
+    """
+    new_name_text = (new_name_text or "").strip()
+    if not new_name_text:
+        raise ValueError("Empty FName")
+    base, instance = _split_name_instance(new_name_text)
+    if not base:
+        raise ValueError("Empty base name")
+    if instance < 0:
+        raise ValueError("Instance number must be >= 0")
+
+    # Locate where this export's entry sits inside the export table so we can
+    # patch the 8-byte object_name field in place. Layout of an export entry:
+    #   class_index (i32) | super_index (i32) | outer_index (i32) |
+    #   object_name (i32 name_index + i32 instance_number) | ...
+    # so object_name starts at entry_offset + 12.
+    export_entry_offsets = get_export_entry_offsets(package)
+    if export.table_index < 0 or export.table_index >= len(export_entry_offsets):
+        raise ValueError("Export table index out of range")
+    fname_field_abs = export_entry_offsets[export.table_index] + 12
+
+    # The user-typed instance number is the "displayed" value (0 for no
+    # suffix, 3 for _3, etc.). On disk for >= NUMBER_ADDED_TO_NAME the
+    # stored value is (instance + 1), so we add 1 here. For older versions
+    # the stored value equals the displayed value.
+    if package.summary.file_version >= NUMBER_ADDED_TO_NAME:
+        stored_instance = instance + 1 if instance > 0 else 0
+    else:
+        stored_instance = instance
+
+    # Try to reuse an existing name first.
+    existing_idx: Optional[int] = None
+    for entry in package.names:
+        if entry.name == base:
+            existing_idx = entry.index
+            break
+
+    if existing_idx is not None:
+        # Fast path: in-place 8-byte patch of the export entry's FName field.
+        new_data = bytearray(package.file_bytes)
+        new_data[fname_field_abs:fname_field_abs + 8] = struct.pack("<ii", existing_idx, stored_instance)
+        result = parse_decrypted_package_bytes(package.file_path, bytes(new_data))
+        setattr(result, '_rename_added_names', 0)
+        setattr(result, '_rename_new_name', new_name_text)
+        setattr(result, '_rename_export_index', export.table_index)
+        return result
+
+    # Slow path: append a new name entry and rebuild the header tables. The
+    # rebuild may shift the depends_offset and any export serial_offsets that
+    # come after it, but the entries inside the export table itself stay at the
+    # same relative positions because _replace_header_tables preserves their
+    # order. So entry_offsets of the rebuilt file equal new_export_offset +
+    # (old_offset - old_export_offset).
+    names = [NameEntry(index=n.index, name=n.name, flags=n.flags) for n in package.names]
+    new_entry_index = len(names)
+    names.append(NameEntry(index=new_entry_index, name=base, flags=0))
+
+    rebuilt_bytes = bytearray(_replace_header_tables(package, names, package.imports))
+
+    # Recompute export entry offsets in the rebuilt file (their positions can
+    # shift because the names table grew) and patch the FName field.
+    rebuilt_pkg = parse_decrypted_package_bytes(package.file_path, bytes(rebuilt_bytes))
+    new_offsets = get_export_entry_offsets(rebuilt_pkg)
+    if export.table_index >= len(new_offsets):
+        raise ValueError("Export entry not present after header rebuild")
+    new_fname_field_abs = new_offsets[export.table_index] + 12
+    rebuilt_bytes[new_fname_field_abs:new_fname_field_abs + 8] = struct.pack("<ii", new_entry_index, stored_instance)
+
+    result = parse_decrypted_package_bytes(package.file_path, bytes(rebuilt_bytes))
+    setattr(result, '_rename_added_names', 1)
+    setattr(result, '_rename_new_name', new_name_text)
+    setattr(result, '_rename_export_index', export.table_index)
+    return result
+
+
+def rename_name_entry(package: ParsedPackage, name_index: int, new_text: str) -> ParsedPackage:
+    """Rewrite the text of a single entry in the package's name table.
+
+    The name's *index* stays the same, only the string changes. Because every
+    FNameRef across the package (exports, imports, serialized property tags,
+    object names, etc.) references names by index, all references continue to
+    resolve correctly and now read the new text.
+
+    The names blob length almost always changes (different string length, or
+    ANSI vs UTF-16 encoding), so the entire header is rebuilt via
+    _replace_header_tables. That helper recomputes name_offset-following
+    offsets (import/export/depends/thumbnail/import-export-guids) and shifts
+    every export.serial_offset by the resulting delta, so the package stays
+    internally consistent. total_header_size is preserved by the rebuild
+    helper's offset patching - the bytes after the header are taken verbatim
+    from the original file at old_depends_offset.
+
+    Args:
+        package: The package to modify.
+        name_index: Zero-based index into package.names of the entry to rename.
+        new_text: New text for the name entry. Must be a bare base name (no
+            "_<N>" instance suffix - instance numbers live on FNameRefs, not
+            on name table entries).
+
+    Raises:
+        ValueError: If name_index is out of range, new_text is empty, new_text
+            contains an instance suffix, or new_text already exists elsewhere
+            in the name table (which would create a duplicate base name and
+            ambiguous lookups).
+
+    Returns:
+        A re-parsed ParsedPackage with attributes:
+            _name_rename_index: int  - index that was renamed
+            _name_rename_old: str    - previous text
+            _name_rename_new: str    - new text
+            _name_size_delta: int    - bytes added (+) or removed (-) by the
+                                       rename, useful for status reporting
+    """
+    new_text = (new_text or "").strip()
+    if not new_text:
+        raise ValueError("Empty name text")
+    if name_index < 0 or name_index >= len(package.names):
+        raise ValueError(f"Name index {name_index} out of range (0..{len(package.names) - 1})")
+
+    # Reject instance suffixes - those belong on FNameRefs, not entries. A
+    # name table entry is a pure base string; entries like "Foo_3" only happen
+    # if the original asset really had a literal underscore-digit base name.
+    base, instance = _split_name_instance(new_text)
+    if instance != 0:
+        raise ValueError(
+            "Name entries cannot include an instance suffix like '_3'. "
+            "Instance numbers live on each FName reference, not on the "
+            "name table entry. Use the bare base name (e.g. 'MyName')."
+        )
+
+    old_entry = package.names[name_index]
+    if old_entry.name == new_text:
+        # No-op: re-parse so callers always get a fresh ParsedPackage with the
+        # standard rename metadata attached.
+        result = parse_decrypted_package_bytes(package.file_path, bytes(package.file_bytes))
+        setattr(result, '_name_rename_index', name_index)
+        setattr(result, '_name_rename_old', old_entry.name)
+        setattr(result, '_name_rename_new', new_text)
+        setattr(result, '_name_size_delta', 0)
+        return result
+
+    # Reject collisions with other entries. Merging duplicates would require
+    # remapping every FNameRef across exports/imports/serialized properties to
+    # the surviving index, which is a much larger operation than a rename.
+    for entry in package.names:
+        if entry.index == name_index:
+            continue
+        if entry.name == new_text:
+            raise ValueError(
+                f"Name '{new_text}' already exists at index {entry.index}. "
+                "Renaming would create a duplicate base name. Choose a unique "
+                "name, or rename the other entry first."
+            )
+
+    # Build the modified names list and let _replace_header_tables redo the
+    # names blob, recompute downstream offsets, and shift export serial_offsets
+    # by the size delta.
+    old_blob_len = len(serialize_name_entry(old_entry))
+    new_entry = NameEntry(index=name_index, name=new_text, flags=old_entry.flags)
+    new_blob_len = len(serialize_name_entry(new_entry))
+    size_delta = new_blob_len - old_blob_len
+
+    names = [NameEntry(index=n.index, name=n.name, flags=n.flags) for n in package.names]
+    names[name_index] = new_entry
+
+    rebuilt_bytes = _replace_header_tables(package, names, package.imports)
+    result = parse_decrypted_package_bytes(package.file_path, rebuilt_bytes)
+    setattr(result, '_name_rename_index', name_index)
+    setattr(result, '_name_rename_old', old_entry.name)
+    setattr(result, '_name_rename_new', new_text)
+    setattr(result, '_name_size_delta', size_delta)
+    return result
+
+
+def resolve_object_index_by_text(package: ParsedPackage, text: str) -> Optional[int]:
+    text = text.strip()
+    try:
+        return int(text, 0)
+    except Exception:
+        pass
+    if text.startswith('Import[') or text.startswith('Export['):
+        m = re.match(r'^(Import|Export)\[(\d+)\]', text)
+        if m:
+            kind, num = m.groups()
+            idx = int(num)
+            return -(idx + 1) if kind == 'Import' else (idx + 1)
+    for i in range(len(package.exports)):
+        if package.resolve_object_path(i + 1) == text:
+            return i + 1
+    for i in range(len(package.imports)):
+        if package.resolve_object_path(-(i + 1)) == text:
+            return -(i + 1)
+    return None
+
+
+# ── DLLBind support ──────────────────────────────────────────────────────────
+#
+# In UE3 the compiler keyword `DLLBind(SomeDLL)` on a class declaration
+# stores the DLL name as an FString field called DLLBindName inside the
+# UClass serial body.  It is the LAST field serialized by UClass::Serialize,
+# immediately after NativeClassName (also an FString).
+#
+# When the engine loads the package it reads this field and calls
+# LoadLibrary on the named DLL before the class is fully initialised,
+# making DLLBind a clean DLL-injection point for Rocket League mods.
+#
+# Binary layout at the tail of a cooked UClass serial body:
+#   [... UClass-specific fields ...]
+#   NativeClassName  : FString  (usually empty → 4 zero bytes)
+#   DLLBindName      : FString  (empty = 4 zero bytes; or len+chars+NUL)
+#
+# FString encoding:  int32 length (including NUL) then ASCII bytes + NUL.
+#                    Length == 0 means empty string (no NUL follows).
+
+def is_uclass_export(package: ParsedPackage, export: ExportEntry) -> bool:
+    """Return True when *export* is itself a class definition (class_index → Class)."""
+    return package.export_class_name(export) == "Class"
+
+
+def find_uclass_dllbind_fstring_offset(raw: bytes) -> Optional[Tuple[int, str]]:
+    """Locate the DLLBindName FString at the tail of a UClass serial body.
+
+    Strategy: DLLBindName is the last thing serialized by UClass::Serialize.
+    We scan forward from the last 260 bytes of *raw* looking for the unique
+    FString whose byte span ends exactly at len(raw).
+
+    Returns (fstring_start_offset, dll_name) where fstring_start_offset is
+    the offset (relative to the start of *raw*) of the 4-byte length field of
+    DLLBindName, and dll_name is the current value (empty string if no bind).
+
+    Returns None if no valid FString pattern ending at EOF is found.
+    """
+    L = len(raw)
+    if L < 4:
+        return None
+
+    # Determine the search window.  DLLBind names are short (<260 chars),
+    # so DLLBindName is at most 4+260 = 264 bytes.  We walk backwards.
+    lo = max(0, L - 264 - 4)
+
+    # Try every possible starting offset for an FString that ends at L.
+    #   fstring_start = pos
+    #   length field  = int32 at pos              (4 bytes)
+    #   string data   = raw[pos+4 : pos+4+length] (length bytes)
+    #   total size    = 4 + length
+    #   must satisfy  = pos + 4 + length == L
+    for pos in range(L - 4, lo - 1, -1):
+        if pos < 0:
+            break
+        try:
+            length = struct.unpack_from("<i", raw, pos)[0]
+        except struct.error:
+            break
+
+        if length == 0:
+            # Empty FString: occupies exactly 4 bytes.
+            if pos + 4 == L:
+                return pos, ""
+            # Keep scanning — this zero might be padding before the real field.
+            continue
+
+        if length < 0 or length > 260:
+            # Negative → UTF-16 (unusual for DLL names); too large → noise.
+            continue
+
+        # Non-empty ASCII FString: must end exactly at L.
+        if pos + 4 + length != L:
+            continue
+
+        str_bytes = raw[pos + 4: L]
+        if len(str_bytes) != length:
+            continue
+        # Null-terminated ASCII.
+        if str_bytes[-1] != 0:
+            continue
+        try:
+            dll_name = str_bytes[:-1].decode("ascii")
+        except (UnicodeDecodeError, ValueError):
+            continue
+        if not dll_name.isprintable():
+            continue
+        return pos, dll_name
+
+    return None
+
+
+def set_uclass_dllbind_name(package: ParsedPackage, export: ExportEntry, dll_name: str) -> bytes:
+    """Inject or replace the DLLBindName FString in a UClass serial body.
+
+    *dll_name* is the bare DLL name (e.g. ``'CodeRed.dll'``).  Pass an empty
+    string to remove an existing DLLBind.
+
+    Returns the full modified package bytes.  The export's serial_size is
+    updated and all subsequent exports' serial_offset values are shifted as
+    required, mirroring the variable-size StrProperty edit logic.
+
+    Raises ValueError if the DLLBindName field cannot be found (e.g. the
+    export is not a UClass) or if *dll_name* contains non-ASCII characters.
+    """
+    if dll_name and not dll_name.isascii():
+        raise ValueError("DLL name must be ASCII (no unicode characters).")
+
+    raw = package.object_data(export)
+    if not raw:
+        raise ValueError("Export has no serial data.")
+
+    result = find_uclass_dllbind_fstring_offset(raw)
+    if result is None:
+        raise ValueError(
+            "Could not locate DLLBindName in this export's serial data.\n"
+            "Make sure the selected export is a UClass (class definition) "
+            "and that its serial body is intact."
+        )
+
+    fstring_offset, current_dll_name = result
+
+    # Build old and new FString byte representations.
+    def encode_fstring(name: str) -> bytes:
+        if not name:
+            return struct.pack("<i", 0)
+        enc = name.encode("ascii") + b"\x00"
+        return struct.pack("<i", len(enc)) + enc
+
+    old_fstring = encode_fstring(current_dll_name)
+    new_fstring = encode_fstring(dll_name)
+
+    if old_fstring == new_fstring:
+        return bytes(package.file_bytes)  # nothing to do
+
+    size_delta = len(new_fstring) - len(old_fstring)
+
+    # Absolute byte range of the old FString inside the package file.
+    abs_start = export.serial_offset + fstring_offset
+    abs_end   = abs_start + len(old_fstring)
+
+    new_data = bytearray()
+    new_data += package.file_bytes[:abs_start]
+    new_data += new_fstring
+    new_data += package.file_bytes[abs_end:]
+
+    if size_delta != 0:
+        export_entry_offsets = get_export_entry_offsets(package)
+        if export.table_index >= len(export_entry_offsets):
+            raise ValueError("Export table index out of range.")
+
+        # Patch this export's serial_size (at entry_offset + 32).
+        entry_offset = export_entry_offsets[export.table_index]
+        patch_i32_le(new_data, entry_offset + 32, export.serial_size + size_delta)
+
+        # Shift all exports whose bodies come after this one (at entry_offset + 36).
+        for idx, other in enumerate(package.exports):
+            if idx == export.table_index:
+                continue
+            if other.serial_offset > export.serial_offset:
+                other_entry_offset = export_entry_offsets[idx]
+                patch_i64_le(new_data, other_entry_offset + 36, other.serial_offset + size_delta)
+
+    return bytes(new_data)
+
+
+class NativeWindowsDropTarget:
+    WM_DROPFILES = 0x0233
+    GWL_WNDPROC = -4
+
+    def __init__(self, widget: tk.Misc, callback):
+        self.widget = widget
+        self.callback = callback
+        self.enabled = False
+        if sys.platform != "win32":
+            return
+        self.user32 = ctypes.windll.user32
+        self.shell32 = ctypes.windll.shell32
+        self.user32.SetWindowLongPtrW.restype = ctypes.c_void_p
+        self.user32.SetWindowLongPtrW.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p]
+        self.user32.CallWindowProcW.restype = ctypes.c_longlong
+        self.user32.CallWindowProcW.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p, ctypes.c_void_p]
+        self.shell32.DragAcceptFiles.argtypes = [ctypes.c_void_p, ctypes.c_bool]
+        self.shell32.DragAcceptFiles.restype = None
+        self.shell32.DragQueryFileW.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_wchar_p, ctypes.c_uint]
+        self.shell32.DragQueryFileW.restype = ctypes.c_uint
+        self.shell32.DragFinish.argtypes = [ctypes.c_void_p]
+        self.shell32.DragFinish.restype = None
+        self.old_proc = None
+        self.new_proc = None
+        widget.after(100, self._install)
+
+    def _install(self):
+        if sys.platform != "win32" or not self.widget.winfo_exists():
+            return
+        hwnd = self.widget.winfo_id()
+        self.shell32.DragAcceptFiles(hwnd, True)
+        WNDPROC = ctypes.WINFUNCTYPE(ctypes.c_longlong, ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p, ctypes.c_void_p)
+
+        def _wnd_proc(hwnd, msg, wparam, lparam):
+            if msg == self.WM_DROPFILES:
+                hdrop = ctypes.c_void_p(wparam)
+                count = self.shell32.DragQueryFileW(hdrop, 0xFFFFFFFF, None, 0)
+                files = []
+                for i in range(count):
+                    length = self.shell32.DragQueryFileW(hdrop, i, None, 0)
+                    buffer = ctypes.create_unicode_buffer(length + 1)
+                    self.shell32.DragQueryFileW(hdrop, i, buffer, length + 1)
+                    files.append(buffer.value)
+                self.shell32.DragFinish(hdrop)
+                self.widget.after(0, lambda: self.callback(files))
+                return 0
+            return self.user32.CallWindowProcW(self.old_proc, hwnd, msg, wparam, lparam)
+
+        self.new_proc = WNDPROC(_wnd_proc)
+        self.old_proc = self.user32.SetWindowLongPtrW(hwnd, self.GWL_WNDPROC, self.new_proc)
+        self.enabled = True
+
+
+def read_tarray(reader: BinaryReader, read_item):
+    count = reader.read_i32()
+    return [read_item(reader) for _ in range(count)]
+
+
+def read_guid(reader: BinaryReader) -> Tuple[int, int, int, int]:
+    return (reader.read_u32(), reader.read_u32(), reader.read_u32(), reader.read_u32())
+
+
+def read_generation(reader: BinaryReader) -> Tuple[int, int, int]:
+    return (reader.read_i32(), reader.read_i32(), reader.read_i32())
+
+
+def read_texture_allocation(reader: BinaryReader):
+    reader.read_i32()
+    reader.read_i32()
+    reader.read_i32()
+    reader.read_i32()
+    reader.read_i32()
+    read_tarray(reader, lambda r: r.read_i32())
+    return None
+
+
+def read_compact_index(reader: BinaryReader) -> int:
+    index = 0
+    b0 = reader.read_u8()
+    if (b0 & 0x40) != 0:
+        b1 = reader.read_u8()
+        if (b1 & 0x80) != 0:
+            b2 = reader.read_u8()
+            if (b2 & 0x80) != 0:
+                b3 = reader.read_u8()
+                if (b3 & 0x80) != 0:
+                    b4 = reader.read_u8()
+                    index = b4
+                index = (index << 7) | (b3 & 0x7F)
+            index = (index << 7) | (b2 & 0x7F)
+        index = (index << 7) | (b1 & 0x7F)
+    index = (index << 6) | (b0 & 0x3F)
+    if (b0 & 0x80) != 0:
+        index *= -1
+    return index
+
+
+def read_index_pkg(reader: BinaryReader, package: ParsedPackage) -> int:
+    if package.summary.file_version >= COMPACT_INDEX_DEPRECATED:
+        return reader.read_i32()
+    return read_compact_index(reader)
+
+
+def read_fname_pkg(reader: BinaryReader, package: ParsedPackage) -> FNameRef:
+    name_index = read_index_pkg(reader, package)
+    if package.summary.file_version >= NUMBER_ADDED_TO_NAME:
+        instance_number = reader.read_i32() - 1
+    else:
+        instance_number = -1
+    return FNameRef(name_index, instance_number)
+
+
+def read_fname(reader: BinaryReader, summary: Optional["FileSummary"] = None) -> FNameRef:
+    # When called with a FileSummary, applies the same UE3 instance-number
+    # convention as read_fname_pkg: the value stored on disk is (number + 1),
+    # so we subtract 1 to recover the in-memory number where -1 means "no
+    # suffix" and 0/1/2/... are real instance suffixes. UE Explorer's
+    # ReadName/ReadNameReference does the same thing
+    # (see UELib/src/UnrealStream.cs ReadName, line ~509-516). When called
+    # without a summary we keep the legacy raw read for any caller that
+    # genuinely wants two i32s with no adjustment - currently nothing in the
+    # codebase relies on that, but the default keeps the signature backwards
+    # compatible if external callers exist.
+    name_index = reader.read_i32()
+    raw_instance = reader.read_i32()
+    if summary is not None and summary.file_version >= NUMBER_ADDED_TO_NAME:
+        instance_number = raw_instance - 1
+    else:
+        instance_number = raw_instance
+    return FNameRef(name_index, instance_number)
+
+
+def read_name_entry(reader: BinaryReader, index: int) -> NameEntry:
+    return NameEntry(index=index, name=reader.read_fstring(), flags=reader.read_u64())
+
+
+def read_compressed_chunk_32(reader: BinaryReader) -> FCompressedChunk:
+    return FCompressedChunk(
+        uncompressed_offset=reader.read_i32(),
+        uncompressed_size=reader.read_i32(),
+        compressed_offset=reader.read_i32(),
+        compressed_size=reader.read_i32(),
+    )
+
+
+def read_compressed_chunk_64(reader: BinaryReader) -> FCompressedChunk:
+    return FCompressedChunk(
+        uncompressed_offset=reader.read_i64(),
+        uncompressed_size=reader.read_i32(),
+        compressed_offset=reader.read_i64(),
+        compressed_size=reader.read_i32(),
+    )
+
+
+def parse_file_summary(stream: BinaryIO) -> FileSummary:
+    r = BinaryReader(stream)
+    summary = FileSummary()
+    summary.tag = r.read_u32()
+    if summary.tag != PACKAGE_FILE_TAG:
+        raise ValueError("Not a valid Unreal Engine package")
+    summary.file_version = r.read_u16()
+    summary.licensee_version = r.read_u16()
+    summary.total_header_size = r.read_i32()
+    summary.folder_name = r.read_fstring()
+    summary.package_flags_flags_offset = r.tell()
+    summary.package_flags = r.read_u32()
+    summary.name_count = r.read_i32()
+    summary.name_offset = r.read_i32()
+    summary.export_count = r.read_i32()
+    summary.export_offset = r.read_i32()
+    summary.import_count = r.read_i32()
+    summary.import_offset = r.read_i32()
+    summary.depends_offset = r.read_i32()
+    summary.import_export_guids_offset = r.read_i32()
+    summary.import_guids_count = r.read_i32()
+    summary.export_guids_count = r.read_i32()
+    summary.thumbnail_table_offset = r.read_i32()
+    summary.guid = read_guid(r)
+    summary.generations = read_tarray(r, read_generation)
+    summary.engine_version = r.read_u32()
+    summary.cooker_version = r.read_u32()
+    summary.compression_flags_offset = r.tell()
+    summary.compression_flags = r.read_u32()
+    summary.compressed_chunks = read_tarray(r, read_compressed_chunk_32)
+    r.read_i32()
+    read_tarray(r, lambda rr: rr.read_fstring())
+    read_tarray(r, read_texture_allocation)
+    return summary
+
+
+def parse_file_compression_metadata(stream: BinaryIO) -> FileCompressionMetaData:
+    r = BinaryReader(stream)
+    return FileCompressionMetaData(
+        garbage_size=r.read_i32(),
+        compressed_chunks_offset=r.read_i32(),
+        last_block_size=r.read_i32(),
+    )
+
+
+def verify_decryptor(summary: FileSummary, meta: FileCompressionMetaData, key: bytes, encrypted_data: bytes) -> bool:
+    block_offset = meta.compressed_chunks_offset % 16
+    block_start = meta.compressed_chunks_offset - block_offset
+    probe = encrypted_data[block_start:block_start + 32]
+    if len(probe) != 32:
+        return False
+    decrypted = DecryptionProvider.decrypt_ecb(key, probe)
+    view = decrypted[block_offset:]
+    if len(view) < 8:
+        return False
+    chunk_info_length, first_uncompressed_offset = struct.unpack("<ii", view[:8])
+    return chunk_info_length >= 1 and first_uncompressed_offset == summary.depends_offset
+
+
+def decrypt_data(stream: BinaryIO, summary: FileSummary, meta: FileCompressionMetaData, provider: DecryptionProvider) -> bytes:
+    encrypted_size = summary.total_header_size - meta.garbage_size - summary.name_offset
+    encrypted_size = (encrypted_size + 15) & ~15
+    stream.seek(summary.name_offset)
+    encrypted_data = stream.read(encrypted_size)
+    if len(encrypted_data) != encrypted_size:
+        raise ValueError("Failed to read the encrypted data from the stream")
+    valid_key = None
+    for key in provider.decryption_keys:
+        if verify_decryptor(summary, meta, key, encrypted_data):
+            valid_key = key
+            break
+    if valid_key is None:
+        raise ValueError("Unknown Decryption key")
+    return DecryptionProvider.decrypt_ecb(valid_key, encrypted_data)
+
+
+def parse_rl_compressed_chunks(decrypted_data: bytes, offset: int) -> List[FCompressedChunk]:
+    bio = io.BytesIO(decrypted_data)
+    bio.seek(offset)
+    r = BinaryReader(bio)
+    return read_tarray(r, read_compressed_chunk_64)
+
+
+def process_compressed_data(output: BinaryIO, package_stream: BinaryIO, summary: FileSummary) -> None:
+    if not summary.compressed_chunks:
+        raise ValueError("No compressed chunks were found in decrypted data")
+    first_uncompressed_offset = summary.compressed_chunks[0].uncompressed_offset
+    last_chunk = summary.compressed_chunks[-1]
+    final_size = last_chunk.uncompressed_offset + last_chunk.uncompressed_size
+    output.truncate(final_size)
+    output.seek(first_uncompressed_offset)
+    r = BinaryReader(package_stream)
+    for chunk in summary.compressed_chunks:
+        package_stream.seek(chunk.compressed_offset)
+        r.read_i32()
+        r.read_i32()
+        r.read_i32()
+        total_uncompressed_size = r.read_i32()
+        sum_uncompressed_size = 0
+        blocks: List[Tuple[int, int]] = []
+        while sum_uncompressed_size < total_uncompressed_size:
+            comp_size = r.read_i32()
+            uncomp_size = r.read_i32()
+            blocks.append((comp_size, uncomp_size))
+            sum_uncompressed_size += uncomp_size
+        for comp_size, uncomp_size in blocks:
+            compressed_block = r.read_exact(comp_size)
+            inflated = zlib.decompress(compressed_block)
+            if len(inflated) != uncomp_size:
+                raise ValueError(f"Unexpected uncompressed block size: expected {uncomp_size}, got {len(inflated)}")
+            output.write(inflated)
+    output.seek(summary.package_flags_flags_offset)
+    output.write(struct.pack("<I", summary.package_flags & ~PKG_COOKED))
+    output.seek(summary.compression_flags_offset)
+    output.write(struct.pack("<I", COMPRESS_NONE))
+
+
+def unpack_package(input_path: str, output_path: str, provider: DecryptionProvider) -> Path:
+    with open(input_path, "rb") as src:
+        summary = parse_file_summary(src)
+        if (summary.compression_flags & COMPRESS_ZLIB) == 0:
+            raise ValueError("Package compression type is unsupported")
+        meta = parse_file_compression_metadata(src)
+        src.seek(0)
+        header_bytes = src.read(summary.name_offset)
+        decrypted_data = decrypt_data(src, summary, meta, provider)
+        summary.compressed_chunks = parse_rl_compressed_chunks(decrypted_data, meta.compressed_chunks_offset)
+        if not summary.compressed_chunks or summary.compressed_chunks[0].uncompressed_offset != summary.depends_offset:
+            raise ValueError("Failed to parse decrypted compressed chunk table")
+        output_path = str(output_path)
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+        with open(output_path, "wb+") as dst:
+            dst.write(header_bytes)
+            dst.write(decrypted_data)
+            process_compressed_data(dst, src, summary)
+    return Path(output_path)
+
+
+def unpack_plain_package(input_path: str, output_path: str) -> Path:
+    with open(input_path, "rb") as src:
+        summary = parse_file_summary(src)
+        if (summary.compression_flags & COMPRESS_ZLIB) == 0:
+            raise ValueError("Package compression type is unsupported")
+        output_path = str(output_path)
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+        original_bytes = Path(input_path).read_bytes()
+        with open(output_path, "wb+") as dst:
+            dst.write(original_bytes)
+            process_compressed_data(dst, src, summary)
+    return Path(output_path)
+
+
+def try_parse_plain_package(input_path: Path) -> Optional["ParsedPackage"]:
+    try:
+        return parse_decrypted_package(input_path)
+    except Exception:
+        return None
+
+
+def resolve_input_package(input_path: Path, decrypted_dir: Path, script_dir: Path) -> Tuple[Path, "ParsedPackage", Optional[DecryptionProvider], Optional[Path], bool]:
+    plain_package = try_parse_plain_package(input_path)
+    if plain_package is not None:
+        return input_path, plain_package, None, None, False
+
+    with input_path.open("rb") as fh:
+        summary = parse_file_summary(fh)
+
+    if (summary.compression_flags & COMPRESS_ZLIB) != 0:
+        plain_decompressed_path = decrypted_dir / f"{input_path.stem}_decompressed.upk"
+        try:
+            unpack_plain_package(str(input_path), str(plain_decompressed_path))
+            return plain_decompressed_path, parse_decrypted_package(plain_decompressed_path), None, None, False
+        except Exception:
+            pass
+
+    keys_path = find_keys_path(script_dir, input_path)
+    if keys_path is None:
+        raise FileNotFoundError("Could not find keys.txt next to the script, current directory, or selected file")
+    provider = DecryptionProvider(str(keys_path))
+    decrypted_path = decrypted_dir / f"{input_path.stem}_decrypted.upk"
+    unpack_package(str(input_path), str(decrypted_path), provider)
+    return decrypted_path, parse_decrypted_package(decrypted_path), provider, keys_path, True
+
+
+def parse_import_entry(reader: BinaryReader, table_index: int, summary: "FileSummary") -> ImportEntry:
+    return ImportEntry(
+        table_index=table_index,
+        class_package=read_fname(reader, summary),
+        class_name=read_fname(reader, summary),
+        outer_index=reader.read_i32(),
+        object_name=read_fname(reader, summary),
+    )
+
+
+def parse_export_entry(reader: BinaryReader, table_index: int, generation_count: int, summary: "FileSummary") -> ExportEntry:
+    # The export entry layout in this UE3 build is:
+    #   class_index (i32) | super_index (i32) | outer_index (i32) |
+    #   object_name (FName: i32 name_index + i32 instance_number) |
+    #   archetype_index (i32) | object_flags (u64) |
+    #   serial_size (i32) | serial_offset (i64) | export_flags (i32) |
+    #   net_objects (TArray<i32>: i32 count + count * i32) |
+    #   package_guid (4*u32) | package_flags (i32)
+    #
+    # net_objects IS length-prefixed in this package version - it was the
+    # generation_count assumption that was wrong. The original "None / Class
+    # / 0 / 0" tail in the GUI is most likely an artifact of the export count
+    # in the summary being larger than the number of real entries on disk
+    # (the table is followed by zero padding), not a parser desync. The
+    # generation_count parameter is kept for signature stability with
+    # callers, but is not used.
+    del generation_count
+    class_index = reader.read_i32()
+    super_index = reader.read_i32()
+    outer_index = reader.read_i32()
+    object_name = read_fname(reader, summary)
+    archetype_index = reader.read_i32()
+    object_flags = reader.read_u64()
+    serial_size = reader.read_i32()
+    serial_offset = reader.read_i64()
+    export_flags = reader.read_i32()
+    net_objects = read_tarray(reader, lambda rr: rr.read_i32())
+    package_guid = read_guid(reader)
+    package_flags = reader.read_i32()
+    return ExportEntry(
+        table_index=table_index,
+        class_index=class_index,
+        super_index=super_index,
+        outer_index=outer_index,
+        object_name=object_name,
+        archetype_index=archetype_index,
+        object_flags=object_flags,
+        serial_size=serial_size,
+        serial_offset=serial_offset,
+        export_flags=export_flags,
+        net_objects=net_objects,
+        package_guid=package_guid,
+        package_flags=package_flags,
+    )
+
+
+def parse_decrypted_package(file_path: Path) -> ParsedPackage:
+    data = file_path.read_bytes()
+    bio = io.BytesIO(data)
+    summary = parse_file_summary(bio)
+    if summary.compression_flags != COMPRESS_NONE:
+        raise ValueError("The decrypted package is still marked as compressed")
+    r = BinaryReader(bio)
+    bio.seek(summary.name_offset)
+    names = [read_name_entry(r, i) for i in range(summary.name_count)]
+    bio.seek(summary.import_offset)
+    imports = [parse_import_entry(r, i, summary) for i in range(summary.import_count)]
+    bio.seek(summary.export_offset)
+    exports = [parse_export_entry(r, i, len(summary.generations), summary) for i in range(summary.export_count)]
+    return ParsedPackage(file_path=file_path, summary=summary, names=names, imports=imports, exports=exports, file_bytes=data)
+
+
+def parse_decrypted_package_bytes(file_path: Path, data: bytes) -> ParsedPackage:
+    bio = io.BytesIO(data)
+    summary = parse_file_summary(bio)
+    if summary.compression_flags != COMPRESS_NONE:
+        raise ValueError("The decrypted package is still marked as compressed")
+    r = BinaryReader(bio)
+    bio.seek(summary.name_offset)
+    names = [read_name_entry(r, i) for i in range(summary.name_count)]
+    bio.seek(summary.import_offset)
+    imports = [parse_import_entry(r, i, summary) for i in range(summary.import_count)]
+    bio.seek(summary.export_offset)
+    exports = [parse_export_entry(r, i, len(summary.generations), summary) for i in range(summary.export_count)]
+    return ParsedPackage(file_path=file_path, summary=summary, names=names, imports=imports, exports=exports, file_bytes=data)
+
+
+def verify_package(package: ParsedPackage) -> List[Tuple[str, str]]:
+    """Deep consistency check on a parsed package's header tables.
+
+    Returns a list of (severity, message) tuples where severity is one of
+    'OK', 'WARN', 'ERROR'. An 'ERROR' indicates the package is internally
+    inconsistent in a way that the engine is likely to choke on at load
+    time (often manifesting as a freeze or crash). 'WARN' flags things
+    that look unusual but might be intentional. 'OK' lines summarize
+    successful invariant checks.
+
+    The checks here are derived from cross-referencing UE Explorer's
+    canonical loader and the offset bookkeeping in our own _replace_header_tables.
+    """
+    findings: List[Tuple[str, str]] = []
+    s = package.summary
+    file_len = len(package.file_bytes)
+
+    # Summary-level offset sanity.
+    if s.name_offset <= 0 or s.name_offset >= file_len:
+        findings.append(("ERROR", f"name_offset {s.name_offset} is out of bounds (file size {file_len})"))
+    if s.import_offset <= 0 or s.import_offset >= file_len:
+        findings.append(("ERROR", f"import_offset {s.import_offset} is out of bounds"))
+    if s.export_offset <= 0 or s.export_offset >= file_len:
+        findings.append(("ERROR", f"export_offset {s.export_offset} is out of bounds"))
+    if s.depends_offset <= 0 or s.depends_offset > file_len:
+        findings.append(("ERROR", f"depends_offset {s.depends_offset} is out of bounds"))
+
+    # Tables must be in the canonical order: names < imports < exports < depends.
+    if not (s.name_offset < s.import_offset < s.export_offset < s.depends_offset):
+        findings.append((
+            "ERROR",
+            f"Header tables out of order: names@{s.name_offset} imports@{s.import_offset} "
+            f"exports@{s.export_offset} depends@{s.depends_offset}",
+        ))
+    else:
+        findings.append(("OK", "Header tables are in canonical order"))
+
+    # total_header_size sanity. For plain (decompressed) packages this should
+    # equal depends_offset + (size of depends table). We can't compute the
+    # depends table size without re-parsing it, but we can at least require
+    # total_header_size >= depends_offset.
+    if s.total_header_size < s.depends_offset:
+        findings.append((
+            "ERROR",
+            f"total_header_size {s.total_header_size} is less than depends_offset {s.depends_offset}; "
+            f"header region claims to end before the depends table starts",
+        ))
+    else:
+        findings.append(("OK", f"total_header_size {s.total_header_size} >= depends_offset {s.depends_offset}"))
+
+    # Re-parse the export table from disk and verify the cursor lands at
+    # depends_offset. If it doesn't, the export entries on disk don't match
+    # what our parser thinks they look like, which would also confuse the
+    # engine.
+    try:
+        bio = io.BytesIO(package.file_bytes)
+        bio.seek(s.export_offset)
+        r = BinaryReader(bio)
+        for i in range(s.export_count):
+            parse_export_entry(r, i, len(s.generations), s)
+        end_cursor = bio.tell()
+        if end_cursor != s.depends_offset:
+            findings.append((
+                "ERROR",
+                f"After parsing {s.export_count} exports cursor is at {end_cursor}, "
+                f"expected depends_offset {s.depends_offset} (delta {end_cursor - s.depends_offset})",
+            ))
+        else:
+            findings.append(("OK", f"Export table parse cursor lands exactly at depends_offset"))
+    except Exception as exc:
+        findings.append(("ERROR", f"Export table re-parse failed: {exc}"))
+
+    # Per-export bounds. Every export's [serial_offset, serial_offset + serial_size)
+    # must lie inside the file, and must lie at or after total_header_size
+    # (the export bodies live in the data region, not the header region).
+    body_violations = 0
+    for exp in package.exports:
+        if package.is_placeholder_export(exp):
+            continue
+        if exp.serial_size < 0:
+            findings.append(("ERROR", f"Export[{exp.table_index}] has negative serial_size {exp.serial_size}"))
+            body_violations += 1
+            continue
+        if exp.serial_size == 0:
+            continue  # Zero-size exports legitimately have offset 0.
+        if exp.serial_offset < s.total_header_size:
+            findings.append((
+                "ERROR",
+                f"Export[{exp.table_index}] '{package.resolve_name(exp.object_name)}' "
+                f"serial_offset {exp.serial_offset} is before total_header_size {s.total_header_size}",
+            ))
+            body_violations += 1
+        if exp.serial_offset + exp.serial_size > file_len:
+            findings.append((
+                "ERROR",
+                f"Export[{exp.table_index}] '{package.resolve_name(exp.object_name)}' "
+                f"body extends past EOF: serial_offset={exp.serial_offset} + serial_size={exp.serial_size} > file_size={file_len}",
+            ))
+            body_violations += 1
+    if body_violations == 0:
+        findings.append(("OK", f"All {sum(1 for e in package.exports if not package.is_placeholder_export(e))} non-placeholder export bodies are in-bounds"))
+
+    # Detect overlapping export bodies. Two exports' [start, end) ranges
+    # should not overlap.
+    bodies = sorted(
+        ((exp.serial_offset, exp.serial_offset + exp.serial_size, exp.table_index, package.resolve_name(exp.object_name))
+         for exp in package.exports
+         if exp.serial_size > 0 and not package.is_placeholder_export(exp)),
+        key=lambda x: x[0],
+    )
+    overlap_count = 0
+    for prev, curr in zip(bodies, bodies[1:]):
+        if curr[0] < prev[1]:
+            findings.append((
+                "ERROR",
+                f"Export bodies overlap: Export[{prev[2]}] '{prev[3]}' [{prev[0]}, {prev[1]}) "
+                f"vs Export[{curr[2]}] '{curr[3]}' [{curr[0]}, {curr[1]})",
+            ))
+            overlap_count += 1
+    if overlap_count == 0 and bodies:
+        findings.append(("OK", f"No overlapping export bodies among {len(bodies)} non-placeholder exports"))
+
+    # Cross-reference checks. Every export.class_index, super_index,
+    # outer_index, archetype_index must be a valid export or import index.
+    def _index_label(idx: int) -> str:
+        if idx == 0:
+            return "None"
+        if idx > 0:
+            return f"Export[{idx - 1}]"
+        return f"Import[{-idx - 1}]"
+
+    bad_refs = 0
+    for exp in package.exports:
+        for field_name in ("class_index", "super_index", "outer_index", "archetype_index"):
+            idx = getattr(exp, field_name)
+            if idx == 0:
+                continue
+            if idx > 0:
+                if not (1 <= idx <= len(package.exports)):
+                    findings.append((
+                        "ERROR",
+                        f"Export[{exp.table_index}] '{package.resolve_name(exp.object_name)}' "
+                        f"{field_name}={idx} -> {_index_label(idx)} is out of range",
+                    ))
+                    bad_refs += 1
+            else:
+                if not (1 <= -idx <= len(package.imports)):
+                    findings.append((
+                        "ERROR",
+                        f"Export[{exp.table_index}] '{package.resolve_name(exp.object_name)}' "
+                        f"{field_name}={idx} -> {_index_label(idx)} is out of range",
+                    ))
+                    bad_refs += 1
+    for imp in package.imports:
+        # Imports' outer_index can be 0 (top-level) or another import (negative)
+        # or an export (positive). All three are legal in UE3 - imports
+        # parented to exports happen for sub-objects of exports referenced
+        # from outside.
+        if imp.outer_index == 0:
+            continue
+        if imp.outer_index > 0:
+            if not (1 <= imp.outer_index <= len(package.exports)):
+                findings.append((
+                    "ERROR",
+                    f"Import[{imp.table_index}] '{package.resolve_name(imp.object_name)}' "
+                    f"outer_index={imp.outer_index} is out of range",
+                ))
+                bad_refs += 1
+        else:
+            if not (1 <= -imp.outer_index <= len(package.imports)):
+                findings.append((
+                    "ERROR",
+                    f"Import[{imp.table_index}] '{package.resolve_name(imp.object_name)}' "
+                    f"outer_index={imp.outer_index} is out of range",
+                ))
+                bad_refs += 1
+    if bad_refs == 0:
+        findings.append(("OK", "All export/import cross-references resolve"))
+
+    # Name index validity. Every FNameRef in every import/export must have
+    # a name_index inside the names table.
+    bad_names = 0
+    name_count = len(package.names)
+    for imp in package.imports:
+        for label, ref in (("class_package", imp.class_package), ("class_name", imp.class_name), ("object_name", imp.object_name)):
+            if not (0 <= ref.name_index < name_count):
+                findings.append((
+                    "ERROR",
+                    f"Import[{imp.table_index}] {label}.name_index={ref.name_index} is out of range (name_count={name_count})",
+                ))
+                bad_names += 1
+    for exp in package.exports:
+        if not (0 <= exp.object_name.name_index < name_count):
+            findings.append((
+                "ERROR",
+                f"Export[{exp.table_index}] object_name.name_index={exp.object_name.name_index} is out of range",
+            ))
+            bad_names += 1
+    if bad_names == 0:
+        findings.append(("OK", f"All FName references point inside the {name_count}-entry name table"))
+
+    # Detect orphan exports: any non-placeholder export whose outer_index
+    # cannot be reached from a root (outer_index == 0). Exports that descend
+    # into invalid outers are loadable in isolation but the engine may
+    # behave oddly when iterating the package tree.
+    orphans = 0
+    visited: Dict[int, bool] = {}
+
+    def _has_root(idx: int, depth: int = 0) -> bool:
+        if depth > len(package.exports) + len(package.imports) + 2:
+            return False  # cycle
+        if idx == 0:
+            return True
+        if idx in visited:
+            return visited[idx]
+        if idx > 0:
+            outer = package.exports[idx - 1].outer_index
+        else:
+            outer = package.imports[-idx - 1].outer_index
+        result = _has_root(outer, depth + 1)
+        visited[idx] = result
+        return result
+
+    for exp in package.exports:
+        if package.is_placeholder_export(exp):
+            continue
+        if not _has_root(exp.table_index + 1):
+            findings.append((
+                "WARN",
+                f"Export[{exp.table_index}] '{package.resolve_name(exp.object_name)}' "
+                "has an unreachable outer chain (cycle or invalid outer)",
+            ))
+            orphans += 1
+    if orphans == 0:
+        findings.append(("OK", "All non-placeholder exports have valid outer chains"))
+
+    return findings
+
+
+def format_verify_report(findings: List[Tuple[str, str]]) -> str:
+    error_count = sum(1 for sev, _ in findings if sev == "ERROR")
+    warn_count = sum(1 for sev, _ in findings if sev == "WARN")
+    ok_count = sum(1 for sev, _ in findings if sev == "OK")
+    header = f"Package verification: {error_count} error(s), {warn_count} warning(s), {ok_count} check(s) passed"
+    lines = [header, "=" * len(header), ""]
+    # Errors first, then warnings, then OK.
+    for severity in ("ERROR", "WARN", "OK"):
+        for sev, msg in findings:
+            if sev == severity:
+                lines.append(f"[{sev}] {msg}")
+    return "\n".join(lines)
+
+
+def sha1_file(path: Path) -> str:
+    digest = hashlib.sha1()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def patch_sha1_in_exe(exe_path: Path, old_sha1_hex: str, new_sha1_hex: str) -> int:
+    old_sha1_hex = old_sha1_hex.strip().lower()
+    new_sha1_hex = new_sha1_hex.strip().lower()
+    if len(old_sha1_hex) != 40 or len(new_sha1_hex) != 40:
+        raise ValueError("SHA-1 values must be 40 hex characters")
+    old_bytes = bytes.fromhex(old_sha1_hex)
+    new_bytes = bytes.fromhex(new_sha1_hex)
+    data = bytearray(exe_path.read_bytes())
+    count = 0
+    start = 0
+    while True:
+        idx = data.find(old_bytes, start)
+        if idx < 0:
+            break
+        data[idx:idx + len(old_bytes)] = new_bytes
+        count += 1
+        start = idx + len(new_bytes)
+    if count == 0:
+        raise ValueError(f"Original SHA-1 bytes were not found in {exe_path.name}")
+    exe_path.write_bytes(data)
+    return count
+
+
+def find_keys_path(script_dir: Path, selected_file: Path) -> Optional[Path]:
+    candidates = [
+        script_dir / "keys.txt",
+        Path.cwd() / "keys.txt",
+        selected_file.parent / "keys.txt",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def format_hex_preview(data: bytes, base_offset: int = 0) -> str:
+    if not data:
+        return ""
+    lines = []
+    for i in range(0, len(data), 16):
+        chunk = data[i:i + 16]
+        hex_part = " ".join(f"{b:02X}" for b in chunk)
+        ascii_part = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
+        lines.append(f"{base_offset + i:08X}  {hex_part:<47}  {ascii_part}")
+    return "\n".join(lines)
+
+
+class App:
+    def __init__(self, root: tk.Tk):
+        self.root = root
+        self.root.title("RL UPK All-in-One GUI")
+        self.root.geometry("1500x920")
+        self.script_dir = Path(__file__).resolve().parent
+        self.decrypted_dir = self.script_dir / "Decrypted"
+        self.decrypted_dir.mkdir(exist_ok=True)
+        self.sha1_memory: Dict[str, Dict[str, str]] = {}
+        self.package: Optional[ParsedPackage] = None
+        self.current_content_map: Dict[str, ExportEntry] = {}
+        self.current_export_map: Dict[str, ExportEntry] = {}
+        self.current_import_map: Dict[str, ImportEntry] = {}
+        self.current_name_map: Dict[str, NameEntry] = {}
+        self.selected_input_path: Optional[Path] = None
+        self.sdk_db: Optional[RLSDKDatabase] = None
+        self.sdk_path: Optional[Path] = None
+        self.current_properties: List[ParsedProperty] = []
+        self.current_export: Optional[ExportEntry] = None
+        self.current_property: Optional[ParsedProperty] = None
+        self.current_provider: Optional[DecryptionProvider] = None
+        self.current_encrypted_input_path: Optional[Path] = None
+        self.current_keys_path: Optional[Path] = None
+        self.current_original_sha1: Optional[str] = None
+        self.donor_key_upk_path: Optional[Path] = None  # path to donor encrypted UPK for key sourcing
+        self.use_donor_key_var: Optional[tk.BooleanVar] = None  # set during _build_ui
+        self.donor_key_path_var: Optional[tk.StringVar] = None  # display label, set during _build_ui
+        self.status_var = tk.StringVar(value="Ready")
+        self.original_var = tk.StringVar(value="Original: -")
+        self.sha1_var = tk.StringVar(value="SHA-1: -")
+        self.decrypted_var = tk.StringVar(value="Decrypted: -")
+        self.keys_var = tk.StringVar(value="Keys: -")
+        self.sdk_var = tk.StringVar(value="Property parser: package-native UE3 tags")
+        self._build_ui()
+        self.drop_target = NativeWindowsDropTarget(self.root, self._on_drop_files)
+        self.root.after(200, self._update_drop_label)
+
+    def _build_ui(self):
+        self.root.configure(bg="#101114")
+        style = ttk.Style()
+        try:
+            style.theme_use("clam")
+        except tk.TclError:
+            pass
+        style.configure("Treeview", rowheight=24)
+
+        top = tk.Frame(self.root, bg="#101114")
+        top.pack(fill="x", padx=12, pady=12)
+
+        open_button = ttk.Button(top, text="Open UPK", command=self.open_file)
+        open_button.pack(side="left")
+
+        self.drop_label = tk.Label(
+            top,
+            text="Drop an encrypted .upk here or use Open UPK",
+            bg="#171a21",
+            fg="#dbe6ff",
+            padx=18,
+            pady=12,
+            relief="groove",
+            bd=2,
+        )
+        self.drop_label.pack(side="left", fill="x", expand=True, padx=(10, 0))
+
+        info = tk.Frame(self.root, bg="#101114")
+        info.pack(fill="x", padx=12)
+        for value in [self.original_var, self.sha1_var, self.decrypted_var, self.keys_var]:
+            tk.Label(info, textvariable=value, anchor="w", bg="#101114", fg="#dbe6ff").pack(fill="x")
+
+        main = tk.PanedWindow(self.root, sashrelief="flat", sashwidth=6, bg="#101114")
+        main.pack(fill="both", expand=True, padx=12, pady=12)
+
+        left = tk.Frame(main, bg="#101114")
+        right = tk.Frame(main, bg="#101114")
+        main.add(left, minsize=520)
+        main.add(right, minsize=520)
+
+        session_frame = ttk.LabelFrame(left, text="Session SHA-1 Memory")
+        session_frame.pack(fill="x")
+        self.history_tree = ttk.Treeview(session_frame, columns=("sha1",), show="tree headings", height=6)
+        self.history_tree.heading("#0", text="File")
+        self.history_tree.heading("sha1", text="SHA-1")
+        self.history_tree.column("#0", width=320, anchor="w")
+        self.history_tree.column("sha1", width=260, anchor="w")
+        self.history_tree.pack(fill="x", padx=6, pady=6)
+
+        left_notebook = ttk.Notebook(left)
+        left_notebook.pack(fill="both", expand=True, pady=(12, 0))
+
+        self.content_tree = self._make_tree(left_notebook, ("class", "path"), (240, 380))
+        self.content_tree.heading("#0", text="Name")
+        left_notebook.add(self.content_tree.master, text="Content")
+        self.content_tree.bind("<<TreeviewSelect>>", self._on_content_select)
+
+        # Exports tab: wrap the tree in a frame that also holds a
+        # 'Hide placeholder exports' checkbox. RL .upk files contain export
+        # slots that are entirely zeroed (class=0, name='None', no body) -
+        # these are real on-disk entries, not parser bugs, but they clutter
+        # the table. The checkbox lets the user filter them out, matching
+        # how UE Explorer hides them from its class list. Default is OFF so
+        # nothing changes for existing workflows; flipping it on hides the
+        # placeholders. Same pack-order rule as the Names tab: bottom row
+        # first, tree second, so the tree's expand=True doesn't shove the
+        # row off-screen.
+        exports_tab = ttk.Frame(left_notebook)
+        left_notebook.add(exports_tab, text="Exports")
+
+        self.hide_placeholder_exports_var = tk.BooleanVar(value=False)
+        exports_top_row = ttk.Frame(exports_tab)
+        exports_top_row.pack(side="top", fill="x", padx=6, pady=(6, 0))
+        ttk.Checkbutton(
+            exports_top_row,
+            text="Hide placeholder exports (class=0, name=None, empty)",
+            variable=self.hide_placeholder_exports_var,
+            command=self._populate_exports_tree,
+        ).pack(side="left")
+        self.exports_placeholder_count_var = tk.StringVar(value="")
+        ttk.Label(exports_top_row, textvariable=self.exports_placeholder_count_var).pack(side="left", padx=(12, 0))
+
+        self.exports_tree = self._make_tree(exports_tab, ("name", "class", "outer", "size", "offset"), (220, 160, 240, 90, 110))
+        self.exports_tree.heading("#0", text="Index")
+        self.exports_tree.master.pack(side="top", fill="both", expand=True)
+        self.exports_tree.bind("<<TreeviewSelect>>", self._on_exports_select)
+        # Visual styling for placeholder rows so they're clearly distinct
+        # even when shown. Treeview supports tag_configure for per-row
+        # foreground colors.
+        self.exports_tree.tag_configure("placeholder", foreground="#5a6577")
+
+        self.imports_tree = self._make_tree(left_notebook, ("name", "class", "package", "outer"), (220, 160, 160, 260))
+        self.imports_tree.heading("#0", text="Index")
+        left_notebook.add(self.imports_tree.master, text="Imports")
+        self.imports_tree.bind("<<TreeviewSelect>>", self._on_imports_select)
+
+        # Names tab: a wrapper frame holds both the names tree (top, fills
+        # available space) and the inline rename row (bottom, fixed height).
+        # Without the wrapper, the edit row would be inside the tree's own
+        # grid-managed frame and could get clipped by the notebook's height
+        # calculation, so we mimic the Properties-tab layout: pack the tree
+        # frame and the edit row as siblings inside one container that gets
+        # added to the notebook.
+        #
+        # Pack order matters: the bottom edit row is packed FIRST so pack
+        # reserves its space before the tree's expand=True consumes the rest.
+        # If we packed the tree first, it would claim all available height
+        # and the edit row would be pushed below the visible area.
+        names_tab = ttk.Frame(left_notebook)
+        left_notebook.add(names_tab, text="Names")
+
+        # Edit row pinned to the bottom of the Names tab, outside the tree's
+        # internal grid so the notebook can never hide it. Packed first.
+        names_edit = ttk.Frame(names_tab)
+        names_edit.pack(side="bottom", fill="x", padx=6, pady=6)
+        self.name_edit_info_var = tk.StringVar(value="Select a name to rename")
+        ttk.Label(names_edit, textvariable=self.name_edit_info_var).pack(fill="x")
+        name_edit_row = ttk.Frame(names_edit)
+        name_edit_row.pack(fill="x", pady=(4, 0))
+        ttk.Label(name_edit_row, text="New Text:").pack(side="left")
+        self.name_edit_var = tk.StringVar()
+        self.name_edit_entry = ttk.Entry(name_edit_row, textvariable=self.name_edit_var)
+        self.name_edit_entry.pack(side="left", fill="x", expand=True, padx=(6, 6))
+        # Pressing Enter in the entry applies the rename.
+        self.name_edit_entry.bind("<Return>", lambda _e: self.rename_selected_name())
+        ttk.Button(name_edit_row, text="Rename Name", command=self.rename_selected_name).pack(side="left")
+
+        # Now pack the tree on top, filling the remaining space.
+        self.names_tree = self._make_tree(names_tab, ("name", "flags"), (380, 220))
+        self.names_tree.heading("#0", text="Index")
+        # The tree's own frame (created by _make_tree, exposed as tree.master)
+        # is already grid-managed internally; pack it into the wrapper.
+        self.names_tree.master.pack(side="top", fill="both", expand=True)
+        self.names_tree.bind("<<TreeviewSelect>>", self._on_names_select)
+        # Double-clicking a row in the names tree focuses the entry so the
+        # user can immediately type a replacement.
+        self.names_tree.bind("<Double-1>", self._on_names_double_click)
+
+        self.summary_tree = self._make_tree(left_notebook, ("value",), (520,))
+        self.summary_tree.heading("#0", text="Field")
+        left_notebook.add(self.summary_tree.master, text="Summary")
+
+        right_notebook = ttk.Notebook(right)
+        right_notebook.pack(fill="both", expand=True)
+
+        details_frame = ttk.Frame(right_notebook)
+        right_notebook.add(details_frame, text="Details")
+        self.details_text = tk.Text(details_frame, wrap="none", bg="#111318", fg="#e8ecf4", insertbackground="#ffffff")
+        self._pack_text_with_scrollbars(details_frame, self.details_text)
+
+        properties_frame = ttk.Frame(right_notebook)
+        right_notebook.add(properties_frame, text="Properties")
+        self.properties_tree = self._make_tree(properties_frame, ("declared_type", "tag_type", "owner_type", "size", "array_index", "value"), (180, 130, 220, 80, 90, 420))
+        self.properties_tree.heading("#0", text="Property")
+        self.properties_tree.master.pack(fill="both", expand=True)
+        self.properties_tree.bind("<<TreeviewSelect>>", self._on_property_select)
+        prop_edit = ttk.Frame(properties_frame)
+        prop_edit.pack(fill="x", padx=6, pady=6)
+        self.property_info_var = tk.StringVar(value="Select a property to edit")
+        ttk.Label(prop_edit, textvariable=self.property_info_var).pack(fill="x")
+        # ── Donor-key row ────────────────────────────────────────────────────
+        # When enabled, re-encryption uses the key that decrypts a *different*
+        # encrypted UPK (selected by the user) rather than the key that was
+        # used to decrypt the currently-loaded package.  This lets you take an
+        # edit from one version's package and encrypt it with a key from a
+        # different version without needing to know the key in advance.
+        donor_key_row = ttk.Frame(prop_edit)
+        donor_key_row.pack(fill="x", pady=(4, 0))
+        self.use_donor_key_var = tk.BooleanVar(value=False)
+        ttk.Checkbutton(
+            donor_key_row,
+            text="Encrypt with key from another UPK:",
+            variable=self.use_donor_key_var,
+        ).pack(side="left")
+        self.donor_key_path_var = tk.StringVar(value="(none selected)")
+        tk.Label(donor_key_row, textvariable=self.donor_key_path_var,
+                 bg="#101114", fg="#a8b4cc", anchor="w").pack(side="left", fill="x", expand=True, padx=(6, 6))
+        ttk.Button(donor_key_row, text="Pick Donor UPK…",
+                   command=self._pick_donor_key_upk).pack(side="left")
+
+        # ── Action buttons ───────────────────────────────────────────────────
+        edit_row = ttk.Frame(prop_edit)
+        edit_row.pack(fill="x", pady=(6, 0))
+        ttk.Label(edit_row, text="New Value:").pack(side="left")
+        self.property_edit_var = tk.StringVar()
+        self.property_edit_entry = ttk.Entry(edit_row, textvariable=self.property_edit_var)
+        self.property_edit_entry.pack(side="left", fill="x", expand=True, padx=(6, 6))
+        ttk.Button(edit_row, text="Apply Property Edit", command=self.apply_property_edit).pack(side="left")
+        ttk.Button(edit_row, text="Rename Export FName", command=self.rename_export_fname).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Import Donor Names", command=self.import_donor_names).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Import Donor Exports", command=self.import_donor_exports).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Replace Export From Donor", command=self.replace_export_from_donor).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Save Re-Encrypted UPK", command=self.save_reencrypted_upk).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Save Decrypted UPK", command=self.save_decrypted_upk).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Set DLLBind", command=self.set_dll_bind).pack(side="left", padx=(6, 0))
+        ttk.Button(edit_row, text="Verify Package", command=self.verify_current_package).pack(side="left", padx=(6, 0))
+
+        raw_frame = ttk.Frame(right_notebook)
+        right_notebook.add(raw_frame, text="Raw Data")
+        self.raw_text = tk.Text(raw_frame, wrap="none", bg="#111318", fg="#e8ecf4", insertbackground="#ffffff")
+        self._pack_text_with_scrollbars(raw_frame, self.raw_text)
+
+        status = tk.Label(self.root, textvariable=self.status_var, anchor="w", bg="#0b0c0f", fg="#dbe6ff", padx=12, pady=6)
+        status.pack(fill="x", side="bottom")
+
+    def _make_tree(self, parent, columns: Tuple[str, ...], widths: Tuple[int, ...]):
+        frame = ttk.Frame(parent)
+        tree = ttk.Treeview(frame, columns=columns, show="tree headings")
+        tree.heading("#0", text="#")
+        tree.column("#0", width=70, anchor="w")
+        for column, width in zip(columns, widths):
+            tree.heading(column, text=column.title())
+            tree.column(column, width=width, anchor="w")
+        vsb = ttk.Scrollbar(frame, orient="vertical", command=tree.yview)
+        hsb = ttk.Scrollbar(frame, orient="horizontal", command=tree.xview)
+        tree.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)
+        tree.grid(row=0, column=0, sticky="nsew")
+        vsb.grid(row=0, column=1, sticky="ns")
+        hsb.grid(row=1, column=0, sticky="ew")
+        frame.rowconfigure(0, weight=1)
+        frame.columnconfigure(0, weight=1)
+        return tree
+
+    def _pack_text_with_scrollbars(self, frame, text):
+        vsb = ttk.Scrollbar(frame, orient="vertical", command=text.yview)
+        hsb = ttk.Scrollbar(frame, orient="horizontal", command=text.xview)
+        text.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)
+        text.grid(row=0, column=0, sticky="nsew")
+        vsb.grid(row=0, column=1, sticky="ns")
+        hsb.grid(row=1, column=0, sticky="ew")
+        frame.rowconfigure(0, weight=1)
+        frame.columnconfigure(0, weight=1)
+
+    def _load_rlsdk(self):
+        candidates = [
+            self.script_dir / "RLSDK.zip",
+            Path.cwd() / "RLSDK.zip",
+            self.script_dir / "SDK.zip",
+            Path.cwd() / "SDK.zip",
+        ]
+        for candidate in candidates:
+            if candidate.exists():
+                try:
+                    self.sdk_db = parse_rlsdk_database(candidate)
+                    self.sdk_path = candidate
+                    self.sdk_var.set(f"RLSDK: {candidate}")
+                    return
+                except Exception as exc:
+                    self.sdk_var.set(f"RLSDK: failed to load ({exc})")
+                    return
+        self.sdk_var.set("RLSDK: not found (put RLSDK.zip next to the script)")
+
+    def _update_drop_label(self):
+        if self.drop_target.enabled:
+            self.drop_label.config(text="Drop an encrypted .upk anywhere on this window or use Open UPK")
+        elif sys.platform == "win32":
+            self.drop_label.config(text="Open UPK is ready. Drag/drop initializes after the window is fully created.")
+        else:
+            self.drop_label.config(text="Open UPK is available. Native drag/drop is enabled on Windows.")
+
+    def set_status(self, text: str):
+        self.status_var.set(text)
+        self.root.update_idletasks()
+
+    def open_file(self):
+        path = filedialog.askopenfilename(filetypes=[("Unreal Packages", "*.upk"), ("All Files", "*.*")])
+        if path:
+            self.load_input(Path(path))
+
+    def _on_drop_files(self, files: List[str]):
+        for file_path in files:
+            path = Path(file_path)
+            if path.suffix.lower() == ".upk":
+                self.load_input(path)
+                return
+        messagebox.showerror("Invalid file", "Drop a .upk file.")
+
+    def load_input(self, input_path: Path):
+        self.selected_input_path = input_path
+        self.set_status(f"Hashing {input_path.name}...")
+        threading.Thread(target=self._load_input_worker, args=(input_path,), daemon=True).start()
+
+    def _load_input_worker(self, input_path: Path):
+        try:
+            sha1 = sha1_file(input_path)
+            self.sha1_memory[str(input_path)] = {"sha1": sha1}
+            self.root.after(0, lambda: self._refresh_history())
+            self.root.after(0, lambda: self.set_status(f"Opening {input_path.name}..."))
+            decrypted_path, package, provider, keys_path, was_encrypted = resolve_input_package(input_path, self.decrypted_dir, self.script_dir)
+            label = keys_path if keys_path is not None else "not required"
+            self.root.after(0, lambda: self.keys_var.set(f"Keys: {label}"))
+            if decrypted_path != input_path:
+                self.root.after(0, lambda: self.set_status(f"Parsing {decrypted_path.name}..."))
+            self.root.after(0, lambda: self._apply_loaded_package(input_path, sha1, keys_path or Path(""), decrypted_path, package, provider))
+        except Exception as exc:
+            details = "".join(traceback.format_exception_only(type(exc), exc)).strip()
+            self.root.after(0, lambda: self._show_error(details))
+
+    def _refresh_history(self):
+        for item in self.history_tree.get_children():
+            self.history_tree.delete(item)
+        for path, record in self.sha1_memory.items():
+            self.history_tree.insert("", "end", text=Path(path).name, values=(record["sha1"],))
+
+    def _clear_tree(self, tree: ttk.Treeview):
+        for item in tree.get_children():
+            tree.delete(item)
+
+    def _apply_loaded_package(self, input_path: Path, sha1: str, keys_path: Path, decrypted_path: Path, package: ParsedPackage, provider: Optional[DecryptionProvider]):
+        self.package = package
+        self.current_provider = provider
+        self.current_keys_path = keys_path if str(keys_path) else None
+        self.current_encrypted_input_path = input_path if provider is not None else None
+        self.current_original_sha1 = sha1
+        self.original_var.set(f"Original: {input_path}")
+        self.sha1_var.set(f"SHA-1: {sha1}")
+        self.decrypted_var.set(f"Decrypted: {decrypted_path}")
+        self.keys_var.set(f"Keys: {keys_path if str(keys_path) else 'not required'}")
+        self._populate_summary()
+        self._populate_content_tree()
+        self._populate_exports_tree()
+        self._populate_imports_tree()
+        self._populate_names_tree()
+        self.details_text.delete("1.0", "end")
+        self.raw_text.delete("1.0", "end")
+        self._clear_tree(self.properties_tree)
+        self.current_export = None
+        self.current_property = None
+        self.property_edit_var.set("")
+        self.property_info_var.set("Select a property to edit")
+        self.current_properties = []
+        self.details_text.insert("1.0", self._format_package_overview())
+        self.set_status(f"Loaded {input_path.name}")
+
+    def _populate_summary(self):
+        self._clear_tree(self.summary_tree)
+        if not self.package:
+            return
+        s = self.package.summary
+        rows = [
+            ("FileVersion", s.file_version),
+            ("LicenseeVersion", s.licensee_version),
+            ("TotalHeaderSize", s.total_header_size),
+            ("FolderName", s.folder_name),
+            ("PackageFlags", hex(s.package_flags)),
+            ("NameCount", s.name_count),
+            ("NameOffset", s.name_offset),
+            ("ExportCount", s.export_count),
+            ("ExportOffset", s.export_offset),
+            ("ImportCount", s.import_count),
+            ("ImportOffset", s.import_offset),
+            ("DependsOffset", s.depends_offset),
+            ("CompressionFlags", hex(s.compression_flags)),
+            ("EngineVersion", s.engine_version),
+            ("CookerVersion", s.cooker_version),
+            ("Guid", f"{s.guid[0]:08X}-{s.guid[1]:08X}-{s.guid[2]:08X}-{s.guid[3]:08X}"),
+            ("Generations", len(s.generations)),
+        ]
+        for key, value in rows:
+            self.summary_tree.insert("", "end", text=key, values=(value,))
+
+    def _populate_content_tree(self):
+        self._clear_tree(self.content_tree)
+        self.current_content_map.clear()
+        if not self.package:
+            return
+        children: Dict[int, List[ExportEntry]] = {}
+        for export in self.package.exports:
+            children.setdefault(export.outer_index, []).append(export)
+        roots = [export for export in self.package.exports if export.outer_index == 0 and export.class_index != 0]
+        for export in roots:
+            self._insert_content_export("", export, children)
+
+    def _insert_content_export(self, parent: str, export: ExportEntry, children: Dict[int, List[ExportEntry]]):
+        iid = f"export:{export.table_index}"
+        name = self.package.resolve_name(export.object_name)
+        self.current_content_map[iid] = export
+        path = self.package.resolve_object_path(export.table_index + 1)
+        node = self.content_tree.insert(parent, "end", iid=iid, text=name, values=(self.package.export_class_name(export), path), open=False)
+        for child in children.get(export.table_index + 1, []):
+            self._insert_content_export(node, child, children)
+
+    def _populate_exports_tree(self):
+        self._clear_tree(self.exports_tree)
+        self.current_export_map.clear()
+        if not self.package:
+            self.exports_placeholder_count_var.set("")
+            return
+        hide_placeholders = bool(self.hide_placeholder_exports_var.get())
+        placeholder_count = 0
+        shown = 0
+        for export in self.package.exports:
+            is_placeholder = self.package.is_placeholder_export(export)
+            if is_placeholder:
+                placeholder_count += 1
+                if hide_placeholders:
+                    continue
+            iid = f"export:{export.table_index}"
+            self.current_export_map[iid] = export
+            tags = ("placeholder",) if is_placeholder else ()
+            class_label = "Class (placeholder)" if is_placeholder else self.package.export_class_name(export)
+            self.exports_tree.insert(
+                "",
+                "end",
+                iid=iid,
+                text=str(export.table_index),
+                values=(
+                    self.package.resolve_name(export.object_name),
+                    class_label,
+                    self.package.resolve_object_ref(export.outer_index),
+                    export.serial_size,
+                    export.serial_offset,
+                ),
+                tags=tags,
+            )
+            shown += 1
+        if placeholder_count == 0:
+            self.exports_placeholder_count_var.set(f"{shown} exports, no placeholders")
+        elif hide_placeholders:
+            self.exports_placeholder_count_var.set(
+                f"{shown} shown, {placeholder_count} placeholders hidden"
+            )
+        else:
+            self.exports_placeholder_count_var.set(
+                f"{shown} exports ({placeholder_count} placeholders, marked gray)"
+            )
+
+    def _populate_imports_tree(self):
+        self._clear_tree(self.imports_tree)
+        self.current_import_map.clear()
+        if not self.package:
+            return
+        for imp in self.package.imports:
+            iid = f"import:{imp.table_index}"
+            self.current_import_map[iid] = imp
+            self.imports_tree.insert(
+                "",
+                "end",
+                iid=iid,
+                text=str(imp.table_index),
+                values=(
+                    self.package.resolve_name(imp.object_name),
+                    self.package.resolve_name(imp.class_name),
+                    self.package.resolve_name(imp.class_package),
+                    self.package.resolve_object_ref(imp.outer_index),
+                ),
+            )
+
+    def _populate_names_tree(self):
+        self._clear_tree(self.names_tree)
+        self.current_name_map.clear()
+        # Reset the inline rename row so stale text from a previous package or
+        # selection doesn't carry over after a reload.
+        if hasattr(self, "name_edit_var"):
+            self.name_edit_var.set("")
+        if hasattr(self, "name_edit_info_var"):
+            self.name_edit_info_var.set("Select a name to rename")
+        if not self.package:
+            return
+        for name in self.package.names:
+            iid = f"name:{name.index}"
+            self.current_name_map[iid] = name
+            self.names_tree.insert("", "end", iid=iid, text=str(name.index), values=(name.name, hex(name.flags)))
+
+    def _format_package_overview(self) -> str:
+        if not self.package:
+            return ""
+        s = self.package.summary
+        return "\n".join([
+            f"Package: {self.package.file_path.name}",
+            f"Names: {len(self.package.names)}",
+            f"Imports: {len(self.package.imports)}",
+            f"Exports: {len(self.package.exports)}",
+            f"File Version: {s.file_version}",
+            f"Licensee Version: {s.licensee_version}",
+            f"Header Size: {s.total_header_size}",
+            f"Package Flags: {hex(s.package_flags)}",
+            f"Compression Flags: {hex(s.compression_flags)}",
+            f"Engine Version: {s.engine_version}",
+            f"Cooker Version: {s.cooker_version}",
+        ])
+
+    def _populate_properties(self, export: ExportEntry):
+        self._clear_tree(self.properties_tree)
+        self.current_export = export
+        self.current_property = None
+        self.property_edit_var.set("")
+        self.property_info_var.set("Select a property to edit")
+        self.current_properties = parse_serialized_properties(self.package, export, None) if self.package else []
+        if not self.current_properties:
+            self.properties_tree.insert("", "end", text="No serialized property tags parsed", values=("", "", "", "", "", ""))
+            return
+        for prop in self.current_properties:
+            label = f"{prop.index}: {prop.name}"
+            iid = f"prop:{prop.index}"
+            self.properties_tree.insert("", "end", iid=iid, text=label, values=(prop.declared_type, prop.tag_type, prop.owner_type, prop.size, prop.array_index, prop.value))
+
+    def _show_export(self, export: ExportEntry):
+        class_name = self.package.export_class_name(export)
+        raw = self.package.object_data(export)
+        preview = raw[:HEX_PREVIEW_LIMIT]
+        self._populate_properties(export)
+        details = [
+            f"Type: Export[{export.table_index}]",
+            f"Name: {self.package.resolve_name(export.object_name)}",
+            f"Path: {self.package.resolve_object_path(export.table_index + 1)}",
+            f"Class: {class_name}",
+            f"ClassIndex: {export.class_index} ({self.package.resolve_object_ref(export.class_index)})",
+            f"SuperIndex: {export.super_index} ({self.package.resolve_object_ref(export.super_index)})",
+            f"OuterIndex: {export.outer_index} ({self.package.resolve_object_ref(export.outer_index)})",
+            f"ArchetypeIndex: {export.archetype_index} ({self.package.resolve_object_ref(export.archetype_index)})",
+            f"ObjectFlags: {hex(export.object_flags)}",
+            f"ExportFlags: {hex(export.export_flags)}",
+            f"PackageFlags: {hex(export.package_flags)}",
+            f"SerialSize: {export.serial_size}",
+            f"SerialOffset: {export.serial_offset}",
+            f"PropertiesParsed: {len(self.current_properties)}",
+            f"NetObjects: {export.net_objects}",
+            f"PackageGuid: {export.package_guid[0]:08X}-{export.package_guid[1]:08X}-{export.package_guid[2]:08X}-{export.package_guid[3]:08X}",
+        ]
+        # ── DLLBind info (UClass exports only) ──────────────────────────────
+        if is_uclass_export(self.package, export):
+            dllbind_result = find_uclass_dllbind_fstring_offset(raw)
+            if dllbind_result is not None:
+                dllbind_offset, dllbind_name = dllbind_result
+                details.append(
+                    f"DLLBind: {dllbind_name!r}  "
+                    f"(FString at serial+0x{dllbind_offset:X})"
+                    if dllbind_name else
+                    f"DLLBind: (none)  (FString at serial+0x{dllbind_offset:X})"
+                )
+            else:
+                details.append("DLLBind: <could not locate DLLBindName field>")
+        self.details_text.delete("1.0", "end")
+        self.details_text.insert("1.0", "\n".join(details))
+        self.raw_text.delete("1.0", "end")
+        if raw:
+            header = f"Object data preview: {len(preview)} / {len(raw)} bytes"
+            if len(raw) > HEX_PREVIEW_LIMIT:
+                header += f"\nPreview truncated at {HEX_PREVIEW_LIMIT} bytes\n"
+            else:
+                header += "\n"
+            self.raw_text.insert("1.0", header + "\n" + format_hex_preview(preview, export.serial_offset))
+        else:
+            self.raw_text.insert("1.0", "No serial data available for this export.")
+
+    def _show_import(self, imp: ImportEntry):
+        details = [
+            f"Type: Import[{imp.table_index}]",
+            f"Name: {self.package.resolve_name(imp.object_name)}",
+            f"Path: {self.package.resolve_object_path(-imp.table_index - 1)}",
+            f"ClassName: {self.package.resolve_name(imp.class_name)}",
+            f"ClassPackage: {self.package.resolve_name(imp.class_package)}",
+            f"OuterIndex: {imp.outer_index} ({self.package.resolve_object_ref(imp.outer_index)})",
+        ]
+        self.details_text.delete("1.0", "end")
+        self.details_text.insert("1.0", "\n".join(details))
+        self.raw_text.delete("1.0", "end")
+        self.raw_text.insert("1.0", "Imports do not contain local serial data in the package.")
+        self._clear_tree(self.properties_tree)
+        self.current_export = None
+        self.current_property = None
+        self.property_edit_var.set("")
+        self.property_info_var.set("Select a property to edit")
+        self.current_properties = []
+
+    def _show_name(self, name: NameEntry):
+        self.details_text.delete("1.0", "end")
+        self.details_text.insert("1.0", f"Type: Name[{name.index}]\nName: {name.name}\nFlags: {hex(name.flags)}")
+        self.raw_text.delete("1.0", "end")
+        self.raw_text.insert("1.0", "")
+        self._clear_tree(self.properties_tree)
+        self.current_properties = []
+
+    def _on_content_select(self, _event):
+        selection = self.content_tree.selection()
+        if not selection:
+            return
+        iid = selection[0]
+        export = self.current_content_map.get(iid)
+        if export:
+            self._show_export(export)
+
+    def _on_exports_select(self, _event):
+        selection = self.exports_tree.selection()
+        if not selection:
+            return
+        export = self.current_export_map.get(selection[0])
+        if export:
+            self._show_export(export)
+
+    def _on_imports_select(self, _event):
+        selection = self.imports_tree.selection()
+        if not selection:
+            return
+        imp = self.current_import_map.get(selection[0])
+        if imp:
+            self._show_import(imp)
+
+    def _on_names_select(self, _event):
+        selection = self.names_tree.selection()
+        if not selection:
+            return
+        name = self.current_name_map.get(selection[0])
+        if name:
+            self._show_name(name)
+            # Pre-fill the rename entry with the current text and update the
+            # info label so the user knows exactly which entry will be edited.
+            self.name_edit_var.set(name.name)
+            self.name_edit_info_var.set(
+                f"Name[{name.index}]  flags={hex(name.flags)}  ({len(name.name)} chars)"
+            )
+
+    def _on_names_double_click(self, _event):
+        # Convenience: double-click jumps focus into the rename field with the
+        # current text pre-selected so the user can just start typing.
+        if not self.names_tree.selection():
+            return
+        self.name_edit_entry.focus_set()
+        self.name_edit_entry.select_range(0, "end")
+        self.name_edit_entry.icursor("end")
+
+    def _on_property_select(self, _event):
+        selection = self.properties_tree.selection()
+        if not selection:
+            return
+        iid = selection[0]
+        if not iid.startswith("prop:"):
+            return
+        try:
+            index = int(iid.split(":", 1)[1])
+        except Exception:
+            return
+        if 0 <= index < len(self.current_properties):
+            prop = self.current_properties[index]
+            self.current_property = prop
+            self.property_edit_var.set(prop.value)
+            self.property_info_var.set(f"{prop.name} | {prop.tag_type} | file+0x{(self.current_export.serial_offset + (prop.value_offset - 1 if prop.tag_type == 'BoolProperty' and prop.bool_value is not None else prop.value_offset)):X}")
+
+    def apply_property_edit(self):
+        if not self.package or not self.current_export or not self.current_property:
+            messagebox.showwarning("UPK GUI", "Select an export and a property first.")
+            return
+        try:
+            export_index = self.current_export.table_index
+            prop_name = self.current_property.name
+            prop_array_index = self.current_property.array_index
+            new_bytes = apply_property_edit_bytes(self.package, self.current_export, self.current_property, self.property_edit_var.get())
+            self.package = parse_decrypted_package_bytes(self.package.file_path, new_bytes)
+            self.current_export = self.package.exports[export_index]
+            self._show_export(self.current_export)
+            for i, prop in enumerate(self.current_properties):
+                if prop.name == prop_name and prop.array_index == prop_array_index:
+                    iid = f"prop:{i}"
+                    if self.properties_tree.exists(iid):
+                        self.properties_tree.selection_set(iid)
+                        self.properties_tree.focus(iid)
+                        self.current_property = prop
+                        self.property_edit_var.set(prop.value)
+                        break
+            self.set_status(f"Edited {prop_name}")
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def _pick_donor_key_upk(self):
+        """Let the user select an encrypted UPK whose decryption key will be
+        used when 'Save Re-Encrypted UPK' is next invoked (while the checkbox
+        is ticked).  The key is resolved from keys.txt at save time, not here,
+        so any recently-updated keys.txt is automatically picked up."""
+        path = filedialog.askopenfilename(
+            title="Select donor encrypted UPK (to source the encryption key)",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=str(self.script_dir),
+        )
+        if not path:
+            return
+        self.donor_key_upk_path = Path(path)
+        self.donor_key_path_var.set(self.donor_key_upk_path.name)
+        # Auto-enable the checkbox when the user picks a file.
+        self.use_donor_key_var.set(True)
+        self.set_status(f"Donor key UPK set: {self.donor_key_upk_path.name}")
+
+    def save_reencrypted_upk(self):
+        source_path = self.current_encrypted_input_path or self.selected_input_path
+        if not self.package or not source_path or not self.current_provider:
+            messagebox.showwarning("UPK GUI", "Load an encrypted package first.")
+            return
+
+        # ── Resolve override key from donor UPK if requested ─────────────────
+        override_key: Optional[bytes] = None
+        if self.use_donor_key_var and self.use_donor_key_var.get():
+            donor_path = self.donor_key_upk_path
+            if not donor_path or not donor_path.exists():
+                messagebox.showwarning(
+                    "UPK GUI",
+                    "The 'Encrypt with key from another UPK' option is enabled but no valid "
+                    "donor UPK has been selected.\n\n"
+                    "Click 'Pick Donor UPK…' to choose one, or uncheck the option to use "
+                    "the original package's own key.",
+                )
+                return
+            # Build a provider from the same keys.txt so we can try all known keys.
+            keys_path = self.current_keys_path
+            try:
+                donor_provider = DecryptionProvider(str(keys_path) if keys_path and keys_path.exists() else None)
+            except Exception as exc:
+                messagebox.showerror("UPK GUI", f"Could not load keys.txt for donor key search:\n{exc}")
+                return
+            try:
+                self.set_status(f"Finding key for donor UPK: {donor_path.name}…")
+                override_key = find_key_for_encrypted_upk(donor_path, donor_provider)
+                import base64 as _b64
+                self.set_status(f"Donor key found ({_b64.b64encode(override_key).decode()[:16]}…), saving…")
+            except Exception as exc:
+                messagebox.showerror(
+                    "UPK GUI",
+                    f"Could not find a working decryption key for the donor UPK:\n{donor_path.name}\n\n{exc}\n\n"
+                    "Make sure keys.txt contains a key that can decrypt the selected donor package.",
+                )
+                return
+
+        default_name = f"{source_path.stem}_edited{source_path.suffix}"
+        initial_dir = str(self.script_dir / "ReEncrypted")
+        out_path = filedialog.asksaveasfilename(
+            title="Save re-encrypted UPK",
+            defaultextension=".upk",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=initial_dir,
+            initialfile=default_name,
+        )
+        if not out_path:
+            return
+        try:
+            saved = build_reencrypted_package(
+                source_path,
+                bytes(self.package.file_bytes),
+                self.current_provider,
+                Path(out_path),
+                override_key=override_key,
+            )
+            new_sha1 = sha1_file(saved)
+            patch_note = "RocketLeague.exe patch skipped (file not found)."
+            exe_path = self.script_dir / "RocketLeague.exe"
+            if self.current_original_sha1 and exe_path.exists():
+                replaced = patch_sha1_in_exe(exe_path, self.current_original_sha1, new_sha1)
+                patch_note = f"Patched {exe_path.name}: {replaced} occurrence(s)."
+            elif self.current_original_sha1 and not exe_path.exists():
+                patch_note = f"RocketLeague.exe patch skipped ({exe_path.name} not found)."
+            key_note = ""
+            if override_key is not None:
+                import base64 as _b64
+                key_note = f"\nEncryption key sourced from: {self.donor_key_upk_path.name}\n(key prefix: {_b64.b64encode(override_key).decode()[:16]}…)"
+            self.set_status(f"Saved {saved.name}")
+            prompt = f"Saved re-encrypted UPK:\n{saved}\n\nSHA-1: {new_sha1}\n{patch_note}{key_note}\n\nOpen it now?"
+            if messagebox.askyesno("UPK GUI", prompt):
+                self._load_selected_file(saved)
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def import_donor_names(self):
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        donor_path = filedialog.askopenfilename(
+            title="Select donor UPK",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=str(self.script_dir),
+        )
+        if not donor_path:
+            return
+        try:
+            donor_input = Path(donor_path)
+            _donor_decrypted, donor_package, _donor_provider, _donor_keys, _donor_was_encrypted = resolve_input_package(donor_input, self.decrypted_dir, self.script_dir)
+            name_to_import = simpledialog.askstring("Import Donor Names", "Name to import from donor package (leave blank for all donor names):", parent=self.root)
+            selected = [name_to_import.strip()] if name_to_import and name_to_import.strip() else None
+            merged = import_donor_names(self.package, donor_package, selected)
+            self.package = merged
+            self._apply_loaded_package(self.selected_input_path or self.package.file_path, self.current_original_sha1 or "-", self.current_keys_path or Path("keys.txt"), self.package.file_path, merged, self.current_provider)
+            added_names = getattr(merged, '_merge_added_names', 0)
+            self.set_status(f"Imported donor names: +{added_names} names")
+            messagebox.showinfo("UPK GUI", f"Imported donor names: +{added_names}")
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def import_donor_exports(self):
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        donor_path = filedialog.askopenfilename(
+            title="Select donor UPK",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=str(self.script_dir),
+        )
+        if not donor_path:
+            return
+        try:
+            donor_input = Path(donor_path)
+            donor_decrypted, donor_package, _donor_provider, _donor_keys, donor_was_encrypted = resolve_input_package(donor_input, self.decrypted_dir, self.script_dir)
+            # Use the original (encrypted) input filename as the donor package
+            # name, not the decrypted working copy's stem - the game looks up
+            # the file by its deployed name in the cooked content folder.
+            donor_pkg_name = donor_input.stem
+            merged = merge_donor_exports_as_imports(self.package, donor_package, donor_pkg_name)
+            self.package = merged
+            self._apply_loaded_package(self.selected_input_path or self.package.file_path, self.current_original_sha1 or "-", self.current_keys_path or Path("keys.txt"), self.package.file_path, merged, self.current_provider)
+            added_imports = getattr(merged, '_merge_added_imports', 0)
+            added_names = getattr(merged, '_merge_added_names', 0)
+            resolved_name = getattr(merged, '_merge_donor_package_name', donor_pkg_name)
+            self.set_status(f"Imported donor exports as '{resolved_name}': +{added_imports} imports, +{added_names} names")
+            messagebox.showinfo(
+                "UPK GUI",
+                f"Imported exports from {donor_input.name}\n\n"
+                f"Donor package name (used in import paths): {resolved_name}\n"
+                f"Added imports: {added_imports}\n"
+                f"Added names: {added_names}\n\n"
+                "All donor exports have been re-imported under a Core.Package "
+                f"\"{resolved_name}\" import, so the engine will attempt to load "
+                f"{resolved_name}.upk when this package is loaded.\n\n"
+                "IMPORTANT: For the references to actually resolve at runtime, "
+                f"deploy {donor_input.name} into the same cooked content folder "
+                "where the game looks for .upk files (typically alongside the "
+                "other Rocket League .upk files in CookedPCConsole). If the "
+                "donor file isn't on disk where the engine can find it, the "
+                "imports will fail to resolve and dependent objects will be "
+                "missing at load time.\n\n"
+                "You can now use the new imported object paths in ObjectProperty "
+                "edits and the new imported names in NameProperty edits.",
+            )
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def replace_export_from_donor(self):
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        if not self.current_export:
+            messagebox.showwarning("UPK GUI", "Select the target export first.")
+            return
+        donor_path = filedialog.askopenfilename(
+            title="Select donor UPK",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=str(self.script_dir),
+        )
+        if not donor_path:
+            return
+        try:
+            donor_input = Path(donor_path)
+            _donor_decrypted, donor_package, _donor_provider, _donor_keys, _donor_was_encrypted = resolve_input_package(donor_input, self.decrypted_dir, self.script_dir)
+            target_path = self.package.resolve_object_path(self.current_export.table_index + 1)
+            donor_export_path = simpledialog.askstring(
+                "Replace Export From Donor",
+                "Donor export path:",
+                parent=self.root,
+            )
+            if not donor_export_path or not donor_export_path.strip():
+                return
+            replaced = replace_export_with_donor_export(self.package, donor_package, target_path, donor_export_path.strip())
+            self.package = replaced
+            self._apply_loaded_package(self.selected_input_path or self.package.file_path, self.current_original_sha1 or "-", self.current_keys_path or Path("keys.txt"), self.package.file_path, replaced, self.current_provider)
+            note = getattr(replaced, '_replace_note', '')
+            self.set_status(f"Replaced export from donor: {Path(donor_path).name}")
+            messagebox.showinfo(
+                "UPK GUI",
+                f"Replaced target export:\n{target_path}\n\nWith donor export:\n{donor_export_path.strip()}\n\n{note}",
+            )
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+
+    def rename_export_fname(self):
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        if not self.current_export:
+            messagebox.showwarning("UPK GUI", "Select the export you want to rename first.")
+            return
+        export_index = self.current_export.table_index
+        current_name = self.package.resolve_name(self.current_export.object_name)
+        new_name = simpledialog.askstring(
+            "Rename Export FName",
+            "New FName for this export.\n"
+            "- Use 'BaseName' or 'BaseName_<N>' (e.g. 'MyMesh_3').\n"
+            "- An existing name is reused; a new base name is appended to the name table.\n"
+            f"\nCurrent: {current_name}",
+            initialvalue=current_name,
+            parent=self.root,
+        )
+        if new_name is None:
+            return
+        new_name = new_name.strip()
+        if not new_name:
+            return
+        if new_name == current_name:
+            self.set_status("Rename skipped (name unchanged)")
+            return
+        try:
+            renamed = rename_export_fname(self.package, self.current_export, new_name)
+            self.package = renamed
+            self._apply_loaded_package(
+                self.selected_input_path or self.package.file_path,
+                self.current_original_sha1 or "-",
+                self.current_keys_path or Path("keys.txt"),
+                self.package.file_path,
+                renamed,
+                self.current_provider,
+            )
+            # Re-select the renamed export so the user can immediately see/save it.
+            if 0 <= export_index < len(self.package.exports):
+                self.current_export = self.package.exports[export_index]
+                self._show_export(self.current_export)
+                iid = f"export:{export_index}"
+                if self.exports_tree.exists(iid):
+                    self.exports_tree.selection_set(iid)
+                    self.exports_tree.focus(iid)
+                    self.exports_tree.see(iid)
+            added = getattr(renamed, '_rename_added_names', 0)
+            self.set_status(f"Renamed export[{export_index}] -> {new_name} (+{added} name)")
+            messagebox.showinfo(
+                "UPK GUI",
+                f"Renamed export[{export_index}]:\n  {current_name}\n  ->\n  {new_name}\n\n"
+                f"Names added to package: {added}\n\n"
+                "Use 'Save Decrypted UPK' (for plain packages) or 'Save Re-Encrypted UPK' "
+                "(for encrypted packages) to write the change to disk.",
+            )
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def rename_selected_name(self):
+        """Rewrite the text of the currently-selected name table entry.
+
+        Triggered from the Names tab edit row (button or <Return> in the
+        entry). Reads the new text from self.name_edit_var, calls the
+        rename_name_entry helper which rebuilds the package's header (names
+        blob + offsets + serial_offsets), and reloads the GUI from the
+        rebuilt bytes. The same name index is re-selected after reload so
+        the user can immediately verify the change.
+        """
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        selection = self.names_tree.selection()
+        if not selection:
+            messagebox.showwarning("UPK GUI", "Select a name in the Names list first.")
+            return
+        name_entry = self.current_name_map.get(selection[0])
+        if name_entry is None:
+            messagebox.showwarning("UPK GUI", "Could not resolve the selected name.")
+            return
+        new_text = self.name_edit_var.get().strip()
+        if not new_text:
+            messagebox.showwarning("UPK GUI", "New name text cannot be empty.")
+            return
+        if new_text == name_entry.name:
+            self.set_status("Rename skipped (name unchanged)")
+            return
+        target_index = name_entry.index
+        try:
+            renamed = rename_name_entry(self.package, target_index, new_text)
+            self.package = renamed
+            self._apply_loaded_package(
+                self.selected_input_path or self.package.file_path,
+                self.current_original_sha1 or "-",
+                self.current_keys_path or Path("keys.txt"),
+                self.package.file_path,
+                renamed,
+                self.current_provider,
+            )
+            # Re-select the renamed entry. _populate_names_tree rebuilt the
+            # tree from scratch, so the iid is regenerated but uses the same
+            # name:<index> pattern.
+            iid = f"name:{target_index}"
+            if self.names_tree.exists(iid):
+                self.names_tree.selection_set(iid)
+                self.names_tree.focus(iid)
+                self.names_tree.see(iid)
+            delta = getattr(renamed, '_name_size_delta', 0)
+            old_text = getattr(renamed, '_name_rename_old', name_entry.name)
+            sign = "+" if delta >= 0 else ""
+            self.set_status(
+                f"Renamed name[{target_index}]: {old_text!r} -> {new_text!r} "
+                f"({sign}{delta} bytes)"
+            )
+            messagebox.showinfo(
+                "UPK GUI",
+                f"Renamed name table entry [{target_index}]:\n"
+                f"  {old_text!r}\n"
+                f"  ->\n"
+                f"  {new_text!r}\n\n"
+                f"Names blob delta: {sign}{delta} bytes\n"
+                "Header offsets and export serial_offsets were rebuilt to "
+                "match the new size.\n\n"
+                "Use 'Save Decrypted UPK' (for plain packages) or "
+                "'Save Re-Encrypted UPK' (for encrypted packages) to write "
+                "the change to disk.",
+            )
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def set_dll_bind(self):
+        """Inject or change the DLLBind DLL name on the currently selected UClass export.
+
+        DLLBind causes the Unreal Engine to call LoadLibrary on the given DLL
+        name immediately when the class is loaded from the package.  This is
+        the standard injection point used by Rocket League mod frameworks such
+        as BakkesMod and CodeRed.
+
+        The DLL name is stored as an FString (DLLBindName) at the very end of
+        the UClass serial body.  This method locates that FString, replaces it
+        with the user-supplied value, and adjusts all relevant package offsets
+        so the result is a valid, save-able package.
+
+        Requirements:
+          • The selected export must be a class definition (class_index → Class).
+          • The DLL name must be pure ASCII (as required by the UE3 FString
+            encoding used for DLLBindName in cooked packages).
+          • No path separators — supply only the DLL filename, e.g. 'MyMod.dll'.
+        """
+        if not self.package or not self.current_export:
+            messagebox.showwarning("UPK GUI", "Select a UClass export first.")
+            return
+
+        if not is_uclass_export(self.package, self.current_export):
+            cls = self.package.export_class_name(self.current_export)
+            messagebox.showwarning(
+                "UPK GUI",
+                f"The selected export is a '{cls}', not a Class.\n\n"
+                "DLLBind can only be set on class definition exports "
+                "(exports whose class is 'Class' in the Exports tab).  "
+                "Select a UClass export and try again.",
+            )
+            return
+
+        raw = self.package.object_data(self.current_export)
+        if not raw:
+            messagebox.showerror("UPK GUI", "The selected UClass export has no serial data.")
+            return
+
+        dllbind_result = find_uclass_dllbind_fstring_offset(raw)
+        if dllbind_result is None:
+            messagebox.showerror(
+                "UPK GUI",
+                "Could not locate the DLLBindName field in this UClass export's serial data.\n\n"
+                "The export's binary layout may be non-standard or the serial data may be "
+                "truncated.  Check the Raw Data tab for the hex dump.",
+            )
+            return
+
+        fstring_offset, current_dll_name = dllbind_result
+
+        new_dll_name = simpledialog.askstring(
+            "Set DLLBind",
+            f"Enter the DLL filename to bind (ASCII only, no path separators).\n"
+            f"Example: CodeRed.dll\n\n"
+            f"Leave blank to remove an existing DLLBind.\n\n"
+            f"Current DLLBind: {repr(current_dll_name) if current_dll_name else '(none)'}\n"
+            f"FString at serial+0x{fstring_offset:X}",
+            initialvalue=current_dll_name,
+            parent=self.root,
+        )
+        if new_dll_name is None:
+            return  # user cancelled
+
+        new_dll_name = new_dll_name.strip()
+
+        if new_dll_name == current_dll_name:
+            self.set_status("DLLBind unchanged — no action taken.")
+            return
+
+        try:
+            export_index = self.current_export.table_index
+            export_name = self.package.resolve_name(self.current_export.object_name)
+            new_bytes = set_uclass_dllbind_name(self.package, self.current_export, new_dll_name)
+            self.package = parse_decrypted_package_bytes(self.package.file_path, new_bytes)
+            self.current_export = self.package.exports[export_index]
+            self._show_export(self.current_export)
+
+            if new_dll_name:
+                action_msg = f"Set DLLBind → '{new_dll_name}'"
+                detail_msg = (
+                    f"Export[{export_index}] '{export_name}' will now cause the engine "
+                    f"to load '{new_dll_name}' via LoadLibrary when this package is opened."
+                )
+            else:
+                action_msg = "Removed DLLBind"
+                detail_msg = f"DLLBind was cleared on Export[{export_index}] '{export_name}'."
+
+            self.set_status(action_msg)
+            messagebox.showinfo(
+                "UPK GUI",
+                f"{action_msg}\n\n"
+                f"{detail_msg}\n\n"
+                "Use 'Save Re-Encrypted UPK' (for encrypted RL packages) or "
+                "'Save Decrypted UPK' (for plain packages) to write the change to disk.",
+            )
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+    def save_decrypted_upk(self):
+        """Save the current (possibly edited) decrypted package bytes to a .upk file.
+
+        Use this when the loaded package is plain/decompressed (not encrypted).
+        For encrypted Rocket League packages, use Save Re-Encrypted UPK instead.
+        """
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        # Pick a sensible default location/name. If the original input was a
+        # plain UPK, write next to it; otherwise drop into the decrypted_dir.
+        source_path = self.selected_input_path or self.package.file_path
+        if self.current_provider is not None:
+            initial_dir = str(self.decrypted_dir)
+            default_name = f"{source_path.stem}_edited_decrypted.upk"
+        else:
+            initial_dir = str(source_path.parent)
+            default_name = f"{source_path.stem}_edited{source_path.suffix or '.upk'}"
+        out_path = filedialog.asksaveasfilename(
+            title="Save decrypted UPK",
+            defaultextension=".upk",
+            filetypes=[("UPK files", "*.upk"), ("All files", "*.*")],
+            initialdir=initial_dir,
+            initialfile=default_name,
+        )
+        if not out_path:
+            return
+        try:
+            out = Path(out_path)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_bytes(bytes(self.package.file_bytes))
+            self.set_status(f"Saved {out.name}")
+            note = ""
+            if self.current_provider is not None:
+                note = (
+                    "\n\nNote: this is a decrypted/plain copy. The Rocket League game "
+                    "loader expects the encrypted format - use 'Save Re-Encrypted UPK' "
+                    "to produce a file the game will load."
+                )
+            prompt = f"Saved decrypted UPK:\n{out}{note}\n\nOpen it now?"
+            if messagebox.askyesno("UPK GUI", prompt):
+                self._load_selected_file(out)
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", str(exc))
+
+
+    def verify_current_package(self):
+        """Run consistency checks on the loaded package and show a report dialog.
+
+        Useful when an edited package freezes or crashes the game on load -
+        the report will pinpoint which header invariant is violated. Read-only,
+        does not modify or save the package.
+        """
+        if not self.package:
+            messagebox.showwarning("UPK GUI", "Load a package first.")
+            return
+        try:
+            findings = verify_package(self.package)
+            report = format_verify_report(findings)
+        except Exception as exc:
+            messagebox.showerror("UPK GUI", f"Verification failed to run: {exc}")
+            return
+
+        # Show the report in a dedicated scrollable dialog so long reports
+        # don't get clipped by messagebox's fixed sizing.
+        dlg = tk.Toplevel(self.root)
+        dlg.title("Package Verification Report")
+        dlg.geometry("980x560")
+        dlg.transient(self.root)
+        text = tk.Text(dlg, wrap="word", bg="#111318", fg="#e8ecf4", insertbackground="#ffffff")
+        vsb = ttk.Scrollbar(dlg, orient="vertical", command=text.yview)
+        text.configure(yscrollcommand=vsb.set)
+        text.grid(row=0, column=0, sticky="nsew")
+        vsb.grid(row=0, column=1, sticky="ns")
+        dlg.rowconfigure(0, weight=1)
+        dlg.columnconfigure(0, weight=1)
+        text.insert("1.0", report)
+        text.tag_configure("error", foreground="#ff7676")
+        text.tag_configure("warn", foreground="#ffd166")
+        text.tag_configure("ok", foreground="#7be39a")
+        for line_idx, line in enumerate(report.split("\n"), start=1):
+            tag = None
+            if line.startswith("[ERROR]"):
+                tag = "error"
+            elif line.startswith("[WARN]"):
+                tag = "warn"
+            elif line.startswith("[OK]"):
+                tag = "ok"
+            if tag is not None:
+                text.tag_add(tag, f"{line_idx}.0", f"{line_idx}.end")
+        text.configure(state="disabled")
+
+        button_row = ttk.Frame(dlg)
+        button_row.grid(row=1, column=0, columnspan=2, sticky="ew", padx=8, pady=6)
+
+        def _copy():
+            self.root.clipboard_clear()
+            self.root.clipboard_append(report)
+            self.set_status("Verification report copied to clipboard")
+
+        ttk.Button(button_row, text="Copy to Clipboard", command=_copy).pack(side="left")
+        ttk.Button(button_row, text="Close", command=dlg.destroy).pack(side="right")
+
+        error_count = sum(1 for sev, _ in findings if sev == "ERROR")
+        if error_count:
+            self.set_status(f"Verification: {error_count} error(s) found")
+        else:
+            self.set_status("Verification: no errors found")
+
+
+    def _show_error(self, details: str):
+        self.set_status("Failed")
+        messagebox.showerror("UPK GUI", details)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.parse_args()
+    root = tk.Tk()
+    App(root)
+    root.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())