dungeon_editor_v2.cc

Go to the documentation of this file.

// Related header
#include "dungeon_editor_v2.h"
#include "util/i18n/tr.h"
 
// C system headers
#include <cctype>
#include <cstdio>
 
// C++ standard library headers
#include <algorithm>
#include <array>
#include <iterator>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
// Third-party library headers
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "absl/types/span.h"
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/dungeon/dungeon_canvas_viewer.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_coverage_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/commands/shortcut_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/features.h"
#include "core/project.h"
#include "rom/snes.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/draw_routines/draw_routine_registry.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_rom_addresses.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 {
 
auto GraphicsObjectStamp(const zelda3::RoomObject& object) {
  return std::make_tuple(object.id_, object.x_, object.y_, object.size_,
                         object.GetLayerValue(), object.all_bgs_, object.lit_,
                         object.options(), object.block_behavior_layer(),
                         object.torch_reserved_bit());
}
 
bool SameGraphicsEntrance(const DungeonRenderContext& a,
                          const DungeonRenderContext& b) {
  return a.source == b.source && a.entrance_slot == b.entrance_slot &&
         a.effective_blockset() == b.effective_blockset() &&
         a.room_header_blockset == b.room_header_blockset &&
         a.owner_index == b.owner_index && a.owner_id == b.owner_id;
}
 
bool ProjectAdvertisesMinecartTracks(const project::YazeProject* project) {
  return project != nullptr && project->hack_manifest.loaded() &&
         project->hack_manifest.minecart_track_layout().source.has_value();
}
 
// Dungeon tools are hosted by the Workbench inspector's tool drawer. They also
// open standalone from shortcuts and canvas actions, and from the command
// palette.
WindowPresentationPolicy WorkbenchTool(std::string capability = std::string()) {
  return WindowPresentationPolicy::EmbeddedTool(std::move(capability))
      .WithHost("Dungeon Workbench inspector");
}
 
}  // namespace
 
void DungeonEditorV2::SetDependencies(const EditorDependencies& deps) {
  if (minecart_track_editor_panel_)
    minecart_track_editor_panel_->CancelNodePlacement();
  room_viewers_.ForEach([](int, std::unique_ptr<DungeonCanvasViewer>& viewer) {
    if (viewer)
      viewer->CancelMinecartGesture();
  });
  for (auto* viewer :
       {workbench_viewer_.get(), workbench_compare_viewer_.get()}) {
    if (viewer)
      viewer->CancelMinecartGesture();
  }
  minecart_collision_ownership_.clear();
  ++minecart_collision_generation_;
  Editor::SetDependencies(deps);
  room_selector_.SetProject(deps.project);
  if (entrance_navigator_panel_)
    entrance_navigator_panel_->SetProject(deps.project);
  // Dependency rebinding is the project-reload boundary even when the project
  // object is reused in place with a newly loaded manifest.
  InvalidateDungeonRenderContextCensus();
  if (minecart_track_editor_panel_) {
    const absl::Status status =
        minecart_track_editor_panel_->RebindProjectContext(deps.project);
    if (!status.ok()) {
      LOG_WARN("DungeonEditorV2", "Minecart project rebind failed: %s",
               status.message());
    }
    ConfigureMinecartProjectCallbacks();
  }
}
 
void DungeonEditorV2::ConfigureMinecartProjectCallbacks() {
  if (minecart_track_editor_panel_ == nullptr) {
    return;
  }
 
  auto* editor_manager = static_cast<EditorManager*>(dependencies_.custom_data);
  const size_t session_id = dependencies_.session_id;
  minecart_track_editor_panel_->SetActiveRoom(current_room_id_);
  minecart_track_editor_panel_->SetTrackEditCallback(
      [this, editor_manager, session_id](const MinecartTrack& before,
                                         const MinecartTrack& after,
                                         bool move_cart) {
        if (editor_manager &&
            !editor_manager->IsCurrentProjectContextOwnedBySession(session_id))
          return absl::FailedPreconditionError(
              "Activate this dungeon project before editing tracks");
        return ApplyMinecartTrackEdit(before, after, move_cart);
      });
  minecart_track_editor_panel_->SetRailPaletteCallback([this]() {
    return object_selector_panel_ &&
           object_selector_panel_->DrawMinecartPalette();
  });
  minecart_track_editor_panel_->SetNodePlacementCallback(
      [this, editor_manager, session_id](
          int room, int x, int y,
          const MinecartNodeBrush& brush) -> absl::Status {
        if (editor_manager &&
            !editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Activate this dungeon project before placing track nodes");
        }
        return PlaceMinecartNode(room, x, y, brush);
      });
  minecart_track_editor_panel_->SetCollisionStampCallback(
      [this, editor_manager, session_id](
          int room, const zelda3::CustomCollisionMap& expected,
          const MinecartCollisionStamp& stamp) -> absl::Status {
        if (editor_manager &&
            !editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Activate this dungeon project before editing rails");
        }
        return ApplyMinecartCollisionStamp(room, expected, stamp);
      });
  minecart_track_editor_panel_->SetCollisionBatchApplyCallback(
      [this, editor_manager, session_id](
          const std::vector<zelda3::TrackCollisionResult>& preview,
          const zelda3::GeneratorOptions& options) -> absl::Status {
        if (editor_manager != nullptr &&
            !editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart collision apply requires its project context to be "
              "active");
        }
        return ApplyMinecartCollisionBatch(preview, options);
      });
  if (editor_manager == nullptr) {
    minecart_track_editor_panel_->SetProjectChangedCallback({});
    minecart_track_editor_panel_->SetProjectDraftChangedCallback({});
    minecart_track_editor_panel_->SetProjectSaveCallback({});
    return;
  }
 
  minecart_track_editor_panel_->SetProjectChangedCallback(
      [editor_manager, session_id](
          const project::DungeonOverlaySettings& overlay) -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart overlay edit requires its project context to be "
              "active");
        }
        editor_manager->GetCurrentProject()->dungeon_overlay = overlay;
        editor_manager->MarkCurrentProjectDirty();
        return absl::OkStatus();
      });
  minecart_track_editor_panel_->SetProjectDraftChangedCallback(
      [editor_manager, session_id]() -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart overlay draft requires its project context to be "
              "active");
        }
        editor_manager->MarkCurrentProjectDirty();
        return absl::OkStatus();
      });
  minecart_track_editor_panel_->SetProjectSaveCallback(
      [editor_manager, session_id]() -> absl::Status {
        if (!editor_manager->IsCurrentProjectContextOwnedBySession(
                session_id)) {
          return absl::FailedPreconditionError(
              "Minecart project save requires its project context to be "
              "active");
        }
        return editor_manager->SaveProject();
      });
}
 
absl::Status DungeonEditorV2::EnsureMinecartTrackEditorPanel() {
  if (minecart_track_editor_panel_ != nullptr) {
    return absl::OkStatus();
  }
  if (!ProjectAdvertisesMinecartTracks(dependencies_.project)) {
    return absl::FailedPreconditionError(
        "Minecart Tracks requires hack_manifest.minecart_tracks.source");
  }
  if (!core::FeatureFlags::get().kEnableCustomObjects &&
      dependencies_.toast_manager != nullptr) {
    dependencies_.toast_manager->Show(
        "Custom Objects is disabled. Minecart Tracks remains available, but "
        "custom-object ROM writes stay protected until the flag is enabled.",
        ToastType::kWarning);
  }
  if (dependencies_.window_manager != nullptr &&
      dependencies_.window_manager->GetActiveSessionId() !=
          dependencies_.session_id) {
    return absl::FailedPreconditionError(
        "Minecart Tracks can only be registered for the active project "
        "session");
  }
 
  auto minecart_panel = std::make_unique<MinecartTrackEditorPanel>();
  RETURN_IF_ERROR(minecart_panel->SetProject(dependencies_.project));
  minecart_panel->SetRooms(&rooms_);
  minecart_panel->SetRoomNavigationCallback(
      [this](int room_id) { OnRoomSelected(room_id); });
 
  minecart_track_editor_panel_ = minecart_panel.get();
  ConfigureMinecartProjectCallbacks();
  if (dependencies_.window_manager != nullptr) {
    dependencies_.window_manager->RegisterWindowContent(
        std::move(minecart_panel), WorkbenchTool("minecart_tracks"));
  } else {
    owned_minecart_track_editor_panel_ = std::move(minecart_panel);
  }
 
  room_viewers_.ForEach(
      [this](int, std::unique_ptr<DungeonCanvasViewer>& viewer) {
        if (viewer != nullptr) {
          viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
        }
      });
  if (workbench_viewer_ != nullptr) {
    workbench_viewer_->SetMinecartTrackPanel(minecart_track_editor_panel_);
  }
  if (workbench_compare_viewer_ != nullptr) {
    workbench_compare_viewer_->SetMinecartTrackPanel(
        minecart_track_editor_panel_);
  }
  if (workbench_panel_ != nullptr) {
    workbench_panel_->SetEmbeddedToolPanels(
        room_tag_editor_panel_, custom_collision_panel_, water_fill_panel_,
        minecart_track_editor_panel_);
    workbench_panel_->SetObjectCoverageContent(object_coverage_panel_);
  }
 
  return absl::OkStatus();
}
 
void DungeonEditorV2::SynchronizeCustomObjectAssets() {
  const bool custom_objects_enabled =
      core::FeatureFlags::get().kEnableCustomObjects;
  const bool custom_objects_state_changed =
      custom_objects_enabled != observed_custom_objects_enabled_;
  const uint64_t generation =
      zelda3::CustomObjectManager::Get().asset_generation();
  if (generation == observed_custom_object_generation_ &&
      !custom_objects_state_changed) {
    return;
  }
 
  InvalidateDungeonRenderContextCensus();
  if (custom_objects_state_changed) {
    zelda3::DrawRoutineRegistry::Get().RefreshFeatureFlagMappings();
  }
 
  rooms_.ForEachMaterialized([](int, zelda3::Room& room) {
    room.MarkObjectsDirty();
    room.MarkLayoutDirty();
  });
  // Reload Assets also refreshes external sprite art in every session-owned
  // viewer, including hidden room windows and the comparison canvas.
  const auto invalidate_sprite_resources = [](DungeonCanvasViewer* viewer) {
    if (viewer != nullptr) {
      viewer->InvalidateExternalSpriteResources();
    }
  };
  room_viewers_.ForEach(
      [&](int, auto& viewer) { invalidate_sprite_resources(viewer.get()); });
  invalidate_sprite_resources(workbench_viewer_.get());
  invalidate_sprite_resources(workbench_compare_viewer_.get());
  if (object_selector_panel_ != nullptr) {
    object_selector_panel_->object_selector()
        .SynchronizeCustomObjectGeneration();
  }
  observed_custom_object_generation_ = generation;
  observed_custom_objects_enabled_ = custom_objects_enabled;
}
 
namespace {
 
bool IsTransientDungeonRoomWindowId(const std::string& card_id) {
  constexpr const char* kPrefix = "dungeon.room_";
  constexpr size_t kPrefixLength = 13;
  if (card_id.rfind(kPrefix, 0) != 0 || card_id.size() <= kPrefixLength) {
    return false;
  }
  return std::all_of(card_id.begin() + kPrefixLength, card_id.end(),
                     [](unsigned char ch) { return std::isdigit(ch) != 0; });
}
 
bool IsWorkbenchNavigationWindowId(const std::string& card_id) {
  constexpr std::array<const char*, 3> kWorkbenchNavigationPanelIds = {
      DungeonEditorV2::kRoomSelectorId,
      "dungeon.entrance_properties",
      DungeonEditorV2::kRoomMatrixId,
  };
 
  return IsTransientDungeonRoomWindowId(card_id) ||
         std::any_of(kWorkbenchNavigationPanelIds.begin(),
                     kWorkbenchNavigationPanelIds.end(),
                     [&card_id](const char* navigation_id) {
                       return card_id == navigation_id;
                     });
}
 
}  // namespace
 
DungeonEditorV2::DungeonEditorV2(Rom* rom)
    : rom_(rom), room_loader_(rom), room_selector_(rom), rooms_(rom) {
  type_ = EditorType::kDungeon;
  if (rom) {
    dungeon_editor_system_ = zelda3::CreateDungeonEditorSystem(rom);
  }
}
 
DungeonEditorV2::~DungeonEditorV2() {
  if (palette_listener_id_ >= 0) {
    gfx::Arena::Get().UnregisterPaletteListener(palette_listener_id_);
    palette_listener_id_ = -1;
  }
 
  PrepareForSessionTeardown();
}
 
void DungeonEditorV2::PrepareForSessionTeardown() {
  dungeon_render_context_census_shutdown_ = true;
  InvalidateDungeonRenderContextCensus();
  if (room_matrix_panel_) {
    room_matrix_panel_->DetachRuntimeContext();
    room_matrix_panel_ = nullptr;
  }
  // Clear runtime references in panels BEFORE editor-owned rooms and viewers are
  // destroyed. WorkspaceWindowManager panels may outlive this editor session.
  if (room_graphics_panel_) {
    room_graphics_panel_->DetachRuntimeContext();
    room_graphics_panel_ = nullptr;
  }
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->Close();
    object_tile_editor_panel_->SetStandardWritePreflightCallback({});
    object_tile_editor_panel_->SetTilesAppliedCallback({});
    object_tile_editor_panel_ = nullptr;
  }
  if (object_selector_panel_) {
    object_selector_panel_->DetachRuntimeContext();
    object_selector_panel_ = nullptr;
  }
  if (door_editor_panel_) {
    door_editor_panel_->SetCanvasViewer(nullptr);
    door_editor_panel_ = nullptr;
  }
  if (sprite_editor_panel_) {
    sprite_editor_panel_->SetCanvasViewer(nullptr);
    sprite_editor_panel_ = nullptr;
  }
  if (item_editor_panel_) {
    item_editor_panel_->SetCanvasViewer(nullptr);
    item_editor_panel_ = nullptr;
  }
  if (custom_collision_panel_) {
    custom_collision_panel_->SetCanvasViewer(nullptr);
    custom_collision_panel_->SetInteraction(nullptr);
    custom_collision_panel_ = nullptr;
  }
  if (water_fill_panel_) {
    water_fill_panel_->SetCanvasViewer(nullptr);
    water_fill_panel_->SetInteraction(nullptr);
    water_fill_panel_ = nullptr;
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->DetachRuntimeContext();
    minecart_track_editor_panel_ = nullptr;
  }
}
 
