rust-map-parser 0.1.0__py3-none-any.whl

rustmap/populations.py

@@ -0,0 +1,361 @@
+"""Extract and evaluate Rust server DensitySpawnPopulation filters."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .layers import biome_grid, splat_grid, topology_grid
+
+
+@dataclass(slots=True)
+class SpawnRule:
+    asset_path: str
+    name: str
+    class_name: str
+    active: bool
+    resource_folder: str
+    resources: list[str]
+    target_density: float
+    scale_with_large_maps: bool
+    scale_with_spawn_filter: bool
+    splat_mask: int
+    biome_mask: int
+    topology_any: int
+    topology_all: int
+    topology_not: int
+    filter_cutoff: float
+    filter_radius: float
+    filter_out_tutorial_islands: bool
+    filter_out_monuments: list[int]
+    align_to_normal: bool
+    npc_radius_check_distance: float
+    population_convar: str | None = None
+
+
+def heatmap_categories(rules: list[SpawnRule]) -> dict[str, list[str]]:
+    """Map Rust+ Desktop's category keys to active population asset paths."""
+    exact = {
+        "ores": {"ores", "ores_sand", "ores_snow", "v3_ores_jungle"},
+        "wood": {"collectable-resource-wood"},
+        "mushroom": {"collectable-food-mushroom"},
+        "corn": {"plant-corn"}, "pumpkin": {"plant-pumpkin"},
+        "potato": {"plant-potato"}, "wheat": {"plant-wheat"},
+        "junkpiles": {"junkpiles", "junkpiles_water"},
+        "rowboat": {"rowboat.population"}, "modularcar": {"modularcar.population"},
+        "horse": {"ridablehorse.population"},
+        # Monument bikes use fixed spawn points, not a terrain distribution.
+        # Including their unrestricted default filter makes the raster solid.
+        "pedalbike": {"pedalbikes_world.population"},
+        "hab": {"hab.population"},
+        "hemp": {"collectable-resource-hemp", "jungle-collectable-resource-hemp"},
+        "bear": {"bear.population", "polarbear.population"},
+        "boar": {"boar.population"}, "chicken": {"chicken.population"},
+        "wolf": {"wolf.population"}, "stag": {"stag.population"},
+        "crocodile": {"crocodile.population"}, "tiger": {"tiger.population"},
+        "snake": {"snake.population"},
+    }
+    result = {key: [] for key in exact}
+    result.update({"logs": [], "berries": [], "flowers": []})
+    for rule in rules:
+        if not rule.active:
+            continue
+        name = rule.name.casefold()
+        for category, names in exact.items():
+            if name in names:
+                result[category].append(rule.asset_path)
+        if name.startswith("logs_") or name in {"driftwood", "wood_log_pile"}:
+            result["logs"].append(rule.asset_path)
+        if "plant-berry-" in name:
+            result["berries"].append(rule.asset_path)
+        if name in {"plant-rose", "plant-orchid", "plant-sunflower"}:
+            result["flowers"].append(rule.asset_path)
+    return {key: sorted(value) for key, value in sorted(result.items())}
+
+
+def _u32(value: int) -> int:
+    return int(value) & 0xFFFFFFFF
+
+
+def _ptr_id(value: Any) -> int:
+    if isinstance(value, dict):
+        return int(value.get("m_PathID", value.get("path_id", 0)))
+    return int(getattr(value, "path_id", 0))
+
+
+def _script_classes(environment) -> dict[int, str]:
+    result = {}
+    for obj in environment.objects:
+        if obj.type.name == "MonoScript":
+            data = obj.read()
+            result[obj.path_id] = getattr(data, "m_ClassName", "")
+    return result
+
+
+def _class_name(data, fallback: dict[int, str], obj=None) -> str:
+    """Resolve a script within its serialized file (path IDs repeat per file)."""
+    try:
+        return str(data.m_Script.get_obj().read().m_ClassName)
+    except Exception:
+        try:
+            script = obj.assets_file.objects[data.m_Script.path_id]
+            return str(script.read().m_ClassName)
+        except Exception:
+            return fallback.get(data.m_Script.path_id, "")
+
+
+def _guid_paths(environment, classes: dict[int, str]) -> dict[str, str]:
+    for obj in environment.objects:
+        if obj.type.name != "MonoBehaviour":
+            continue
+        data = obj.read()
+        if _class_name(data, classes, obj) != "GameManifest":
+            continue
+        tree = obj.read_typetree()
+        # Current Rust stores parallel GUID/path arrays. Retain fallbacks for
+        # older manifest layouts.
+        guids = tree.get("guidList") or tree.get("guids") or []
+        paths = tree.get("guidPaths") or tree.get("paths") or []
+        if isinstance(paths, list) and paths and isinstance(paths[0], dict):
+            return {
+                str(x.get("guid", "")): str(x.get("path", x.get("name", "")))
+                for x in paths if x.get("guid")
+            }
+        if len(guids) == len(paths):
+            return {str(g): str(p) for g, p in zip(guids, paths)}
+        for item in tree.get("prefabProperties", []):
+            if item.get("guid") and item.get("name"):
+                guids.append(item["guid"]); paths.append(item["name"])
+        return {str(g): str(p) for g, p in zip(guids, paths)}
+    return {}
+
+
+def _active_population_ids_local(maps_bundle: Path) -> tuple[set[int], dict]:
+    import UnityPy
+
+    env = UnityPy.load(str(maps_bundle))
+    classes = _script_classes(env)
+    candidates = []
+    # Locate SpawnHandler scripts first, then inspect only their serialized
+    # files. A full typetree scan of the 50k behaviours is unnecessarily large.
+    for script in env.objects:
+        if script.type.name != "MonoScript" or getattr(script.read(), "m_ClassName", "") != "SpawnHandler":
+            continue
+        for obj in script.assets_file.objects.values():
+            if obj.type.name != "MonoBehaviour":
+                continue
+            data = obj.read()
+            if data.m_Script.path_id != script.path_id:
+                continue
+            tree = obj.read_typetree()
+            regular = tree.get("SpawnPopulations", [])
+            convar = tree.get("ConvarSpawnPopulations", [])
+            refs = regular + convar
+            ids = {_ptr_id(x) for x in refs if _ptr_id(x)}
+            if ids:
+                candidates.append((len(ids), ids, obj.path_id, len(regular), len(convar)))
+    if not candidates:
+        raise RuntimeError("No SpawnHandler was found in maps.bundle")
+    count, ids, path_id, regular_count, convar_count = max(candidates, key=lambda x: x[0])
+    result = ids, {"handler_count": len(candidates), "selected_path_id": path_id,
+                   "selected_population_count": count,
+                   "regular_population_count": regular_count,
+                   "convar_population_count": convar_count}
+    del env
+    return result
+
+
+def _active_worker(path: str, connection) -> None:
+    try:
+        ids, metadata = _active_population_ids_local(Path(path))
+        connection.send((sorted(ids), metadata, None))
+    except Exception as exc:
+        connection.send(([], {}, repr(exc)))
+    finally:
+        connection.close()
+
+
+def _active_population_ids(maps_bundle: Path) -> tuple[set[int], dict]:
+    """Read maps.bundle in a disposable process to release UnityPy's graph."""
+    import multiprocessing as mp
+    parent, child = mp.get_context("spawn").Pipe(False)
+    process = mp.get_context("spawn").Process(
+        target=_active_worker, args=(str(maps_bundle), child)
+    )
+    process.start()
+    ids, metadata, error = parent.recv()
+    process.join()
+    if error:
+        raise RuntimeError(f"SpawnHandler extraction failed: {error}")
+    return set(ids), metadata
+
+
+def extract_spawn_rules(content_bundle: str | Path, maps_bundle: str | Path) -> dict:
+    """Extract all population assets and mark those in the main SpawnHandler."""
+    import UnityPy
+
+    content = Path(content_bundle).resolve()
+    maps = Path(maps_bundle).resolve()
+    active_ids, handler = _active_population_ids(maps)
+    env = UnityPy.load(str(content))
+    classes = _script_classes(env)
+    guid_paths = _guid_paths(env, classes)
+
+    populations = {
+        "DensitySpawnPopulation", "ConvarControlledSpawnPopulation",
+        "ConvarControlledSpawnPopulationRail", "SpawnPointSpawnPopulation",
+        "ConvarControlledSpawnPointPopulation",
+    }
+    rules = []
+    for asset_path, obj in env.container.items():
+        normalized_path = str(asset_path).casefold().replace("\\", "/")
+        if "/spawnpopulation/" not in normalized_path and not normalized_path.endswith(".population.asset"):
+            continue
+        if obj.type.name != "MonoBehaviour":
+            continue
+        data = obj.read()
+        class_name = _class_name(data, classes, obj)
+        if class_name not in populations:
+            continue
+        tree = obj.read_typetree()
+        filt = tree.get("Filter", {})
+        resources = []
+        for ref in tree.get("ResourceList", []):
+            guid = ref.get("guid", ref) if isinstance(ref, dict) else ref
+            resources.append(guid_paths.get(str(guid), str(guid)))
+        convar = tree.get("PopulationConvar")
+        if isinstance(convar, dict):
+            convar = convar.get("name") or convar.get("Value") or str(convar)
+        rules.append(SpawnRule(
+            asset_path=str(asset_path), name=str(tree.get("m_Name", Path(asset_path).stem)),
+            class_name=class_name, active=obj.path_id in active_ids,
+            resource_folder=str(tree.get("ResourceFolder", "")), resources=resources,
+            target_density=float(tree.get("_targetDensity", 0)),
+            scale_with_large_maps=bool(tree.get("ScaleWithLargeMaps", False)),
+            scale_with_spawn_filter=bool(tree.get("ScaleWithSpawnFilter", False)),
+            splat_mask=int(filt.get("SplatType", -1)), biome_mask=int(filt.get("BiomeType", -1)),
+            topology_any=_u32(filt.get("TopologyAny", -1)),
+            topology_all=_u32(filt.get("TopologyAll", -1)),
+            topology_not=_u32(filt.get("TopologyNot", 0)),
+            filter_cutoff=float(tree.get("FilterCutoff", 0)),
+            filter_radius=float(tree.get("FilterRadius", 0)),
+            filter_out_tutorial_islands=bool(tree.get("FilterOutTutorialIslands", False)),
+            filter_out_monuments=[int(x) for x in tree.get("FilterOutMonuments", [])],
+            align_to_normal=bool(tree.get("AlignToNormal", False)),
+            npc_radius_check_distance=float(tree.get("NpcRadiusCheckDistance", 0)),
+            population_convar=str(convar) if convar else None,
+        ))
+    rules.sort(key=lambda x: x.asset_path.casefold())
+    return {
+        "schema_version": 1,
+        "sources": {
+            "content_bundle": {"path": str(content), "size": content.stat().st_size,
+                               "mtime_ns": content.stat().st_mtime_ns},
+            "maps_bundle": {"path": str(maps), "size": maps.stat().st_size,
+                            "mtime_ns": maps.stat().st_mtime_ns},
+        },
+        "spawn_handler": handler,
+        "rule_count": len(rules), "active_rule_count": sum(r.active for r in rules),
+        "heatmap_categories": heatmap_categories(rules),
+        "rules": [asdict(r) for r in rules],
+    }
+
+
+def save_rule_database(database: dict, path: str | Path) -> None:
+    target = Path(path); target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(database, indent=2) + "\n", encoding="utf-8")
+
+
+class SpawnFilterEvaluator:
+    """Reusable population evaluator with resolution-specific sampling caches."""
+
+    def __init__(self, world, resolution: int = 512):
+        self.resolution = resolution
+        self.source_splat = splat_grid(world)
+        source_biome = biome_grid(world)
+        source_topology = topology_grid(world)
+        self.norm = (np.arange(resolution, dtype=np.float32) + 0.5) / resolution
+        ix = np.minimum((self.norm * source_topology.shape[1]).astype(int), source_topology.shape[1] - 1)
+        iz = np.minimum((self.norm * source_topology.shape[0]).astype(int), source_topology.shape[0] - 1)
+        self.topology = source_topology[np.ix_(iz, ix)]
+        sampled_biome = source_biome[:, iz][:, :, ix]
+        # Server uses >=, so ties select the last/highest channel.
+        self.dominant_biome = sampled_biome.shape[0] - 1 - np.argmax(sampled_biome[::-1], axis=0)
+        self.biome_count = sampled_biome.shape[0]
+        self._splat_cache: dict[int, np.ndarray] = {}
+        # Bilinear sampling a 2048² splat channel is relatively expensive, and
+        # the rule database combines the same eight channels into many masks.
+        # Keep float64 terms because the original NumPy expression evaluates in
+        # float64 before each in-place float32 addition.  Storing float32 here
+        # changes a small number of final uint8 values.
+        self._splat_channel_cache: dict[int, np.ndarray] = {}
+        self._evaluation_cache: dict[tuple[int, int, int, int, int, float], np.ndarray] = {}
+
+        source = self.source_splat
+        self._splat_pos = self.norm * (source.shape[2] - 1)
+        self._splat_x0 = np.floor(self._splat_pos).astype(int)
+        self._splat_x1 = np.minimum(self._splat_x0 + 1, source.shape[2] - 1)
+        self._splat_t = self._splat_pos - self._splat_x0
+
+    def _sample_splat_channel(self, channel: int) -> np.ndarray:
+        cached = self._splat_channel_cache.get(channel)
+        if cached is not None:
+            return cached
+        grid = self.source_splat[channel]
+        x0, x1, t = self._splat_x0, self._splat_x1, self._splat_t
+        a = grid[np.ix_(x0, x0)]
+        b = grid[np.ix_(x0, x1)]
+        c = grid[np.ix_(x1, x0)]
+        d = grid[np.ix_(x1, x1)]
+        sampled = ((a * (1-t)[None,:] + b * t[None,:]) * (1-t)[:,None]
+                   + (c * (1-t)[None,:] + d * t[None,:]) * t[:,None]) / 255.0
+        self._splat_channel_cache[channel] = sampled
+        return sampled
+
+    def _splat_factor(self, mask: int) -> np.ndarray:
+        cached = self._splat_cache.get(mask)
+        if cached is not None:
+            return cached
+        value = np.zeros((self.resolution, self.resolution), dtype=np.float32)
+        for channel in range(self.source_splat.shape[0]):
+            if not (mask & (1 << channel)):
+                continue
+            value += self._sample_splat_channel(channel)
+        value = np.clip(value, 0, 1)
+        self._splat_cache[mask] = value
+        return value
+
+    def evaluate(self, rule: SpawnRule | dict) -> np.ndarray:
+        if isinstance(rule, dict):
+            rule = SpawnRule(**rule)
+        cache_key = (
+            _u32(rule.topology_any), _u32(rule.topology_all), _u32(rule.topology_not),
+            int(rule.biome_mask), int(rule.splat_mask), float(rule.filter_cutoff),
+        )
+        cached = self._evaluation_cache.get(cache_key)
+        if cached is not None:
+            return cached
+        topo = self.topology
+        factor = np.ones((self.resolution, self.resolution), dtype=np.float32)
+        any_mask, all_mask, not_mask = map(_u32, (rule.topology_any, rule.topology_all, rule.topology_not))
+        if any_mask != 0xFFFFFFFF: factor[(topo & any_mask) == 0] = 0
+        if all_mask != 0xFFFFFFFF: factor[(topo & all_mask) != all_mask] = 0
+        if not_mask: factor[(topo & not_mask) != 0] = 0
+
+        if rule.biome_mask != -1:
+            allowed = np.array([(rule.biome_mask & (1 << i)) != 0 for i in range(self.biome_count)])
+            factor[~allowed[self.dominant_biome]] = 0
+        if rule.splat_mask != -1:
+            factor *= self._splat_factor(rule.splat_mask)
+        result = np.where(factor > rule.filter_cutoff, factor * 255, 0).astype(np.uint8)
+        self._evaluation_cache[cache_key] = result
+        return result
+
+
+def evaluate_filter(world, rule: SpawnRule | dict, resolution: int = 512) -> np.ndarray:
+    """Reproduce DensitySpawnPopulation.GetBaseMapValues (placement map excluded)."""
+    return SpawnFilterEvaluator(world, resolution).evaluate(rule)

