full_diff.patch

diff --git a/QuickView/HeavyLanePool.cpp b/QuickView/HeavyLanePool.cpp
index 4b031a2..119b0cd 100644
--- a/QuickView/HeavyLanePool.cpp
+++ b/QuickView/HeavyLanePool.cpp
@@ -21,6 +21,8 @@ namespace {
         HeavyLanePool* pool;
         std::wstring path;
         ImageID id;
+        PaneSlot targetSlot;
+        uint64_t generationId;
     };
 
     struct MmfDeleterCtx {
@@ -541,7 +543,7 @@ void HeavyLanePool::ShrinkMemory() {
 // Task Submission
 // ============================================================================
 
-void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf) {
+void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf, PaneSlot targetSlot, uint64_t generationId) {
     // [Hardware] Update IO throttling based on target drive
     bool isSSD = SystemInfo::IsSolidStateDrive(path);
     UpdateIOLimit(isSSD ? m_cap : 2);
@@ -553,7 +555,7 @@ void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::share
     // [Revision 2] Trigger ONLY for the active image. Prefetch jobs (ID mismatch) 
     // are prohibited from destroying current Titan resources.
     if (m_isTitanMode.load(std::memory_order_relaxed) && imageId == m_activeTitanImageId.load(std::memory_order_relaxed)) {
-        EnsureMasterWarmup(path, imageId, mmf);
+        EnsureMasterWarmup(path, imageId, mmf, targetSlot, generationId);
     }
 
     std::lock_guard lock(m_poolMutex);
@@ -564,7 +566,7 @@ void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::share
     // [Dedup] Prevent redundant decoding jobs in the pending queue
     if (!m_isTitanMode) {
         for (const auto& existing : m_pendingJobs) {
-            if (existing.type == JobType::Standard && existing.imageId == imageId) {
+        if (existing.type == JobType::Standard && existing.imageId == imageId && existing.targetSlot == targetSlot) {
                 // If the generation is old, we could update it. But simple dedup is fine.
                 // Just return if we already have it pending.
                 return;
@@ -576,6 +578,8 @@ void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::share
     job.type = JobType::Standard;
     job.path = path;
     job.imageId = imageId;
+    job.targetSlot = targetSlot;
+    job.generationId = generationId;
     job.submitTime = std::chrono::steady_clock::now();
     job.mmf = mmf;
     job.targetHdrHeadroomStops = m_targetHdrHeadroomStops.load(std::memory_order_relaxed);
@@ -590,13 +594,15 @@ void HeavyLanePool::Submit(const std::wstring& path, ImageID imageId, std::share
     m_poolCv.notify_all(); // [Fix] notify_all required
 }
 
-void HeavyLanePool::SubmitFullDecode(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf) {
+void HeavyLanePool::SubmitFullDecode(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf, PaneSlot targetSlot, uint64_t generationId) {
     std::lock_guard lock(m_poolMutex);
     
     JobInfo job;
     job.type = JobType::Standard;
     job.path = path;
     job.imageId = imageId;
+    job.targetSlot = targetSlot;
+    job.generationId = generationId;
     job.submitTime = std::chrono::steady_clock::now();
     job.mmf = mmf; 
     job.targetHdrHeadroomStops = m_targetHdrHeadroomStops.load(std::memory_order_relaxed);
@@ -733,14 +739,14 @@ void HeavyLanePool::SubmitTileBatch(const std::wstring& path, ImageID imageId, s
 // Cancellation
 // ============================================================================
 
-void HeavyLanePool::CancelOthers(ImageID currentId) {
+void HeavyLanePool::CancelOthers(ImageID currentId, PaneSlot targetSlot) {
     std::lock_guard lock(m_poolMutex);
     
 // 1. Clear Job Queue of non-matching IDs
     auto it = m_pendingJobs.begin();
     int removedTiles = 0;
     while (it != m_pendingJobs.end()) {
-        if (it->imageId != currentId) {
+        if (it->targetSlot == targetSlot && it->imageId != currentId) {
             if (it->type == JobType::Tile) {
                 removedTiles++;
                 // [Dedup] Remove from in-flight set
@@ -1340,7 +1346,7 @@ void HeavyLanePool::PerformDecode(int workerId, const JobInfo& job, std::stop_to
               // For WIC formats (TIFF, AVIF, etc), loading from MMF via SHCreateMemStream COPIES the file,
               // leading to massive memory bloat/OOM for 1GB+ large files. Pass directly to file loader instead.
               {
-                  auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, job.path, job.imageId };
+                  auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, job.path, job.imageId, job.targetSlot, job.generationId };
                   if (ctx) {
                       rawFrame.onAuxLayerReady.ctx = ctx;
                       rawFrame.onAuxLayerReady.pfn = [](void* c, std::unique_ptr<QuickView::AuxLayer> aux, QuickView::GpuBlendOp op, QuickView::GpuShaderPayload payload) {
@@ -1349,6 +1355,8 @@ void HeavyLanePool::PerformDecode(int workerId, const JobInfo& job, std::stop_to
                           ev.type = EventType::AuxLayerReady;
                           ev.filePath = lctx->path;
                           ev.imageId = lctx->id;
+                          ev.targetSlot = lctx->targetSlot;
+                          ev.generationId = lctx->generationId;
                           ev.auxLayer = std::move(aux);
                           ev.blendOp = op;
                           ev.shaderPayload = payload;
@@ -1779,6 +1787,8 @@ tile_decode_done: ; // [P14] Jump target for fast path (skip legacy TJ decode)
             EngineEvent evt;
             evt.filePath = job.path;
             evt.imageId = job.imageId;
+            evt.targetSlot = job.targetSlot;
+            evt.generationId = job.generationId;
             
             if (job.type == JobType::Tile) {
                 evt.type = EventType::TileReady;
@@ -1895,6 +1905,8 @@ tile_decode_done: ; // [P14] Jump target for fast path (skip legacy TJ decode)
                 evt.type = EventType::LoadError;
                 evt.filePath = job.path;
                 evt.imageId = job.imageId;
+                evt.targetSlot = job.targetSlot;
+                evt.generationId = job.generationId;
                 evt.hr = hr;
                 QueueResult(std::move(evt));
             }
@@ -2115,7 +2127,7 @@ void HeavyLanePool::StopMasterWarmup() {
     m_lodCacheCond.notify_all(); // Wake any waiters so they can re-check
 }
 
-void HeavyLanePool::EnsureMasterWarmup(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf) {
+void HeavyLanePool::EnsureMasterWarmup(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf, PaneSlot targetSlot, uint64_t generationId) {
     if (!ShouldWarmupMasterBacking()) return;
     if (!mmf || !mmf->IsValid()) return;
 
@@ -2135,7 +2147,7 @@ void HeavyLanePool::EnsureMasterWarmup(const std::wstring& path, ImageID imageId
     m_masterWarmupReady.store(false, std::memory_order_release);
     const uint32_t warmupGen = m_generationID.load(std::memory_order_acquire);
 
-    m_masterWarmupThread = std::jthread([this, path, imageId, mmf, warmupGen](std::stop_token st) {
+    m_masterWarmupThread = std::jthread([this, path, imageId, mmf, warmupGen, targetSlot, generationId](std::stop_token st) {
         // [Fix] Ensure the UI marquee stops even if we exit early (failure/stop)
         struct Finalizer {
             std::atomic<bool>* ready;
@@ -2245,7 +2257,7 @@ void HeavyLanePool::EnsureMasterWarmup(const std::wstring& path, ImageID imageId
 
             QuickView::RawImageFrame fullFrame;
             {
-                auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, path, imageId };
+                auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, path, imageId, targetSlot, generationId };
                 if (ctx) {
                     fullFrame.onAuxLayerReady.ctx = ctx;
                     fullFrame.onAuxLayerReady.pfn = [](void* c, std::unique_ptr<QuickView::AuxLayer> aux, QuickView::GpuBlendOp op, QuickView::GpuShaderPayload payload) {
@@ -2254,6 +2266,8 @@ void HeavyLanePool::EnsureMasterWarmup(const std::wstring& path, ImageID imageId
                         ev.type = EventType::AuxLayerReady;
                         ev.filePath = lctx->path;
                         ev.imageId = lctx->id;
+                        ev.targetSlot = lctx->targetSlot;
+                        ev.generationId = lctx->generationId;
                         ev.auxLayer = std::move(aux);
                         ev.blendOp = op;
                         ev.shaderPayload = payload;
@@ -3245,7 +3259,7 @@ HRESULT HeavyLanePool::FullDecodeAndCacheLOD(Worker& worker, const JobInfo& job,
                 const int targetW = (m_titanSrcW + (1 << lod) - 1) / (1 << lod);
                 const int targetH = (m_titanSrcH + (1 << lod) - 1) / (1 << lod);
                 {
-                    auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, job.path, job.imageId };
+                    auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ this, job.path, job.imageId, job.targetSlot, job.generationId };
                     if (ctx) {
                         fullFrame.onAuxLayerReady.ctx = ctx;
                         fullFrame.onAuxLayerReady.pfn = [](void* c, std::unique_ptr<QuickView::AuxLayer> aux, QuickView::GpuBlendOp op, QuickView::GpuShaderPayload payload) {
@@ -3254,6 +3268,8 @@ HRESULT HeavyLanePool::FullDecodeAndCacheLOD(Worker& worker, const JobInfo& job,
                             ev.type = EventType::AuxLayerReady;
                             ev.filePath = lctx->path;
                             ev.imageId = lctx->id;
+                            ev.targetSlot = lctx->targetSlot;
+                            ev.generationId = lctx->generationId;
                             ev.auxLayer = std::move(aux);
                             ev.blendOp = op;
                             ev.shaderPayload = payload;
diff --git a/QuickView/HeavyLanePool.h b/QuickView/HeavyLanePool.h
index b2926c8..047ff13 100644
--- a/QuickView/HeavyLanePool.h
+++ b/QuickView/HeavyLanePool.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "ImageEngine.h" // For EngineEvent complete type
+#include "PaneTypes.h"
 #include "ImageLoader.h"
 #include "MemoryArena.h"
 #include "SystemInfo.h"
@@ -67,10 +68,10 @@ public:
     // === Task Submission ===
     // Thread-safe. Will auto-expand if needed.
     // [ImageID] Uses stable path hash instead of incrementing token
-    void Submit(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf = nullptr);
+    void Submit(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf = nullptr, PaneSlot targetSlot = PaneSlot::Primary, uint64_t generationId = 0);
     
     // Full resolution decode (no scaling)
-    void SubmitFullDecode(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf = nullptr);
+    void SubmitFullDecode(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf = nullptr, PaneSlot targetSlot = PaneSlot::Primary, uint64_t generationId = 0);
     
     // [Titan Engine] Submit a tile decode task
     void SubmitTile(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf, QuickView::TileCoord coord, QuickView::RegionRequest region, int priority = 0);
@@ -89,7 +90,7 @@ public:
     
     // === Cancellation ===
     // [ImageID] Cancel tasks that don't match the current imageId
-    void CancelOthers(ImageID currentId);
+    void CancelOthers(ImageID currentId, PaneSlot targetSlot = PaneSlot::Primary);
     void CancelAll();
     
     // === Result Retrieval ===
@@ -276,6 +277,8 @@ private:
         // Common
         std::wstring path;
         ImageID imageId;
+        PaneSlot targetSlot = PaneSlot::Primary;
+        uint64_t generationId = 0;
         std::chrono::steady_clock::time_point submitTime; // [Metrics] Track queue time
         std::shared_ptr<QuickView::MappedFile> mmf; // [Optimization] Zero-Copy MMF Source
         float targetHdrHeadroomStops = -1.0f;
@@ -459,7 +462,7 @@ private:
     std::atomic<ImageID> m_masterWarmupImageId{ 0 };
     std::atomic<bool> m_masterWarmupReady{ false };  // [Direct-to-MMF] Set true when warmup decode is complete
     bool ShouldWarmupMasterBacking() const;
-    void EnsureMasterWarmup(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf);
+    void EnsureMasterWarmup(const std::wstring& path, ImageID imageId, std::shared_ptr<QuickView::MappedFile> mmf, PaneSlot targetSlot, uint64_t generationId);
     void StopMasterWarmup();
     
     // ============================================================================
diff --git a/QuickView/ImageEngine.cpp b/QuickView/ImageEngine.cpp
index 21d57e2..7a8d7cc 100644
--- a/QuickView/ImageEngine.cpp
+++ b/QuickView/ImageEngine.cpp
@@ -19,6 +19,8 @@ namespace {
         ImageEngine* engine;
         std::wstring path;
         ImageID id;
+        PaneSlot targetSlot;
+        uint64_t generationId;
     };
 }
 
@@ -150,7 +152,7 @@ void ImageEngine::SetTargetHdrHeadroomStops(float stops) {
 }
 
 // Request full resolution decode for current image (used by JXL serial pipeline)
-void ImageEngine::RequestFullDecode(const std::wstring& path, ImageID imageId) {
+void ImageEngine::RequestFullDecode(const std::wstring& path, ImageID imageId, PaneSlot targetSlot, uint64_t generationId) {
     // Node B: Decoding Complete / Request Full Decode
     QV_LOG("ImageEngine_FullDecode",
         TraceLoggingInt32(g_debugMetrics.lastUploadChannel.load(), "LastUploadChannel"),
@@ -161,7 +163,7 @@ void ImageEngine::RequestFullDecode(const std::wstring& path, ImageID imageId) {
     if (!m_heavyPool) return;
     
     // Only proceed if this is still the current image
-    if (imageId != m_currentImageId.load()) {
+    if (imageId != m_currentImageIdBySlot[static_cast<int>(targetSlot)].load()) {
         QV_LOG("Engine_FullDecode", TraceLoggingString("Cancelled ImageChanged", "Action"));
         return;
     }
@@ -178,7 +180,7 @@ void ImageEngine::RequestFullDecode(const std::wstring& path, ImageID imageId) {
     // [Note] No MMF passed here because this is a delayed request (MMF might not persist unless Titan)
     // Actually, if we are in Titan mode, m_mmf is valid. If not, it's null.
     // It's safe to pass m_mmf (member) here.
-    m_heavyPool->SubmitFullDecode(path, imageId, m_mmf);
+    m_heavyPool->SubmitFullDecode(path, imageId, m_mmf, targetSlot, generationId);
     
     QV_LOG("Engine_FullDecode",
         TraceLoggingString("Requested", "Action"),
@@ -186,7 +188,7 @@ void ImageEngine::RequestFullDecode(const std::wstring& path, ImageID imageId) {
 }
 
 // [Phase 2] Dispatcher Implementation
-void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, uintmax_t fileSize) {
+void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, uintmax_t fileSize, PaneSlot targetSlot, uint64_t generationId) {
     // 1. Peek Header
     CImageLoader::ImageHeaderInfo info = m_loader->PeekHeader(path.c_str());
 
@@ -343,6 +345,8 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
                 e.type = EventType::FullReady;
                 e.filePath = path; 
                 e.imageId = imageId;
+                e.targetSlot = targetSlot;
+                e.generationId = generationId;
                 e.rawFrame = cachedFrame; // Zero-copy shared_ptr
                 
                 // [Fix - Bug 7] Re-populate metadata from cache
@@ -413,7 +417,7 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
         if (m_config.ForceRawDecode) {
             // [Fix] Explicitly request Full Decode
             // This ensures we bypass IDCT scaling and get the full sensor resolution
-            m_heavyPool->SubmitFullDecode(path, imageId, primaryMMF);
+            m_heavyPool->SubmitFullDecode(path, imageId, primaryMMF, targetSlot, generationId);
             return; 
         }
         else if (info.hasEmbeddedThumb) {
@@ -455,7 +459,7 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
              } else {
                 // [v7.2 Fix] Large WebP -> Force Heavy Direct (non-Titan is full decode).
                  QV_LOG("Dispatch_Route", TraceLoggingString("WebP Large HeavyDirect", "Action"));
-                 m_heavyPool->Submit(path, imageId, primaryMMF);
+                 m_heavyPool->Submit(path, imageId, primaryMMF, targetSlot, generationId);
                  return; 
              }
         }
@@ -470,7 +474,7 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
         
         if (fmtLower == L"webp") {
              QV_LOG("Dispatch_Route", TraceLoggingString("WebP Heavy HeavyDirect", "Action"));
-             m_heavyPool->Submit(path, imageId, primaryMMF); // Base Layer Scaled
+             m_heavyPool->Submit(path, imageId, primaryMMF, targetSlot, generationId); // Base Layer Scaled
              return;
         }
         
@@ -481,6 +485,8 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
     if (info.format == L"JXL") {
         m_pendingJxlHeavyPath.clear();
         m_pendingJxlHeavyId = 0;
+        m_pendingJxlHeavySlot = targetSlot;
+        m_pendingJxlHeavyGenerationId = generationId;
         
         // Scene A: Small JXL (< 1MB AND < 2MP) -> FastLane Direct Full Decode
         // 1MB = 1048576 bytes
@@ -493,7 +499,7 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
         if (isSmall) {
             QV_LOG("Dispatch_Route", TraceLoggingString("JXL Small FastLane", "Action"));
             // FastLane will use target=0 if detected as small
-            m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed));
+            m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed), targetSlot, generationId);
         } 
         else {
             if (enableTitan) {
@@ -504,13 +510,15 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
                 // [Fix] Stage 2 Trigger explicitly needs these to be set for the pending heavy decode
                 m_pendingJxlHeavyPath = path;
                 m_pendingJxlHeavyId = imageId;
+                m_pendingJxlHeavySlot = targetSlot;
+                m_pendingJxlHeavyGenerationId = generationId;
                 
-                m_heavyPool->Submit(path, imageId, primaryMMF);
+                m_heavyPool->Submit(path, imageId, primaryMMF, targetSlot, generationId);
             } else {
                 // [v3.2.5 Restore] 鏅€氶潪Titan澶у瀷澶у浘锛屽儚鏃х増涓€鏍风洿鎺ヨ窇 FullDecode
                 // 鍏嶅幓 300ms 寤惰繜锛岄€熷害鏈€蹇紝骞跺ぉ鐒剁敱瑙ｇ爜绔睍绀鸿嚜甯﹂瑙堝浘锛?                 QV_LOG("Dispatch_Route", TraceLoggingString("JXL Large HeavyFullDecode", "Action"));
-                m_heavyPool->SubmitFullDecode(path, imageId, primaryMMF);
+                m_heavyPool->SubmitFullDecode(path, imageId, primaryMMF, targetSlot, generationId);
             }
         }
         return; // JXL dispatched
@@ -559,10 +567,10 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
 
         if (isSmall) {
             QV_LOG("Dispatch_Route", TraceLoggingString("FormatSmall FastLane", "Action"));
-            m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed));
+            m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed), targetSlot, generationId);
         } else {
             QV_LOG("Dispatch_Route", TraceLoggingString("FormatLarge HeavyLane", "Action"));
-            m_heavyPool->Submit(path, imageId, primaryMMF);
+            m_heavyPool->Submit(path, imageId, primaryMMF, targetSlot, generationId);
         }
         return;
     }
@@ -570,18 +578,18 @@ void ImageEngine::DispatchImageLoad(const std::wstring& path, ImageID imageId, u
     // 7. Standard Routing
     if (useHeavy) {
         QV_LOG("Dispatch_Route", TraceLoggingString("HeavyLane", "Action"));
-        m_heavyPool->Submit(path, imageId, primaryMMF);
+        m_heavyPool->Submit(path, imageId, primaryMMF, targetSlot, generationId);
     }
     if (useFastLane) {
         // Avoid parallel duplicate work if Heavy is already taking it?
         // Logic: TypeA -> FastLane only. TypeB -> Heavy only.
         // Unknown type -> Parallel (Both).
         QV_LOG("Dispatch_Route", TraceLoggingString("FastLane", "Action"));
-        m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed));
+        m_fastLane.Push(path, imageId, m_targetHdrHeadroomStops.load(std::memory_order_relaxed), targetSlot, generationId);
     }
 }
 
-void ImageEngine::NavigateTo(const std::wstring& path, uintmax_t fileSize, uint64_t navToken) {
+void ImageEngine::NavigateTo(const std::wstring& path, uintmax_t fileSize, uint64_t navToken, PaneSlot targetSlot, uint64_t generationId) {
     if (path.empty()) return;
     
     // [Phase 3] Store the navigation token
@@ -590,8 +598,9 @@ void ImageEngine::NavigateTo(const std::wstring& path, uintmax_t fileSize, uint6
     // [ImageID Architecture] Compute stable hash
     ImageID imageId = ComputePathHash(path);
     m_currentImageId.store(imageId);
-    // Cancel stale heavy/tile work immediately for all dispatch paths.
-    m_heavyPool->CancelOthers(imageId);
+    m_currentImageIdBySlot[static_cast<int>(targetSlot)].store(imageId);
+    // Cancel stale heavy/tile work immediately for the target pane.
+    m_heavyPool->CancelOthers(imageId, targetSlot);
     
     m_currentNavPath = path;
     m_lastInputTime = std::chrono::steady_clock::now();
@@ -602,7 +611,11 @@ void ImageEngine::NavigateTo(const std::wstring& path, uintmax_t fileSize, uint6
     m_baseLayerReady.store(false);
 
     // Use Central Dispatcher
-    DispatchImageLoad(path, imageId, fileSize);
+    DispatchImageLoad(path, imageId, fileSize, targetSlot, generationId);
+}
+
+ImageID ImageEngine::GetCurrentImageId(PaneSlot slot) const {
+    return m_currentImageIdBySlot[static_cast<int>(slot)].load();
 }
 
 bool ImageEngine::ShouldSkipFastLaneForFastFormat(const std::wstring& path) {
@@ -685,7 +698,7 @@ std::vector<EngineEvent> ImageEngine::PollState() {
                 // [JXL Serial] Trigger Stage 2 IMMEDIATELY for JXL (No 300ms wait)
                 if (m_pendingJxlHeavyId == e.imageId && m_pendingJxlHeavyId != 0) {
                      QV_LOG("PollState_Route", TraceLoggingString("JXL PreviewReady HeavyImmediate", "Action"));
-                     RequestFullDecode(m_pendingJxlHeavyPath, m_pendingJxlHeavyId);
+                     RequestFullDecode(m_pendingJxlHeavyPath, m_pendingJxlHeavyId, m_pendingJxlHeavySlot, m_pendingJxlHeavyGenerationId);
                      m_stage2Requested = true; 
                      m_pendingJxlHeavyId = 0; 
                 }
@@ -699,7 +712,7 @@ std::vector<EngineEvent> ImageEngine::PollState() {
                 // [JXL Scene C] FastLane Aborted (Modular?) -> Trigger Heavy Immediately
                 if (m_pendingJxlHeavyId == e.imageId && m_pendingJxlHeavyId != 0) {
                      QV_LOG("PollState_Route", TraceLoggingString("FastLane Failed HeavyImmediate", "Action"));
-                     RequestFullDecode(m_pendingJxlHeavyPath, m_pendingJxlHeavyId);
+                     RequestFullDecode(m_pendingJxlHeavyPath, m_pendingJxlHeavyId, m_pendingJxlHeavySlot, m_pendingJxlHeavyGenerationId);
                      m_stage2Requested = true; // Mark as requested
                      m_pendingJxlHeavyId = 0;  // Consumed
                 }
@@ -770,11 +783,11 @@ std::vector<EngineEvent> ImageEngine::PollState() {
     
     // Check Timer (300ms idle)
     // Only if pending JXL is waiting and not already requested
-    if (m_isViewingScaledImage && !m_stage2Requested && m_pendingJxlHeavyId != 0 && m_pendingJxlHeavyId == m_currentImageId.load()) {
+    if (m_isViewingScaledImage && !m_stage2Requested && m_pendingJxlHeavyId != 0 && m_pendingJxlHeavyId == m_currentImageIdBySlot[static_cast<int>(m_pendingJxlHeavySlot)].load()) {
         auto now = std::chrono::steady_clock::now();
         auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_stage1Time).count();
         if (dur > 300) {
-             RequestFullDecode(m_currentNavPath, m_currentImageId.load());
+             RequestFullDecode(m_currentNavPath, m_currentImageIdBySlot[static_cast<int>(m_pendingJxlHeavySlot)].load(), m_pendingJxlHeavySlot, m_pendingJxlHeavyGenerationId);
              m_stage2Requested = true;
              m_pendingJxlHeavyId = 0; // Consumed
         }
@@ -1057,11 +1070,11 @@ void ImageEngine::FastLane::Clear() {
     // m_skipCount is not reset here, it accumulates for debug stats.
 }
 
-void ImageEngine::FastLane::Push(const std::wstring& path, ImageID id, float targetHdrHeadroomStops) {
+void ImageEngine::FastLane::Push(const std::wstring& path, ImageID id, float targetHdrHeadroomStops, PaneSlot targetSlot, uint64_t generationId) {
     if (m_stopSignal) return;
     {
         std::lock_guard lock(m_queueMutex);
-        m_queue.push_back({path, id, targetHdrHeadroomStops});
+        m_queue.push_back({path, id, targetHdrHeadroomStops, targetSlot, generationId});
         // [v3.1] Simplified Push: No complex anti-explosion here.
         // UpdateView()'s "Ruthless Purge" handles queue depth.
     }
@@ -1157,7 +1170,7 @@ void ImageEngine::FastLane::QueueWorker() {
 
             // [Direct D2D] Load directly to RawImageFrame backed by Arena
             {
-                auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ m_parent, cmd.path, cmd.id };
+                auto* ctx = new(std::nothrow) AuxLayerReadyCtx{ m_parent, cmd.path, cmd.id, cmd.targetSlot, cmd.generationId };
                 if (ctx) {
                     rawFrame.onAuxLayerReady.ctx = ctx;
                     rawFrame.onAuxLayerReady.pfn = [](void* c, std::unique_ptr<QuickView::AuxLayer> aux, QuickView::GpuBlendOp op, QuickView::GpuShaderPayload payload) {
@@ -1166,6 +1179,8 @@ void ImageEngine::FastLane::QueueWorker() {
                         ev.type = EventType::AuxLayerReady;
                         ev.filePath = lctx->path;
                         ev.imageId = lctx->id;
+                        ev.targetSlot = lctx->targetSlot;
+                        ev.generationId = lctx->generationId;
                         ev.auxLayer = std::move(aux);
                         ev.blendOp = op;
                         ev.shaderPayload = payload;
@@ -1195,7 +1210,9 @@ void ImageEngine::FastLane::QueueWorker() {
                 EngineEvent e;
                 e.type = isClear ? EventType::FullReady : EventType::PreviewReady;
                 e.filePath = cmd.path;
-                e.imageId = cmd.id; 
+                e.imageId = cmd.id;
+                e.targetSlot = cmd.targetSlot;
+                e.generationId = cmd.generationId;
                 
                 // [v8.16 Fix] DEEP COPY pixels to heap BEFORE outputting event!
                 // When FastLane immediately starts next job, Arena memory is reused.
@@ -1307,6 +1324,8 @@ void ImageEngine::FastLane::QueueWorker() {
                     e.type = EventType::LoadError;
                     e.filePath = cmd.path;
                     e.imageId = cmd.id;
+                    e.targetSlot = cmd.targetSlot;
+                    e.generationId = cmd.generationId;
                     e.hr = hr; // Propagate error code
                     {
                         std::lock_guard lock(m_queueMutex);
@@ -1336,7 +1355,7 @@ void ImageEngine::SetPrefetchPolicy(const PrefetchPolicy& policy) {
 void ImageEngine::TriggerPendingJxlHeavy() {
     if (!m_pendingJxlHeavyPath.empty() && m_pendingJxlHeavyId != 0) {
         QV_LOG("PollState_Route", TraceLoggingString("JXL Sequential TriggerHeavy", "Action"));
-        m_heavyPool->Submit(m_pendingJxlHeavyPath, m_pendingJxlHeavyId);
+        m_heavyPool->Submit(m_pendingJxlHeavyPath, m_pendingJxlHeavyId, nullptr, m_pendingJxlHeavySlot, m_pendingJxlHeavyGenerationId);
         m_pendingJxlHeavyPath.clear();
         m_pendingJxlHeavyId = 0;
     }
diff --git a/QuickView/ImageEngine.h b/QuickView/ImageEngine.h
index 8dea20d..923040f 100644
--- a/QuickView/ImageEngine.h
+++ b/QuickView/ImageEngine.h
@@ -20,6 +20,7 @@
 #include "EditState.h"
 #include "SystemInfo.h"  // [N+1] Hardware detection & auto-config
 #include "FileNavigator.h"  // [ImageID] For ImageID type and ComputePathHash
+#include "PaneTypes.h"
 
 // Forward declarations
 class HeavyLanePool; 
@@ -54,6 +55,8 @@ struct EngineEvent {
     std::wstring filePath; // Which file is this event for?
     uint64_t navToken = 0; // [Phase 3] Navigation session token (deprecated, use imageId)
     ImageID imageId = 0;   // [ImageID Architecture] Stable content-based hash
+    PaneSlot targetSlot = PaneSlot::Primary;
+    uint64_t generationId = 0;
     
     // Payload (Optional parts)
     ComPtr<IWICBitmapSource> fullImage;    // For FullReady (Legacy, being deprecated)
@@ -96,7 +99,7 @@ public:
     /// </summary>
     // fileSize: Used for Threshold Dispatch (Fast/Heavy/Express)
     // navToken: [Phase 3] Navigation session token for event filtering
-    void NavigateTo(const std::wstring& path, uintmax_t fileSize = 0, uint64_t navToken = 0);
+    void NavigateTo(const std::wstring& path, uintmax_t fileSize = 0, uint64_t navToken = 0, PaneSlot targetSlot = PaneSlot::Primary, uint64_t generationId = 0);
     void SetWindow(HWND hwnd);
     void SetTargetHdrHeadroomStops(float stops);
     
@@ -104,7 +107,7 @@ public:
     void CancelHeavy();  // Implementation in ImageEngine.cpp
     
     // Request full resolution decode for current image (used by JXL serial pipeline)
-    void RequestFullDecode(const std::wstring& path, ImageID imageId);
+    void RequestFullDecode(const std::wstring& path, ImageID imageId, PaneSlot targetSlot = PaneSlot::Primary, uint64_t generationId = 0);
     
     // [JXL Sequential] Trigger pending Heavy task after FastLane completes
     void TriggerPendingJxlHeavy();
@@ -137,6 +140,7 @@ public:
     
     // [v4.0] Infrastructure: Global Token Access
     ImageID GetGlobalToken() const { return m_currentImageId.load(); }
+    ImageID GetCurrentImageId(PaneSlot slot) const;
     CImageLoader* GetLoader() const { return m_loader; }
     
     // [Phase 6] Dynamic Gating
@@ -290,7 +294,7 @@ private:
     bool ShouldSkipFastLaneForFastFormat(const std::wstring& path);
 
     // [Phase 2] Dispatcher
-    void DispatchImageLoad(const std::wstring& path, ImageID imageId, uintmax_t fileSize);
+    void DispatchImageLoad(const std::wstring& path, ImageID imageId, uintmax_t fileSize, PaneSlot targetSlot, uint64_t generationId);
 
     // --- Lane 1: The Fast Lane ---
     class FastLane {
@@ -302,7 +306,7 @@ private:
         // [v3.1] Ruthless Purge: Clear pending queue
         // [v3.1] Ruthless Purge: Clear pending queue
         void Clear();
-        void Push(const std::wstring& path, ImageID id, float targetHdrHeadroomStops = -1.0f);
+        void Push(const std::wstring& path, ImageID id, float targetHdrHeadroomStops = -1.0f, PaneSlot targetSlot = PaneSlot::Primary, uint64_t generationId = 0);
         std::optional<EngineEvent> TryPopResult();
         bool IsQueueEmpty() const;
         
@@ -341,6 +345,8 @@ private:
             std::wstring path;
             ImageID id;
             float targetHdrHeadroomStops = -1.0f;
+            PaneSlot targetSlot = PaneSlot::Primary;
+            uint64_t generationId = 0;
         };
         std::deque<FastLaneCommand> m_queue; 
         std::deque<EngineEvent> m_results; 
@@ -367,11 +373,14 @@ private:
     
     // [ImageID Architecture] Stable content-based ID for current image
     std::atomic<ImageID> m_currentImageId{0};
+    std::atomic<ImageID> m_currentImageIdBySlot[2]{};
     std::atomic<bool> m_baseLayerReady{false};
     
     // [JXL Sequential] Pending Heavy task - waits for FastLane completion
     std::wstring m_pendingJxlHeavyPath;
     ImageID m_pendingJxlHeavyId = 0;
+    PaneSlot m_pendingJxlHeavySlot = PaneSlot::Primary;
+    uint64_t m_pendingJxlHeavyGenerationId = 0;
 
     // [JXL Serial] State Tracking
     bool m_isViewingScaledImage = false; // True if current view is Fast/Preview (Scaled)
diff --git a/QuickView/ImageLoader.cpp b/QuickView/ImageLoader.cpp
index 45d822c..2245cbb 100644
--- a/QuickView/ImageLoader.cpp
+++ b/QuickView/ImageLoader.cpp
@@ -45,7 +45,7 @@ using namespace QuickView;
 #include <shobjidl.h> // [Add] for IShellItemImageFactory
 #include <thread>
 
-extern FileNavigator g_navigator;
+extern FileNavigator& g_navigator;
 
 // Forward declaration
 static bool ReadFileToVector(LPCWSTR filePath, std::vector<uint8_t> &buffer);
diff --git a/QuickView/ImageResource.h b/QuickView/ImageResource.h
new file mode 100644
index 0000000..64a6d5e
--- /dev/null
+++ b/QuickView/ImageResource.h
@@ -0,0 +1,107 @@
+/*
+ * QuickView - Image Resource Management and GPU Asset Handles
+ * Copyright (C) 2026-Present QuickView Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "pch.h"
+#include "ImageTypes.h"
+#include "AnimationDecoder.h"
+
+#include <d2d1_2.h>
+#include <d2d1_3.h>
+#include <dxgi1_2.h>
+#include <memory>
+#include <wrl/client.h>
+
+using Microsoft::WRL::ComPtr;
+
+struct ImageResource {
+    ComPtr<ID2D1Bitmap> bitmap;
+    ComPtr<ID2D1SvgDocument> svgDoc;
+    bool isSvg = false;
+    float svgW = 0.0f;
+    float svgH = 0.0f;
+
+    QuickView::GpuBlendOp blendOp = QuickView::GpuBlendOp::None;
+    QuickView::GpuShaderPayload shaderPayload = {};
+    std::unique_ptr<QuickView::AuxLayer> auxLayer;
+
+    std::shared_ptr<QuickView::IAnimationDecoder> animator;
+    QuickView::AnimationFrameMeta frameMeta;
+
+    void Reset() {
+        bitmap.Reset();
+        svgDoc.Reset();
+        isSvg = false;
+        svgW = 0.0f;
+        svgH = 0.0f;
+        blendOp = QuickView::GpuBlendOp::None;
+        shaderPayload = {};
+        auxLayer.reset();
+        animator.reset();
+        frameMeta = {};
+    }
+
+    ImageResource() = default;
+    ImageResource(const ImageResource&) = delete;
+    ImageResource& operator=(const ImageResource&) = delete;
+    ImageResource(ImageResource&&) = default;
+    ImageResource& operator=(ImageResource&&) = default;
+
+    ImageResource Clone() const {
+        ImageResource cloned;
+        cloned.bitmap = bitmap;
+        cloned.svgDoc = svgDoc;
+        cloned.isSvg = isSvg;
+        cloned.svgW = svgW;
+        cloned.svgH = svgH;
+        cloned.blendOp = blendOp;
+        cloned.shaderPayload = shaderPayload;
+        if (auxLayer) {
+            cloned.auxLayer = auxLayer->Clone();
+        }
+        cloned.animator = animator;
+        cloned.frameMeta = frameMeta;
+        return cloned;
+    }
+
+    D2D1_SIZE_F GetSize() const {
+        if (isSvg) return D2D1::SizeF(svgW, svgH);
+        if (bitmap) return bitmap->GetSize();
+        return D2D1::SizeF(0.0f, 0.0f);
+    }
+
+    operator bool() const {
+        return (isSvg && svgDoc) || bitmap;
+    }
+};
+
+inline DXGI_FORMAT GetImageResourceSurfaceFormat(const ImageResource& resource) {
+    if (!resource.bitmap) {
+        return DXGI_FORMAT_B8G8R8A8_UNORM;
+    }
+
+    const DXGI_FORMAT bitmapFormat = resource.bitmap->GetPixelFormat().format;
+    if (bitmapFormat == DXGI_FORMAT_R16G16B16A16_FLOAT ||
+        bitmapFormat == DXGI_FORMAT_R32G32B32A32_FLOAT) {
+        return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    }
+
+    return DXGI_FORMAT_B8G8R8A8_UNORM;
+}
+
diff --git a/QuickView/PaneContext.h b/QuickView/PaneContext.h
new file mode 100644
index 0000000..eba0644
--- /dev/null
+++ b/QuickView/PaneContext.h
@@ -0,0 +1,64 @@
+/*
+ * QuickView - Compare Mode Pane Context and State Tracking
+ * Copyright (C) 2026-Present QuickView Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "PaneTypes.h"
+#include "ImageResource.h"
+#include "EditState.h"
+#include "FileNavigator.h"
+#include "ImageLoader.h"
+
+#include <cstdint>
+#include <string>
+
+struct PaneContext {
+    ImageResource resource;
+    std::wstring path;
+    EditState editState;
+    ViewState view;
+    FileNavigator navigator;
+    CImageLoader::ImageMetadata metadata;
+    bool valid = false;
+    uint64_t generationId = 0;
+
+    int CmsModeOverride = -1;
+    bool EnableSoftProofing = false;
+    std::wstring SoftProofProfilePath;
+
+    void Reset() {
+        resource.Reset();
+        path.clear();
+        editState.Reset();
+        view.Reset();
+        metadata = {};
+        valid = false;
+        CmsModeOverride = -1;
+        EnableSoftProofing = false;
+        SoftProofProfilePath.clear();
+        ++generationId;
+    }
+};
+
+extern PaneContext g_panes[2];
+
+inline PaneContext& GetPaneContext(PaneSlot slot) {
+    return g_panes[static_cast<int>(slot)];
+}
+
+
diff --git a/QuickView/PaneTypes.h b/QuickView/PaneTypes.h
new file mode 100644
index 0000000..b58077d
--- /dev/null
+++ b/QuickView/PaneTypes.h
@@ -0,0 +1,25 @@
+/*
+ * QuickView - Compare Mode Pane Slot Enumeration
+ * Copyright (C) 2026-Present QuickView Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+enum class PaneSlot {
+    Primary = 0,
+    Left = 1
+};
+
diff --git a/QuickView/SettingsOverlay.cpp b/QuickView/SettingsOverlay.cpp
index c0dacc1..ad7d592 100644
--- a/QuickView/SettingsOverlay.cpp
+++ b/QuickView/SettingsOverlay.cpp
@@ -26,8 +26,8 @@
 extern ImageEngine* g_pImageEngine;
 extern AppConfig g_config;
 extern RuntimeConfig g_runtime;
-extern std::wstring g_imagePath;
-extern FileNavigator g_navigator;
+extern std::wstring& g_imagePath;
+extern FileNavigator& g_navigator;
 extern Toolbar g_toolbar; // [Fix] Allow Settings to update toolbar state directly
 extern HelpOverlay g_helpOverlay;
 
diff --git a/QuickView/ThumbnailManager.cpp b/QuickView/ThumbnailManager.cpp
index 8e4d655..ca21d7a 100644
--- a/QuickView/ThumbnailManager.cpp
+++ b/QuickView/ThumbnailManager.cpp
@@ -3,7 +3,7 @@
 #include <algorithm>
 #include <cwctype>
 #include "FileNavigator.h"
-extern FileNavigator g_navigator;
+extern FileNavigator& g_navigator;
 
 ThumbnailManager::ThumbnailManager() {}
 
diff --git a/QuickView/Toolbar.cpp b/QuickView/Toolbar.cpp
index 0f451f6..6e090f0 100644
--- a/QuickView/Toolbar.cpp
+++ b/QuickView/Toolbar.cpp
@@ -8,7 +8,7 @@
 using QuickView::UI::GeekIconRenderer;
 
 extern AppConfig g_config;
-extern FileNavigator g_navigator;
+extern FileNavigator& g_navigator;
 
 namespace Icons = GeekIcons;
 
diff --git a/QuickView/UIRenderer.cpp b/QuickView/UIRenderer.cpp
index 6026e19..dfd3eaf 100644
--- a/QuickView/UIRenderer.cpp
+++ b/QuickView/UIRenderer.cpp
@@ -26,7 +26,7 @@ extern HelpOverlay g_helpOverlay;
 extern ImageEngine* g_pImageEngine; // [v3.1] Accessor (renamed from g_imageEngine)
 
 #include "FileNavigator.h"
-extern FileNavigator g_navigator;
+extern FileNavigator& g_navigator;
 
 // DrawDialog is still in main.cpp (modal dialog handling)
 extern void DrawDialog(ID2D1DeviceContext* context, const RECT& clientRect);
@@ -35,9 +35,9 @@ extern RuntimeConfig g_runtime;
 extern bool g_isLoading; // [Fix] Loading indicator for progress bar
 extern bool g_isLeftPaneDecoding; // [Fix] Left pane decoding status
 extern bool g_isNavigatingToTitan; // [Fix] Restrict decode progress bar to Titan images
-extern ViewState g_viewState;  // [v3.2] For Nav Indicators
-extern CImageLoader::ImageMetadata g_currentMetadata;  // [v3.2] For Info Panel
-extern std::wstring g_imagePath;  // [v3.2] For Info Panel
+extern ViewState& g_viewState;  // [v3.2] For Nav Indicators
+extern CImageLoader::ImageMetadata& g_currentMetadata;  // [v3.2] For Info Panel
+extern std::wstring& g_imagePath;  // [v3.2] For Info Panel
 extern bool g_slowMotionMode; // [Debug] Slow-motion crossfade mode
 extern AppConfig g_config;
 extern int GetCurrentZoomPercent(); // [v3.2.3] For Info Panel Zoom Display
diff --git a/QuickView/main.cpp b/QuickView/main.cpp
index 29f30bb..ae73dea 100644
--- a/QuickView/main.cpp
+++ b/QuickView/main.cpp
@@ -16,6 +16,7 @@ static constexpr const char* CURRENT_MODULE = "Main";
 #include "InputController.h"  // Quantum Stream: Warp Mode
 #include "LosslessTransform.h"
 #include "EditState.h"
+#include "PaneContext.h"
 #include "AppStrings.h"
 #include "ContextMenu.h"
 #include "SupportedExtensions.h"
@@ -236,85 +237,11 @@ FlushMenuThemesFn LoadFlushMenuThemes() {
 }
 }
 
-// [Step 3] Unified Resource Management
-struct ImageResource {
-    ComPtr<ID2D1Bitmap> bitmap;
-    ComPtr<ID2D1SvgDocument> svgDoc;
-    bool isSvg = false;
-    float svgW = 0, svgH = 0;
-    
-    // [GPU Pipeline] Multi-layer composition
-    QuickView::GpuBlendOp blendOp = QuickView::GpuBlendOp::None;
-    QuickView::GpuShaderPayload shaderPayload = {};
-    std::unique_ptr<QuickView::AuxLayer> auxLayer;
-
-    // [v10.5] Animation state
-    std::shared_ptr<QuickView::IAnimationDecoder> animator;
-    QuickView::AnimationFrameMeta frameMeta;
-
-    void Reset() {
-        bitmap.Reset();
-        svgDoc.Reset();
-        isSvg = false;
-        svgW = 0; svgH = 0;
-        blendOp = QuickView::GpuBlendOp::None;
-        shaderPayload = {};
-        auxLayer.reset();
-        animator.reset();
-        frameMeta = {};
-    }
-
-    ImageResource() = default;
-    ImageResource(const ImageResource&) = delete;
-    ImageResource& operator=(const ImageResource&) = delete;
-    ImageResource(ImageResource&&) = default;
-    ImageResource& operator=(ImageResource&&) = default;
-
-    ImageResource Clone() const {
-        ImageResource cloned;
-        cloned.bitmap = bitmap;
-        cloned.svgDoc = svgDoc;
-        cloned.isSvg = isSvg;
-        cloned.svgW = svgW;
-        cloned.svgH = svgH;
-        cloned.blendOp = blendOp;
-        cloned.shaderPayload = shaderPayload;
-        if (auxLayer) {
-            cloned.auxLayer = auxLayer->Clone();
-        }
-        cloned.animator = animator;
-        cloned.frameMeta = frameMeta;
-        return cloned;
-    }
-    
-    D2D1_SIZE_F GetSize() const {
-        if (isSvg) return D2D1::SizeF(svgW, svgH);
-        if (bitmap) return bitmap->GetSize();
-        return D2D1::SizeF(0, 0);
-    }
-    
-    // Truthy check
-    operator bool() const {
-        return (isSvg && svgDoc) || bitmap;
-    }
-};
-
-static DXGI_FORMAT GetImageResourceSurfaceFormat(const ImageResource& resource) {
-    if (!resource.bitmap) {
-        return DXGI_FORMAT_B8G8R8A8_UNORM;
-    }
-
-    const DXGI_FORMAT bitmapFormat = resource.bitmap->GetPixelFormat().format;
-    if (bitmapFormat == DXGI_FORMAT_R16G16B16A16_FLOAT ||
-        bitmapFormat == DXGI_FORMAT_R32G32B32A32_FLOAT) {
-        return DXGI_FORMAT_R16G16B16A16_FLOAT;
-    }
-
-    return DXGI_FORMAT_B8G8R8A8_UNORM;
-}
-
-static ImageResource g_imageResource;
-std::wstring g_imagePath;  // Non-static for extern access from UIRenderer
+PaneContext g_panes[2];
+FileNavigator& g_navigator = g_panes[0].navigator;
+std::wstring& g_imagePath = g_panes[0].path;
+CImageLoader::ImageMetadata& g_currentMetadata = g_panes[0].metadata;
+ViewState& g_viewState = g_panes[0].view;
 static bool g_isImageDirty = true; // Feature: Conditional Image Repaint (DComp Optimization)
 static bool g_isBlurry = false; // For Motion Blur (Ghost)
 static bool g_isCrossFading = false;
@@ -332,20 +259,16 @@ static const UINT_PTR TIMER_ID_REGISTRY_CHECK = 993;
 
 DWORD g_toolbarHideTime = 0; // For auto-hide delay
 static DialogState g_dialog;
-static EditState g_editState;
 AppConfig g_config;
 RuntimeConfig g_runtime;
-ViewState g_viewState;  // Non-static for extern access from UIRenderer
 bool g_preserveViewStateOnNextLoad = false;
 ViewState g_preservedViewState;
 static int g_renderExifOrientation = 1; // Exif orientation baked into the bitmap surface
-FileNavigator g_navigator; // New Navigator (Non-static for extern access from SettingsOverlay)
 static ThumbnailManager g_thumbMgr;
 GalleryOverlay g_gallery;  // Non-static for extern access from UIRenderer
 Toolbar g_toolbar;  // Non-static for extern access from UIRenderer
 SettingsOverlay g_settingsOverlay;  // Non-static for extern access from UIRenderer
 HelpOverlay g_helpOverlay; // Non-static for extern access
-CImageLoader::ImageMetadata g_currentMetadata;  // Non-static for extern access from UIRenderer
 static UINT g_windowDpi = USER_DEFAULT_SCREEN_DPI;
 static float g_uiScale = 1.0f;
 
@@ -425,6 +348,7 @@ void AdjustWindowForOverlay(HWND hwnd, bool isClosed);
 int g_galleryContextMenuIndex = -1;
 // [Fix] Track long operations in the compare left pane
 bool g_isLeftPaneDecoding = false;
+std::function<void(bool)> g_leftPaneReadyCallback = nullptr;
 
 bool g_isLoading = false;           // Show Wait Cursor
 std::atomic<bool> g_isPhase2Debouncing{false}; // Suppress IsIdle logic during phase 2 delay
@@ -579,7 +503,7 @@ static bool g_showTileGrid = false;  // Toggle with Ctrl+4
 static float g_fps = 0.0f;
 
 // Indicates a programmatic resize initiated by zoom/overlay logic.
-// When true, WM_SIZE should not reset g_viewState.Zoom which would cancel
+// When true, WM_SIZE should not reset GetPaneContext(PaneSlot::Primary).view.Zoom which would cancel
 // the intended zoom change. Cleared by WM_SIZE after handling.
 static bool g_programmaticResize = false;
 static bool g_deferProgrammaticZoomResizeSync = false;
@@ -611,40 +535,10 @@ enum class ComparePane {
     Right
 };
 
-struct CompareView {
-    float Zoom = 1.0f;
-    float PanX = 0.0f;
-    float PanY = 0.0f;
-    int ExifOrientation = 1;
-};
-
-struct CompareSlot {
-    ImageResource resource;
-    CImageLoader::ImageMetadata metadata;
-    std::wstring path;
-    CompareView view;
-    bool valid = false;
-    EditState editState;
-    int CmsModeOverride = -1;
-    bool EnableSoftProofing = false;
-    std::wstring SoftProofProfilePath;
-
-    void Reset() {
-        resource.Reset();
-        metadata = {};
-        path.clear();
-        view = {};
-        valid = false;
-        editState.Reset();
-        CmsModeOverride = -1;
-        EnableSoftProofing = false;
-        SoftProofProfilePath.clear();
-    }
-};
+using CompareView = ViewState;
 
 struct CompareState {
     ViewMode mode = ViewMode::Single;
-    CompareSlot left;
     float splitRatio = 0.5f;
     bool syncZoom = true;
     bool syncPan = true;
@@ -706,17 +600,17 @@ bool IsCompareModeActive();
 bool IsRawFile(const std::wstring& path); // Forward declaration
 
 static void UpdateCompareRawButton() {
-    bool leftIsRaw = !g_compare.left.path.empty() && IsRawFile(g_compare.left.path);
-    bool rightIsRaw = !g_imagePath.empty() && IsRawFile(g_imagePath);
+    bool leftIsRaw = !GetPaneContext(PaneSlot::Left).path.empty() && IsRawFile(GetPaneContext(PaneSlot::Left).path);
+    bool rightIsRaw = !GetPaneContext(PaneSlot::Primary).path.empty() && IsRawFile(GetPaneContext(PaneSlot::Primary).path);
     bool anyRaw = leftIsRaw || rightIsRaw;
     bool selectedIsRaw = (g_compare.selectedPane == ComparePane::Left) ? leftIsRaw : rightIsRaw;
     
     // [Fix] Read isolated decode state from the metadata of the selected pane instead of global g_runtime.ForceRawDecode
     bool isFullDecode = false;
     if (g_compare.selectedPane == ComparePane::Left) {
-        if (leftIsRaw) isFullDecode = g_compare.left.metadata.IsRawFullDecode;
+        if (leftIsRaw) isFullDecode = GetPaneContext(PaneSlot::Left).metadata.IsRawFullDecode;
     } else {
-        if (rightIsRaw) isFullDecode = g_currentMetadata.IsRawFullDecode;
+        if (rightIsRaw) isFullDecode = GetPaneContext(PaneSlot::Primary).metadata.IsRawFullDecode;
     }
 
     g_toolbar.SetCompareRawState(anyRaw, selectedIsRaw, isFullDecode);
@@ -730,14 +624,14 @@ static bool GetComparePaneRawState(ComparePane pane, bool& isRaw, bool& isFullDe
     }
 
     if (pane == ComparePane::Left) {
-        isRaw = !g_compare.left.path.empty() && IsRawFile(g_compare.left.path);
-        isFullDecode = isRaw && g_compare.left.metadata.IsRawFullDecode;
-        return g_compare.left.valid;
+        isRaw = !GetPaneContext(PaneSlot::Left).path.empty() && IsRawFile(GetPaneContext(PaneSlot::Left).path);
+        isFullDecode = isRaw && GetPaneContext(PaneSlot::Left).metadata.IsRawFullDecode;
+        return GetPaneContext(PaneSlot::Left).valid;
     }
 
-    isRaw = !g_imagePath.empty() && IsRawFile(g_imagePath);
-    isFullDecode = isRaw && g_currentMetadata.IsRawFullDecode;
-    return static_cast<bool>(g_imageResource);
+    isRaw = !GetPaneContext(PaneSlot::Primary).path.empty() && IsRawFile(GetPaneContext(PaneSlot::Primary).path);
+    isFullDecode = isRaw && GetPaneContext(PaneSlot::Primary).metadata.IsRawFullDecode;
+    return static_cast<bool>(GetPaneContext(PaneSlot::Primary).resource);
 }
 
 static void RefreshCompareRawUI(HWND hwnd) {
@@ -780,10 +674,10 @@ static D2D1_SIZE_F GetVisualImageSize();
 VisualState GetVisualState();
 
 void ApplyFullScreenZoomMode(HWND hwnd) {
-    if (!g_imageResource || (!g_isFullScreen && !IsZoomed(hwnd))) return;
+    if (!GetPaneContext(PaneSlot::Primary).resource || (!g_isFullScreen && !IsZoomed(hwnd))) return;
 
     if (g_config.FullScreenZoomMode == 0) { // Fit
-        g_viewState.Zoom = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
     } else { // Auto (100% / Fit)
         D2D1_SIZE_F effSize = GetVisualImageSize();
         float imgW = effSize.width;
@@ -800,9 +694,9 @@ void ApplyFullScreenZoomMode(HWND hwnd) {
 
         // Use true original metadata size to determine 100% target
         float originalW = imgW;
-        if (g_currentMetadata.Width > 0) {
+        if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0) {
             VisualState vs = GetVisualState();
-            originalW = (float)(vs.IsRotated90 ? g_currentMetadata.Height : g_currentMetadata.Width);
+            originalW = (float)(vs.IsRotated90 ? GetPaneContext(PaneSlot::Primary).metadata.Height : GetPaneContext(PaneSlot::Primary).metadata.Width);
         }
 
         // The scale factor required to render at exactly 100% original size
@@ -811,13 +705,13 @@ void ApplyFullScreenZoomMode(HWND hwnd) {
         // If the 100% size is smaller than the window, use 100% (renderScaleTarget),
         // which means setting Zoom so that fitScale * Zoom = renderScaleTarget
         if (fitScale > renderScaleTarget) {
-            g_viewState.Zoom = renderScaleTarget / fitScale;
+            GetPaneContext(PaneSlot::Primary).view.Zoom = renderScaleTarget / fitScale;
         } else {
-            g_viewState.Zoom = 1.0f; // Fit
+            GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f; // Fit
         }
     }
-    g_viewState.PanX = 0;
-    g_viewState.PanY = 0;
+    GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+    GetPaneContext(PaneSlot::Primary).view.PanY = 0;
 }
 static bool g_isAutoLocked = false;
 
@@ -1431,7 +1325,7 @@ static DCOMPOSITION_BITMAP_INTERPOLATION_MODE GetOptimalDCompInterpolationMode(f
 }
 
 bool GetCurrentPixelArtState(HWND hwnd) {
-    if (!g_imageResource) return false;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return false;
 
     D2D1_SIZE_F visualSize = GetVisualImageSize();
     float imgW = visualSize.width;
@@ -1444,18 +1338,18 @@ bool GetCurrentPixelArtState(HWND hwnd) {
     if (winW <= 0 || winH <= 0) return false;
 
     float fitScale = std::min(winW / imgW, winH / imgH);
-    if (imgW < 200.0f && imgH < 200.0f && !g_imageResource.isSvg) {
+    if (imgW < 200.0f && imgH < 200.0f && !GetPaneContext(PaneSlot::Primary).resource.isSvg) {
         if (fitScale > 1.0f) fitScale = 1.0f;
     }
 
-    float totalScale = fitScale * g_viewState.Zoom;
+    float totalScale = fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     // Also resolve origW/origH
     float origW = imgW;
     float origH = imgH;
-    if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
-        origW = (float)g_currentMetadata.Width;
-        origH = (float)g_currentMetadata.Height;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
+        origW = (float)GetPaneContext(PaneSlot::Primary).metadata.Width;
+        origH = (float)GetPaneContext(PaneSlot::Primary).metadata.Height;
     }
 
     return IsEffectivelyPixelArtMode(totalScale, origW, origH);
@@ -1554,9 +1448,9 @@ static bool CopyToClipboard(HWND hwnd, const std::wstring& text) {
 
 static void SaveOverlayWindowState(HWND hwnd) {
     GetWindowRect(hwnd, &g_savedState.windowRect);
-    g_savedState.zoom = g_viewState.Zoom;
-    g_savedState.panX = g_viewState.PanX;
-    g_savedState.panY = g_viewState.PanY;
+    g_savedState.zoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+    g_savedState.panX = GetPaneContext(PaneSlot::Primary).view.PanX;
+    g_savedState.panY = GetPaneContext(PaneSlot::Primary).view.PanY;
     g_savedState.isValid = true;
 }
 
@@ -1571,9 +1465,9 @@ static void RestoreOverlayWindowState(HWND hwnd) {
         g_savedState.windowRect.bottom - g_savedState.windowRect.top, 
         SWP_NOZORDER);
     
-    g_viewState.Zoom = g_savedState.zoom;
-    g_viewState.PanX = g_savedState.panX;
-    g_viewState.PanY = g_savedState.panY;
+    GetPaneContext(PaneSlot::Primary).view.Zoom = g_savedState.zoom;
+    GetPaneContext(PaneSlot::Primary).view.PanX = g_savedState.panX;
+    GetPaneContext(PaneSlot::Primary).view.PanY = g_savedState.panY;
     
     g_savedState.isValid = false;
     g_isImageDirty = true; // Force Image layer recalculation
@@ -1657,11 +1551,11 @@ bool GetCompareIndicatorState(int& outPane, float& outSplitRatio, bool& outIsWip
 }
 
 bool GetCompareInfoSnapshot(CImageLoader::ImageMetadata& left, CImageLoader::ImageMetadata& right) {
-    if (!IsCompareModeActive() || !g_compare.left.valid || !g_imageResource) return false;
-    left = g_compare.left.metadata;
-    left.SourcePath = g_compare.left.path;
-    right = g_currentMetadata;
-    right.SourcePath = g_imagePath;
+    if (!IsCompareModeActive() || !GetPaneContext(PaneSlot::Left).valid || !GetPaneContext(PaneSlot::Primary).resource) return false;
+    left = GetPaneContext(PaneSlot::Left).metadata;
+    left.SourcePath = GetPaneContext(PaneSlot::Left).path;
+    right = GetPaneContext(PaneSlot::Primary).metadata;
+    right.SourcePath = GetPaneContext(PaneSlot::Primary).path;
     return true;
 }
 
@@ -1673,37 +1567,37 @@ bool GetAdaptiveUiPaneSnapshot(int paneIndex, AdaptiveUiPaneSnapshot& outSnapsho
     if (!g_mainHwnd) return false;
 
     if (!IsCompareModeActive()) {
-        if (paneIndex != 0 || !g_imageResource || g_imagePath.empty()) return false;
+        if (paneIndex != 0 || !GetPaneContext(PaneSlot::Primary).resource || GetPaneContext(PaneSlot::Primary).path.empty()) return false;
         RECT rc{};
         GetClientRect(g_mainHwnd, &rc);
-        outSnapshot.path = g_imagePath;
+        outSnapshot.path = GetPaneContext(PaneSlot::Primary).path;
         outSnapshot.viewport = D2D1::RectF(0.0f, 0.0f, (float)rc.right, (float)rc.bottom);
-        outSnapshot.visualSize = GetOrientedSize(g_imageResource, g_viewState.ExifOrientation);
-        outSnapshot.zoom = g_viewState.Zoom;
-        outSnapshot.panX = g_viewState.PanX;
-        outSnapshot.panY = g_viewState.PanY;
+        outSnapshot.visualSize = GetOrientedSize(GetPaneContext(PaneSlot::Primary).resource, GetPaneContext(PaneSlot::Primary).view.ExifOrientation);
+        outSnapshot.zoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+        outSnapshot.panX = GetPaneContext(PaneSlot::Primary).view.PanX;
+        outSnapshot.panY = GetPaneContext(PaneSlot::Primary).view.PanY;
         return outSnapshot.visualSize.width > 0.0f && outSnapshot.visualSize.height > 0.0f;
     }
 
     if (paneIndex == 0) {
-        if (!g_compare.left.valid || g_compare.left.path.empty()) return false;
-        outSnapshot.path = g_compare.left.path;
+        if (!GetPaneContext(PaneSlot::Left).valid || GetPaneContext(PaneSlot::Left).path.empty()) return false;
+        outSnapshot.path = GetPaneContext(PaneSlot::Left).path;
         outSnapshot.viewport = GetCompareViewport(g_mainHwnd, ComparePane::Left);
-        outSnapshot.visualSize = GetOrientedSize(g_compare.left.resource, g_compare.left.view.ExifOrientation);
-        outSnapshot.zoom = g_compare.left.view.Zoom;
-        outSnapshot.panX = g_compare.left.view.PanX;
-        outSnapshot.panY = g_compare.left.view.PanY;
+        outSnapshot.visualSize = GetOrientedSize(GetPaneContext(PaneSlot::Left).resource, GetPaneContext(PaneSlot::Left).view.ExifOrientation);
+        outSnapshot.zoom = GetPaneContext(PaneSlot::Left).view.Zoom;
+        outSnapshot.panX = GetPaneContext(PaneSlot::Left).view.PanX;
+        outSnapshot.panY = GetPaneContext(PaneSlot::Left).view.PanY;
         return outSnapshot.visualSize.width > 0.0f && outSnapshot.visualSize.height > 0.0f;
     }
 
     if (paneIndex == 1) {
-        if (!g_imageResource || g_imagePath.empty()) return false;
-        outSnapshot.path = g_imagePath;
+        if (!GetPaneContext(PaneSlot::Primary).resource || GetPaneContext(PaneSlot::Primary).path.empty()) return false;
+        outSnapshot.path = GetPaneContext(PaneSlot::Primary).path;
         outSnapshot.viewport = GetCompareViewport(g_mainHwnd, ComparePane::Right);
-        outSnapshot.visualSize = GetOrientedSize(g_imageResource, g_viewState.ExifOrientation);
-        outSnapshot.zoom = g_viewState.Zoom;
-        outSnapshot.panX = g_viewState.PanX;
-        outSnapshot.panY = g_viewState.PanY;
+        outSnapshot.visualSize = GetOrientedSize(GetPaneContext(PaneSlot::Primary).resource, GetPaneContext(PaneSlot::Primary).view.ExifOrientation);
+        outSnapshot.zoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+        outSnapshot.panX = GetPaneContext(PaneSlot::Primary).view.PanX;
+        outSnapshot.panY = GetPaneContext(PaneSlot::Primary).view.PanY;
         return outSnapshot.visualSize.width > 0.0f && outSnapshot.visualSize.height > 0.0f;
     }
 
@@ -1732,18 +1626,18 @@ static void MarkCompareDirty() {
 
 static CompareView GetRightCompareView() {
     CompareView v;
-    v.Zoom = g_viewState.Zoom;
-    v.PanX = g_viewState.PanX;
-    v.PanY = g_viewState.PanY;
-    v.ExifOrientation = g_viewState.ExifOrientation;
+    v.Zoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+    v.PanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+    v.PanY = GetPaneContext(PaneSlot::Primary).view.PanY;
+    v.ExifOrientation = GetPaneContext(PaneSlot::Primary).view.ExifOrientation;
     return v;
 }
 
 static void SetRightCompareView(const CompareView& view) {
-    g_viewState.Zoom = view.Zoom;
-    g_viewState.PanX = view.PanX;
-    g_viewState.PanY = view.PanY;
-    g_viewState.ExifOrientation = view.ExifOrientation;
+    GetPaneContext(PaneSlot::Primary).view.Zoom = view.Zoom;
+    GetPaneContext(PaneSlot::Primary).view.PanX = view.PanX;
+    GetPaneContext(PaneSlot::Primary).view.PanY = view.PanY;
+    GetPaneContext(PaneSlot::Primary).view.ExifOrientation = view.ExifOrientation;
 }
 
 static CompareView g_rightDragZoomStartLeftView{};
@@ -2051,38 +1945,38 @@ static int GetEffectiveExifOrientation(int baseExif, const EditState& editState)
 }
 
 static void CaptureCurrentImageAsCompareLeft() {
-    if (!g_imageResource || g_imagePath.empty()) return;
-
-    g_compare.left.Reset();
-    g_compare.left.resource = g_imageResource.Clone();
-    g_compare.left.metadata = g_currentMetadata;
-    g_compare.left.path = g_imagePath;
-    g_compare.left.valid = true;
-    g_compare.left.view.Zoom = g_viewState.Zoom;
-    g_compare.left.view.PanX = g_viewState.PanX;
-    g_compare.left.view.PanY = g_viewState.PanY;
-    // [Fix] Use g_renderExifOrientation instead of g_viewState.ExifOrientation.
-    // After RenderImageToDComp, g_viewState.ExifOrientation is neutralized to 1
+    if (!GetPaneContext(PaneSlot::Primary).resource || GetPaneContext(PaneSlot::Primary).path.empty()) return;
+
+    GetPaneContext(PaneSlot::Left).Reset();
+    GetPaneContext(PaneSlot::Left).resource = GetPaneContext(PaneSlot::Primary).resource.Clone();
+    GetPaneContext(PaneSlot::Left).metadata = GetPaneContext(PaneSlot::Primary).metadata;
+    GetPaneContext(PaneSlot::Left).path = GetPaneContext(PaneSlot::Primary).path;
+    GetPaneContext(PaneSlot::Left).valid = true;
+    GetPaneContext(PaneSlot::Left).view.Zoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+    GetPaneContext(PaneSlot::Left).view.PanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+    GetPaneContext(PaneSlot::Left).view.PanY = GetPaneContext(PaneSlot::Primary).view.PanY;
+    // [Fix] Use g_renderExifOrientation instead of GetPaneContext(PaneSlot::Primary).view.ExifOrientation.
+    // After RenderImageToDComp, GetPaneContext(PaneSlot::Primary).view.ExifOrientation is neutralized to 1
     // (since the DComp surface is physically rotated). But the bitmap in
-    // g_imageResource is still un-rotated, so compare mode's DrawResourceIntoViewport
+    // GetPaneContext(PaneSlot::Primary).resource is still un-rotated, so compare mode's DrawResourceIntoViewport
     // needs the original orientation to apply the rotation correctly.
-    g_compare.left.view.ExifOrientation = g_renderExifOrientation;
+    GetPaneContext(PaneSlot::Left).view.ExifOrientation = g_renderExifOrientation;
     if (!g_config.AutoRotate) {
-        g_compare.left.view.ExifOrientation = 1;
-        g_compare.left.metadata.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Left).view.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Left).metadata.ExifOrientation = 1;
     }
-    g_compare.left.CmsModeOverride = g_runtime.CmsModeOverride;
-    g_compare.left.EnableSoftProofing = g_runtime.EnableSoftProofing;
-    g_compare.left.SoftProofProfilePath = g_runtime.SoftProofProfilePath;
+    GetPaneContext(PaneSlot::Left).CmsModeOverride = g_runtime.CmsModeOverride;
+    GetPaneContext(PaneSlot::Left).EnableSoftProofing = g_runtime.EnableSoftProofing;
+    GetPaneContext(PaneSlot::Left).SoftProofProfilePath = g_runtime.SoftProofProfilePath;
     // [Fix] Also restore metadata ExifOrientation (was neutralized after RenderImageToDComp)
     if (g_config.AutoRotate && g_renderExifOrientation > 1) {
-        g_compare.left.metadata.ExifOrientation = g_renderExifOrientation;
+        GetPaneContext(PaneSlot::Left).metadata.ExifOrientation = g_renderExifOrientation;
     }
 }
 
 static bool RenderCompareComposite(HWND hwnd) {
     if (!g_compEngine || !g_compEngine->IsInitialized()) return false;
-    if (!g_compare.left.valid || !g_imageResource) return false;
+    if (!GetPaneContext(PaneSlot::Left).valid || !GetPaneContext(PaneSlot::Primary).resource) return false;
 
     RECT rc{};
     GetClientRect(hwnd, &rc);
@@ -2090,9 +1984,9 @@ static bool RenderCompareComposite(HWND hwnd) {
     const UINT winH = (UINT)(rc.bottom - rc.top);
     if (winW == 0 || winH == 0) return false;
 
-    DXGI_FORMAT compareSurfaceFormat = GetImageResourceSurfaceFormat(g_imageResource);
-    if (g_compare.left.resource.bitmap) {
-        const DXGI_FORMAT leftFormat = GetImageResourceSurfaceFormat(g_compare.left.resource);
+    DXGI_FORMAT compareSurfaceFormat = GetImageResourceSurfaceFormat(GetPaneContext(PaneSlot::Primary).resource);
+    if (GetPaneContext(PaneSlot::Left).resource.bitmap) {
+        const DXGI_FORMAT leftFormat = GetImageResourceSurfaceFormat(GetPaneContext(PaneSlot::Left).resource);
         if (leftFormat == DXGI_FORMAT_R16G16B16A16_FLOAT) {
             compareSurfaceFormat = leftFormat;
         }
@@ -2163,13 +2057,13 @@ static bool RenderCompareComposite(HWND hwnd) {
         const D2D1_RECT_F rightClip = D2D1::RectF(splitX, 0.0f, (float)winW, (float)winH);
 
         ctx->PushAxisAlignedClip(leftClip, D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
-        int leftExif = GetEffectiveExifOrientation(g_compare.left.view.ExifOrientation, g_compare.left.editState);
-        DrawResourceIntoViewport(ctx, g_compare.left.resource, leftExif, g_compare.left.view, full);
+        int leftExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Left).view.ExifOrientation, GetPaneContext(PaneSlot::Left).editState);
+        DrawResourceIntoViewport(ctx, GetPaneContext(PaneSlot::Left).resource, leftExif, GetPaneContext(PaneSlot::Left).view, full);
         ctx->PopAxisAlignedClip();
 
         ctx->PushAxisAlignedClip(rightClip, D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
-        int rightExif = GetEffectiveExifOrientation(g_viewState.ExifOrientation, g_editState);
-        DrawResourceIntoViewport(ctx, g_imageResource, rightExif, rightView, full);
+        int rightExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Primary).view.ExifOrientation, GetPaneContext(PaneSlot::Primary).editState);
+        DrawResourceIntoViewport(ctx, GetPaneContext(PaneSlot::Primary).resource, rightExif, rightView, full);
         ctx->PopAxisAlignedClip();
 
         ComPtr<ID2D1SolidColorBrush> dividerBrush;
@@ -2182,10 +2076,10 @@ static bool RenderCompareComposite(HWND hwnd) {
         const float splitX = 0.5f * (float)winW;
         const D2D1_RECT_F leftVp = D2D1::RectF(0.0f, 0.0f, splitX, (float)winH);
         const D2D1_RECT_F rightVp = D2D1::RectF(splitX, 0.0f, (float)winW, (float)winH);
-        int leftExif = GetEffectiveExifOrientation(g_compare.left.view.ExifOrientation, g_compare.left.editState);
-        int rightExif = GetEffectiveExifOrientation(g_viewState.ExifOrientation, g_editState);
-        DrawResourceIntoViewport(ctx, g_compare.left.resource, leftExif, g_compare.left.view, leftVp);
-        DrawResourceIntoViewport(ctx, g_imageResource, rightExif, rightView, rightVp);
+        int leftExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Left).view.ExifOrientation, GetPaneContext(PaneSlot::Left).editState);
+        int rightExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Primary).view.ExifOrientation, GetPaneContext(PaneSlot::Primary).editState);
+        DrawResourceIntoViewport(ctx, GetPaneContext(PaneSlot::Left).resource, leftExif, GetPaneContext(PaneSlot::Left).view, leftVp);
+        DrawResourceIntoViewport(ctx, GetPaneContext(PaneSlot::Primary).resource, rightExif, rightView, rightVp);
 
         ComPtr<ID2D1SolidColorBrush> dividerBrush;
         ctx->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.35f), &dividerBrush);
@@ -2219,14 +2113,14 @@ static bool RenderCompareComposite(HWND hwnd) {
 }
 
 static void SnapWindowToCompareImages(HWND hwnd) {
-    if (!IsCompareModeActive() || !g_compare.left.valid || !g_imageResource) return;
+    if (!IsCompareModeActive() || !GetPaneContext(PaneSlot::Left).valid || !GetPaneContext(PaneSlot::Primary).resource) return;
 
     // [Fix] Respect Fullscreen, Maximized, and Lock states. Do not snap window if already in these modes.
     if (!g_isFullScreen && !IsZoomed(hwnd) && (!g_runtime.LockWindowSize || !g_config.KeepWindowSizeOnNav)) {
-        int leftExif = GetEffectiveExifOrientation(g_compare.left.view.ExifOrientation, g_compare.left.editState);
-        int rightExif = GetEffectiveExifOrientation(g_viewState.ExifOrientation, g_editState);
-        D2D1_SIZE_F szLeft = GetOrientedSize(g_compare.left.resource, leftExif);
-        D2D1_SIZE_F szRight = GetOrientedSize(g_imageResource, rightExif);
+        int leftExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Left).view.ExifOrientation, GetPaneContext(PaneSlot::Left).editState);
+        int rightExif = GetEffectiveExifOrientation(GetPaneContext(PaneSlot::Primary).view.ExifOrientation, GetPaneContext(PaneSlot::Primary).editState);
+        D2D1_SIZE_F szLeft = GetOrientedSize(GetPaneContext(PaneSlot::Left).resource, leftExif);
+        D2D1_SIZE_F szRight = GetOrientedSize(GetPaneContext(PaneSlot::Primary).resource, rightExif);
 
         if (szLeft.width > 0 && szRight.width > 0) {
             float targetImgW, targetImgH;
@@ -2272,20 +2166,20 @@ static void SnapWindowToCompareImages(HWND hwnd) {
     }
     
     // Reset views to match the current window size (Fit mode)
-    g_viewState.Reset();
-    g_compare.left.view.Zoom = 1.0f;
-    g_compare.left.view.PanX = 0;
-    g_compare.left.view.PanY = 0;
-    g_viewState.CompareActive = true;
+    GetPaneContext(PaneSlot::Primary).view.Reset();
+    GetPaneContext(PaneSlot::Left).view.Zoom = 1.0f;
+    GetPaneContext(PaneSlot::Left).view.PanX = 0;
+    GetPaneContext(PaneSlot::Left).view.PanY = 0;
+    GetPaneContext(PaneSlot::Primary).view.CompareActive = true;
     if (g_config.AutoRotate) {
-         g_compare.left.view.ExifOrientation = g_compare.left.metadata.ExifOrientation;
-         g_viewState.ExifOrientation = g_currentMetadata.ExifOrientation;
+         GetPaneContext(PaneSlot::Left).view.ExifOrientation = GetPaneContext(PaneSlot::Left).metadata.ExifOrientation;
+         GetPaneContext(PaneSlot::Primary).view.ExifOrientation = GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation;
     }
 }
 
 static void EnterCompareMode(HWND hwnd) {
-    if (IsCompareModeActive() || !g_imageResource) return;
-    if (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192) {
+    if (IsCompareModeActive() || !GetPaneContext(PaneSlot::Primary).resource) return;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192) {
         g_osd.Show(hwnd, L"Compare mode is not available for Titan images yet.", true);
         return;
     }
@@ -2293,27 +2187,27 @@ static void EnterCompareMode(HWND hwnd) {
     g_compare.splitRatio = ClampCompareRatio(g_compare.splitRatio);
 
 
-    if (g_toolbar.IsComicMode() && g_navigator.Count() > 0) {
-        int currentIndex = g_navigator.Index();
+    if (g_toolbar.IsComicMode() && GetPaneContext(PaneSlot::Primary).navigator.Count() > 0) {
+        int currentIndex = GetPaneContext(PaneSlot::Primary).navigator.Index();
 
         // Standard (0,1), (2,3) pairing
         int leftIndex = currentIndex & ~1;
         int rightIndex = leftIndex + 1;
 
         std::wstring leftPath;
-        if (leftIndex >= 0 && leftIndex < (int)g_navigator.Count()) {
-            leftPath = g_navigator.GetFile(leftIndex);
+        if (leftIndex >= 0 && leftIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            leftPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(leftIndex);
         }
 
         std::wstring rightPath;
-        if (rightIndex >= 0 && rightIndex < (int)g_navigator.Count()) {
-            rightPath = g_navigator.GetFile(rightIndex);
+        if (rightIndex >= 0 && rightIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            rightPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(rightIndex);
         }
 
-        if (g_imagePath == leftPath && g_imageResource.bitmap) {
+        if (GetPaneContext(PaneSlot::Primary).path == leftPath && GetPaneContext(PaneSlot::Primary).resource.bitmap) {
             // Optimization: Current image is the left page, capture it immediately
             CaptureCurrentImageAsCompareLeft();
-            g_navigator.SetIndex(rightIndex);
+            GetPaneContext(PaneSlot::Primary).navigator.SetIndex(rightIndex);
             if (!rightPath.empty()) {
                 LoadImageAsync(hwnd, rightPath, false);
             }
@@ -2323,10 +2217,10 @@ static void EnterCompareMode(HWND hwnd) {
             if (rightPath.empty()) {
                 rightPath = leftPath;
                 leftPath = L"";
-                g_navigator.SetIndex(leftIndex);
+                GetPaneContext(PaneSlot::Primary).navigator.SetIndex(leftIndex);
             }
             else {
-                g_navigator.SetIndex(rightIndex);
+                GetPaneContext(PaneSlot::Primary).navigator.SetIndex(rightIndex);
             }
 
             if (!leftPath.empty()) {
@@ -2334,22 +2228,22 @@ static void EnterCompareMode(HWND hwnd) {
                     if (success) {
                         MarkCompareDirty();
                     }
-                    if (!rightPath.empty() && rightPath != g_imagePath) {
+                    if (!rightPath.empty() && rightPath != GetPaneContext(PaneSlot::Primary).path) {
                         LoadImageAsync(hwnd, rightPath, false);
                     }
                 });
             }
             else {
-                g_compare.left.Reset();
+                GetPaneContext(PaneSlot::Left).Reset();
                 MarkCompareDirty();
-                if (!rightPath.empty() && rightPath != g_imagePath) {
+                if (!rightPath.empty() && rightPath != GetPaneContext(PaneSlot::Primary).path) {
                     LoadImageAsync(hwnd, rightPath, false);
                 }
             }
         }
     } else {
         CaptureCurrentImageAsCompareLeft();
-        if (!g_compare.left.valid) {
+        if (!GetPaneContext(PaneSlot::Left).valid) {
             g_compare.mode = ViewMode::Single;
             return;
         }
@@ -2357,22 +2251,22 @@ static void EnterCompareMode(HWND hwnd) {
 
     // [v6.8] Special Route: If soft-proofing is enabled, automatically compare Before vs After.
     if (g_runtime.EnableSoftProofing) {
-        g_compare.left.EnableSoftProofing = false; // Left pane is the "Before Proofing" version
+        GetPaneContext(PaneSlot::Left).EnableSoftProofing = false; // Left pane is the "Before Proofing" version
         g_runtime.LockWindowSize = false;         // [Fix] Allow window to adapt for side-by-side view
         
         g_osd.ShowCompare(hwnd, AppStrings::OSD_CompareBefore, AppStrings::OSD_CompareAfter, D2D1::ColorF(D2D1::ColorF::White), 2500);
     }
 
-    if (g_config.AutoRotate && g_imageLoader && !g_imagePath.empty()) {
+    if (g_config.AutoRotate && g_imageLoader && !GetPaneContext(PaneSlot::Primary).path.empty()) {
         CImageLoader::ImageMetadata rightMeta;
-        if (SUCCEEDED(g_imageLoader->ReadMetadata(g_imagePath.c_str(), &rightMeta, true)) &&
+        if (SUCCEEDED(g_imageLoader->ReadMetadata(GetPaneContext(PaneSlot::Primary).path.c_str(), &rightMeta, true)) &&
             rightMeta.ExifOrientation >= 1 && rightMeta.ExifOrientation <= 8) {
-            g_viewState.ExifOrientation = rightMeta.ExifOrientation;
-            g_currentMetadata.ExifOrientation = rightMeta.ExifOrientation;
+            GetPaneContext(PaneSlot::Primary).view.ExifOrientation = rightMeta.ExifOrientation;
+            GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation = rightMeta.ExifOrientation;
         }
     } else {
-        g_viewState.ExifOrientation = 1;
-        g_currentMetadata.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation = 1;
     }
 
     g_compare.syncZoom = true;
@@ -2385,17 +2279,17 @@ static void EnterCompareMode(HWND hwnd) {
     g_compare.showDividerHandle = false;
     MarkCompareDirty();
 
-    g_viewState.CompareActive = true;
+    GetPaneContext(PaneSlot::Primary).view.CompareActive = true;
     
     // [v10.0] Trigger Metrics for Left Image (A) if HUD is active
     // [Fix] Must call AFTER CompareActive=true so IsCompareModeActive() check passes
-    if (g_runtime.ShowCompareInfo && (g_compare.left.metadata.HistL.empty() || !g_compare.left.metadata.IsFullMetadataLoaded)) {
-        UpdateCompareLeftHistogramAsync(hwnd, g_compare.left.path);
+    if (g_runtime.ShowCompareInfo && (GetPaneContext(PaneSlot::Left).metadata.HistL.empty() || !GetPaneContext(PaneSlot::Left).metadata.IsFullMetadataLoaded)) {
+        UpdateCompareLeftHistogramAsync(hwnd, GetPaneContext(PaneSlot::Left).path);
     }
 
-    g_viewState.CompareSplitRatio = GetCompareSplitRatio();
-    g_viewState.EdgeHoverLeft = 0;
-    g_viewState.EdgeHoverRight = 0;
+    GetPaneContext(PaneSlot::Primary).view.CompareSplitRatio = GetCompareSplitRatio();
+    GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+    GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
 
     // [v10.0] Seamless Info Transition: Sync Normal Info state to Compare HUD
     if (g_runtime.ShowInfoPanel) {
@@ -2413,11 +2307,11 @@ static void EnterCompareMode(HWND hwnd) {
 
     // Auto-load next image into right pane if possible.
     // [v6.8] If we are in "Before vs After Soft Proofing" mode, do NOT load next image.
-    if (!g_runtime.EnableSoftProofing && g_navigator.Count() > 1) {
+    if (!g_runtime.EnableSoftProofing && GetPaneContext(PaneSlot::Primary).navigator.Count() > 1) {
         g_compare.pendingSnap = true;
-        std::wstring nextPath = g_navigator.PeekNext();
-        if (!nextPath.empty() && nextPath != g_imagePath) {
-            g_viewState.Reset();
+        std::wstring nextPath = GetPaneContext(PaneSlot::Primary).navigator.PeekNext();
+        if (!nextPath.empty() && nextPath != GetPaneContext(PaneSlot::Primary).path) {
+            GetPaneContext(PaneSlot::Primary).view.Reset();
             LoadImageAsync(hwnd, nextPath, false, QuickView::BrowseDirection::FORWARD);
         }
     } else if (g_runtime.EnableSoftProofing) {
@@ -2440,11 +2334,11 @@ static void ExitCompareMode(HWND hwnd) {
     g_compare.selectedPane = ComparePane::Right;
     g_compare.dirty = false;
 
-    g_viewState.CompareActive = false;
-    g_viewState.CompareSplitRatio = 0.5f;
-    g_viewState.EdgeHoverLeft = 0;
-    g_viewState.EdgeHoverRight = 0;
-    g_viewState.EdgeHoverState = 0;
+    GetPaneContext(PaneSlot::Primary).view.CompareActive = false;
+    GetPaneContext(PaneSlot::Primary).view.CompareSplitRatio = 0.5f;
+    GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+    GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
+    GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
 
     // [v10.0] Seamless Info Transition: Restore Compare HUD state to Normal Info
     if (g_runtime.ShowCompareInfo) {
@@ -2459,11 +2353,11 @@ static void ExitCompareMode(HWND hwnd) {
     GetClientRect(hwnd, &rc);
     g_toolbar.UpdateLayout((float)rc.right, (float)rc.bottom);
 
-    if (g_imageResource) {
-        RenderImageToDComp(hwnd, g_imageResource, false);
-        if (g_viewState.ExifOrientation > 1 && g_config.AutoRotate) {
-            g_currentMetadata.ExifOrientation = 1;
-            g_viewState.ExifOrientation = 1;
+    if (GetPaneContext(PaneSlot::Primary).resource) {
+        RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, false);
+        if (GetPaneContext(PaneSlot::Primary).view.ExifOrientation > 1 && g_config.AutoRotate) {
+            GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation = 1;
+            GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1;
         }
         AdjustWindowToImage(hwnd);
         RECT updatedRc{};
@@ -2657,21 +2551,21 @@ bool CanPan(HWND hwnd) {
     if (IsCompareModeActive()) {
         // In compare mode, panning is always allowed if images are loaded,
         // even if they fit the window, to allow precise alignment comparison.
-        return (g_imageResource || g_compare.left.valid);
+        return (GetPaneContext(PaneSlot::Primary).resource || GetPaneContext(PaneSlot::Left).valid);
     }
-    if (!g_imageResource) return false;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return false;
     
     RECT rc; GetClientRect(hwnd, &rc);
     float windowW = (float)(rc.right - rc.left);
     float windowH = (float)(rc.bottom - rc.top);
     
-    D2D1_SIZE_F imgSize = g_imageResource.GetSize();
+    D2D1_SIZE_F imgSize = GetPaneContext(PaneSlot::Primary).resource.GetSize();
     float fitScale = std::min(windowW / imgSize.width, windowH / imgSize.height);
-    float scaledW = imgSize.width * fitScale * g_viewState.Zoom;
-    float scaledH = imgSize.height * fitScale * g_viewState.Zoom;
+    float scaledW = imgSize.width * fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
+    float scaledH = imgSize.height * fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
     
     // Condition 0: Always allow pan if zoomed in
-    if (g_viewState.Zoom > 1.01f) return true;
+    if (GetPaneContext(PaneSlot::Primary).view.Zoom > 1.01f) return true;
 
     // Condition 1: Image exceeds window bounds
     if (scaledW > windowW + 1.0f || scaledH > windowH + 1.0f) {
@@ -2718,13 +2612,13 @@ static float ComputeSvgViewportScale(float winW, float winH, const VisualState&
         return 1.0f;
     }
     const float baseFit = std::min(winW / vs.VisualSize.width, winH / vs.VisualSize.height);
-    return baseFit * g_viewState.Zoom;
+    return baseFit * GetPaneContext(PaneSlot::Primary).view.Zoom;
 }
 
 static D2D1_MATRIX_3X2_F BuildSvgViewportTransform(float winW, float winH, const ImageResource& res, const VisualState& vs) {
     const float targetZoom = ComputeSvgViewportScale(winW, winH, vs);
-    const float centerX = winW * 0.5f + g_viewState.PanX;
-    const float centerY = winH * 0.5f + g_viewState.PanY;
+    const float centerX = winW * 0.5f + GetPaneContext(PaneSlot::Primary).view.PanX;
+    const float centerY = winH * 0.5f + GetPaneContext(PaneSlot::Primary).view.PanY;
     return D2D1::Matrix3x2F::Translation(-res.svgW * 0.5f, -res.svgH * 0.5f) *
            D2D1::Matrix3x2F::Scale(vs.FlipX, vs.FlipY) *
            D2D1::Matrix3x2F::Rotation(vs.TotalRotation) *
@@ -2741,7 +2635,7 @@ static void DrawSvgWithViewportTransform(ID2D1DeviceContext* ctx, const ImageRes
     const D2D1_ANTIALIAS_MODE oldAA = ctx5->GetAntialiasMode();
     // Favor responsiveness while the user is actively dragging/zooming, then let
     // the existing interaction timer trigger a high-quality redraw on settle.
-    ctx5->SetAntialiasMode(g_viewState.IsInteracting ? D2D1_ANTIALIAS_MODE_ALIASED
+    ctx5->SetAntialiasMode(GetPaneContext(PaneSlot::Primary).view.IsInteracting ? D2D1_ANTIALIAS_MODE_ALIASED
                                                      : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
     ctx5->SetTransform(CombineWithCurrentTransform(ctx, transform));
     ctx5->DrawSvgDocument(res.svgDoc.Get());
@@ -2856,7 +2750,7 @@ static bool UpgradeSvgSurface(HWND hwnd, ImageResource& res) {
 }
 
 static void RefreshSvgSurfaceAfterZoom(HWND hwnd) {
-    if (!g_imageResource.isSvg || !g_compEngine || !g_compEngine->IsInitialized()) {
+    if (!GetPaneContext(PaneSlot::Primary).resource.isSvg || !g_compEngine || !g_compEngine->IsInitialized()) {
         return;
     }
     KillTimer(hwnd, IDT_SVG_RERENDER);
@@ -2867,13 +2761,13 @@ static void RefreshSvgSurfaceAfterZoom(HWND hwnd) {
 static D2D1_SIZE_U ComputeDesiredBitmapSurfaceSize(UINT winW, UINT winH, const ImageResource& res) {
     if (!res.bitmap || res.isSvg) return D2D1::SizeU(0, 0);
     if (winW == 0 || winH == 0) return D2D1::SizeU(0, 0);
-    if (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192) return D2D1::SizeU(0, 0);
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192) return D2D1::SizeU(0, 0);
 
     float originalW = 0.0f;
     float originalH = 0.0f;
-    if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
-        originalW = (float)g_currentMetadata.Width;
-        originalH = (float)g_currentMetadata.Height;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
+        originalW = (float)GetPaneContext(PaneSlot::Primary).metadata.Width;
+        originalH = (float)GetPaneContext(PaneSlot::Primary).metadata.Height;
     } else {
         D2D1_SIZE_F bmpSize = res.bitmap->GetSize();
         originalW = bmpSize.width;
@@ -2908,7 +2802,7 @@ static D2D1_SIZE_U ComputeDesiredBitmapSurfaceSize(UINT winW, UINT winH, const I
         }
     }
 
-    float desiredScale = fitScale * g_viewState.Zoom;
+    float desiredScale = fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
     // [Quality Optimization] For bitmaps, cap at original size (1.0) for large images 
     // but allow upscaling to fit (fitScale) for small images for smooth display.
     float qualityCap = std::max(1.0f, fitScale);
@@ -2945,18 +2839,18 @@ static bool ShouldUpgradeBitmapSurface(const D2D1_SIZE_U& desired) {
 
 
 static void TryUpgradeBitmapSurface(HWND hwnd) {
-    if (!g_imageResource || g_imageResource.isSvg) return;
+    if (!GetPaneContext(PaneSlot::Primary).resource || GetPaneContext(PaneSlot::Primary).resource.isSvg) return;
     if (IsCompareModeActive()) return;
     if (g_isLoading) return;
-    if (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192) return;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192) return;
 
     RECT rc; GetClientRect(hwnd, &rc);
     if (rc.right <= 0 || rc.bottom <= 0) return;
 
-    D2D1_SIZE_U desired = ComputeDesiredBitmapSurfaceSize((UINT)rc.right, (UINT)rc.bottom, g_imageResource);
+    D2D1_SIZE_U desired = ComputeDesiredBitmapSurfaceSize((UINT)rc.right, (UINT)rc.bottom, GetPaneContext(PaneSlot::Primary).resource);
     if (!ShouldUpgradeBitmapSurface(desired)) return;
 
-    RenderImageToDComp(hwnd, g_imageResource, true);
+    RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
 }
 
 // [DComp] Render content (Bitmap or SVG) to DComp Pending Surface
@@ -3036,10 +2930,10 @@ static bool RenderImageToDComp(HWND hwnd, ImageResource& res, bool isFastUpgrade
     UINT fullWidth = 0;
     UINT fullHeight = 0;
     // Only Bitmap mode supports Titan (SVG uses vector re-rasterization)
-    if (!res.isSvg && (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192)) {
+    if (!res.isSvg && (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192)) {
          isTitan = true;
-         fullWidth = g_currentMetadata.Width;
-         fullHeight = g_currentMetadata.Height;
+         fullWidth = GetPaneContext(PaneSlot::Primary).metadata.Width;
+         fullHeight = GetPaneContext(PaneSlot::Primary).metadata.Height;
     }
 
     if (!res.isSvg && !isTitan) {
@@ -3176,7 +3070,7 @@ static bool RenderImageToDComp(HWND hwnd, ImageResource& res, bool isFastUpgrade
              // DComp handles its own scaling for zooming, but here we are drawing the base bitmap
              // to the DComp surface (often upscaling a small thumbnail to fit).
              // To ensure sharp nearest-neighbor interpolation when requested, we apply it here as well.
-             float absoluteScale = g_viewState.Zoom * scale;
+             float absoluteScale = GetPaneContext(PaneSlot::Primary).view.Zoom * scale;
              D2D1_INTERPOLATION_MODE interpMode = GetOptimalD2DInterpolationMode(absoluteScale, imgW, imgH);
 
              ctx->DrawBitmap(res.bitmap.Get(), &srcRect, 1.0f, interpMode);
@@ -3199,7 +3093,7 @@ static bool RenderImageToDComp(HWND hwnd, ImageResource& res, bool isFastUpgrade
              D2D1_RECT_F destRect = D2D1::RectF(x, y, x + drawW, y + drawH);
 
              // Use Smart Interpolation
-             float absoluteScale = g_viewState.Zoom * scale;
+             float absoluteScale = GetPaneContext(PaneSlot::Primary).view.Zoom * scale;
              D2D1_INTERPOLATION_MODE interpMode = GetOptimalD2DInterpolationMode(absoluteScale, imgW, imgH);
 
              ctx->DrawBitmap(res.bitmap.Get(), &destRect, 1.0f, interpMode);
@@ -3273,7 +3167,7 @@ bool IsRawFile(const std::wstring& path) {
 }
 
 void ReleaseImageResources() {
-    g_imageResource.Reset();
+    GetPaneContext(PaneSlot::Primary).resource.Reset();
     g_renderExifOrientation = 1;
     Sleep(50);
 }
@@ -3409,7 +3303,7 @@ static bool ExecuteWindowControlButton(HWND hwnd, int buttonIndex) {
                         // Force SW_SHOWNORMAL to ensure style flags update if needed
                         ShowWindow(hwnd, SW_SHOWNORMAL);
                         // Reset view state for proper fit
-                        g_viewState.Reset();
+                        GetPaneContext(PaneSlot::Primary).view.Reset();
                     } else {
                         // Save current placement before spanning
                         GetWindowPlacement(hwnd, &g_savedWindowPlacement);
@@ -3426,7 +3320,7 @@ static bool ExecuteWindowControlButton(HWND hwnd, int buttonIndex) {
                     ShowWindow(hwnd, wasZoomed ? SW_RESTORE : SW_MAXIMIZE);
                     // Reset view state if restoring
                     if (wasZoomed) {
-                        g_viewState.Reset();
+                        GetPaneContext(PaneSlot::Primary).view.Reset();
                         RestoreCurrentExifOrientation();
                     }
                 }
@@ -3515,7 +3409,7 @@ static void RefreshDisplayColorPipeline(HWND hwnd, bool requestFullRepaint) {
 
     // Re-upload cached frames when the output monitor/profile/HDR state changes.
     // A repaint alone would keep showing the bitmap baked for the previous display.
-    if (changed && (g_imageResource || (IsCompareModeActive() && g_compare.left.valid))) {
+    if (changed && (GetPaneContext(PaneSlot::Primary).resource || (IsCompareModeActive() && GetPaneContext(PaneSlot::Left).valid))) {
         RefreshImageDisplay(hwnd);
     }
 
@@ -3585,12 +3479,12 @@ static bool GetDisplayColorStateForPane(HWND hwnd, ComparePane pane, QuickView::
 }
 
 static bool HasActiveGainMapImage() {
-    const bool mainHasGainMap = !g_imagePath.empty() && g_currentMetadata.hdrMetadata.hasGainMap;
+    const bool mainHasGainMap = !GetPaneContext(PaneSlot::Primary).path.empty() && GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata.hasGainMap;
     const bool compareLeftHasGainMap =
         IsCompareModeActive() &&
-        g_compare.left.valid &&
-        !g_compare.left.path.empty() &&
-        g_compare.left.metadata.hdrMetadata.hasGainMap;
+        GetPaneContext(PaneSlot::Left).valid &&
+        !GetPaneContext(PaneSlot::Left).path.empty() &&
+        GetPaneContext(PaneSlot::Left).metadata.hdrMetadata.hasGainMap;
     return mainHasGainMap || compareLeftHasGainMap;
 }
 
@@ -3618,12 +3512,12 @@ static void ReloadGainMapImagesForDisplayChange(HWND hwnd) {
 
 static void ReloadComparePaneForDisplayChange(HWND hwnd, ComparePane pane) {
     if (pane == ComparePane::Left) {
-        if (!IsCompareModeActive() || !g_compare.left.valid || g_compare.left.path.empty() ||
-            !g_compare.left.metadata.hdrMetadata.hasGainMap) {
+        if (!IsCompareModeActive() || !GetPaneContext(PaneSlot::Left).valid || GetPaneContext(PaneSlot::Left).path.empty() ||
+            !GetPaneContext(PaneSlot::Left).metadata.hdrMetadata.hasGainMap) {
             return;
         }
 
-        LoadImageIntoCompareLeftSlot(hwnd, g_compare.left.path, [](bool success) {
+        LoadImageIntoCompareLeftSlot(hwnd, GetPaneContext(PaneSlot::Left).path, [](bool success) {
             if (success) {
                 MarkCompareDirty();
                 RequestRepaint(PaintLayer::Image | PaintLayer::Static | PaintLayer::Dynamic);
@@ -3632,7 +3526,7 @@ static void ReloadComparePaneForDisplayChange(HWND hwnd, ComparePane pane) {
         return;
     }
 
-    if (!g_imagePath.empty() && g_currentMetadata.hdrMetadata.hasGainMap) {
+    if (!GetPaneContext(PaneSlot::Primary).path.empty() && GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata.hasGainMap) {
         ReloadCurrentImage(hwnd);
     }
 }
@@ -3640,7 +3534,7 @@ static void ReloadComparePaneForDisplayChange(HWND hwnd, ComparePane pane) {
 static void ShowGallery(HWND hwnd) {
     if (!g_gallery.IsVisible()) SaveOverlayWindowState(hwnd);
 
-    g_gallery.Open(g_navigator.Index());
+    g_gallery.Open(GetPaneContext(PaneSlot::Primary).navigator.Index());
     if (g_gallery.IsVisible()) {
         AdjustWindowForOverlay(hwnd, false);
     }
@@ -3658,9 +3552,9 @@ static bool OpenPathOrDirectory(HWND hwnd, const std::wstring& path, bool clearT
     const bool isDirectory = fs::is_directory(fsPath, ec);
     if (ec) return false;
 
-    g_editState.Reset();
-    g_viewState.Reset();
-    g_navigator.Initialize(path, hwnd);
+    GetPaneContext(PaneSlot::Primary).editState.Reset();
+    GetPaneContext(PaneSlot::Primary).view.Reset();
+    GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd);
     if (clearThumbCache) {
         g_thumbMgr.ClearCache();
     }
@@ -3668,7 +3562,7 @@ static bool OpenPathOrDirectory(HWND hwnd, const std::wstring& path, bool clearT
     if (isDirectory) {
         ShowGallery(hwnd);
     } else {
-        LoadImageAsync(hwnd, g_navigator.GetResolvedPath(path).c_str());
+        LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(path).c_str());
     }
 
     RequestRepaint(PaintLayer::All);
@@ -3732,12 +3626,12 @@ static void ApplyCompareZoomWithMultiplier(HWND hwnd,
         }
 
         if (p == ComparePane::Left) {
-            if (!g_compare.left.valid) return;
-            ZoomCompareView(g_compare.left.view, g_compare.left.resource, fitVp, centerVp, multiplier, effectiveAnchor);
+            if (!GetPaneContext(PaneSlot::Left).valid) return;
+            ZoomCompareView(GetPaneContext(PaneSlot::Left).view, GetPaneContext(PaneSlot::Left).resource, fitVp, centerVp, multiplier, effectiveAnchor);
         } else {
-            if (!g_imageResource) return;
+            if (!GetPaneContext(PaneSlot::Primary).resource) return;
             CompareView right = GetRightCompareView();
-            ZoomCompareView(right, g_imageResource, fitVp, centerVp, multiplier, effectiveAnchor);
+            ZoomCompareView(right, GetPaneContext(PaneSlot::Primary).resource, fitVp, centerVp, multiplier, effectiveAnchor);
             SetRightCompareView(right);
         }
     };
@@ -3759,7 +3653,7 @@ static void ApplyCompareZoomWithMultiplier(HWND hwnd,
     RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);
 
     wchar_t leftBuf[32], rightBuf[32];
-    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(g_compare.left.view.Zoom * 100.0f));
+    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetPaneContext(PaneSlot::Left).view.Zoom * 100.0f));
     swprintf_s(rightBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetRightCompareView().Zoom * 100.0f));
     g_osd.ShowCompare(hwnd, leftBuf, rightBuf);
 }
@@ -3783,19 +3677,19 @@ static bool g_showControls = true;
 // --- Helpers for Zoom Consistency [Unification] ---
 
 static D2D1_SIZE_F GetLogicalImageSize() {
-    if (g_imageResource && g_imageResource.isSvg && g_imageResource.svgW > 0.0f && g_imageResource.svgH > 0.0f) {
-        return g_imageResource.GetSize();
+    if (GetPaneContext(PaneSlot::Primary).resource && GetPaneContext(PaneSlot::Primary).resource.isSvg && GetPaneContext(PaneSlot::Primary).resource.svgW > 0.0f && GetPaneContext(PaneSlot::Primary).resource.svgH > 0.0f) {
+        return GetPaneContext(PaneSlot::Primary).resource.GetSize();
     }
 
-    if (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192) {
-        return D2D1::SizeF((float)g_currentMetadata.Width, (float)g_currentMetadata.Height);
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192) {
+        return D2D1::SizeF((float)GetPaneContext(PaneSlot::Primary).metadata.Width, (float)GetPaneContext(PaneSlot::Primary).metadata.Height);
     }
 
     if (g_lastSurfaceSize.width > 0.0f && g_lastSurfaceSize.height > 0.0f) {
         return g_lastSurfaceSize;
     }
 
-    return g_imageResource ? g_imageResource.GetSize() : D2D1::SizeF(0, 0);
+    return GetPaneContext(PaneSlot::Primary).resource ? GetPaneContext(PaneSlot::Primary).resource.GetSize() : D2D1::SizeF(0, 0);
 }
 
 // [Fix] Robust Size Calculation using Renderer Metrics
@@ -3807,7 +3701,7 @@ static D2D1_SIZE_F GetVisualImageSize() {
     
     // [Fix Regression] Manual Rotation is applied ON TOP of the surface
     // So we must swap dimensions if the user manually rotated 90/270 degrees.
-    bool manualSwap = (g_editState.TotalRotation % 180 != 0);
+    bool manualSwap = (GetPaneContext(PaneSlot::Primary).editState.TotalRotation % 180 != 0);
     if (manualSwap) {
         return D2D1::SizeF(result.height, result.width);
     }
@@ -3821,7 +3715,7 @@ static float ComputeBaseFitScaleForVisual(const VisualState& vs, float winW, flo
     }
 
     float baseFit = std::min(winW / vs.VisualSize.width, winH / vs.VisualSize.height);
-    if (!g_imageResource.isSvg) {
+    if (!GetPaneContext(PaneSlot::Primary).resource.isSvg) {
         if (g_runtime.LockWindowSize) {
             if (!g_config.UpscaleSmallImagesWhenLocked && baseFit > 1.0f) {
                 baseFit = 1.0f;
@@ -3937,22 +3831,22 @@ static void ConfigureSmoothZoom(HWND hwnd,
 }
 
 static void SyncSmoothZoomToLogical(float winW, float winH, bool activate) {
-    if (!g_imageResource || IsCompareModeActive()) {
+    if (!GetPaneContext(PaneSlot::Primary).resource || IsCompareModeActive()) {
         g_smoothZoom.Reset();
         return;
     }
 
     VisualState vs = GetVisualState();
     const float baseFit = ComputeBaseFitScaleForVisual(vs, winW, winH);
-    const float targetZoom = baseFit * g_viewState.Zoom;
+    const float targetZoom = baseFit * GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     g_smoothZoom.ImageId = g_currentImageId.load(std::memory_order_acquire);
     g_smoothZoom.CurrentZoom = targetZoom;
-    g_smoothZoom.CurrentPanX = g_viewState.PanX;
-    g_smoothZoom.CurrentPanY = g_viewState.PanY;
+    g_smoothZoom.CurrentPanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+    g_smoothZoom.CurrentPanY = GetPaneContext(PaneSlot::Primary).view.PanY;
     g_smoothZoom.TargetZoom = targetZoom;
-    g_smoothZoom.TargetPanX = g_viewState.PanX;
-    g_smoothZoom.TargetPanY = g_viewState.PanY;
+    g_smoothZoom.TargetPanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+    g_smoothZoom.TargetPanY = GetPaneContext(PaneSlot::Primary).view.PanY;
     g_smoothZoom.LastWinW = winW;
     g_smoothZoom.LastWinH = winH;
     g_smoothZoom.LastTick = GetTickCount64();
@@ -3978,7 +3872,7 @@ static bool TickSmoothZoom(HWND hwnd) {
         !g_smoothZoom.AnimateWindow &&
         (fabsf(g_smoothZoom.LastWinW - winW) > 0.5f || fabsf(g_smoothZoom.LastWinH - winH) > 0.5f);
 
-    if (!g_imageResource || IsCompareModeActive() || g_viewState.IsDragging || g_isInSizeMove ||
+    if (!GetPaneContext(PaneSlot::Primary).resource || IsCompareModeActive() || GetPaneContext(PaneSlot::Primary).view.IsDragging || g_isInSizeMove ||
         g_smoothZoom.ImageId != currentImageId || sizeChangedUnexpectedly) {
         SyncSmoothZoomToLogical(winW, winH, false);
         SyncDCompState(hwnd, winW, winH);
@@ -4046,8 +3940,8 @@ static bool TickSmoothZoom(HWND hwnd) {
         ResolveSmoothZoomPan(hwnd, g_smoothZoom.CurrentZoom, g_smoothZoom.CurrentPanX, g_smoothZoom.CurrentPanY);
         g_smoothZoom.LastWinW = winW;
         g_smoothZoom.LastWinH = winH;
-        g_viewState.PanX = g_smoothZoom.CurrentPanX;
-        g_viewState.PanY = g_smoothZoom.CurrentPanY;
+        GetPaneContext(PaneSlot::Primary).view.PanX = g_smoothZoom.CurrentPanX;
+        GetPaneContext(PaneSlot::Primary).view.PanY = g_smoothZoom.CurrentPanY;
         g_programmaticResize = false;
         g_smoothZoom.Active = false;
     }
@@ -4090,11 +3984,11 @@ static void ToggleCompareHUD(HWND hwnd, int targetMode) {
 
     g_toolbar.SetCompareInfoState(g_runtime.ShowCompareInfo);
     if (g_runtime.ShowCompareInfo) {
-        if (g_currentMetadata.HistL.empty() && !g_imagePath.empty()) {
-            UpdateHistogramAsync(hwnd, g_imagePath);
+        if (GetPaneContext(PaneSlot::Primary).metadata.HistL.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+            UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
         }
-        if ((g_compare.left.metadata.HistL.empty() || !g_compare.left.metadata.IsFullMetadataLoaded) && !g_compare.left.path.empty()) {
-            UpdateCompareLeftHistogramAsync(hwnd, g_compare.left.path);
+        if ((GetPaneContext(PaneSlot::Left).metadata.HistL.empty() || !GetPaneContext(PaneSlot::Left).metadata.IsFullMetadataLoaded) && !GetPaneContext(PaneSlot::Left).path.empty()) {
+            UpdateCompareLeftHistogramAsync(hwnd, GetPaneContext(PaneSlot::Left).path);
         }
         
         // Elastic HUD: Expand window if it's too small for the HUD
@@ -4120,7 +4014,7 @@ static void ToggleCompareHUD(HWND hwnd, int targetMode) {
 static RECT s_restoredWindowRect{};
 
 static float GetCurrentRealScale(HWND hwnd) {
-    if (!g_imageResource) return 1.0f;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return 1.0f;
     D2D1_SIZE_F effSize = GetVisualImageSize();
     float imgW = effSize.width;
     float imgH = effSize.height;
@@ -4128,10 +4022,10 @@ static float GetCurrentRealScale(HWND hwnd) {
 
     float originalW = imgW;
     float originalH = imgH;
-    if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
-        originalW = (float)g_currentMetadata.Width;
-        originalH = (float)g_currentMetadata.Height;
-        bool manualSwap = (g_editState.TotalRotation % 180 != 0);
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
+        originalW = (float)GetPaneContext(PaneSlot::Primary).metadata.Width;
+        originalH = (float)GetPaneContext(PaneSlot::Primary).metadata.Height;
+        bool manualSwap = (GetPaneContext(PaneSlot::Primary).editState.TotalRotation % 180 != 0);
         if (manualSwap) std::swap(originalW, originalH);
     }
 
@@ -4140,7 +4034,7 @@ static float GetCurrentRealScale(HWND hwnd) {
     float winH = (float)(rcClient.bottom - rcClient.top);
 
     float fitScale = (std::min)(winW / imgW, winH / imgH);
-    float totalScale = fitScale * g_viewState.Zoom;
+    float totalScale = fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
     return totalScale * (imgW / originalW); // Real pixel scale
 }
 
@@ -4149,9 +4043,9 @@ static void PerformRestoreWindow(HWND hwnd) {
         int rW = s_restoredWindowRect.right - s_restoredWindowRect.left;
         int rH = s_restoredWindowRect.bottom - s_restoredWindowRect.top;
         SetWindowPos(hwnd, nullptr, s_restoredWindowRect.left, s_restoredWindowRect.top, rW, rH, SWP_NOZORDER | SWP_NOACTIVATE);
-        g_viewState.Zoom = 1.0f;
-        g_viewState.PanX = 0;
-        g_viewState.PanY = 0;
+        GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+        GetPaneContext(PaneSlot::Primary).view.PanY = 0;
         g_osd.Show(hwnd, AppStrings::OSD_Restored, false, false, D2D1::ColorF(D2D1::ColorF::White));
         RequestRepaint(PaintLayer::All);
 
@@ -4165,20 +4059,20 @@ static void PerformCompareZoom100(HWND hwnd) {
 
     auto zoomPane = [&](ComparePane p) {
         if (p == ComparePane::Left) {
-            if (!g_compare.left.valid) return;
-            D2D1_SIZE_F sz = GetOrientedSize(g_compare.left.resource, g_compare.left.view.ExifOrientation);
+            if (!GetPaneContext(PaneSlot::Left).valid) return;
+            D2D1_SIZE_F sz = GetOrientedSize(GetPaneContext(PaneSlot::Left).resource, GetPaneContext(PaneSlot::Left).view.ExifOrientation);
             D2D1_RECT_F vp = GetCompareViewport(hwnd, ComparePane::Left);
             float vpW = vp.right - vp.left;
             float vpH = vp.bottom - vp.top;
             if (sz.width > 0 && sz.height > 0 && vpW > 0 && vpH > 0) {
                 float fit = std::min(vpW / sz.width, vpH / sz.height);
-                g_compare.left.view.Zoom = (fit > 0.0001f) ? (1.0f / fit) : 1.0f;
-                g_compare.left.view.PanX = 0; g_compare.left.view.PanY = 0;
+                GetPaneContext(PaneSlot::Left).view.Zoom = (fit > 0.0001f) ? (1.0f / fit) : 1.0f;
+                GetPaneContext(PaneSlot::Left).view.PanX = 0; GetPaneContext(PaneSlot::Left).view.PanY = 0;
             }
         } else {
-            if (!g_imageResource) return;
+            if (!GetPaneContext(PaneSlot::Primary).resource) return;
             CompareView right = GetRightCompareView();
-            D2D1_SIZE_F sz = GetOrientedSize(g_imageResource, right.ExifOrientation);
+            D2D1_SIZE_F sz = GetOrientedSize(GetPaneContext(PaneSlot::Primary).resource, right.ExifOrientation);
             D2D1_RECT_F vp = GetCompareViewport(hwnd, ComparePane::Right);
             float vpW = vp.right - vp.left;
             float vpH = vp.bottom - vp.top;
@@ -4201,7 +4095,7 @@ static void PerformCompareZoom100(HWND hwnd) {
     RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);
 
     wchar_t leftBuf[32], rightBuf[32];
-    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(g_compare.left.view.Zoom * 100.0f));
+    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetPaneContext(PaneSlot::Left).view.Zoom * 100.0f));
     swprintf_s(rightBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetRightCompareView().Zoom * 100.0f));
     g_osd.ShowCompare(hwnd, leftBuf, rightBuf);
 }
@@ -4209,31 +4103,31 @@ static void PerformCompareZoom100(HWND hwnd) {
 static void PerformCompareZoomFit(HWND hwnd) {
     if (!IsCompareModeActive()) return;
     if (g_compare.syncZoom) {
-        g_compare.left.view.Zoom = 1.0f;
-        g_compare.left.view.PanX = 0; g_compare.left.view.PanY = 0;
-        g_viewState.Zoom = 1.0f;
-        g_viewState.PanX = 0; g_viewState.PanY = 0;
+        GetPaneContext(PaneSlot::Left).view.Zoom = 1.0f;
+        GetPaneContext(PaneSlot::Left).view.PanX = 0; GetPaneContext(PaneSlot::Left).view.PanY = 0;
+        GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.PanX = 0; GetPaneContext(PaneSlot::Primary).view.PanY = 0;
     } else {
         if (g_compare.selectedPane == ComparePane::Left) {
-            g_compare.left.view.Zoom = 1.0f;
-            g_compare.left.view.PanX = 0; g_compare.left.view.PanY = 0;
+            GetPaneContext(PaneSlot::Left).view.Zoom = 1.0f;
+            GetPaneContext(PaneSlot::Left).view.PanX = 0; GetPaneContext(PaneSlot::Left).view.PanY = 0;
         } else {
-            g_viewState.Zoom = 1.0f;
-            g_viewState.PanX = 0; g_viewState.PanY = 0;
+            GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.PanX = 0; GetPaneContext(PaneSlot::Primary).view.PanY = 0;
         }
     }
     MarkCompareDirty();
     RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);
 
     wchar_t leftBuf[32], rightBuf[32];
-    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(g_compare.left.view.Zoom * 100.0f));
+    swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetPaneContext(PaneSlot::Left).view.Zoom * 100.0f));
     swprintf_s(rightBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetRightCompareView().Zoom * 100.0f));
     g_osd.ShowCompare(hwnd, leftBuf, rightBuf);
 }
 
 static void PerformZoom100(HWND hwnd, bool allowResizeWindow = true) {
     ResetSmoothZoomState();
-    if (g_imageResource) {
+    if (GetPaneContext(PaneSlot::Primary).resource) {
         // [Fix] Use Robust Visual Size (This refers to current Surface Size, potentially downscaled)
         D2D1_SIZE_F effSize = GetVisualImageSize();
         float imgW = effSize.width;
@@ -4247,12 +4141,12 @@ static void PerformZoom100(HWND hwnd, bool allowResizeWindow = true) {
         float originalW = imgW;
         float originalH = imgH;
 
-        if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
-            originalW = (float)g_currentMetadata.Width;
-            originalH = (float)g_currentMetadata.Height;
+        if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
+            originalW = (float)GetPaneContext(PaneSlot::Primary).metadata.Width;
+            originalH = (float)GetPaneContext(PaneSlot::Primary).metadata.Height;
             
             // Apply Manual Rotation Swap (same logic as GetVisualImageSize)
-            bool manualSwap = (g_editState.TotalRotation % 180 != 0);
+            bool manualSwap = (GetPaneContext(PaneSlot::Primary).editState.TotalRotation % 180 != 0);
             if (manualSwap) {
                 std::swap(originalW, originalH);
             }
@@ -4287,19 +4181,19 @@ static void PerformZoom100(HWND hwnd, bool allowResizeWindow = true) {
                  
                  RECT rcNew; GetClientRect(hwnd, &rcNew);
                  float newFitScale = std::min((float)rcNew.right / imgW, (float)rcNew.bottom / imgH);
-                 if (newFitScale > 0) g_viewState.Zoom = renderScaleTarget / newFitScale;
+                 if (newFitScale > 0) GetPaneContext(PaneSlot::Primary).view.Zoom = renderScaleTarget / newFitScale;
             } else {
                 RECT rc; GetClientRect(hwnd, &rc);
                 float fitScale = std::min((float)rc.right / imgW, (float)rc.bottom / imgH);
-                if (fitScale > 0) g_viewState.Zoom = renderScaleTarget / fitScale;
+                if (fitScale > 0) GetPaneContext(PaneSlot::Primary).view.Zoom = renderScaleTarget / fitScale;
             }
 
-            g_viewState.PanX = 0;
-            g_viewState.PanY = 0;
+            GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+            GetPaneContext(PaneSlot::Primary).view.PanY = 0;
             g_osd.Show(hwnd, AppStrings::OSD_Zoom100, false, false, D2D1::ColorF(0.4f, 1.0f, 0.4f));
     }
     RequestRepaint(PaintLayer::All);
-    g_viewState.IsInteracting = true;
+    GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
     SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
 }
 
@@ -4307,19 +4201,19 @@ static void PerformZoom100(HWND hwnd, bool allowResizeWindow = true) {
 static VisualState GetVisualState();
 
 static float GetCurrentTotalScale(HWND hwnd) {
-    if (!g_imageResource) return g_viewState.Zoom;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     D2D1_SIZE_F visualSize = GetVisualImageSize();
     float imageWidth = visualSize.width;
     float imageHeight = visualSize.height;
-    if (imageWidth <= 0 || imageHeight <= 0) return g_viewState.Zoom;
+    if (imageWidth <= 0 || imageHeight <= 0) return GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     RECT rc; GetClientRect(hwnd, &rc);
     float scaleW = (float)rc.right / imageWidth;
     float scaleH = (float)rc.bottom / imageHeight;
     float fitScale = (scaleW < scaleH) ? scaleW : scaleH;
 
-    if (!g_imageResource.isSvg) {
+    if (!GetPaneContext(PaneSlot::Primary).resource.isSvg) {
         if (g_runtime.LockWindowSize) {
             if (!g_config.UpscaleSmallImagesWhenLocked && fitScale > 1.0f) {
                 fitScale = 1.0f;
@@ -4331,12 +4225,12 @@ static float GetCurrentTotalScale(HWND hwnd) {
         }
     }
 
-    float sourceZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : g_viewState.Zoom;
+    float sourceZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : GetPaneContext(PaneSlot::Primary).view.Zoom;
     return fitScale * sourceZoom;
 }
 
 static float ClampTotalScale(HWND hwnd, float newTotalScale) {
-    if (!g_imageResource) return newTotalScale;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return newTotalScale;
 
     D2D1_SIZE_F visualSize = GetVisualImageSize();
     float imageWidth = visualSize.width;
@@ -4348,7 +4242,7 @@ static float ClampTotalScale(HWND hwnd, float newTotalScale) {
     float scaleH = (float)rc.bottom / imageHeight;
     float fitScale = (scaleW < scaleH) ? scaleW : scaleH;
 
-    if (!g_imageResource.isSvg) {
+    if (!GetPaneContext(PaneSlot::Primary).resource.isSvg) {
         if (g_runtime.LockWindowSize) {
             if (!g_config.UpscaleSmallImagesWhenLocked && fitScale > 1.0f) {
                 fitScale = 1.0f;
@@ -4362,8 +4256,8 @@ static float ClampTotalScale(HWND hwnd, float newTotalScale) {
 
     float minScale = 0.1f * fitScale;
     float maxScale = std::max(50.0f * fitScale, 50.0f);
-    if (g_imageResource.isSvg && !UseSvgViewportRendering(g_imageResource)) {
-        maxScale = std::min(maxScale, GetSvgMaxSharpTotalScale(g_imageResource));
+    if (GetPaneContext(PaneSlot::Primary).resource.isSvg && !UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource)) {
+        maxScale = std::min(maxScale, GetSvgMaxSharpTotalScale(GetPaneContext(PaneSlot::Primary).resource));
     }
 
     if (newTotalScale < minScale) newTotalScale = minScale;
@@ -4374,11 +4268,11 @@ static float ClampTotalScale(HWND hwnd, float newTotalScale) {
 // [Shared] Unified Zoom Calculation
 // Handles robust size retrieval, fit scale, small image protection, and magnetic snap
 static float CalculateTargetZoom(HWND hwnd, float delta, bool isFineInterval = false) {
-    if (!g_imageResource) return g_viewState.Zoom;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     D2D1_SIZE_F visualSize = GetVisualImageSize();
     float imageWidth = visualSize.width;
-    if (imageWidth <= 0) return g_viewState.Zoom;
+    if (imageWidth <= 0) return GetPaneContext(PaneSlot::Primary).view.Zoom;
 
     float currentTotalScale = GetCurrentTotalScale(hwnd);
 
@@ -4407,9 +4301,9 @@ static float CalculateTargetZoom(HWND hwnd, float delta, bool isFineInterval = f
     // 6. [Logic] Magnetic Snap to 100%
     float snapTarget = 1.0f;
     // Calculate true 100% scale relative to current surface
-    if (g_currentMetadata.Width > 0 && imageWidth > 0) {
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && imageWidth > 0) {
             VisualState vsSnap = GetVisualState();
-            float origW = (float)(vsSnap.IsRotated90 ? g_currentMetadata.Height : g_currentMetadata.Width);
+            float origW = (float)(vsSnap.IsRotated90 ? GetPaneContext(PaneSlot::Primary).metadata.Height : GetPaneContext(PaneSlot::Primary).metadata.Width);
             if (origW > 0) snapTarget = origW / imageWidth;
     }
 
@@ -4443,9 +4337,9 @@ static float CalculateTargetZoom(HWND hwnd, float delta, bool isFineInterval = f
 static void ShowZoomOsd(HWND hwnd, float newTotalScale) {
     D2D1_SIZE_F visualSize = GetVisualImageSize();
     float osdScale = newTotalScale;
-    if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
         VisualState vs = GetVisualState();
-        float originalDim = (float)(vs.IsRotated90 ? g_currentMetadata.Height : g_currentMetadata.Width);
+        float originalDim = (float)(vs.IsRotated90 ? GetPaneContext(PaneSlot::Primary).metadata.Height : GetPaneContext(PaneSlot::Primary).metadata.Width);
         if (originalDim > 0) {
             osdScale = newTotalScale * (visualSize.width / originalDim);
         }
@@ -4463,23 +4357,23 @@ static void ShowZoomOsd(HWND hwnd, float newTotalScale) {
 
 static void PerformZoomFit(HWND hwnd, float maxScreenPct = 1.0f, bool allowResizeWindow = true) {
     ResetSmoothZoomState();
-    if (g_imageResource) {
+    if (GetPaneContext(PaneSlot::Primary).resource) {
         if (!allowResizeWindow) {
-            g_viewState.Zoom = 1.0f;
-            g_viewState.PanX = 0;
-            g_viewState.PanY = 0;
+            GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+            GetPaneContext(PaneSlot::Primary).view.PanY = 0;
             g_osd.Show(hwnd, AppStrings::OSD_ZoomFit, false, false, D2D1::ColorF(D2D1::ColorF::White));
             RequestRepaint(PaintLayer::All);
-            g_viewState.IsInteracting = true;
+            GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
             SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
             return;
         }
 
         // [Requirement] If maximized or fullscreen, just reset zoom/pan without resizing window
         if (IsZoomed(hwnd) || g_isFullScreen) {
-            g_viewState.Zoom = 1.0f;
-            g_viewState.PanX = 0;
-            g_viewState.PanY = 0;
+            GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+            GetPaneContext(PaneSlot::Primary).view.PanY = 0;
             g_osd.Show(hwnd, AppStrings::OSD_ZoomFit, false, false, D2D1::ColorF(D2D1::ColorF::White));
             RequestRepaint(PaintLayer::All);
             return;
@@ -4528,10 +4422,10 @@ static void PerformZoomFit(HWND hwnd, float maxScreenPct = 1.0f, bool allowResiz
              SetWindowPos(hwnd, nullptr, x, y, targetWinW, targetWinH, SWP_NOZORDER | SWP_NOACTIVATE);
         }
         
-        g_viewState.Zoom = 1.0f; 
+        GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f; 
         g_osd.Show(hwnd, AppStrings::OSD_ZoomFit, false, false, D2D1::ColorF(D2D1::ColorF::White));
         RequestRepaint(PaintLayer::All);
-        g_viewState.IsInteracting = true;
+        GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
         SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
     }
 }
@@ -5080,14 +4974,14 @@ std::wstring ShowQuickViewInputDialog(HWND hwnd, const std::wstring& title, cons
 // --- Logic Functions ---
 
 bool SaveCurrentImage(bool saveAs) {
-    if (!g_editState.IsDirty && !saveAs) return true;
+    if (!GetPaneContext(PaneSlot::Primary).editState.IsDirty && !saveAs) return true;
     
-    std::wstring targetPath = g_editState.OriginalFilePath;
+    std::wstring targetPath = GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath;
     if (saveAs) {
         OPENFILENAMEW ofn{};
         ofn.lStructSize = sizeof(ofn);
         wchar_t szFile[MAX_PATH] = { 0 };
-        wcscpy_s(szFile, g_editState.OriginalFilePath.c_str());
+        wcscpy_s(szFile, GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath.c_str());
         ofn.lStructSize = sizeof(ofn);
         ofn.hwndOwner = GetActiveWindow();
         ofn.lpstrFile = szFile;
@@ -5122,7 +5016,7 @@ bool SaveCurrentImage(bool saveAs) {
     
     std::wstring workFile = tempFile;
 
-    if (!CopyFileW(g_editState.OriginalFilePath.c_str(), workFile.c_str(), FALSE)) {
+    if (!CopyFileW(GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath.c_str(), workFile.c_str(), FALSE)) {
         DeleteFileW(workFile.c_str());
         SetCursor(hOldCursor);
         wchar_t err[256];
@@ -5133,7 +5027,7 @@ bool SaveCurrentImage(bool saveAs) {
     
     // 2. Apply Pending Transforms
     bool transformError = false;
-    for (auto type : g_editState.PendingTransforms) {
+    for (auto type : GetPaneContext(PaneSlot::Primary).editState.PendingTransforms) {
         TransformResult res;
         if (CLosslessTransform::IsJPEG(workFile.c_str())) {
             res = CLosslessTransform::TransformJPEG(workFile.c_str(), workFile.c_str(), type);
@@ -5182,9 +5076,9 @@ bool SaveCurrentImage(bool saveAs) {
     SetCursor(hOldCursor);
     
     if (success) {
-        g_editState.Reset();
-        g_editState.OriginalFilePath = targetPath; // Update logic if SaveAs changed it
-        g_imagePath = targetPath;
+        GetPaneContext(PaneSlot::Primary).editState.Reset();
+        GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath = targetPath; // Update logic if SaveAs changed it
+        GetPaneContext(PaneSlot::Primary).path = targetPath;
         
         // [Fix] Invalidate Cache & Refresh File Info
         // This prevents showing the old (unrotated) image if navigating away and back.
@@ -5192,7 +5086,7 @@ bool SaveCurrentImage(bool saveAs) {
              g_imageEngine->InvalidateCache(targetPath);
         }
         // Force refresh of file navigator to pick up new file size/date
-        g_navigator.Refresh();
+        GetPaneContext(PaneSlot::Primary).navigator.Refresh();
         
         ReloadCurrentImage(GetActiveWindow());
         return true;
@@ -5782,24 +5676,24 @@ void LoadConfig() {
 
 void DiscardChanges() {
     // Save original path BEFORE reset (Reset clears it)
-    std::wstring originalPath = g_editState.OriginalFilePath;
+    std::wstring originalPath = GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath;
     
-    if (g_editState.IsDirty && !g_editState.TempFilePath.empty()) {
+    if (GetPaneContext(PaneSlot::Primary).editState.IsDirty && !GetPaneContext(PaneSlot::Primary).editState.TempFilePath.empty()) {
         ReleaseImageResources();
-        if (!DeleteFileW(g_editState.TempFilePath.c_str())) { Sleep(100); DeleteFileW(g_editState.TempFilePath.c_str()); }
+        if (!DeleteFileW(GetPaneContext(PaneSlot::Primary).editState.TempFilePath.c_str())) { Sleep(100); DeleteFileW(GetPaneContext(PaneSlot::Primary).editState.TempFilePath.c_str()); }
     }
-    g_editState.Reset();
+    GetPaneContext(PaneSlot::Primary).editState.Reset();
     
     // Restore to original file path if we had one
     if (!originalPath.empty()) {
-        g_imagePath = originalPath;
+        GetPaneContext(PaneSlot::Primary).path = originalPath;
         ReloadCurrentImage(GetActiveWindow());
     }
 }
 
 bool CheckUnsavedChanges(HWND hwnd) {
-    if (!g_editState.IsDirty) return true;
-    if (g_config.ShouldAutoSave(g_editState.Quality)) return SaveCurrentImage(false);
+    if (!GetPaneContext(PaneSlot::Primary).editState.IsDirty) return true;
+    if (g_config.ShouldAutoSave(GetPaneContext(PaneSlot::Primary).editState.Quality)) return SaveCurrentImage(false);
     
     std::vector<DialogButton> buttons = {
         { DialogResult::Yes, AppStrings::Dialog_ButtonSave, true },
@@ -5809,23 +5703,23 @@ bool CheckUnsavedChanges(HWND hwnd) {
     
     const wchar_t* checkboxLabel = AppStrings::Checkbox_AlwaysSaveLossless;
     std::wstring qualityMsg = L"Quality: Lossless";
-    if (g_editState.Quality == EditQuality::EdgeAdapted) {
+    if (GetPaneContext(PaneSlot::Primary).editState.Quality == EditQuality::EdgeAdapted) {
         checkboxLabel = AppStrings::Checkbox_AlwaysSaveEdgeAdapted;
         qualityMsg = L"Quality: Edge Adapted";
     }
-    else if (g_editState.Quality == EditQuality::Lossy) {
+    else if (GetPaneContext(PaneSlot::Primary).editState.Quality == EditQuality::Lossy) {
         checkboxLabel = AppStrings::Checkbox_AlwaysSaveLossy;
         qualityMsg = L"Quality: Lossy Re-encoded";
     }
     
     DialogResult result = ShowQuickViewDialog(hwnd, AppStrings::Dialog_SaveTitle, AppStrings::Dialog_SaveContent, 
-                                          g_editState.GetQualityColor(), buttons, true, checkboxLabel, qualityMsg);
+                                          GetPaneContext(PaneSlot::Primary).editState.GetQualityColor(), buttons, true, checkboxLabel, qualityMsg);
     
     if (result == DialogResult::None) return false;
     
     if (g_dialog.IsChecked) {
-        if (g_editState.Quality == EditQuality::EdgeAdapted) g_config.AlwaysSaveEdgeAdapted = true;
-        else if (g_editState.Quality == EditQuality::Lossy) g_config.AlwaysSaveLossy = true;
+        if (GetPaneContext(PaneSlot::Primary).editState.Quality == EditQuality::EdgeAdapted) g_config.AlwaysSaveEdgeAdapted = true;
+        else if (GetPaneContext(PaneSlot::Primary).editState.Quality == EditQuality::Lossy) g_config.AlwaysSaveLossy = true;
         else g_config.AlwaysSaveLossless = true;
     }
     
@@ -5851,7 +5745,7 @@ VisualState GetVisualState() {
     int baseRot = 0;
     bool baseFlipX = false;
     
-    switch(g_viewState.ExifOrientation) {
+    switch(GetPaneContext(PaneSlot::Primary).view.ExifOrientation) {
         case 1: baseRot = 0;   baseFlipX = false; break; // Normal
         case 2: baseRot = 0;   baseFlipX = true;  break; // Flip Horizontal
         case 3: baseRot = 180; baseFlipX = false; break; // Rotate 180
@@ -5865,7 +5759,7 @@ VisualState GetVisualState() {
     
     // C. Apply User Rotation
     // Total Rotation = (Base + User) % 360
-    int totalAngle = (baseRot + (int)g_editState.TotalRotation) % 360;
+    int totalAngle = (baseRot + (int)GetPaneContext(PaneSlot::Primary).editState.TotalRotation) % 360;
     if (totalAngle < 0) totalAngle += 360;
     
     // D. Apply User Flips (Visual -> Physical Mapping)
@@ -5878,7 +5772,7 @@ VisualState GetVisualState() {
     bool isRotated90or270 = (totalAngle == 90 || totalAngle == 270);
     
     // Visual Horizontal Flip
-    if (g_editState.FlippedH) {
+    if (GetPaneContext(PaneSlot::Primary).editState.FlippedH) {
         if (isRotated90or270) {
             finalFlipY = !finalFlipY; // Visual H = Physical V when rotated 90/270
         } else {
@@ -5887,7 +5781,7 @@ VisualState GetVisualState() {
     }
     
     // Visual Vertical Flip
-    if (g_editState.FlippedV) {
+    if (GetPaneContext(PaneSlot::Primary).editState.FlippedV) {
         if (isRotated90or270) {
             finalFlipX = !finalFlipX; // Visual V = Physical H when rotated 90/270
         } else {
@@ -5922,15 +5816,15 @@ static void ClampPanForViewport(const VisualState& vs, float winW, float winH, f
     const float maxPanY = std::max(0.0f, (scaledH - winH) * 0.5f);
 
     if (maxPanX <= 0.5f) {
-        g_viewState.PanX = 0.0f;
+        GetPaneContext(PaneSlot::Primary).view.PanX = 0.0f;
     } else {
-        g_viewState.PanX = std::clamp(g_viewState.PanX, -maxPanX, maxPanX);
+        GetPaneContext(PaneSlot::Primary).view.PanX = std::clamp(GetPaneContext(PaneSlot::Primary).view.PanX, -maxPanX, maxPanX);
     }
 
     if (maxPanY <= 0.5f) {
-        g_viewState.PanY = 0.0f;
+        GetPaneContext(PaneSlot::Primary).view.PanY = 0.0f;
     } else {
-        g_viewState.PanY = std::clamp(g_viewState.PanY, -maxPanY, maxPanY);
+        GetPaneContext(PaneSlot::Primary).view.PanY = std::clamp(GetPaneContext(PaneSlot::Primary).view.PanY, -maxPanY, maxPanY);
     }
 }
 
@@ -5942,8 +5836,8 @@ D2D1_SIZE_F GetEffectiveImageSize() {
 // [v3.2.3] Get current zoom percentage relative to Original Resolution
 // Shared by OSD and Info Panel to avoid duplicated calculation logic.
 int GetCurrentZoomPercent() {
-    if (!g_imageResource) return 100;
-    if (g_currentMetadata.Width <= 0) return 100;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return 100;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width <= 0) return 100;
     
     // Get effective surface size and window size
     D2D1_SIZE_F effSize = GetEffectiveImageSize();
@@ -5957,7 +5851,7 @@ int GetCurrentZoomPercent() {
     
     // Calculate BaseFit (same as WM_MOUSEWHEEL and SyncDCompState)
     float fitScale = std::min(winW / effSize.width, winH / effSize.height);
-    if (!g_imageResource.isSvg) {
+    if (!GetPaneContext(PaneSlot::Primary).resource.isSvg) {
         if (g_runtime.LockWindowSize) {
             if (!g_config.UpscaleSmallImagesWhenLocked && fitScale > 1.0f) {
                 fitScale = 1.0f;
@@ -5970,11 +5864,11 @@ int GetCurrentZoomPercent() {
     }
     
     // TotalScale = BaseFit * Zoom
-    float totalScale = fitScale * g_viewState.Zoom;
+    float totalScale = fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom;
     
     // Convert to "True Scale" relative to Original Resolution
     VisualState vs = GetVisualState();
-    float originalDim = (float)(vs.IsRotated90 ? g_currentMetadata.Height : g_currentMetadata.Width);
+    float originalDim = (float)(vs.IsRotated90 ? GetPaneContext(PaneSlot::Primary).metadata.Height : GetPaneContext(PaneSlot::Primary).metadata.Width);
     if (originalDim > 0) {
         totalScale = totalScale * (effSize.width / originalDim);
     }
@@ -6010,10 +5904,10 @@ void AdjustWindowForOverlay(HWND hwnd, bool isClosed) {
     float curBaseFit = 1.0f;
     if (hasImage) {
         curBaseFit = std::min(curClientW / imgW, curClientH / imgH);
-        if (imgW < 200.0f && imgH < 200.0f && !g_imageResource.isSvg) {
+        if (imgW < 200.0f && imgH < 200.0f && !GetPaneContext(PaneSlot::Primary).resource.isSvg) {
             if (curBaseFit > 1.0f) curBaseFit = 1.0f;
         }
-        absoluteZoom = g_viewState.Zoom * curBaseFit;
+        absoluteZoom = GetPaneContext(PaneSlot::Primary).view.Zoom * curBaseFit;
     }
 
     if (!isClosed) {
@@ -6040,7 +5934,7 @@ void AdjustWindowForOverlay(HWND hwnd, bool isClosed) {
             return;
         } else {
             // Fallback if somehow no state was saved: attempt to fit image normally
-            if (g_imageResource) AdjustWindowToImage(hwnd);
+            if (GetPaneContext(PaneSlot::Primary).resource) AdjustWindowToImage(hwnd);
             return;
         }
     }
@@ -6079,12 +5973,12 @@ void AdjustWindowForOverlay(HWND hwnd, bool isClosed) {
 
         if (!isClosed) {
             float newBaseFit = std::min(finalClientW / imgW, finalClientH / imgH);
-            if (imgW < 200.0f && imgH < 200.0f && !g_imageResource.isSvg) {
+            if (imgW < 200.0f && imgH < 200.0f && !GetPaneContext(PaneSlot::Primary).resource.isSvg) {
                 if (newBaseFit > 1.0f) newBaseFit = 1.0f;
             }
 
             if (newBaseFit > 0.0001f) {
-                g_viewState.Zoom = absoluteZoom / newBaseFit;
+                GetPaneContext(PaneSlot::Primary).view.Zoom = absoluteZoom / newBaseFit;
             }
         }
 
@@ -6097,7 +5991,7 @@ void AdjustWindowForOverlay(HWND hwnd, bool isClosed) {
 
 void AdjustWindowToImage(HWND hwnd) {
     s_restoredWindowRect = {}; // Clear restored rect so new image sets new initial size
-    if (!g_imageResource) return;
+    if (!GetPaneContext(PaneSlot::Primary).resource) return;
 
     // [Fix] If window size was restored from config, skip the initial auto-resize to fit the image.
     // This ensures the window stays at the user's saved dimensions on startup.
@@ -6124,9 +6018,9 @@ void AdjustWindowToImage(HWND hwnd) {
     // [Phase 1 Fix] Prefer metadata dimensions to prevent small-to-large jump.
     // Guard against EXIF pre-rotation path where metadata orientation can lag one step behind
     // the already-rendered visual surface orientation.
-    if (g_currentMetadata.Width > 0 && g_currentMetadata.Height > 0) {
-        float metaW = (float)g_currentMetadata.Width;
-        float metaH = (float)g_currentMetadata.Height;
+    if (GetPaneContext(PaneSlot::Primary).metadata.Width > 0 && GetPaneContext(PaneSlot::Primary).metadata.Height > 0) {
+        float metaW = (float)GetPaneContext(PaneSlot::Primary).metadata.Width;
+        float metaH = (float)GetPaneContext(PaneSlot::Primary).metadata.Height;
 
         // First apply current logical rotation state (legacy behavior).
         VisualState vsMeta = GetVisualState();
@@ -6256,15 +6150,15 @@ void RefreshImageDisplay(HWND hwnd) {
     bool needsRepaint = false;
 
     // Refresh Right Pane (Single or Compare Right)
-    if (!g_imagePath.empty()) {
-        auto frame = g_pImageEngine->GetCachedImage(g_imagePath);
+    if (!GetPaneContext(PaneSlot::Primary).path.empty()) {
+        auto frame = g_pImageEngine->GetCachedImage(GetPaneContext(PaneSlot::Primary).path);
         if (frame && frame->IsValid()) {
-            if (g_currentMetadata.MeasuredPeakNits < 0.0f &&
+            if (GetPaneContext(PaneSlot::Primary).metadata.MeasuredPeakNits < 0.0f &&
                 frame->pixels &&
                 (frame->format == QuickView::PixelFormat::R32G32B32A32_FLOAT ||
                  frame->format == QuickView::PixelFormat::R16G16B16A16_FLOAT ||
                  frame->format == QuickView::PixelFormat::R16G16B16A16_UNORM)) {
-                g_currentMetadata.MeasuredPeakNits = g_renderEngine->EstimateFramePeakScRgb(*frame) * 80.0f;
+                GetPaneContext(PaneSlot::Primary).metadata.MeasuredPeakNits = g_renderEngine->EstimateFramePeakScRgb(*frame) * 80.0f;
             }
             ComPtr<ID2D1Bitmap> bitmap;
             CRenderEngine::RenderPipelineOptions rightOpts;
@@ -6274,7 +6168,7 @@ void RefreshImageDisplay(HWND hwnd) {
             rightOpts.softProofProfilePath = g_runtime.SoftProofProfilePath;
 
             if (SUCCEEDED(g_renderEngine->UploadRawFrameToGPU(*frame, &bitmap, &rightOpts))) {
-                g_imageResource.bitmap = bitmap;
+                GetPaneContext(PaneSlot::Primary).resource.bitmap = bitmap;
                 g_isImageDirty = false; // [v10.3.1] Force refresh consumed, preventing redundant OnPaint cycle
                 
                 // [Titan] Invalidate tiles to trigger CMS re-upload
@@ -6287,26 +6181,26 @@ void RefreshImageDisplay(HWND hwnd) {
     }
 
     // Refresh Left Pane (Compare Mode)
-    if (IsCompareModeActive() && g_compare.left.valid && !g_compare.left.path.empty()) {
-        auto leftFrame = g_pImageEngine->GetCachedImage(g_compare.left.path);
+    if (IsCompareModeActive() && GetPaneContext(PaneSlot::Left).valid && !GetPaneContext(PaneSlot::Left).path.empty()) {
+        auto leftFrame = g_pImageEngine->GetCachedImage(GetPaneContext(PaneSlot::Left).path);
         if (leftFrame && leftFrame->IsValid()) {
-            if (g_compare.left.metadata.MeasuredPeakNits < 0.0f &&
+            if (GetPaneContext(PaneSlot::Left).metadata.MeasuredPeakNits < 0.0f &&
                 leftFrame->pixels &&
                 (leftFrame->format == QuickView::PixelFormat::R32G32B32A32_FLOAT ||
                  leftFrame->format == QuickView::PixelFormat::R16G16B16A16_FLOAT ||
                  leftFrame->format == QuickView::PixelFormat::R16G16B16A16_UNORM)) {
-                g_compare.left.metadata.MeasuredPeakNits = g_renderEngine->EstimateFramePeakScRgb(*leftFrame) * 80.0f;
+                GetPaneContext(PaneSlot::Left).metadata.MeasuredPeakNits = g_renderEngine->EstimateFramePeakScRgb(*leftFrame) * 80.0f;
             }
             ComPtr<ID2D1Bitmap> leftBitmap;
             CRenderEngine::RenderPipelineOptions leftOpts;
             leftOpts.hasOverrides = true;
-            int leftCmsModeOverride = g_compare.left.CmsModeOverride;
+            int leftCmsModeOverride = GetPaneContext(PaneSlot::Left).CmsModeOverride;
             leftOpts.effectiveCmsMode = (leftCmsModeOverride != -1) ? leftCmsModeOverride : (g_config.ColorManagement ? 1 : 0);
-            leftOpts.enableSoftProofing = g_compare.left.EnableSoftProofing;
-            leftOpts.softProofProfilePath = g_compare.left.SoftProofProfilePath;
+            leftOpts.enableSoftProofing = GetPaneContext(PaneSlot::Left).EnableSoftProofing;
+            leftOpts.softProofProfilePath = GetPaneContext(PaneSlot::Left).SoftProofProfilePath;
 
             if (SUCCEEDED(g_renderEngine->UploadRawFrameToGPU(*leftFrame, &leftBitmap, &leftOpts))) {
-                g_compare.left.resource.bitmap = leftBitmap;
+                GetPaneContext(PaneSlot::Left).resource.bitmap = leftBitmap;
                 needsRepaint = true;
             }
         }
@@ -6315,7 +6209,7 @@ void RefreshImageDisplay(HWND hwnd) {
     if (needsRepaint) {
         if (!IsCompareModeActive()) {
             extern bool RenderImageToDComp(HWND hwnd, ImageResource & res, bool isFastUpgrade);
-            RenderImageToDComp(hwnd, g_imageResource, true);
+            RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
         } else {
             extern bool RenderCompareComposite(HWND hwnd);
             RenderCompareComposite(hwnd);
@@ -6369,9 +6263,9 @@ void RefreshHdrOverrideSettings(HWND hwnd) {
 }
 
 void ReloadCurrentImage(HWND hwnd) {
-    if (g_imagePath.empty() && g_editState.OriginalFilePath.empty()) return;
-    g_imageResource.Reset();
-    std::wstring path = g_editState.IsDirty ? g_editState.TempFilePath : g_imagePath;
+    if (GetPaneContext(PaneSlot::Primary).path.empty() && GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath.empty()) return;
+    GetPaneContext(PaneSlot::Primary).resource.Reset();
+    std::wstring path = GetPaneContext(PaneSlot::Primary).editState.IsDirty ? GetPaneContext(PaneSlot::Primary).editState.TempFilePath : GetPaneContext(PaneSlot::Primary).path;
     
     // [v4.1] Reload: Skip OSD (to preserve Rotate/Flip messages)
     LoadImageAsync(hwnd, path.c_str(), false);
@@ -6554,12 +6448,12 @@ static void SyncDCompState([[maybe_unused]] HWND hwnd, float winW, float winH, b
     }
 
     // 2. Update Image Transforms
-    if (g_imageResource) {
+    if (GetPaneContext(PaneSlot::Primary).resource) {
         VisualState vs = GetVisualState();
         if (vs.VisualSize.width > 0 && vs.VisualSize.height > 0) {
             float baseFit = ComputeBaseFitScaleForVisual(vs, winW, winH);
 
-            float targetZoom = baseFit * g_viewState.Zoom;
+            float targetZoom = baseFit * GetPaneContext(PaneSlot::Primary).view.Zoom;
 
             // [Fix] Maintain absolute scale during interactive resize
             if (g_isInSizeMove && s_maintainAbsoluteScale && baseFit > 0.0001f) {
@@ -6571,8 +6465,8 @@ static void SyncDCompState([[maybe_unused]] HWND hwnd, float winW, float winH, b
                     newZoom = 1.0f;
                 }
 
-                g_viewState.Zoom = newZoom;
-                targetZoom = baseFit * g_viewState.Zoom;
+                GetPaneContext(PaneSlot::Primary).view.Zoom = newZoom;
+                targetZoom = baseFit * GetPaneContext(PaneSlot::Primary).view.Zoom;
             }
 
             ClampPanForViewport(vs, winW, winH, targetZoom);
@@ -6581,8 +6475,8 @@ static void SyncDCompState([[maybe_unused]] HWND hwnd, float winW, float winH, b
             float animationDurationMs = (animate && g_config.EnableSmoothScaling) ? 90.0f : 0.0f;
 
             float displayZoom = targetZoom;
-            float displayPanX = g_viewState.PanX;
-            float displayPanY = g_viewState.PanY;
+            float displayPanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+            float displayPanY = GetPaneContext(PaneSlot::Primary).view.PanY;
 
             const ImageID currentImageId = g_currentImageId.load(std::memory_order_acquire);
             if (g_smoothZoom.Active) {
@@ -6591,7 +6485,7 @@ static void SyncDCompState([[maybe_unused]] HWND hwnd, float winW, float winH, b
                     (!g_smoothZoom.AnimateWindow &&
                      (fabsf(g_smoothZoom.LastWinW - winW) > 0.5f ||
                       fabsf(g_smoothZoom.LastWinH - winH) > 0.5f)) ||
-                    g_viewState.IsDragging ||
+                    GetPaneContext(PaneSlot::Primary).view.IsDragging ||
                     g_isInSizeMove;
                 if (smoothInvalid) {
                     SyncSmoothZoomToLogical(winW, winH, false);
@@ -6607,7 +6501,7 @@ static void SyncDCompState([[maybe_unused]] HWND hwnd, float winW, float winH, b
             }
 
 
-            if (UseSvgViewportRendering(g_imageResource)) {
+            if (UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource)) {
                 VisualState surfaceVs{};
                 float currentScale = 1.0f;
                 // [Fix] Maintain aspect ratio and sync zoom during interactive resize by uniformly scaling the old surface.
@@ -6703,9 +6597,9 @@ static void TickSmoothWindowZoom(HWND hwnd) {
         lerpLong(g_smoothWindowZoom.startRect.bottom, g_smoothWindowZoom.targetRect.bottom)
     };
 
-    g_viewState.Zoom = lerpFloat(g_smoothWindowZoom.startZoom, g_smoothWindowZoom.targetZoom);
-    g_viewState.PanX = lerpFloat(g_smoothWindowZoom.startPanX, g_smoothWindowZoom.targetPanX);
-    g_viewState.PanY = lerpFloat(g_smoothWindowZoom.startPanY, g_smoothWindowZoom.targetPanY);
+    GetPaneContext(PaneSlot::Primary).view.Zoom = lerpFloat(g_smoothWindowZoom.startZoom, g_smoothWindowZoom.targetZoom);
+    GetPaneContext(PaneSlot::Primary).view.PanX = lerpFloat(g_smoothWindowZoom.startPanX, g_smoothWindowZoom.targetPanX);
+    GetPaneContext(PaneSlot::Primary).view.PanY = lerpFloat(g_smoothWindowZoom.startPanY, g_smoothWindowZoom.targetPanY);
 
     g_programmaticResize = true;
     g_deferProgrammaticZoomResizeSync = true;
@@ -6729,9 +6623,9 @@ static void TickSmoothWindowZoom(HWND hwnd) {
     RequestRepaint(PaintLayer::Dynamic);
 
     if (t >= 1.0f) {
-        g_viewState.Zoom = g_smoothWindowZoom.targetZoom;
-        g_viewState.PanX = g_smoothWindowZoom.targetPanX;
-        g_viewState.PanY = g_smoothWindowZoom.targetPanY;
+        GetPaneContext(PaneSlot::Primary).view.Zoom = g_smoothWindowZoom.targetZoom;
+        GetPaneContext(PaneSlot::Primary).view.PanX = g_smoothWindowZoom.targetPanX;
+        GetPaneContext(PaneSlot::Primary).view.PanY = g_smoothWindowZoom.targetPanY;
         CancelSmoothWindowZoom(hwnd);
     }
 }
@@ -6740,8 +6634,8 @@ static void TickSmoothWindowZoom(HWND hwnd) {
 
 void PerformTransform(HWND hwnd, TransformType type) {
     bool isLeft = IsCompareModeActive() && (g_compare.selectedPane == ComparePane::Left);
-    EditState& state = isLeft ? g_compare.left.editState : g_editState;
-    std::wstring& path = isLeft ? g_compare.left.path : g_imagePath;
+    EditState& state = isLeft ? GetPaneContext(PaneSlot::Left).editState : GetPaneContext(PaneSlot::Primary).editState;
+    std::wstring& path = isLeft ? GetPaneContext(PaneSlot::Left).path : GetPaneContext(PaneSlot::Primary).path;
 
     if (path.empty()) return;
     
@@ -7232,7 +7126,7 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, [[maybe_unused]] LPWSTR lpCm
     g_imageEngine = std::make_unique<ImageEngine>(g_imageLoader.get());
     g_pImageEngine = g_imageEngine.get(); // [v3.1] Init Global Accessor
     g_imageEngine->SetWindow(hwnd);
-    g_imageEngine->SetNavigator(&g_navigator); // [Phase 3] Enable prefetch
+    g_imageEngine->SetNavigator(&GetPaneContext(PaneSlot::Primary).navigator); // [Phase 3] Enable prefetch
     
     // [Prefetch System] Apply Initial Policy from Config
     {
@@ -7312,8 +7206,8 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, [[maybe_unused]] LPWSTR lpCm
           isTitanCandidate = isSupportedFormat && (sizeTrigger || pixelTrigger);
         }
         if (!isTitanCandidate) {
-          g_navigator.Initialize(initialImagePath, hwnd);
-          LoadImageAsync(hwnd, g_navigator.GetResolvedPath(initialImagePath).c_str());
+          GetPaneContext(PaneSlot::Primary).navigator.Initialize(initialImagePath, hwnd);
+          LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(initialImagePath).c_str());
           startedInitialLoadEarly = true;
           deferStartupShow = true;
         }
@@ -7338,7 +7232,7 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, [[maybe_unused]] LPWSTR lpCm
     
     // Init Gallery
     g_thumbMgr.Initialize(hwnd, g_imageLoader.get());
-    g_gallery.Initialize(&g_thumbMgr, &g_navigator);
+    g_gallery.Initialize(&g_thumbMgr, &GetPaneContext(PaneSlot::Primary).navigator);
     g_settingsOverlay.Init(g_renderEngine->GetDeviceContext(), hwnd);
     g_helpOverlay.Init(g_renderEngine->GetDeviceContext(), hwnd);
     DragAcceptFiles(hwnd, TRUE);
@@ -7397,8 +7291,8 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, [[maybe_unused]] LPWSTR lpCm
         ofn.lpstrFilter = filterStr.c_str();
         ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
         if (GetOpenFileNameW(&ofn)) {
-            g_navigator.Initialize(szFile, hwnd);
-            LoadImageAsync(hwnd, g_navigator.GetResolvedPath(szFile).c_str());
+            GetPaneContext(PaneSlot::Primary).navigator.Initialize(szFile, hwnd);
+            LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(szFile).c_str());
             // [Fix Race] Force check here too
              PostMessageW(hwnd, WM_ENGINE_EVENT, 0, 0); 
         }
@@ -7495,20 +7389,20 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
         g_isInSizeMove = true;
 
         // [Fix] Maintain Absolute Scale during resize if a manual zoom is active
-        if (g_imageResource) {
+        if (GetPaneContext(PaneSlot::Primary).resource) {
             VisualState vs = GetVisualState();
             if (vs.VisualSize.width > 0 && vs.VisualSize.height > 0) {
                 RECT rc; GetClientRect(hwnd, &rc);
                 float winW = (float)rc.right;
                 float winH = (float)rc.bottom;
                 float baseFit = std::min(winW / vs.VisualSize.width, winH / vs.VisualSize.height);
-                if (vs.VisualSize.width < 200.0f && vs.VisualSize.height < 200.0f && !g_imageResource.isSvg) {
+                if (vs.VisualSize.width < 200.0f && vs.VisualSize.height < 200.0f && !GetPaneContext(PaneSlot::Primary).resource.isSvg) {
                     if (baseFit > 1.0f) baseFit = 1.0f;
                 }
 
-                s_resizeInitialAbsoluteScale = baseFit * g_viewState.Zoom;
-                s_maintainAbsoluteScale = (abs(g_viewState.Zoom - 1.0f) > 0.001f);
-                s_resizeStartedWithBorders = (g_viewState.Zoom < 0.999f);
+                s_resizeInitialAbsoluteScale = baseFit * GetPaneContext(PaneSlot::Primary).view.Zoom;
+                s_maintainAbsoluteScale = (abs(GetPaneContext(PaneSlot::Primary).view.Zoom - 1.0f) > 0.001f);
+                s_resizeStartedWithBorders = (GetPaneContext(PaneSlot::Primary).view.Zoom < 0.999f);
             }
         } else {
             s_maintainAbsoluteScale = false;
@@ -7738,27 +7632,27 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
         static const UINT_PTR OSD_TIMER_ID = 994;
         
         if (wParam == IDT_ANIMATION) {
-            if (!g_animPlaying || !g_imageResource.animator) {
+            if (!g_animPlaying || !GetPaneContext(PaneSlot::Primary).resource.animator) {
                 KillTimer(hwnd, IDT_ANIMATION);
                 return 0;
             }
             
-            auto nextFrame = g_imageResource.animator->GetNextFrame();
+            auto nextFrame = GetPaneContext(PaneSlot::Primary).resource.animator->GetNextFrame();
             if (!nextFrame || !nextFrame->pixels) {
                 // EOF: Loop back to frame 0
                 QV_LOG("Anim_Playback", TraceLoggingString("EOF Looping", "Action"));
-                nextFrame = g_imageResource.animator->SeekToFrame(0);
+                nextFrame = GetPaneContext(PaneSlot::Primary).resource.animator->SeekToFrame(0);
             }
             
             if (nextFrame && nextFrame->pixels) {
                 ComPtr<ID2D1Bitmap> newBitmap;
                 HRESULT hr = g_renderEngine->UploadRawFrameToGPU(*nextFrame, &newBitmap);
                 if (SUCCEEDED(hr)) {
-                    g_imageResource.bitmap = newBitmap;
-                    g_imageResource.frameMeta = nextFrame->frameMeta;
+                    GetPaneContext(PaneSlot::Primary).resource.bitmap = newBitmap;
+                    GetPaneContext(PaneSlot::Primary).resource.frameMeta = nextFrame->frameMeta;
                     
                     // Update timer delay with speed multiplier
-                    uint32_t delayMs = g_imageResource.frameMeta.delayMs;
+                    uint32_t delayMs = GetPaneContext(PaneSlot::Primary).resource.frameMeta.delayMs;
                     if (delayMs < 10) delayMs = 100;
                     float speedMult = g_toolbar.GetAnimSpeedMultiplier();
                     if (speedMult > 0.01f) delayMs = (uint32_t)(delayMs / speedMult);
@@ -7766,7 +7660,7 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                     SetTimer(hwnd, IDT_ANIMATION, delayMs, NULL);
                     
                     // Update Surface but defer DComp Commit to OnPaint to avoid stuttering
-                    RenderImageToDComp(hwnd, g_imageResource, true);
+                    RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
                     RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic); 
                 } else {
                     QV_LOG("Anim_Playback", TraceLoggingString("UploadFailed", "Action"));
@@ -7786,8 +7680,8 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
         // [SVG Adaptive] Re-rasterize SVG at current zoom's needed resolution
         if (wParam == IDT_SVG_RERENDER) {
              KillTimer(hwnd, IDT_SVG_RERENDER);
-             if (g_imageResource.isSvg) {
-                 UpgradeSvgSurface(hwnd, g_imageResource);
+             if (GetPaneContext(PaneSlot::Primary).resource.isSvg) {
+                 UpgradeSvgSurface(hwnd, GetPaneContext(PaneSlot::Primary).resource);
              }
              return 0;
         }
@@ -7820,7 +7714,7 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
         // Interaction Timer (1001)
         if (wParam == IDT_INTERACTION) {
             KillTimer(hwnd, IDT_INTERACTION);
-            g_viewState.IsInteracting = false;  // End interaction mode
+            GetPaneContext(PaneSlot::Primary).view.IsInteracting = false;  // End interaction mode
             TryUpgradeBitmapSurface(hwnd);
             RequestRepaint(PaintLayer::Image);  // [v4.1] Trigger HQ interpolation redraw
         }
@@ -8021,16 +7915,16 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                if (!isMaximized && s_wasMaximized) {
                     // Reset to default view state (centered, fit)
                     bool wasCompare = IsCompareModeActive();
-                    g_viewState.Reset();
+                    GetPaneContext(PaneSlot::Primary).view.Reset();
                     if (wasCompare) {
-                        g_compare.left.view.Zoom = 1.0f;
-                        g_compare.left.view.PanX = 0.0f;
-                        g_compare.left.view.PanY = 0.0f;
-                        g_viewState.CompareActive = true;
+                        GetPaneContext(PaneSlot::Left).view.Zoom = 1.0f;
+                        GetPaneContext(PaneSlot::Left).view.PanX = 0.0f;
+                        GetPaneContext(PaneSlot::Left).view.PanY = 0.0f;
+                        GetPaneContext(PaneSlot::Primary).view.CompareActive = true;
                     }
                     RestoreCurrentExifOrientation();
-                    if (wasCompare && g_config.AutoRotate && g_compare.left.valid) {
-                         g_compare.left.view.ExifOrientation = g_compare.left.metadata.ExifOrientation;
+                    if (wasCompare && g_config.AutoRotate && GetPaneContext(PaneSlot::Left).valid) {
+                         GetPaneContext(PaneSlot::Left).view.ExifOrientation = GetPaneContext(PaneSlot::Left).metadata.ExifOrientation;
                     }
                     RequestRepaint(PaintLayer::All);
                 } else if (isMaximized && !s_wasMaximized) {
@@ -8160,10 +8054,10 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
      // Mouse Interaction
      case WM_MOUSEMOVE: {
           g_currentCursor = LoadCursor(nullptr, IDC_ARROW);
-          if (g_viewState.IsDraggingInfoPanel) {
+          if (GetPaneContext(PaneSlot::Primary).view.IsDraggingInfoPanel) {
               POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
-              int dx = pt.x - g_viewState.InfoPanelDragAnchor.x;
-              int dy = pt.y - g_viewState.InfoPanelDragAnchor.y;
+              int dx = pt.x - GetPaneContext(PaneSlot::Primary).view.InfoPanelDragAnchor.x;
+              int dy = pt.y - GetPaneContext(PaneSlot::Primary).view.InfoPanelDragAnchor.y;
 
               if (dx != 0 || dy != 0) {
                   float s = g_uiRenderer ? g_uiRenderer->GetUIScale() : 1.0f;
@@ -8177,12 +8071,12 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                   g_runtime.InfoPanelX = std::max(0.0f, std::min(g_runtime.InfoPanelX, maxW - 50.0f));
                   g_runtime.InfoPanelY = std::max(0.0f, std::min(g_runtime.InfoPanelY, maxH - 50.0f));
 
-                  g_viewState.InfoPanelDragAnchor = pt;
+                  GetPaneContext(PaneSlot::Primary).view.InfoPanelDragAnchor = pt;
                   RequestRepaint(PaintLayer::Static);
               }
               return 0; // Handled
           }
-          if (g_viewState.IsDragging) {
+          if (GetPaneContext(PaneSlot::Primary).view.IsDragging) {
               g_currentCursor = LoadCursor(nullptr, IDC_SIZEALL);
           } else if (g_config.EdgeNavClick && !g_gallery.IsVisible() && !g_settingsOverlay.IsVisible() && !g_helpOverlay.IsVisible() && !g_dialog.IsVisible) {
               POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
@@ -8206,9 +8100,9 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                   }
               } else {
                   if (IsCompareModeActive()) {
-                      hoverEdge = (g_viewState.EdgeHoverLeft != 0) || (g_viewState.EdgeHoverRight != 0);
+                      hoverEdge = (GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft != 0) || (GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight != 0);
                   } else {
-                      hoverEdge = (g_viewState.EdgeHoverState != 0);
+                      hoverEdge = (GetPaneContext(PaneSlot::Primary).view.EdgeHoverState != 0);
                   }
               }
               if (hoverEdge) g_currentCursor = LoadCursor(nullptr, IDC_HAND);
@@ -8220,7 +8114,7 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
              isTracking = true;
           }
           POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
-          if (IsCompareModeActive() && !g_viewState.IsDragging && !g_viewState.IsMiddleDragWindow) {
+          if (IsCompareModeActive() && !GetPaneContext(PaneSlot::Primary).view.IsDragging && !GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow) {
               g_compare.activePane = HitTestComparePane(hwnd, pt);
           }
           if (IsNearCompareDivider(hwnd, pt)) {
@@ -8256,9 +8150,9 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                 if (g_uiRenderer) {
                     auto hit = g_uiRenderer->HitTest((float)pt.x, (float)pt.y);
                     if (hit.type != UIHitResult::None) {
-                        g_viewState.EdgeHoverLeft = 0;
-                        g_viewState.EdgeHoverRight = 0;
-                        g_viewState.EdgeHoverState = 0;
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
                         // For HUD, reset hover if it changed recently
                         RequestRepaint(PaintLayer::Static);
                         goto SKIP_EDGE_NAV;
@@ -8266,39 +8160,39 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                 }
 
                 if (IsCompareModeActive()) {
-                    if (g_compare.draggingDivider || g_viewState.IsDragging) {
-                        if (g_viewState.EdgeHoverLeft != 0 || g_viewState.EdgeHoverRight != 0) {
-                            g_viewState.EdgeHoverLeft = 0;
-                            g_viewState.EdgeHoverRight = 0;
+                    if (g_compare.draggingDivider || GetPaneContext(PaneSlot::Primary).view.IsDragging) {
+                        if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft != 0 || GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight != 0) {
+                            GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+                            GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
                             RequestRepaint(PaintLayer::Static);
                         }
                     } else {
-                        int oldLeft = g_viewState.EdgeHoverLeft;
-                        int oldRight = g_viewState.EdgeHoverRight;
-                        g_viewState.EdgeHoverState = 0;
-                        g_viewState.CompareActive = true;
+                        int oldLeft = GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft;
+                        int oldRight = GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight;
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
+                        GetPaneContext(PaneSlot::Primary).view.CompareActive = true;
 
                         float splitX = (g_compare.mode == ViewMode::CompareWipe)
                             ? ClampCompareRatio(g_compare.splitRatio) * (float)w
                             : 0.5f * (float)w;
-                        g_viewState.CompareSplitRatio = (w > 1) ? (splitX / (float)w) : 0.5f;
+                        GetPaneContext(PaneSlot::Primary).view.CompareSplitRatio = (w > 1) ? (splitX / (float)w) : 0.5f;
 
                         const D2D1_RECT_F leftRect = D2D1::RectF(0.0f, 0.0f, splitX, (float)h);
                         const D2D1_RECT_F rightRect = D2D1::RectF(splitX, 0.0f, (float)w, (float)h);
 
-                        g_viewState.EdgeHoverLeft = ComputeEdgeHoverForPane(pt, leftRect);
-                        g_viewState.EdgeHoverRight = ComputeEdgeHoverForPane(pt, rightRect);
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = ComputeEdgeHoverForPane(pt, leftRect);
+                        GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = ComputeEdgeHoverForPane(pt, rightRect);
 
-                        if (g_viewState.EdgeHoverLeft != oldLeft || g_viewState.EdgeHoverRight != oldRight) {
+                        if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft != oldLeft || GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight != oldRight) {
                             RequestRepaint(PaintLayer::Static);
                         }
                     }
                 } else {
-                    g_viewState.CompareActive = false;
-                    g_viewState.EdgeHoverLeft = 0;
-                    g_viewState.EdgeHoverRight = 0;
+                    GetPaneContext(PaneSlot::Primary).view.CompareActive = false;
+                    GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+                    GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
 
-                    int oldState = g_viewState.EdgeHoverState; // Record old state
+                    int oldState = GetPaneContext(PaneSlot::Primary).view.EdgeHoverState; // Record old state
                     if (w > 50 && h > 100) {
                         float edgeMargin = 64.0f * g_uiScale;
                         bool inHRange = (pt.x < edgeMargin) || (pt.x > w - edgeMargin);
@@ -8311,22 +8205,22 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
                         }
 
                         if (inHRange && inVRange) {
-                            g_viewState.EdgeHoverState = (pt.x < edgeMargin) ? -1 : 1;
+                            GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = (pt.x < edgeMargin) ? -1 : 1;
                         } else {
-                            g_viewState.EdgeHoverState = 0;
+                            GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
                         }
                     }
 
-                    if (g_viewState.EdgeHoverState != oldState) {
+                    if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverState != oldState) {
                         RequestRepaint(PaintLayer::Static);
                     }
                 }
             } else {
-                if (g_viewState.EdgeHoverState != 0 || g_viewState.EdgeHoverLeft != 0 || g_viewState.EdgeHoverRight != 0) {
-                    g_viewState.EdgeHoverState = 0;
-                    g_viewState.EdgeHoverLeft = 0;
-                    g_viewState.EdgeHoverRight = 0;
-                    g_viewState.CompareActive = false;
+                if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverState != 0 || GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft != 0 || GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight != 0) {
+                    GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
+                    GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+                    GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
+                    GetPaneContext(PaneSlot::Primary).view.CompareActive = false;
                     RequestRepaint(PaintLayer::Static);
                 }
             }
@@ -8438,58 +8332,58 @@ SKIP_EDGE_NAV:;
               MarkStaticLayerDirty();  // Window Controls hover change (includes InvalidateRect)
           }
 
-         if (g_viewState.IsRightButtonDown && !g_viewState.IsRightButtonDragZoom) {
+         if (GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown && !GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom) {
              POINT cursorPos{};
              GetCursorPos(&cursorPos);
-             const int dxFromStart = abs(cursorPos.x - g_viewState.RightDragZoomStartScreenPos.x);
-             const int dyFromStart = abs(cursorPos.y - g_viewState.RightDragZoomStartScreenPos.y);
+             const int dxFromStart = abs(cursorPos.x - GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos.x);
+             const int dyFromStart = abs(cursorPos.y - GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos.y);
              if (dxFromStart > 4 || dyFromStart > 4) {
-                 g_viewState.IsRightButtonDragZoom = true;
-                 g_viewState.LastMousePos = pt;
+                 GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom = true;
+                 GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
              }
          }
 
-         if (g_viewState.IsRightButtonDragZoom) {
-             g_viewState.LastMousePos = pt;
+         if (GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom) {
+             GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
 
              if (IsCompareModeActive()) {
                  POINT cursorPos{};
                  GetCursorPos(&cursorPos);
-                 const float totalDy = (float)(cursorPos.y - g_viewState.RightDragZoomStartScreenPos.y);
+                 const float totalDy = (float)(cursorPos.y - GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos.y);
                  const float dragSteps = (-totalDy * g_config.RightDragZoomSpeed) / (48.0f * (std::max)(0.75f, g_uiScale));
                  float multiplier = 1.0f;
                  if (dragSteps > 0.0f) multiplier = 1.0f + 0.1f * dragSteps;
                  else if (dragSteps < 0.0f) multiplier = 1.0f / (1.0f + 0.1f * fabsf(dragSteps));
 
-                 g_viewState.IsInteracting = true;
+                 GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
                  SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
                  if (g_hasRightDragZoomStartViews) {
-                     g_compare.left.view = g_rightDragZoomStartLeftView;
+                     GetPaneContext(PaneSlot::Left).view = g_rightDragZoomStartLeftView;
                      SetRightCompareView(g_rightDragZoomStartRightView);
                  }
-                 ApplyCompareZoomWithMultiplier(hwnd, g_compare.activePane, multiplier, &g_viewState.DragStartPos, g_compare.syncZoom);
-             } else if (g_imageResource) {
+                 ApplyCompareZoomWithMultiplier(hwnd, g_compare.activePane, multiplier, &GetPaneContext(PaneSlot::Primary).view.DragStartPos, g_compare.syncZoom);
+             } else if (GetPaneContext(PaneSlot::Primary).resource) {
                  constexpr float kPixelsPerStep = 48.0f;
                  POINT cursorPos{};
                  GetCursorPos(&cursorPos);
-                 const float totalDy = (float)(cursorPos.y - g_viewState.RightDragZoomStartScreenPos.y);
+                 const float totalDy = (float)(cursorPos.y - GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos.y);
                  const float dragSteps = (-totalDy * g_config.RightDragZoomSpeed) / (kPixelsPerStep * (std::max)(0.75f, g_uiScale));
                  if (fabsf(dragSteps) > 0.0001f) {
-                     g_viewState.IsInteracting = true;
+                     GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
                      SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
 
                      float multiplier = 1.0f;
                      if (dragSteps > 0.0f) multiplier = 1.0f + 0.1f * dragSteps;
                      else multiplier = 1.0f / (1.0f + 0.1f * fabsf(dragSteps));
 
-                     float newTotalScale = ClampTotalScale(hwnd, g_viewState.RightDragZoomStartTotalScale * multiplier);
-                     POINT anchorPt = g_viewState.RightDragZoomStartScreenPos;
+                     float newTotalScale = ClampTotalScale(hwnd, GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartTotalScale * multiplier);
+                     POINT anchorPt = GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos;
                      PerformSmartZoom(hwnd, newTotalScale, &anchorPt, false, false);
                      RequestRepaint(PaintLayer::Dynamic);
                      ShowZoomOsd(hwnd, newTotalScale);
                  } else {
-                     float startScale = ClampTotalScale(hwnd, g_viewState.RightDragZoomStartTotalScale);
-                     POINT anchorPt = g_viewState.RightDragZoomStartScreenPos;
+                     float startScale = ClampTotalScale(hwnd, GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartTotalScale);
+                     POINT anchorPt = GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos;
                      PerformSmartZoom(hwnd, startScale, &anchorPt, false, false);
                      RequestRepaint(PaintLayer::Dynamic);
                      ShowZoomOsd(hwnd, startScale);
@@ -8499,21 +8393,21 @@ SKIP_EDGE_NAV:;
          }
          
          // Middle button window drag
-         if (g_viewState.IsMiddleDragWindow) {
+         if (GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow) {
              POINT cursorPos;
              GetCursorPos(&cursorPos);
-             int newX = g_viewState.WindowDragStart.x + (cursorPos.x - g_viewState.CursorDragStart.x);
-             int newY = g_viewState.WindowDragStart.y + (cursorPos.y - g_viewState.CursorDragStart.y);
+             int newX = GetPaneContext(PaneSlot::Primary).view.WindowDragStart.x + (cursorPos.x - GetPaneContext(PaneSlot::Primary).view.CursorDragStart.x);
+             int newY = GetPaneContext(PaneSlot::Primary).view.WindowDragStart.y + (cursorPos.y - GetPaneContext(PaneSlot::Primary).view.CursorDragStart.y);
              SetWindowPos(hwnd, nullptr, newX, newY, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
              return 0;
          }
 
         // [Requirement 2] Exit fullscreen on drag detection
-        if (g_viewState.IsPendingFullscreenExitDrag) {
-            int dx = abs(pt.x - g_viewState.DragStartPos.x);
-            int dy = abs(pt.y - g_viewState.DragStartPos.y);
+        if (GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag) {
+            int dx = abs(pt.x - GetPaneContext(PaneSlot::Primary).view.DragStartPos.x);
+            int dy = abs(pt.y - GetPaneContext(PaneSlot::Primary).view.DragStartPos.y);
             if (dx > 5 || dy > 5) {
-                g_viewState.IsPendingFullscreenExitDrag = false;
+                GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag = false;
                 ReleaseCapture();
                 SendMessage(hwnd, WM_COMMAND, IDM_FULLSCREEN, 0);
                 // Start dragging the restored window
@@ -8528,43 +8422,43 @@ SKIP_EDGE_NAV:;
             const float w = (float)(rcSplit.right - rcSplit.left);
             if (w > 1.0f) {
                 g_compare.splitRatio = ClampCompareRatio((float)pt.x / w);
-                g_viewState.CompareSplitRatio = g_compare.splitRatio;
+                GetPaneContext(PaneSlot::Primary).view.CompareSplitRatio = g_compare.splitRatio;
                 MarkCompareDirty();
                 RequestRepaint(PaintLayer::Image | PaintLayer::Static);
             }
             return 0;
         }
          
-         if (g_viewState.IsDragging) {
-             const float dx = (float)(pt.x - g_viewState.LastMousePos.x);
-             const float dy = (float)(pt.y - g_viewState.LastMousePos.y);
-             g_viewState.LastMousePos = pt;
+         if (GetPaneContext(PaneSlot::Primary).view.IsDragging) {
+             const float dx = (float)(pt.x - GetPaneContext(PaneSlot::Primary).view.LastMousePos.x);
+             const float dy = (float)(pt.y - GetPaneContext(PaneSlot::Primary).view.LastMousePos.y);
+             GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
 
              if (IsCompareModeActive()) {
                  if (g_compare.activePane == ComparePane::Left) {
-                     g_compare.left.view.PanX += dx;
-                     g_compare.left.view.PanY += dy;
+                     GetPaneContext(PaneSlot::Left).view.PanX += dx;
+                     GetPaneContext(PaneSlot::Left).view.PanY += dy;
                      if (g_compare.syncPan) {
-                         g_viewState.PanX += dx;
-                         g_viewState.PanY += dy;
+                         GetPaneContext(PaneSlot::Primary).view.PanX += dx;
+                         GetPaneContext(PaneSlot::Primary).view.PanY += dy;
                      }
                  } else {
-                     g_viewState.PanX += dx;
-                     g_viewState.PanY += dy;
+                     GetPaneContext(PaneSlot::Primary).view.PanX += dx;
+                     GetPaneContext(PaneSlot::Primary).view.PanY += dy;
                      if (g_compare.syncPan) {
-                         g_compare.left.view.PanX += dx;
-                         g_compare.left.view.PanY += dy;
+                         GetPaneContext(PaneSlot::Left).view.PanX += dx;
+                         GetPaneContext(PaneSlot::Left).view.PanY += dy;
                      }
                  }
                  MarkCompareDirty();
                  RequestRepaint(PaintLayer::Image | PaintLayer::Static);
              } else {
-                 g_viewState.PanX += dx; 
-                 g_viewState.PanY += dy; 
+                 GetPaneContext(PaneSlot::Primary).view.PanX += dx; 
+                 GetPaneContext(PaneSlot::Primary).view.PanY += dy; 
 
                  RECT rc; GetClientRect(hwnd, &rc);
                  SyncDCompState(hwnd, (float)rc.right, (float)rc.bottom);
-                 if (UseSvgViewportRendering(g_imageResource)) {
+                 if (UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource)) {
                      RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic | PaintLayer::Static);
                  } else {
                      RequestRepaint(PaintLayer::Dynamic | PaintLayer::Static);  // OSD and Border indicators update
@@ -8612,13 +8506,13 @@ SKIP_EDGE_NAV:;
                 MarkStaticLayerDirty(); // Force Static Layer Update (Critical for Toolbar)
             }
         }
-        if (g_viewState.EdgeHoverState != 0) {
-            g_viewState.EdgeHoverState = 0;
+        if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverState != 0) {
+            GetPaneContext(PaneSlot::Primary).view.EdgeHoverState = 0;
             MarkStaticLayerDirty();
         }
-        if (g_viewState.EdgeHoverLeft != 0 || g_viewState.EdgeHoverRight != 0) {
-            g_viewState.EdgeHoverLeft = 0;
-            g_viewState.EdgeHoverRight = 0;
+        if (GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft != 0 || GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight != 0) {
+            GetPaneContext(PaneSlot::Primary).view.EdgeHoverLeft = 0;
+            GetPaneContext(PaneSlot::Primary).view.EdgeHoverRight = 0;
             MarkStaticLayerDirty();
         }
         if (g_compare.showDividerHandle) {
@@ -8648,12 +8542,12 @@ SKIP_EDGE_NAV:;
             ComparePane pane = HitTestComparePane(hwnd, pt);
             auto cyclePane = [&](ComparePane p) {
                 if (p == ComparePane::Left) {
-                    if (!g_compare.left.valid) return;
-                    CycleCompareZoomForPane(g_compare.left.view, g_compare.left.resource, GetCompareViewport(hwnd, ComparePane::Left));
+                    if (!GetPaneContext(PaneSlot::Left).valid) return;
+                    CycleCompareZoomForPane(GetPaneContext(PaneSlot::Left).view, GetPaneContext(PaneSlot::Left).resource, GetCompareViewport(hwnd, ComparePane::Left));
                 } else {
-                    if (!g_imageResource) return;
+                    if (!GetPaneContext(PaneSlot::Primary).resource) return;
                     CompareView right = GetRightCompareView();
-                    CycleCompareZoomForPane(right, g_imageResource, GetCompareViewport(hwnd, ComparePane::Right));
+                    CycleCompareZoomForPane(right, GetPaneContext(PaneSlot::Primary).resource, GetCompareViewport(hwnd, ComparePane::Right));
                     SetRightCompareView(right);
                 }
             };
@@ -8663,12 +8557,12 @@ SKIP_EDGE_NAV:;
                 // ComparePane other = (pane == ComparePane::Left) ? ComparePane::Right : ComparePane::Left;
                 if (pane == ComparePane::Left) {
                     CompareView right = GetRightCompareView();
-                    right.Zoom = g_compare.left.view.Zoom;
+                    right.Zoom = GetPaneContext(PaneSlot::Left).view.Zoom;
                     right.PanX = 0; right.PanY = 0;
                     SetRightCompareView(right);
                 } else {
-                    g_compare.left.view.Zoom = GetRightCompareView().Zoom;
-                    g_compare.left.view.PanX = 0; g_compare.left.view.PanY = 0;
+                    GetPaneContext(PaneSlot::Left).view.Zoom = GetRightCompareView().Zoom;
+                    GetPaneContext(PaneSlot::Left).view.PanX = 0; GetPaneContext(PaneSlot::Left).view.PanY = 0;
                 }
             } else {
                 cyclePane(pane);
@@ -8676,24 +8570,24 @@ SKIP_EDGE_NAV:;
 
             if (g_compare.syncPan) {
                 if (pane == ComparePane::Left) {
-                    g_viewState.PanX = g_compare.left.view.PanX;
-                    g_viewState.PanY = g_compare.left.view.PanY;
+                    GetPaneContext(PaneSlot::Primary).view.PanX = GetPaneContext(PaneSlot::Left).view.PanX;
+                    GetPaneContext(PaneSlot::Primary).view.PanY = GetPaneContext(PaneSlot::Left).view.PanY;
                 } else {
-                    g_compare.left.view.PanX = g_viewState.PanX;
-                    g_compare.left.view.PanY = g_viewState.PanY;
+                    GetPaneContext(PaneSlot::Left).view.PanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+                    GetPaneContext(PaneSlot::Left).view.PanY = GetPaneContext(PaneSlot::Primary).view.PanY;
                 }
             }
             MarkCompareDirty();
             RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);
 
             wchar_t leftBuf[32], rightBuf[32];
-            swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(g_compare.left.view.Zoom * 100.0f));
+            swprintf_s(leftBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetPaneContext(PaneSlot::Left).view.Zoom * 100.0f));
             swprintf_s(rightBuf, L"%s%d%%", AppStrings::OSD_ZoomPrefix, (int)std::round(GetRightCompareView().Zoom * 100.0f));
             g_osd.ShowCompare(hwnd, leftBuf, rightBuf);
             return 0;
         }
 
-        if (g_imageResource) {
+        if (GetPaneContext(PaneSlot::Primary).resource) {
             float currentRealScale = GetCurrentRealScale(hwnd);
             bool is100Percent = (fabsf(currentRealScale - 1.0f) < 0.05f);
 
@@ -8741,19 +8635,19 @@ SKIP_EDGE_NAV:;
 
     case WM_RBUTTONDOWN: {
         POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
-        g_viewState.IsRightButtonDown = false;
-        g_viewState.IsRightButtonDragZoom = false;
+        GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown = false;
+        GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom = false;
 
         const bool canStartRightDragZoom =
             g_config.RightButtonDragZoom &&
-            g_imageResource &&
+            GetPaneContext(PaneSlot::Primary).resource &&
             !g_gallery.IsVisible() &&
             !g_settingsOverlay.IsVisible() &&
             !g_helpOverlay.IsVisible() &&
             !g_dialog.IsVisible &&
-            !g_viewState.IsDragging &&
-            !g_viewState.IsMiddleDragWindow &&
-            !g_viewState.IsPendingFullscreenExitDrag;
+            !GetPaneContext(PaneSlot::Primary).view.IsDragging &&
+            !GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow &&
+            !GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag;
 
         if (canStartRightDragZoom) {
             POINT cursorPos{};
@@ -8761,21 +8655,21 @@ SKIP_EDGE_NAV:;
             if (IsCompareModeActive()) {
                 g_compare.activePane = HitTestComparePane(hwnd, pt);
             }
-            g_viewState.IsRightButtonDown = true;
-            g_viewState.LastMousePos = pt;
-            g_viewState.DragStartPos = pt;
-            g_viewState.RightDragZoomStartScreenPos = cursorPos;
-            g_viewState.DragStartTime = GetTickCount();
-            g_viewState.RightDragZoomStartTotalScale = GetCurrentTotalScale(hwnd);
+            GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown = true;
+            GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
+            GetPaneContext(PaneSlot::Primary).view.DragStartPos = pt;
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos = cursorPos;
+            GetPaneContext(PaneSlot::Primary).view.DragStartTime = GetTickCount();
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartTotalScale = GetCurrentTotalScale(hwnd);
             if (IsCompareModeActive()) {
                 if (g_compare.activePane == ComparePane::Left) {
-                    g_viewState.RightDragZoomStartComparePrimaryZoom = g_compare.left.view.Zoom;
-                    g_viewState.RightDragZoomStartCompareSecondaryZoom = GetRightCompareView().Zoom;
+                    GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartComparePrimaryZoom = GetPaneContext(PaneSlot::Left).view.Zoom;
+                    GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartCompareSecondaryZoom = GetRightCompareView().Zoom;
                 } else {
-                    g_viewState.RightDragZoomStartComparePrimaryZoom = GetRightCompareView().Zoom;
-                    g_viewState.RightDragZoomStartCompareSecondaryZoom = g_compare.left.view.Zoom;
+                    GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartComparePrimaryZoom = GetRightCompareView().Zoom;
+                    GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartCompareSecondaryZoom = GetPaneContext(PaneSlot::Left).view.Zoom;
                 }
-                g_rightDragZoomStartLeftView = g_compare.left.view;
+                g_rightDragZoomStartLeftView = GetPaneContext(PaneSlot::Left).view;
                 g_rightDragZoomStartRightView = GetRightCompareView();
                 g_hasRightDragZoomStartViews = true;
             } else {
@@ -8789,9 +8683,9 @@ SKIP_EDGE_NAV:;
     case WM_MBUTTONDOWN: {
         POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
         // Record start position/time for click vs drag detection
-        g_viewState.LastMousePos = pt;
-        g_viewState.DragStartPos = g_viewState.LastMousePos;
-        g_viewState.DragStartTime = GetTickCount();
+        GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
+        GetPaneContext(PaneSlot::Primary).view.DragStartPos = GetPaneContext(PaneSlot::Primary).view.LastMousePos;
+        GetPaneContext(PaneSlot::Primary).view.DragStartTime = GetTickCount();
 
         if (IsCompareModeActive()) {
             g_compare.activePane = HitTestComparePane(hwnd, pt);
@@ -8807,36 +8701,36 @@ SKIP_EDGE_NAV:;
             GetWindowRect(hwnd, &rc);
             POINT cursorPos;
             GetCursorPos(&cursorPos);
-            g_viewState.WindowDragStart = { rc.left, rc.top };
-            g_viewState.CursorDragStart = cursorPos;
-            g_viewState.IsMiddleDragWindow = true;
+            GetPaneContext(PaneSlot::Primary).view.WindowDragStart = { rc.left, rc.top };
+            GetPaneContext(PaneSlot::Primary).view.CursorDragStart = cursorPos;
+            GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow = true;
             SetCapture(hwnd);
             return 0;
         } else if (g_config.MiddleDragAction == MouseAction::PanImage) {
             // Pan Image with middle button
             if (CanPan(hwnd)) {
                 SetCapture(hwnd);
-                g_viewState.IsDragging = true;
-                g_viewState.IsInteracting = true;
+                GetPaneContext(PaneSlot::Primary).view.IsDragging = true;
+                GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
                 SetCursor(LoadCursor(nullptr, IDC_SIZEALL));
             } else {
-                g_viewState.IsDragging = false;
+                GetPaneContext(PaneSlot::Primary).view.IsDragging = false;
             }
         }
         return 0;
     }
     case WM_MBUTTONUP: {
         // Release capture if we were dragging window with middle button
-        if (g_viewState.IsMiddleDragWindow) {
+        if (GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow) {
             ReleaseCapture();
-            g_viewState.IsMiddleDragWindow = false;
+            GetPaneContext(PaneSlot::Primary).view.IsMiddleDragWindow = false;
             
             // Use screen coordinates to detect click (client coords change when window moves)
             POINT cursorPos;
             GetCursorPos(&cursorPos);
-            DWORD elapsed = GetTickCount() - g_viewState.DragStartTime;
-            int dx = abs(cursorPos.x - g_viewState.CursorDragStart.x);
-            int dy = abs(cursorPos.y - g_viewState.CursorDragStart.y);
+            DWORD elapsed = GetTickCount() - GetPaneContext(PaneSlot::Primary).view.DragStartTime;
+            int dx = abs(cursorPos.x - GetPaneContext(PaneSlot::Primary).view.CursorDragStart.x);
+            int dy = abs(cursorPos.y - GetPaneContext(PaneSlot::Primary).view.CursorDragStart.y);
             
             // Check if this was a "click" (short duration, minimal movement)
             if (elapsed < 300 && dx < 5 && dy < 5) {
@@ -8851,14 +8745,14 @@ SKIP_EDGE_NAV:;
         
         // For image drag mode, use client coordinates
         POINT currentPos = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
-        DWORD elapsed = GetTickCount() - g_viewState.DragStartTime;
-        int dx = abs(currentPos.x - g_viewState.DragStartPos.x);
-        int dy = abs(currentPos.y - g_viewState.DragStartPos.y);
+        DWORD elapsed = GetTickCount() - GetPaneContext(PaneSlot::Primary).view.DragStartTime;
+        int dx = abs(currentPos.x - GetPaneContext(PaneSlot::Primary).view.DragStartPos.x);
+        int dy = abs(currentPos.y - GetPaneContext(PaneSlot::Primary).view.DragStartPos.y);
         
         // Release capture if we were dragging image
-        if (g_viewState.IsDragging) {
+        if (GetPaneContext(PaneSlot::Primary).view.IsDragging) {
             ReleaseCapture();
-            g_viewState.IsDragging = false;
+            GetPaneContext(PaneSlot::Primary).view.IsDragging = false;
         }
         
         // Click threshold: <300ms and <5px movement
@@ -8871,8 +8765,8 @@ SKIP_EDGE_NAV:;
                     break;
                 case MouseAction::PanImage:
                     // Reset pan to center
-                    g_viewState.PanX = 0;
-                    g_viewState.PanY = 0;
+                    GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+                    GetPaneContext(PaneSlot::Primary).view.PanY = 0;
                     // [DComp] Hardware pan reset
                     if (g_compEngine && g_compEngine->IsInitialized()) {
                         RECT rc; GetClientRect(hwnd, &rc);
@@ -8888,9 +8782,9 @@ SKIP_EDGE_NAV:;
                     break;
                 case MouseAction::FitWindow:
                     // Reset zoom to fit
-                    g_viewState.Zoom = 1.0f;
-                    g_viewState.PanX = 0;
-                    g_viewState.PanY = 0;
+                    GetPaneContext(PaneSlot::Primary).view.Zoom = 1.0f;
+                    GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+                    GetPaneContext(PaneSlot::Primary).view.PanY = 0;
                     // [DComp] Hardware transform reset
                     if (g_compEngine && g_compEngine->IsInitialized()) {
                         RECT rc; GetClientRect(hwnd, &rc);
@@ -8902,7 +8796,7 @@ SKIP_EDGE_NAV:;
         }
         
         // Only end interaction and repaint if NOT exiting
-        g_viewState.IsInteracting = false;
+        GetPaneContext(PaneSlot::Primary).view.IsInteracting = false;
         RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);  // Pan end affects Image + OSD
         return 0;
     }
@@ -8941,9 +8835,9 @@ SKIP_EDGE_NAV:;
 
     case WM_NAVIGATOR_DIR_CHANGED: {
         // [Directory Watcher] Apply background scan result from watcher thread
-        size_t oldCount = g_navigator.Count();
-        g_navigator.ApplyPendingScanResult();
-        size_t newCount = g_navigator.Count();
+        size_t oldCount = GetPaneContext(PaneSlot::Primary).navigator.Count();
+        GetPaneContext(PaneSlot::Primary).navigator.ApplyPendingScanResult();
+        size_t newCount = GetPaneContext(PaneSlot::Primary).navigator.Count();
         if (newCount != oldCount) {
             RequestRepaint(PaintLayer::Static | PaintLayer::Dynamic);
             if (g_gallery.IsVisible()) {
@@ -9021,12 +8915,12 @@ SKIP_EDGE_NAV:;
                     SetCursor(LoadCursor(nullptr, IDC_ARROW)); // Fix sticky wait cursor
                     RestoreOverlayWindowState(hwnd);
                     int idx = g_gallery.GetSelectedIndex();
-                    if (idx >= 0 && idx < (int)g_navigator.Count()) {
-                         std::wstring path = g_navigator.GetFile(idx);
+                    if (idx >= 0 && idx < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+                         std::wstring path = GetPaneContext(PaneSlot::Primary).navigator.GetFile(idx);
                          // Only load if different from current image
-                         if (path != g_imagePath) {
-                             g_navigator.Initialize(path, hwnd);
-                             LoadImageAsync(hwnd, g_navigator.GetResolvedPath(path).c_str());
+                         if (path != GetPaneContext(PaneSlot::Primary).path) {
+                             GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd);
+                             LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(path).c_str());
                          }
                     }
                     RequestRepaint(PaintLayer::All);
@@ -9044,15 +8938,15 @@ SKIP_EDGE_NAV:;
              
              switch (hit.type) {
                  case UIHitResult::InfoPanelDrag:
-                     g_viewState.IsDraggingInfoPanel = true;
-                     g_viewState.InfoPanelDragAnchor = pt;
+                     GetPaneContext(PaneSlot::Primary).view.IsDraggingInfoPanel = true;
+                     GetPaneContext(PaneSlot::Primary).view.InfoPanelDragAnchor = pt;
                      SetCapture(hwnd);
                      return 0;
 
                  case UIHitResult::PanelToggle:
                      g_runtime.InfoPanelExpanded = !g_runtime.InfoPanelExpanded;
-                     if (g_runtime.InfoPanelExpanded && g_currentMetadata.HistR.empty() && !g_imagePath.empty()) {
-                         UpdateHistogramAsync(hwnd, g_imagePath);
+                     if (g_runtime.InfoPanelExpanded && GetPaneContext(PaneSlot::Primary).metadata.HistR.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                         UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
                      }
                      if (g_runtime.ShowInfoPanel) {
                 AdjustWindowForOverlay(hwnd, false);
@@ -9093,9 +8987,9 @@ SKIP_EDGE_NAV:;
                          g_runtime.CompareHudMode = 0;
                      }
                      if (g_runtime.ShowCompareInfo) {
-                         if (g_currentMetadata.HistL.empty() && !g_imagePath.empty()) UpdateHistogramAsync(hwnd, g_imagePath);
-                         if ((g_compare.left.metadata.HistL.empty() || !g_compare.left.metadata.IsFullMetadataLoaded) && !g_compare.left.path.empty())
-                             UpdateCompareLeftHistogramAsync(hwnd, g_compare.left.path);
+                         if (GetPaneContext(PaneSlot::Primary).metadata.HistL.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
+                         if ((GetPaneContext(PaneSlot::Left).metadata.HistL.empty() || !GetPaneContext(PaneSlot::Left).metadata.IsFullMetadataLoaded) && !GetPaneContext(PaneSlot::Left).path.empty())
+                             UpdateCompareLeftHistogramAsync(hwnd, GetPaneContext(PaneSlot::Left).path);
                      }
                      RequestRepaint(PaintLayer::All);
                      return 0;
@@ -9108,9 +9002,9 @@ SKIP_EDGE_NAV:;
                          g_runtime.CompareHudMode = 2;
                      }
                      if (g_runtime.ShowCompareInfo) {
-                         if (g_currentMetadata.HistL.empty() && !g_imagePath.empty()) UpdateHistogramAsync(hwnd, g_imagePath);
-                         if ((g_compare.left.metadata.HistL.empty() || !g_compare.left.metadata.IsFullMetadataLoaded) && !g_compare.left.path.empty())
-                             UpdateCompareLeftHistogramAsync(hwnd, g_compare.left.path);
+                         if (GetPaneContext(PaneSlot::Primary).metadata.HistL.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
+                         if ((GetPaneContext(PaneSlot::Left).metadata.HistL.empty() || !GetPaneContext(PaneSlot::Left).metadata.IsFullMetadataLoaded) && !GetPaneContext(PaneSlot::Left).path.empty())
+                             UpdateCompareLeftHistogramAsync(hwnd, GetPaneContext(PaneSlot::Left).path);
                      }
                      RequestRepaint(PaintLayer::All);
                      return 0;
@@ -9207,8 +9101,8 @@ SKIP_EDGE_NAV:;
         }
         
         // Record Drag Start for click detection
-        g_viewState.DragStartPos = pt;
-        g_viewState.DragStartTime = GetTickCount();
+        GetPaneContext(PaneSlot::Primary).view.DragStartPos = pt;
+        GetPaneContext(PaneSlot::Primary).view.DragStartTime = GetTickCount();
         
         // If in Edge Zone, skip WindowDrag and let LBUTTONUP handle nav
         if (inEdgeZone) {
@@ -9228,8 +9122,8 @@ SKIP_EDGE_NAV:;
         if (effectiveAction == MouseAction::WindowDrag) {
             // [Requirement] Exit fullscreen on drag
             if (g_isFullScreen) {
-                g_viewState.IsPendingFullscreenExitDrag = true;
-                g_viewState.DragStartPos = pt;
+                GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag = true;
+                GetPaneContext(PaneSlot::Primary).view.DragStartPos = pt;
                 SetCapture(hwnd);
                 return 0;
             }
@@ -9243,13 +9137,13 @@ SKIP_EDGE_NAV:;
         } else if (effectiveAction == MouseAction::PanImage) {
             bool allowPan = CanPan(hwnd);
             if (IsCompareModeActive()) {
-                allowPan = (g_compare.activePane == ComparePane::Left) ? g_compare.left.valid : (bool)g_imageResource;
+                allowPan = (g_compare.activePane == ComparePane::Left) ? GetPaneContext(PaneSlot::Left).valid : (bool)GetPaneContext(PaneSlot::Primary).resource;
             }
             if (allowPan) {
                 SetCapture(hwnd);
-                g_viewState.IsDragging = true;
-                g_viewState.IsInteracting = true;  // Start interaction mode
-                g_viewState.LastMousePos = pt;
+                GetPaneContext(PaneSlot::Primary).view.IsDragging = true;
+                GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;  // Start interaction mode
+                GetPaneContext(PaneSlot::Primary).view.LastMousePos = pt;
                 SetCursor(LoadCursor(nullptr, IDC_SIZEALL));
             }
         }
@@ -9272,8 +9166,8 @@ SKIP_EDGE_NAV:;
             return 0;
         }
 
-        if (g_viewState.IsDraggingInfoPanel) {
-            g_viewState.IsDraggingInfoPanel = false;
+        if (GetPaneContext(PaneSlot::Primary).view.IsDraggingInfoPanel) {
+            GetPaneContext(PaneSlot::Primary).view.IsDraggingInfoPanel = false;
             ReleaseCapture();
             g_config.InfoPanelX = g_runtime.InfoPanelX;
             g_config.InfoPanelY = g_runtime.InfoPanelY;
@@ -9281,8 +9175,8 @@ SKIP_EDGE_NAV:;
             return 0;
         }
 
-        if (g_viewState.IsPendingFullscreenExitDrag) {
-            g_viewState.IsPendingFullscreenExitDrag = false;
+        if (GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag) {
+            GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag = false;
             ReleaseCapture();
         }
         if (IsCompareModeActive()) {
@@ -9308,10 +9202,10 @@ SKIP_EDGE_NAV:;
                      SetCursor(LoadCursor(nullptr, IDC_ARROW)); // Restore cursor
                      RestoreOverlayWindowState(hwnd);
                      int idx = g_gallery.GetSelectedIndex();
-                     if (idx >= 0 && idx < (int)g_navigator.Count()) {
-                         std::wstring path = g_navigator.GetFile(idx);
-                         g_navigator.Initialize(path, hwnd);
-                         LoadImageAsync(hwnd, g_navigator.GetResolvedPath(path).c_str());
+                     if (idx >= 0 && idx < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+                         std::wstring path = GetPaneContext(PaneSlot::Primary).navigator.GetFile(idx);
+                         GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd);
+                         LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(path).c_str());
                      }
                      RequestRepaint(PaintLayer::All);
                 } else {
@@ -9406,24 +9300,24 @@ SKIP_EDGE_NAV:;
                     RequestRepaint(PaintLayer::All);
                     break;
                 case ToolbarButtonID::CompareSwap:
-                    if (IsCompareModeActive() && g_compare.left.valid && g_imageResource) {
-                        ImageResource rightRes = std::move(g_imageResource);
-                        CImageLoader::ImageMetadata rightMeta = g_currentMetadata;
-                        std::wstring rightPath = g_imagePath;
+                    if (IsCompareModeActive() && GetPaneContext(PaneSlot::Left).valid && GetPaneContext(PaneSlot::Primary).resource) {
+                        ImageResource rightRes = std::move(GetPaneContext(PaneSlot::Primary).resource);
+                        CImageLoader::ImageMetadata rightMeta = GetPaneContext(PaneSlot::Primary).metadata;
+                        std::wstring rightPath = GetPaneContext(PaneSlot::Primary).path;
                         CompareView rightView = GetRightCompareView();
 
-                        g_imageResource = std::move(g_compare.left.resource);
-                        g_currentMetadata = g_compare.left.metadata;
-                        g_imagePath = g_compare.left.path;
-                        SetRightCompareView(g_compare.left.view);
-
-                        g_compare.left.resource = std::move(rightRes);
-                        g_compare.left.metadata = rightMeta;
-                        g_compare.left.path = rightPath;
-                        g_compare.left.view = rightView;
-                        g_compare.left.valid = true;
-                        if (!g_imagePath.empty()) {
-                            g_navigator.Initialize(g_imagePath, hwnd);
+                        GetPaneContext(PaneSlot::Primary).resource = std::move(GetPaneContext(PaneSlot::Left).resource);
+                        GetPaneContext(PaneSlot::Primary).metadata = GetPaneContext(PaneSlot::Left).metadata;
+                        GetPaneContext(PaneSlot::Primary).path = GetPaneContext(PaneSlot::Left).path;
+                        SetRightCompareView(GetPaneContext(PaneSlot::Left).view);
+
+                        GetPaneContext(PaneSlot::Left).resource = std::move(rightRes);
+                        GetPaneContext(PaneSlot::Left).metadata = rightMeta;
+                        GetPaneContext(PaneSlot::Left).path = rightPath;
+                        GetPaneContext(PaneSlot::Left).view = rightView;
+                        GetPaneContext(PaneSlot::Left).valid = true;
+                        if (!GetPaneContext(PaneSlot::Primary).path.empty()) {
+                            GetPaneContext(PaneSlot::Primary).navigator.Initialize(GetPaneContext(PaneSlot::Primary).path, hwnd);
                         }
                         MarkCompareDirty();
                         RequestRepaint(PaintLayer::Image | PaintLayer::Static);
@@ -9438,25 +9332,25 @@ SKIP_EDGE_NAV:;
                             : ViewMode::CompareSideBySide;
                         g_compare.draggingDivider = false;
                         ReleaseCapture();
-                        g_viewState.CompareActive = true;
+                        GetPaneContext(PaneSlot::Primary).view.CompareActive = true;
                         
                         // SNAP window to images on mode change (Side-by-Side <-> Wipe)
                         SnapWindowToCompareImages(hwnd);
                         
-                        g_viewState.CompareSplitRatio = GetCompareSplitRatio();
+                        GetPaneContext(PaneSlot::Primary).view.CompareSplitRatio = GetCompareSplitRatio();
                         MarkCompareDirty();
                         RequestRepaint(PaintLayer::Image | PaintLayer::Static);
                     }
                     break;
                 case ToolbarButtonID::CompareInfo:
-                    if (IsCompareModeActive() && g_compare.left.valid && g_imageResource) {
+                    if (IsCompareModeActive() && GetPaneContext(PaneSlot::Left).valid && GetPaneContext(PaneSlot::Primary).resource) {
                         ToggleCompareHUD(hwnd, 1);
                     }
                     break;
                 case ToolbarButtonID::CompareRawToggle:
                     if (IsCompareModeActive()) {
                         bool isLeft = (g_compare.selectedPane == ComparePane::Left);
-                        const std::wstring& selPath = isLeft ? g_compare.left.path : g_imagePath;
+                        const std::wstring& selPath = isLeft ? GetPaneContext(PaneSlot::Left).path : GetPaneContext(PaneSlot::Primary).path;
                         if (!IsRawFile(selPath)) break; // Selected pane is not RAW, ignore
                         // Point context to selected pane, then delegate to IDM_RENDER_RAW
                         g_compare.contextPane = g_compare.selectedPane;
@@ -9501,7 +9395,7 @@ SKIP_EDGE_NAV:;
                     break;
                 // [v10.5] Animation Toolbar Buttons
                 case ToolbarButtonID::AnimPlayPause:
-                    if (g_imageResource.animator) {
+                    if (GetPaneContext(PaneSlot::Primary).resource.animator) {
                         SendMessage(hwnd, WM_KEYDOWN, VK_SPACE, 0);
                     }
                     break;
@@ -9512,7 +9406,7 @@ SKIP_EDGE_NAV:;
                     HandleAnimFrameStep(hwnd, true);
                     break;
                 case ToolbarButtonID::AnimDirtyRect:
-                    if (g_imageResource.animator) {
+                    if (GetPaneContext(PaneSlot::Primary).resource.animator) {
                         g_showAnimDirtyRect = !g_showAnimDirtyRect;
                         g_osd.Show(hwnd, g_showAnimDirtyRect ? L"[Animation] Dirty Rect: ON" : L"[Animation] Dirty Rect: OFF", true);
                         RequestRepaint(PaintLayer::Dynamic);
@@ -9531,7 +9425,7 @@ SKIP_EDGE_NAV:;
                         g_toolbarHideTime = GetTickCount() + 2000; 
                     }
                     float targetProgress = 0.0f;
-                    if (g_imageResource.animator && g_toolbar.GetAnimSeekTarget(targetProgress)) {
+                    if (GetPaneContext(PaneSlot::Primary).resource.animator && g_toolbar.GetAnimSeekTarget(targetProgress)) {
                         PerformAnimSeek(hwnd, targetProgress);
                     }
                     break;
@@ -9542,16 +9436,16 @@ SKIP_EDGE_NAV:;
             return 0;
         }
 
-        if (g_viewState.IsDragging) { 
+        if (GetPaneContext(PaneSlot::Primary).view.IsDragging) { 
             // Only consider it a drag if moved significantly or held long
             POINT currentPos = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
-            DWORD elapsed = GetTickCount() - g_viewState.DragStartTime;
-            int dx = abs(currentPos.x - g_viewState.DragStartPos.x);
-            int dy = abs(currentPos.y - g_viewState.DragStartPos.y);
+            DWORD elapsed = GetTickCount() - GetPaneContext(PaneSlot::Primary).view.DragStartTime;
+            int dx = abs(currentPos.x - GetPaneContext(PaneSlot::Primary).view.DragStartPos.x);
+            int dy = abs(currentPos.y - GetPaneContext(PaneSlot::Primary).view.DragStartPos.y);
             
             ReleaseCapture(); 
-            g_viewState.IsDragging = false; 
-            g_viewState.IsInteracting = false;  // End interaction mode
+            GetPaneContext(PaneSlot::Primary).view.IsDragging = false; 
+            GetPaneContext(PaneSlot::Primary).view.IsInteracting = false;  // End interaction mode
 
             // If it was a real drag, return
             if (elapsed > 300 || dx > 5 || dy > 5) {
@@ -9560,10 +9454,10 @@ SKIP_EDGE_NAV:;
             }
             // Fallthrough: Treat as Click
         }
-        g_viewState.IsInteracting = false;  // End interaction mode
+        GetPaneContext(PaneSlot::Primary).view.IsInteracting = false;  // End interaction mode
 
         // Edge Navigation Click
-        if (g_config.EdgeNavClick && !g_gallery.IsVisible() && !g_settingsOverlay.IsVisible() && !g_helpOverlay.IsVisible() && !g_dialog.IsVisible && !g_compare.draggingDivider && !g_viewState.IsDragging) {
+        if (g_config.EdgeNavClick && !g_gallery.IsVisible() && !g_settingsOverlay.IsVisible() && !g_helpOverlay.IsVisible() && !g_dialog.IsVisible && !g_compare.draggingDivider && !GetPaneContext(PaneSlot::Primary).view.IsDragging) {
             // [Fix] Block edge nav if clicking on Info UI / HUD
             if (g_uiRenderer) {
                 auto hit = g_uiRenderer->HitTest((float)pt.x, (float)pt.y);
@@ -9727,7 +9621,7 @@ SKIP_EDGE_NAV:;
             return 0;
         }
 
-        if (!g_imageResource) return 0;
+        if (!GetPaneContext(PaneSlot::Primary).resource) return 0;
 
         if (shouldNavigate) {
             int direction = (delta > 0.0f) ? -1 : 1;
@@ -9740,7 +9634,7 @@ SKIP_EDGE_NAV:;
         // Magnetic Snap Time Lock is now handled inside CalculateTargetZoom
         
         // Enable interaction mode during zoom (use LINEAR interpolation)
-        g_viewState.IsInteracting = true;
+        GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
         // Set timer to reset interaction mode after 150ms of inactivity
         SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
         
@@ -9791,15 +9685,15 @@ SKIP_EDGE_NAV:;
         if ((HWND)lParam != hwnd) {
             g_winCtrlPressedState = -1;
         }
-        g_viewState.IsRightButtonDown = false;
-        g_viewState.IsRightButtonDragZoom = false;
-        g_viewState.RightDragZoomStartScreenPos = { 0, 0 };
-        g_viewState.RightDragZoomStartTotalScale = 1.0f;
-        g_viewState.RightDragZoomStartComparePrimaryZoom = 1.0f;
-        g_viewState.RightDragZoomStartCompareSecondaryZoom = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown = false;
+        GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom = false;
+        GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos = { 0, 0 };
+        GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartTotalScale = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartComparePrimaryZoom = 1.0f;
+        GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartCompareSecondaryZoom = 1.0f;
         g_hasRightDragZoomStartViews = false;
-        if (g_viewState.IsPendingFullscreenExitDrag) {
-            g_viewState.IsPendingFullscreenExitDrag = false;
+        if (GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag) {
+            GetPaneContext(PaneSlot::Primary).view.IsPendingFullscreenExitDrag = false;
         }
         break;
 
@@ -9870,12 +9764,12 @@ SKIP_EDGE_NAV:;
                     AdjustWindowForOverlay(hwnd, true); // Restore window state on close
                     // Closed with selection potentially
                     int idx = g_gallery.GetSelectedIndex();
-                    if (idx >= 0 && idx < (int)g_navigator.Count()) {
-                         std::wstring path = g_navigator.GetFile(idx);
+                    if (idx >= 0 && idx < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+                         std::wstring path = GetPaneContext(PaneSlot::Primary).navigator.GetFile(idx);
                          // Only load if different from current image
-                         if (path != g_imagePath) {
-                             g_navigator.Initialize(path, hwnd); 
-                             LoadImageAsync(hwnd, g_navigator.GetResolvedPath(path).c_str());
+                         if (path != GetPaneContext(PaneSlot::Primary).path) {
+                             GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd); 
+                             LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(path).c_str());
                          }
                     }
                     RequestRepaint(PaintLayer::All);
@@ -9925,37 +9819,37 @@ SKIP_EDGE_NAV:;
         case VK_MENU: return 0; // 鎷︽埅 Alt 閿寜涓嬶紝閰嶅悎 WM_SYSKEYUP 褰诲簳娑堥櫎鑿滃崟寰幆闂
         // Navigation
         case VK_LEFT: 
-            if (alt && g_imageResource.animator) {
+            if (alt && GetPaneContext(PaneSlot::Primary).resource.animator) {
                 HandleAnimFrameStep(hwnd, false);
             } else if (CheckUnsavedChanges(hwnd)) {
                 Navigate(hwnd, -1);
             }
             break;
         case VK_RIGHT: 
-            if (alt && g_imageResource.animator) {
+            if (alt && GetPaneContext(PaneSlot::Primary).resource.animator) {
                 HandleAnimFrameStep(hwnd, true);
             } else if (CheckUnsavedChanges(hwnd)) {
                 Navigate(hwnd, 1);
             }
             break;
         case VK_OEM_COMMA: // Comma (,): Previous Frame
-            if (g_imageResource.animator) {
+            if (GetPaneContext(PaneSlot::Primary).resource.animator) {
                 SendMessage(hwnd, WM_COMMAND, (WPARAM)ToolbarButtonID::AnimPrevFrame, 0);
             }
             break;
         case VK_OEM_PERIOD: // Period (.): Next Frame
-            if (g_imageResource.animator) {
+            if (GetPaneContext(PaneSlot::Primary).resource.animator) {
                 SendMessage(hwnd, WM_COMMAND, (WPARAM)ToolbarButtonID::AnimNextFrame, 0);
             }
             break;
         case VK_UP: SendMessage(hwnd, WM_KEYDOWN, VK_ADD, 0); break; // Up: Zoom In
         case VK_DOWN: SendMessage(hwnd, WM_KEYDOWN, VK_SUBTRACT, 0); break; // Down: Zoom Out
         case VK_SPACE: 
-            if (g_imageResource.animator) {
+            if (GetPaneContext(PaneSlot::Primary).resource.animator) {
                 g_animPlaying = !g_animPlaying;
                 if (g_animPlaying) {
                     g_animInspectorFrame = -1;
-                    uint32_t delayMs = g_imageResource.frameMeta.delayMs;
+                    uint32_t delayMs = GetPaneContext(PaneSlot::Primary).resource.frameMeta.delayMs;
                     if (delayMs < 10) delayMs = 100;
                     SetTimer(hwnd, IDT_ANIMATION, delayMs, NULL);
                     g_osd.Show(hwnd, L"[Animation] Playing", true);
@@ -10066,14 +9960,14 @@ SKIP_EDGE_NAV:;
                 if (!g_runtime.ShowInfoPanel) {
                     g_runtime.ShowInfoPanel = true;
                     g_runtime.InfoPanelExpanded = true;
-                    if (g_currentMetadata.HistR.empty() && !g_imagePath.empty()) {
-                        UpdateHistogramAsync(hwnd, g_imagePath);
+                    if (GetPaneContext(PaneSlot::Primary).metadata.HistR.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                        UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
                     }
                     g_toolbar.SetExifState(true);
                 } else if (!g_runtime.InfoPanelExpanded) {
                     g_runtime.InfoPanelExpanded = true;
-                    if (g_currentMetadata.HistR.empty() && !g_imagePath.empty()) {
-                        UpdateHistogramAsync(hwnd, g_imagePath);
+                    if (GetPaneContext(PaneSlot::Primary).metadata.HistR.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                        UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
                     }
                 } else {
                     g_runtime.ShowInfoPanel = false;
@@ -10113,7 +10007,7 @@ SKIP_EDGE_NAV:;
         case '1': case 'Z': case VK_NUMPAD1: { // 100% Original size
             if (IsCompareModeActive()) {
                 PerformCompareZoom100(hwnd);
-            } else if (g_imageResource) {
+            } else if (GetPaneContext(PaneSlot::Primary).resource) {
                 float currentRealScale = GetCurrentRealScale(hwnd);
                 bool is100Percent = (fabsf(currentRealScale - 1.0f) < 0.05f);
                 bool isMaximizedOrFullscreen = IsZoomed(hwnd) || g_isFullScreen;
@@ -10131,7 +10025,7 @@ SKIP_EDGE_NAV:;
         case '0': case 'F': case VK_NUMPAD0: { // Fit to Screen (Best Fit)
             if (IsCompareModeActive()) {
                 PerformCompareZoomFit(hwnd);
-            } else if (g_imageResource) {
+            } else if (GetPaneContext(PaneSlot::Primary).resource) {
                 HMONITOR hMon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
                 MONITORINFO mi{}; mi.cbSize = sizeof(mi); GetMonitorInfoW(hMon, &mi);
                 int maxW = mi.rcWork.right - mi.rcWork.left;
@@ -10155,7 +10049,7 @@ SKIP_EDGE_NAV:;
 
         case VK_ADD: case VK_OEM_PLUS: // Zoom In
         case VK_SUBTRACT: case VK_OEM_MINUS: { // Zoom Out
-            if (!g_imageResource) break;
+            if (!GetPaneContext(PaneSlot::Primary).resource) break;
             
             bool isZoomIn = (wParam == VK_ADD || wParam == VK_OEM_PLUS);
             bool isCtrl = (GetKeyState(VK_CONTROL) & 0x8000);
@@ -10172,7 +10066,7 @@ SKIP_EDGE_NAV:;
             // Keyboard step zoom should respect the current lock-window policy.
             PerformSmartZoom(hwnd, newTotalScale, nullptr, false, false);
 
-            g_viewState.IsInteracting = true;
+            GetPaneContext(PaneSlot::Primary).view.IsInteracting = true;
             SetTimer(hwnd, IDT_INTERACTION, 150, nullptr);
 
             ShowZoomOsd(hwnd, newTotalScale);
@@ -10207,18 +10101,18 @@ SKIP_EDGE_NAV:;
     }
     
     case WM_RBUTTONUP: {
-        const bool wasRightDragZoom = g_viewState.IsRightButtonDragZoom;
-        const bool wasRightButtonDown = g_viewState.IsRightButtonDown;
+        const bool wasRightDragZoom = GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom;
+        const bool wasRightButtonDown = GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown;
         if (wasRightDragZoom || wasRightButtonDown) {
             if (GetCapture() == hwnd) {
                 ReleaseCapture();
             }
-            g_viewState.IsRightButtonDragZoom = false;
-            g_viewState.IsRightButtonDown = false;
-            g_viewState.RightDragZoomStartScreenPos = { 0, 0 };
-            g_viewState.RightDragZoomStartTotalScale = 1.0f;
-            g_viewState.RightDragZoomStartComparePrimaryZoom = 1.0f;
-            g_viewState.RightDragZoomStartCompareSecondaryZoom = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.IsRightButtonDragZoom = false;
+            GetPaneContext(PaneSlot::Primary).view.IsRightButtonDown = false;
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartScreenPos = { 0, 0 };
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartTotalScale = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartComparePrimaryZoom = 1.0f;
+            GetPaneContext(PaneSlot::Primary).view.RightDragZoomStartCompareSecondaryZoom = 1.0f;
             g_hasRightDragZoomStartViews = false;
             if (wasRightDragZoom) {
                 return 0;
@@ -10247,17 +10141,17 @@ SKIP_EDGE_NAV:;
             RequestRepaint(PaintLayer::Image | PaintLayer::Static);
         }
         
-        bool hasImage = g_imageResource;
+        bool hasImage = GetPaneContext(PaneSlot::Primary).resource;
         bool extensionFixNeeded = false;
         bool isRaw = false;
         bool renderRaw = g_runtime.ForceRawDecode;
-        std::wstring targetPath = g_imagePath;
-        std::wstring targetFmt = g_currentMetadata.Format;
+        std::wstring targetPath = GetPaneContext(PaneSlot::Primary).path;
+        std::wstring targetFmt = GetPaneContext(PaneSlot::Primary).metadata.Format;
 
         if (IsCompareModeActive() && g_compare.contextPane == ComparePane::Left) {
-            hasImage = g_compare.left.valid;
-            targetPath = g_compare.left.path;
-            targetFmt = g_compare.left.metadata.Format;
+            hasImage = GetPaneContext(PaneSlot::Left).valid;
+            targetPath = GetPaneContext(PaneSlot::Left).path;
+            targetFmt = GetPaneContext(PaneSlot::Left).metadata.Format;
         }
 
         if (IsCompareModeActive()) {
@@ -10275,9 +10169,9 @@ SKIP_EDGE_NAV:;
         
         bool isPixelArtMode = GetCurrentPixelArtState(hwnd);
         const bool contextLeft = IsCompareModeActive() && g_compare.contextPane == ComparePane::Left;
-        int menuCmsMode = contextLeft ? (g_compare.left.CmsModeOverride != -1 ? g_compare.left.CmsModeOverride : (g_config.ColorManagement ? 1 : 0)) : g_runtime.GetEffectiveCmsMode(g_config.ColorManagement);
-        bool menuEnableSoftProofing = contextLeft ? g_compare.left.EnableSoftProofing : g_runtime.EnableSoftProofing;
-        std::wstring menuSoftProofPath = contextLeft ? g_compare.left.SoftProofProfilePath : g_runtime.SoftProofProfilePath;
+        int menuCmsMode = contextLeft ? (GetPaneContext(PaneSlot::Left).CmsModeOverride != -1 ? GetPaneContext(PaneSlot::Left).CmsModeOverride : (g_config.ColorManagement ? 1 : 0)) : g_runtime.GetEffectiveCmsMode(g_config.ColorManagement);
+        bool menuEnableSoftProofing = contextLeft ? GetPaneContext(PaneSlot::Left).EnableSoftProofing : g_runtime.EnableSoftProofing;
+        std::wstring menuSoftProofPath = contextLeft ? GetPaneContext(PaneSlot::Left).SoftProofProfilePath : g_runtime.SoftProofProfilePath;
 
         ShowContextMenu(hwnd, pt, hasImage, extensionFixNeeded, g_runtime.LockWindowSize, g_runtime.ShowInfoPanel, g_runtime.InfoPanelExpanded, g_config.AlwaysOnTop, renderRaw, isRaw, IsZoomed(hwnd) != 0, g_runtime.CrossMonitorMode, IsCompareModeActive(), isPixelArtMode, menuCmsMode, menuEnableSoftProofing, menuSoftProofPath);
         return 0;
@@ -10302,8 +10196,8 @@ SKIP_EDGE_NAV:;
         UINT wmId = cmdId;
 
         const bool contextLeft = IsCompareContextLeft();
-        const std::wstring& contextPath = contextLeft ? g_compare.left.path : g_imagePath;
-        const CImageLoader::ImageMetadata& contextMeta = contextLeft ? g_compare.left.metadata : g_currentMetadata;
+        const std::wstring& contextPath = contextLeft ? GetPaneContext(PaneSlot::Left).path : GetPaneContext(PaneSlot::Primary).path;
+        const CImageLoader::ImageMetadata& contextMeta = contextLeft ? GetPaneContext(PaneSlot::Left).metadata : GetPaneContext(PaneSlot::Primary).metadata;
 
         // Soft Proofing Profile Dynamic Dispatch
         if (cmdId >= IDM_SOFT_PROOF_BASE && cmdId <= IDM_SOFT_PROOF_BASE + 99) {
@@ -10312,8 +10206,8 @@ SKIP_EDGE_NAV:;
             int idx = cmdId - IDM_SOFT_PROOF_BASE;
             if (idx >= 0 && static_cast<size_t>(idx) < profiles.size()) {
                 if (contextLeft) {
-                    g_compare.left.SoftProofProfilePath = profiles[idx];
-                    g_compare.left.EnableSoftProofing = true;
+                    GetPaneContext(PaneSlot::Left).SoftProofProfilePath = profiles[idx];
+                    GetPaneContext(PaneSlot::Left).EnableSoftProofing = true;
                 } else {
                     g_runtime.SoftProofProfilePath = profiles[idx];
                     g_runtime.EnableSoftProofing = true;
@@ -10333,8 +10227,8 @@ SKIP_EDGE_NAV:;
 
         switch (cmdId) {
         case IDM_GALLERY_OPEN_COMPARE: {
-            if (g_galleryContextMenuIndex >= 0 && g_galleryContextMenuIndex < (int)g_navigator.Count()) {
-                std::wstring path = g_navigator.GetFile(g_galleryContextMenuIndex);
+            if (g_galleryContextMenuIndex >= 0 && g_galleryContextMenuIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+                std::wstring path = GetPaneContext(PaneSlot::Primary).navigator.GetFile(g_galleryContextMenuIndex);
                 g_gallery.Close();
                 RestoreOverlayWindowState(hwnd);
                 if (!IsCompareModeActive()) {
@@ -10354,8 +10248,8 @@ SKIP_EDGE_NAV:;
         }
 
         case IDM_GALLERY_OPEN_NEW_WINDOW: {
-            if (g_galleryContextMenuIndex >= 0 && g_galleryContextMenuIndex < (int)g_navigator.Count()) {
-                std::wstring path = g_navigator.GetFile(g_galleryContextMenuIndex);
+            if (g_galleryContextMenuIndex >= 0 && g_galleryContextMenuIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+                std::wstring path = GetPaneContext(PaneSlot::Primary).navigator.GetFile(g_galleryContextMenuIndex);
                 wchar_t exePath[MAX_PATH];
                 if (GetModuleFileNameW(nullptr, exePath, MAX_PATH)) {
                     // Enclose path in quotes
@@ -10390,11 +10284,11 @@ SKIP_EDGE_NAV:;
                             g_compare.activePane = ComparePane::Right;
                             g_compare.selectedPane = ComparePane::Right;
                         }
-                        g_editState.Reset();
-                        g_viewState.Reset();
-                        g_navigator.Initialize(szFile, hwnd);
+                        GetPaneContext(PaneSlot::Primary).editState.Reset();
+                        GetPaneContext(PaneSlot::Primary).view.Reset();
+                        GetPaneContext(PaneSlot::Primary).navigator.Initialize(szFile, hwnd);
                         g_thumbMgr.ClearCache(); // Fix: Clear old thumbnails on folder switch
-                    LoadImageAsync(hwnd, g_navigator.GetResolvedPath(szFile).c_str());
+                    LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(szFile).c_str());
                 }
             }
             break;
@@ -10531,7 +10425,7 @@ SKIP_EDGE_NAV:;
                              SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
                 
                     // [Fix] Reset zoom/pan to ensure image fits restored window
-                    g_viewState.Reset();
+                    GetPaneContext(PaneSlot::Primary).view.Reset();
                     RestoreCurrentExifOrientation();
                 } else {
                 // Enter Fullscreen
@@ -10570,15 +10464,15 @@ SKIP_EDGE_NAV:;
         }
         case IDM_RENAME: {
             if (!CheckUnsavedChanges(hwnd)) break;
-            if (IsCompareModeActive() && g_compare.contextPane == ComparePane::Left && !g_compare.left.path.empty()) {
+            if (IsCompareModeActive() && g_compare.contextPane == ComparePane::Left && !GetPaneContext(PaneSlot::Left).path.empty()) {
                 std::wstring currentFolder = L"";
                 std::wstring currentName = L"";
-                size_t lastSlash = g_compare.left.path.find_last_of(L"\\/");
+                size_t lastSlash = GetPaneContext(PaneSlot::Left).path.find_last_of(L"\\/");
                 if (lastSlash != std::wstring::npos) {
-                    currentFolder = g_compare.left.path.substr(0, lastSlash + 1);
-                    currentName = g_compare.left.path.substr(lastSlash + 1);
+                    currentFolder = GetPaneContext(PaneSlot::Left).path.substr(0, lastSlash + 1);
+                    currentName = GetPaneContext(PaneSlot::Left).path.substr(lastSlash + 1);
                 } else {
-                    currentName = g_compare.left.path;
+                    currentName = GetPaneContext(PaneSlot::Left).path;
                 }
 
                 CenterDialogOnComparePaneIfNeeded(hwnd, ComparePane::Left);
@@ -10596,7 +10490,7 @@ SKIP_EDGE_NAV:;
 
                 if (!newName.empty() && newName != currentName) {
                     std::wstring newPath = currentFolder + newName;
-                    if (MoveFileW(g_compare.left.path.c_str(), newPath.c_str())) {
+                    if (MoveFileW(GetPaneContext(PaneSlot::Left).path.c_str(), newPath.c_str())) {
                         LoadImageIntoCompareLeftSlot(hwnd, newPath, [hwnd](bool success){
                             if (success) {
                                 g_osd.Show(hwnd, L"Renamed (Left)", false);
@@ -10611,15 +10505,15 @@ SKIP_EDGE_NAV:;
                 break;
             }
 
-            if (!g_imagePath.empty()) {
+            if (!GetPaneContext(PaneSlot::Primary).path.empty()) {
                 std::wstring currentFolder = L"";
                 std::wstring currentName = L"";
-                size_t lastSlash = g_imagePath.find_last_of(L"\\/");
+                size_t lastSlash = GetPaneContext(PaneSlot::Primary).path.find_last_of(L"\\/");
                 if (lastSlash != std::wstring::npos) {
-                    currentFolder = g_imagePath.substr(0, lastSlash + 1);
-                    currentName = g_imagePath.substr(lastSlash + 1);
+                    currentFolder = GetPaneContext(PaneSlot::Primary).path.substr(0, lastSlash + 1);
+                    currentName = GetPaneContext(PaneSlot::Primary).path.substr(lastSlash + 1);
                 } else {
-                    currentName = g_imagePath;
+                    currentName = GetPaneContext(PaneSlot::Primary).path;
                 }
                 
                 // Show Input Dialog
@@ -10644,21 +10538,21 @@ SKIP_EDGE_NAV:;
                     // Release resources before rename (Critical)
                     ReleaseImageResources();
                     
-                    if (MoveFileW(g_imagePath.c_str(), newPath.c_str())) {
-                        g_imagePath = newPath;
-                        g_navigator.Initialize(newPath, hwnd); // Update navigator list explicitly
+                    if (MoveFileW(GetPaneContext(PaneSlot::Primary).path.c_str(), newPath.c_str())) {
+                        GetPaneContext(PaneSlot::Primary).path = newPath;
+                        GetPaneContext(PaneSlot::Primary).navigator.Initialize(newPath, hwnd); // Update navigator list explicitly
                         
                         // Reload image from new path
-                        g_preservedViewState = g_viewState;
+                        g_preservedViewState = GetPaneContext(PaneSlot::Primary).view;
                         g_preserveViewStateOnNextLoad = true;
-                        LoadImageAsync(hwnd, g_navigator.GetResolvedPath(newPath).c_str()); 
+                        LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(newPath).c_str()); 
                         
                         g_osd.Show(hwnd, L"Renamed", false);
                     } else {
                         // Failed, reload original
-                        g_preservedViewState = g_viewState;
+                        g_preservedViewState = GetPaneContext(PaneSlot::Primary).view;
                         g_preserveViewStateOnNextLoad = true;
-                        LoadImageAsync(hwnd, g_imagePath); 
+                        LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).path); 
                         g_osd.Show(hwnd, L"Rename Failed", true);
                     }
                 }
@@ -10667,12 +10561,14 @@ SKIP_EDGE_NAV:;
             break;
         }
         case IDM_DELETE: {
-            if (IsCompareModeActive() && g_compare.contextPane == ComparePane::Left && !g_compare.left.path.empty()) {
-                std::wstring recycleTarget = g_compare.left.path;
+            if (IsCompareModeActive() && g_compare.contextPane == ComparePane::Left && !GetPaneContext(PaneSlot::Left).path.empty()) {
+                std::wstring recycleTarget = GetPaneContext(PaneSlot::Left).path;
                 size_t lastSlash = recycleTarget.find_last_of(L"\\/");
                 std::wstring filename = (lastSlash != std::wstring::npos) ? recycleTarget.substr(lastSlash + 1) : recycleTarget;
-                FileNavigator tempNav;
-                tempNav.Initialize(recycleTarget);
+                auto& leftNavigator = GetPaneContext(PaneSlot::Left).navigator;
+                if (leftNavigator.Count() <= 0 || leftNavigator.GetFile(leftNavigator.Index()) != recycleTarget) {
+                    leftNavigator.Initialize(recycleTarget);
+                }
 
                 bool confirmed = true;
                 if (g_config.ConfirmDelete) {
@@ -10700,8 +10596,8 @@ SKIP_EDGE_NAV:;
                     if (SHFileOperationW(&op) == 0) {
                         g_osd.Show(hwnd, AppStrings::OSD_MovedToRecycleBin, false);
 
-                        std::wstring nextPath = tempNav.PeekNext();
-                        if (nextPath == recycleTarget) nextPath = tempNav.PeekPrevious();
+                        std::wstring nextPath = leftNavigator.PeekNext();
+                        if (nextPath == recycleTarget) nextPath = leftNavigator.PeekPrevious();
 
                         if (!nextPath.empty()) {
                             LoadImageIntoCompareLeftSlot(hwnd, nextPath, [hwnd](bool success) {
@@ -10712,13 +10608,13 @@ SKIP_EDGE_NAV:;
                                     MarkCompareDirty();
                                     RequestRepaint(PaintLayer::Image | PaintLayer::Static | PaintLayer::Dynamic);
                                 } else {
-                                    g_compare.left.Reset();
+                                    GetPaneContext(PaneSlot::Left).Reset();
                                     ExitCompareMode(hwnd);
                                     RequestRepaint(PaintLayer::All);
                                 }
                             });
                         } else {
-                            g_compare.left.Reset();
+                            GetPaneContext(PaneSlot::Left).Reset();
                             ExitCompareMode(hwnd);
                             RequestRepaint(PaintLayer::All);
                         }
@@ -10729,14 +10625,14 @@ SKIP_EDGE_NAV:;
 
             // [v9.9 Fix] Handle Deletion during Edit/Transform
             // Determine actual target to recycle and temp file to map
-            std::wstring recycleTarget = g_imagePath;
+            std::wstring recycleTarget = GetPaneContext(PaneSlot::Primary).path;
             std::wstring tempToDelete = L"";
             
-            if (!g_editState.OriginalFilePath.empty()) {
+            if (!GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath.empty()) {
                 // We are in edit mode (Rotate/Flip), so target is the ORIGINAL file
-                recycleTarget = g_editState.OriginalFilePath;
+                recycleTarget = GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath;
                 // And we must cleanup the temp file too
-                tempToDelete = g_editState.TempFilePath;
+                tempToDelete = GetPaneContext(PaneSlot::Primary).editState.TempFilePath;
             }
 
             if (!recycleTarget.empty()) {
@@ -10766,8 +10662,8 @@ SKIP_EDGE_NAV:;
                 
                 if (confirmed) {
                     // Peek next using Navigator (which should still track the collection)
-                    std::wstring nextPath = g_navigator.PeekNext();
-                    if (nextPath == recycleTarget) nextPath = g_navigator.PeekPrevious();
+                    std::wstring nextPath = GetPaneContext(PaneSlot::Primary).navigator.PeekNext();
+                    if (nextPath == recycleTarget) nextPath = GetPaneContext(PaneSlot::Primary).navigator.PeekPrevious();
                     
                     // Release image before delete (Critical for file lock)
                     ReleaseImageResources();
@@ -10789,9 +10685,9 @@ SKIP_EDGE_NAV:;
                         }
 
                         RequestRepaint(PaintLayer::All);
-                        g_editState.Reset();
-                        g_viewState.Reset();
-                        g_imageResource.Reset();
+                        GetPaneContext(PaneSlot::Primary).editState.Reset();
+                        GetPaneContext(PaneSlot::Primary).view.Reset();
+                        GetPaneContext(PaneSlot::Primary).resource.Reset();
                         
                         // Re-init navigator if needed (though usually list is handled by next/prev logic, 
                         // strictly we might want to refresh list, but let's stick to PeekNext flow)
@@ -10803,14 +10699,14 @@ SKIP_EDGE_NAV:;
                              // Optimization: Just load nextPath. Initialize inside Navigate will handle it?
                              // NavigateTo doesn't init navigator. 
                              // Let's call Initialize(nextPath) to refresh list and set index.
-                             g_navigator.Initialize(nextPath, hwnd);
-                             LoadImageAsync(hwnd, g_navigator.GetResolvedPath(nextPath).c_str());
+                             GetPaneContext(PaneSlot::Primary).navigator.Initialize(nextPath, hwnd);
+                             LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).navigator.GetResolvedPath(nextPath).c_str());
                              if (IsCompareModeActive()) {
                                  MarkCompareDirty();
                              }
                         } else {
                              // Empty folder?
-                             g_navigator.Initialize(L"", hwnd);
+                             GetPaneContext(PaneSlot::Primary).navigator.Initialize(L"", hwnd);
                              if (IsCompareModeActive()) {
                                  ExitCompareMode(hwnd);
                              }
@@ -10834,8 +10730,8 @@ SKIP_EDGE_NAV:;
             // When turning on, set expanded state based on ToolbarInfoDefault config
             if (g_runtime.ShowInfoPanel) {
                 g_runtime.InfoPanelExpanded = (g_config.ToolbarInfoDefault == 1); // 0=Lite, 1=Full
-                if (g_currentMetadata.HistR.empty() && !g_imagePath.empty()) {
-                    UpdateHistogramAsync(hwnd, g_imagePath);
+                if (GetPaneContext(PaneSlot::Primary).metadata.HistR.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                    UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
                 }
             }
  
@@ -10908,8 +10804,8 @@ SKIP_EDGE_NAV:;
         case IDM_FULL_INFO:
              g_runtime.ShowInfoPanel = true;
              g_runtime.InfoPanelExpanded = true; // Full = expanded
-             if (g_currentMetadata.HistR.empty() && !g_imagePath.empty()) {
-                 UpdateHistogramAsync(hwnd, g_imagePath);
+             if (GetPaneContext(PaneSlot::Primary).metadata.HistR.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                 UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
              }
              g_toolbar.SetExifState(true);
              if (g_runtime.ShowInfoPanel) {
@@ -10934,7 +10830,7 @@ SKIP_EDGE_NAV:;
         case IDM_RENDER_RAW: {
              // [Fix] Toggle Force RAW Decode based on the selected pane's ACTUAL decode state.
              // This prevents "double click required" bugs when switching panes with mismatched states.
-             bool isFullDecode = contextLeft ? g_compare.left.metadata.IsRawFullDecode : g_currentMetadata.IsRawFullDecode;
+             bool isFullDecode = contextLeft ? GetPaneContext(PaneSlot::Left).metadata.IsRawFullDecode : GetPaneContext(PaneSlot::Primary).metadata.IsRawFullDecode;
              g_runtime.ForceRawDecode = !isFullDecode;
              g_toolbar.SetRawState(true, g_runtime.ForceRawDecode); // Update toolbar icon
              
@@ -10952,7 +10848,7 @@ SKIP_EDGE_NAV:;
                          g_imageEngine->UpdateConfig(g_runtime); // [Fix] Push config to engine
                          g_imageEngine->SetForceRefresh(true);
                      }
-                     g_preservedViewState = g_viewState;
+                     g_preservedViewState = GetPaneContext(PaneSlot::Primary).view;
                      g_preserveViewStateOnNextLoad = true;
                      ReleaseImageResources();
                      LoadImageAsync(hwnd, contextPath.c_str()); 
@@ -10972,8 +10868,8 @@ SKIP_EDGE_NAV:;
         case IDM_SORT_SIZE:
         case IDM_SORT_TYPE: {
             g_runtime.SortOrder = wmId - IDM_SORT_AUTO;
-            if (!g_imagePath.empty()) {
-                g_navigator.Initialize(g_imagePath, hwnd); // Re-initialize to re-sort
+            if (!GetPaneContext(PaneSlot::Primary).path.empty()) {
+                GetPaneContext(PaneSlot::Primary).navigator.Initialize(GetPaneContext(PaneSlot::Primary).path, hwnd); // Re-initialize to re-sort
             }
             break;
         }
@@ -10981,8 +10877,8 @@ SKIP_EDGE_NAV:;
         case IDM_SORT_ASCENDING:
         case IDM_SORT_DESCENDING: {
             g_runtime.SortDescending = (wmId == IDM_SORT_DESCENDING);
-            if (!g_imagePath.empty()) {
-                g_navigator.Initialize(g_imagePath, hwnd); // Re-initialize to re-sort
+            if (!GetPaneContext(PaneSlot::Primary).path.empty()) {
+                GetPaneContext(PaneSlot::Primary).navigator.Initialize(GetPaneContext(PaneSlot::Primary).path, hwnd); // Re-initialize to re-sort
             }
             break;
         }
@@ -11011,7 +10907,7 @@ SKIP_EDGE_NAV:;
         case IDM_CMS_PROPHOTO: {
              int newMode = (int)cmdId - (int)IDM_CMS_UNMANAGED;
              if (contextLeft) {
-                 g_compare.left.CmsModeOverride = newMode;
+                 GetPaneContext(PaneSlot::Left).CmsModeOverride = newMode;
              } else {
                  g_runtime.CmsModeOverride = newMode;
              }
@@ -11036,8 +10932,8 @@ SKIP_EDGE_NAV:;
         }
 
         case IDM_SOFT_PROOF_TOGGLE: {
-             std::wstring& currentProfile = contextLeft ? g_compare.left.SoftProofProfilePath : g_runtime.SoftProofProfilePath;
-             bool& currentEnable = contextLeft ? g_compare.left.EnableSoftProofing : g_runtime.EnableSoftProofing;
+             std::wstring& currentProfile = contextLeft ? GetPaneContext(PaneSlot::Left).SoftProofProfilePath : g_runtime.SoftProofProfilePath;
+             bool& currentEnable = contextLeft ? GetPaneContext(PaneSlot::Left).EnableSoftProofing : g_runtime.EnableSoftProofing;
 
              if (currentProfile.empty() && !g_config.CustomSoftProofProfile.empty()) {
                  currentProfile = g_config.CustomSoftProofProfile;
@@ -11054,8 +10950,8 @@ SKIP_EDGE_NAV:;
         }
         case IDM_SOFT_PROOF_CUSTOM: {
              if (contextLeft) {
-                 g_compare.left.SoftProofProfilePath = g_config.CustomSoftProofProfile;
-                 g_compare.left.EnableSoftProofing = true;
+                 GetPaneContext(PaneSlot::Left).SoftProofProfilePath = g_config.CustomSoftProofProfile;
+                 GetPaneContext(PaneSlot::Left).EnableSoftProofing = true;
              } else {
                  g_runtime.SoftProofProfilePath = g_config.CustomSoftProofProfile;
                  g_runtime.EnableSoftProofing = true;
@@ -11079,8 +10975,8 @@ SKIP_EDGE_NAV:;
              }
 
              // Update interpolation immediately by redrawing the surface
-             if (g_imageResource) {
-                 RenderImageToDComp(hwnd, g_imageResource, true);
+             if (GetPaneContext(PaneSlot::Primary).resource) {
+                 RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
                  if (g_compEngine && g_compEngine->IsInitialized()) {
                      RECT rc; GetClientRect(hwnd, &rc);
                      SyncDCompState(hwnd, (float)rc.right, (float)rc.bottom);
@@ -11157,15 +11053,15 @@ SKIP_EDGE_NAV:;
                         } else {
                             ReleaseImageResources();
                             if (MoveFileW(contextPath.c_str(), newPath.c_str())) {
-                                g_imagePath = newPath;
-                                g_preservedViewState = g_viewState;
+                                GetPaneContext(PaneSlot::Primary).path = newPath;
+                                g_preservedViewState = GetPaneContext(PaneSlot::Primary).view;
                                 g_preserveViewStateOnNextLoad = true;
                                 LoadImageAsync(hwnd, newPath);
                                 g_osd.Show(hwnd, L"Extension Fixed", false);
                             } else {
-                                g_preservedViewState = g_viewState;
+                                g_preservedViewState = GetPaneContext(PaneSlot::Primary).view;
                                 g_preserveViewStateOnNextLoad = true;
-                                LoadImageAsync(hwnd, g_imagePath); // Reload old
+                                LoadImageAsync(hwnd, GetPaneContext(PaneSlot::Primary).path); // Reload old
                                 g_osd.Show(hwnd, std::wstring(L"Rename Failed"), true);
                             }
                         }
@@ -11216,7 +11112,7 @@ void OnResize(HWND hwnd, UINT width, UINT height) {
         
         // [SVG Sync] Trigger lazy re-render after window resize settles.
         // During active resize, SyncDCompState handles smooth pixel scaling.
-        if (g_imageResource.isSvg && UseSvgViewportRendering(g_imageResource)) {
+        if (GetPaneContext(PaneSlot::Primary).resource.isSvg && UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource)) {
             SetTimer(hwnd, IDT_SVG_RERENDER, 100, nullptr);
         }
     }
@@ -11250,19 +11146,19 @@ static void HandleExifPreRotation(const EngineEvent& evt) {
     if (isFrameSwapped) {
         // Neutralize: Bitmap is already Visual. Treat as Orient=1.
         // Update Globals directly (evt.metadata is const)
-        g_currentMetadata.ExifOrientation = 1;
-        g_viewState.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1;
     }
 }
 
 static void RestoreCurrentExifOrientation() {
     if (!g_config.AutoRotate) {
-        g_viewState.ExifOrientation = 1;
+        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1;
         return;
     }
-    int exif = g_currentMetadata.ExifOrientation;
+    int exif = GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation;
     if (exif >= 1 && exif <= 8) {
-        g_viewState.ExifOrientation = exif;
+        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = exif;
     }
 }
 
@@ -11278,6 +11174,86 @@ void ProcessEngineEvents(HWND hwnd) {
         case EventType::FullReady: {
             if (!g_renderEngine) break;
             
+            // ============================================================
+            // [Pane Architecture] Route event to correct PaneContext
+            // ============================================================
+            const PaneSlot targetSlot = evt.targetSlot;
+            auto& pane = GetPaneContext(targetSlot);
+            
+            // [generationId] Stale event filter 鈥?discard if pane has moved on
+            if (evt.generationId != 0 && evt.generationId != pane.generationId) {
+                break;
+            }
+            
+            // === LEFT PANE: Lean handler (upload bitmap, store metadata, done) ===
+            if (targetSlot == PaneSlot::Left) {
+                if (!evt.rawFrame || !evt.rawFrame->IsValid() || evt.rawFrame->IsSvg()) break;
+                
+                ComPtr<ID2D1Bitmap> leftBitmap;
+                QuickView::DisplayColorState uploadState = {};
+                const bool hasPaneDisplayState =
+                    IsCompareModeActive() &&
+                    GetDisplayColorStateForPane(hwnd, ComparePane::Left, &uploadState);
+                const QuickView::DisplayColorState restoreState =
+                    g_compEngine ? g_compEngine->GetDisplayColorState() : g_renderEngine->GetDisplayColorState();
+                if (hasPaneDisplayState) {
+                    g_renderEngine->SetDisplayColorState(uploadState);
+                }
+                HRESULT hr = g_renderEngine->UploadRawFrameToGPU(*evt.rawFrame, &leftBitmap);
+                if (hasPaneDisplayState) {
+                    g_renderEngine->SetDisplayColorState(restoreState);
+                }
+                if (FAILED(hr) || !leftBitmap) break;
+                
+                pane.resource.Reset();
+                pane.resource.bitmap = leftBitmap;
+                pane.path = evt.filePath;
+                pane.valid = true;
+                pane.view = {};
+                
+                // Metadata
+                pane.metadata = evt.metadata;
+                D2D1_SIZE_U pixel = leftBitmap->GetPixelSize();
+                if (pane.metadata.Width == 0 || pane.metadata.Height == 0) {
+                    pane.metadata.Width = pixel.width;
+                    pane.metadata.Height = pixel.height;
+                }
+                int frameExif = evt.rawFrame->exifOrientation;
+                if (frameExif < 1 || frameExif > 8) frameExif = 1;
+                pane.metadata.ExifOrientation = frameExif;
+                pane.view.ExifOrientation = g_config.AutoRotate ? frameExif : 1;
+                
+                // AuxLayer from frame
+                if (evt.rawFrame->auxLayer) {
+                    pane.resource.blendOp = evt.rawFrame->blendOp;
+                    pane.resource.shaderPayload = evt.rawFrame->shaderPayload;
+                    pane.resource.auxLayer = evt.rawFrame->auxLayer->Clone();
+                }
+                
+                pane.CmsModeOverride = g_runtime.CmsModeOverride;
+                pane.EnableSoftProofing = g_runtime.EnableSoftProofing;
+                pane.SoftProofProfilePath = g_runtime.SoftProofProfilePath;
+                
+                g_isLeftPaneDecoding = false;
+                
+                // Fire pending callback if one exists
+                if (g_leftPaneReadyCallback) {
+                    auto cb = std::move(g_leftPaneReadyCallback);
+                    g_leftPaneReadyCallback = nullptr;
+                    cb(true);
+                }
+                
+                if (g_runtime.ShowCompareInfo && (pane.metadata.HistL.empty() || !pane.metadata.IsFullMetadataLoaded)) {
+                    UpdateCompareLeftHistogramAsync(hwnd, pane.path);
+                }
+                RefreshCompareRawUI(hwnd);
+                
+                MarkCompareDirty();
+                needsRepaint = true;
+                break;
+            }
+            
+            // === PRIMARY PANE: Full handler (existing logic) ===
             // [ImageID] Validate using stable path hash
             ImageID currentId = g_currentImageId.load();
             if (evt.imageId != currentId) {
@@ -11308,10 +11284,10 @@ void ProcessEngineEvents(HWND hwnd) {
             if (evt.rawFrame && evt.rawFrame->IsValid()) {
                 if (evt.rawFrame->IsSvg()) {
                      // === SVG Path ===
-                     g_imageResource.Reset();
-                     g_imageResource.isSvg = true;
-                     g_imageResource.svgW = evt.rawFrame->svg->viewBoxW;
-                     g_imageResource.svgH = evt.rawFrame->svg->viewBoxH;
+                     GetPaneContext(PaneSlot::Primary).resource.Reset();
+                     GetPaneContext(PaneSlot::Primary).resource.isSvg = true;
+                     GetPaneContext(PaneSlot::Primary).resource.svgW = evt.rawFrame->svg->viewBoxW;
+                     GetPaneContext(PaneSlot::Primary).resource.svgH = evt.rawFrame->svg->viewBoxH;
                      
                      // Get D2D Context (from RenderEngine)
                      ComPtr<ID2D1DeviceContext> ctxBase = g_renderEngine->GetDeviceContext();
@@ -11333,11 +11309,11 @@ void ProcessEngineEvents(HWND hwnd) {
                          }
                          
                          if (stream) {
-                             D2D1_SIZE_F vpSize = { g_imageResource.svgW, g_imageResource.svgH };
+                             D2D1_SIZE_F vpSize = { GetPaneContext(PaneSlot::Primary).resource.svgW, GetPaneContext(PaneSlot::Primary).resource.svgH };
                              if (vpSize.width <= 0) vpSize.width = 100;
                              if (vpSize.height <= 0) vpSize.height = 100;
                              
-                             hr = ctx5->CreateSvgDocument(stream.Get(), vpSize, &g_imageResource.svgDoc);
+                             hr = ctx5->CreateSvgDocument(stream.Get(), vpSize, &GetPaneContext(PaneSlot::Primary).resource.svgDoc);
                          } else hr = E_OUTOFMEMORY;
                      } else hr = E_NOINTERFACE;
                      
@@ -11366,21 +11342,21 @@ void ProcessEngineEvents(HWND hwnd) {
                     } else {
                          g_debugMetrics.rawFrameUploadCount++;
                          g_debugMetrics.lastUploadChannel.store(1);
-                         g_imageResource.Reset();
-                         g_imageResource.bitmap = bitmap;
+                         GetPaneContext(PaneSlot::Primary).resource.Reset();
+                         GetPaneContext(PaneSlot::Primary).resource.bitmap = bitmap;
                          g_isImageDirty = false; // [v10.3.1] Force refresh consumed, preventing redundant OnPaint cycle
                          
                          // [v10.3.1] Restore AuxLayer from frame if present
                          if (evt.rawFrame && evt.rawFrame->auxLayer) {
-                             g_imageResource.blendOp = evt.rawFrame->blendOp;
-                             g_imageResource.shaderPayload = evt.rawFrame->shaderPayload;
-                             g_imageResource.auxLayer = evt.rawFrame->auxLayer->Clone();
+                             GetPaneContext(PaneSlot::Primary).resource.blendOp = evt.rawFrame->blendOp;
+                             GetPaneContext(PaneSlot::Primary).resource.shaderPayload = evt.rawFrame->shaderPayload;
+                             GetPaneContext(PaneSlot::Primary).resource.auxLayer = evt.rawFrame->auxLayer->Clone();
                          }
                          
                          // [v10.5] Animation State
                          if (evt.rawFrame) {
-                             g_imageResource.animator = evt.rawFrame->animator;
-                             g_imageResource.frameMeta = evt.rawFrame->frameMeta;
+                             GetPaneContext(PaneSlot::Primary).resource.animator = evt.rawFrame->animator;
+                             GetPaneContext(PaneSlot::Primary).resource.frameMeta = evt.rawFrame->frameMeta;
                          }
 
                          resourceReady = true;
@@ -11390,11 +11366,11 @@ void ProcessEngineEvents(HWND hwnd) {
             
             if (resourceReady) {
                 // Apply State
-                // g_imageResource is already populated
+                // GetPaneContext(PaneSlot::Primary).resource is already populated
 
                 g_isBlurry = isPreview;
                 g_imageQualityLevel = isPreview ? 1 : 2;
-                g_imagePath = evt.filePath;
+                GetPaneContext(PaneSlot::Primary).path = evt.filePath;
                 
                 // Metadata
                 // [v5.4 Fix] Race Condition: Prevent FullReady (Basic) from overwriting Async EXIF
@@ -11410,14 +11386,14 @@ void ProcessEngineEvents(HWND hwnd) {
                 }
                 
                 // [Fix] For SVG frames, explicitly set Format and dimensions
-                if (g_imageResource.isSvg) {
+                if (GetPaneContext(PaneSlot::Primary).resource.isSvg) {
                     finalMetadata.Format = L"SVG";
-                    finalMetadata.Width = (UINT)g_imageResource.svgW;
-                    finalMetadata.Height = (UINT)g_imageResource.svgH;
-                } else if (g_imageResource.bitmap) {
+                    finalMetadata.Width = (UINT)GetPaneContext(PaneSlot::Primary).resource.svgW;
+                    finalMetadata.Height = (UINT)GetPaneContext(PaneSlot::Primary).resource.svgH;
+                } else if (GetPaneContext(PaneSlot::Primary).resource.bitmap) {
                     // [Fix] Robust Dimensions: If Metadata is missing or partial (e.g. 100x0), use actual Bitmap size
                     // This ensures Info Panel always matches what user sees.
-                    D2D1_SIZE_U pixelSize = g_imageResource.bitmap->GetPixelSize();
+                    D2D1_SIZE_U pixelSize = GetPaneContext(PaneSlot::Primary).resource.bitmap->GetPixelSize();
                     if (finalMetadata.Width == 0 || finalMetadata.Height == 0) {
                         finalMetadata.Width = pixelSize.width;
                         finalMetadata.Height = pixelSize.height;
@@ -11434,85 +11410,85 @@ void ProcessEngineEvents(HWND hwnd) {
                 // [Phase 6 Fix] Fake Base Protection: Do not let 1x1 or 4x4 fake Titan bases overwrite global metadata.
                 // [SVG Fix] SVG has no scaled/full upgrade, so always accept SVG dimensions.
                 {
-                    bool acceptDimUpdate = (finalMetadata.Width >= g_currentMetadata.Width && finalMetadata.Width > 16);
-                    if (g_imageResource.isSvg && finalMetadata.Width > 0) acceptDimUpdate = true;
+                    bool acceptDimUpdate = (finalMetadata.Width >= GetPaneContext(PaneSlot::Primary).metadata.Width && finalMetadata.Width > 16);
+                    if (GetPaneContext(PaneSlot::Primary).resource.isSvg && finalMetadata.Width > 0) acceptDimUpdate = true;
                     if (acceptDimUpdate) {
-                        g_currentMetadata.Width = finalMetadata.Width;
-                        g_currentMetadata.Height = finalMetadata.Height;
+                        GetPaneContext(PaneSlot::Primary).metadata.Width = finalMetadata.Width;
+                        GetPaneContext(PaneSlot::Primary).metadata.Height = finalMetadata.Height;
                     }
                 }
                 
                 // 2. File Stats: Always trust non-zero (Source fix ensures Async has it, but safety first)
-                if (finalMetadata.FileSize == 0 && g_currentMetadata.FileSize > 0) {
-                    finalMetadata.FileSize = g_currentMetadata.FileSize;
+                if (finalMetadata.FileSize == 0 && GetPaneContext(PaneSlot::Primary).metadata.FileSize > 0) {
+                    finalMetadata.FileSize = GetPaneContext(PaneSlot::Primary).metadata.FileSize;
                 }
                 if ((finalMetadata.CreationTime.dwLowDateTime == 0 && finalMetadata.CreationTime.dwHighDateTime == 0) &&
-                    (g_currentMetadata.CreationTime.dwLowDateTime != 0 || g_currentMetadata.CreationTime.dwHighDateTime != 0)) {
-                    finalMetadata.CreationTime = g_currentMetadata.CreationTime;
+                    (GetPaneContext(PaneSlot::Primary).metadata.CreationTime.dwLowDateTime != 0 || GetPaneContext(PaneSlot::Primary).metadata.CreationTime.dwHighDateTime != 0)) {
+                    finalMetadata.CreationTime = GetPaneContext(PaneSlot::Primary).metadata.CreationTime;
                 }
                 // (Repeat for LastWriteTime if needed, mainly Creation is used)
                 
                 // 3. Color Space: Trust Decoder (EasyExif/Native) if Async (WIC) misses it
                 // BUT: Async might have found it via deeper WIC search.
                 // Logic: If Async has it, use it. If Async is empty, keep HeavyLane.
-                if (finalMetadata.ColorSpace.empty() && !g_currentMetadata.ColorSpace.empty()) {
-                    finalMetadata.ColorSpace = g_currentMetadata.ColorSpace;
+                if (finalMetadata.ColorSpace.empty() && !GetPaneContext(PaneSlot::Primary).metadata.ColorSpace.empty()) {
+                    finalMetadata.ColorSpace = GetPaneContext(PaneSlot::Primary).metadata.ColorSpace;
                 }
                 
                 // 4. Format: Critical for ROI detection. Preserve if HeavyLane didn't set it.
-                if (finalMetadata.Format.empty() && !g_currentMetadata.Format.empty()) {
-                    finalMetadata.Format = g_currentMetadata.Format;
+                if (finalMetadata.Format.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Format.empty()) {
+                    finalMetadata.Format = GetPaneContext(PaneSlot::Primary).metadata.Format;
                 }
                 
                 // 5. Format Details: HeavyLane often has specific codec info (e.g. "Q=95")
                 // Async might be generic.
-                if (finalMetadata.FormatDetails.empty() && !g_currentMetadata.FormatDetails.empty()) {
-                    finalMetadata.FormatDetails = g_currentMetadata.FormatDetails;
+                if (finalMetadata.FormatDetails.empty() && !GetPaneContext(PaneSlot::Primary).metadata.FormatDetails.empty()) {
+                    finalMetadata.FormatDetails = GetPaneContext(PaneSlot::Primary).metadata.FormatDetails;
                 }
                 
                 // 5. GPS: Async usually has better GPS (WIC). Keep Async unless empty?
                 // Actually HeavyLane doesn't parse GPS (yet), so Async is primary.
                 // But just in case:
-                if (!finalMetadata.HasGPS && g_currentMetadata.HasGPS) {
+                if (!finalMetadata.HasGPS && GetPaneContext(PaneSlot::Primary).metadata.HasGPS) {
                      finalMetadata.HasGPS = true;
-                     finalMetadata.Latitude = g_currentMetadata.Latitude;
-                     finalMetadata.Longitude = g_currentMetadata.Longitude;
-                     finalMetadata.Altitude = g_currentMetadata.Altitude;
+                     finalMetadata.Latitude = GetPaneContext(PaneSlot::Primary).metadata.Latitude;
+                     finalMetadata.Longitude = GetPaneContext(PaneSlot::Primary).metadata.Longitude;
+                     finalMetadata.Altitude = GetPaneContext(PaneSlot::Primary).metadata.Altitude;
                 }
 
                 // 6. Camera Info (Universal Protection)
-                if (finalMetadata.Make.empty() && !g_currentMetadata.Make.empty()) finalMetadata.Make = g_currentMetadata.Make;
-                if (finalMetadata.Model.empty() && !g_currentMetadata.Model.empty()) finalMetadata.Model = g_currentMetadata.Model;
-                if (finalMetadata.Lens.empty() && !g_currentMetadata.Lens.empty()) finalMetadata.Lens = g_currentMetadata.Lens;
-                if (finalMetadata.Software.empty() && !g_currentMetadata.Software.empty()) finalMetadata.Software = g_currentMetadata.Software;
-                if (finalMetadata.Date.empty() && !g_currentMetadata.Date.empty()) finalMetadata.Date = g_currentMetadata.Date;
+                if (finalMetadata.Make.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Make.empty()) finalMetadata.Make = GetPaneContext(PaneSlot::Primary).metadata.Make;
+                if (finalMetadata.Model.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Model.empty()) finalMetadata.Model = GetPaneContext(PaneSlot::Primary).metadata.Model;
+                if (finalMetadata.Lens.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Lens.empty()) finalMetadata.Lens = GetPaneContext(PaneSlot::Primary).metadata.Lens;
+                if (finalMetadata.Software.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Software.empty()) finalMetadata.Software = GetPaneContext(PaneSlot::Primary).metadata.Software;
+                if (finalMetadata.Date.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Date.empty()) finalMetadata.Date = GetPaneContext(PaneSlot::Primary).metadata.Date;
                 
                 // 7. Exposure Info
-                if (finalMetadata.ISO.empty() && !g_currentMetadata.ISO.empty()) finalMetadata.ISO = g_currentMetadata.ISO;
-                if (finalMetadata.Aperture.empty() && !g_currentMetadata.Aperture.empty()) finalMetadata.Aperture = g_currentMetadata.Aperture;
-                if (finalMetadata.Shutter.empty() && !g_currentMetadata.Shutter.empty()) finalMetadata.Shutter = g_currentMetadata.Shutter;
-                if (finalMetadata.Focal.empty() && !g_currentMetadata.Focal.empty()) finalMetadata.Focal = g_currentMetadata.Focal;
-                if (finalMetadata.Focal35mm.empty() && !g_currentMetadata.Focal35mm.empty()) finalMetadata.Focal35mm = g_currentMetadata.Focal35mm;
-                if (finalMetadata.ExposureBias.empty() && !g_currentMetadata.ExposureBias.empty()) finalMetadata.ExposureBias = g_currentMetadata.ExposureBias;
-                if (finalMetadata.Flash.empty() && !g_currentMetadata.Flash.empty()) finalMetadata.Flash = g_currentMetadata.Flash;
-                if (finalMetadata.MeteringMode.empty() && !g_currentMetadata.MeteringMode.empty()) finalMetadata.MeteringMode = g_currentMetadata.MeteringMode;
-                if (finalMetadata.ExposureProgram.empty() && !g_currentMetadata.ExposureProgram.empty()) finalMetadata.ExposureProgram = g_currentMetadata.ExposureProgram;
-                if (finalMetadata.WhiteBalance.empty() && !g_currentMetadata.WhiteBalance.empty()) finalMetadata.WhiteBalance = g_currentMetadata.WhiteBalance;
+                if (finalMetadata.ISO.empty() && !GetPaneContext(PaneSlot::Primary).metadata.ISO.empty()) finalMetadata.ISO = GetPaneContext(PaneSlot::Primary).metadata.ISO;
+                if (finalMetadata.Aperture.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Aperture.empty()) finalMetadata.Aperture = GetPaneContext(PaneSlot::Primary).metadata.Aperture;
+                if (finalMetadata.Shutter.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Shutter.empty()) finalMetadata.Shutter = GetPaneContext(PaneSlot::Primary).metadata.Shutter;
+                if (finalMetadata.Focal.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Focal.empty()) finalMetadata.Focal = GetPaneContext(PaneSlot::Primary).metadata.Focal;
+                if (finalMetadata.Focal35mm.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Focal35mm.empty()) finalMetadata.Focal35mm = GetPaneContext(PaneSlot::Primary).metadata.Focal35mm;
+                if (finalMetadata.ExposureBias.empty() && !GetPaneContext(PaneSlot::Primary).metadata.ExposureBias.empty()) finalMetadata.ExposureBias = GetPaneContext(PaneSlot::Primary).metadata.ExposureBias;
+                if (finalMetadata.Flash.empty() && !GetPaneContext(PaneSlot::Primary).metadata.Flash.empty()) finalMetadata.Flash = GetPaneContext(PaneSlot::Primary).metadata.Flash;
+                if (finalMetadata.MeteringMode.empty() && !GetPaneContext(PaneSlot::Primary).metadata.MeteringMode.empty()) finalMetadata.MeteringMode = GetPaneContext(PaneSlot::Primary).metadata.MeteringMode;
+                if (finalMetadata.ExposureProgram.empty() && !GetPaneContext(PaneSlot::Primary).metadata.ExposureProgram.empty()) finalMetadata.ExposureProgram = GetPaneContext(PaneSlot::Primary).metadata.ExposureProgram;
+                if (finalMetadata.WhiteBalance.empty() && !GetPaneContext(PaneSlot::Primary).metadata.WhiteBalance.empty()) finalMetadata.WhiteBalance = GetPaneContext(PaneSlot::Primary).metadata.WhiteBalance;
                 
                 // [Phase 18 Fix] Preserve Embedded Profile Flag
-                if (!finalMetadata.HasEmbeddedColorProfile && g_currentMetadata.HasEmbeddedColorProfile) {
+                if (!finalMetadata.HasEmbeddedColorProfile && GetPaneContext(PaneSlot::Primary).metadata.HasEmbeddedColorProfile) {
                     finalMetadata.HasEmbeddedColorProfile = true;
                 }
 
                 // 8. HDR / Pixel Workspace: preserve decoder-provided high-value metadata
                 if (finalMetadata.colorInfo.dataSpace == QuickView::PixelDataSpace::Unknown &&
-                    g_currentMetadata.colorInfo.dataSpace != QuickView::PixelDataSpace::Unknown) {
-                    finalMetadata.colorInfo = g_currentMetadata.colorInfo;
+                    GetPaneContext(PaneSlot::Primary).metadata.colorInfo.dataSpace != QuickView::PixelDataSpace::Unknown) {
+                    finalMetadata.colorInfo = GetPaneContext(PaneSlot::Primary).metadata.colorInfo;
                 }
                 if (!finalMetadata.hdrMetadata.isValid &&
                     !finalMetadata.hdrMetadata.hasGainMap &&
-                    (g_currentMetadata.hdrMetadata.isValid || g_currentMetadata.hdrMetadata.hasGainMap)) {
-                    finalMetadata.hdrMetadata = g_currentMetadata.hdrMetadata;
+                    (GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata.isValid || GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata.hasGainMap)) {
+                    finalMetadata.hdrMetadata = GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata;
                 }
                 
                  // [v5.3 Fix] Do NOT force true here.
@@ -11520,7 +11496,7 @@ void ProcessEngineEvents(HWND hwnd) {
                  // finalMetadata.IsFullMetadataLoaded = true;
 
                 // Metadata - Full Copy (Propagate EXIF/Histograms/LoaderName)
-                g_currentMetadata = finalMetadata;
+                GetPaneContext(PaneSlot::Primary).metadata = finalMetadata;
                 g_runtime.ShowHdrDetailsExpanded = false;
                 if (evt.rawFrame && evt.rawFrame->IsValid()) {
                     {
@@ -11564,7 +11540,7 @@ void ProcessEngineEvents(HWND hwnd) {
                         if (GetMonitorInfo(hMon, &mi)) {
                             int monWidth = mi.rcMonitor.right - mi.rcMonitor.left;
                             int monHeight = mi.rcMonitor.bottom - mi.rcMonitor.top;
-                            if (g_currentMetadata.Width > (UINT)monWidth || g_currentMetadata.Height > (UINT)monHeight) {
+                            if (GetPaneContext(PaneSlot::Primary).metadata.Width > (UINT)monWidth || GetPaneContext(PaneSlot::Primary).metadata.Height > (UINT)monHeight) {
                                 shouldFullscreen = true;
                             }
                         }
@@ -11580,14 +11556,14 @@ void ProcessEngineEvents(HWND hwnd) {
                 // Force one Titan scheduling pass after content swap.
                 // This prevents "same size, same zoom" switches from skipping
                 // initial tile dispatch under Phase2 queue-drop flow.
-                if (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192) {
+                if (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192) {
                     g_forceTitanTileReseed.store(true, std::memory_order_release);
                 }
                 
                 // [v9.9] Extension Mismatch Detection for Toolbar Button
                 // Uses Format field (e.g., "JPEG", "PNG") to detect if file extension is incorrect
-                if (!g_currentMetadata.Format.empty()) {
-                    bool mismatch = CheckExtensionMismatch(g_imagePath, g_currentMetadata.Format);
+                if (!GetPaneContext(PaneSlot::Primary).metadata.Format.empty()) {
+                    bool mismatch = CheckExtensionMismatch(GetPaneContext(PaneSlot::Primary).path, GetPaneContext(PaneSlot::Primary).metadata.Format);
                     g_toolbar.SetExtensionWarning(mismatch);
                 } else {
                     g_toolbar.SetExtensionWarning(false);
@@ -11602,9 +11578,9 @@ void ProcessEngineEvents(HWND hwnd) {
                      // Trust the metadata.
                      // User confirms dedicated decoder (TurboJPEG) is used, which does NOT auto-rotate.
                      // Therefore we must apply the Exif rotation.
-                     g_viewState.ExifOrientation = evt.metadata.ExifOrientation;
+                     GetPaneContext(PaneSlot::Primary).view.ExifOrientation = evt.metadata.ExifOrientation;
                 } else {
-                    g_viewState.ExifOrientation = 1; // Ignore rotation
+                    GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1; // Ignore rotation
                 }
                 
                 // JXL Logic (Trigger Heavy if Preview)
@@ -11614,7 +11590,7 @@ void ProcessEngineEvents(HWND hwnd) {
                 
                 // [Detect Pre-Rotation]
                 HandleExifPreRotation(evt);
-                g_renderExifOrientation = g_viewState.ExifOrientation;
+                g_renderExifOrientation = GetPaneContext(PaneSlot::Primary).view.ExifOrientation;
 
                 // UI Text Logic
                 wchar_t titleBuf[2048];
@@ -11631,7 +11607,7 @@ void ProcessEngineEvents(HWND hwnd) {
                 }
                 SetWindowTextW(hwnd, titleBuf);
                 
-                if (IsCompareModeActive() && (g_currentMetadata.Width > 8192 || g_currentMetadata.Height > 8192)) {
+                if (IsCompareModeActive() && (GetPaneContext(PaneSlot::Primary).metadata.Width > 8192 || GetPaneContext(PaneSlot::Primary).metadata.Height > 8192)) {
                     ExitCompareMode(hwnd);
                     g_osd.Show(hwnd, L"Compare mode exited: Titan image is not supported yet.", true);
                 }
@@ -11645,14 +11621,14 @@ void ProcessEngineEvents(HWND hwnd) {
                     }
                 } else {
                     // Update DComp Visual (Base Preview for Titan, or full image for standard)
-                    RenderImageToDComp(hwnd, g_imageResource, false);
+                    RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, false);
                     
                     // [Optimization] GPU-Assistant Surface Rotation Complete
                     // The Surface is now physically rotated. Neutralize global Exif.
                     // This ensures AdjustWindowToImage sees "Orientation 1" and uses the already-swapped Surface dimensions.
-                    if (g_viewState.ExifOrientation > 1 && g_config.AutoRotate) {
-                        g_currentMetadata.ExifOrientation = 1;
-                        g_viewState.ExifOrientation = 1;
+                    if (GetPaneContext(PaneSlot::Primary).view.ExifOrientation > 1 && g_config.AutoRotate) {
+                        GetPaneContext(PaneSlot::Primary).metadata.ExifOrientation = 1;
+                        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = 1;
                     }
                     
                     // [Strategy] Visual Continuity for Soft-Refresh (e.g. Color Space/RAW Switch)
@@ -11661,12 +11637,12 @@ void ProcessEngineEvents(HWND hwnd) {
                     // size and trigger a 'Fit' zoom, which is counter-productive here.
                     if (g_preserveViewStateOnNextLoad) {
                         // Restore exact zoom and pan values before SyncDCompState() calculates the final matrix
-                        g_viewState.Zoom = g_preservedViewState.Zoom;
-                        g_viewState.PanX = g_preservedViewState.PanX;
-                        g_viewState.PanY = g_preservedViewState.PanY;
+                        GetPaneContext(PaneSlot::Primary).view.Zoom = g_preservedViewState.Zoom;
+                        GetPaneContext(PaneSlot::Primary).view.PanX = g_preservedViewState.PanX;
+                        GetPaneContext(PaneSlot::Primary).view.PanY = g_preservedViewState.PanY;
                         
                         // [Fix] Ensure any other interaction flags that might have been reset are also restored
-                        g_viewState.ExifOrientation = g_preservedViewState.ExifOrientation;
+                        GetPaneContext(PaneSlot::Primary).view.ExifOrientation = g_preservedViewState.ExifOrientation;
 
                         g_preserveViewStateOnNextLoad = false; // One-time consume
                     } else {
@@ -11706,9 +11682,9 @@ void ProcessEngineEvents(HWND hwnd) {
                 KillTimer(hwnd, 995); // Stop UI heartbeat timer
                 
                 // [v10.5] Start Animation Timer
-                if (!isPreview && g_imageResource.animator) {
+                if (!isPreview && GetPaneContext(PaneSlot::Primary).resource.animator) {
                     g_animPlaying = true;
-                    uint32_t delayMs = g_imageResource.frameMeta.delayMs;
+                    uint32_t delayMs = GetPaneContext(PaneSlot::Primary).resource.frameMeta.delayMs;
                     if (delayMs < 10) delayMs = 100;
                     SetTimer(hwnd, IDT_ANIMATION, delayMs, NULL);
                 } else if (!isPreview) {
@@ -11723,8 +11699,8 @@ void ProcessEngineEvents(HWND hwnd) {
 
                 // [HUD & Info Panel] Trigger metrics calculation if visible
                 if (!isPreview && (g_runtime.ShowCompareInfo || (g_runtime.ShowInfoPanel && g_runtime.InfoPanelExpanded))) {
-                    if (g_currentMetadata.HistL.empty() && !g_imagePath.empty()) {
-                        UpdateHistogramAsync(hwnd, g_imagePath);
+                    if (GetPaneContext(PaneSlot::Primary).metadata.HistL.empty() && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                        UpdateHistogramAsync(hwnd, GetPaneContext(PaneSlot::Primary).path);
                     }
                 }
 
@@ -11741,56 +11717,56 @@ void ProcessEngineEvents(HWND hwnd) {
             // [v5.3] Async Aux Metadata handling (Split Strategy)
             if (evt.imageId == g_currentImageId.load()) {
                  // Merge logic: Only overwrite fields that are present in aux data
-                 if (!evt.metadata.Date.empty()) g_currentMetadata.Date = evt.metadata.Date;
+                 if (!evt.metadata.Date.empty()) GetPaneContext(PaneSlot::Primary).metadata.Date = evt.metadata.Date;
                  // [Fix] Copy Make!
-                 if (!evt.metadata.Make.empty()) g_currentMetadata.Make = evt.metadata.Make;
-                 if (!evt.metadata.Model.empty()) g_currentMetadata.Model = evt.metadata.Model;
-                 if (!evt.metadata.Lens.empty()) g_currentMetadata.Lens = evt.metadata.Lens;
+                 if (!evt.metadata.Make.empty()) GetPaneContext(PaneSlot::Primary).metadata.Make = evt.metadata.Make;
+                 if (!evt.metadata.Model.empty()) GetPaneContext(PaneSlot::Primary).metadata.Model = evt.metadata.Model;
+                 if (!evt.metadata.Lens.empty()) GetPaneContext(PaneSlot::Primary).metadata.Lens = evt.metadata.Lens;
                  
 
                  
-                 if (!evt.metadata.ISO.empty()) g_currentMetadata.ISO = evt.metadata.ISO;
-                 if (!evt.metadata.Shutter.empty()) g_currentMetadata.Shutter = evt.metadata.Shutter;
-                 if (!evt.metadata.Aperture.empty()) g_currentMetadata.Aperture = evt.metadata.Aperture;
-                 if (!evt.metadata.Focal.empty()) g_currentMetadata.Focal = evt.metadata.Focal;
-                 if (!evt.metadata.Focal35mm.empty()) g_currentMetadata.Focal35mm = evt.metadata.Focal35mm;
-                 if (!evt.metadata.ExposureBias.empty()) g_currentMetadata.ExposureBias = evt.metadata.ExposureBias;
-                 if (!evt.metadata.Flash.empty()) g_currentMetadata.Flash = evt.metadata.Flash;
-                 if (!evt.metadata.Software.empty()) g_currentMetadata.Software = evt.metadata.Software;
+                 if (!evt.metadata.ISO.empty()) GetPaneContext(PaneSlot::Primary).metadata.ISO = evt.metadata.ISO;
+                 if (!evt.metadata.Shutter.empty()) GetPaneContext(PaneSlot::Primary).metadata.Shutter = evt.metadata.Shutter;
+                 if (!evt.metadata.Aperture.empty()) GetPaneContext(PaneSlot::Primary).metadata.Aperture = evt.metadata.Aperture;
+                 if (!evt.metadata.Focal.empty()) GetPaneContext(PaneSlot::Primary).metadata.Focal = evt.metadata.Focal;
+                 if (!evt.metadata.Focal35mm.empty()) GetPaneContext(PaneSlot::Primary).metadata.Focal35mm = evt.metadata.Focal35mm;
+                 if (!evt.metadata.ExposureBias.empty()) GetPaneContext(PaneSlot::Primary).metadata.ExposureBias = evt.metadata.ExposureBias;
+                 if (!evt.metadata.Flash.empty()) GetPaneContext(PaneSlot::Primary).metadata.Flash = evt.metadata.Flash;
+                 if (!evt.metadata.Software.empty()) GetPaneContext(PaneSlot::Primary).metadata.Software = evt.metadata.Software;
                  
                  // [v5.5] New Indicators
-                 if (!evt.metadata.Flash.empty()) g_currentMetadata.Flash = evt.metadata.Flash;
-                 if (!evt.metadata.WhiteBalance.empty()) g_currentMetadata.WhiteBalance = evt.metadata.WhiteBalance;
-                 if (!evt.metadata.MeteringMode.empty()) g_currentMetadata.MeteringMode = evt.metadata.MeteringMode;
-                 if (!evt.metadata.ExposureProgram.empty()) g_currentMetadata.ExposureProgram = evt.metadata.ExposureProgram;
-                 if (!evt.metadata.ColorSpace.empty()) g_currentMetadata.ColorSpace = evt.metadata.ColorSpace;
-                 if (evt.metadata.HasEmbeddedColorProfile) g_currentMetadata.HasEmbeddedColorProfile = true;
-                 if (evt.metadata.colorInfo.dataSpace != QuickView::PixelDataSpace::Unknown) g_currentMetadata.colorInfo = evt.metadata.colorInfo;
-                 if (evt.metadata.hdrMetadata.isValid || evt.metadata.hdrMetadata.hasGainMap) g_currentMetadata.hdrMetadata = evt.metadata.hdrMetadata;
+                 if (!evt.metadata.Flash.empty()) GetPaneContext(PaneSlot::Primary).metadata.Flash = evt.metadata.Flash;
+                 if (!evt.metadata.WhiteBalance.empty()) GetPaneContext(PaneSlot::Primary).metadata.WhiteBalance = evt.metadata.WhiteBalance;
+                 if (!evt.metadata.MeteringMode.empty()) GetPaneContext(PaneSlot::Primary).metadata.MeteringMode = evt.metadata.MeteringMode;
+                 if (!evt.metadata.ExposureProgram.empty()) GetPaneContext(PaneSlot::Primary).metadata.ExposureProgram = evt.metadata.ExposureProgram;
+                 if (!evt.metadata.ColorSpace.empty()) GetPaneContext(PaneSlot::Primary).metadata.ColorSpace = evt.metadata.ColorSpace;
+                 if (evt.metadata.HasEmbeddedColorProfile) GetPaneContext(PaneSlot::Primary).metadata.HasEmbeddedColorProfile = true;
+                 if (evt.metadata.colorInfo.dataSpace != QuickView::PixelDataSpace::Unknown) GetPaneContext(PaneSlot::Primary).metadata.colorInfo = evt.metadata.colorInfo;
+                 if (evt.metadata.hdrMetadata.isValid || evt.metadata.hdrMetadata.hasGainMap) GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata = evt.metadata.hdrMetadata;
                  
                  // [v6.3] Propagate Format Details & Format
-                 if (!evt.metadata.FormatDetails.empty()) g_currentMetadata.FormatDetails = evt.metadata.FormatDetails;
-                 if (!evt.metadata.Format.empty()) g_currentMetadata.Format = evt.metadata.Format;
+                 if (!evt.metadata.FormatDetails.empty()) GetPaneContext(PaneSlot::Primary).metadata.FormatDetails = evt.metadata.FormatDetails;
+                 if (!evt.metadata.Format.empty()) GetPaneContext(PaneSlot::Primary).metadata.Format = evt.metadata.Format;
                  
                  // GPS (Atomic update)
                  if (evt.metadata.HasGPS) {
-                     g_currentMetadata.HasGPS = true;
-                     g_currentMetadata.Latitude = evt.metadata.Latitude;
-                     g_currentMetadata.Longitude = evt.metadata.Longitude;
-                     g_currentMetadata.Altitude = evt.metadata.Altitude;
+                     GetPaneContext(PaneSlot::Primary).metadata.HasGPS = true;
+                     GetPaneContext(PaneSlot::Primary).metadata.Latitude = evt.metadata.Latitude;
+                     GetPaneContext(PaneSlot::Primary).metadata.Longitude = evt.metadata.Longitude;
+                     GetPaneContext(PaneSlot::Primary).metadata.Altitude = evt.metadata.Altitude;
                  }
                  
                  // File Attributes
-                 if (evt.metadata.FileSize > 0) g_currentMetadata.FileSize = evt.metadata.FileSize;
+                 if (evt.metadata.FileSize > 0) GetPaneContext(PaneSlot::Primary).metadata.FileSize = evt.metadata.FileSize;
                  // [v5.8] Dimensions (if generic/RAW metadata has them)
-                 if (evt.metadata.Width >= g_currentMetadata.Width && evt.metadata.Height > 0) {
-                     g_currentMetadata.Width = evt.metadata.Width;
-                     g_currentMetadata.Height = evt.metadata.Height;
+                 if (evt.metadata.Width >= GetPaneContext(PaneSlot::Primary).metadata.Width && evt.metadata.Height > 0) {
+                     GetPaneContext(PaneSlot::Primary).metadata.Width = evt.metadata.Width;
+                     GetPaneContext(PaneSlot::Primary).metadata.Height = evt.metadata.Height;
                      
                      // [Fix] Only access rawFrame if it exists (MetadataReady may not have it)
                      if (evt.rawFrame) {
                          // [Fix] Infinite Loop Strategy: "No Improvement" Breaker
-                         float currentWidth = g_imageResource.bitmap ? g_imageResource.GetSize().width : 0.0f;
+                         float currentWidth = GetPaneContext(PaneSlot::Primary).resource.bitmap ? GetPaneContext(PaneSlot::Primary).resource.GetSize().width : 0.0f;
                          bool noImprovement = ((int)currentWidth > 0 && abs((int)evt.rawFrame->width - (int)currentWidth) < 10);
                          
                          // HitLimit: Hardware Constraint (4096 or 16384) OR Just "Big Enough" (> 3000)
@@ -11807,10 +11783,10 @@ void ProcessEngineEvents(HWND hwnd) {
                              hitLimit, dimensionsMatch, noImprovement, g_isImageScaled);
                      }
                  }
-                 if (evt.metadata.CreationTime.dwLowDateTime != 0) g_currentMetadata.CreationTime = evt.metadata.CreationTime;
-                 if (evt.metadata.LastWriteTime.dwLowDateTime != 0) g_currentMetadata.LastWriteTime = evt.metadata.LastWriteTime;
+                 if (evt.metadata.CreationTime.dwLowDateTime != 0) GetPaneContext(PaneSlot::Primary).metadata.CreationTime = evt.metadata.CreationTime;
+                 if (evt.metadata.LastWriteTime.dwLowDateTime != 0) GetPaneContext(PaneSlot::Primary).metadata.LastWriteTime = evt.metadata.LastWriteTime;
 
-                 g_currentMetadata.IsFullMetadataLoaded = true;
+                 GetPaneContext(PaneSlot::Primary).metadata.IsFullMetadataLoaded = true;
                  
                  // Refresh UI layers
                  RequestRepaint(PaintLayer::Static | PaintLayer::Dynamic);
@@ -11833,7 +11809,7 @@ void ProcessEngineEvents(HWND hwnd) {
                         cachedFrame->auxLayer = std::move(evt.auxLayer);
                         
                         // [v10.3.1] Propagate hasGainMap to metadata so simulation knows to bake
-                        g_currentMetadata.hdrMetadata.hasGainMap = true;
+                        GetPaneContext(PaneSlot::Primary).metadata.hdrMetadata.hasGainMap = true;
                         cachedFrame->hdrMetadata.hasGainMap = true;
                     }
                 }
@@ -11841,9 +11817,9 @@ void ProcessEngineEvents(HWND hwnd) {
                 // 2. Update Active Runtime Resource (for immediate repaint)
                 auto cachedFrame = (g_pImageEngine) ? g_pImageEngine->GetCachedImage(evt.filePath) : nullptr;
                 if (cachedFrame && cachedFrame->auxLayer) {
-                    g_imageResource.blendOp = cachedFrame->blendOp;
-                    g_imageResource.shaderPayload = cachedFrame->shaderPayload;
-                    g_imageResource.auxLayer = cachedFrame->auxLayer->Clone();
+                    GetPaneContext(PaneSlot::Primary).resource.blendOp = cachedFrame->blendOp;
+                    GetPaneContext(PaneSlot::Primary).resource.shaderPayload = cachedFrame->shaderPayload;
+                    GetPaneContext(PaneSlot::Primary).resource.auxLayer = cachedFrame->auxLayer->Clone();
                 }
 
                 // 3. Trigger GPU Re-upload and Bake (Binds base layer + new gain map)
@@ -12076,26 +12052,26 @@ static bool ApplyPhase1PlaceholderFrame(
     ComPtr<ID2D1Bitmap> bitmap;
     if (FAILED(g_renderEngine->UploadRawFrameToGPU(*frame, &bitmap)) || !bitmap) return false;
 
-    g_imageResource.Reset();
-    g_imageResource.bitmap = bitmap;
+    GetPaneContext(PaneSlot::Primary).resource.Reset();
+    GetPaneContext(PaneSlot::Primary).resource.bitmap = bitmap;
     g_isBlurry = true;
     g_isImageScaled = true;
     g_imageQualityLevel = std::max(g_imageQualityLevel, 1);
 
     if (sourceW > 0 && sourceH > 0) {
-        g_currentMetadata.Width = sourceW;
-        g_currentMetadata.Height = sourceH;
+        GetPaneContext(PaneSlot::Primary).metadata.Width = sourceW;
+        GetPaneContext(PaneSlot::Primary).metadata.Height = sourceH;
     } else if (frame->width > 4 && frame->height > 4) {
         // Only fallback to frame dimensions if it's a real thumbnail (not a 1x1 transparent skeleton).
         // This prevents the window from rapidly shrinking to 1x1 before the real decode finishes.
-        if (g_currentMetadata.Width == 0 || g_currentMetadata.Height == 0) {
-            g_currentMetadata.Width = static_cast<UINT>(frame->width);
-            g_currentMetadata.Height = static_cast<UINT>(frame->height);
+        if (GetPaneContext(PaneSlot::Primary).metadata.Width == 0 || GetPaneContext(PaneSlot::Primary).metadata.Height == 0) {
+            GetPaneContext(PaneSlot::Primary).metadata.Width = static_cast<UINT>(frame->width);
+            GetPaneContext(PaneSlot::Primary).metadata.Height = static_cast<UINT>(frame->height);
         }
     }
 
     if (loaderName && *loaderName) {
-        g_currentMetadata.LoaderName = loaderName;
+        GetPaneContext(PaneSlot::Primary).metadata.LoaderName = loaderName;
     }
 
     wchar_t titleBuf[2048];
@@ -12104,7 +12080,7 @@ static bool ApplyPhase1PlaceholderFrame(
     swprintf_s(titleBuf, L"Loading... %s - %s", name, g_szWindowTitle);
     SetWindowTextW(hwnd, titleBuf);
 
-    RenderImageToDComp(hwnd, g_imageResource, false);
+    RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, false);
     if (g_compEngine && g_compEngine->IsInitialized()) {
         RECT rc; GetClientRect(hwnd, &rc);
         SyncDCompState(hwnd, static_cast<float>(rc.right), static_cast<float>(rc.bottom));
@@ -12229,8 +12205,10 @@ static void DispatchNavigationToEngine(
     uintmax_t fileSize,
     uint64_t navToken,
     int navigatorIndex,
-    QuickView::BrowseDirection dir) {
-    if (g_imageEngine) g_imageEngine->NavigateTo(path, fileSize, navToken);
+    QuickView::BrowseDirection dir,
+    PaneSlot targetSlot = PaneSlot::Primary,
+    uint64_t generationId = 0) {
+    if (g_imageEngine) g_imageEngine->NavigateTo(path, fileSize, navToken, targetSlot, generationId);
     if (navigatorIndex != -1) {
         g_imageEngine->UpdateView(navigatorIndex, dir);
     }
@@ -12288,7 +12266,7 @@ static FireAndForget RunPhase2DispatchLoop() {
 
         if (task.imageId != g_currentImageId.load() ||
             task.navToken != g_currentNavToken.load() ||
-            g_imagePath != task.path) {
+            GetPaneContext(PaneSlot::Primary).path != task.path) {
             QV_LOG("Phase2_Dispatch", TraceLoggingString("StaleSkipped", "Action"));
             g_isPhase2Debouncing.store(false, std::memory_order_release);
             co_await ResumeBackground{};
@@ -12385,7 +12363,7 @@ void StartNavigation(HWND hwnd, std::wstring path, [[maybe_unused]] bool showOSD
     
     // [Fix] Only reset Runtime State if loading a NEW file.
     // If reloading the same file (e.g. RAW Toggle), preserve g_runtime.ForceRawDecode.
-    if (g_imagePath != path) {
+    if (GetPaneContext(PaneSlot::Primary).path != path) {
         g_runtime.ForceRawDecode = g_config.ForceRawDecode;
         
         // [Fix] Reverted to preserve manual LockWindowSize during navigation.
@@ -12410,23 +12388,23 @@ void StartNavigation(HWND hwnd, std::wstring path, [[maybe_unused]] bool showOSD
     }
     
     // Update Comic Mode state
-    g_toolbar.SetComicMode(g_navigator.GetArchive() != nullptr);
+    g_toolbar.SetComicMode(GetPaneContext(PaneSlot::Primary).navigator.GetArchive() != nullptr);
 
-    g_imagePath = path; // Set target path immediately for UI consistency
+    GetPaneContext(PaneSlot::Primary).path = path; // Set target path immediately for UI consistency
     
     // [Fix] Restore OriginalFilePath when loading a new clean image.
     // If IsDirty is true, we are likely reloading the TempFile, so we must PRESERVE OriginalFilePath.
-    if (!g_editState.IsDirty) {
-        g_editState.OriginalFilePath = path;
+    if (!GetPaneContext(PaneSlot::Primary).editState.IsDirty) {
+        GetPaneContext(PaneSlot::Primary).editState.OriginalFilePath = path;
     }
     
  // [Fix] Reliable Titan Detection
     // Use the robust Phase 2 logic (which checks exact dimensions + file size) 
     // to determine if we should show the Titan decode progress bar.
-    int idx = g_navigator.FindIndex(path);
+    int idx = GetPaneContext(PaneSlot::Primary).navigator.FindIndex(path);
     uintmax_t fileSize = 0;
     if (idx != -1) {
-        fileSize = g_navigator.GetFileSize(idx);
+        fileSize = GetPaneContext(PaneSlot::Primary).navigator.GetFileSize(idx);
     }
     g_isNavigatingToTitan = ShouldUsePhase2TitanDebounce(path, fileSize);
     if (g_isNavigatingToTitan) {
@@ -12443,9 +12421,9 @@ void StartNavigation(HWND hwnd, std::wstring path, [[maybe_unused]] bool showOSD
     // [v5.5 Fix] Reset global metadata to prevent stale data merging
     // Crucial for the Race Fix in FullReady to work correctly!
     if (!g_preserveViewStateOnNextLoad) {
-        g_currentMetadata = {};
+        GetPaneContext(PaneSlot::Primary).metadata = {};
         g_runtime.ShowHdrDetailsExpanded = false;
-        g_currentMetadata.IsFullMetadataLoaded = false;
+        GetPaneContext(PaneSlot::Primary).metadata.IsFullMetadataLoaded = false;
     }
     ClearGamutWarningState(hwnd);
 
@@ -12485,7 +12463,7 @@ void StartNavigation(HWND hwnd, std::wstring path, [[maybe_unused]] bool showOSD
 
 
 FireAndForget UpdateHistogramAsync(HWND hwnd, std::wstring path) {
-    if (path.empty() || path != g_imagePath) co_return;
+    if (path.empty() || path != GetPaneContext(PaneSlot::Primary).path) co_return;
     
     co_await ResumeBackground{};
     
@@ -12494,10 +12472,10 @@ FireAndForget UpdateHistogramAsync(HWND hwnd, std::wstring path) {
     // Instead, we use the pixels already residing in the engine's cache.
     auto frame = (g_pImageEngine) ? g_pImageEngine->GetCachedImage(path) : nullptr;
     if (frame && frame->IsValid()) {
-        g_pImageEngine->GetLoader()->ComputeHistogramFromFrame(*frame, &g_currentMetadata);
+        g_pImageEngine->GetLoader()->ComputeHistogramFromFrame(*frame, &GetPaneContext(PaneSlot::Primary).metadata);
         
         co_await ResumeMainThread(hwnd);
-        if (path == g_imagePath) {
+        if (path == GetPaneContext(PaneSlot::Primary).path) {
             RequestRepaint(PaintLayer::Dynamic);
         }
     } else {
@@ -12510,15 +12488,15 @@ FireAndForget UpdateHistogramAsync(HWND hwnd, std::wstring path) {
              
              co_await ResumeMainThread(hwnd);
              
-            if (path == g_imagePath) {
-                g_currentMetadata.HistR = histMeta.HistR;
-                g_currentMetadata.HistG = histMeta.HistG;
-                g_currentMetadata.HistB = histMeta.HistB;
-                g_currentMetadata.HistL = histMeta.HistL;
-                g_currentMetadata.Sharpness = histMeta.Sharpness;
-                g_currentMetadata.Entropy = histMeta.Entropy;
-                g_currentMetadata.HasSharpness = histMeta.HasSharpness;
-                g_currentMetadata.HasEntropy = histMeta.HasEntropy;
+            if (path == GetPaneContext(PaneSlot::Primary).path) {
+                GetPaneContext(PaneSlot::Primary).metadata.HistR = histMeta.HistR;
+                GetPaneContext(PaneSlot::Primary).metadata.HistG = histMeta.HistG;
+                GetPaneContext(PaneSlot::Primary).metadata.HistB = histMeta.HistB;
+                GetPaneContext(PaneSlot::Primary).metadata.HistL = histMeta.HistL;
+                GetPaneContext(PaneSlot::Primary).metadata.Sharpness = histMeta.Sharpness;
+                GetPaneContext(PaneSlot::Primary).metadata.Entropy = histMeta.Entropy;
+                GetPaneContext(PaneSlot::Primary).metadata.HasSharpness = histMeta.HasSharpness;
+                GetPaneContext(PaneSlot::Primary).metadata.HasEntropy = histMeta.HasEntropy;
                 RequestRepaint(PaintLayer::All);
             }
         }
@@ -12527,7 +12505,7 @@ FireAndForget UpdateHistogramAsync(HWND hwnd, std::wstring path) {
 
 FireAndForget UpdateCompareLeftHistogramAsync(HWND hwnd, std::wstring path) {
     if (path.empty() || !IsCompareModeActive()) co_return;
-    if (path != g_compare.left.path) co_return;
+    if (path != GetPaneContext(PaneSlot::Left).path) co_return;
 
     co_await ResumeBackground{};
 
@@ -12548,39 +12526,39 @@ FireAndForget UpdateCompareLeftHistogramAsync(HWND hwnd, std::wstring path) {
 
     co_await ResumeMainThread(hwnd);
 
-    if (IsCompareModeActive() && path == g_compare.left.path) {
+    if (IsCompareModeActive() && path == GetPaneContext(PaneSlot::Left).path) {
         if (hasFullMeta) {
             // Merge missing file stats and EXIF data
-            if (g_compare.left.metadata.FileSize == 0) g_compare.left.metadata.FileSize = fullMeta.FileSize;
-            if (g_compare.left.metadata.Date.empty()) g_compare.left.metadata.Date = fullMeta.Date;
-            if (g_compare.left.metadata.Make.empty()) g_compare.left.metadata.Make = fullMeta.Make;
-            if (g_compare.left.metadata.Model.empty()) g_compare.left.metadata.Model = fullMeta.Model;
-            if (g_compare.left.metadata.Lens.empty()) g_compare.left.metadata.Lens = fullMeta.Lens;
-            if (g_compare.left.metadata.ISO.empty()) g_compare.left.metadata.ISO = fullMeta.ISO;
-            if (g_compare.left.metadata.Aperture.empty()) g_compare.left.metadata.Aperture = fullMeta.Aperture;
-            if (g_compare.left.metadata.Shutter.empty()) g_compare.left.metadata.Shutter = fullMeta.Shutter;
-            if (g_compare.left.metadata.Focal.empty()) g_compare.left.metadata.Focal = fullMeta.Focal;
-            if (g_compare.left.metadata.Focal35mm.empty()) g_compare.left.metadata.Focal35mm = fullMeta.Focal35mm;
-            if (g_compare.left.metadata.ExposureBias.empty()) g_compare.left.metadata.ExposureBias = fullMeta.ExposureBias;
-            if (g_compare.left.metadata.Flash.empty()) g_compare.left.metadata.Flash = fullMeta.Flash;
-            if (g_compare.left.metadata.WhiteBalance.empty()) g_compare.left.metadata.WhiteBalance = fullMeta.WhiteBalance;
-            if (g_compare.left.metadata.MeteringMode.empty()) g_compare.left.metadata.MeteringMode = fullMeta.MeteringMode;
-            if (g_compare.left.metadata.ExposureProgram.empty()) g_compare.left.metadata.ExposureProgram = fullMeta.ExposureProgram;
-            if (g_compare.left.metadata.Software.empty()) g_compare.left.metadata.Software = fullMeta.Software;
-            if (g_compare.left.metadata.ColorSpace.empty()) g_compare.left.metadata.ColorSpace = fullMeta.ColorSpace;
-            if (g_compare.left.metadata.FormatDetails.empty()) g_compare.left.metadata.FormatDetails = fullMeta.FormatDetails;
-            g_compare.left.metadata.IsFullMetadataLoaded = true;
+            if (GetPaneContext(PaneSlot::Left).metadata.FileSize == 0) GetPaneContext(PaneSlot::Left).metadata.FileSize = fullMeta.FileSize;
+            if (GetPaneContext(PaneSlot::Left).metadata.Date.empty()) GetPaneContext(PaneSlot::Left).metadata.Date = fullMeta.Date;
+            if (GetPaneContext(PaneSlot::Left).metadata.Make.empty()) GetPaneContext(PaneSlot::Left).metadata.Make = fullMeta.Make;
+            if (GetPaneContext(PaneSlot::Left).metadata.Model.empty()) GetPaneContext(PaneSlot::Left).metadata.Model = fullMeta.Model;
+            if (GetPaneContext(PaneSlot::Left).metadata.Lens.empty()) GetPaneContext(PaneSlot::Left).metadata.Lens = fullMeta.Lens;
+            if (GetPaneContext(PaneSlot::Left).metadata.ISO.empty()) GetPaneContext(PaneSlot::Left).metadata.ISO = fullMeta.ISO;
+            if (GetPaneContext(PaneSlot::Left).metadata.Aperture.empty()) GetPaneContext(PaneSlot::Left).metadata.Aperture = fullMeta.Aperture;
+            if (GetPaneContext(PaneSlot::Left).metadata.Shutter.empty()) GetPaneContext(PaneSlot::Left).metadata.Shutter = fullMeta.Shutter;
+            if (GetPaneContext(PaneSlot::Left).metadata.Focal.empty()) GetPaneContext(PaneSlot::Left).metadata.Focal = fullMeta.Focal;
+            if (GetPaneContext(PaneSlot::Left).metadata.Focal35mm.empty()) GetPaneContext(PaneSlot::Left).metadata.Focal35mm = fullMeta.Focal35mm;
+            if (GetPaneContext(PaneSlot::Left).metadata.ExposureBias.empty()) GetPaneContext(PaneSlot::Left).metadata.ExposureBias = fullMeta.ExposureBias;
+            if (GetPaneContext(PaneSlot::Left).metadata.Flash.empty()) GetPaneContext(PaneSlot::Left).metadata.Flash = fullMeta.Flash;
+            if (GetPaneContext(PaneSlot::Left).metadata.WhiteBalance.empty()) GetPaneContext(PaneSlot::Left).metadata.WhiteBalance = fullMeta.WhiteBalance;
+            if (GetPaneContext(PaneSlot::Left).metadata.MeteringMode.empty()) GetPaneContext(PaneSlot::Left).metadata.MeteringMode = fullMeta.MeteringMode;
+            if (GetPaneContext(PaneSlot::Left).metadata.ExposureProgram.empty()) GetPaneContext(PaneSlot::Left).metadata.ExposureProgram = fullMeta.ExposureProgram;
+            if (GetPaneContext(PaneSlot::Left).metadata.Software.empty()) GetPaneContext(PaneSlot::Left).metadata.Software = fullMeta.Software;
+            if (GetPaneContext(PaneSlot::Left).metadata.ColorSpace.empty()) GetPaneContext(PaneSlot::Left).metadata.ColorSpace = fullMeta.ColorSpace;
+            if (GetPaneContext(PaneSlot::Left).metadata.FormatDetails.empty()) GetPaneContext(PaneSlot::Left).metadata.FormatDetails = fullMeta.FormatDetails;
+            GetPaneContext(PaneSlot::Left).metadata.IsFullMetadataLoaded = true;
         }
 
         if (hasHist) {
-            g_compare.left.metadata.HistR = histMeta.HistR;
-            g_compare.left.metadata.HistG = histMeta.HistG;
-            g_compare.left.metadata.HistB = histMeta.HistB;
-            g_compare.left.metadata.HistL = histMeta.HistL;
-            g_compare.left.metadata.Sharpness = histMeta.Sharpness;
-            g_compare.left.metadata.Entropy = histMeta.Entropy;
-            g_compare.left.metadata.HasSharpness = histMeta.HasSharpness;
-            g_compare.left.metadata.HasEntropy = histMeta.HasEntropy;
+            GetPaneContext(PaneSlot::Left).metadata.HistR = histMeta.HistR;
+            GetPaneContext(PaneSlot::Left).metadata.HistG = histMeta.HistG;
+            GetPaneContext(PaneSlot::Left).metadata.HistB = histMeta.HistB;
+            GetPaneContext(PaneSlot::Left).metadata.HistL = histMeta.HistL;
+            GetPaneContext(PaneSlot::Left).metadata.Sharpness = histMeta.Sharpness;
+            GetPaneContext(PaneSlot::Left).metadata.Entropy = histMeta.Entropy;
+            GetPaneContext(PaneSlot::Left).metadata.HasSharpness = histMeta.HasSharpness;
+            GetPaneContext(PaneSlot::Left).metadata.HasEntropy = histMeta.HasEntropy;
         }
 
         RequestRepaint(PaintLayer::All);
@@ -12589,92 +12567,34 @@ FireAndForget UpdateCompareLeftHistogramAsync(HWND hwnd, std::wstring path) {
 
 static FireAndForget LoadImageIntoCompareLeftSlot(HWND hwnd, std::wstring path, std::function<void(bool)> callback) {
     const std::wstring localPath = path;
-    if (localPath.empty() || !g_imageLoader || !g_renderEngine) {
+    if (localPath.empty() || !g_imageEngine) {
         if (callback) callback(false);
         co_return;
     }
 
-    const bool previousRawDecodeState = g_runtime.ForceRawDecode;
-    const bool isSameImageReload = (g_compare.left.path == localPath);
-    const bool desiredRawDecode = isSameImageReload ? g_runtime.ForceRawDecode : g_config.ForceRawDecode;
-    g_runtime.ForceRawDecode = desiredRawDecode;
-
-    // [UI Responsiveness] Apply "Heavy Lane" heuristic from ImageEngine
-    // Only show decode progress bar for genuinely slow work, matching the right pane:
-    // Titan scans and RAW full decode. Embedded preview reloads stay silent.
-    bool isHeavy = ShouldUsePhase2TitanDebounce(localPath, 0) || (IsRawFile(localPath) && desiredRawDecode);
-    if (isHeavy) {
-        g_isLeftPaneDecoding = true;
-        RequestRepaint(PaintLayer::Dynamic);
-        SetTimer(hwnd, 995, 16, nullptr); // Start UI Heartbeat timer for animating progress bar
-    }
-
-    co_await ResumeBackground{};
-
-    QuickView::RawImageFrame frame;
-    CImageLoader::ImageMetadata meta;
-    std::wstring loaderName;
-    HRESULT hr = g_imageLoader->LoadToFrame(localPath.c_str(), &frame, nullptr, 0, 0,
-                                             &loaderName, {}, &meta, true, false,
-                                             GetDisplayHdrHeadroomStopsForPane(hwnd, ComparePane::Left));
+    g_leftPaneReadyCallback = callback;
     
-    co_await ResumeMainThread(hwnd);
-
-    g_runtime.ForceRawDecode = previousRawDecodeState;
-    g_isLeftPaneDecoding = false;
-
-    if (FAILED(hr) || !frame.IsValid()) {
-        if (callback) callback(false);
-        co_return;
-    }
-
-    // Upload pixel data to D2D bitmap (same as main pipeline)
-    ComPtr<ID2D1Bitmap> d2dBitmap;
-    QuickView::DisplayColorState uploadState = {};
-    const bool hasPaneDisplayState = GetDisplayColorStateForPane(hwnd, ComparePane::Left, &uploadState);
-    const QuickView::DisplayColorState restoreState =
-        g_compEngine ? g_compEngine->GetDisplayColorState() : g_renderEngine->GetDisplayColorState();
-    if (hasPaneDisplayState) {
-        g_renderEngine->SetDisplayColorState(uploadState);
-    }
-    hr = g_renderEngine->UploadRawFrameToGPU(frame, &d2dBitmap);
-    if (hasPaneDisplayState) {
-        g_renderEngine->SetDisplayColorState(restoreState);
-    }
-    if (FAILED(hr) || !d2dBitmap) {
-        if (callback) callback(false);
-        co_return;
-    }
-
-    g_compare.left.Reset();
-    g_compare.left.resource.bitmap = d2dBitmap;
-    g_compare.left.path = localPath;
-    g_compare.left.valid = true;
-    g_compare.left.view = {};
-
-    g_compare.left.metadata = meta;
-    D2D1_SIZE_U pixel = d2dBitmap->GetPixelSize();
-    if (g_compare.left.metadata.Width == 0 || g_compare.left.metadata.Height == 0) {
-        g_compare.left.metadata.Width = pixel.width;
-        g_compare.left.metadata.Height = pixel.height;
-    }
-
-    int frameExif = frame.exifOrientation;
-    if (frameExif < 1 || frameExif > 8) frameExif = 1;
-    g_compare.left.metadata.ExifOrientation = frameExif;
-    g_compare.left.view.ExifOrientation = g_config.AutoRotate ? frameExif : 1;
-
-    g_compare.left.CmsModeOverride = g_runtime.CmsModeOverride;
-    g_compare.left.EnableSoftProofing = g_runtime.EnableSoftProofing;
-    g_compare.left.SoftProofProfilePath = g_runtime.SoftProofProfilePath;
+    // Set left pane state to decoding/loading
+    g_isLeftPaneDecoding = true;
+    RequestRepaint(PaintLayer::Dynamic);
+    SetTimer(hwnd, 995, 16, nullptr); // Start UI Heartbeat timer for animating progress bar
 
-    if (g_runtime.ShowCompareInfo && (g_compare.left.metadata.HistL.empty() || !g_compare.left.metadata.IsFullMetadataLoaded)) {
-        UpdateCompareLeftHistogramAsync(hwnd, localPath);
+    uintmax_t fileSize = 0;
+    std::wstring archivePath;
+    size_t entryIndex = 0;
+    if (FileNavigator::ParseVirtualPath(localPath, archivePath, entryIndex)) {
+        // Virtual archive entry
+    } else {
+        std::error_code ec;
+        fileSize = std::filesystem::file_size(localPath, ec);
     }
 
-    RefreshCompareRawUI(hwnd);
-
-    if (callback) callback(true);
+    // Increment generation ID on Left slot to invalidate stale loads
+    auto& leftPane = GetPaneContext(PaneSlot::Left);
+    leftPane.Reset(); // This increments generationId
+    
+    g_imageEngine->NavigateTo(localPath, fileSize, 0, PaneSlot::Left, leftPane.generationId);
+    co_return;
 }
 
 FireAndForget LoadImageAsync(HWND hwnd, std::wstring path, bool showOSD, QuickView::BrowseDirection dir) {
@@ -12692,23 +12612,23 @@ FireAndForget LoadImageAsync(HWND hwnd, std::wstring path, bool showOSD, QuickVi
 
 
 void NavigateEdge(HWND hwnd, bool toLast) {
-    if (g_navigator.Count() <= 0) return;
+    if (GetPaneContext(PaneSlot::Primary).navigator.Count() <= 0) return;
     if (!CheckUnsavedChanges(hwnd)) return;
 
     if (IsCompareModeActive() && g_toolbar.IsComicMode()) {
-        int targetRightIndex = toLast ? (int)g_navigator.Count() - 1 : 0;
+        int targetRightIndex = toLast ? (int)GetPaneContext(PaneSlot::Primary).navigator.Count() - 1 : 0;
 
         int nextRightIndex = (targetRightIndex + 1) & ~1;
         int nextLeftIndex = nextRightIndex - 1;
 
         std::wstring rightPath;
-        if (nextRightIndex >= 0 && nextRightIndex < (int)g_navigator.Count()) {
-            rightPath = g_navigator.GetFile(nextRightIndex);
+        if (nextRightIndex >= 0 && nextRightIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            rightPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(nextRightIndex);
         }
 
         std::wstring leftPath;
-        if (nextLeftIndex >= 0 && nextLeftIndex < (int)g_navigator.Count()) {
-            leftPath = g_navigator.GetFile(nextLeftIndex);
+        if (nextLeftIndex >= 0 && nextLeftIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            leftPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(nextLeftIndex);
         }
 
         if (rightPath.empty() && leftPath.empty()) {
@@ -12718,17 +12638,17 @@ void NavigateEdge(HWND hwnd, bool toLast) {
         if (rightPath.empty()) {
             rightPath = leftPath;
             leftPath = L"";
-            g_navigator.SetIndex(nextLeftIndex);
+            GetPaneContext(PaneSlot::Primary).navigator.SetIndex(nextLeftIndex);
         } else {
-            g_navigator.SetIndex(nextRightIndex);
+            GetPaneContext(PaneSlot::Primary).navigator.SetIndex(nextRightIndex);
         }
 
         g_compare.activePane = ComparePane::Right;
         g_compare.contextPane = ComparePane::Right;
         g_compare.selectedPane = ComparePane::Right;
-        g_editState.Reset();
+        GetPaneContext(PaneSlot::Primary).editState.Reset();
         if (!g_preserveViewStateOnNextLoad) {
-            g_viewState.Reset();
+            GetPaneContext(PaneSlot::Primary).view.Reset();
         }
 
         QuickView::BrowseDirection browseDir = toLast ? QuickView::BrowseDirection::FORWARD : QuickView::BrowseDirection::BACKWARD;
@@ -12743,7 +12663,7 @@ void NavigateEdge(HWND hwnd, bool toLast) {
                 }
             });
         } else {
-            g_compare.left.Reset();
+            GetPaneContext(PaneSlot::Left).Reset();
             MarkCompareDirty();
             LoadImageAsync(hwnd, rightPath, true, browseDir);
         }
@@ -12752,12 +12672,14 @@ void NavigateEdge(HWND hwnd, bool toLast) {
     }
 
     if (IsCompareModeActive() && g_compare.selectedPane == ComparePane::Left) {
-        if (!g_compare.left.valid || g_compare.left.path.empty()) return;
-        FileNavigator tempNav;
-        tempNav.Initialize(g_compare.left.path);
-        if (tempNav.Count() <= 0) return;
+        auto& leftPane = GetPaneContext(PaneSlot::Left);
+        if (!leftPane.valid || leftPane.path.empty()) return;
+        if (leftPane.navigator.Count() <= 0 || leftPane.navigator.GetFile(leftPane.navigator.Index()) != leftPane.path) {
+            leftPane.navigator.Initialize(leftPane.path);
+        }
+        if (leftPane.navigator.Count() <= 0) return;
 
-        std::wstring path = toLast ? tempNav.Last() : tempNav.First();
+        std::wstring path = toLast ? leftPane.navigator.Last() : leftPane.navigator.First();
 
         if (!path.empty()) {
             LoadImageIntoCompareLeftSlot(hwnd, path, [](bool success){
@@ -12773,8 +12695,8 @@ void NavigateEdge(HWND hwnd, bool toLast) {
     }
 
     std::wstring path = (toLast)
-        ? g_navigator.Last()
-        : g_navigator.First();
+        ? GetPaneContext(PaneSlot::Primary).navigator.Last()
+        : GetPaneContext(PaneSlot::Primary).navigator.First();
 
     if (IsCompareModeActive()) {
         if (!path.empty()) {
@@ -12782,7 +12704,7 @@ void NavigateEdge(HWND hwnd, bool toLast) {
             g_compare.contextPane = ComparePane::Right;
             g_compare.selectedPane = ComparePane::Right;
             if (!g_preserveViewStateOnNextLoad) {
-                g_viewState.Reset();
+                GetPaneContext(PaneSlot::Primary).view.Reset();
             }
             QuickView::BrowseDirection browseDir = toLast
                 ? QuickView::BrowseDirection::FORWARD
@@ -12794,7 +12716,7 @@ void NavigateEdge(HWND hwnd, bool toLast) {
     }
 
     if (!path.empty()) {
-        g_editState.Reset();
+        GetPaneContext(PaneSlot::Primary).editState.Reset();
         QuickView::BrowseDirection browseDir = toLast
             ? QuickView::BrowseDirection::FORWARD
             : QuickView::BrowseDirection::BACKWARD;
@@ -12803,14 +12725,14 @@ void NavigateEdge(HWND hwnd, bool toLast) {
 }
 
 void Navigate(HWND hwnd, int direction) {
-    if (g_navigator.Count() <= 0) return;
+    if (GetPaneContext(PaneSlot::Primary).navigator.Count() <= 0) return;
     if (!CheckUnsavedChanges(hwnd)) return;
 
     if (IsCompareModeActive() && g_toolbar.IsComicMode()) {
-        int currentIndex = g_navigator.Index();
+        int currentIndex = GetPaneContext(PaneSlot::Primary).navigator.Index();
 
         if (direction > 0) {
-            if (currentIndex >= (int)g_navigator.Count() - 1) {
+            if (currentIndex >= (int)GetPaneContext(PaneSlot::Primary).navigator.Count() - 1) {
                 g_osd.Show(hwnd, std::wstring(AppStrings::OSD_LastImage), false);
                 return;
             }
@@ -12827,13 +12749,13 @@ void Navigate(HWND hwnd, int direction) {
         int nextRightIndex = nextBaseIndex + 1;
 
         std::wstring rightPath;
-        if (nextRightIndex >= 0 && nextRightIndex < (int)g_navigator.Count()) {
-            rightPath = g_navigator.GetFile(nextRightIndex);
+        if (nextRightIndex >= 0 && nextRightIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            rightPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(nextRightIndex);
         }
 
         std::wstring leftPath;
-        if (nextLeftIndex >= 0 && nextLeftIndex < (int)g_navigator.Count()) {
-            leftPath = g_navigator.GetFile(nextLeftIndex);
+        if (nextLeftIndex >= 0 && nextLeftIndex < (int)GetPaneContext(PaneSlot::Primary).navigator.Count()) {
+            leftPath = GetPaneContext(PaneSlot::Primary).navigator.GetFile(nextLeftIndex);
         }
 
         if (rightPath.empty() && leftPath.empty()) {
@@ -12843,17 +12765,17 @@ void Navigate(HWND hwnd, int direction) {
         if (rightPath.empty()) {
             rightPath = leftPath;
             leftPath = L"";
-            g_navigator.SetIndex(nextLeftIndex);
+            GetPaneContext(PaneSlot::Primary).navigator.SetIndex(nextLeftIndex);
         } else {
-            g_navigator.SetIndex(nextRightIndex);
+            GetPaneContext(PaneSlot::Primary).navigator.SetIndex(nextRightIndex);
         }
 
         g_compare.activePane = ComparePane::Right;
         g_compare.contextPane = ComparePane::Right;
         g_compare.selectedPane = ComparePane::Right;
-        g_editState.Reset();
+        GetPaneContext(PaneSlot::Primary).editState.Reset();
         if (!g_preserveViewStateOnNextLoad) {
-            g_viewState.Reset();
+            GetPaneContext(PaneSlot::Primary).view.Reset();
         }
 
         QuickView::BrowseDirection browseDir = (direction > 0) ? QuickView::BrowseDirection::FORWARD : QuickView::BrowseDirection::BACKWARD;
@@ -12868,7 +12790,7 @@ void Navigate(HWND hwnd, int direction) {
                 }
             });
         } else {
-            g_compare.left.Reset();
+            GetPaneContext(PaneSlot::Left).Reset();
             MarkCompareDirty();
             LoadImageAsync(hwnd, rightPath, true, browseDir);
         }
@@ -12877,14 +12799,16 @@ void Navigate(HWND hwnd, int direction) {
     }
 
     if (IsCompareModeActive() && g_compare.selectedPane == ComparePane::Left) {
-        if (!g_compare.left.valid || g_compare.left.path.empty()) return;
-        FileNavigator tempNav;
-        tempNav.Initialize(g_compare.left.path);
-        if (tempNav.Count() <= 0) return;
+        auto& leftPane = GetPaneContext(PaneSlot::Left);
+        if (!leftPane.valid || leftPane.path.empty()) return;
+        if (leftPane.navigator.Count() <= 0 || leftPane.navigator.GetFile(leftPane.navigator.Index()) != leftPane.path) {
+            leftPane.navigator.Initialize(leftPane.path);
+        }
+        if (leftPane.navigator.Count() <= 0) return;
 
         std::wstring path = (direction > 0)
-            ? tempNav.Next()
-            : tempNav.Previous();
+            ? leftPane.navigator.Next()
+            : leftPane.navigator.Previous();
 
         if (!path.empty()) {
             LoadImageIntoCompareLeftSlot(hwnd, path, [](bool success){
@@ -12896,7 +12820,7 @@ void Navigate(HWND hwnd, int direction) {
                     RequestRepaint(PaintLayer::Image | PaintLayer::Static);
                 }
             });
-        } else if (tempNav.HitEnd()) {
+        } else if (leftPane.navigator.HitEnd()) {
             if (direction > 0) g_osd.Show(hwnd, std::wstring(AppStrings::OSD_LastImage), false);
             else g_osd.Show(hwnd, std::wstring(AppStrings::OSD_FirstImage), false);
         }
@@ -12904,34 +12828,34 @@ void Navigate(HWND hwnd, int direction) {
     }
 
     std::wstring path = (direction > 0)
-        ? g_navigator.Next()
-        : g_navigator.Previous();
+        ? GetPaneContext(PaneSlot::Primary).navigator.Next()
+        : GetPaneContext(PaneSlot::Primary).navigator.Previous();
 
     if (IsCompareModeActive()) {
         if (!path.empty()) {
             g_compare.activePane = ComparePane::Right;
             g_compare.contextPane = ComparePane::Right;
             g_compare.selectedPane = ComparePane::Right;
-            g_editState.Reset();
+            GetPaneContext(PaneSlot::Primary).editState.Reset();
             if (!g_preserveViewStateOnNextLoad) {
-                g_viewState.Reset();
+                GetPaneContext(PaneSlot::Primary).view.Reset();
             }
             QuickView::BrowseDirection browseDir = (direction > 0)
                 ? QuickView::BrowseDirection::FORWARD
                 : QuickView::BrowseDirection::BACKWARD;
-            std::wstring crossMsg = g_navigator.GetCrossFolderMessage();
+            std::wstring crossMsg = GetPaneContext(PaneSlot::Primary).navigator.GetCrossFolderMessage();
             if (!crossMsg.empty()) {
-                g_navigator.Initialize(path, hwnd); // Update playlist to new folder
+                GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd); // Update playlist to new folder
                 g_osd.Show(hwnd, crossMsg.c_str());
-            } else if (g_navigator.HitEnd() && g_runtime.NavLoop) {
+            } else if (GetPaneContext(PaneSlot::Primary).navigator.HitEnd() && g_runtime.NavLoop) {
                 wchar_t buf[256];
-                swprintf_s(buf, L"[Loop] %d / %zu", g_navigator.Index() + 1, g_navigator.Count());
+                swprintf_s(buf, L"[Loop] %d / %zu", GetPaneContext(PaneSlot::Primary).navigator.Index() + 1, GetPaneContext(PaneSlot::Primary).navigator.Count());
                 g_osd.Show(hwnd, buf, false);
             }
 
             LoadImageAsync(hwnd, path, true, browseDir);
             MarkCompareDirty();
-        } else if (g_navigator.HitEnd()) {
+        } else if (GetPaneContext(PaneSlot::Primary).navigator.HitEnd()) {
             if (direction > 0) g_osd.Show(hwnd, std::wstring(AppStrings::OSD_LastImage), false);
             else g_osd.Show(hwnd, std::wstring(AppStrings::OSD_FirstImage), false);
         }
@@ -12939,8 +12863,8 @@ void Navigate(HWND hwnd, int direction) {
     }
 
     if (!path.empty()) {
-        g_editState.Reset();
-        g_viewState.Reset();
+        GetPaneContext(PaneSlot::Primary).editState.Reset();
+        GetPaneContext(PaneSlot::Primary).view.Reset();
         
         // [Fix Race Condition] 
         // Call UpdateView FIRST to clear old queue and set direction.
@@ -12952,18 +12876,18 @@ void Navigate(HWND hwnd, int direction) {
             ? QuickView::BrowseDirection::FORWARD 
             : QuickView::BrowseDirection::BACKWARD;
         
-        std::wstring crossMsg = g_navigator.GetCrossFolderMessage();
+        std::wstring crossMsg = GetPaneContext(PaneSlot::Primary).navigator.GetCrossFolderMessage();
         if (!crossMsg.empty()) {
-            g_navigator.Initialize(path, hwnd); // Update playlist to new folder
+            GetPaneContext(PaneSlot::Primary).navigator.Initialize(path, hwnd); // Update playlist to new folder
             g_osd.Show(hwnd, crossMsg.c_str());
-        } else if (g_navigator.HitEnd() && g_runtime.NavLoop) {
+        } else if (GetPaneContext(PaneSlot::Primary).navigator.HitEnd() && g_runtime.NavLoop) {
             wchar_t buf[256];
-            swprintf_s(buf, L"[Loop] %d / %zu", g_navigator.Index() + 1, g_navigator.Count());
+            swprintf_s(buf, L"[Loop] %d / %zu", GetPaneContext(PaneSlot::Primary).navigator.Index() + 1, GetPaneContext(PaneSlot::Primary).navigator.Count());
             g_osd.Show(hwnd, buf, false);
         }
 
         LoadImageAsync(hwnd, path, true, browseDir);
-    } else if (g_navigator.HitEnd()) {
+    } else if (GetPaneContext(PaneSlot::Primary).navigator.HitEnd()) {
         // Show OSD when reaching end without looping
         if (direction > 0) {
             g_osd.Show(hwnd, std::wstring(AppStrings::OSD_LastImage), false);
@@ -13029,12 +12953,12 @@ void OnPaint(HWND hwnd) {
             // Background clearing and grid drawing are moved to CompositionEngine surfaces.
             SyncDCompState(hwnd, winPixelsW, winPixelsH);
 
-            if (imageWasDirty && UseSvgViewportRendering(g_imageResource)) {
-                UpgradeSvgSurface(hwnd, g_imageResource);
+            if (imageWasDirty && UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource)) {
+                UpgradeSvgSurface(hwnd, GetPaneContext(PaneSlot::Primary).resource);
             }
 
-            // [Fix] Snapshot metadata to avoid dangling .c_str() if coroutine resets g_currentMetadata mid-paint.
-            const auto titanMeta = g_currentMetadata; // Value copy 閳?safe from concurrent reset
+            // [Fix] Snapshot metadata to avoid dangling .c_str() if coroutine resets GetPaneContext(PaneSlot::Primary).metadata mid-paint.
+            const auto titanMeta = GetPaneContext(PaneSlot::Primary).metadata; // Value copy 閳?safe from concurrent reset
 
             // [Infinity Engine] Cascade Rendering Path
             bool isTitan = g_imageEngine && g_imageEngine->IsTitanModeEnabled();
@@ -13045,7 +12969,7 @@ void OnPaint(HWND hwnd) {
 
                  // 2. Calculate Absolute Scale
                  float fitScale = std::min(logicW / imgFullW, logicH / imgFullH);
-                 float absoluteZoom = fitScale * g_viewState.Zoom; 
+                 float absoluteZoom = fitScale * GetPaneContext(PaneSlot::Primary).view.Zoom; 
                  float invZoom = 1.0f / absoluteZoom;
                  
                  // Centers
@@ -13055,8 +12979,8 @@ void OnPaint(HWND hwnd) {
                  float iCH = imgFullH / 2.0f;
                  
                  // Viewport Top-Left in Image Space
-                 float viewL = (0.0f - sCW - g_viewState.PanX) * invZoom + iCW;
-                 float viewT = (0.0f - sCH - g_viewState.PanY) * invZoom + iCH;
+                 float viewL = (0.0f - sCW - GetPaneContext(PaneSlot::Primary).view.PanX) * invZoom + iCW;
+                 float viewT = (0.0f - sCH - GetPaneContext(PaneSlot::Primary).view.PanY) * invZoom + iCH;
                  float viewW = logicW * invZoom;
                  float viewH = logicH * invZoom;
                  
@@ -13064,8 +12988,8 @@ void OnPaint(HWND hwnd) {
                  
                  // Calculate Base Preview Ratio (Preview / Original)
                  float baseRatio = 0.0f;
-                 float previewW = g_imageResource.GetSize().width;
-                 float previewH = g_imageResource.GetSize().height;
+                 float previewW = GetPaneContext(PaneSlot::Primary).resource.GetSize().width;
+                 float previewH = GetPaneContext(PaneSlot::Primary).resource.GetSize().height;
                  if (titanMeta.Width > 0 && titanMeta.Height > 0) {
                      float ratioW = previewW / (float)titanMeta.Width;
                      float ratioH = previewH / (float)titanMeta.Height;
@@ -13077,8 +13001,8 @@ void OnPaint(HWND hwnd) {
                  std::wstring fmtUpper = titanMeta.Format;
                  std::transform(fmtUpper.begin(), fmtUpper.end(), fmtUpper.begin(), ::towupper);
                  bool isJxlLike = (fmtUpper.contains(L"JXL") || fmtUpper.contains(L"JPEG XL"));
-                 if (!isJxlLike && !g_imagePath.empty()) {
-                     std::wstring pathLower = g_imagePath;
+                 if (!isJxlLike && !GetPaneContext(PaneSlot::Primary).path.empty()) {
+                     std::wstring pathLower = GetPaneContext(PaneSlot::Primary).path;
                      std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::towlower);
                      if (pathLower.ends_with(L".jxl")) isJxlLike = true;
                  }
@@ -13219,7 +13143,7 @@ void OnPaint(HWND hwnd) {
             // Telemetry is always needed for the decode status UI.
             auto s = g_imageEngine->GetTelemetry();
             s.fps = shouldCompute ? g_fps : 0.0f;
-            s.renderHash = ComputePathHash(g_imagePath);
+            s.renderHash = ComputePathHash(GetPaneContext(PaneSlot::Primary).path);
             s.syncStatus = (s.targetHash == s.renderHash);
             s.isScaled = g_isImageScaled; // Pass scaled state to HUD
 
@@ -13283,18 +13207,18 @@ void OnPaint(HWND hwnd) {
         
         // Pass animation state
         AnimationPlaybackState animState;
-        if (g_imageResource.animator) {
+        if (GetPaneContext(PaneSlot::Primary).resource.animator) {
             animState.IsAnimated = true;
             animState.IsPlaying = g_animPlaying;
             animState.InspectorMode = !g_animPlaying;
             animState.ShowDirtyRect = g_showAnimDirtyRect;
-            animState.TotalFrames = g_imageResource.animator->GetTotalFrames();
-            animState.CurrentFrameIndex = g_imageResource.frameMeta.index;
-            animState.CurrentFrameDelayTime = g_imageResource.frameMeta.delayMs;
-            animState.CurrentDisposal = g_imageResource.frameMeta.disposal;
+            animState.TotalFrames = GetPaneContext(PaneSlot::Primary).resource.animator->GetTotalFrames();
+            animState.CurrentFrameIndex = GetPaneContext(PaneSlot::Primary).resource.frameMeta.index;
+            animState.CurrentFrameDelayTime = GetPaneContext(PaneSlot::Primary).resource.frameMeta.delayMs;
+            animState.CurrentDisposal = GetPaneContext(PaneSlot::Primary).resource.frameMeta.disposal;
             
             // Dirty rect info
-            auto& fm = g_imageResource.frameMeta;
+            auto& fm = GetPaneContext(PaneSlot::Primary).resource.frameMeta;
             if (fm.isDelta && (fm.rcRight > fm.rcLeft || fm.rcBottom > fm.rcTop)) {
                 animState.HasDirtyRect = true;
                 animState.DirtyRcLeft = fm.rcLeft;
@@ -13307,8 +13231,8 @@ void OnPaint(HWND hwnd) {
             animState.FitScale = g_lastFitScale;
             animState.FitOffsetX = g_lastFitOffset.x;
             animState.FitOffsetY = g_lastFitOffset.y;
-            animState.ImageWidth = g_imageResource.GetSize().width;
-            animState.ImageHeight = g_imageResource.GetSize().height;
+            animState.ImageWidth = GetPaneContext(PaneSlot::Primary).resource.GetSize().width;
+            animState.ImageHeight = GetPaneContext(PaneSlot::Primary).resource.GetSize().height;
             RECT rcT; GetClientRect(hwnd, &rcT);
             animState.WindowWidth = (float)(rcT.right - rcT.left);
             animState.WindowHeight = (float)(rcT.bottom - rcT.top);
@@ -13316,8 +13240,8 @@ void OnPaint(HWND hwnd) {
         g_uiRenderer->UpdateAnimationState(animState);
         
         // [v10.5] Sync Toolbar animation mode
-        bool hasAnim = (g_imageResource.animator != nullptr);
-        bool supportsDirtyRect = hasAnim ? g_imageResource.animator->SupportsDirtyRect() : false;
+        bool hasAnim = (GetPaneContext(PaneSlot::Primary).resource.animator != nullptr);
+        bool supportsDirtyRect = hasAnim ? GetPaneContext(PaneSlot::Primary).resource.animator->SupportsDirtyRect() : false;
         g_toolbar.SetAnimationMode(hasAnim, hasAnim && g_animPlaying, g_showAnimDirtyRect, supportsDirtyRect);
         if (hasAnim && animState.TotalFrames > 1) {
             float progress = (float)animState.CurrentFrameIndex / (float)(animState.TotalFrames - 1);
@@ -13361,10 +13285,10 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
     const float currentWinW = (float)rcCurrentClient.right;
     const float currentWinH = (float)rcCurrentClient.bottom;
     const float currentBaseFit = ComputeBaseFitScaleForVisual(vs, currentWinW, currentWinH);
-    const float sourceDisplayZoom = g_smoothZoom.Active ? g_smoothZoom.CurrentZoom : (currentBaseFit * g_viewState.Zoom);
-    const float sourceDisplayPanX = g_smoothZoom.Active ? g_smoothZoom.CurrentPanX : g_viewState.PanX;
-    const float sourceDisplayPanY = g_smoothZoom.Active ? g_smoothZoom.CurrentPanY : g_viewState.PanY;
-    const bool useSmoothZoomAnimation = animateDisplay && !UseSvgViewportRendering(g_imageResource);
+    const float sourceDisplayZoom = g_smoothZoom.Active ? g_smoothZoom.CurrentZoom : (currentBaseFit * GetPaneContext(PaneSlot::Primary).view.Zoom);
+    const float sourceDisplayPanX = g_smoothZoom.Active ? g_smoothZoom.CurrentPanX : GetPaneContext(PaneSlot::Primary).view.PanX;
+    const float sourceDisplayPanY = g_smoothZoom.Active ? g_smoothZoom.CurrentPanY : GetPaneContext(PaneSlot::Primary).view.PanY;
+    const bool useSmoothZoomAnimation = animateDisplay && !UseSvgViewportRendering(GetPaneContext(PaneSlot::Primary).resource);
     const POINT* effectiveAnchorPt = (centerPt && g_config.MouseAnchoredWindowZoom) ? centerPt : nullptr;
 
     // [Fix] Do not trigger auto-lock resize if we're just looking at the skeleton
@@ -13405,21 +13329,21 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
          if (finalWinH < (int)GetMinWindowWidth()) finalWinH = (int)GetMinWindowWidth();
          
          if (!centerPt) {
-             if (!cappedW) g_viewState.PanX = 0;
-             if (!cappedH) g_viewState.PanY = 0;
+             if (!cappedW) GetPaneContext(PaneSlot::Primary).view.PanX = 0;
+             if (!cappedH) GetPaneContext(PaneSlot::Primary).view.PanY = 0;
          }
     }
     
     if (willResizeWindow) {
          // --- Resize Window Path ---
-         float oldZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : g_viewState.Zoom;
-         float startZoom = g_viewState.Zoom;
-         float startPanX = g_viewState.PanX;
-         float startPanY = g_viewState.PanY;
+         float oldZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : GetPaneContext(PaneSlot::Primary).view.Zoom;
+         float startZoom = GetPaneContext(PaneSlot::Primary).view.Zoom;
+         float startPanX = GetPaneContext(PaneSlot::Primary).view.PanX;
+         float startPanY = GetPaneContext(PaneSlot::Primary).view.PanY;
          
          float baseFit_next = std::min((float)finalWinW / imgW, (float)finalWinH / imgH);
          // [SVG Lossless] Vector images shouldn't be capped.
-         if (imgW < 200.0f && imgH < 200.0f && !g_imageResource.isSvg) {
+         if (imgW < 200.0f && imgH < 200.0f && !GetPaneContext(PaneSlot::Primary).resource.isSvg) {
              if (baseFit_next > 1.0f) baseFit_next = 1.0f;
          }
          
@@ -13463,9 +13387,9 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
                                     targetPanY);
           } else {
               // Direct Mode - Snap to target immediately
-              g_viewState.Zoom = targetZoomState;
-              g_viewState.PanX = targetPanX;
-              g_viewState.PanY = targetPanY;
+              GetPaneContext(PaneSlot::Primary).view.Zoom = targetZoomState;
+              GetPaneContext(PaneSlot::Primary).view.PanX = targetPanX;
+              GetPaneContext(PaneSlot::Primary).view.PanY = targetPanY;
               
               SetWindowPos(hwnd, NULL, targetRect.left, targetRect.top, 
                            targetRect.right - targetRect.left, targetRect.bottom - targetRect.top, 
@@ -13484,7 +13408,7 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
          
          float fitScale = std::min(winW / imgW, winH / imgH);
          // [SVG Lossless] Don't cap fitScale for SVG - vector content scales losslessly
-         if (!g_imageResource.isSvg) {
+         if (!GetPaneContext(PaneSlot::Primary).resource.isSvg) {
              if (g_runtime.LockWindowSize) {
                  if (!g_config.UpscaleSmallImagesWhenLocked && fitScale > 1.0f) {
                      fitScale = 1.0f;
@@ -13496,7 +13420,7 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
              }
          }
          
-         float oldZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : g_viewState.Zoom;
+         float oldZoom = (g_smoothWindowZoom.active) ? g_smoothWindowZoom.targetZoom : GetPaneContext(PaneSlot::Primary).view.Zoom;
          float newZoom = newTotalScale / fitScale;
          
          // Apply Zoom Ratio to Pan if Center Point Provided
@@ -13513,16 +13437,16 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
              float dx = mouseX - winCenterX;
              float dy = mouseY - winCenterY;
              
-             g_viewState.PanX = g_viewState.PanX * zoomRatio + dx * (1.0f - zoomRatio);
-             g_viewState.PanY = g_viewState.PanY * zoomRatio + dy * (1.0f - zoomRatio);
+             GetPaneContext(PaneSlot::Primary).view.PanX = GetPaneContext(PaneSlot::Primary).view.PanX * zoomRatio + dx * (1.0f - zoomRatio);
+             GetPaneContext(PaneSlot::Primary).view.PanY = GetPaneContext(PaneSlot::Primary).view.PanY * zoomRatio + dy * (1.0f - zoomRatio);
          } else {
              // Center Zoom (for Keyboard)
              float zoomRatio = newZoom / oldZoom;
-             g_viewState.PanX *= zoomRatio;
-             g_viewState.PanY *= zoomRatio;
+             GetPaneContext(PaneSlot::Primary).view.PanX *= zoomRatio;
+             GetPaneContext(PaneSlot::Primary).view.PanY *= zoomRatio;
          }
          
-         g_viewState.Zoom = newZoom;
+         GetPaneContext(PaneSlot::Primary).view.Zoom = newZoom;
          
          if (g_compEngine && g_compEngine->IsInitialized()) {
 
@@ -13535,8 +13459,8 @@ void PerformSmartZoom(HWND hwnd, float newTotalScale, const POINT* centerPt, boo
                                       sourceDisplayPanX,
                                       sourceDisplayPanY,
                                       newTotalScale,
-                                      g_viewState.PanX,
-                                      g_viewState.PanY,
+                                      GetPaneContext(PaneSlot::Primary).view.PanX,
+                                      GetPaneContext(PaneSlot::Primary).view.PanY,
                                       effectiveAnchorPt,
                                       false,
                                       nullptr);
@@ -13588,7 +13512,7 @@ std::vector<std::wstring>& GetSystemIccProfiles() {
 
 // [v10.5] Animation Frame Stepping Helper
 void HandleAnimFrameStep(HWND hwnd, bool forward) {
-    if (!g_imageResource.animator) return;
+    if (!GetPaneContext(PaneSlot::Primary).resource.animator) return;
     
     // Pause if playing
     if (g_animPlaying) {
@@ -13597,10 +13521,10 @@ void HandleAnimFrameStep(HWND hwnd, bool forward) {
         g_osd.Show(hwnd, AppStrings::OSD_AnimPaused, true);
     }
     
-    uint32_t total = g_imageResource.animator->GetTotalFrames();
+    uint32_t total = GetPaneContext(PaneSlot::Primary).resource.animator->GetTotalFrames();
     if (total <= 1) return;
     
-    uint32_t current = g_imageResource.frameMeta.index;
+    uint32_t current = GetPaneContext(PaneSlot::Primary).resource.frameMeta.index;
     uint32_t target = 0;
     if (forward) {
         target = (current + 1) % total;
@@ -13608,13 +13532,13 @@ void HandleAnimFrameStep(HWND hwnd, bool forward) {
         target = (current > 0) ? current - 1 : total - 1;
     }
     
-    auto nextFrame = g_imageResource.animator->SeekToFrame(target);
+    auto nextFrame = GetPaneContext(PaneSlot::Primary).resource.animator->SeekToFrame(target);
     if (nextFrame && nextFrame->pixels) {
         ComPtr<ID2D1Bitmap> newBitmap;
         if (SUCCEEDED(g_renderEngine->UploadRawFrameToGPU(*nextFrame, &newBitmap))) {
-            g_imageResource.bitmap = newBitmap;
-            g_imageResource.frameMeta = nextFrame->frameMeta;
-            RenderImageToDComp(hwnd, g_imageResource, true);
+            GetPaneContext(PaneSlot::Primary).resource.bitmap = newBitmap;
+            GetPaneContext(PaneSlot::Primary).resource.frameMeta = nextFrame->frameMeta;
+            RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
             if (g_compEngine) {
                 RECT rc; GetClientRect(hwnd, &rc);
                 SyncDCompState(hwnd, (float)rc.right, (float)rc.bottom, false);
@@ -13626,8 +13550,8 @@ void HandleAnimFrameStep(HWND hwnd, bool forward) {
 }
 
 void PerformAnimSeek(HWND hwnd, float targetProgress) {
-    if (!g_imageResource.animator) return;
-    uint32_t total = g_imageResource.animator->GetTotalFrames();
+    if (!GetPaneContext(PaneSlot::Primary).resource.animator) return;
+    uint32_t total = GetPaneContext(PaneSlot::Primary).resource.animator->GetTotalFrames();
     if (total <= 1) return;
 
     // Pause if playing
@@ -13638,15 +13562,15 @@ void PerformAnimSeek(HWND hwnd, float targetProgress) {
     }
 
     uint32_t targetFrame = (uint32_t)(std::round(targetProgress * (total - 1)));
-    auto nextFrame = g_imageResource.animator->SeekToFrame(targetFrame);
+    auto nextFrame = GetPaneContext(PaneSlot::Primary).resource.animator->SeekToFrame(targetFrame);
     if (nextFrame && nextFrame->pixels) {
         ComPtr<ID2D1Bitmap> newBitmap;
         if (SUCCEEDED(g_renderEngine->UploadRawFrameToGPU(*nextFrame, &newBitmap))) {
-            g_imageResource.bitmap = newBitmap;
-            g_imageResource.frameMeta = nextFrame->frameMeta;
+            GetPaneContext(PaneSlot::Primary).resource.bitmap = newBitmap;
+            GetPaneContext(PaneSlot::Primary).resource.frameMeta = nextFrame->frameMeta;
 
             // Update Surface but defer DComp Commit to OnPaint to avoid stuttering
-            RenderImageToDComp(hwnd, g_imageResource, true);
+            RenderImageToDComp(hwnd, GetPaneContext(PaneSlot::Primary).resource, true);
             RequestRepaint(PaintLayer::Image | PaintLayer::Dynamic);
             g_toolbar.SetAnimProgress(targetProgress); // Visual feedback
         }