dungeon_editor_v2_persistence.cc

Go to the documentation of this file.

// Persistence (ROM and project save) implementation for DungeonEditorV2. Split out of
// dungeon_editor_v2.cc to keep that translation unit within the editor
// source-size guardrail. Class declaration lives in dungeon_editor_v2.h.
 
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <iterator>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "absl/status/status.h"
#include "absl/strings/cord.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/editor/dungeon/dungeon_project_labels.h"
#include "app/editor/dungeon/dungeon_room_store.h"
#include "app/editor/dungeon/dungeon_room_transfer.h"
#include "app/editor/dungeon/inspectors/door_editor_content.h"
#include "app/editor/dungeon/inspectors/palette_editor_content.h"
#include "app/editor/dungeon/selectors/object_selector_content.h"
#include "app/editor/dungeon/ui/window/custom_collision_panel.h"
#include "app/editor/dungeon/ui/window/dungeon_entrances_panel.h"
#include "app/editor/dungeon/ui/window/item_editor_panel.h"
#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
#include "app/editor/dungeon/ui/window/object_tile_editor_panel.h"
#include "app/editor/dungeon/ui/window/overlay_manager_panel.h"
#include "app/editor/dungeon/ui/window/room_tag_editor_panel.h"
#include "app/editor/dungeon/ui/window/sprite_editor_panel.h"
#include "app/editor/dungeon/ui/window/water_fill_panel.h"
#include "app/editor/dungeon/widgets/dungeon_status_bar.h"
#include "app/editor/dungeon/workspace/dungeon_workbench_content.h"
#include "app/editor/dungeon/workspace/room_browser_content.h"
#include "app/editor/dungeon/workspace/room_graphics_content.h"
#include "app/editor/dungeon/workspace/room_matrix_content.h"
#include "app/editor/editor_manager.h"
#include "app/editor/events/core_events.h"
#include "app/editor/graphics/graphics_editor.h"
#include "app/editor/menu/status_bar.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/session/hack_manifest_save_validation.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/emu/mesen/mesen_client_registry.h"
#include "app/emu/mesen/mesen_socket_client.h"
#include "app/emu/render/emulator_render_service.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/ui_config.h"
#include "core/dungeon_stream_layout_adapter.h"
#include "core/features.h"
#include "core/project.h"
#include "dungeon_editor_v2.h"
#include "imgui/imgui.h"
#include "rom/snes.h"
#include "rom/transaction.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/dungeon_stream_allocator.h"
#include "zelda3/dungeon/dungeon_validator.h"
#include "zelda3/dungeon/object_dimensions.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/water_fill_zone.h"
#include "zelda3/resource_labels.h"
 
namespace yaze::editor {
 
namespace {
 
constexpr char kMinecartDraftSaveBlockMessage[] =
    "Minecart Track Editor has unpublished drafts. ROM Save/Apply never "
    "publishes ASM source; use Publish Tracks in the Minecart Track Editor "
    "or discard the drafts first.";
 
absl::Status ValidateChestObjectSaveCoupling(const DungeonRoomStore& rooms,
                                             int only_room = -1) {
  const auto& flags = core::FeatureFlags::get().dungeon;
  absl::Status status;
  rooms.ForEachMaterialized([&](int id, const zelda3::Room& room) {
    if (!status.ok() || !room.chests_dirty() || !room.object_stream_dirty())
      return;
    const bool writes_objects = flags.kSaveObjects && room.IsLoaded() &&
                                (only_room < 0 || only_room == id);
    if (writes_objects == flags.kSaveChests)
      return;
    status = absl::FailedPreconditionError(absl::StrFormat(
        "Room 0x%03X has pending chest object and reward edits. Enable both "
        "Room Objects and Chests, then apply that room or save all rooms "
        "together before applying another room.",
        id));
  });
  return status;
}
 
absl::Status SaveWaterFillZones(Rom* rom, DungeonRoomStore& rooms) {
  if (!rom || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  bool any_dirty = false;
  rooms.ForEachMaterialized([&any_dirty](int, const zelda3::Room& room) {
    if (room.water_fill_dirty()) {
      any_dirty = true;
    }
  });
  if (!any_dirty) {
    return absl::OkStatus();
  }
 
  // Preserve saved zones even when no viewer has materialized their room.
  ASSIGN_OR_RETURN(auto saved_zones, zelda3::LoadWaterFillTable(rom));
  std::map<int, zelda3::WaterFillZoneEntry> merged;
  for (auto& zone : saved_zones)
    merged[zone.room_id] = std::move(zone);
  for (int room_id = 0; room_id < static_cast<int>(rooms.size()); ++room_id) {
    auto* room = rooms.GetIfMaterialized(room_id);
    if (room == nullptr) {
      continue;
    }
    if (!room->has_water_fill_zone()) {
      if (room->water_fill_dirty())
        merged.erase(room_id);
      continue;
    }
 
    const int tile_count = room->WaterFillTileCount();
    if (tile_count <= 0) {
      continue;
    }
    if (tile_count > 255) {
      return absl::InvalidArgumentError(absl::StrFormat(
          "Water fill zone in room 0x%02X has %d tiles (max 255)", room_id,
          tile_count));
    }
 
    zelda3::WaterFillZoneEntry z;
    z.room_id = room_id;
    z.sram_bit_mask = room->water_fill_sram_bit_mask();
    z.fill_offsets.reserve(static_cast<size_t>(tile_count));
 
    const auto& map = room->water_fill_zone().tiles;
    for (size_t i = 0; i < map.size(); ++i) {
      if (map[i] != 0) {
        z.fill_offsets.push_back(static_cast<uint16_t>(i));
      }
    }
    merged[room_id] = std::move(z);
  }
 
  std::vector<zelda3::WaterFillZoneEntry> zones;
  for (auto& [id, zone] : merged)
    zones.push_back(std::move(zone));
 
  if (zones.size() > 8) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Too many water fill zones: %zu (max 8 fits in $7EF411 bitfield)",
        zones.size()));
  }
 
  // Canonicalize SRAM mask assignment using the shared normalizer so editor
  // save behavior matches JSON import/export workflows.
  RETURN_IF_ERROR(zelda3::NormalizeWaterFillZoneMasks(&zones));
  for (const auto& z : zones) {
    if (auto* room = rooms.GetIfMaterialized(z.room_id)) {
      room->set_water_fill_sram_bit_mask(z.sram_bit_mask);
    }
  }
 
  RETURN_IF_ERROR(zelda3::WriteWaterFillTable(rom, zones));
  rooms.ForEachMaterialized(
      [](int, zelda3::Room& room) { room.ClearWaterFillDirty(); });
 
  return absl::OkStatus();
}
 