absl::Status DungeonEditorV2::RefreshRomBackedState() {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  room_loader_.SetRom(rom_);
  room_loader_.SetGameData(game_data_);
 
  std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>
      refreshed_entrances;
  std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>
      refreshed_spawn_points;
  RETURN_IF_ERROR(room_loader_.LoadRoomEntrances(refreshed_entrances));
  RETURN_IF_ERROR(room_loader_.LoadDungeonSpawnPoints(refreshed_spawn_points));
 
  struct RefreshedRoom {
    int room_id;
    zelda3::Room room;
  };
  std::vector<std::pair<int, bool>> materialized_rooms;
  rooms_.ForEachMaterialized(
      [&materialized_rooms](int room_id, const zelda3::Room& room) {
        materialized_rooms.emplace_back(room_id, room.IsLoaded());
      });
 
  std::vector<RefreshedRoom> refreshed_rooms;
  refreshed_rooms.reserve(materialized_rooms.size());
  for (const auto& [room_id, was_loaded] : materialized_rooms) {
    zelda3::Room refreshed_room;
    if (was_loaded) {
      RETURN_IF_ERROR(room_loader_.LoadRoom(room_id, refreshed_room));
    } else {
      refreshed_room = zelda3::LoadRoomHeaderFromRom(rom_, room_id);
      refreshed_room.SetGameData(game_data_);
    }
    refreshed_rooms.push_back({room_id, std::move(refreshed_room)});
  }
 
  // All ROM reads succeeded. Clear every interaction that can retain indices
  // into Room vectors before replacing any Room contents.
  if (object_selector_panel_) {
    object_selector_panel_->CancelPlacement();
    object_selector_panel_->object_selector().InvalidatePreviewCache();
  }
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->Close();
  }
  if (room_matrix_panel_) {
    room_matrix_panel_->InvalidatePreviewCache();
  }
  auto prepare_viewer = [this](DungeonCanvasViewer* viewer, int room_id) {
    if (viewer) {
      viewer->RefreshRomBackedState(rom_, game_data_, &rooms_, room_id);
    }
  };
  room_viewers_.ForEach(
      [&prepare_viewer](int room_id,
                        std::unique_ptr<DungeonCanvasViewer>& viewer) {
        prepare_viewer(viewer.get(), room_id);
      });
  prepare_viewer(workbench_viewer_.get(), current_room_id_);
  const int compare_room_id =
      workbench_compare_viewer_ &&
              IsValidRoomId(workbench_compare_viewer_->current_room_id())
          ? workbench_compare_viewer_->current_room_id()
          : current_room_id_;
  prepare_viewer(workbench_compare_viewer_.get(), compare_room_id);
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->ClearHistory();
    if (auto object_editor = dungeon_editor_system_->GetObjectEditor()) {
      (void)object_editor->ClearSelection();
      object_editor->ClearHistory();
    }
  }
  undo_manager_.Clear();
  save_transaction_snapshot_.reset();
  pending_undo_ = {};
  minecart_collision_ownership_.clear();
  ++minecart_collision_generation_;
  has_pending_undo_ = false;
  pending_collision_undo_ = {};
  pending_water_fill_undo_ = {};
  pending_entity_undo_ = {};
  pending_selection_undo_ = {};
  pending_swap_ = {};
  pending_workflow_mode_ = {};
  pending_standalone_tool_window_ = {};
  undo_restore_triggered_ping_ = false;
 
  room_selector_.SetRom(rom_);
  rooms_.SetRom(rom_);
  rooms_.SetGameData(game_data_);
  for (auto& refreshed : refreshed_rooms) {
    auto* room = rooms_.GetIfMaterialized(refreshed.room_id);
    if (room) {
      *room = std::move(refreshed.room);
    }
  }
  entrances_ = std::move(refreshed_entrances);
  spawn_points_ = std::move(refreshed_spawn_points);
  InvalidateDungeonRenderContextCensus();
  ReloadWaterFillZones();
 
  room_selector_.set_rooms(&rooms_);
  room_selector_.set_entrances(&entrances_);
  room_selector_.set_spawn_points(&spawn_points_);
  room_selector_.set_current_entrance_id(current_entrance_id_);
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->SetGameData(game_data_);
    auto* current_room = IsValidRoomId(current_room_id_)
                             ? rooms_.GetIfMaterialized(current_room_id_)
                             : nullptr;
    RETURN_IF_ERROR(dungeon_editor_system_->RefreshRomBackedState(
        current_room, current_room_id_));
  }
 
  current_palette_.clear();
  current_palette_group_ = gfx::PaletteGroup{};
  current_palette_id_ = 0;
  current_palette_group_id_ = 0;
  if (auto* current_room = rooms_.GetIfMaterialized(current_room_id_);
      current_room && game_data_ &&
      !game_data_->palette_groups.dungeon_main.empty()) {
    const int resolved_palette_id = current_room->ResolveDungeonPaletteId();
    current_palette_id_ =
        resolved_palette_id >= 0 &&
                resolved_palette_id <
                    static_cast<int>(
                        game_data_->palette_groups.dungeon_main.size())
            ? static_cast<uint64_t>(resolved_palette_id)
            : 0;
    current_palette_group_id_ = current_palette_id_;
    current_palette_ =
        game_data_->palette_groups.dungeon_main[current_palette_id_];
    current_palette_group_ = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
        current_palette_, game_data_);
  }
 
  if (is_loaded_) {
    palette_editor_.Initialize(game_data_);
    palette_editor_.SetDungeonRenderPaletteMode(true);
    palette_editor_.SetCurrentPaletteId(current_palette_id_);
  }
 
  auto bind_viewer = [this](DungeonCanvasViewer* viewer, int room_id) {
    if (!viewer) {
      return;
    }
    RefreshViewerRuntimeContext(viewer, room_id, /*rebind_project=*/true);
    ApplyEntranceRenderContext(room_id);
  };
  room_viewers_.ForEach(
      [&bind_viewer](int room_id,
                     std::unique_ptr<DungeonCanvasViewer>& viewer) {
        bind_viewer(viewer.get(), room_id);
      });
  bind_viewer(workbench_viewer_.get(), current_room_id_);
  bind_viewer(workbench_compare_viewer_.get(), compare_room_id);
 
  if (object_selector_panel_) {
    object_selector_panel_->SetContext({rom_, game_data_});
    object_selector_panel_->SetRooms(&rooms_);
    object_selector_panel_->SetCurrentRoom(current_room_id_);
    object_selector_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (room_graphics_panel_) {
    room_graphics_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (object_tile_editor_panel_) {
    object_tile_editor_panel_->SetCurrentPaletteGroup(current_palette_group_);
  }
  if (room_tag_editor_panel_) {
    room_tag_editor_panel_->SetRooms(&rooms_);
  }
  if (object_coverage_panel_) {
    object_coverage_panel_->SetProject(dependencies_.project);
    object_coverage_panel_->SetRooms(&rooms_);
  }
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->SetRooms(&rooms_);
  }
  if (workbench_panel_) {
    workbench_panel_->SetRom(rom_);
  }
 
  DungeonCanvasViewer* current_viewer = nullptr;
  if (IsWorkbenchWorkflowEnabled()) {
    current_viewer = workbench_viewer_.get();
  } else if (auto* viewer = room_viewers_.Get(current_room_id_)) {
    current_viewer = viewer->get();
  }
  if (current_viewer) {
    SyncPanelsToRoom(current_room_id_);
  }
 
  // This editor-level refresh is used for same-address ROM replacement and
  // revert. Ordinary room navigation refreshes only its canvas viewer.
  selection_clipboard_ = {};
  return absl::OkStatus();
}
 
void DungeonEditorV2::ReloadWaterFillZones() {
  rooms_.ForEachMaterialized([](int, zelda3::Room& room) {
    room.ClearWaterFillZone();
    room.ClearWaterFillDirty();
  });
 
  bool legacy_imported = false;
  const bool water_fill_save_enabled =
      core::FeatureFlags::get().dungeon.kSaveWaterFillZones;
  std::vector<zelda3::WaterFillZoneEntry> zones;
 
  auto zones_or = zelda3::LoadWaterFillTable(rom_);
  if (zones_or.ok()) {
    zones = std::move(zones_or.value());
  } else {
    LOG_WARN("DungeonEditorV2", "WaterFillTable parse failed: %s",
             zones_or.status().message().data());
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(
          absl::StrFormat("WaterFill table parse failed: %s",
                          zones_or.status().message()),
          ToastType::kWarning);
    }
  }
 
  if (zones.empty()) {
    std::string sym_path;
    if (dependencies_.project &&
        !dependencies_.project->symbols_filename.empty()) {
      sym_path = dependencies_.project->GetAbsolutePath(
          dependencies_.project->symbols_filename);
    }
    auto legacy_or = zelda3::LoadLegacyWaterGateZones(rom_, sym_path);
    if (legacy_or.ok()) {
      zones = std::move(legacy_or.value());
      legacy_imported = !zones.empty();
    } else {
      LOG_WARN("DungeonEditorV2", "Legacy water gate import failed: %s",
               legacy_or.status().message().data());
    }
  }
 
  for (const auto& z : zones) {
    if (z.room_id < 0 || z.room_id >= static_cast<int>(rooms_.size())) {
      continue;
    }
    auto& room = rooms_[z.room_id];
    room.set_water_fill_sram_bit_mask(z.sram_bit_mask);
    for (uint16_t off : z.fill_offsets) {
      const int x = static_cast<int>(off % 64);
      const int y = static_cast<int>(off / 64);
      room.SetWaterFillTile(x, y, true);
    }
 
    // A passive legacy import is pending migration only when this project is
    // allowed to write the WaterFill table. Otherwise retain the overlay as
    // read-only reference data without creating unsavable room dirtiness.
    if (!legacy_imported || !water_fill_save_enabled) {
      room.ClearWaterFillDirty();
    }
  }
 
  if (legacy_imported && dependencies_.toast_manager) {
    dependencies_.toast_manager->Show(
        water_fill_save_enabled
            ? "Imported legacy water gate zones (save to write new table)"
            : "Loaded legacy water gate zones read-only (WaterFill saving is "
              "disabled)",
        ToastType::kInfo);
  }
}
 
