PyREUser3 0.7.2__tar.gz → 0.8.0__tar.gz

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.7.2
+Version: 0.8.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/PyREUser3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.7.2
+Version: 0.8.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/README.md

@@ -169,8 +169,10 @@ Use `json_format="readable"` for the same shape produced by `export_file()`. Thi
 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
+Readable enum fields are rendered as `[numeric] Name` labels using the enum's actual
+storage width and signedness, so signed Fixed IDs match their in-game runtime values.
+Repack documents retain canonical unsigned Fixed prefixes for stable machine editing.
+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

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyREUser3"
-version = "0.7.2"
+version = "0.8.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.7.2 → pyreuser3-0.8.0}/pyreuser3/__init__.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from importlib import import_module
 from typing import Any
 
-__version__ = "0.7.2"
+__version__ = "0.8.0"
 
 __all__ = [
     "__version__",

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/pyreuser3/export/enums.py

@@ -18,6 +18,9 @@ from ..core import ENUM_UNUSED_KEY, normalize_enum_storage_type
 _FIXED_ENUM_RE = re.compile(r"[A-Za-z0-9_.+]+_Fixed")
 _PROPERTY_METHOD_RE = re.compile(r"^(?:get|set)_(?P<name>.+?)(?:\d+)?$")
 _BACKING_FIELD_RE = re.compile(r"^<(?P<name>[^>]+)>")
+_INTEGER_STORAGE_TYPES = frozenset(
+    {"S8", "U8", "S16", "U16", "S32", "U32", "S64", "U64"}
+)
 
 
 class ExporterEnumSourceMixin:
@@ -104,6 +107,39 @@ class ExporterEnumSourceMixin:
         for candidate in cls._field_name_variants(field_name):
             field_map.setdefault(candidate, fixed_type)
 
+    @classmethod
+    def _add_fixed_backing_candidate(
+        cls,
+        candidates: dict[str, set[str]],
+        field_name: Any,
+        type_name: Any,
+    ) -> None:
+        """Record an integer ``*_Fixed`` backing field by its runtime property name."""
+        if not isinstance(field_name, str):
+            return
+        storage_type = normalize_enum_storage_type(type_name)
+        if storage_type not in _INTEGER_STORAGE_TYPES:
+            return
+        for field_variant in cls._field_name_variants(field_name):
+            normalized_name = field_variant.lstrip("_")
+            if not normalized_name.endswith("_Fixed"):
+                continue
+            property_name = normalized_name[: -len("_Fixed")]
+            if property_name:
+                candidates.setdefault(property_name, set()).add(field_variant)
+            candidates.setdefault(normalized_name, set()).add(field_variant)
+
+    @staticmethod
+    def _method_return_type(method: Any) -> str | None:
+        """Return one concrete method return type when metadata exposes it."""
+        if not isinstance(method, dict):
+            return None
+        returns = method.get("returns")
+        if not isinstance(returns, dict):
+            return None
+        return_type = returns.get("type")
+        return return_type if isinstance(return_type, str) and return_type else None
+
     @staticmethod
     def _method_matches_property(method_name: str, getter_or_setter: str) -> bool:
         """Return whether an il2cpp method key represents the named property accessor."""
@@ -264,6 +300,7 @@ class ExporterEnumSourceMixin:
             "enum_underlying_types": {},
             "enum_types": set(),
             "serializable_fallback_candidates": [],
+            "fixed_backing_candidates": [],
         }
 
     @classmethod
@@ -282,6 +319,7 @@ class ExporterEnumSourceMixin:
                 state["enum_underlying_types"][class_name] = storage_type
 
         field_map: dict[str, str] = {}
+        fixed_backing_fields: dict[str, set[str]] = {}
         fields_obj = obj.get("fields")
         if isinstance(fields_obj, dict):
             for field_name, field_info in fields_obj.items():
@@ -290,6 +328,9 @@ class ExporterEnumSourceMixin:
                 cls._add_field_fixed_type(
                     field_map, field_name, field_info.get("type")
                 )
+                cls._add_fixed_backing_candidate(
+                    fixed_backing_fields, field_name, field_info.get("type")
+                )
 
         # Older dumps expose RE_RSZ field hints through an explicit RSZ array.
         rsz_fields = obj.get("RSZ")
