PyREUser3 0.7.1__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.7.1
+Version: 0.7.2
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT
@@ -60,13 +60,6 @@ Verified H30/modern layouts support repacking. Experimental physical H28 and leg
 RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
 until real fixtures provide byte-for-byte validation.
 
-Version 0.7.1 fixes the 0.7.0 modern RSZ alignment regression. Modern userdata and
-data targets use absolute 16-byte file alignment even though their stored offsets
-remain RSZ-relative. Readable parsing accepts alignment-only deviations without
-hiding structural corruption, while the probe API reports them explicitly. Repack
-output blocks layouts carrying unverified diagnostics. The strict schema-free
-probe can validate large local corpora.
-
 Repeated operations on one `REUser3Converter` reuse schema and il2cpp metadata,
 with automatic file-signature invalidation and an explicit
 `clear_metadata_cache()` escape hatch. Batch patching reuses one exporter and

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.7.1
+Version: 0.7.2
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT
@@ -60,13 +60,6 @@ Verified H30/modern layouts support repacking. Experimental physical H28 and leg
 RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
 until real fixtures provide byte-for-byte validation.
 
-Version 0.7.1 fixes the 0.7.0 modern RSZ alignment regression. Modern userdata and
-data targets use absolute 16-byte file alignment even though their stored offsets
-remain RSZ-relative. Readable parsing accepts alignment-only deviations without
-hiding structural corruption, while the probe API reports them explicitly. Repack
-output blocks layouts carrying unverified diagnostics. The strict schema-free
-probe can validate large local corpora.
-
 Repeated operations on one `REUser3Converter` reuse schema and il2cpp metadata,
 with automatic file-signature invalidation and an explicit
 `clear_metadata_cache()` escape hatch. Batch patching reuses one exporter and

{pyreuser3-0.7.1 → pyreuser3-0.7.2}/PyREUser3.egg-info/SOURCES.txt

@@ -30,8 +30,10 @@ pyreuser3/export/tree.py
 pyreuser3/export/user3.py
 pyreuser3/pack/__init__.py
 pyreuser3/pack/base.py
+pyreuser3/pack/container.py
 pyreuser3/pack/models.py
 pyreuser3/pack/plan.py
+pyreuser3/pack/values.py
 pyreuser3/pack/writer.py
 pyreuser3/web/__init__.py
 pyreuser3/web/__main__.py

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

@@ -217,33 +217,6 @@ converter.patch_file(
 )
 ```
 
-## Compatibility Validation
-
-The repository includes a schema-free corpus runner. Game files are not committed;
-point it at a locally unpacked `natives` tree:
-
-```bash
-python tests/corpus_probe.py D:/game/natives \
-  --expected-total 62768 \
-  --expected-version 16 \
-  --report layout-report.json
-```
-
-Version 0.7.1 fixes modern RSZ alignment regression found in 0.7.0 and folds the
-planned compatibility work into the bug-fix release: staged layout detection,
-structured diagnostics, safe readable parsing, verified-only repacking, and the
-schema-free probe command. The modern rule was validated against 62,768 MHWS
-`.user.3` files; four SystemSetting fixtures additionally passed readable export,
-repack export, byte-identical packing, and reparse checks.
-
-A second corpus from Monster Hunter Stories 3 was also validated: all 42,945 files
-passed strict layout detection and schema-driven repack export. All 42,945 rebuilt
-without exceptions; 38,548 were byte-identical. The remaining 4,397 are successful
-rebuilds but not byte-identical; observed causes include nonzero padding and
-alternate empty-string encodings, so they are not claimed as byte-identical
-fixtures. Two voxel files use the compact large-array representation; both rebuilt
-byte-identically, including the 6.55 MB `dg100_Root` payload.
-
 ## Build From Source
 
 ```bash

{pyreuser3-0.7.1 → pyreuser3-0.7.2}/docs/PYPI.md

@@ -27,13 +27,6 @@ Verified H30/modern layouts support repacking. Experimental physical H28 and leg
 RSZ v3 layouts are readable for analysis but intentionally blocked from repacking
 until real fixtures provide byte-for-byte validation.
 