void DungeonEditorV2::Initialize() {
  if (dependencies_.renderer) {
    renderer_ = dependencies_.renderer;
  }
  room_selector_.SetProject(dependencies_.project);
  const bool rom_changed = dependencies_.rom && dependencies_.rom != rom_;
  if (rom_changed) {
    SetRom(dependencies_.rom);
    // The system owns ROM-backed views; ensure it matches the current ROM.
    dungeon_editor_system_.reset();
  }
  if (rom_ && !dungeon_editor_system_) {
    dungeon_editor_system_ = zelda3::CreateDungeonEditorSystem(rom_);
    if (game_data_) {
      dungeon_editor_system_->SetGameData(game_data_);
    }
  }
 
  // Setup docking class for room windows
  room_window_class_.DockingAllowUnclassed = true;
  room_window_class_.DockingAlwaysTabBar = true;
 
  if (!dependencies_.window_manager)
    return;
  auto* window_manager = dependencies_.window_manager;
  const auto shortcut_hint =
      [this](const char* id,
             std::vector<ImGuiKey> default_keys) -> std::string {
    if (dependencies_.shortcut_manager != nullptr) {
      const std::string live =
          dependencies_.shortcut_manager->GetDisplayString(id);
      if (!live.empty()) {
        return live;
      }
    }
    return PrintShortcut(default_keys);
  };
 
  // Legacy panel IDs persisted in older layouts/settings.
  window_manager->RegisterPanelAlias("dungeon.object_tools", kObjectSelectorId);
  window_manager->RegisterPanelAlias("dungeon.entrances",
                                     "dungeon.entrance_properties");
  window_manager->RegisterPanelAlias(kEntranceListId,
                                     "dungeon.entrance_properties");
 
  // Register panels with WorkspaceWindowManager (no boolean flags - visibility is
  // managed entirely by WorkspaceWindowManager::ShowPanel/HidePanel/IsPanelVisible)
  // No default chord: Ctrl+Shift+W is reserved for Close Session. Toggle via
  // View / Window Browser / command palette instead.
  window_manager->RegisterPanel(
      {.card_id = "dungeon.workbench",
       .display_name = "Dungeon Workbench",
       .window_title = " Dungeon Workbench",
       .icon = ICON_MD_WORKSPACES,
       .category = "Dungeon",
       .workflow_group = "Core",
       .presentation = WindowPresentationPolicy::CoreWorkspace(),
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 5,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon rooms"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomSelectorId,
       .display_name = "Room List",
       .window_title = " Room List",
       .icon = ICON_MD_LIST,
       .category = "Dungeon",
       .workflow_group = "Core",
       .presentation = {.role = WindowPresentationRole::kOptionalPopOut,
                        .default_host = WindowDefaultHost::kWorkspace,
                        .list_in_window_browser = false,
                        .allow_popout = true,
                        .declared = true},
       .shortcut_hint = shortcut_hint(
           "dungeon.open_room_list", {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_L}),
       .shortcut_scope = WindowDescriptor::ShortcutScope::kEditor,
       .visibility_flag = nullptr,
       .priority = 20,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse dungeon rooms"});
 
  window_manager->RegisterPanel(
      {.card_id = "dungeon.entrance_properties",
       .display_name = "Entrances",
       .window_title = " Entrances",
       .icon = ICON_MD_DOOR_FRONT,
       .category = "Dungeon",
       .workflow_group = "Core",
       .presentation = WindowPresentationPolicy::OptionalPopOut(),
       .shortcut_hint =
           shortcut_hint("dungeon.open_entrances",
                         {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_E}),
       .shortcut_scope = WindowDescriptor::ShortcutScope::kEditor,
       .visibility_flag = nullptr,
       .priority = 25,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse and edit dungeon entrances"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomMatrixId,
       .display_name = "Room Matrix",
       .window_title = " Room Matrix",
       .icon = ICON_MD_GRID_VIEW,
       .category = "Dungeon",
       .workflow_group = "Core",
       .presentation = WindowPresentationPolicy::OptionalPopOut(),
       .shortcut_hint = shortcut_hint(
           "dungeon.open_matrix", {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_M}),
       .shortcut_scope = WindowDescriptor::ShortcutScope::kEditor,
       .visibility_flag = nullptr,
       .priority = 30,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to view the room matrix"});
 
  window_manager->RegisterPanel(
      {.card_id = kRoomGraphicsId,
       .display_name = "Room Graphics",
       .window_title = " Room Graphics",
       .icon = ICON_MD_IMAGE,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .presentation = WorkbenchTool(),
       .shortcut_hint =
           shortcut_hint("dungeon.open_room_graphics",
                         {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_G}),
       .shortcut_scope = WindowDescriptor::ShortcutScope::kEditor,
       .visibility_flag = nullptr,
       .priority = 50,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to view room graphics"});
 
  window_manager->RegisterPanel(
      {.card_id = kObjectSelectorId,
       .display_name = "Object Selector",
       .window_title = " Object Selector",
       .icon = ICON_MD_CATEGORY,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .presentation = WorkbenchTool(),
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 60,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to browse dungeon objects"});
 
  window_manager->RegisterPanel(
      {.card_id = kDoorEditorId,
       .display_name = "Door Editor",
       .window_title = " Door Editor",
       .icon = ICON_MD_DOOR_FRONT,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .presentation = WorkbenchTool(),
       .shortcut_hint = "",
       .visibility_flag = nullptr,
       .priority = 69,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon doors"});
 
  window_manager->RegisterPanel(
      {.card_id = kPaletteEditorId,
       .display_name = "Palette Editor",
       .window_title = " Palette Editor",
       .icon = ICON_MD_PALETTE,
       .category = "Dungeon",
       .workflow_group = "Editors",
       .presentation = WorkbenchTool(),
       // Avoid conflicting with the global Command Palette (Ctrl/Cmd+Shift+P).
       .shortcut_hint = shortcut_hint(
           "dungeon.open_palette",
           {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiMod_Alt, ImGuiKey_P}),
       .shortcut_scope = WindowDescriptor::ShortcutScope::kEditor,
       .visibility_flag = nullptr,
       .priority = 70,
       .enabled_condition = [this]() { return rom_ && rom_->is_loaded(); },
       .disabled_tooltip = "Load a ROM to edit dungeon palettes"});
 
  // Show default panels on startup.
  // Workbench mode intentionally suppresses parallel standalone defaults to
  // avoid two competing workflows being open at once.
  SetWorkbenchWorkflowMode(core::FeatureFlags::get().dungeon.kUseWorkbench,
                           /*show_toast=*/false);
 
  // Wire intent-aware callback for double-click / context menu
  room_selector_.SetRoomSelectedWithIntentCallback(
      [this](int room_id, RoomSelectionIntent intent) {
        OnRoomSelected(room_id, intent);
      });
 
  // Register WindowContent instances
  window_manager->RegisterWindowContent(std::make_unique<RoomBrowserContent>(
      &room_selector_, [this](int room_id) { OnRoomSelected(room_id); }));
 
  {
    auto matrix_panel = std::make_unique<RoomMatrixContent>(
        &current_room_id_, &active_rooms_,
        [this](int room_id) { OnRoomSelected(room_id); },
        [this](int old_room, int new_room) {
          SwapRoomInPanel(old_room, new_room);
        },
        &rooms_);
    matrix_panel->SetRoomIntentCallback(
        [this](int room_id, RoomSelectionIntent intent) {
          OnRoomSelected(room_id, intent);
        });
    matrix_panel->SetCensusManifestProvider(
        [this]() -> const core::HackManifest* {
          return dependencies_.project ? &dependencies_.project->hack_manifest
                                       : nullptr;
        });
    room_matrix_panel_ = matrix_panel.get();
    window_manager->RegisterWindowContent(std::move(matrix_panel));
  }
 
  {
    auto workbench = std::make_unique<DungeonWorkbenchContent>(
        &room_selector_, &current_room_id_,
        [this](int room_id) { OnRoomSelected(room_id); },
        [this](int room_id, RoomSelectionIntent intent) {
          OnRoomSelected(room_id, intent);
        },
        [this](int room_id) {
          auto status = SaveRoom(room_id);
          if (!status.ok()) {
            LOG_ERROR("DungeonEditorV2", "Apply Room failed: %s",
                      status.message().data());
            if (dependencies_.toast_manager) {
              dependencies_.toast_manager->Show(
                  absl::StrFormat("Apply Room failed: %s", status.message()),
                  ToastType::kError);
            }
            return;
          }
          if (dependencies_.toast_manager) {
            dependencies_.toast_manager->Show("Applied room to ROM buffer",
                                              ToastType::kSuccess);
          }
        },
        [this]() { SaveAllRooms(); }, [this]() { return GetWorkbenchViewer(); },
        [this](int room_id) { return GetWorkbenchCompareViewer(room_id); },
        [this]() -> const std::deque<int>& { return recent_rooms_; },
        [this](int room_id) {
          recent_rooms_.erase(
              std::remove(recent_rooms_.begin(), recent_rooms_.end(), room_id),
              recent_rooms_.end());
        },
        [this](bool enabled) { QueueWorkbenchWorkflowMode(enabled); }, rom_);
    workbench_panel_ = workbench.get();
    workbench_panel_->SetPrimaryCanvasDrawnCallback(
        [this](DungeonCanvasViewer& viewer) {
          ConsumeRoomCanvasDeleteShortcut(viewer);
        });
    workbench_panel_->SetUndoRedoProvider(
        [this]() { return undo_manager_.CanUndo(); },
        [this]() { return undo_manager_.CanRedo(); },
        [this]() { Undo().IgnoreError(); }, [this]() { Redo().IgnoreError(); },
        [this]() { return undo_manager_.GetUndoDescription(); },
        [this]() { return undo_manager_.GetRedoDescription(); },
        [this]() { return static_cast<int>(undo_manager_.UndoStackSize()); });
    workbench_panel_->SetStandaloneToolCallbacks(
        [window_manager](const std::string& window_id) {
          const size_t session_id = window_manager->GetActiveSessionId();
          return window_manager->IsWindowOpen(session_id, window_id);
        },
        [this, window_manager](const std::string& window_id) {
          if (window_id.empty()) {
            return false;
          }
          pending_standalone_tool_window_.session_id =
              window_manager->GetActiveSessionId();
          pending_standalone_tool_window_.window_id = window_id;
          pending_standalone_tool_window_.pending = true;
          return true;
        });
    workbench_panel_->SetOpenKeyboardShortcutsCallback(
        [window_manager]() { window_manager->TriggerShowShortcuts(); });
    workbench_panel_->SetPitDamageTableProvider(
        [this]() {
          return game_data_ ? &game_data_->pit_damage_table : nullptr;
        },
        [this]() { InvalidateConnectedRoomGraphs(); });
    window_manager->RegisterWindowContent(std::move(workbench));
  }
 
  {
    auto entrances_panel = std::make_unique<DungeonEntrancesPanel>(
        &entrances_, &spawn_points_, &current_entrance_id_,
        [this](int entrance_id) { OnEntranceSelected(entrance_id); });
    entrances_panel->SetProject(dependencies_.project);
    entrances_panel->SetGraphicsPreview(
        [this]() {
          return ResolveDungeonRenderContextForRoom(current_room_id_);
        },
        [this]() { return automatic_entrance_preview_; },
        [this](int slot) { SetGraphicsPreviewEntrance(slot); });
    ConfigureEntrancePropertyEditCallbacks(entrances_panel.get());
    entrance_navigator_panel_ = entrances_panel.get();
    window_manager->RegisterWindowContent(std::move(entrances_panel));
  }
  if (workbench_panel_) {
    workbench_panel_->SetNavigationPanels(room_matrix_panel_,
                                          entrance_navigator_panel_);
    workbench_panel_->SetRoomRenderContextCallback(
        [this](int room_id) { ApplyEntranceRenderContext(room_id); });
    workbench_panel_->SetRoomLabelEditCallback(
        [this](int room_id, std::optional<std::string> label) {
          return ApplyRoomLabelEdit(room_id, std::move(label));
        });
  }
  if (room_matrix_panel_) {
    room_matrix_panel_->SetPreviewEntranceBlocksetResolver([this](int room_id) {
      return ResolveSelectedEntranceBlocksetForRoom(room_id);
    });
  }
 
  // Note: RoomGraphicsContent and PaletteEditorContent are registered
  // in Load() after their dependencies (renderer_, palette_editor_) are initialized
}
 
absl::Status DungeonEditorV2::Load() {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Initialize ObjectDimensionTable so DimensionService's fallback path works.
  // DimensionService::Get() queries this table internally but has no Load API.
  auto& dim_table = zelda3::ObjectDimensionTable::Get();
  if (!dim_table.IsLoaded()) {
    RETURN_IF_ERROR(dim_table.LoadFromRom(rom_));
  }
 
  RETURN_IF_ERROR(room_loader_.LoadRoomEntrances(entrances_));
  RETURN_IF_ERROR(room_loader_.LoadDungeonSpawnPoints(spawn_points_));
  InvalidateDungeonRenderContextCensus();
 
  if (!game_data()) {
    return absl::FailedPreconditionError("GameData not available");
  }
  auto dungeon_main_pal_group = game_data()->palette_groups.dungeon_main;
  current_palette_ = dungeon_main_pal_group[current_palette_group_id_];
  current_palette_group_ = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
      current_palette_, game_data());
 
  room_selector_.set_rooms(&rooms_);
  room_selector_.set_entrances(&entrances_);
  room_selector_.set_spawn_points(&spawn_points_);
  room_selector_.set_current_entrance_id(current_entrance_id_);
  room_selector_.set_active_rooms(active_rooms_);
  room_selector_.SetRoomSelectedCallback(
      [this](int room_id) { OnRoomSelected(room_id); });
  room_selector_.SetRoomSelectedWithIntentCallback(
      [this](int room_id, RoomSelectionIntent intent) {
        OnRoomSelected(room_id, intent);
      });
  room_selector_.SetEntranceSelectedCallback(
      [this](int entrance_id) { OnEntranceSelected(entrance_id); });
 
  // Canvas viewers are lazily created in GetViewerForRoom
 
  if (game_data()) {
    gfx::PaletteManager::Get().Initialize(game_data());
  } else {
    gfx::PaletteManager::Get().Initialize(rom_);
  }
 
  palette_editor_.Initialize(game_data());
  palette_editor_.SetDungeonRenderPaletteMode(true);
 
  // Register panels that depend on initialized state (renderer, palette_editor_)
  if (dependencies_.window_manager) {
    auto graphics_panel = std::make_unique<RoomGraphicsContent>(
        &current_room_id_, &rooms_, renderer_);
    graphics_panel->SetAssignmentCallback(
        [this](int room, int slot, int sheet) {
          return EditRoomGraphicsSheet(room, slot, sheet);
        });
    graphics_panel->SetUsageCallback(
        [this](int roomset) { return GetRoomGraphicsUsage(roomset); });
    room_graphics_panel_ = graphics_panel.get();
    dependencies_.window_manager->RegisterWindowContent(
        std::move(graphics_panel), WorkbenchTool());
    auto palette_panel =
        std::make_unique<PaletteEditorContent>(&palette_editor_);
    palette_editor_panel_ = palette_panel.get();
    dependencies_.window_manager->RegisterWindowContent(
        std::move(palette_panel), WorkbenchTool());
  }
 
  dungeon_editor_system_ = std::make_unique<zelda3::DungeonEditorSystem>(rom_);
  (void)dungeon_editor_system_->Initialize();
  dungeon_editor_system_->SetCurrentRoom(current_room_id_);
 
  // Initialize browse-only object selector and the dedicated object editor.
  auto object_selector = std::make_unique<ObjectSelectorContent>(
      rom_, nullptr, dungeon_editor_system_->GetObjectEditor(),
      dependencies_.toast_manager);
 
  // Wire up object change callback to trigger room re-rendering
  dungeon_editor_system_->GetObjectEditor()->SetObjectChangedCallback(
      [this](size_t /*object_index*/, const zelda3::RoomObject& /*object*/) {
        if (current_room_id_ >= 0 && current_room_id_ < (int)rooms_.size()) {
          rooms_[current_room_id_].RenderRoomGraphics();
        }
      });
 
  // Set rooms and initial palette group for correct preview rendering
  object_selector->SetRooms(&rooms_);
  object_selector->SetCurrentPaletteGroup(current_palette_group_);
 
  auto open_workbench_selection_inspector = [this]() {
    if (workbench_panel_) {
      workbench_panel_->FocusSelectionInspector();
    }
    OpenWindow("dungeon.workbench");
  };
 
  object_selector->SetOpenObjectEditorCallback(
      open_workbench_selection_inspector);
 
  // Keep raw pointers for later access
  object_selector_panel_ = object_selector.get();
 
  auto jump_to_reciprocal_door = [this](int neighbor_room_id,
                                        size_t door_index) {
    if (neighbor_room_id < 0 ||
        neighbor_room_id >= static_cast<int>(rooms_.size())) {
      return;
    }
    OnRoomSelected(neighbor_room_id, true);
    if (auto* viewer = GetViewerForRoom(neighbor_room_id)) {
      // Bind before selecting; see NavigateToPlacedObject.
      viewer->object_interaction().SetCurrentRoom(&rooms_, neighbor_room_id);
      viewer->object_interaction()
          .entity_coordinator()
          .door_handler()
          .SelectDoor(door_index);
    }
  };
  auto door_editor = std::make_unique<DoorEditorContent>();
  door_editor->SetRooms(&rooms_);
  door_editor->SetOpenSelectionInspectorCallback(
      open_workbench_selection_inspector);
  door_editor->SetJumpToReciprocalDoorCallback(jump_to_reciprocal_door);
  door_editor_panel_ = door_editor.get();
 
  // Propagate game_data to the object editor panel if available
  if (game_data()) {
    object_selector_panel_->SetGameData(game_data());
  }
 
  // Room-scoped utility tools use the Workbench inspector by default, while the
  // same WindowContent instances remain available to users who prefer floating
  // windows. OpenTool keeps one presentation owner at a time so one content
  // instance is never drawn in both places during the same frame.
  auto custom_collision_panel =
      std::make_unique<CustomCollisionPanel>(nullptr, nullptr);
  custom_collision_panel_ = custom_collision_panel.get();
 
  auto water_fill_panel = std::make_unique<WaterFillPanel>(nullptr, nullptr);
  water_fill_panel_ = water_fill_panel.get();
 
  auto room_tag_panel = std::make_unique<RoomTagEditorPanel>();
  room_tag_panel->SetProject(dependencies_.project);
  room_tag_panel->SetRooms(&rooms_);
  room_tag_panel->SetCurrentRoomId(current_room_id_);
  room_tag_panel->SetMetadataEditCallback(
      [this](int room_id, const RoomMetadataEdit& edit) {
        return EditRoomMetadata(room_id, edit);
      });
  room_tag_editor_panel_ = room_tag_panel.get();
 
  auto object_coverage_panel = CreateObjectCoveragePanel();
  object_coverage_panel_ = object_coverage_panel.get();
 
  // Register the ObjectSelectorContent directly (it inherits from WindowContent)
  // Panel manager takes ownership
  if (dependencies_.window_manager) {
    dependencies_.window_manager->RegisterWindowContent(
        std::move(object_selector), WorkbenchTool());
    dependencies_.window_manager->RegisterWindowContent(std::move(door_editor),
                                                        WorkbenchTool());
 
    // Register sprite and item editor panels with canvas viewer = nullptr
    // They will get the viewer reference in OnRoomSelected when a room is selected
    auto sprite_panel = std::make_unique<SpriteEditorPanel>(&current_room_id_,
                                                            &rooms_, nullptr);
    sprite_panel->SetOpenSelectionInspectorCallback(
        open_workbench_selection_inspector);
    sprite_editor_panel_ = sprite_panel.get();
    dependencies_.window_manager->RegisterWindowContent(std::move(sprite_panel),
                                                        WorkbenchTool());
 
    auto item_panel =
        std::make_unique<ItemEditorPanel>(&current_room_id_, &rooms_, nullptr);
    item_panel->SetOpenSelectionInspectorCallback(
        open_workbench_selection_inspector);
    item_editor_panel_ = item_panel.get();
    dependencies_.window_manager->RegisterWindowContent(std::move(item_panel),
                                                        WorkbenchTool());
 
    dependencies_.window_manager->RegisterWindowContent(
        std::move(custom_collision_panel), WorkbenchTool());
    dependencies_.window_manager->RegisterWindowContent(
        std::move(water_fill_panel), WorkbenchTool());
    dependencies_.window_manager->RegisterWindowContent(
        std::move(room_tag_panel), WorkbenchTool());
    dependencies_.window_manager->RegisterWindowContent(
        std::move(object_coverage_panel),
        WindowPresentationPolicy::Diagnostic().WithHost(
            "Canvas context menu > Check in Object Coverage"));
    // Object Tile Editor Panel
    {
      auto tile_editor_panel =
          std::make_unique<ObjectTileEditorPanel>(renderer_, rom_);
      tile_editor_panel->SetCurrentPaletteGroup(current_palette_group_);
      tile_editor_panel->SetStandardWritePreflightCallback(
          [this](const std::vector<std::pair<uint32_t, uint32_t>>& ranges) {
            if (ranges.empty() || dependencies_.project == nullptr ||
                !dependencies_.project->hack_manifest.loaded()) {
              return absl::OkStatus();
            }
            return ValidateHackManifestSaveConflicts(
                dependencies_.project->hack_manifest,
                dependencies_.project->rom_metadata.write_policy, ranges,
                "dungeon object tile data", "ObjectTileEditorPanel",
                dependencies_.toast_manager);
          });
      tile_editor_panel->SetTilesAppliedCallback([this]() {
        if (object_selector_panel_) {
          object_selector_panel_->object_selector().InvalidatePreviewCache();
        }
      });
 
      object_tile_editor_panel_ = tile_editor_panel.get();
      dependencies_.window_manager->RegisterWindowContent(
          std::move(tile_editor_panel),
          WorkbenchTool().WithHost(
              "Object navigator or canvas selection menu > Edit tiles"));
    }
 
    // Wire fixed-slot custom-object management actions to their workspace
    // windows.
    if (object_selector_panel_) {
      object_selector_panel_->object_selector().SetEditObjectTilesCallback(
          [this](int room_id, const zelda3::RoomObject& object) {
            return OpenObjectTileEditorForObject(room_id, object);
          });
      object_selector_panel_->object_selector().SetTileEditorPanel(
          object_tile_editor_panel_);
      object_selector_panel_->object_selector().SetOpenTileEditorWindowCallback(
          [this]() {
            return dependencies_.window_manager != nullptr &&
                   object_tile_editor_panel_ != nullptr &&
                   dependencies_.window_manager->OpenWindow(
                       object_tile_editor_panel_->GetId());
          });
      object_selector_panel_->object_selector()
          .SetOpenMinecartEditorWindowCallback([this]() {
            return dependencies_.window_manager != nullptr &&
                   minecart_track_editor_panel_ != nullptr &&
                   dependencies_.window_manager->OpenWindow(
                       minecart_track_editor_panel_->GetId());
          });
    }
 
    // Overlay Manager Panel
    {
      auto overlay_panel = std::make_unique<OverlayManagerPanel>();
      overlay_manager_panel_ = overlay_panel.get();
      dependencies_.window_manager->RegisterWindowContent(
          std::move(overlay_panel),
          WorkbenchTool().WithHost("Command palette"));
    }
 
  } else {
    owned_object_selector_panel_ = std::move(object_selector);
    owned_door_editor_panel_ = std::move(door_editor);
    owned_custom_collision_panel_ = std::move(custom_collision_panel);
    owned_water_fill_panel_ = std::move(water_fill_panel);
    owned_room_tag_editor_panel_ = std::move(room_tag_panel);
    owned_object_coverage_panel_ = std::move(object_coverage_panel);
  }
 
  if (ProjectAdvertisesMinecartTracks(dependencies_.project)) {
    RETURN_IF_ERROR(EnsureMinecartTrackEditorPanel());
  }
 
  palette_editor_.SetOnDungeonPaletteChanged(
      [this](gui::DungeonPaletteChange change) {
        HandleDungeonPaletteChanged(change);
      });
  RegisterPaletteListener();
 
  // Oracle of Secrets: load editor-authored water fill zones (best-effort).
  ReloadWaterFillZones();
 
  if (workbench_panel_) {
    workbench_panel_->SetEmbeddedToolPanels(
        room_tag_editor_panel_, custom_collision_panel_, water_fill_panel_,
        minecart_track_editor_panel_);
    workbench_panel_->SetObjectCoverageContent(object_coverage_panel_);
    workbench_panel_->SetEmbeddedEditorPanels(
        object_selector_panel_, door_editor_panel_, sprite_editor_panel_,
        item_editor_panel_, room_graphics_panel_, palette_editor_panel_);
  }
 
  is_loaded_ = true;
  return absl::OkStatus();
}
 
void DungeonEditorV2::RegisterPaletteListener() {
  if (palette_listener_id_ >= 0) {
    return;
  }
 
  palette_listener_id_ = gfx::Arena::Get().RegisterPaletteListener(
      [this](const std::string& group_name, int palette_index) {
        HandleArenaPaletteChanged(group_name, palette_index);
      });
}
 
void DungeonEditorV2::HandleArenaPaletteChanged(const std::string& group_name,
                                                int palette_index) {
  if (!gfx::PaletteManager::Get().IsManaging(game_data_)) {
    return;
  }
 
  if (group_name == "hud") {
    HandleDungeonPaletteChanged({static_cast<int>(current_palette_id_),
                                 gui::DungeonRenderPaletteSource::kHud});
  } else if (group_name == "dungeon_main") {
    HandleDungeonPaletteChanged(
        {palette_index, gui::DungeonRenderPaletteSource::kDungeonMain});
  }
}
 
void DungeonEditorV2::HandleDungeonPaletteChanged(
    gui::DungeonPaletteChange change) {
  InvalidateDungeonPaletteUsers(change);
 
  std::array<bool, zelda3::kNumberOfRooms> rendered_rooms{};
  auto render_once = [this, &rendered_rooms](int room_id) {
    if (room_id < 0 || room_id >= static_cast<int>(rooms_.size()) ||
        room_id >= static_cast<int>(rendered_rooms.size()) ||
        rendered_rooms[room_id]) {
      return;
    }
    rooms_[room_id].RenderRoomGraphics();
    rendered_rooms[room_id] = true;
  };
 
  for (int i = 0; i < active_rooms_.Size; i++) {
    render_once(active_rooms_[i]);
  }
 
  render_once(current_room_id_);
 
  auto apply_palette = [](DungeonCanvasViewer* viewer, uint64_t palette_id,
                          const gfx::PaletteGroup& palette_group,
                          bool force_shared_palette_refresh) {
    if (!viewer) {
      return;
    }
    viewer->SetCurrentPaletteId(palette_id);
    viewer->SetCurrentPaletteGroup(
        palette_group,
        /*force_refresh=*/force_shared_palette_refresh &&
            viewer->object_interaction().IsObjectLoaded());
  };
 
  if (current_room_id_ >= 0 &&
      current_room_id_ < static_cast<int>(rooms_.size()) && game_data()) {
    const bool force_shared_palette_refresh =
        change.source == gui::DungeonRenderPaletteSource::kHud;
    auto& dungeon_main_pal_group = game_data()->palette_groups.dungeon_main;
    if (current_palette_id_ <
        static_cast<uint64_t>(dungeon_main_pal_group.size())) {
      current_palette_group_id_ = current_palette_id_;
      current_palette_ = dungeon_main_pal_group[current_palette_id_];
      current_palette_group_ =
          zelda3::BuildDungeonRenderPaletteGroupFromGameData(current_palette_,
                                                             game_data());
      apply_palette(workbench_viewer_.get(), current_palette_id_,
                    current_palette_group_, force_shared_palette_refresh);
      apply_palette(workbench_compare_viewer_.get(), current_palette_id_,
                    current_palette_group_, force_shared_palette_refresh);
      room_viewers_.ForEach([this, change, &apply_palette,
                             &dungeon_main_pal_group, &render_once,
                             force_shared_palette_refresh](
                                int room_id,
                                std::unique_ptr<DungeonCanvasViewer>& viewer) {
        if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
          return;
        }
        const int palette_id = rooms_[room_id].ResolveDungeonPaletteId();
        if (palette_id < 0 ||
            palette_id >= static_cast<int>(dungeon_main_pal_group.size())) {
          return;
        }
        if (change.source == gui::DungeonRenderPaletteSource::kDungeonMain &&
            change.palette_id >= 0 && palette_id != change.palette_id) {
          return;
        }
        const auto room_palette_group =
            zelda3::BuildDungeonRenderPaletteGroupFromGameData(
                dungeon_main_pal_group.palette_ref(palette_id), game_data());
        if (viewer && viewer->object_interaction().IsObjectLoaded()) {
          render_once(room_id);
        }
        apply_palette(viewer.get(), palette_id, room_palette_group,
                      force_shared_palette_refresh);
      });
      if (object_selector_panel_) {
        object_selector_panel_->SetCurrentPaletteGroup(current_palette_group_);
      }
      if (room_graphics_panel_) {
        room_graphics_panel_->SetCurrentPaletteGroup(current_palette_group_);
      }
    }
  }
 
  // Tile edits remain bound to their original room even when the active room
  // changes or closes. Refresh that room's palette without reopening its session.
  if (!object_tile_editor_panel_ || !object_tile_editor_panel_->IsOpen() ||
      !game_data()) {
    return;
  }
  const int tile_room_id = object_tile_editor_panel_->current_room_id();
  const auto* tile_room = rooms_.GetIfLoaded(tile_room_id);
  if (!tile_room) {
    return;
  }
  const int tile_palette_id = tile_room->ResolveDungeonPaletteId();
  const auto& dungeon_palettes = game_data()->palette_groups.dungeon_main;
  if (tile_palette_id < 0 ||
      tile_palette_id >= static_cast<int>(dungeon_palettes.size()) ||
      (change.source == gui::DungeonRenderPaletteSource::kDungeonMain &&
       change.palette_id >= 0 && tile_palette_id != change.palette_id)) {
    return;
  }
  object_tile_editor_panel_->SetCurrentPaletteGroupForRoom(
      tile_room_id,
      zelda3::BuildDungeonRenderPaletteGroupFromGameData(
          dungeon_palettes.palette_ref(tile_palette_id), game_data()));
}
 
void DungeonEditorV2::InvalidateDungeonPaletteUsers(
    gui::DungeonPaletteChange change) {
  if (change.source == gui::DungeonRenderPaletteSource::kHud ||
      change.palette_id < 0) {
    rooms_.ForEachMaterialized(
        [](int, zelda3::Room& room) { room.MarkGraphicsDirty(); });
    return;
  }
 
  // Editing palette bytes does not change a room header, so the room's normal
  // property cache cannot detect this dependency change. Mark every cached
  // room that resolves to the edited concrete palette; inactive rooms will
  // redraw lazily the next time they are shown.
  rooms_.ForEachMaterialized([change](int, zelda3::Room& room) {
    if (room.ResolveDungeonPaletteId() == change.palette_id) {
      room.MarkGraphicsDirty();
    }
  });
}
 
absl::Status DungeonEditorV2::Update() {
  SynchronizeCustomObjectAssets();
  ProcessPendingWorkflowMode();
  ProcessPendingStandaloneToolWindow();
  ExpireStaleRoomCanvasDeleteShortcut();
 
  const auto& theme = AgentUI::GetTheme();
  if (room_window_class_.ClassId == 0) {
    room_window_class_.ClassId = ImGui::GetID("DungeonRoomClass");
  }
 
  if (!is_loaded_) {
    gui::PanelWindow loading_card("Dungeon Editor Loading", ICON_MD_CASTLE);
    loading_card.SetDefaultSize(400, 200);
    if (loading_card.Begin()) {
      ImGui::TextColored(theme.text_secondary_gray,
                         tr("Loading dungeon data..."));
      ImGui::TextWrapped(
          tr("Independent editor cards will appear once ROM data is loaded."));
    }
    loading_card.End();
    return absl::OkStatus();
  }
 
  // Poll the async ownership census and propagate a newly resolved entrance
  // context before any room or graphics surface draws this frame.
  ApplyEntranceRenderContext(current_room_id_);
 
  if (!IsWorkbenchWorkflowEnabled() || active_rooms_.Size > 0) {
    DrawRoomPanels();
  }
 
  // Process any pending room swaps after all drawing is complete
  // This prevents ImGui state corruption from modifying collections mid-frame
  ProcessPendingSwap();
 
  return absl::OkStatus();
}
 
bool DungeonEditorV2::CanHandleDungeonNavigationShortcut() const {
  if (ImGui::GetCurrentContext() == nullptr) {
    return false;
  }
  bool canvas_owns_focus = false;
  room_viewers_.ForEach(
      [&canvas_owns_focus](int,
                           const std::unique_ptr<DungeonCanvasViewer>& viewer) {
        canvas_owns_focus =
            canvas_owns_focus ||
            (viewer != nullptr && viewer->OwnsRoomNavigationShortcutFocus());
      });
  canvas_owns_focus =
      canvas_owns_focus ||
      (workbench_viewer_ != nullptr &&
       workbench_viewer_->OwnsRoomNavigationShortcutFocus()) ||
      (workbench_compare_viewer_ != nullptr &&
       workbench_compare_viewer_->OwnsRoomNavigationShortcutFocus());
  const bool navigator_owns_focus =
      (room_matrix_panel_ != nullptr &&
       room_matrix_panel_->OwnsNavigationShortcutFocus()) ||
      (entrance_navigator_panel_ != nullptr &&
       entrance_navigator_panel_->OwnsNavigationShortcutFocus());
  return canvas_owns_focus || navigator_owns_focus;
}
 
bool DungeonEditorV2::NavigateToAdjacentRoom(
    DungeonRoomNavigationDirection direction) {
  constexpr int kColumns = 16;
  int next_room = -1;
  switch (direction) {
    case DungeonRoomNavigationDirection::kUp:
      if (current_room_id_ >= kColumns) {
        next_room = current_room_id_ - kColumns;
      }
      break;
    case DungeonRoomNavigationDirection::kDown:
      if (IsValidRoomId(current_room_id_ + kColumns)) {
        next_room = current_room_id_ + kColumns;
      }
      break;
    case DungeonRoomNavigationDirection::kLeft:
      if (current_room_id_ % kColumns > 0) {
        next_room = current_room_id_ - 1;
      }
      break;
    case DungeonRoomNavigationDirection::kRight:
      if (current_room_id_ % kColumns < kColumns - 1 &&
          IsValidRoomId(current_room_id_ + 1)) {
        next_room = current_room_id_ + 1;
      }
      break;
  }
  if (next_room < 0) {
    return false;
  }
  if (IsWorkbenchWorkflowEnabled()) {
    OnRoomSelected(next_room, /*request_focus=*/false);
  } else {
    SwapRoomInPanel(current_room_id_, next_room);
  }
  return true;
}
 
bool DungeonEditorV2::CycleRoomSelection(int direction) {
  if (direction == 0) {
    return false;
  }
  if (IsWorkbenchWorkflowEnabled()) {
    if (recent_rooms_.size() <= 1) {
      return false;
    }
    const auto current =
        std::find(recent_rooms_.begin(), recent_rooms_.end(), current_room_id_);
    if (current == recent_rooms_.end()) {
      return false;
    }
    const int current_index =
        static_cast<int>(std::distance(recent_rooms_.begin(), current));
    const int count = static_cast<int>(recent_rooms_.size());
    const int next_index =
        (current_index + (direction > 0 ? 1 : -1) + count) % count;
    OnRoomSelected(recent_rooms_[next_index]);
    return true;
  }
 
  if (active_rooms_.size() <= 1) {
    return false;
  }
  int current_index = -1;
  for (int index = 0; index < active_rooms_.size(); ++index) {
    if (active_rooms_[index] == current_room_id_) {
      current_index = index;
      break;
    }
  }
  if (current_index < 0) {
    return false;
  }
  const int count = active_rooms_.size();
  const int next_index =
      (current_index + (direction > 0 ? 1 : -1) + count) % count;
  OnRoomSelected(active_rooms_[next_index]);
  return true;
}
 
bool DungeonEditorV2::CycleObjectSelection(int direction) {
  if (direction == 0 || !IsValidRoomId(current_room_id_)) {
    return false;
  }
  const auto* room = rooms_.GetIfLoaded(current_room_id_);
  if (!room || room->GetTileObjects().empty()) {
    return false;
  }
  auto* viewer = GetViewerForRoom(current_room_id_);
  if (!viewer || viewer->rooms() != &rooms_ ||
      viewer->current_room_id() != current_room_id_ ||
      !viewer->IsObjectInteractionEnabled() || viewer->header_read_only()) {
    return false;
  }
  auto& interaction = viewer->object_interaction();
  const auto* context =
      interaction.entity_coordinator().tile_handler().context();
  if (!context || context->current_room_id != current_room_id_) {
    return false;
  }
  const auto selected = interaction.GetSelectedObjectIndices();
  const auto& objects = room->GetTileObjects();
  const size_t count = objects.size();
  const size_t current = selected.empty() ? 0 : selected.front();
  const size_t next =
      ((current < count ? current : 0) + (direction > 0 ? 1 : count - 1)) %
      count;
  interaction.SetSelectedObjects({next});
  viewer->ScrollToTile(objects[next].x_, objects[next].y_);
  return true;
}
 
int DungeonEditorV2::LoadedRoomCount() const {
  return rooms_.LoadedCount();
}
 
int DungeonEditorV2::PendingRoomCount() const {
  int count = 0;
  rooms_.ForEachMaterialized([&count](int, const zelda3::Room& room) {
    if (room.HasUnsavedChanges()) {
      ++count;
    }
  });
  return count;
}
 
bool DungeonEditorV2::HasPendingRoomChanges() const {
  return PendingRoomCount() > 0;
}
 
bool DungeonEditorV2::HasUnpublishedMinecartTrackChanges() const {
  return minecart_track_editor_panel_ != nullptr &&
         minecart_track_editor_panel_->HasUnpublishedChanges();
}
 
bool DungeonEditorV2::HasPendingDungeonChanges() const {
  if (HasUnpublishedMinecartTrackChanges()) {
    return true;
  }
  if (object_tile_editor_panel_ != nullptr &&
      object_tile_editor_panel_->HasUnappliedChanges()) {
    return true;
  }
  if (HasPendingRoomChanges()) {
    return true;
  }
  if (std::any_of(entrances_.begin(), entrances_.end(),
                  [](const zelda3::RoomEntrance& entrance) {
                    return entrance.dirty();
                  })) {
    return true;
  }
  if (std::any_of(spawn_points_.begin(), spawn_points_.end(),
                  [](const zelda3::DungeonSpawnPoint& spawn) {
                    return spawn.dirty();
                  })) {
    return true;
  }
  return game_data_ != nullptr && game_data_->pit_damage_table.dirty();
}
 
bool DungeonEditorV2::HasPendingProjectDraftChanges() const {
  return minecart_track_editor_panel_ != nullptr &&
         minecart_track_editor_panel_->HasPendingProjectDraftChanges();
}
 
absl::Status DungeonEditorV2::PrepareProjectSave() {
  return minecart_track_editor_panel_ != nullptr
             ? minecart_track_editor_panel_->PrepareProjectSave()
             : absl::OkStatus();
}
 
bool DungeonEditorV2::CurrentRoomHasPendingChanges() const {
  if (current_room_id_ < 0 ||
      current_room_id_ >= static_cast<int>(rooms_.size())) {
    return false;
  }
  if (const auto* room = rooms_.GetIfMaterialized(current_room_id_)) {
    return room->HasUnsavedChanges();
  }
  return false;
}
 
bool DungeonEditorV2::IsWorkbenchWorkflowEnabled() const {
  if (!core::FeatureFlags::get().dungeon.kUseWorkbench) {
    return false;
  }
  if (!dependencies_.window_manager) {
    return true;
  }
  return dependencies_.window_manager->IsWindowOpen("dungeon.workbench");
}
 
void DungeonEditorV2::SetWorkbenchWorkflowMode(bool enabled, bool show_toast) {
  auto* window_manager = dependencies_.window_manager;
  if (!window_manager) {
    return;
  }
 
  const size_t session_id = window_manager->GetActiveSessionId();
  const bool was_enabled = IsWorkbenchWorkflowEnabled();
 
  if (enabled) {
    window_manager->OpenWindow(session_id, "dungeon.workbench");
 
    if (!was_enabled) {
      workbench_suspended_navigation_window_ids_.clear();
 
      // The Workbench replaces room navigation, but not standalone editing
      // tools. Keep those tool windows open so user-owned HM/ZS-style layouts
      // survive workflow switches; the embedded inspector yields ownership to
      // any standalone tool that is already visible.
      for (const auto& descriptor :
           window_manager->GetWindowsInCategory(session_id, "Dungeon")) {
        const std::string& card_id = descriptor.card_id;
        if (!IsWorkbenchNavigationWindowId(card_id) ||
            !window_manager->IsWindowOpen(session_id, card_id) ||
            window_manager->IsWindowPinned(session_id, card_id)) {
          continue;
        }
        workbench_suspended_navigation_window_ids_.push_back(card_id);
        window_manager->CloseWindow(session_id, card_id);
      }
    }
  } else {
    window_manager->CloseWindow(session_id, "dungeon.workbench");
    window_manager->OpenWindow(session_id, kRoomMatrixId);
    window_manager->OpenWindow(session_id, "dungeon.entrance_properties");
    if (current_room_id_ >= 0) {
      ShowRoomPanel(current_room_id_);
    }
    for (const std::string& card_id :
         workbench_suspended_navigation_window_ids_) {
      window_manager->OpenWindow(session_id, card_id);
    }
    workbench_suspended_navigation_window_ids_.clear();
  }
 
  const bool now_enabled = IsWorkbenchWorkflowEnabled();
  if (is_loaded_ && was_enabled != now_enabled &&
      IsValidRoomId(current_room_id_)) {
    // One room model and the same tools serve either canvas host. Rebind all
    // room-scoped panel pointers before closed standalone viewers are retired
    // by DrawRoomPanels on the next frame.
    SyncPanelsToRoom(current_room_id_);
  }
 
  if (show_toast && dependencies_.toast_manager && was_enabled != now_enabled) {
    dependencies_.toast_manager->Show(
        now_enabled ? "Dungeon workflow: Workbench"
                    : "Dungeon workflow: Standalone Panels",
        ToastType::kInfo);
  }
}
 
void DungeonEditorV2::QueueWorkbenchWorkflowMode(bool enabled,
                                                 bool show_toast) {
  pending_workflow_mode_.enabled = enabled;
  pending_workflow_mode_.show_toast = show_toast;
  pending_workflow_mode_.pending = true;
}
 
void DungeonEditorV2::ToggleWorkbenchWorkflowMode(bool show_toast) {
  QueueWorkbenchWorkflowMode(!IsWorkbenchWorkflowEnabled(), show_toast);
}
 
void DungeonEditorV2::DrawRoomPanels() {
  for (int i = 0; i < active_rooms_.Size; i++) {
    int room_id = active_rooms_[i];
    std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
    bool panel_visible = true;
    if (dependencies_.window_manager) {
      panel_visible = dependencies_.window_manager->IsWindowOpen(card_id);
    }
 
    if (!panel_visible) {
      dependencies_.window_manager->UnregisterWindow(card_id);
      room_cards_.erase(room_id);
      active_rooms_.erase(active_rooms_.Data + i);
      ReleaseRoomPanelSlotId(room_id);
      // Clean up viewer
      room_viewers_.Erase(room_id);
      i--;
      continue;
    }
 
    bool is_pinned = dependencies_.window_manager &&
                     dependencies_.window_manager->IsWindowPinned(card_id);
    std::string active_category =
        dependencies_.window_manager
            ? dependencies_.window_manager->GetActiveCategory()
            : "";
 
    if (active_category != "Dungeon" && !is_pinned) {
      continue;
    }
 
    // Ensure room card exists (should have been created by ShowRoomPanel/ShowPanel)
    if (room_cards_.find(room_id) == room_cards_.end()) {
      ShowRoomPanel(room_id);
    }
 
    auto& room_card = room_cards_[room_id];
    bool open = true;
 
    ImGui::SetNextWindowClass(&room_window_class_);
    if (room_dock_id_ == 0) {
      room_dock_id_ = ImGui::GetID("DungeonRoomDock");
    }
    ImGui::SetNextWindowDockID(room_dock_id_, ImGuiCond_FirstUseEver);
 
    if (room_card->Begin(&open)) {
      if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) {
        OnRoomSelected(room_id, /*request_focus=*/false);
      }
      DrawRoomTab(room_id);
    }
    room_card->End();
 
    if (!open) {
      if (dependencies_.window_manager) {
        dependencies_.window_manager->UnregisterWindow(card_id);
      }
 
      room_cards_.erase(room_id);
      active_rooms_.erase(active_rooms_.Data + i);
      room_viewers_.Erase(room_id);
      ReleaseRoomPanelSlotId(room_id);
      i--;
    }
  }
}
 
int DungeonEditorV2::GetOrCreateRoomPanelSlotId(int room_id) {
  if (auto it = room_panel_slot_ids_.find(room_id);
      it != room_panel_slot_ids_.end()) {
    return it->second;
  }
  const int slot_id = next_room_panel_slot_id_++;
  room_panel_slot_ids_[room_id] = slot_id;
  return slot_id;
}
 
void DungeonEditorV2::ReleaseRoomPanelSlotId(int room_id) {
  room_panel_slot_ids_.erase(room_id);
}
 
void DungeonEditorV2::DrawRoomTab(int room_id) {
  const auto& theme = AgentUI::GetTheme();
  if (room_id < 0 || room_id >= 0x128) {
    ImGui::Text(tr("Invalid room ID: %d"), room_id);
    return;
  }
 
  auto& room = rooms_[room_id];
 
  if (!room.IsLoaded()) {
    auto status = room_loader_.LoadRoom(room_id, room);
    if (!status.ok()) {
      ImGui::TextColored(theme.text_error_red, tr("Failed to load room: %s"),
                         status.message().data());
      return;
    }
 
    if (dungeon_editor_system_) {
      auto sys_status = dungeon_editor_system_->ReloadRoom(room_id);
      if (!sys_status.ok()) {
        LOG_ERROR("DungeonEditorV2", "Failed to load system data: %s",
                  sys_status.message().data());
      }
    }
  }
 
  if (room.IsLoaded()) {
    bool needs_render = false;
 
    if (room.blocks().empty()) {
      ApplyEntranceRenderContext(room_id);
      room.LoadRoomGraphics();
      needs_render = true;
    }
 
    if (!room.AreObjectsLoaded()) {
      room.LoadObjects();
      needs_render = true;
    }
 
    auto& bg1_bitmap = room.bg1_buffer().bitmap();
    if (needs_render || !bg1_bitmap.is_active() || bg1_bitmap.width() == 0) {
      room.RenderRoomGraphics();
    }
  }
 
  if (room.IsLoaded()) {
    ImGui::TextColored(theme.text_success_green, ICON_MD_CHECK " Loaded");
  } else {
    ImGui::TextColored(theme.text_error_red, ICON_MD_PENDING " Not Loaded");
  }
  ImGui::SameLine();
  ImGui::TextDisabled(tr("Objects: %zu"), room.GetTileObjects().size());
 
  if (core::FeatureFlags::get().dungeon.kUseWorkbench &&
      !IsWorkbenchWorkflowEnabled()) {
    ImGui::SameLine();
    const std::string return_label = absl::StrFormat(
        ICON_MD_WORKSPACES " Workbench##return_workbench_%03X", room_id);
    if (ImGui::SmallButton(return_label.c_str())) {
      QueueWorkbenchWorkflowMode(true);
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Switch back to the integrated Dungeon Workbench workflow."));
    }
  }
 
  // Warp to Room button — sends room ID to running Mesen2 emulator
  ImGui::SameLine();
  {
    auto client = emu::mesen::MesenClientRegistry::GetClient();
    bool connected = client && client->IsConnected();
    if (!connected) {
      ImGui::BeginDisabled();
    }
    std::string warp_label =
        absl::StrFormat(ICON_MD_ROCKET_LAUNCH " Warp##warp_%03X", room_id);
    if (ImGui::SmallButton(warp_label.c_str())) {
      auto status = client->WriteWord(0x7E00A0, static_cast<uint16_t>(room_id));
      if (status.ok()) {
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Warped to room 0x%03X", room_id),
              ToastType::kSuccess);
        }
      } else {
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Warp failed: %s", status.message()),
              ToastType::kError);
        }
      }
    }
    if (!connected) {
      ImGui::EndDisabled();
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
        ImGui::SetTooltip(tr("Connect to Mesen2 first"));
      }
    } else {
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Warp to room 0x%03X in Mesen2"), room_id);
      }
    }
  }
 
  ImGui::Separator();
 
  // Use per-room viewer; reserve a bottom strip for the shared dungeon
  // status bar so this Windows-mode standalone window mirrors the Workbench
  // canvas pane's affordances.
  if (auto* viewer = GetStandaloneViewerForRoom(room_id)) {
    const float status_bar_reserved =
        std::max(ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f,
                 gui::UIConfig::kStatusBarHeight) +
        ImGui::GetStyle().ItemSpacing.y;
    if (ImGui::BeginChild("##StandaloneRoomBody",
                          ImVec2(0.0f, -status_bar_reserved), false)) {
      viewer->DrawDungeonCanvas(room_id);
      ConsumeRoomCanvasDeleteShortcut(*viewer);
    }
    ImGui::EndChild();
 
    bool room_dirty = false;
    if (room_id >= 0 && room_id < static_cast<int>(rooms_.size())) {
      room_dirty = rooms_[room_id].HasUnsavedChanges();
    }
    const char* tool_mode =
        viewer->object_interaction().mode_manager().GetModeName();
    auto status = DungeonStatusBar::BuildState(*viewer, tool_mode, room_dirty);
    status.workflow_mode = workflow_mode_names::kStandalone;
    status.workflow_primary = false;
    status.can_undo = undo_manager_.CanUndo();
    status.can_redo = undo_manager_.CanRedo();
    status.undo_depth = static_cast<int>(undo_manager_.UndoStackSize());
    status.on_undo = [this]() {
      Undo().IgnoreError();
    };
    status.on_redo = [this]() {
      Redo().IgnoreError();
    };
    DungeonStatusBar::Draw(status);
  }
}
 
void DungeonEditorV2::QueueRoomCanvasDeleteShortcut() {
  if (ImGui::GetCurrentContext() == nullptr) {
    room_canvas_delete_shortcut_frame_.reset();
    return;
  }
  room_canvas_delete_shortcut_frame_ = ImGui::GetFrameCount();
}
 
void DungeonEditorV2::ExpireStaleRoomCanvasDeleteShortcut() {
  if (!room_canvas_delete_shortcut_frame_.has_value()) {
    return;
  }
  if (ImGui::GetCurrentContext() == nullptr ||
      *room_canvas_delete_shortcut_frame_ != ImGui::GetFrameCount()) {
    room_canvas_delete_shortcut_frame_.reset();
  }
}
 
bool DungeonEditorV2::ConsumeRoomCanvasDeleteShortcut(
    DungeonCanvasViewer& viewer) {
  ExpireStaleRoomCanvasDeleteShortcut();
  if (!room_canvas_delete_shortcut_frame_.has_value() ||
      ImGui::GetIO().WantTextInput || ImGui::IsAnyItemActive() ||
      !viewer.CanHandleRoomCanvasShortcut()) {
    return false;
  }
 
  room_canvas_delete_shortcut_frame_.reset();
  viewer.DeleteSelectedObjects();
  return true;
}
 
void DungeonEditorV2::OnRoomSelected(int room_id, RoomSelectionIntent intent) {
  switch (intent) {
    case RoomSelectionIntent::kFocusInWorkbench:
      OnRoomSelected(room_id, /*request_focus=*/true);
      break;
    case RoomSelectionIntent::kOpenStandalone: {
      // Explicitly pivot to panel workflow when user asks for standalone room.
      if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
        return;
      }
      if (IsWorkbenchWorkflowEnabled()) {
        SetWorkbenchWorkflowMode(false);
      }
      // Update shared state (same as OnRoomSelected with request_focus=true)
      OnRoomSelected(room_id, /*request_focus=*/false);
      // Now force-open a standalone panel for this room
      ShowRoomPanel(room_id);
      break;
    }
    case RoomSelectionIntent::kPreview:
      OnRoomSelected(room_id, /*request_focus=*/false);
      break;
  }
}
 
