PyREUser3 0.5.0__tar.gz → 0.7.0__tar.gz

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.5.0
+Version: 0.7.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT
@@ -48,11 +48,17 @@ pip install pyreuser3
 - A reusable Python API through `REUser3Converter`.
 - CLI commands through `pyreuser3`.
 - A local `.user.3` export Web UI through `pyreuser3-web`.
+- Automatic separation of the USR outer layout from the embedded RSZ header family;
+  modern RSZ v4+ files preserve their original numeric version during repack.
 
 The published package intentionally does not include game resources, dumped game data, RE_RSZ templates,
 `il2cpp_dump.json`, or repository-specific helper scripts. You need to provide data files that match the target game and
 version.
 
+Verified H30/modern layouts support repacking. Experimental physical H28 and legacy
+RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
+until real fixtures provide byte-for-byte validation.
+
 ## Requirements
 
 - Python 3.9 or newer.

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/PyREUser3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.5.0
+Version: 0.7.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT
@@ -48,11 +48,17 @@ pip install pyreuser3
 - A reusable Python API through `REUser3Converter`.
 - CLI commands through `pyreuser3`.
 - A local `.user.3` export Web UI through `pyreuser3-web`.
+- Automatic separation of the USR outer layout from the embedded RSZ header family;
+  modern RSZ v4+ files preserve their original numeric version during repack.
 
 The published package intentionally does not include game resources, dumped game data, RE_RSZ templates,
 `il2cpp_dump.json`, or repository-specific helper scripts. You need to provide data files that match the target game and
 version.
 
+Verified H30/modern layouts support repacking. Experimental physical H28 and legacy
+RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
+until real fixtures provide byte-for-byte validation.
+
 ## Requirements
 
 - Python 3.9 or newer.

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/PyREUser3.egg-info/SOURCES.txt

@@ -15,8 +15,11 @@ pyreuser3/__main__.py
 pyreuser3/api.py
 pyreuser3/cli.py
 pyreuser3/core.py
+pyreuser3/enum_codec.py
 pyreuser3/rich_ui.py
 pyreuser3/schema.py
+pyreuser3/usr_container.py
+pyreuser3/usr_layouts.py
 pyreuser3/export/__init__.py
 pyreuser3/export/base.py
 pyreuser3/export/enums.py
@@ -40,4 +43,6 @@ pyreuser3/web/runners.py
 pyreuser3/web/server.py
 pyreuser3/web/settings.py
 tests/test_enum_binary.py
-tests/test_export_enums.py
+tests/test_enum_codec.py
+tests/test_export_enums.py
+tests/test_usr_container.py

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/README.md

@@ -55,11 +55,20 @@ pyreuser3 export \
   -p <il2cpp_dump.json>
 ```
 
-Pack JSON back to `.user.3`:
+Export full repack JSON, then pack it back to `.user.3`:
+
+```bash
+pyreuser3 export \
+  -i <input-user3-file-or-directory> \
+  -s <RE_RSZ-schema.json> \
+  -o <repack-json-output-directory> \
+  -p <il2cpp_dump.json> \
+  --json-format repack
+```
 
 ```bash
 pyreuser3 pack \
-  -j <input-json-file-or-directory> \
+  -j <input-repack-json-file-or-directory> \
   -s <RE_RSZ-schema.json> \
   -o <user3-output-directory> \
   -p <il2cpp_dump.json>
@@ -90,8 +99,14 @@ converter.export_file(
     "json/OtomonData.user.3.json",
 )
 
+# Packing only accepts the full repack document. Readable exports are read-only.
+converter.export_file(
+    "input/OtomonData.user.3",
+    "json/OtomonData.user.3.pack.json",
+    json_format="repack",
+)
 converter.pack_file(
-    "json/OtomonData.user.3.json",
+    "json/OtomonData.user.3.pack.json",
     "mod/OtomonData.user.3",
 )
 ```
@@ -110,7 +125,24 @@ repack_data = converter.user3_to_json(
 )
 ```
 