std::vector<std::pair<uint32_t, uint32_t>> CollectDirtyPotItemWriteRanges(
    const project::YazeProject* project, const Rom* rom,
    const DungeonRoomStore& rooms) {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
  if (rom == nullptr || !rom->is_loaded()) {
    return ranges;
  }
 
  bool any_dirty = false;
  rooms.ForEachMaterialized([&](int, const zelda3::Room& room) {
    if (room.pot_items_dirty()) {
      any_dirty = true;
    }
  });
  if (!any_dirty) {
    return ranges;
  }
 
  if (project != nullptr && project->hack_manifest.loaded()) {
    const auto* layout = project->hack_manifest.GetDungeonStreamLayout(
        core::DungeonStreamType::kPotItems);
    if (layout != nullptr &&
        layout->strategy == core::DungeonWriteStrategy::kRepackAll) {
      for (const auto& range : layout->allocation_regions) {
        ranges.emplace_back(yaze::SnesToPc(range.start),
                            yaze::SnesToPc(range.end));
      }
      const uint32_t pointer_width =
          layout->pointer_encoding == core::DungeonPointerEncoding::kLong24
              ? 3u
              : 2u;
      const uint32_t pointer_table_pc = yaze::SnesToPc(layout->pointer_table);
      ranges.emplace_back(
          pointer_table_pc,
          pointer_table_pc + layout->pointer_count * pointer_width);
      return ranges;
    }
  }
 
  const auto& rom_data = rom->vector();
  rooms.ForEachMaterialized([&](int room_id, const zelda3::Room& room) {
    if (!room.pot_items_dirty()) {
      return;
    }
    const int pointer_slot = zelda3::kRoomItemsPointers + room_id * 2;
    if (pointer_slot < 0 ||
        pointer_slot + 1 >= static_cast<int>(rom_data.size())) {
      return;
    }
    const uint16_t pointer =
        (static_cast<uint16_t>(rom_data[pointer_slot + 1]) << 8) |
        rom_data[pointer_slot];
    if (pointer < 0x8000) {
      return;
    }
    const uint32_t stream_pc = yaze::SnesToPc(0x010000u | pointer);
    const uint32_t encoded_size =
        static_cast<uint32_t>(room.GetPotItems().size() * 3 + 2);
    ranges.emplace_back(stream_pc, stream_pc + encoded_size);
  });
  return ranges;
}
 
absl::StatusOr<std::vector<std::pair<uint32_t, uint32_t>>>
CollectDirtyChestWriteRanges(const Rom* rom, const DungeonRoomStore& rooms) {
  ASSIGN_OR_RETURN(
      zelda3::ChestSavePlan plan,
      zelda3::BuildChestSavePlan(
          rom, static_cast<int>(rooms.size()),
          [&rooms](int room_id) { return rooms.GetIfMaterialized(room_id); }));
  return plan.write_ranges();
}
 
std::vector<std::pair<uint32_t, uint32_t>> CollectDirtyWaterFillWriteRanges(
    const Rom* rom, const DungeonRoomStore& rooms) {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
  if (rom == nullptr || !rom->is_loaded() ||
      zelda3::kWaterFillTableEnd > static_cast<int>(rom->size())) {
    return ranges;
  }
  bool any_dirty = false;
  rooms.ForEachMaterialized([&any_dirty](int, const zelda3::Room& room) {
    if (room.water_fill_dirty()) {
      any_dirty = true;
    }
  });
  if (any_dirty) {
    ranges.emplace_back(zelda3::kWaterFillTableStart,
                        zelda3::kWaterFillTableEnd);
  }
  return ranges;
}
 
std::vector<std::pair<uint32_t, uint32_t>>
CollectDirtyCustomCollisionWriteRanges(const Rom* rom,
                                       const DungeonRoomStore& rooms) {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
  const int pointer_table_size = zelda3::kNumberOfRooms * 3;
  if (rom == nullptr || !rom->is_loaded() ||
      zelda3::kCustomCollisionRoomPointers + pointer_table_size >
          static_cast<int>(rom->size()) ||
      zelda3::kCustomCollisionDataSoftEnd > static_cast<int>(rom->size())) {
    return ranges;
  }
  bool any_dirty = false;
  rooms.ForEachMaterialized([&any_dirty](int, const zelda3::Room& room) {
    if (room.custom_collision_dirty()) {
      any_dirty = true;
    }
  });
  if (any_dirty) {
    ranges.emplace_back(
        zelda3::kCustomCollisionRoomPointers,
        zelda3::kCustomCollisionRoomPointers + pointer_table_size);
    ranges.emplace_back(zelda3::kCustomCollisionDataPosition,
                        zelda3::kCustomCollisionDataSoftEnd);
  }
  return ranges;
}
 
absl::Status SaveAllPotItemsForProject(const project::YazeProject* project,
                                       Rom* rom, DungeonRoomStore& rooms) {
  std::optional<zelda3::DungeonStreamLayout> repack_layout;
  bool any_dirty = false;
  rooms.ForEachMaterialized([&](int, const zelda3::Room& room) {
    if (room.pot_items_dirty()) {
      any_dirty = true;
    }
  });
  if (any_dirty && project != nullptr && project->hack_manifest.loaded()) {
    const auto* manifest_layout = project->hack_manifest.GetDungeonStreamLayout(
        core::DungeonStreamType::kPotItems);
    if (manifest_layout != nullptr &&
        manifest_layout->strategy == core::DungeonWriteStrategy::kRepackAll) {
      ASSIGN_OR_RETURN(
          zelda3::DungeonStreamLayout allocator_layout,
          core::ToDungeonStreamAllocatorLayout(
              core::DungeonStreamType::kPotItems, *manifest_layout));
      repack_layout = std::move(allocator_layout);
    }
  }
 
  return zelda3::SaveAllPotItems(
      rom, static_cast<int>(rooms.size()),
      [&rooms](int room_id) { return rooms.GetIfMaterialized(room_id); },
      repack_layout.has_value() ? &*repack_layout : nullptr);
}
 