void DungeonEditorV2::OnRoomSelected(int room_id, bool request_focus) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    LOG_WARN("DungeonEditorV2", "Ignoring invalid room selection: %d", room_id);
    return;
  }
  if (room_id != current_room_id_ && workbench_panel_) {
    workbench_panel_->NotifyRoomChanged(current_room_id_);
  }
  current_room_id_ = room_id;
  if (automatic_entrance_preview_) {
    const auto context = ResolveDungeonRenderContextForRoom(room_id);
    if (context.uses_entrance()) {
      current_entrance_id_ = context.entrance_slot;
      room_selector_.set_current_entrance_id(current_entrance_id_);
    }
  }
  room_selector_.set_current_room_id(static_cast<uint16_t>(room_id));
 
  // Track recent rooms (remove if already present, add to front)
  recent_rooms_.erase(
      std::remove(recent_rooms_.begin(), recent_rooms_.end(), room_id),
      recent_rooms_.end());
  recent_rooms_.push_front(room_id);
  if (recent_rooms_.size() > kMaxRecentRooms) {
    recent_rooms_.pop_back();
  }
 
  if (dungeon_editor_system_) {
    dungeon_editor_system_->SetExternalRoom(&rooms_[room_id]);
  }
 
  // Update all sub-panels (Object Editor, Sprite Editor, etc.)
  SyncPanelsToRoom(room_id);
 
  // Sync palette with current room (must happen before early return for focus changes)
 
  // Sync palette with current room (must happen before early return for focus changes)
  if (room_id >= 0 && room_id < (int)rooms_.size()) {
    auto& room = rooms_[room_id];
    if (!room.IsLoaded()) {
      room_loader_.LoadRoom(room_id, room);
    }
 
    if (room.IsLoaded()) {
      ApplyEntranceRenderContext(room_id);
      current_palette_id_ = room.ResolveDungeonPaletteId();
      current_palette_group_id_ = current_palette_id_;
      palette_editor_.SetCurrentPaletteId(current_palette_id_);
 
      // Update viewer and object editor palette
      if (auto* viewer = GetViewerForRoom(room_id)) {
        ConfigureViewerRenderContext(viewer, room_id);
        viewer->SetCurrentPaletteId(current_palette_id_);
 
        if (game_data()) {
          auto dungeon_main_pal_group =
              game_data()->palette_groups.dungeon_main;
          if (current_palette_id_ < (int)dungeon_main_pal_group.size()) {
            current_palette_ = dungeon_main_pal_group[current_palette_id_];
            current_palette_group_ =
                zelda3::BuildDungeonRenderPaletteGroupFromGameData(
                    current_palette_, game_data());
            viewer->SetCurrentPaletteGroup(current_palette_group_);
            if (object_selector_panel_) {
              object_selector_panel_->SetCurrentPaletteGroup(
                  current_palette_group_);
            }
            // Sync palette to graphics panel for proper sheet coloring
            if (room_graphics_panel_) {
              room_graphics_panel_->SetCurrentPaletteGroup(
                  current_palette_group_);
            }
            if (object_tile_editor_panel_) {
              object_tile_editor_panel_->SetCurrentPaletteGroupForRoom(
                  room_id, current_palette_group_);
            }
          }
        }
      }
    }
  }
 
  // Workbench mode uses a single stable window and does not spawn per-room
  // panels. Keep selection + panels in sync and return.
  if (IsWorkbenchWorkflowEnabled()) {
    if (dependencies_.window_manager && request_focus) {
      // Only force-show if it's already visible or if it's the first initialization
      // This avoids obtrusive behavior when the user explicitly closed it.
      if (dependencies_.window_manager->IsWindowOpen("dungeon.workbench")) {
        dependencies_.window_manager->OpenWindow("dungeon.workbench");
      }
    }
    return;
  }
 
  // Check if room is already open
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (active_rooms_[i] == room_id) {
      // Always ensure panel is visible, even if already in active_rooms_
      if (dependencies_.window_manager) {
        std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
        dependencies_.window_manager->OpenWindow(card_id);
      }
      if (request_focus) {
        FocusRoom(room_id);
      }
      return;
    }
  }
 
  active_rooms_.push_back(room_id);
  room_selector_.set_active_rooms(active_rooms_);
 
  if (dependencies_.window_manager) {
    // Use unified ResourceLabelProvider for room names
    std::string room_name = absl::StrFormat(
        "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
 
    std::string base_card_id = absl::StrFormat("dungeon.room_%d", room_id);
 
    dependencies_.window_manager->RegisterWindow(
        {.card_id = base_card_id,
         .display_name = room_name,
         .window_title = ICON_MD_GRID_ON " " + room_name,
         .icon = ICON_MD_GRID_ON,
         .category = "Dungeon",
         .workflow_group = "Rooms",
         .presentation = WindowPresentationPolicy::OptionalPopOut(),
         .shortcut_hint = "",
         .visibility_flag = nullptr,
         .priority = 200 + room_id});
 
    dependencies_.window_manager->OpenWindow(base_card_id);
  }
}
 