-Version 0.7.1 fixes the 0.7.0 modern RSZ alignment regression. Modern userdata and
-data targets use absolute 16-byte file alignment even though their stored offsets
-remain RSZ-relative. Readable parsing accepts alignment-only deviations without
-hiding structural corruption, while the probe API reports them explicitly. Repack
-output blocks layouts carrying unverified diagnostics. The strict schema-free
-probe can validate large local corpora.
-
 Repeated operations on one `REUser3Converter` reuse schema and il2cpp metadata,
 with automatic file-signature invalidation and an explicit
 `clear_metadata_cache()` escape hatch. Batch patching reuses one exporter and

{pyreuser3-0.7.1 → pyreuser3-0.7.2}/docs/README.zh-CN.md

@@ -256,29 +256,6 @@ converter.patch_file(
 )
 ```
 
-## 兼容性验证
-
-仓库内提供无需 schema 的语料测试脚本。游戏文件不会提交到仓库，请让脚本指向本地已解包的
-`natives` 目录：
-
-```bash
-python tests/corpus_probe.py D:/game/natives \
-  --expected-total 62768 \
-  --expected-version 16 \
-  --report layout-report.json
-```
-
-0.7.1 修复了 0.7.0 引入的现代 RSZ 对齐回归，并把原计划中的兼容性工作合并进本次 bugfix：
-分阶段布局探测、结构化诊断、安全 readable 解析、仅验证布局可 repack，以及无需 schema 的
-probe 命令。新的现代布局规则已用 62,768 个 MHWS `.user.3` 文件验证；其中四个
-SystemSetting 样本还完成了 readable 导出、repack 导出、逐字节一致回封和二次解析验证。
-
-另外还验证了 Monster Hunter Stories 3 语料：42,945 个文件全部通过严格 layout 探测和
-schema 驱动的 repack 导出；42,945 个文件全部能够无异常地重新构建，其中 38,548 个逐字节
-一致。其余 4,397 个可以成功重建但并非逐字节一致；已观察到的原因包括非零 padding、空字符串
-的另一种物理编码，因此不把它们宣称为逐字节 fixture。两个使用紧凑超大数组表示的 voxel 文件
-都能逐字节一致回封，其中包括 6.55 MB 的 `dg100_Root` payload。
-
 ## 常见注意事项
 
 - schema JSON、`il2cpp_dump.json` 和 `.user.3` 文件应来自同一个游戏版本；

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

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

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

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

@@ -71,6 +71,9 @@ class ExporterPostprocessMixin:
     def _format_enum_value(self, fixed_enum_type: str, value: int) -> Any:
         """Format enum value.
 
+        Exact declared members stay intact; flagged enums are decomposed only when the
+        numeric value has no exact member.
+
         The method keeps parsing, metadata lookup, and JSON shaping explicit so incomplete
         templates can still produce inspectable output.
 
@@ -86,7 +89,15 @@ class ExporterPostprocessMixin:
         value_map = self.enum_lookup.get(fixed_enum_type)
         if value_map is None:
             return value
-        # Leave numeric enum values unchanged when no enum lookup is available for the current context.
+        matched = enum_member_for_value(
+            self.enum_lookup,
+            fixed_enum_type,
+            value,
+            getattr(self, "enum_underlying_types", {}),
+        )
+        if matched is not None:
+            member_name, fixed_value = matched
+            return self._id_formatter(member_name, fixed_value)
         if fixed_enum_type in getattr(self, "enum_flags", set()):
             return decode_flags(
                 self.enum_lookup,
@@ -94,16 +105,7 @@ class ExporterPostprocessMixin:
                 value,
                 getattr(self, "enum_underlying_types", {}),
             )
-        matched = enum_member_for_value(
-            self.enum_lookup,
-            fixed_enum_type,
-            value,
-            getattr(self, "enum_underlying_types", {}),
-        )
-        if matched is None:
-            return value
-        member_name, fixed_value = matched
-        return self._id_formatter(member_name, fixed_value)
+        return value
 
     @staticmethod
     def _looks_like_class_name(text: str) -> bool:

{pyreuser3-0.7.1 → pyreuser3-0.7.2}/pyreuser3/pack/base.py

@@ -11,12 +11,10 @@ import re
 from pathlib import Path
 from typing import Any
 
+from .container import RepackContainer
 from .models import (
     ExternalUserdataSpec,
     InstanceSpec,
-    RszUserdataSpec,
-    UsrResourceSpec,
-    UsrUserdataSpec,
 )
 from .plan import PackerPlanMixin
 from .writer import PackerWriterMixin
@@ -25,12 +23,6 @@ from ..enum_codec import is_probable_flags_enum
 from ..export import User3Exporter
 from ..rich_ui import BatchProgress
 from ..schema import TypeDB
-from ..usr_layouts import (
-    DEFAULT_RSZ_HEADER_LAYOUT_ID,
-    DEFAULT_USR_LAYOUT_ID,
-    get_rsz_header_layout,
-    get_usr_layout,
-)
 
 
 class User3Packer(PackerPlanMixin, PackerWriterMixin):
@@ -97,25 +89,9 @@ class User3Packer(PackerPlanMixin, PackerWriterMixin):
             )
         }
         self.instances: list[InstanceSpec | ExternalUserdataSpec | None] = []
-        self.usr_layout = get_usr_layout(DEFAULT_USR_LAYOUT_ID)
-        if self.usr_layout is None:
-            raise RuntimeError(f"default USR layout is not registered: {DEFAULT_USR_LAYOUT_ID}")
-        self.rsz_header_layout = get_rsz_header_layout(
-            DEFAULT_RSZ_HEADER_LAYOUT_ID
-        )
-        if self.rsz_header_layout is None:
-            raise RuntimeError(
-                "default RSZ header layout is not registered: "
-                f"{DEFAULT_RSZ_HEADER_LAYOUT_ID}"
-            )
-        self.usr_header_padding = b"\x00" * self.usr_layout.header_padding_size
-        self.usr_resources: list[UsrResourceSpec] = []
-        self.usr_userdata: list[UsrUserdataSpec] = []
-        # A numeric RSZ version must be loaded from repack metadata.  The modern
-        # header family is shared across games and must not imply MHWS version 16.
-        self.rsz_version: int | None = None
-        self.rsz_reserved = 0
-        self.rsz_userdata: list[RszUserdataSpec] = []
+        # The container is committed atomically only after one complete repack document
+        # has passed layout, table, instance, and resource validation.
+        self.container: RepackContainer | None = None
 
     def pack_json_file(self, json_path: str | Path, output_path: str | Path) -> Path:
         """Pack json file.

pyreuser3-0.7.2/pyreuser3/pack/container.py

@@ -0,0 +1,388 @@
+"""Parse and validate pack-side USR/RSZ container metadata.
+
+The repack document carries physical container information separately from the RSZ
+instance graph.  This module turns that JSON boundary into one immutable plan before
+instance planning or binary writing mutates packer state.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from .models import (
+    ExternalUserdataSpec,
+    InstanceSpec,
+    PackError,
+    RszUserdataSpec,
+    StructValue,
+    UsrResourceSpec,
+    UsrUserdataSpec,
+)
+from ..core import PACK_JSON_FORMAT
+from ..schema import ClassDef
+from ..usr_layouts import (
+    RszHeaderLayout,
+    UsrLayoutCandidate,
+    get_rsz_header_layout,
+    get_usr_layout,
+    rsz_header_layouts_for_version,
+)
+
+
+@dataclass(frozen=True)
+class RepackContainer:
+    """Validated physical metadata required to rebuild one ``.user.3`` container."""
+
+    usr_layout: UsrLayoutCandidate
+    rsz_layout: RszHeaderLayout
+    usr_header_padding: bytes
+    usr_resources: tuple[UsrResourceSpec, ...]
+    usr_userdata: tuple[UsrUserdataSpec, ...]
+    rsz_version: int
+    rsz_reserved: int
+    rsz_userdata: tuple[RszUserdataSpec, ...]
+
+
+def parse_optional_u32(value: Any) -> int | None:
+    """Parse an optional integer or hexadecimal string as unsigned 32-bit data."""
+
+    if value is None:
+        return None
+    if isinstance(value, int):
+        return value & 0xFFFFFFFF
+    if isinstance(value, str):
+        text = value.strip()
+        if not text:
+            return None
+        return int(text, 0) & 0xFFFFFFFF
+    raise PackError(f"expected integer or hex string, got {value!r}")
+
+
+def parse_required_u32(value: Any, label: str) -> int:
+    """Parse a required unsigned 32-bit value with a document-path label."""
+
+    parsed = parse_optional_u32(value)
+    if parsed is None:
+        raise PackError(f"{label} is required")
+    return parsed
+
+
+def parse_path(value: Any, label: str) -> str:
+    """Validate a path-like JSON field without normalizing its binary spelling."""
+
+    if not isinstance(value, str):
+        raise PackError(f"{label} must be a string")
+    if "\x00" in value:
+        raise PackError(f"{label} cannot contain a NUL character")
+    return value
+
+
+def _parse_layout_metadata(
+    data: dict[str, Any],
+) -> tuple[str, UsrLayoutCandidate, RszHeaderLayout, int, int]:
+    """Resolve and validate the outer and embedded layout declarations."""
+
+    raw_layout = data.get("_layout")
+    if not isinstance(raw_layout, dict):
+        raise PackError("repack v3 must contain a _layout object")
+    layout_id = raw_layout.get("usr")
+    if not isinstance(layout_id, str) or not layout_id:
+        raise PackError("repack v3 _layout.usr must be a layout id")
+    usr_layout = get_usr_layout(layout_id)
+    if usr_layout is None:
+        raise PackError(f"unknown USR layout id: {layout_id}")
+    if not usr_layout.repack_supported:
+        raise PackError(f"USR layout {usr_layout.identifier} is read-only")
+
+    rsz_version = raw_layout.get("rsz_version")
+    if not isinstance(rsz_version, int):
+        raise PackError("_layout.rsz_version must be an integer")
+    rsz_layout = _resolve_rsz_layout(raw_layout.get("rsz_header"), rsz_version)
+    if not rsz_layout.repack_supported:
+        raise PackError(f"RSZ header layout {rsz_layout.identifier} is read-only")
+    if not rsz_layout.supports_version(rsz_version):
+        raise PackError(
+            f"RSZ version {rsz_version} is not supported by header layout "
+            f"{rsz_layout.identifier}"
+        )
+
+    rsz_reserved = raw_layout.get("rsz_reserved", 0)
+    if not isinstance(rsz_reserved, int) or not -(1 << 31) <= rsz_reserved < (1 << 31):
+        raise PackError("_layout.rsz_reserved must be a signed 32-bit integer")
+    return layout_id, usr_layout, rsz_layout, rsz_version, rsz_reserved
+
+
+def _resolve_rsz_layout(
+    layout_id: Any, rsz_version: int
+) -> RszHeaderLayout:
+    """Resolve an explicit RSZ header id or one unambiguous version match."""
+
+    if layout_id is None:
+        inferred = rsz_header_layouts_for_version(rsz_version)
+        if len(inferred) != 1:
+            raise PackError(
+                f"cannot infer one RSZ header layout for version {rsz_version}"
+            )
+        return inferred[0]
+    if not isinstance(layout_id, str) or not layout_id:
+        raise PackError("repack v3 _layout.rsz_header must be a layout id")
+    layout = get_rsz_header_layout(layout_id)
+    if layout is None:
+        raise PackError(f"unknown RSZ header layout id: {layout_id}")
+    return layout
+
+
+def _parse_usr_metadata(
+    data: dict[str, Any],
+    layout_id: str,
+    layout: UsrLayoutCandidate,
+) -> tuple[bytes, tuple[UsrResourceSpec, ...], tuple[UsrUserdataSpec, ...]]:
+    """Parse outer USR padding, dependency tables, and capability gates."""
+
+    raw_usr = data.get("_usr")
+    if not isinstance(raw_usr, dict):
+        raise PackError("repack v3 must contain a _usr object")
+    header_padding = _parse_header_padding(raw_usr, layout_id, layout)
+    resources = _parse_usr_resources(raw_usr, layout_id, layout)
+    userdata = _parse_usr_userdata(raw_usr, layout_id, layout)
+    raw_info = raw_usr.get("info")
+    if not isinstance(raw_info, list):
+        raise PackError("_usr.info must be an array")
+    if raw_info:
+        raise PackError(
+            f"layout {layout_id} cannot rebuild a nonempty USR info table"
+        )
+    return header_padding, resources, userdata
+
+
+def _parse_header_padding(
+    raw_usr: dict[str, Any],
+    layout_id: str,
+    layout: UsrLayoutCandidate,
+) -> bytes:
+    """Decode the opaque bytes between the semantic and physical USR headers."""
+
+    padding_hex = raw_usr.get("header_padding_hex", "")
+    if not isinstance(padding_hex, str):
+        raise PackError("_usr.header_padding_hex must be hexadecimal text")
+    try:
+        header_padding = bytes.fromhex(padding_hex)
+    except ValueError as exc:
+        raise PackError("_usr.header_padding_hex is not valid hexadecimal") from exc
+    if len(header_padding) != layout.header_padding_size:
+        raise PackError(
+            f"layout {layout_id} requires {layout.header_padding_size} header "
+            f"padding bytes, got {len(header_padding)}"
+        )
+    return header_padding
+
+
+def _parse_usr_resources(
+    raw_usr: dict[str, Any],
+    layout_id: str,
+    layout: UsrLayoutCandidate,
+) -> tuple[UsrResourceSpec, ...]:
+    """Parse the outer resource dependency table."""
+
+    raw_resources = raw_usr.get("resources")
+    if not isinstance(raw_resources, list):
+        raise PackError("_usr.resources must be an array")
+    resources: list[UsrResourceSpec] = []
+    for index, raw in enumerate(raw_resources):
+        if not isinstance(raw, dict):
+            raise PackError(f"_usr.resources[{index}] must be an object")
+        resources.append(
+            UsrResourceSpec(
+                path=parse_path(raw.get("path"), f"_usr.resources[{index}].path"),
+                reserved=parse_required_u32(
+                    raw.get("reserved", 0),
+                    f"_usr.resources[{index}].reserved",
+                ),
+            )
+        )
+    if resources and not layout.supports_resources:
+        raise PackError(f"layout {layout_id} cannot rebuild USR resources")
+    return tuple(resources)
+
+
+def _parse_usr_userdata(
+    raw_usr: dict[str, Any],
+    layout_id: str,
+    layout: UsrLayoutCandidate,
+) -> tuple[UsrUserdataSpec, ...]:
+    """Parse the outer userdata dependency table."""
+
+    raw_userdata = raw_usr.get("userdata")
+    if not isinstance(raw_userdata, list):
+        raise PackError("_usr.userdata must be an array")
+    userdata: list[UsrUserdataSpec] = []
+    for index, raw in enumerate(raw_userdata):
+        if not isinstance(raw, dict):
+            raise PackError(f"_usr.userdata[{index}] must be an object")
+        userdata.append(
+            UsrUserdataSpec(
+                class_hash=parse_required_u32(
+                    raw.get("class_hash"),
+                    f"_usr.userdata[{index}].class_hash",
+                ),
+                crc=parse_required_u32(
+                    raw.get("crc", 0),
+                    f"_usr.userdata[{index}].crc",
+                ),
+                path=parse_path(
+                    raw.get("path"),
+                    f"_usr.userdata[{index}].path",
+                ),
+            )
+        )
+    if userdata and not layout.supports_usr_userdata:
+        raise PackError(f"layout {layout_id} cannot rebuild USR userdata")
+    return tuple(userdata)
+
+
+def _parse_rsz_userdata(
+    data: dict[str, Any], layout: RszHeaderLayout
+) -> tuple[RszUserdataSpec, ...]:
+    """Parse the embedded RSZ userdata table and enforce unique instance ids."""
+
+    raw_rsz = data.get("_rsz")
+    if not isinstance(raw_rsz, dict):
+        raise PackError("repack v3 must contain a _rsz object")
+    raw_userdata = raw_rsz.get("userdata")
+    if not isinstance(raw_userdata, list):
+        raise PackError("_rsz.userdata must be an array")
+    userdata: list[RszUserdataSpec] = []
+    seen_instance_ids: set[int] = set()
+    for index, raw in enumerate(raw_userdata):
+        if not isinstance(raw, dict):
+            raise PackError(f"_rsz.userdata[{index}] must be an object")
+        instance_id = raw.get("instance_id")
+        if not isinstance(instance_id, int) or instance_id <= 0:
+            raise PackError(
+                f"_rsz.userdata[{index}].instance_id must be a positive integer"
+            )
+        if instance_id in seen_instance_ids:
+            raise PackError(f"duplicate RSZ userdata instance id: {instance_id}")
+        seen_instance_ids.add(instance_id)
+        userdata.append(
+            RszUserdataSpec(
+                instance_id=instance_id,
+                type_hash=parse_required_u32(
+                    raw.get("type_hash"),
+                    f"_rsz.userdata[{index}].type_hash",
+                ),
+                path=parse_path(
+                    raw.get("path"),
+                    f"_rsz.userdata[{index}].path",
+                ),
+            )
+        )
+    if userdata and not layout.supports_rsz_userdata:
+        raise PackError(
+            f"RSZ header layout {layout.identifier} cannot rebuild userdata"
+        )
+    return tuple(userdata)
+
+
+def parse_repack_container(data: dict[str, Any]) -> RepackContainer:
+    """Build one validated container plan from a repack v3 JSON document."""
+
+    format_name = data.get("_format")
+    if format_name != PACK_JSON_FORMAT:
+        raise PackError(
+            f"{format_name} does not record USR/RSZ layout metadata; "
+            "re-export the source file as repack v3 before packing"
+        )
+    (
+        layout_id,
+        usr_layout,
+        rsz_layout,
+        rsz_version,
+        rsz_reserved,
+    ) = _parse_layout_metadata(data)
+    header_padding, resources, usr_userdata = _parse_usr_metadata(
+        data, layout_id, usr_layout
+    )
+    rsz_userdata = _parse_rsz_userdata(data, rsz_layout)
+    return RepackContainer(
+        usr_layout=usr_layout,
+        rsz_layout=rsz_layout,
+        usr_header_padding=header_padding,
+        usr_resources=resources,
+        usr_userdata=usr_userdata,
+        rsz_version=rsz_version,
+        rsz_reserved=rsz_reserved,
+        rsz_userdata=rsz_userdata,
+    )
+
+
+def validate_userdata_metadata(
+    container: RepackContainer,
+    instances: Sequence[InstanceSpec | ExternalUserdataSpec | None],
+) -> None:
+    """Ensure outer and embedded userdata tables agree with instance metadata."""
+
+    external = {
+        index: spec
+        for index, spec in enumerate(instances)
+        if isinstance(spec, ExternalUserdataSpec)
+    }
+    listed_ids = {item.instance_id for item in container.rsz_userdata}
+    if listed_ids != set(external):
+        raise PackError(
+            "RSZ userdata table instance ids do not match userdata_reference "
+            f"instances: table={sorted(listed_ids)}, instances={sorted(external)}"
+        )
+    for item in container.rsz_userdata:
+        spec = external[item.instance_id]
+        if item.type_hash != spec.class_hash or item.path != spec.path:
+            raise PackError(
+                f"RSZ userdata metadata does not match instance {item.instance_id}"
+            )
+    outer = [(item.class_hash, item.path) for item in container.usr_userdata]
+    embedded = [(item.type_hash, item.path) for item in container.rsz_userdata]
+    if outer != embedded:
+        raise PackError("USR userdata dependencies do not match RSZ userdata order")
+
+
+def validate_resource_metadata(
+    container: RepackContainer,
+    instances: Sequence[InstanceSpec | ExternalUserdataSpec | None],
+) -> None:
+    """Require every RSZ ``Resource`` value in the outer dependency table."""
+
+    dependencies = {item.path for item in container.usr_resources}
+    missing: set[str] = set()
+    for spec in instances[1:]:
+        if isinstance(spec, InstanceSpec):
+            missing.update(
+                path
+                for path in _iter_struct_resources(spec.class_def, spec.fields)
+                if path and path not in dependencies
+            )
+    if missing:
+        raise PackError(
+            "RSZ Resource values are missing from _usr.resources: "
+            f"{sorted(missing)}"
+        )
+
+
+def _iter_struct_resources(
+    class_def: ClassDef,
+    fields: dict[str, Any],
+) -> Iterator[str]:
+    """Yield resource paths from one prepared instance or nested struct."""
+
+    for field_def in class_def.fields:
+        value = fields.get(field_def.name or "unnamed")
+        values = value if field_def.is_array and isinstance(value, list) else [value]
+        if field_def.field_type == "Resource":
+            yield from (item for item in values if isinstance(item, str) and item)
+            continue
+        if field_def.field_type != "Struct":
+            continue
+        for item in values:
+            if isinstance(item, StructValue):
+                yield from _iter_struct_resources(item.class_def, item.fields)