-Use `json_format="readable"` for the same shape produced by `export_file()`, or `json_format="repack"` for the full instance-table document accepted by `pack()`.
+Use `json_format="readable"` for the same shape produced by `export_file()`. This
+shape is read-only. Use `json_format="repack"` for the full document accepted by
+`pack()`; the packer rejects readable JSON.
+
+Enum fields are rendered as `[numeric] Name` labels using the enum's actual storage
+width. Scalar flag enums are rendered as arrays of labels. ``ace.Bitset`1<T>`` values are
+rendered as enum-index labels together with `_MaxElement` and `_WordCount`, so unknown
+bits and padded word arrays remain reversible. Repack exports use
+`re_user3_pack_v3`, which records the independently detected USR outer layout, RSZ
+header family, and numeric RSZ version while preserving resource and userdata
+dependency tables. Layout candidates and their read/repack capability status are
+declared in `pyreuser3/usr_layouts.py`; RSZ field definitions still come from the
+supplied REFramework-compatible schema. The verified modern header family accepts
+structurally valid RSZ v4+ files and preserves their original version instead of
+forcing MHWS version 16. Experimental physical H28 and legacy RSZ v3 candidates are
+read-only until real fixtures validate byte-for-byte repacking. V1 and v2 documents
+are recognized for diagnostics but must be re-exported as v3 before packing because
+they do not record the required layout metadata.
 
 For stable patch-and-repack workflows, use `patch_file()` or `parse_pack_file()`:
 

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/docs/PYPI.md

@@ -15,11 +15,17 @@ pip install pyreuser3
 - A reusable Python API through `REUser3Converter`.
 - CLI commands through `pyreuser3`.
 - A local `.user.3` export Web UI through `pyreuser3-web`.
+- Automatic separation of the USR outer layout from the embedded RSZ header family;
+  modern RSZ v4+ files preserve their original numeric version during repack.
 
 The published package intentionally does not include game resources, dumped game data, RE_RSZ templates,
 `il2cpp_dump.json`, or repository-specific helper scripts. You need to provide data files that match the target game and
 version.
 
+Verified H30/modern layouts support repacking. Experimental physical H28 and legacy
+RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
+until real fixtures provide byte-for-byte validation.
+
 ## Requirements
 
 - Python 3.9 or newer.

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/docs/README.zh-CN.md

@@ -56,11 +56,20 @@ pyreuser3 export \
   -p <il2cpp_dump.json>
 ```
 
-将 JSON 封回 `.user.3`：
+导出完整 repack JSON，然后封回 `.user.3`：
+
+```bash
+pyreuser3 export \
+  -i <输入的-user3-文件或目录> \
+  -s <RE_RSZ-schema.json> \
+  -o <repack-JSON-输出目录> \
+  -p <il2cpp_dump.json> \
+  --json-format repack
+```
 
 ```bash
 pyreuser3 pack \
-  -j <输入的-JSON-文件或目录> \
+  -j <输入的-repack-JSON-文件或目录> \
   -s <RE_RSZ-schema.json> \
   -o <user3-输出目录> \
   -p <il2cpp_dump.json>
@@ -118,8 +127,14 @@ converter.export_file(
     "json/OtomonData.user.3.json",
 )
 
+# 封包只接受完整 repack 文档；readable 导出仅供读取。
+converter.export_file(
+    "input/OtomonData.user.3",
+    "json/OtomonData.user.3.pack.json",
+    json_format="repack",
+)
 converter.pack_file(
-    "json/OtomonData.user.3.json",
+    "json/OtomonData.user.3.pack.json",
     "mod/OtomonData.user.3",
 )
 ```