void DungeonEditorV2::OnEntranceSelected(int entrance_id) {
  if (entrance_id < 0 || entrance_id >= static_cast<int>(entrances_.size())) {
    return;
  }
  current_entrance_id_ = entrance_id;
  automatic_entrance_preview_ = false;
  room_selector_.set_current_entrance_id(entrance_id);
  RefreshEntranceCameraOverlays();
 
  const int room_id = ResolveEntranceRoomId(entrance_id);
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  OnRoomSelected(room_id);
}
 
void DungeonEditorV2::SetGraphicsPreviewEntrance(int entrance_id) {
  if (entrance_id < -1 || entrance_id >= static_cast<int>(entrances_.size()))
    return;
  automatic_entrance_preview_ = entrance_id == -1;
  if (!automatic_entrance_preview_)
    current_entrance_id_ = entrance_id;
  RefreshEntranceCameraOverlays();
  OnRoomSelected(current_room_id_, /*request_focus=*/false);
}
 
int DungeonEditorV2::ResolveEntranceRoomId(int entrance_id) const {
  if (entrance_id < 0 || entrance_id >= static_cast<int>(entrances_.size())) {
    return -1;
  }
  if (entrance_id < zelda3::kNumDungeonSpawnPoints) {
    const auto& spawn = spawn_points_[entrance_id];
    return spawn.spawn_id() == entrance_id ? spawn.room_id : -1;
  }
  return entrances_[entrance_id].room_;
}
 