rustmap/prefabs.py

@@ -0,0 +1,281 @@
+"""Extract Rust's GameManifest and resolve numeric map prefab IDs."""
+
+from __future__ import annotations
+
+import csv
+import json
+from collections import Counter, defaultdict
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from .parser import RustMap, RustMapError
+
+
+@dataclass(slots=True)
+class PrefabManifestEntry:
+    prefab_id: int
+    path: str
+    guid: str | None = None
+    pooled: bool | None = None
+
+
+@dataclass(slots=True)
+class PrefabResolution:
+    prefab_id: int
+    path: str | None
+    instance_count: int
+    map_categories: list[str]
+    classification: str
+    heatmap_relevance: str
+    guid: str | None = None
+    pooled: bool | None = None
+
+
+@dataclass(slots=True)
+class PrefabManifest:
+    entries: dict[int, PrefabManifestEntry]
+    collisions: dict[int, list[str]]
+    source_bundle: str
+    source_size: int
+    source_mtime_ns: int
+
+    def get(self, prefab_id: int) -> PrefabManifestEntry | None:
+        return self.entries.get(prefab_id)
+
+    def save(self, path: str | Path) -> None:
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "source_bundle": self.source_bundle,
+            "source_size": self.source_size,
+            "source_mtime_ns": self.source_mtime_ns,
+            "entry_count": len(self.entries),
+            "entries": {
+                str(key): asdict(value) for key, value in sorted(self.entries.items())
+            },
+            "collisions": {str(k): v for k, v in sorted(self.collisions.items())},
+        }
+        target.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+    @classmethod
+    def load(cls, path: str | Path) -> "PrefabManifest":
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+        entries = {
+            int(key): PrefabManifestEntry(**value)
+            for key, value in payload["entries"].items()
+        }
+        return cls(
+            entries=entries,
+            collisions={int(k): v for k, v in payload.get("collisions", {}).items()},
+            source_bundle=payload["source_bundle"],
+            source_size=int(payload["source_size"]),
+            source_mtime_ns=int(payload["source_mtime_ns"]),
+        )
+
+
+def find_content_bundle(rust_install: str | Path) -> Path:
+    root = Path(rust_install)
+    candidates = (
+        root / "Bundles" / "shared" / "content.bundle",
+        root / "shared" / "content.bundle",
+        root if root.name.casefold() == "content.bundle" else None,
+    )
+    for candidate in candidates:
+        if candidate is not None and candidate.is_file():
+            return candidate
+    raise FileNotFoundError(f"Could not find Bundles/shared/content.bundle below {root}")
+
+
+def extract_game_manifest(content_bundle: str | Path) -> PrefabManifest:
+    """Extract the authoritative ID/path table from Rust's GameManifest asset."""
+    try:
+        import UnityPy
+    except ImportError as exc:
+        raise RuntimeError("UnityPy is required to extract the installed GameManifest") from exc
+
+    bundle = Path(content_bundle).resolve()
+    stat = bundle.stat()
+    environment = UnityPy.load(str(bundle))
+
+    game_manifest_script_id: int | None = None
+    for obj in environment.objects:
+        if obj.type.name != "MonoScript":
+            continue
+        script = obj.read()
+        if getattr(script, "m_ClassName", "") == "GameManifest":
+            game_manifest_script_id = obj.path_id
+            break
+    if game_manifest_script_id is None:
+        raise RustMapError("GameManifest MonoScript was not found in content.bundle")
+
+    tree = None
+    for obj in environment.objects:
+        if obj.type.name != "MonoBehaviour":
+            continue
+        behaviour = obj.read()
+        if behaviour.m_Script.path_id == game_manifest_script_id:
+            tree = obj.read_typetree()
+            break
+    if tree is None:
+        raise RustMapError("GameManifest data object was not found in content.bundle")
+
+    properties_by_path: dict[str, dict] = {
+        item["name"].casefold(): item for item in tree.get("prefabProperties", [])
+    }
+    entries: dict[int, PrefabManifestEntry] = {}
+    all_paths: dict[int, list[str]] = defaultdict(list)
+    for item in tree.get("pooledStrings", []):
+        prefab_id = int(item["hash"])
+        asset_path = item["str"]
+        all_paths[prefab_id].append(asset_path)
+        prop = properties_by_path.get(asset_path.casefold())
+        entries[prefab_id] = PrefabManifestEntry(
+            prefab_id=prefab_id,
+            path=asset_path,
+            guid=prop.get("guid") if prop else None,
+            pooled=bool(prop.get("pool")) if prop else None,
+        )
+
+    collisions = {
+        prefab_id: sorted(set(paths))
+        for prefab_id, paths in all_paths.items()
+        if len(set(paths)) > 1
+    }
+    return PrefabManifest(
+        entries=entries,
+        collisions=collisions,
+        source_bundle=str(bundle),
+        source_size=stat.st_size,
+        source_mtime_ns=stat.st_mtime_ns,
+    )
+
+
+def load_or_extract_manifest(
+    rust_install: str | Path, cache_path: str | Path | None = None
+) -> PrefabManifest:
+    bundle = find_content_bundle(rust_install)
+    stat = bundle.stat()
+    if cache_path is not None and Path(cache_path).is_file():
+        cached = PrefabManifest.load(cache_path)
+        if cached.source_size == stat.st_size and cached.source_mtime_ns == stat.st_mtime_ns:
+            return cached
+    manifest = extract_game_manifest(bundle)
+    if cache_path is not None:
+        manifest.save(cache_path)
+    return manifest
+
+
+def classify_prefab(path: str | None, map_categories: list[str]) -> tuple[str, str]:
+    if path is None:
+        return "unresolved", "unknown"
+    value = path.casefold().replace("\\", "/")
+    category_text = " ".join(map_categories).casefold()
+
+    if "/monument/" in value or "monument" in category_text:
+        return "monument", "spawn exclusion and orientation reference"
+    if any(token in value for token in (
+        "rock_formation", "/cliff", "cliff_", "coastal_rock", "shore_ice",
+        "iceberg", "ice_sheet", "rockformation",
+    )):
+        return "terrain_geometry", "slope/ore environment and spawn exclusion"
+    if any(token in category_text for token in ("road", "powerline")) or any(
+        token in value for token in ("/road", "roadside", "powerline")
+    ):
+        return "transport_corridor", "vehicle and junkpile spawn environment"
+    if "river" in category_text or any(
+        token in value for token in ("/river", "riversound", "waterfall", "water_")
+    ):
+        return "water_feature", "water/river spawn environment"
+    if "dungeon" in category_text or "/dungeon" in value:
+        return "dungeon", "spawn exclusion and underground geometry"
+    if any(token in value for token in (
+        "/resource/", "/collectable/", "/animals/", "/plant/", "tree",
+        "bush", "foliage", "vine",
+    )):
+        return "natural_resource", "possible direct resource or vegetation feature"
+    if "decor" in category_text or "/decor/" in value:
+        return "decor", "possible spawn environment or exclusion geometry"
+    return "other", "not yet assigned"
+
+
+def resolve_world_prefabs(
+    world: RustMap, manifest: PrefabManifest
+) -> list[PrefabResolution]:
+    counts = Counter(item.prefab_id for item in world.prefabs)
+    categories: dict[int, set[str]] = defaultdict(set)
+    for item in world.prefabs:
+        categories[item.prefab_id].add(item.category)
+
+    result: list[PrefabResolution] = []
+    for prefab_id, count in counts.most_common():
+        entry = manifest.get(prefab_id)
+        map_categories = sorted(categories[prefab_id])
+        classification, relevance = classify_prefab(
+            entry.path if entry else None, map_categories
+        )
+        result.append(PrefabResolution(
+            prefab_id=prefab_id,
+            path=entry.path if entry else None,
+            instance_count=count,
+            map_categories=map_categories,
+            classification=classification,
+            heatmap_relevance=relevance,
+            guid=entry.guid if entry else None,
+            pooled=entry.pooled if entry else None,
+        ))
+    return result
+
+
+def write_resolution_reports(
+    world: RustMap,
+    manifest: PrefabManifest,
+    output_dir: str | Path,
+) -> dict:
+    output = Path(output_dir)
+    output.mkdir(parents=True, exist_ok=True)
+    resolutions = resolve_world_prefabs(world, manifest)
+    resolved = [item for item in resolutions if item.path is not None]
+    unresolved = [item for item in resolutions if item.path is None]
+    classification_instances = Counter()
+    for item in resolutions:
+        classification_instances[item.classification] += item.instance_count
+
+    report = {
+        "manifest": {
+            "source_bundle": manifest.source_bundle,
+            "source_size": manifest.source_size,
+            "entry_count": len(manifest.entries),
+            "hash_collision_count": len(manifest.collisions),
+        },
+        "map": {
+            "world_size": world.size,
+            "prefab_instances": len(world.prefabs),
+            "unique_prefab_ids": len(resolutions),
+        },
+        "coverage": {
+            "resolved_unique_ids": len(resolved),
+            "unresolved_unique_ids": len(unresolved),
+            "resolved_instances": sum(x.instance_count for x in resolved),
+            "unresolved_instances": sum(x.instance_count for x in unresolved),
+        },
+        "classification_instance_counts": dict(classification_instances.most_common()),
+        "unresolved": [asdict(item) for item in unresolved],
+        "resolved": [asdict(item) for item in resolutions],
+    }
+    (output / "phase2_resolution.json").write_text(
+        json.dumps(report, indent=2) + "\n", encoding="utf-8"
+    )
+
+    with (output / "resolved_prefabs.csv").open("w", newline="", encoding="utf-8") as stream:
+        writer = csv.writer(stream)
+        writer.writerow((
+            "prefab_id", "instance_count", "map_categories", "classification",
+            "heatmap_relevance", "path", "guid", "pooled",
+        ))
+        for item in resolutions:
+            writer.writerow((
+                item.prefab_id, item.instance_count, ";".join(item.map_categories),
+                item.classification, item.heatmap_relevance, item.path or "",
+                item.guid or "", "" if item.pooled is None else item.pooled,
+            ))
+    return report