@@ -138,7 +153,18 @@ repack_data = converter.user3_to_json(
 )
 ```
 
-使用 `json_format="readable"` 时返回与 `export_file()` 一致的可读导出结构；使用 `json_format="repack"` 时返回可传给 `pack()` 的完整实例表结构。
+使用 `json_format="readable"` 时返回与 `export_file()` 一致的只读导出结构；使用
+`json_format="repack"` 时返回可传给 `pack()` 的完整实例表结构。封回器会拒绝 readable JSON。
+
+枚举字段会按照真实底层存储宽度输出为 `[数值] 名称`。标量位标志枚举输出为标签数组；
+``ace.Bitset`1<T>`` 输出为枚举索引标签，并保留 `_MaxElement` 与 `_WordCount`，因此未知位和
+填充词也可以无损封回。新的 repack 文档格式为 `re_user3_pack_v3`，它会分别记录自动探测到的
+USR 外层布局、RSZ 头族和文件中的真实 RSZ 版本，并保留 resource 与 userdata 依赖表。布局
+候选及其读取/回封能力状态集中声明在 `pyreuser3/usr_layouts.py`，RSZ 字段定义仍来自传入的
+REFramework 兼容模板。已验证的现代头族接受通过完整结构校验的 RSZ v4+ 文件，并原样保留
+版本号，不再固定为 MHWS 的版本 16。实验性的物理 H28 与 legacy RSZ v3 候选暂时只读，获得
+真实样本并完成逐字节回封验证后才能启用 repack。v1 和 v2 文档仍可识别以便诊断，但由于缺少
+必要的布局元数据，封回前必须从源文件重新导出为 v3。
 
 批量处理目录：
 
@@ -153,6 +179,7 @@ converter = REUser3Converter(
 export_result = converter.export_directory(
     "D:/game/unpacked",
     "D:/game/json",
+    json_format="repack",
 )
 
 pack_result = converter.pack_directory(

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyREUser3"
-version = "0.5.0"
+version = "0.7.0"
 description = "Pure Python tools for converting RE Engine .user.3 files to and from JSON."
 readme = "docs/PYPI.md"
 requires-python = ">=3.9"

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/pyreuser3/__init__.py

@@ -9,7 +9,10 @@ from __future__ import annotations
 from importlib import import_module
 from typing import Any
 
+__version__ = "0.7.0"
+
 __all__ = [
+    "__version__",
     "BinaryReader",
     "ClassDef",
     "FieldDef",

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/pyreuser3/api.py

@@ -73,6 +73,7 @@ class REUser3Converter:
         user3_root: str | Path,
         output_root: str | Path,
         exclude_regexes: list[str] | None = None,
+        json_format: JsonFormat = "readable",
     ) -> dict[str, int]:
         """Export every selected .user.3 file under a directory or single-file root.
 
@@ -81,33 +82,42 @@ class REUser3Converter:
             output_root (str | Path): Directory where generated output is written.
             exclude_regexes (list[str] | None): Regular expressions used to skip matching
             relative paths.
+            json_format (JsonFormat): "readable" for read-only exports or "repack"
+            for documents accepted by pack().
 
         Returns:
             dict[str, int]: Counters describing total, successful, and failed items.
         """
-        exporter = self._new_exporter(user3_root, output_root, exclude_regexes)
+        exporter = self._new_exporter(
+            user3_root,
+            output_root,
+            exclude_regexes,
+            json_format=self._normalize_json_format(json_format),
+        )
         return exporter.run()
 
     def export_file(
         self,
         user3_path: str | Path,
         json_path: str | Path,
+        json_format: JsonFormat = "readable",
     ) -> Path:
         """Export one .user.3 file to the requested JSON path.
 
         Args:
             user3_path (str | Path): Path to the .user.3 file being parsed, exported, patched, or packed.
             json_path (str | Path): Path to the JSON document read from or written by this workflow.
+            json_format (JsonFormat): "readable" for a read-only tree or "repack"
+            for a document accepted by pack().
 
         Returns:
             Path: Concrete filesystem path returned after the read, write, or resolution step finishes.
         """
-        # Reuse parse_file so single-file and batch exports keep the same parsed JSON shape and metadata handling.
-        # Preserve the exported JSON structure so external scripts and hand-edited files
-        # remain compatible across workflows.
+        # Use the same in-memory format selector as parse_file/parse_pack_file so
+        # single-file and batch exports keep identical document shapes.
         tree = self.user3_to_json(
             user3_path,
-            json_format="readable",
+            json_format=json_format,
             round_floats=True,
         )
         target = Path(json_path)
@@ -343,6 +353,7 @@ class REUser3Converter:
         user3_root: str | Path,
         output_root: str | Path,
         exclude_regexes: list[str] | None,
+        json_format: str = "readable",
     ) -> User3Exporter:
         """Create an exporter with this facade's schema, enum metadata, and magic values.
 
@@ -351,6 +362,7 @@ class REUser3Converter:
             output_root (str | Path): Directory where generated output is written.
             exclude_regexes (list[str] | None): Regular expressions used to skip matching
             relative paths.
+            json_format (str): Export document shape requested by the caller.
 
         Returns:
             User3Exporter: Configured object or normalized value returned for the caller to use directly.
@@ -369,6 +381,7 @@ class REUser3Converter:
             il2cpp_dump_path=self.il2cpp_dump_path,
             user_magic=self.user_magic,
             rsz_magic=self.rsz_magic,
+            json_format=json_format,
         )
 
     def _new_packer(self, output_root: str | Path | None) -> User3Packer:

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/pyreuser3/cli.py

@@ -8,9 +8,9 @@ from __future__ import annotations
 
 import argparse
 import json
-from importlib.metadata import PackageNotFoundError, version
 from typing import Sequence
 
+from . import __version__
 from .core import RSZ_MAGIC, USR_MAGIC
 
 
@@ -33,10 +33,7 @@ def package_version() -> str:
     Returns:
         str: Normalized or formatted text.
     """
-    try:
-        return version("PyREUser3")
-    except PackageNotFoundError:
-        return "0.1.0"
+    return __version__
 
 
 def normalize_tree_depth(value: str) -> int | str:
@@ -143,6 +140,12 @@ def build_parser() -> argparse.ArgumentParser:
         required=True,
         help="Path to il2cpp_dump.json, used to generate enum labels.",
     )