uint8_t DungeonEditorV2::ResolveSelectedEntranceBlocksetForRoom(
    int room_id) const {
  const DungeonRenderContext context =
      ResolveDungeonRenderContextForRoom(room_id);
  return context.effective_blockset();
}
 
void DungeonEditorV2::ApplyEntranceRenderContext(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  auto& room = rooms_[room_id];
  if (!room.IsLoaded()) {
    return;
  }
  room.SetRenderEntranceBlockset(
      ResolveSelectedEntranceBlocksetForRoom(room_id));
}
 
void DungeonEditorV2::ConfigureViewerRenderContext(DungeonCanvasViewer* viewer,
                                                   int room_id) {
  if (viewer == nullptr) {
    return;
  }
  const DungeonRenderContext context =
      ResolveDungeonRenderContextForRoom(room_id);
  viewer->SetEntranceRenderContext(context.entrance_slot,
                                   context.effective_blockset());
  viewer->SetEntranceBlocksetResolver([this](int target_room) {
    return ResolveSelectedEntranceBlocksetForRoom(target_room);
  });
  const auto camera = GetEntranceCameraState(context.entrance_slot);
  if (camera.has_value() && camera->room_id == room_id) {
    viewer->SetEntranceCameraOverlay(context.entrance_slot, *camera);
  } else {
    viewer->ClearEntranceCameraOverlay();
  }
}
 
void DungeonEditorV2::add_room(int room_id) {
  OnRoomSelected(room_id);
}
 
void DungeonEditorV2::OpenRegularEntrance(int entrance_id) {
  if (entrance_id < 0 || entrance_id >= zelda3::kNumRegularDungeonEntrances)
    return;
  OnEntranceSelected(zelda3::kNumDungeonSpawnPoints + entrance_id);
}
 
void DungeonEditorV2::FocusRoom(int room_id) {
  auto it = room_cards_.find(room_id);
  if (it != room_cards_.end()) {
    it->second->Focus();
  }
}
 
std::string DungeonEditorV2::proposal_review_path() const {
  return workbench_panel_ ? workbench_panel_->loaded_proposal_path() : "";
}
 
absl::Status DungeonEditorV2::LoadProposalForReview(const std::string& path) {
  if (!workbench_panel_) {
    return absl::FailedPreconditionError("Dungeon Workbench is not loaded");
  }
  if (!workbench_panel_->LoadProposalOverlay(path)) {
    return absl::InvalidArgumentError(workbench_panel_->proposal_error());
  }
  OpenWindow("dungeon.workbench");
  workbench_panel_->RequestProposalPreview();
  return absl::OkStatus();
}
 
void DungeonEditorV2::SelectObject(int obj_id) {
  if (object_selector_panel_) {
    object_selector_panel_->SelectObject(obj_id);
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenObjectSelectorTool();
      OpenWindow("dungeon.workbench");
    } else {
      OpenWindow(kObjectSelectorId);
    }
  }
}
 
void DungeonEditorV2::SetAgentMode(bool enabled) {
  if (enabled && dependencies_.window_manager) {
    if (IsWorkbenchWorkflowEnabled()) {
      OpenWindow("dungeon.workbench");
      if (workbench_panel_) {
        workbench_panel_->OpenObjectSelectorTool();
      }
    } else {
      OpenWindow(kRoomSelectorId);
      OpenWindow(kObjectSelectorId);
      OpenWindow(kRoomGraphicsId);
    }
    if (object_selector_panel_) {
      object_selector_panel_->SetAgentOptimizedLayout(true);
    }
  }
}
 
void DungeonEditorV2::ProcessDeferredTextures() {
  gfx::Arena::Get().ProcessTextureQueue(renderer_);
}
 
void DungeonEditorV2::HandleObjectPlaced(const zelda3::RoomObject& obj) {
  if (!IsValidRoomId(current_room_id_)) {
    LOG_ERROR("DungeonEditorV2", "Cannot place object: Invalid room ID %d",
              current_room_id_);
    const std::string message = absl::StrFormat(
        "Cannot place 0x%02X: invalid room %d", obj.id_, current_room_id_);
    if (object_selector_panel_) {
      object_selector_panel_->SetPlacementError(message);
    } else if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(message, ToastType::kError);
    }
    return;
  }
 
  auto& room = rooms_[current_room_id_];
 
  LOG_INFO("DungeonEditorV2",
           "Placing object ID=0x%02X at position (%d,%d) in room %03X", obj.id_,
           obj.x_, obj.y_, current_room_id_);
 
  room.RenderRoomGraphics();
  LOG_DEBUG("DungeonEditorV2",
            "Object placed and room re-rendered successfully");
  // Brief success feedback so the user knows the placement was accepted.
  // Kept minimal (no inline panel update) — success is non-spammy by design.
  if (dependencies_.toast_manager) {
    dependencies_.toast_manager->Show(
        absl::StrFormat("Placed 0x%02X in room %03X", obj.id_,
                        current_room_id_),
        ToastType::kSuccess);
  }
}
 