@@ -303,6 +344,9 @@ class ExporterEnumSourceMixin:
                 cls._add_field_fixed_type(
                     field_map, potential_name, rsz_field.get("type")
                 )
+                cls._add_fixed_backing_candidate(
+                    fixed_backing_fields, potential_name, rsz_field.get("type")
+                )
 
         # Newer dumps can omit RSZ entirely but keep property/type hints here.
         reflection_props = obj.get("reflection_properties")
@@ -311,8 +355,12 @@ class ExporterEnumSourceMixin:
                 if not isinstance(prop_name, str) or not isinstance(prop_info, dict):
                     continue
                 cls._add_field_fixed_type(field_map, prop_name, prop_info.get("type"))
+                cls._add_fixed_backing_candidate(
+                    fixed_backing_fields, prop_name, prop_info.get("type")
+                )
 
         methods_obj = obj.get("methods")
+        runtime_property_types: dict[str, set[str]] = {}
         if isinstance(methods_obj, dict):
             properties_obj = obj.get("properties")
             if isinstance(properties_obj, dict):
@@ -326,6 +374,11 @@ class ExporterEnumSourceMixin:
                                 continue
                             if not cls._method_matches_property(method_name, getter):
                                 continue
+                            return_type = cls._method_return_type(method)
+                            if return_type is not None:
+                                runtime_property_types.setdefault(
+                                    prop_name, set()
+                                ).add(return_type)
                             fixed_type = cls._fixed_type_from_method_return(method)
                             if fixed_type is not None:
                                 cls._add_field_fixed_type(
@@ -350,6 +403,12 @@ class ExporterEnumSourceMixin:
                 method_prop_name = cls._property_name_from_method(method_name)
                 if method_prop_name is None:
                     continue
+                if method_name.startswith("get_"):
+                    return_type = cls._method_return_type(method)
+                    if return_type is not None:
+                        runtime_property_types.setdefault(
+                            method_prop_name, set()
+                        ).add(return_type)
                 fixed_type = None
                 if method_name.startswith("get_"):
                     fixed_type = cls._fixed_type_from_method_return(method)
@@ -358,6 +417,18 @@ class ExporterEnumSourceMixin:
                 if fixed_type is not None:
                     cls._add_field_fixed_type(field_map, method_prop_name, fixed_type)
 
+        for property_name, field_names in fixed_backing_fields.items():
+            runtime_types = runtime_property_types.get(property_name, set())
+            if len(runtime_types) != 1:
+                continue
+            state["fixed_backing_candidates"].append(
+                (
+                    class_name,
+                    tuple(sorted(field_names)),
+                    next(iter(runtime_types)),
+                )
+            )
+
         if field_map:
             state["class_field_fixed_types"][class_name] = field_map
 
@@ -411,6 +482,20 @@ class ExporterEnumSourceMixin:
             if len(fallback_types) == 1:
                 serializable_to_fixed[class_name] = fallback_types[0]
 
+        for class_name, field_names, runtime_type in state[
+            "fixed_backing_candidates"
+        ]:
+            fixed_type = (
+                runtime_type
+                if runtime_type.endswith("_Fixed")
+                else f"{runtime_type}_Fixed"
+            )
+            if fixed_type not in enum_types:
+                continue
+            field_map = state["class_field_fixed_types"].setdefault(class_name, {})
+            for field_name in field_names:
+                field_map.setdefault(field_name, fixed_type)
+
         for class_name, raw_types in state["generic_candidates"].items():
             enum_args = list(dict.fromkeys(t for t in raw_types if t in enum_types))
             param_args = list(dict.fromkeys(t for t in raw_types if t not in enum_types))

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/pyreuser3/export/postprocess.py

@@ -13,6 +13,7 @@ from ..enum_codec import (
     decode_bitset,
     decode_flags,
     enum_member_for_value,
+    normalize_integer_for_storage,
 )
 
 
@@ -68,7 +69,13 @@ class ExporterPostprocessMixin:
                 return candidate
         return type_name
 
-    def _format_enum_value(self, fixed_enum_type: str, value: int) -> Any:
+    def _format_enum_value(
+        self,
+        fixed_enum_type: str,
+        value: int,
+        *,
+        runtime_signedness: bool = True,
+    ) -> Any:
         """Format enum value.
 
         Exact declared members stay intact; flagged enums are decomposed only when the
@@ -97,7 +104,14 @@ class ExporterPostprocessMixin:
         )
         if matched is not None:
             member_name, fixed_value = matched
-            return self._id_formatter(member_name, fixed_value)
+            return self._id_formatter(
+                member_name,
+                self._normalize_enum_display_value(
+                    fixed_enum_type,
+                    fixed_value,
+                    runtime_signedness=runtime_signedness,
+                ),
+            )
         if fixed_enum_type in getattr(self, "enum_flags", set()):
             return decode_flags(
                 self.enum_lookup,
@@ -105,7 +119,37 @@ class ExporterPostprocessMixin:
                 value,
                 getattr(self, "enum_underlying_types", {}),
             )
-        return value
+        if not fixed_enum_type.endswith("_Fixed"):
+            return value
+        return self._id_formatter(
+            "<unknown>",
+            self._normalize_enum_display_value(
+                fixed_enum_type,
+                value,
+                runtime_signedness=runtime_signedness,
+            ),
+        )
+
+    def _normalize_enum_display_value(
+        self,
+        enum_type: str,
+        value: int,
+        *,
+        runtime_signedness: bool,
+    ) -> int:
+        """Normalize IDs to the integer domain exposed by the runtime enum."""
+        storage_type = getattr(self, "enum_underlying_types", {}).get(enum_type)
+        if (
+            not runtime_signedness
+            and enum_type.endswith("_Fixed")
+            and storage_type in {"S8", "S16", "S32", "S64"}
+        ):
+            storage_type = f"U{storage_type[1:]}"
+        return (
+            normalize_integer_for_storage(value, storage_type)
+            if storage_type is not None
+            else value
+        )
 
     @staticmethod
     def _looks_like_class_name(text: str) -> bool:
@@ -427,7 +471,11 @@ class ExporterPostprocessMixin:
         if isinstance(value, int) and scalar_enum_hint is not None:
             # Register enum values through the shared lookup tables so readable labels
             # and numeric packing stay reversible.
-            return self._format_enum_value(scalar_enum_hint, value)
+            return self._format_enum_value(
+                scalar_enum_hint,
+                value,
+                runtime_signedness=output_mode != "repack",
+            )
         return value
 
     def _finalize_export_tree(self, value: Any) -> Any:

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/pyreuser3/pack/writer.py

@@ -20,7 +20,7 @@ from .models import (
     StructValue,
 )
 from ..core import align, enum_storage_size, enum_storage_type_from_size
-from ..enum_codec import ENUM_LABEL_RE
+from ..enum_codec import ENUM_LABEL_RE, normalize_integer_for_storage
 from ..schema import FieldDef
 
 class PackerWriterMixin:
@@ -437,19 +437,28 @@ class PackerWriterMixin:
             writer.write_struct("<B", 1 if bool(value) else 0)
             return
         if t == "S8":
-            writer.write_struct("<b", self._coerce_int(value, field_def))
+            writer.write_struct(
+                "<b",
+                self._coerce_signed_storage(value, field_def, "S8"),
+            )
             return
         if t == "U8":
             writer.write_struct("<B", self._coerce_int(value, field_def) & 0xFF)
             return
         if t == "S16":
-            writer.write_struct("<h", self._coerce_int(value, field_def))
+            writer.write_struct(
+                "<h",
+                self._coerce_signed_storage(value, field_def, "S16"),
+            )
             return
         if t == "U16":
             writer.write_struct("<H", self._coerce_int(value, field_def) & 0xFFFF)
             return
         if t in {"S32", "Sfix"}:
-            writer.write_struct("<i", self._to_s32(self._coerce_int(value, field_def)))
+            writer.write_struct(
+                "<i",
+                self._coerce_signed_storage(value, field_def, "S32"),
+            )
             return
         if t == "Enum":
             self._write_enum_value(writer, field_def, value)
@@ -458,7 +467,10 @@ class PackerWriterMixin:
             writer.write_struct("<I", self._coerce_int(value, field_def) & 0xFFFFFFFF)
             return
         if t == "S64":
-            writer.write_struct("<q", self._coerce_int(value, field_def))
+            writer.write_struct(
+                "<q",
+                self._coerce_signed_storage(value, field_def, "S64"),
+            )
             return
         if t == "U64":
             writer.write_struct(
@@ -617,6 +629,21 @@ class PackerWriterMixin:
             # remain binary-compatible.
             writer.write(b"\x00" * (value.declared_size - consumed))
 
+    def _coerce_signed_storage(
+        self, value: Any, field_def: FieldDef, storage_type: str
+    ) -> int:
+        """Accept a signed runtime value or its canonical unsigned bit pattern."""
+        number = self._coerce_int(value, field_def)
+        bits = int(storage_type[1:])
+        signed_minimum = -(1 << (bits - 1))
+        unsigned_maximum = (1 << bits) - 1
+        if number < signed_minimum or number > unsigned_maximum:
+            raise PackError(
+                f"value {number} is outside the signed or canonical unsigned "
+                f"{storage_type} range for field {field_def.name}"
+            )
+        return normalize_integer_for_storage(number, storage_type)
+
     def _coerce_int(self, value: Any, field_def: FieldDef) -> int:
         """Coerce int.
 

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/tests/test_enum_binary.py

@@ -139,6 +139,84 @@ class EnumBinaryTests(unittest.TestCase):
 
         self.assertEqual(bytes(writer.data), b"\x02\x00\x00\x00")
 
+    def test_erased_fixed_field_accepts_unsigned_numeric_label(self):
+        writer_mixin = EnumFieldWriter()
+        writer = BinaryWriter()
+        field = FieldDef(
+            name="_StageID_Fixed",
+            field_type="S32",
+            original_type="System.Int32",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        writer_mixin._write_scalar(writer, field, "[3068809728] ST101")
+
+        self.assertEqual(bytes(writer.data), bytes.fromhex("00 52 ea b6"))
+
+    def test_erased_fixed_field_accepts_signed_runtime_label(self):
+        writer_mixin = EnumFieldWriter()
+        writer = BinaryWriter()
+        field = FieldDef(
+            name="_StageID_Fixed",
+            field_type="S32",
+            original_type="System.Int32",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        writer_mixin._write_scalar(writer, field, "[-1226157568] ST101")
+
+        self.assertEqual(bytes(writer.data), bytes.fromhex("00 52 ea b6"))
+
+    def test_erased_fixed_fields_accept_runtime_and_canonical_signed_widths(self):
+        writer_mixin = EnumFieldWriter()
+        cases = (
+            ("S8", "System.SByte", 1, "[255] MinusOne"),
+            ("S16", "System.Int16", 2, "[65535] MinusOne"),
+            ("S32", "System.Int32", 4, "[4294967295] MinusOne"),
+            (
+                "S64",
+                "System.Int64",
+                8,
+                "[18446744073709551615] MinusOne",
+            ),
+        )
+
+        for field_type, original_type, size, unsigned_label in cases:
+            with self.subTest(field_type=field_type):
+                field = FieldDef(
+                    name="_Value_Fixed",
+                    field_type=field_type,
+                    original_type=original_type,
+                    size=size,
+                    align=size,
+                    is_array=False,
+                )
+
+                for label in ("[-1] MinusOne", unsigned_label):
+                    writer = BinaryWriter()
+
+                    writer_mixin._write_scalar(writer, field, label)
+
+                    self.assertEqual(bytes(writer.data), b"\xff" * size)
+
+    def test_signed_field_rejects_values_outside_both_numeric_domains(self):
+        writer_mixin = EnumFieldWriter()
+        field = FieldDef(
+            name="_Value_Fixed",
+            field_type="S8",
+            original_type="System.SByte",
+            size=1,
+            align=1,
+            is_array=False,
+        )
+
+        with self.assertRaisesRegex(PackError, "outside .* S8 range"):
+            writer_mixin._write_scalar(BinaryWriter(), field, "[256] Invalid")
+
     def test_runtime_type_reader_uses_c8_string_layout(self):
         parser = EnumFieldParser()
         reader = BinaryReader(b"\x04\x00\x00\x00abc\x00tail")

{pyreuser3-0.7.2 → pyreuser3-0.8.0}/tests/test_export_enums.py

@@ -54,6 +54,104 @@ class ExporterEnumSourceMixinTests(unittest.TestCase):
             {"v2_Interpolation": "[1] SmoothStep"},
         )
 
+        self.assertEqual(
+            postprocessor._postprocess_enum_nodes(
+                {"v2_Interpolation": 99},
+                current_class="via.ColorRampKey",
+            ),
+            {"v2_Interpolation": 99},
+        )
+
+    def test_postprocess_respects_unsigned_fixed_storage(self):
+        postprocessor = EnumPostprocessor()
+        fixed_type = "app.FieldDef.STAGE_Fixed"
+        postprocessor.enum_lookup[fixed_type] = {
+            3068809728: ("ST101", 3068809728),
+        }
+        postprocessor.enum_underlying_types[fixed_type] = "U32"
+        postprocessor.class_field_fixed_types = {
+            "app.user_data.GrassCullingSetting.cStageData": {
+                "_StageID_Fixed": fixed_type,
+            }
+        }
+
+        self.assertEqual(
+            postprocessor._postprocess_enum_nodes(
+                {"_StageID_Fixed": -1226157568},
+                current_class="app.user_data.GrassCullingSetting.cStageData",
+            ),
+            {"_StageID_Fixed": "[3068809728] ST101"},
+        )
+
+    def test_postprocess_displays_signed_runtime_fixed_id(self):
+        postprocessor = EnumPostprocessor()
+        fixed_type = "app.FieldDef.STAGE_Fixed"
+        postprocessor.enum_lookup[fixed_type] = {
+            3068809728: ("ST101", 3068809728),
+        }
+        postprocessor.enum_underlying_types[fixed_type] = "S32"
+        postprocessor.class_field_fixed_types = {
+            "app.user_data.GrassCullingSetting.cStageData": {
+                "_StageID_Fixed": fixed_type,
+            }
+        }
+
+        self.assertEqual(
+            postprocessor._postprocess_enum_nodes(
+                {"_StageID_Fixed": -1226157568},
+                current_class="app.user_data.GrassCullingSetting.cStageData",
+            ),
+            {"_StageID_Fixed": "[-1226157568] ST101"},
+        )
+
+    def test_repack_keeps_canonical_unsigned_fixed_id(self):
+        postprocessor = EnumPostprocessor()
+        fixed_type = "app.FieldDef.STAGE_Fixed"
+        postprocessor.enum_lookup[fixed_type] = {
+            3068809728: ("ST101", 3068809728),
+        }
+        postprocessor.enum_underlying_types[fixed_type] = "S32"
+        postprocessor.class_field_fixed_types = {
+            "app.user_data.GrassCullingSetting.cStageData": {
+                "_StageID_Fixed": fixed_type,
+            }
+        }
+
+        self.assertEqual(
+            postprocessor._postprocess_enum_nodes(
+                {"_StageID_Fixed": -1226157568},
+                current_class="app.user_data.GrassCullingSetting.cStageData",
+                output_mode="repack",
+            ),
+            {"_StageID_Fixed": "[3068809728] ST101"},
+        )
+
+    def test_unsigned_fixed_type_keeps_unknown_value_as_structured_label(self):
+        postprocessor = EnumPostprocessor()
+        fixed_type = "app.FieldDef.STAGE_Fixed"
+        postprocessor.enum_lookup[fixed_type] = {
+            3068809728: ("ST101", 3068809728),
+        }
+        postprocessor.enum_underlying_types[fixed_type] = "U32"
+
+        self.assertEqual(
+            postprocessor._format_enum_value(fixed_type, -1),
+            "[4294967295] <unknown>",
+        )
+
+    def test_signed_fixed_enum_unknown_value_uses_runtime_fixed_id(self):
+        postprocessor = EnumPostprocessor()
+        fixed_type = "app.StageDef.StageID_Fixed"
+        postprocessor.enum_lookup[fixed_type] = {
+            884165440: ("st200", 884165440),
+        }
+        postprocessor.enum_underlying_types[fixed_type] = "S32"
+
+        self.assertEqual(
+            postprocessor._format_enum_value(fixed_type, -521343680),
+            "[-521343680] <unknown>",
+        )
+
     def test_export_enums_internal_skips_incomplete_enum_entries(self):
         dump = {
             "app.Mode_Fixed": {
@@ -153,6 +251,137 @@ class ExporterEnumSourceMixinTests(unittest.TestCase):
             },
         )
 
+    def test_enum_context_infers_integer_fixed_backing_field_from_getter(self):
+        dump = {
+            "app.FieldDef.STAGE": {
+                "parent": "System.Enum",
+                "fields": {
+                    "value__": {"type": "System.Int32"},
+                    "ST101": {"default": 0},
+                },
+            },
+            "app.FieldDef.STAGE_Fixed": {
+                "parent": "System.Enum",
+                "fields": {
+                    "value__": {"type": "System.UInt32"},
+                    "ST101": {"default": 3068809728},
+                },
+            },
+            "app.user_data.GrassCullingSetting.cStageData": {
+                "fields": {
+                    "_StageID_Fixed": {"type": "System.Int32"},
+                },
+                "RSZ": [
+                    {
+                        "potential_name": "_StageID_Fixed",
+                        "type": "System.Int32",
+                    }
+                ],
+                "methods": {
+                    "get_StageID1185265": {
+                        "returns": {"type": "app.FieldDef.STAGE"},
+                    }
+                },
+            },
+        }
+
+        context = ExporterEnumSourceMixin.export_enum_context_internal(dump)
+
+        self.assertEqual(
+            context["class_field_fixed_types"][
+                "app.user_data.GrassCullingSetting.cStageData"
+            ],
+            {"_StageID_Fixed": "app.FieldDef.STAGE_Fixed"},
+        )
+
+    def test_enum_context_does_not_guess_fixed_type_without_enum_pair(self):
+        dump = {
+            "app.FieldDef.STAGE": {
+                "parent": "System.Enum",
+                "fields": {"ST101": {"default": 0}},
+            },
+            "app.Owner": {
+                "fields": {"_StageID_Fixed": {"type": "System.Int32"}},
+                "methods": {
+                    "get_StageID1": {
+                        "returns": {"type": "app.FieldDef.STAGE"},
+                    }
+                },
+            },
+        }
+
+        context = ExporterEnumSourceMixin.export_enum_context_internal(dump)
+
+        self.assertNotIn("app.Owner", context["class_field_fixed_types"])
+
+    def test_enum_context_infers_integer_backing_field_from_fixed_getter(self):
+        dump = {
+            "app.StageDef.StageID_Fixed": {
+                "parent": "System.Enum",
+                "fields": {
+                    "value__": {"type": "System.UInt32"},
+                    "st100": {"default": 1769129856},
+                },
+            },
+            "app.user_data.WindGlobalAnimationData.cData": {
+                "fields": {
+                    "_StageID_Fixed": {"type": "System.Int32"},
+                },
+                "methods": {
+                    "get_StageID_Fixed332574": {
+                        "returns": {"type": "app.StageDef.StageID_Fixed"},
+                    }
+                },
+            },
+        }
+
+        context = ExporterEnumSourceMixin.export_enum_context_internal(dump)
+
+        self.assertEqual(
+            context["class_field_fixed_types"][
+                "app.user_data.WindGlobalAnimationData.cData"
+            ]["_StageID_Fixed"],
+            "app.StageDef.StageID_Fixed",
+        )
+
+    def test_enum_context_preserves_digits_from_explicit_property_name(self):
+        dump = {
+            "app.LOD": {
+                "parent": "System.Enum",
+                "fields": {
+                    "value__": {"type": "System.Int32"},
+                    "LOD0": {"default": 0},
+                },
+            },
+            "app.LOD_Fixed": {
+                "parent": "System.Enum",
+                "fields": {
+                    "value__": {"type": "System.Int32"},
+                    "LOD0": {"default": 123},
+                },
+            },
+            "app.Owner": {
+                "fields": {
+                    "_LOD0_Fixed": {"type": "System.Int32"},
+                },
+                "properties": {
+                    "LOD0": {"getter": "get_LOD0"},
+                },
+                "methods": {
+                    "get_LOD0123456": {
+                        "returns": {"type": "app.LOD"},
+                    }
+                },
+            },
+        }
+
+        context = ExporterEnumSourceMixin.export_enum_context_internal(dump)
+
+        self.assertEqual(
+            context["class_field_fixed_types"]["app.Owner"]["_LOD0_Fixed"],
+            "app.LOD_Fixed",
+        )
+
     def test_generic_context_supports_ordinary_enum_wrappers(self):
         dump = {
             "app.Mode": {