+    export_parser.add_argument(
+        "--json-format",
+        choices=("readable", "repack"),
+        default="readable",
+        help="Export read-only readable JSON or packable repack JSON (default: readable).",
+    )
     add_magic_args(export_parser)
     export_parser.set_defaults(func=run_export)
 
@@ -154,7 +157,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--input-json",
         "-j",
         required=True,
-        help="JSON file or root directory that contains .user.3.json files.",
+        help="Repack JSON file or root directory that contains repack documents.",
     )
     pack_parser.add_argument(
         "--schema-path",
@@ -212,6 +215,7 @@ def run_export(args: argparse.Namespace) -> int:
         il2cpp_dump_path=args.il2cpp_dump_path,
         user_magic=args.user_magic,
         rsz_magic=args.rsz_magic,
+        json_format=args.json_format,
     )
     result = exporter.run()
     console.log("Export complete:", json.dumps(result, ensure_ascii=False))

{pyreuser3-0.5.0 → pyreuser3-0.7.0}/pyreuser3/core.py

@@ -20,7 +20,12 @@ USR_MAGIC = 5395285
 RSZ_MAGIC = 5919570
 # Preserve instance numbering and reference identity; RSZ object links depend on these
 # indexes remaining stable.
-PACK_JSON_FORMAT = "re_user3_pack_v1"
+PACK_JSON_FORMAT_V1 = "re_user3_pack_v1"
+PACK_JSON_FORMAT_V2 = "re_user3_pack_v2"
+PACK_JSON_FORMAT = "re_user3_pack_v3"
+PACK_JSON_FORMATS = frozenset(
+    {PACK_JSON_FORMAT_V1, PACK_JSON_FORMAT_V2, PACK_JSON_FORMAT}
+)
 # Decode strings and GUID-like values conservatively so invalid data does not corrupt
 # subsequent parsing.
 HEX32_RE = re.compile(r"^[0-9a-fA-F]{32}$")

pyreuser3-0.7.0/pyreuser3/enum_codec.py