void DungeonEditorV2::VisitGraphicsUsageRooms(
    const std::function<void(int, zelda3::Room&, const std::string&, bool,
                             int)>& visitor) {
  rooms_.ForEachLoaded([&](int id, zelda3::Room& room) {
    ApplyEntranceRenderContext(id);
    const auto previous_blocks = room.blocks();
    const auto previous_main = room.resolved_main_blockset();
    room.LoadRoomGraphics();
    if (room.blocks() != previous_blocks ||
        room.resolved_main_blockset() != previous_main) {
      // Membership resolution must not consume a group change without leaving
      // the room dirty for its eventual on-demand render.
      room.MarkGraphicsDirty();
    }
    const auto context = ResolveDungeonRenderContextForRoom(id);
    visitor(id, room, DungeonRenderContextSourceName(context),
            id == current_room_id_, context.entrance_slot);
  });
}
 
void DungeonEditorV2::OpenGraphicsEditorForObject(
    int room_id, const zelda3::RoomObject& object) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    LOG_WARN("DungeonEditorV2", "Edit Graphics ignored (invalid room id %d)",
             room_id);
    return;
  }
 
  auto* editor_manager = static_cast<EditorManager*>(dependencies_.custom_data);
  if (!editor_manager) {
    LOG_WARN("DungeonEditorV2",
             "Edit Graphics ignored (editor manager unavailable)");
    return;
  }
 
  auto& room = rooms_[room_id];
  ApplyEntranceRenderContext(room_id);
  room.PrepareForRender();
  const auto object_stamp = GraphicsObjectStamp(object);
  std::optional<size_t> placed_index;
  bool ambiguous_placement = false;
  // The canvas callback supplies an object copy, without its room index.
  // Infer a placement only when its scalar identity has one match. An
  // unmatched copy is a catalog pattern; duplicates may be previewed, but
  // their mutation source is ambiguous until the callback carries an index.
  const auto& placed_objects = room.GetTileObjects();
  for (size_t i = 0; i < placed_objects.size(); ++i) {
    if (GraphicsObjectStamp(placed_objects[i]) != object_stamp)
      continue;
    if (placed_index) {
      ambiguous_placement = true;
      break;
    }
    placed_index = i;
  }
  auto context = MakeDungeonGraphicsEditContext(room, object, game_data_);
  if (!context.ok()) {
    LOG_WARN("DungeonEditorV2", "Edit Graphics: %s",
             std::string(context.status().message()).c_str());
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show(std::string(context.status().message()),
                                        ToastType::kWarning);
    }
    return;
  }
  const auto entrance = ResolveDungeonRenderContextForRoom(room_id);
  context->label +=
      absl::StrFormat(" / %s", DungeonRenderContextSourceName(entrance));
  auto resolve_live_source =
      [this, room_id, object, object_stamp, placed_index, ambiguous_placement,
       entrance, owner = game_data_,
       source_rom = rom_](GraphicsEditContext& fresh) -> absl::Status {
    if (game_data_ != owner || rom_ != source_rom || !rom_ ||
        !rom_->is_loaded()) {
      return absl::FailedPreconditionError("Dungeon source session changed");
    }
    if (ambiguous_placement) {
      return absl::FailedPreconditionError(
          "Dungeon object placement is ambiguous; reopen Graphics");
    }
    auto* live_room = rooms_.GetIfMaterialized(room_id);
    if (!live_room || !live_room->IsLoaded()) {
      return absl::FailedPreconditionError("Dungeon source room changed");
    }
    if (!SameGraphicsEntrance(entrance,
                              ResolveDungeonRenderContextForRoom(room_id))) {
      return absl::FailedPreconditionError(
          "Dungeon entrance or blockset source changed; reopen Graphics");
    }
    const zelda3::RoomObject* live_object = &object;
    if (placed_index) {
      const auto& objects = live_room->GetTileObjects();
      if (*placed_index >= objects.size() ||
          GraphicsObjectStamp(objects[*placed_index]) != object_stamp) {
        return absl::FailedPreconditionError(
            "Dungeon object placement changed; reopen Graphics");
      }
      live_object = &objects[*placed_index];
    }
    ApplyEntranceRenderContext(room_id);
    // Prepare resolves changed assignments and committed sheet revisions. A
    // read-only source check must not invalidate an unchanged staged preview.
    live_room->PrepareForRender();
    auto refreshed =
        MakeDungeonGraphicsEditContext(*live_room, *live_object, owner);
    if (!refreshed.ok())
      return refreshed.status();
    fresh = std::move(*refreshed);
    return absl::OkStatus();
  };
  context->resolve_live_source = resolve_live_source;
  ConfigureStagedGraphicsPreview(*context, room_id, resolve_live_source);
  // Display refresh retains its earlier captured-source behavior. The strict
  // live resolver runs only at the palette/pixel mutation boundary.
  context->refresh_palettes = [this, room_id, object, owner = game_data_](
                                  GraphicsEditContext& source) -> absl::Status {
    if (game_data_ != owner) {
      return absl::FailedPreconditionError("Dungeon source session changed");
    }
    auto& live_room = rooms_[room_id];
    ApplyEntranceRenderContext(room_id);
    live_room.MarkGraphicsDirty();
    live_room.PrepareForRender();
    auto refreshed = MakeDungeonGraphicsEditContext(live_room, object, owner);
    if (!refreshed.ok())
      return refreshed.status();
    return UpdateGraphicsContextPalettes(source, std::move(*refreshed));
  };
  context->render_preview =
      [this, room_id]() -> absl::StatusOr<usage_preview::PreviewImage> {
    auto& source = rooms_[room_id];
    ApplyEntranceRenderContext(room_id);
    // A stroke updates store pixels before committing its revision. Usage
    // Preview already throttles on pixel changes; render those live pixels too.
    source.MarkGraphicsDirty();
    source.PrepareForRender();
    zelda3::RoomLayerManager layers;
    layers.ApplyLayerMerging(source.layer_merging());
    layers.ApplyRoomEffect(source.effect());
    layers.ApplyGameLayerRegisters(source.GameLayerRegisters());
    gfx::Bitmap composite;
    source.RenderComposite(layers, composite);
    return usage_preview::SnapshotBitmap(composite);
  };
  context->return_to_source = [this, editor_manager, room_id]() {
    editor_manager->SwitchToEditor(EditorType::kDungeon, true);
    OnRoomSelected(room_id);
  };
 
  if (auto* editor_set = editor_manager->GetCurrentEditorSet()) {
    if (auto* graphics = editor_set->GetGraphicsEditor()) {
      const auto loaded =
          editor_manager->EnsureEditorAssetsLoaded(EditorType::kGraphics);
      if (!loaded.ok()) {
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(std::string(loaded.message()),
                                            ToastType::kWarning);
        }
        return;
      }
      const auto status = graphics->OpenInContext(std::move(*context));
      if (!status.ok()) {
        LOG_WARN("DungeonEditorV2", "Edit Graphics: %s",
                 std::string(status.message()).c_str());
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(std::string(status.message()),
                                            ToastType::kWarning);
        }
        return;
      }
      editor_manager->SwitchToEditor(EditorType::kGraphics, true);
    }
  }
}
 
absl::Status DungeonEditorV2::OpenObjectTileEditorForObject(
    int room_id, const zelda3::RoomObject& object) {
  if (object_tile_editor_panel_ == nullptr) {
    return absl::FailedPreconditionError(
        "Object Tile Editor panel is unavailable");
  }
  if (dependencies_.window_manager == nullptr) {
    return absl::FailedPreconditionError(
        "Workspace window manager is unavailable");
  }
  if (rom_ == nullptr || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return absl::OutOfRangeError("Dungeon room id is outside the room store");
  }
  if (!zelda3::ObjectTileEditor::IsEditableStandardObject(object.id_)) {
    return absl::UnimplementedError(
        "Tile editing is not yet supported for this object layout");
  }
  if (game_data_ == nullptr ||
      game_data_->palette_groups.dungeon_main.empty()) {
    return absl::FailedPreconditionError("Dungeon palette data is unavailable");
  }
 
  auto& room = rooms_[room_id];
  if (!room.IsLoaded()) {
    RETURN_IF_ERROR(room_loader_.LoadRoom(room_id, room));
  }
  ApplyEntranceRenderContext(room_id);
  room.PrepareForRender();
 
  const int palette_id = room.ResolveDungeonPaletteId();
  const auto& dungeon_palettes = game_data_->palette_groups.dungeon_main;
  if (palette_id < 0 ||
      palette_id >= static_cast<int>(dungeon_palettes.size())) {
    return absl::OutOfRangeError(
        "Room resolves to an unavailable dungeon palette");
  }
  auto room_palette = dungeon_palettes[palette_id];
  const auto palette_group = zelda3::BuildDungeonRenderPaletteGroupFromGameData(
      room_palette, game_data_);
 
  const absl::Status open_status = object_tile_editor_panel_->OpenForObject(
      object.id_, room_id, &rooms_, palette_group);
  if (!open_status.ok()) {
    // A modified hidden session rejects replacement to prevent data loss.
    // Surface that existing session so the user can apply, revert, or use the
    // explicit discard action described by the returned status.
    if (object_tile_editor_panel_->IsOpen()) {
      (void)dependencies_.window_manager->OpenWindow(
          object_tile_editor_panel_->GetId());
    }
    return open_status;
  }
  if (!dependencies_.window_manager->OpenWindow(
          object_tile_editor_panel_->GetId())) {
    object_tile_editor_panel_->Close();
    return absl::NotFoundError(
        "Object Tile Editor window is not registered in this session");
  }
  return absl::OkStatus();
}
 
void DungeonEditorV2::SwapRoomInPanel(int old_room_id, int new_room_id) {
  // Defer the swap until after the current frame's draw phase completes
  // This prevents modifying data structures while ImGui is still using them
  if (new_room_id < 0 || new_room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
  pending_swap_.old_room_id = old_room_id;
  pending_swap_.new_room_id = new_room_id;
  pending_swap_.pending = true;
}
 
void DungeonEditorV2::ProcessPendingSwap() {
  if (!pending_swap_.pending) {
    return;
  }
 
  int old_room_id = pending_swap_.old_room_id;
  int new_room_id = pending_swap_.new_room_id;
  pending_swap_.pending = false;
 
  // Find the position of old_room in active_rooms_
  int swap_index = -1;
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (active_rooms_[i] == old_room_id) {
      swap_index = i;
      break;
    }
  }
 
  if (swap_index < 0) {
    // Old room not found in active rooms, just select the new one
    OnRoomSelected(new_room_id);
    return;
  }
 
  // Avoid swapping into an already-open room panel (the per-room maps assume
  // room IDs are unique). In this case, just focus/select the existing room.
  for (int i = 0; i < active_rooms_.Size; i++) {
    if (i != swap_index && active_rooms_[i] == new_room_id) {
      OnRoomSelected(new_room_id);
      return;
    }
  }
 
  // Preserve the old panel's stable ImGui window identity by transferring its
  // slot id to the new room id.
  int slot_id = -1;
  if (auto it = room_panel_slot_ids_.find(old_room_id);
      it != room_panel_slot_ids_.end()) {
    slot_id = it->second;
    room_panel_slot_ids_.erase(it);
  } else {
    slot_id = next_room_panel_slot_id_++;
  }
  room_panel_slot_ids_[new_room_id] = slot_id;
 
  // Preserve the viewer instance so canvas pan/zoom and UI state don't reset
  // when navigating with arrows (swap-in-panel).
  room_viewers_.Rename(old_room_id, new_room_id);
 
  // Replace old room with new room in active_rooms_
  active_rooms_[swap_index] = new_room_id;
  room_selector_.set_active_rooms(active_rooms_);
 
  // Unregister old panel
  if (dependencies_.window_manager) {
    std::string old_card_id = absl::StrFormat("dungeon.room_%d", old_room_id);
    const bool old_pinned =
        dependencies_.window_manager->IsWindowPinned(old_card_id);
    dependencies_.window_manager->UnregisterWindow(old_card_id);
 
    // Register new panel
    // Use unified ResourceLabelProvider for room names
    std::string new_room_name = absl::StrFormat(
        "[%03X] %s", new_room_id, zelda3::GetRoomLabel(new_room_id).c_str());
 
    std::string new_card_id = absl::StrFormat("dungeon.room_%d", new_room_id);
 
    dependencies_.window_manager->RegisterWindow(
        {.card_id = new_card_id,
         .display_name = new_room_name,
         .window_title = ICON_MD_GRID_ON " " + new_room_name,
         .icon = ICON_MD_GRID_ON,
         .category = "Dungeon",
         .workflow_group = "Rooms",
         .presentation = WindowPresentationPolicy::OptionalPopOut(),
         .shortcut_hint = "",
         .visibility_flag = nullptr,
         .priority = 200 + new_room_id});
 
    if (old_pinned) {
      dependencies_.window_manager->SetWindowPinned(new_card_id, true);
    }
    dependencies_.window_manager->OpenWindow(new_card_id);
  }
 
  // Clean up old room's card and viewer
  room_cards_.erase(old_room_id);
 
  // Update current selection
  OnRoomSelected(new_room_id, /*request_focus=*/false);
}
 
void DungeonEditorV2::ProcessPendingWorkflowMode() {
  if (!pending_workflow_mode_.pending) {
    return;
  }
 
  const bool enabled = pending_workflow_mode_.enabled;
  const bool show_toast = pending_workflow_mode_.show_toast;
  pending_workflow_mode_.pending = false;
  SetWorkbenchWorkflowMode(enabled, show_toast);
}
 
void DungeonEditorV2::ProcessPendingStandaloneToolWindow() {
  if (!pending_standalone_tool_window_.pending) {
    return;
  }
 
  PendingStandaloneToolWindow request =
      std::move(pending_standalone_tool_window_);
  pending_standalone_tool_window_ = {};
 
  auto* window_manager = dependencies_.window_manager;
  if (!window_manager) {
    return;
  }
 
  if (!window_manager->OpenWindow(request.session_id, request.window_id)) {
    return;
  }
 
  if (ImGui::GetCurrentContext() != nullptr) {
    const std::string window_name = window_manager->GetWorkspaceWindowName(
        request.session_id, request.window_id);
    if (!window_name.empty()) {
      ImGui::SetWindowFocus(window_name.c_str());
    }
  }
}
 