absl::Status ValidatePotItemManifestConflicts(
    const project::YazeProject* project, Rom* rom,
    const DungeonRoomStore& rooms, absl::string_view save_scope,
    ToastManager* toast_manager) {
  if (project == nullptr || !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  const auto ranges = CollectDirtyPotItemWriteRanges(project, rom, rooms);
  if (ranges.empty()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
absl::Status ValidatePaletteManifestConflicts(
    const project::YazeProject* project,
    const gfx::PaletteManager& palette_manager,
    const zelda3::GameData* game_data, absl::string_view save_scope,
    ToastManager* toast_manager) {
  ASSIGN_OR_RETURN(const auto ranges,
                   palette_manager.GetModifiedColorWriteRanges(game_data));
  if (project == nullptr || !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  if (ranges.empty()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
absl::Status ValidateDungeonEntranceSavePreflight(
    const project::YazeProject* project, Rom* rom,
    const std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>&
        entrances,
    const std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>&
        spawn_points,
    absl::string_view save_scope, ToastManager* toast_manager) {
  if (rom == nullptr || !rom->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Field and ROM-bound validation must happen even without a manifest. This
  // runs before any editor save domain mutates the shared ROM buffer.
  RETURN_IF_ERROR(zelda3::RejectUnsupportedDungeonSpawnPointSaves(entrances));
  RETURN_IF_ERROR(
      zelda3::ValidateRegularDungeonEntrancesForSave(*rom, entrances));
  RETURN_IF_ERROR(
      zelda3::ValidateDungeonSpawnPointsForSave(*rom, spawn_points));
 
  if (project == nullptr || !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  ASSIGN_OR_RETURN(
      auto ranges,
      zelda3::CollectDirtyRegularDungeonEntranceWriteRanges(*rom, entrances));
  auto spawn_ranges =
      zelda3::CollectDirtyDungeonSpawnPointWriteRanges(spawn_points);
  ranges.insert(ranges.end(), spawn_ranges.begin(), spawn_ranges.end());
  if (ranges.empty()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
absl::Status ValidateChestManifestConflicts(const project::YazeProject* project,
                                            const zelda3::ChestSavePlan& plan,
                                            absl::string_view save_scope,
                                            ToastManager* toast_manager) {
  const auto ranges = plan.write_ranges();
  if (ranges.empty() || project == nullptr ||
      !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
absl::Status ValidateWaterFillManifestConflicts(
    const project::YazeProject* project, const Rom* rom,
    const DungeonRoomStore& rooms, absl::string_view save_scope,
    ToastManager* toast_manager) {
  if (project == nullptr || !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  const auto ranges = CollectDirtyWaterFillWriteRanges(rom, rooms);
  if (ranges.empty()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
absl::Status ValidateCustomCollisionManifestConflicts(
    const project::YazeProject* project, const Rom* rom,
    const DungeonRoomStore& rooms, absl::string_view save_scope,
    ToastManager* toast_manager) {
  if (project == nullptr || !project->hack_manifest.loaded()) {
    return absl::OkStatus();
  }
  const auto ranges = CollectDirtyCustomCollisionWriteRanges(rom, rooms);
  if (ranges.empty()) {
    return absl::OkStatus();
  }
  return ValidateHackManifestSaveConflicts(
      project->hack_manifest, project->rom_metadata.write_policy, ranges,
      save_scope, "DungeonEditorV2", toast_manager);
}
 
}  // namespace
 
absl::Status DungeonEditorV2::ApplyRoomLabelEdit(
    int room_id, std::optional<std::string> label) {
  // Save Project serializes EditorManager's project and then replaces the
  // session snapshot (dependencies_.project) from it, so the edit must land
  // in the authoritative project first.
  auto* editor_manager = static_cast<EditorManager*>(dependencies_.custom_data);
  if (editor_manager == nullptr ||
      !editor_manager->IsCurrentProjectContextOwnedBySession(
          dependencies_.session_id)) {
    return absl::FailedPreconditionError(
        "Activate this dungeon project before renaming rooms");
  }
  project::YazeProject* authoritative = editor_manager->GetCurrentProject();
  if (authoritative == nullptr || !authoritative->project_opened()) {
    return absl::FailedPreconditionError("Room names require an open project");
  }
 
  const auto apply = [&](project::YazeProject* project) {
    if (label.has_value()) {
      dungeon_project_labels::SetRoomLabel(project, room_id, *label);
    } else {
      dungeon_project_labels::ClearRoomLabel(project, room_id);
    }
  };
  apply(authoritative);
  if (dependencies_.project != nullptr &&
      dependencies_.project != authoritative) {
    apply(dependencies_.project);
  }
  editor_manager->MarkCurrentProjectDirty();
  editor_manager->RefreshResourceLabelProvider();
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::PreflightPotItemPlacement(
    int room_id, const std::vector<zelda3::PotItem>& items) {
  const auto* room = rooms_.GetIfLoaded(room_id);
  if (!rom_ || !rom_->is_loaded() || !room || room->rom() != rom_) {
    return absl::FailedPreconditionError("Pot-item room is not loaded");
  }
  // Pot streams share one save operation. Include pending edits in other rooms
  // so an individually small placement cannot overcommit the repack pool.
  // Only detached rooms can have their dirty flags cleared by this dry run.
  Rom scratch(*rom_);
  DungeonRoomStore staged(&scratch);
  rooms_.ForEachMaterialized([&](int id, const zelda3::Room& source) {
    if (id != room_id && !source.pot_items_dirty()) {
      return;
    }
    auto& candidate = staged[id];
    candidate.GetPotItems() = id == room_id ? items : source.GetPotItems();
    candidate.MarkPotItemsDirty();
  });
  RETURN_IF_ERROR(ValidatePotItemManifestConflicts(
      dependencies_.project, &scratch, staged, "pot-item placement", nullptr));
  return SaveAllPotItemsForProject(dependencies_.project, &scratch, staged);
}
 
absl::Status DungeonEditorV2::BeginSaveTransaction() {
  if (save_transaction_snapshot_.has_value()) {
    return absl::FailedPreconditionError(
        "Dungeon save transaction is already active");
  }
 
  // A save is a history boundary: a later drag increment must not restore
  // dirty flags captured before the bytes we are about to publish.
  FinalizePendingUndoActions();
  SaveTransactionSnapshot snapshot;
  auto& palette_manager = gfx::PaletteManager::Get();
  if (core::FeatureFlags::get().dungeon.kSavePalettes &&
      palette_manager.HasUnsavedChanges(game_data_)) {
    if (!palette_manager.IsManaging(game_data_)) {
      return absl::FailedPreconditionError(
          "Cannot save dungeon palettes from a different ROM session");
    }
    RETURN_IF_ERROR(palette_manager.BeginSaveTransaction());
    snapshot.has_palette_transaction = true;
  }
  rooms_.ForEachMaterialized([&snapshot](int room_id,
                                         const zelda3::Room& room) {
    snapshot.room_states.emplace_back(room_id, room.CaptureSaveDirtySnapshot());
  });
  for (size_t i = 0; i < entrances_.size(); ++i) {
    snapshot.entrance_dirty_states[i] = entrances_[i].dirty();
  }
  for (size_t i = 0; i < spawn_points_.size(); ++i) {
    snapshot.spawn_dirty_states[i] = spawn_points_[i].dirty();
  }
  if (game_data_ != nullptr) {
    snapshot.has_pit_damage_table = true;
    snapshot.pit_damage_dirty = game_data_->pit_damage_table.dirty();
  }
  save_transaction_snapshot_ = std::move(snapshot);
  return absl::OkStatus();
}
 
void DungeonEditorV2::RollbackSaveTransaction() {
  if (!save_transaction_snapshot_.has_value()) {
    return;
  }
 
  for (const auto& [room_id, state] : save_transaction_snapshot_->room_states) {
    if (auto* room = rooms_.GetIfMaterialized(room_id); room != nullptr) {
      room->RestoreSaveDirtySnapshot(state);
    }
  }
  for (size_t i = 0; i < entrances_.size(); ++i) {
    if (save_transaction_snapshot_->entrance_dirty_states[i]) {
      entrances_[i].MarkDirty();
    } else {
      entrances_[i].ClearDirty();
    }
  }
  for (size_t i = 0; i < spawn_points_.size(); ++i) {
    if (save_transaction_snapshot_->spawn_dirty_states[i]) {
      spawn_points_[i].MarkDirty();
    } else {
      spawn_points_[i].ClearDirty();
    }
  }
  if (save_transaction_snapshot_->has_pit_damage_table &&
      game_data_ != nullptr) {
    if (save_transaction_snapshot_->pit_damage_dirty) {
      game_data_->pit_damage_table.MarkDirty();
    } else {
      game_data_->pit_damage_table.ClearDirty();
    }
  }
  if (save_transaction_snapshot_->has_palette_transaction) {
    gfx::PaletteManager::Get().RollbackSaveTransaction();
  }
  save_transaction_snapshot_.reset();
}
 
void DungeonEditorV2::CommitSaveTransaction() {
  if (save_transaction_snapshot_.has_value()) {
    ++entrance_property_save_generation_;
  }
  if (save_transaction_snapshot_.has_value() &&
      save_transaction_snapshot_->has_palette_transaction) {
    gfx::PaletteManager::Get().CommitSaveTransaction();
  }
  save_transaction_snapshot_.reset();
}
 
absl::Status DungeonEditorV2::RunWithSaveTransaction(
    const std::function<absl::Status()>& operation) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // File > Save already owns a whole-ROM/editor transaction. Direct Apply Room
  // and Apply All actions use the same guarantees without nesting it.
  if (save_transaction_snapshot_.has_value()) {
    return operation();
  }
 
  ScopedRomTransaction rom_transaction(*rom_);
  RETURN_IF_ERROR(BeginSaveTransaction());
 
  const absl::Status status = operation();
  if (!status.ok()) {
    RollbackSaveTransaction();
    return status;
  }
 
  CommitSaveTransaction();
  rom_transaction.Commit();
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::ValidateSaveScope(int only_room,
                                                bool room_data_only) const {
  // A chest object and its reward are one edit. Preserve the more specific
  // recovery instruction when only one half of that edit would be written.
  RETURN_IF_ERROR(ValidateChestObjectSaveCoupling(rooms_, only_room));
  const auto& flags = core::FeatureFlags::get().dungeon;
  zelda3::Room::SaveDirtySnapshot pending{};
  bool collision = false;
  bool water_fill = false;
  rooms_.ForEachMaterialized([&](int id, const zelda3::Room& room) {
    // Apply Room writes local streams for its selected room, but the compact
    // shared tables below include pending records from every materialized room.
    if (only_room < 0 || only_room == id) {
      pending.object_stream |=
          room.object_stream_dirty() || room.object_stream_header_dirty();
      pending.sprites |= room.sprites_dirty();
      pending.header |= room.header_dirty();
    }
    pending.chests |= room.chests_dirty();
    pending.pot_items |= room.pot_items_dirty();
    pending.torches |= room.torches_dirty();
    pending.blocks |= room.blocks_dirty();
    collision |= room.custom_collision_dirty();
    water_fill |= room.water_fill_dirty();
  });
  std::vector<std::string> excluded;
  auto check = [&](bool dirty, bool enabled, const char* label) {
    if (dirty && !enabled) {
      excluded.emplace_back(label);
    }
  };
  check(pending.object_stream, flags.kSaveObjects, "Save Objects");
  check(pending.sprites, flags.kSaveSprites, "Save Sprites");
  check(pending.header, flags.kSaveRoomHeaders, "Save Room Headers");
  check(pending.torches, flags.kSaveTorches, "Save Torches");
  check(pending.blocks, flags.kSaveBlocks, "Save Blocks");
  check(collision, flags.kSaveCollision, "Save Collision");
  check(pending.chests, flags.kSaveChests, "Save Chests");
  check(pending.pot_items, flags.kSavePotItems, "Save Pot Items");
  if (!room_data_only) {
    check(game_data_ && game_data_->pit_damage_table.dirty(), flags.kSavePits,
          "Save Pits");
    const auto dirty = [](const auto& entrance) {
      return entrance.dirty();
    };
    check(std::any_of(entrances_.begin(), entrances_.end(), dirty) ||
              std::any_of(spawn_points_.begin(), spawn_points_.end(), dirty),
          flags.kSaveEntrances, "Save Entrances");
  }
  std::string message;
  if (!excluded.empty()) {
    message = absl::StrCat(
        "Save blocked: pending dungeon edits are excluded by ",
        absl::StrJoin(excluded, ", "),
        ". Open File > Save Scope > Dungeon, enable these choices and retry "
        "Save or Apply Room. Or undo the excluded edits. No project reopen "
        "is needed.");
  }
  // Water Fill import/migration is established at project load, so keep its
  // existing project-only scope contract rather than silently enabling it.
  if (water_fill && !flags.kSaveWaterFillZones) {
    absl::StrAppend(&message, message.empty() ? "Save blocked: " : " ",
                    "Water Fill edits are pending while their project save "
                    "scope is disabled. Undo these edits or restore the "
                    "project's Water Fill save setting before saving.");
  }
  if (!message.empty()) {
    return absl::FailedPreconditionError(message);
  }
  if (!flags.kSaveRoomHeaders) {
    return absl::OkStatus();
  }
  // Check every header this operation writes before palettes or any earlier
  // room in the save loop can change ROM bytes.
  absl::Status ownership;
  rooms_.ForEachLoaded([&](int id, const zelda3::Room& room) {
    if (!ownership.ok() || !room.header_dirty() ||
        (only_room >= 0 && only_room != id)) {
      return;
    }
    if (!rom_ || !rom_->is_loaded()) {
      ownership = absl::FailedPreconditionError("ROM not loaded");
    } else if (room.rom() != rom_) {
      ownership = absl::FailedPreconditionError(
          absl::StrFormat("Room 0x%03X belongs to another ROM", id));
    } else {
      ownership = ValidateRoomHeaderOwnership(*rom_, room.id());
    }
  });
  return ownership;
}
 
absl::Status DungeonEditorV2::ValidateRoomHeaderOwnership(const Rom& rom,
                                                          int room_id) {
  if (!IsValidRoomId(room_id)) {
    return absl::InvalidArgumentError("Invalid room ID");
  }
  ASSIGN_OR_RETURN(const auto table_snes,
                   rom.ReadLong(zelda3::kRoomHeaderPointer));
  ASSIGN_OR_RETURN(const auto bank,
                   rom.ReadByte(zelda3::kRoomHeaderPointerBank));
  const auto table_bank = (table_snes >> 16) & 0xFF;
  if ((table_snes & 0xFFFF) < 0x8000 || table_bank == 0x7E ||
      table_bank == 0x7F || table_bank == 0xFE || table_bank == 0xFF ||
      bank == 0x7E || bank == 0x7F || bank == 0xFE || bank == 0xFF) {
    return absl::FailedPreconditionError("Invalid room header pointer table");
  }
  const auto table_pc = SnesToPc(table_snes);
  if (static_cast<uint64_t>(table_pc) + zelda3::kNumberOfRooms * 2 >
      rom.size()) {
    return absl::FailedPreconditionError(
        "Room header pointer table is truncated");
  }
  ASSIGN_OR_RETURN(const auto header, rom.ReadWord(table_pc + room_id * 2));
  const auto header_pc = SnesToPc((bank << 16) | header);
  if (header < 0x8000 || static_cast<uint64_t>(header_pc) + 14 > rom.size()) {
    return absl::FailedPreconditionError(
        absl::StrFormat("Room %03X header pointer is invalid", room_id));
  }
  for (int other_id = 0; other_id < zelda3::kNumberOfRooms; ++other_id) {
    if (other_id == room_id)
      continue;
    ASSIGN_OR_RETURN(const auto other_header,
                     rom.ReadWord(table_pc + other_id * 2));
    const auto other_pc = SnesToPc((bank << 16) | other_header);
    if (other_header < 0x8000 ||
        static_cast<uint64_t>(other_pc) + 14 > rom.size())
      continue;
    if (header_pc < other_pc + 14 && other_pc < header_pc + 14) {
      auto status = absl::FailedPreconditionError(absl::StrFormat(
          "Room %03X header overlaps room %03X; writing its room properties "
          "would also change that room. Undo or exclude the room property "
          "edits and retry.",
          room_id, other_id));
      status.SetPayload(kRoomTransferSharedHeaderPayload, absl::Cord("1"));
      return status;
    }
  }
  return absl::OkStatus();
}
 
absl::Status DungeonEditorV2::Save() {
  RETURN_IF_ERROR(ValidateSaveScope());
  if (minecart_track_editor_panel_ != nullptr &&
      minecart_track_editor_panel_->HasUnpublishedChanges()) {
    return absl::FailedPreconditionError(kMinecartDraftSaveBlockMessage);
  }
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (object_tile_editor_panel_ != nullptr &&
      object_tile_editor_panel_->HasUnappliedChanges()) {
    return absl::FailedPreconditionError(
        "Apply or explicitly discard Object Tile Editor changes before "
        "using Save or Apply Room");
  }
 
  FinalizePendingUndoActions();
  // A sprite/item drag can first become dirty when the gesture is released.
  // Direct Save callers need the same post-finalization check as File > Save.
  RETURN_IF_ERROR(ValidateSaveScope());
  const auto& flags = core::FeatureFlags::get().dungeon;
  std::optional<zelda3::ChestSavePlan> chest_save_plan;
 
  // Simulate the pending room streams in save order before any ROM writer.
  // Earlier relocations can change where later streams and headers will write.
  ASSIGN_OR_RETURN(const auto stream_ranges, PlanPendingRoomStreamRanges({}));
  if (dependencies_.project && dependencies_.project->hack_manifest.loaded()) {
    RETURN_IF_ERROR(ValidateHackManifestSaveConflicts(
        dependencies_.project->hack_manifest,
        dependencies_.project->rom_metadata.write_policy, stream_ranges,
        "dungeon room streams", "DungeonEditorV2",
        dependencies_.toast_manager));
  }
 
  if (flags.kSaveCollision) {
    RETURN_IF_ERROR(ValidateCustomCollisionManifestConflicts(
        dependencies_.project, rom_, rooms_, "custom collision",
        dependencies_.toast_manager));
  }
  if (flags.kSaveWaterFillZones) {
    RETURN_IF_ERROR(ValidateWaterFillManifestConflicts(
        dependencies_.project, rom_, rooms_, "water fill zones",
        dependencies_.toast_manager));
  }
  if (flags.kSaveEntrances) {
    RETURN_IF_ERROR(ValidateDungeonEntranceSavePreflight(
        dependencies_.project, rom_, entrances_, spawn_points_,
        "dungeon entrances and spawn points", dependencies_.toast_manager));
  }
 
  if (flags.kSaveChests) {
    ASSIGN_OR_RETURN(auto plan, zelda3::BuildChestSavePlan(
                                    rom_, static_cast<int>(rooms_.size()),
                                    [this](int room_id) {
                                      return rooms_.GetIfMaterialized(room_id);
                                    }));
    RETURN_IF_ERROR(ValidateChestManifestConflicts(
        dependencies_.project, plan, "chest table",
        dependencies_.toast_manager));
    chest_save_plan = std::move(plan);
  }
  if (flags.kSavePotItems) {
    RETURN_IF_ERROR(ValidatePotItemManifestConflicts(
        dependencies_.project, rom_, rooms_, "pot items",
        dependencies_.toast_manager));
  }
 
  auto& palette_manager = gfx::PaletteManager::Get();
  if (flags.kSavePalettes && palette_manager.HasUnsavedChanges(game_data_)) {
    if (!palette_manager.IsManaging(game_data_)) {
      return absl::FailedPreconditionError(
          "Cannot save dungeon palettes from a different ROM session");
    }
    RETURN_IF_ERROR(ValidatePaletteManifestConflicts(
        dependencies_.project, palette_manager, game_data_, "dungeon palettes",
        dependencies_.toast_manager));
    const size_t modified_color_count =
        palette_manager.GetModifiedColorCount(game_data_);
    auto status = palette_manager.SaveAllToRom();
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save palette changes: %s",
                status.message().data());
      return status;
    }
    LOG_INFO("DungeonEditorV2", "Saved %zu modified colors to ROM",
             modified_color_count);
  }
 
  if (flags.kSaveObjects || flags.kSaveSprites || flags.kSaveRoomHeaders) {
    absl::Status save_status = absl::OkStatus();
    rooms_.ForEachLoaded([&](int room_id, zelda3::Room&) {
      if (!save_status.ok()) {
        return;
      }
      auto status = SaveRoomData(room_id);
      if (!status.ok()) {
        save_status = status;
      }
    });
    if (!save_status.ok()) {
      return save_status;
    }
  }
 
  if (flags.kSaveTorches) {
    auto status = zelda3::SaveAllTorches(
        rom_, static_cast<int>(rooms_.size()),
        [this](int room_id) { return rooms_.GetIfMaterialized(room_id); });
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save torches: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSavePits) {
    auto status = zelda3::SaveAllPits(
        rom_, game_data_ ? &game_data_->pit_damage_table : nullptr);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save pits: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveBlocks) {
    auto status = zelda3::SaveAllBlocks(
        rom_, static_cast<int>(rooms_.size()),
        [this](int room_id) { return rooms_.GetIfMaterialized(room_id); });
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save blocks: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveCollision) {
    auto status = zelda3::SaveAllCollision(
        rom_, static_cast<int>(rooms_.size()),
        [this](int room_id) { return rooms_.GetIfMaterialized(room_id); });
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save collision: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveWaterFillZones) {
    auto status = SaveWaterFillZones(rom_, rooms_);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save water fill zones: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveChests) {
    auto status = zelda3::ApplyChestSavePlan(
        rom_, *chest_save_plan,
        [this](int room_id) { return rooms_.GetIfMaterialized(room_id); });
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save chests: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSavePotItems) {
    auto status =
        SaveAllPotItemsForProject(dependencies_.project, rom_, rooms_);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save pot items: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveEntrances) {
    auto status = zelda3::SaveAllDungeonEntrances(rom_, entrances_);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save dungeon entrances: %s",
                status.message().data());
      return status;
    }
    status = zelda3::SaveAllDungeonSpawnPoints(rom_, spawn_points_);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save dungeon spawn points: %s",
                status.message().data());
      return status;
    }
  }
 
  return absl::OkStatus();
}
 
std::vector<std::pair<uint32_t, uint32_t>> DungeonEditorV2::CollectWriteRanges()
    const {
  std::vector<std::pair<uint32_t, uint32_t>> ranges;
 
  if (!rom_ || !rom_->is_loaded()) {
    return ranges;
  }
 
  const auto& flags = core::FeatureFlags::get().dungeon;
  const auto& rom_data = rom_->vector();
 
  auto& palette_manager = gfx::PaletteManager::Get();
  if (flags.kSavePalettes) {
    auto palette_ranges =
        palette_manager.GetModifiedColorWriteRanges(game_data_);
    if (palette_ranges.ok()) {
      ranges.insert(ranges.end(), palette_ranges->begin(),
                    palette_ranges->end());
    } else {
      LOG_ERROR("DungeonEditorV2", "Cannot predict palette write ranges: %s",
                palette_ranges.status().message().data());
    }
    // This legacy prediction API cannot return a status. Both actual save
    // paths reject resolution errors in ValidatePaletteManifestConflicts
    // before any palette writer, including when no manifest is loaded.
  }
 
  if (flags.kSaveEntrances) {
    auto entrance_ranges =
        zelda3::CollectDirtyRegularDungeonEntranceWriteRanges(*rom_,
                                                              entrances_);
    if (entrance_ranges.ok()) {
      ranges.insert(ranges.end(), entrance_ranges->begin(),
                    entrance_ranges->end());
    }
    // Invalid layouts are rejected by ValidateDungeonEntranceSavePreflight
    // before any save domain mutates bytes. Do not predict legacy ranges here.
    auto spawn_ranges =
        zelda3::CollectDirtyDungeonSpawnPointWriteRanges(spawn_points_);
    ranges.insert(ranges.end(), spawn_ranges.begin(), spawn_ranges.end());
  }
 
  const auto stream_ranges = PlanPendingRoomStreamRanges({});
  if (stream_ranges.ok()) {
    ranges.insert(ranges.end(), stream_ranges->begin(), stream_ranges->end());
  } else {
    // Save repeats this preflight and fails before mutating any ROM bytes.
    LOG_ERROR("DungeonEditorV2",
              "Could not predict room stream write ranges: %s",
              stream_ranges.status().message().data());
  }
 
  // Oracle of Secrets: the water fill table lives in a reserved tail region.
  // Include it in write-range reporting whenever we have dirty water fill data,
  // even if no rooms are currently loaded (SaveWaterFillZones() is room-indexed
  // and independent of room loading state).
  if (flags.kSaveWaterFillZones) {
    auto water_fill_ranges = CollectDirtyWaterFillWriteRanges(rom_, rooms_);
    ranges.insert(ranges.end(), water_fill_ranges.begin(),
                  water_fill_ranges.end());
  }
 
  // Custom collision writes update the pointer table and append blobs into the
  // expanded collision region. SaveAllCollision() is room-indexed, so include
  // these ranges whenever any room has dirty custom collision data.
  if (flags.kSaveCollision) {
    auto collision_ranges =
        CollectDirtyCustomCollisionWriteRanges(rom_, rooms_);
    ranges.insert(ranges.end(), collision_ranges.begin(),
                  collision_ranges.end());
  }
 
  // Chests use one global fixed-capacity table. Report only the exact byte
  // deltas from the same planner used by the serializer so unrelated protected
  // bytes inside the live table do not block a safe edit.
  if (flags.kSaveChests) {
    auto chest_ranges = CollectDirtyChestWriteRanges(rom_, rooms_);
    if (chest_ranges.ok()) {
      ranges.insert(ranges.end(), chest_ranges->begin(), chest_ranges->end());
    } else {
      LOG_WARN("DungeonEditorV2", "Could not predict chest write ranges: %s",
               chest_ranges.status().message().data());
    }
  }
 
  rooms_.ForEachLoaded([&](int room_id, const zelda3::Room& room) {
    room_id = room.id();
 
    // Header range
    if (flags.kSaveRoomHeaders && room.header_dirty()) {
      if (zelda3::kRoomHeaderPointer + 2 < static_cast<int>(rom_data.size())) {
        int header_ptr_table =
            (rom_data[zelda3::kRoomHeaderPointer + 2] << 16) |
            (rom_data[zelda3::kRoomHeaderPointer + 1] << 8) |
            rom_data[zelda3::kRoomHeaderPointer];
        header_ptr_table = yaze::SnesToPc(header_ptr_table);
        int table_offset = header_ptr_table + (room_id * 2);
 
        if (table_offset + 1 < static_cast<int>(rom_data.size())) {
          int address = (rom_data[zelda3::kRoomHeaderPointerBank] << 16) |
                        (rom_data[table_offset + 1] << 8) |
                        rom_data[table_offset];
          int header_location = yaze::SnesToPc(address);
          ranges.emplace_back(header_location, header_location + 14);
        }
      }
      const int message_address = zelda3::kMessagesIdDungeon + (room_id * 2);
      if (message_address >= 0 &&
          message_address + 1 < static_cast<int>(rom_data.size())) {
        ranges.emplace_back(message_address, message_address + 2);
      }
    }
  });
 
  // Pot items are saved after room-local streams but still participate in the
  // same whole-ROM transaction and manifest preflight.
  if (flags.kSavePotItems) {
    auto pot_ranges =
        CollectDirtyPotItemWriteRanges(dependencies_.project, rom_, rooms_);
    ranges.insert(ranges.end(), pot_ranges.begin(), pot_ranges.end());
  }
 
  return ranges;
}
 
absl::Status DungeonEditorV2::SaveRoom(int room_id) {
  return SaveRoomImpl(room_id, false);
}
 
// The room-only path is used exclusively by a detached scratch editor during
// transfer preflight. It cannot save project-global palettes, pits or entrances.
absl::Status DungeonEditorV2::SaveRoomImpl(int room_id, bool room_data_only) {
  if (minecart_track_editor_panel_ != nullptr &&
      minecart_track_editor_panel_->HasUnpublishedChanges()) {
    return absl::FailedPreconditionError(kMinecartDraftSaveBlockMessage);
  }
  if (object_tile_editor_panel_ != nullptr &&
      object_tile_editor_panel_->HasUnappliedChanges()) {
    return absl::FailedPreconditionError(
        "Apply or explicitly discard Object Tile Editor changes before "
        "using Save or Apply Room");
  }
  auto operation = [this, room_id, room_data_only]() -> absl::Status {
    if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
      return absl::InvalidArgumentError("Invalid room ID");
    }
 
    RETURN_IF_ERROR(ValidateSaveScope(room_id, room_data_only));
    const auto& flags = core::FeatureFlags::get().dungeon;
    std::optional<zelda3::ChestSavePlan> chest_save_plan;
    if (flags.kSaveCollision) {
      RETURN_IF_ERROR(ValidateCustomCollisionManifestConflicts(
          dependencies_.project, rom_, rooms_,
          absl::StrFormat("custom collision for room 0x%03X", room_id),
          dependencies_.toast_manager));
    }
    if (flags.kSaveWaterFillZones) {
      RETURN_IF_ERROR(ValidateWaterFillManifestConflicts(
          dependencies_.project, rom_, rooms_,
          absl::StrFormat("water fill zones for room 0x%03X", room_id),
          dependencies_.toast_manager));
    }
    if (!room_data_only && flags.kSaveEntrances) {
      RETURN_IF_ERROR(ValidateDungeonEntranceSavePreflight(
          dependencies_.project, rom_, entrances_, spawn_points_,
          absl::StrFormat(
              "dungeon entrances and spawn points (Apply Room 0x%03X)",
              room_id),
          dependencies_.toast_manager));
    }
    if (flags.kSaveChests) {
      ASSIGN_OR_RETURN(
          auto plan, zelda3::BuildChestSavePlan(
                         rom_, static_cast<int>(rooms_.size()), [this](int id) {
                           return rooms_.GetIfMaterialized(id);
                         }));
      RETURN_IF_ERROR(ValidateChestManifestConflicts(
          dependencies_.project, plan,
          absl::StrFormat("chest table for room 0x%03X", room_id),
          dependencies_.toast_manager));
      chest_save_plan = std::move(plan);
    }
    if (flags.kSavePotItems) {
      RETURN_IF_ERROR(ValidatePotItemManifestConflicts(
          dependencies_.project, rom_, rooms_,
          absl::StrFormat("pot items for room 0x%03X", room_id),
          dependencies_.toast_manager));
    }
    auto& palette_manager = gfx::PaletteManager::Get();
    if (!room_data_only && flags.kSavePalettes &&
        palette_manager.HasUnsavedChanges(game_data_)) {
      if (!palette_manager.IsManaging(game_data_)) {
        return absl::FailedPreconditionError(
            "Cannot save dungeon palettes from a different ROM session");
      }
      RETURN_IF_ERROR(ValidatePaletteManifestConflicts(
          dependencies_.project, palette_manager, game_data_,
          absl::StrFormat("dungeon palettes for room 0x%03X", room_id),
          dependencies_.toast_manager));
      auto status = palette_manager.SaveAllToRom();
      if (!status.ok()) {
        LOG_ERROR("DungeonEditorV2", "Failed to save palette changes: %s",
                  status.message().data());
        return status;
      }
    }
    if (flags.kSaveObjects || flags.kSaveSprites || flags.kSaveRoomHeaders) {
      RETURN_IF_ERROR(SaveRoomData(room_id));
    }
 
    if (flags.kSaveTorches) {
      RETURN_IF_ERROR(zelda3::SaveAllTorches(
          rom_, static_cast<int>(rooms_.size()),
          [this](int id) { return rooms_.GetIfMaterialized(id); }));
    }
    if (!room_data_only && flags.kSavePits) {
      RETURN_IF_ERROR(zelda3::SaveAllPits(
          rom_, game_data_ ? &game_data_->pit_damage_table : nullptr));
    }
    if (flags.kSaveBlocks) {
      RETURN_IF_ERROR(zelda3::SaveAllBlocks(
          rom_, static_cast<int>(rooms_.size()),
          [this](int id) { return rooms_.GetIfMaterialized(id); }));
    }
    if (flags.kSaveCollision) {
      RETURN_IF_ERROR(zelda3::SaveAllCollision(
          rom_, static_cast<int>(rooms_.size()),
          [this](int id) { return rooms_.GetIfMaterialized(id); }));
    }
    if (flags.kSaveWaterFillZones) {
      RETURN_IF_ERROR(SaveWaterFillZones(rom_, rooms_));
    }
    if (flags.kSaveChests) {
      RETURN_IF_ERROR(zelda3::ApplyChestSavePlan(
          rom_, *chest_save_plan,
          [this](int id) { return rooms_.GetIfMaterialized(id); }));
    }
    if (flags.kSavePotItems) {
      RETURN_IF_ERROR(
          SaveAllPotItemsForProject(dependencies_.project, rom_, rooms_));
    }
    if (!room_data_only && flags.kSaveEntrances) {
      RETURN_IF_ERROR(zelda3::SaveAllDungeonEntrances(rom_, entrances_));
      RETURN_IF_ERROR(zelda3::SaveAllDungeonSpawnPoints(rom_, spawn_points_));
    }
 
    return absl::OkStatus();
  };
  // Scratch state is discarded after either outcome; no live palette/history
  // transaction should be started by a preview.
  return room_data_only ? operation() : RunWithSaveTransaction(operation);
}
 
absl::Status DungeonEditorV2::SaveRoomData(int room_id) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return absl::InvalidArgumentError("Invalid room ID");
  }
 
  auto& room = rooms_[room_id];
  if (!room.IsLoaded()) {
    return absl::OkStatus();
  }
 
  // ROM safety: validate loaded room content before writing any bytes.
  {
    zelda3::DungeonValidator validator;
    const auto result = validator.ValidateRoom(room);
    for (const auto& w : result.warnings) {
      LOG_WARN("DungeonEditorV2", "Room 0x%03X validation warning: %s", room_id,
               w.c_str());
    }
    if (!result.is_valid) {
      for (const auto& e : result.errors) {
        LOG_ERROR("DungeonEditorV2", "Room 0x%03X validation error: %s",
                  room_id, e.c_str());
      }
      if (dependencies_.toast_manager) {
        dependencies_.toast_manager->Show(
            absl::StrFormat(
                "Save blocked: room 0x%03X failed validation (%zu error(s))",
                room_id, result.errors.size()),
            ToastType::kError);
      }
      return absl::FailedPreconditionError(
          absl::StrFormat("Room 0x%03X failed validation", room_id));
    }
  }
 
  const auto& flags = core::FeatureFlags::get().dungeon;
 
  // A present copy-on-write layout is an explicit capability grant from the
  // project manifest. Without it, Room retains the Wave 1 fail-closed behavior
  // for shared or over-capacity streams.
  std::optional<zelda3::DungeonStreamLayout> object_cow_layout;
  std::optional<zelda3::DungeonStreamLayout> sprite_cow_layout;
  if (dependencies_.project && dependencies_.project->hack_manifest.loaded()) {
    const auto& manifest = dependencies_.project->hack_manifest;
    auto load_cow_layout =
        [&](core::DungeonStreamType stream_type, bool stream_dirty,
            std::optional<zelda3::DungeonStreamLayout>* out) -> absl::Status {
      if (!stream_dirty) {
        return absl::OkStatus();
      }
      const auto* manifest_layout =
          manifest.GetDungeonStreamLayout(stream_type);
      if (manifest_layout == nullptr ||
          manifest_layout->strategy !=
              core::DungeonWriteStrategy::kCopyOnWrite) {
        return absl::OkStatus();
      }
      ASSIGN_OR_RETURN(
          zelda3::DungeonStreamLayout allocator_layout,
          core::ToDungeonStreamAllocatorLayout(stream_type, *manifest_layout));
      *out = std::move(allocator_layout);
      return absl::OkStatus();
    };
 
    RETURN_IF_ERROR(load_cow_layout(
        core::DungeonStreamType::kObjects,
        flags.kSaveObjects &&
            (room.object_stream_dirty() || room.object_stream_header_dirty()),
        &object_cow_layout));
    RETURN_IF_ERROR(load_cow_layout(core::DungeonStreamType::kSprites,
                                    flags.kSaveSprites && room.sprites_dirty(),
                                    &sprite_cow_layout));
  }
 
  // HACK MANIFEST VALIDATION
  if (dependencies_.project && dependencies_.project->hack_manifest.loaded()) {
    std::vector<std::pair<uint32_t, uint32_t>> ranges;
    const auto& manifest = dependencies_.project->hack_manifest;
    const auto& rom_data = rom_->vector();
 
    // 1. Validate Header Range
    if (flags.kSaveRoomHeaders && room.header_dirty()) {
      if (zelda3::kRoomHeaderPointer + 2 < static_cast<int>(rom_data.size())) {
        int header_ptr_table =
            (rom_data[zelda3::kRoomHeaderPointer + 2] << 16) |
            (rom_data[zelda3::kRoomHeaderPointer + 1] << 8) |
            rom_data[zelda3::kRoomHeaderPointer];
        header_ptr_table = yaze::SnesToPc(header_ptr_table);
        int table_offset = header_ptr_table + (room_id * 2);
 
        if (table_offset + 1 < static_cast<int>(rom_data.size())) {
          int address = (rom_data[zelda3::kRoomHeaderPointerBank] << 16) |
                        (rom_data[table_offset + 1] << 8) |
                        rom_data[table_offset];
          int header_location = yaze::SnesToPc(address);
          ranges.emplace_back(header_location, header_location + 14);
        }
      }
      const int message_address = zelda3::kMessagesIdDungeon + (room_id * 2);
      if (message_address >= 0 &&
          message_address + 1 < static_cast<int>(rom_data.size())) {
        ranges.emplace_back(message_address, message_address + 2);
      }
    }
 
    // `ranges` are PC offsets (ROM file offsets). The hack manifest is in SNES
    // address space (LoROM), so convert before analysis.
    const auto write_policy = dependencies_.project->rom_metadata.write_policy;
    RETURN_IF_ERROR(ValidateHackManifestSaveConflicts(
        manifest, write_policy, ranges, absl::StrFormat("room 0x%03X", room_id),
        "DungeonEditorV2", dependencies_.toast_manager));
  }
 
  const auto validate_stream_ranges =
      [&](const std::vector<std::pair<uint32_t, uint32_t>>& ranges)
      -> absl::Status {
    if (!dependencies_.project ||
        !dependencies_.project->hack_manifest.loaded()) {
      return absl::OkStatus();
    }
    return ValidateHackManifestSaveConflicts(
        dependencies_.project->hack_manifest,
        dependencies_.project->rom_metadata.write_policy, ranges,
        absl::StrFormat("room 0x%03X", room_id), "DungeonEditorV2",
        dependencies_.toast_manager);
  };
 
  if (flags.kSaveObjects && room.object_stream_dirty()) {
    ASSIGN_OR_RETURN(auto ranges,
                     room.GetObjectSaveWriteRanges(object_cow_layout.has_value()
                                                       ? &*object_cow_layout
                                                       : nullptr));
    RETURN_IF_ERROR(validate_stream_ranges(ranges));
    auto status = room.SaveObjects(
        object_cow_layout.has_value() ? &*object_cow_layout : nullptr);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save room objects: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveObjects && room.object_stream_header_dirty()) {
    // Object serialization may just have relocated the stream. Query its
    // header destination from the updated ROM immediately before saving it.
    ASSIGN_OR_RETURN(
        auto ranges,
        room.GetObjectStreamHeaderSaveWriteRanges(
            object_cow_layout.has_value() ? &*object_cow_layout : nullptr));
    RETURN_IF_ERROR(validate_stream_ranges(ranges));
    auto status = room.SaveObjectStreamHeader(
        object_cow_layout.has_value() ? &*object_cow_layout : nullptr);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2",
                "Failed to save room object-stream header: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveSprites && room.sprites_dirty()) {
    ASSIGN_OR_RETURN(auto ranges,
                     room.GetSpriteSaveWriteRanges(sprite_cow_layout.has_value()
                                                       ? &*sprite_cow_layout
                                                       : nullptr));
    RETURN_IF_ERROR(validate_stream_ranges(ranges));
    auto status = room.SaveSprites(
        sprite_cow_layout.has_value() ? &*sprite_cow_layout : nullptr);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save room sprites: %s",
                status.message().data());
      return status;
    }
  }
 
  if (flags.kSaveRoomHeaders && room.header_dirty()) {
    auto status = room.SaveRoomHeader();
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Failed to save room header: %s",
                status.message().data());
      return status;
    }
  }
 
  return absl::OkStatus();
}
 
void DungeonEditorV2::SaveAllRooms() {
  auto status = RunWithSaveTransaction([this]() { return Save(); });
  if (status.ok()) {
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show("Applied loaded rooms to ROM buffer",
                                        ToastType::kSuccess);
    }
  } else {
    LOG_ERROR("DungeonEditorV2", "SaveAllRooms failed: %s",
              status.message().data());
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(
          absl::StrFormat("Save all failed: %s", status.message()),
          ToastType::kError);
    }
  }
}
 
}  // namespace yaze::editor