@@ -0,0 +1,231 @@
+"""Shared enum, flag, and ``ace.Bitset`` conversion helpers.
+
+The exporter and packer deliberately share these operations so readable labels remain
+lossless across signed/unsigned storage widths and generic container wrappers.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+ENUM_LABEL_RE = re.compile(r"^\[(-?\d+)\]\s*(.*)$")
+_GENERIC_RE = re.compile(r"^[^<]+<(.+)>$")
+
+
+def normalize_integer_for_storage(value: int, storage_type: str | None) -> int:
+    """Normalize an integer according to an enum's declared storage width/sign."""
+    storage = storage_type or "S32"
+    widths = {
+        "S8": (8, True),
+        "U8": (8, False),
+        "S16": (16, True),
+        "U16": (16, False),
+        "S32": (32, True),
+        "U32": (32, False),
+        "S64": (64, True),
+        "U64": (64, False),
+    }
+    bits, signed = widths.get(storage, (32, True))
+    mask = (1 << bits) - 1
+    normalized = int(value) & mask
+    if signed and normalized >= 1 << (bits - 1):
+        normalized -= 1 << bits
+    return normalized
+
+
+def parse_enum_label(value: Any) -> int | None:
+    """Return the authoritative numeric prefix from ``[N] Name`` labels."""
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, int):
+        return value
+    if not isinstance(value, str):
+        return None
+    match = ENUM_LABEL_RE.match(value.strip())
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def enum_member_for_value(
+    enum_lookup: dict[str, dict[int, tuple[str, int]]],
+    enum_type: str,
+    value: int,
+    enum_underlying_types: dict[str, str] | None = None,
+) -> tuple[str, int] | None:
+    """Resolve a value without inventing 32-bit aliases for wider enum types."""
+    value_map = enum_lookup.get(enum_type)
+    if not value_map:
+        return None
+    storage = (enum_underlying_types or {}).get(enum_type, "S32")
+    target = normalize_integer_for_storage(value, storage)
+    direct = value_map.get(value)
+    if direct is not None and normalize_integer_for_storage(direct[1], storage) == target:
+        return direct
+    for member_name, raw_value in value_map.values():
+        if normalize_integer_for_storage(raw_value, storage) == target:
+            return member_name, raw_value
+    return None
+
+
+def generic_arguments(type_name: str) -> list[str]:
+    """Parse the simple, fully-qualified generic type names emitted by il2cpp dumps."""
+    if not isinstance(type_name, str):
+        return []
+    match = _GENERIC_RE.match(type_name)
+    if not match:
+        return []
+    # These metadata names are not assembly-qualified and current RE generic arguments
+    # are flat. Keeping this parser intentionally strict prevents ambiguous guesses.
+    return [part.strip() for part in match.group(1).split(",") if part.strip()]
+
+
+def bitset_enum_type(class_name: str) -> str | None:
+    """Return the generic enum argument for one ``ace.Bitset`1`` class."""
+    if not isinstance(class_name, str) or not class_name.startswith("ace.Bitset`1<"):
+        return None
+    args = generic_arguments(class_name)
+    return args[0] if len(args) == 1 else None
+
+
+def is_probable_flags_enum(
+    enum_type: str,
+    value_map: dict[int, tuple[str, int]],
+    storage_type: str | None = None,
+) -> bool:
+    """Conservatively identify bit-mask enums from their name and member values."""
+    upper = enum_type.upper()
+    markers = ("BIT", "BITS", "FLAG", "FLAGS", "MASK", "ATTR")
+    if not any(marker in upper for marker in markers):
+        return False
+    storage = storage_type or "S32"
+    width = int(storage[1:])
+    mask = (1 << width) - 1
+    values = {
+        normalize_integer_for_storage(raw, storage) & mask
+        for _name, raw in value_map.values()
+        if raw != 0
+    }
+    basis = {value for value in values if value and value & (value - 1) == 0}
+    if len(basis) < 2:
+        return False
+    known_mask = 0
+    for value in basis:
+        known_mask |= value
+    return all(value & ~known_mask == 0 for value in values)
+
+
+def decode_flags(
+    enum_lookup: dict[str, dict[int, tuple[str, int]]],
+    enum_type: str,
+    value: int,
+    enum_underlying_types: dict[str, str] | None = None,
+) -> list[str]:
+    """Expand a scalar mask to stable labels, preserving unknown bits explicitly."""
+    storage = (enum_underlying_types or {}).get(enum_type, "S32")
+    normalized = normalize_integer_for_storage(value, storage)
+    bits = normalized if normalized >= 0 else normalized & ((1 << int(storage[1:])) - 1)
+    value_map = enum_lookup.get(enum_type, {})
+    if bits == 0:
+        zero = enum_member_for_value(enum_lookup, enum_type, 0, enum_underlying_types)
+        return [f"[0] {zero[0]}"] if zero else []
+    labels: list[str] = []
+    remaining = bits
+    width_mask = (1 << int(storage[1:])) - 1
+    members: list[tuple[int, str, int]] = []
+    for name, raw in value_map.values():
+        normalized_raw = normalize_integer_for_storage(raw, storage)
+        mask_value = normalized_raw & width_mask
+        if mask_value and mask_value & (mask_value - 1) == 0:
+            members.append((mask_value, name, raw))
+    for mask_value, name, raw in sorted(members):
+        if remaining & mask_value:
+            labels.append(f"[{raw}] {name}")
+            remaining &= ~mask_value
+    bit_index = 0
+    while remaining:
+        if remaining & 1:
+            unknown_value = 1 << bit_index
+            labels.append(f"[{unknown_value}] <unknown>")
+        remaining >>= 1
+        bit_index += 1
+    return labels
+
+
+def decode_bitset(
+    words: list[int],
+    enum_type: str,
+    enum_lookup: dict[str, dict[int, tuple[str, int]]],
+    max_element: int | None = None,
+    enum_underlying_types: dict[str, str] | None = None,
+) -> list[str]:
+    """Decode 32-bit words into enum-index labels."""
+    labels: list[str] = []
+    for word_index, raw_word in enumerate(words):
+        word = int(raw_word) & 0xFFFFFFFF
+        for bit in range(32):
+            index = word_index * 32 + bit
+            if not (word & (1 << bit)):
+                continue
+            member = enum_member_for_value(
+                enum_lookup, enum_type, index, enum_underlying_types
+            )
+            labels.append(f"[{index}] {member[0] if member else '<unknown>'}")
+    return labels
+
+
+def encode_bitset(
+    labels: list[Any],
+    enum_type: str,
+    member_lookup: dict[str, dict[str, int]],
+    max_element: int | None = None,
+    word_count: int | None = None,
+) -> list[int]:
+    """Encode enum-index labels into 32-bit words, preserving requested padding."""
+    indexes: list[int] = []
+    members = member_lookup.get(enum_type, {})
+    for item in labels:
+        index = parse_enum_label(item)
+        if index is None and isinstance(item, str):
+            index = members.get(item.strip())
+        if index is None or index < 0:
+            raise ValueError(f"invalid {enum_type} bitset member: {item!r}")
+        if (
+            max_element is not None
+            and index >= max_element
+            and (word_count is None or index >= word_count * 32)
+        ):
+            raise ValueError(
+                f"bitset index {index} exceeds _MaxElement {max_element} for {enum_type}"
+            )
+        indexes.append(index)
+    selected_minimum = (max(indexes) + 32) // 32 if indexes else 0
+    derived_count = max(
+        selected_minimum,
+        (max_element + 31) // 32 if max_element else 0,
+    )
+    count = derived_count if word_count is None else word_count
+    if count < selected_minimum:
+        raise ValueError(f"_WordCount {count} is too small for {enum_type} bitset")
+    words = [0] * count
+    for index in indexes:
+        words[index // 32] |= 1 << (index % 32)
+    return words
+
+
+def encode_flags(
+    values: list[Any], enum_type: str, member_lookup: dict[str, dict[str, int]]
+) -> int:
+    """Combine readable scalar flag labels back into one integer mask."""
+    result = 0
+    members = member_lookup.get(enum_type, {})
+    for item in values:
+        numeric = parse_enum_label(item)
+        if numeric is None and isinstance(item, str):
+            numeric = members.get(item.strip())
+        if numeric is None:
+            raise ValueError(f"invalid {enum_type} flag member: {item!r}")
+        result |= numeric
+    return result