void DungeonEditorV2::TouchViewerLru(int room_id) {
  room_viewers_.Touch(room_id);
}
 
void DungeonEditorV2::RemoveViewerFromLru(int room_id) {
  // No-op: LruCache handles removal internally via Erase()
  (void)room_id;
}
 
void DungeonEditorV2::WireViewerPanelCallbacks(DungeonCanvasViewer* viewer) {
  if (!viewer) {
    return;
  }
 
  viewer->SetShowObjectPanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenObjectSelectorTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kObjectSelectorId);
  });
  viewer->SetShowSpritePanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenSpriteTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.sprite_editor");
  });
  viewer->SetShowItemPanelCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenItemTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.item_editor");
  });
  viewer->SetShowRoomListCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->FocusRoomMatrix();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(DungeonEditorV2::kRoomSelectorId);
  });
  viewer->SetShowRoomMatrixCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->FocusRoomMatrix();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kRoomMatrixId);
  });
  viewer->SetShowEntranceListCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->FocusEntranceBrowser();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.entrance_properties");
  });
  viewer->SetShowRoomGraphicsCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenRoomGraphicsTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow(kRoomGraphicsId);
  });
  viewer->SetCheckObjectCoverageCallback(
      [this](int room_id, const zelda3::RoomObject& object) {
        FocusObjectCoverage(room_id, object);
      });
  viewer->SetShowDoorEditorCallback([this]() {
    if (IsWorkbenchWorkflowEnabled() && workbench_panel_) {
      workbench_panel_->OpenDoorTool();
      OpenWindow("dungeon.workbench");
      return;
    }
    OpenWindow("dungeon.door_editor");
  });
  viewer->SetShowDungeonSettingsCallback([this]() {
    if (workbench_panel_) {
      workbench_panel_->FocusRoomInspector();
    }
    OpenWindow("dungeon.workbench");
  });
  viewer->SetEditGraphicsCallback(
      [this](int target_room_id, const zelda3::RoomObject& object) {
        OpenGraphicsEditorForObject(target_room_id, object);
      });
  viewer->SetEditObjectTilesCallback(
      [this](int target_room_id, const zelda3::RoomObject& object) {
        const absl::Status status =
            OpenObjectTileEditorForObject(target_room_id, object);
        if (status.ok()) {
          return;
        }
        LOG_ERROR("DungeonEditorV2", "Edit Object Tiles failed: %s",
                  status.message().data());
        if (dependencies_.toast_manager) {
          dependencies_.toast_manager->Show(
              absl::StrFormat("Edit Object Tiles failed: %s", status.message()),
              ToastType::kError);
        }
      });
  viewer->SetSaveRoomCallback([this](int target_room_id) {
    auto status = SaveRoom(target_room_id);
    if (!status.ok()) {
      LOG_ERROR("DungeonEditorV2", "Apply Room failed: %s",
                status.message().data());
      if (dependencies_.toast_manager) {
        dependencies_.toast_manager->Show(
            absl::StrFormat("Apply Room failed: %s", status.message()),
            ToastType::kError);
      }
      return;
    }
    if (dependencies_.toast_manager) {
      dependencies_.toast_manager->Show("Applied room to ROM buffer",
                                        ToastType::kSuccess);
    }
  });
}
 
DungeonCanvasViewer* DungeonEditorV2::GetViewerForRoom(int room_id) {
  if (IsWorkbenchWorkflowEnabled()) {
    (void)room_id;
    return GetWorkbenchViewer();
  }
 
  return GetStandaloneViewerForRoom(room_id);
}
 
DungeonCanvasViewer* DungeonEditorV2::GetStandaloneViewerForRoom(int room_id) {
  // Set eviction predicate to protect active rooms from eviction
  room_viewers_.SetEvictionPredicate([this](const int& candidate) {
    for (int i = 0; i < active_rooms_.size(); ++i) {
      if (active_rooms_[i] == candidate)
        return false;
    }
    return true;
  });
 
  if (auto* existing = room_viewers_.Get(room_id)) {
    // Viewer already exists - Get() already touched LRU
    auto* viewer_ptr = existing->get();
    RefreshViewerRuntimeContext(viewer_ptr, room_id);
    ApplyEntranceRenderContext(room_id);
 
    // Update pinned state from manager
    if (dependencies_.window_manager) {
      std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
      viewer_ptr->SetPinned(
          dependencies_.window_manager->IsWindowPinned(card_id));
      viewer_ptr->SetPinCallback([this, card_id, room_id](bool pinned) {
        if (dependencies_.window_manager) {
          dependencies_.window_manager->SetWindowPinned(card_id, pinned);
          if (auto* existing_viewer = room_viewers_.Get(room_id)) {
            (*existing_viewer)->SetPinned(pinned);
          }
        }
      });
    }
 
    return viewer_ptr;
  }
 
  // Creating a new viewer - Insert will handle LRU and eviction
  {
    auto viewer = std::make_unique<DungeonCanvasViewer>(rom_);
    viewer->SetCompactHeaderMode(false);
    viewer->SetRoomDetailsExpanded(true);
    DungeonCanvasViewer* viewer_ptr = viewer.get();
    ConfigureEditableViewer(viewer_ptr);
    viewer->SetRoomNavigationCallback([this](int target_room) {
      if (target_room >= 0 && target_room < static_cast<int>(rooms_.size())) {
        OnRoomSelected(target_room);
      }
    });
    // Swap callback swaps the room in the current panel instead of opening new
    viewer->SetRoomSwapCallback([this](int old_room, int new_room) {
      SwapRoomInPanel(old_room, new_room);
    });
    // Wire up pinning for room panels.
    if (dependencies_.window_manager) {
      std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
      viewer->SetPinned(dependencies_.window_manager->IsWindowPinned(card_id));
      viewer->SetPinCallback([this, card_id, room_id](bool pinned) {
        if (dependencies_.window_manager) {
          dependencies_.window_manager->SetWindowPinned(card_id, pinned);
          // Sync state back to viewer in all panels showing this room
          if (auto* existing_viewer = room_viewers_.Get(room_id)) {
            (*existing_viewer)->SetPinned(pinned);
          }
        }
      });
    }
 
    auto* stored = room_viewers_.Insert(room_id, std::move(viewer));
    RefreshViewerRuntimeContext(stored->get(), room_id);
    ApplyEntranceRenderContext(room_id);
    return stored->get();
  }
}
 
void DungeonEditorV2::ConfigureEditableViewer(DungeonCanvasViewer* viewer) {
  ConfigureViewerUndoHooks(viewer);
  viewer->object_interaction().SetObjectPlacedCallback(
      [this](const zelda3::RoomObject& obj) { HandleObjectPlaced(obj); });
  WireViewerPanelCallbacks(viewer);
}
 
void DungeonEditorV2::RefreshViewerRuntimeContext(DungeonCanvasViewer* viewer,
                                                  int room_id,
                                                  bool rebind_project) {
  if (!viewer) {
    return;
  }
 
  if (viewer->rom() != rom_) {
    viewer->SetRom(rom_);
  }
  if (viewer->rooms() != &rooms_) {
    viewer->SetRooms(&rooms_);
  }
  if (viewer->game_data() != game_data_) {
    viewer->SetGameData(game_data_);
  }
  viewer->SetRenderer(renderer_);
  viewer->SetCurrentPaletteGroup(current_palette_group_);
  viewer->SetCurrentPaletteId(current_palette_id_);
  ConfigureViewerRenderContext(viewer, room_id);
  viewer->SetEditorSystem(dungeon_editor_system_.get());
  viewer->SetMinecartTrackPanel(minecart_track_editor_panel_);
  if (rebind_project || viewer->project() != dependencies_.project) {
    viewer->SetProject(dependencies_.project);
  }
}
 
DungeonCanvasViewer* DungeonEditorV2::GetWorkbenchViewer() {
  if (!workbench_viewer_) {
    workbench_viewer_ = std::make_unique<DungeonCanvasViewer>(rom_);
    auto* viewer = workbench_viewer_.get();
    viewer->SetCompactHeaderMode(true);
    viewer->SetRoomDetailsExpanded(false);
    viewer->SetHeaderVisible(false);
    viewer->SetHeaderHiddenMetadataHudVisible(false);
    ConfigureEditableViewer(viewer);
 
    // In workbench mode, arrow navigation swaps the current room without
    // changing window identities.
    viewer->SetRoomSwapCallback([this](int /*old_room*/, int new_room) {
      OnRoomSelected(new_room, /*request_focus=*/false);
    });
    viewer->SetRoomNavigationCallback([this](int target_room) {
      OnRoomSelected(target_room, /*request_focus=*/false);
    });
  }
 
  auto* viewer = workbench_viewer_.get();
  RefreshViewerRuntimeContext(viewer, current_room_id_);
  return viewer;
}
 
DungeonCanvasViewer* DungeonEditorV2::GetWorkbenchCompareViewer(int room_id) {
  if (!workbench_compare_viewer_) {
    workbench_compare_viewer_ = std::make_unique<DungeonCanvasViewer>(rom_);
    auto* viewer = workbench_compare_viewer_.get();
    viewer->SetCompactHeaderMode(true);
    viewer->SetRoomDetailsExpanded(false);
    viewer->SetHeaderHiddenMetadataHudVisible(false);
    // Compare viewer is read-only by default: no object selection/mutation, but
    // still allows canvas pan/zoom.
    viewer->SetObjectInteractionEnabled(false);
    viewer->SetHeaderReadOnly(true);
    viewer->SetHeaderVisible(false);
  }
 
  auto* viewer = workbench_compare_viewer_.get();
  RefreshViewerRuntimeContext(viewer, room_id);
  viewer->SetObjectInteractionEnabled(false);
  viewer->SetHeaderReadOnly(true);
  viewer->SetHeaderVisible(false);
  return viewer;
}
 
void DungeonEditorV2::SyncPanelsToRoom(int room_id) {
  if (minecart_track_editor_panel_) {
    minecart_track_editor_panel_->SetActiveRoom(room_id);
  }
  // Update object editor card with current viewer
  if (object_selector_panel_) {
    object_selector_panel_->SetCanvasViewerProvider(
        [this]() { return GetViewerForRoom(current_room_id_); });
    object_selector_panel_->SetCurrentRoom(room_id);
    object_selector_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (door_editor_panel_) {
    door_editor_panel_->SetCanvasViewerProvider(
        [this]() { return GetViewerForRoom(current_room_id_); });
    door_editor_panel_->SetCurrentRoom(room_id);
    door_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
 
  // Update sprite and item editor panels with current viewer
  if (sprite_editor_panel_) {
    sprite_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (item_editor_panel_) {
    item_editor_panel_->SetCanvasViewer(GetViewerForRoom(room_id));
  }
  if (custom_collision_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    custom_collision_panel_->SetCanvasViewer(viewer);
    if (viewer) {
      custom_collision_panel_->SetInteraction(&viewer->object_interaction());
    }
  }
  if (water_fill_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    water_fill_panel_->SetCanvasViewer(viewer);
    if (viewer) {
      water_fill_panel_->SetInteraction(&viewer->object_interaction());
    }
  }
 
  if (room_tag_editor_panel_) {
    room_tag_editor_panel_->SetCurrentRoomId(room_id);
  }
 
  if (overlay_manager_panel_) {
    auto* viewer = GetViewerForRoom(room_id);
    if (viewer) {
      OverlayManagerPanel::OverlayState overlay_state;
      overlay_state.show_grid = viewer->mutable_show_grid();
      overlay_state.show_object_bounds = viewer->mutable_show_object_bounds();
      overlay_state.show_coordinate_overlay =
          viewer->mutable_show_coordinate_overlay();
      overlay_state.show_room_debug_info =
          viewer->mutable_show_room_debug_info();
      overlay_state.show_texture_debug = viewer->mutable_show_texture_debug();
      overlay_state.show_layer_info = viewer->mutable_show_layer_info();
      overlay_state.show_minecart_tracks =
          viewer->mutable_show_minecart_tracks();
      overlay_state.show_custom_collision =
          viewer->mutable_show_custom_collision_overlay();
      overlay_state.show_track_collision =
          viewer->mutable_show_track_collision_overlay();
      overlay_state.show_camera_quadrants =
          viewer->mutable_show_camera_quadrant_overlay();
      overlay_state.show_minecart_sprites =
          viewer->mutable_show_minecart_sprite_overlay();
      overlay_state.show_collision_legend =
          viewer->mutable_show_track_collision_legend();
      overlay_manager_panel_->SetState(overlay_state);
    }
  }
}
 
void DungeonEditorV2::ShowRoomPanel(int room_id) {
  if (room_id < 0 || room_id >= static_cast<int>(rooms_.size())) {
    return;
  }
 
  bool already_active = false;
  for (int i = 0; i < active_rooms_.Size; ++i) {
    if (active_rooms_[i] == room_id) {
      already_active = true;
      break;
    }
  }
  if (!already_active) {
    active_rooms_.push_back(room_id);
    room_selector_.set_active_rooms(active_rooms_);
  }
 
  std::string card_id = absl::StrFormat("dungeon.room_%d", room_id);
 
  if (dependencies_.window_manager) {
    if (!dependencies_.window_manager->GetWindowDescriptor(
            dependencies_.window_manager->GetActiveSessionId(), card_id)) {
      std::string room_name = absl::StrFormat(
          "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
      dependencies_.window_manager->RegisterWindow(
          {.card_id = card_id,
           .display_name = room_name,
           .window_title = ICON_MD_GRID_ON " " + room_name,
           .icon = ICON_MD_GRID_ON,
           .category = "Dungeon",
           .workflow_group = "Rooms",
           .presentation = WindowPresentationPolicy::OptionalPopOut(),
           .shortcut_hint = "",
           .visibility_flag = nullptr,
           .priority = 200 + room_id});
    }
    dependencies_.window_manager->OpenWindow(card_id);
  }
 
  // Create or update the PanelWindow for this room
  if (room_cards_.find(room_id) == room_cards_.end()) {
    std::string base_name = absl::StrFormat(
        "[%03X] %s", room_id, zelda3::GetRoomLabel(room_id).c_str());
    const int slot_id = GetOrCreateRoomPanelSlotId(room_id);
    std::string card_name_str = absl::StrFormat(
        "%s###RoomPanelSlot%d", MakePanelTitle(base_name).c_str(), slot_id);
 
    auto card = std::make_shared<gui::PanelWindow>(card_name_str.c_str(),
                                                   ICON_MD_GRID_ON);
    card->SetDefaultSize(620, 700);
    room_cards_[room_id] = card;
  }
}
 
}  // namespace yaze::editor