diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index b25b0a08..6ff44b82 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -1,4 +1,4 @@
-
+No explanations, just the code.
 
 # C++ Coding Guidelines
 
@@ -87,4 +87,47 @@
 - **FIXME**: Use `// FIXME: description` for known issues that need fixing.
 - **Documentatioon**: Only add comments that add additional value. Avoid stating the obvious.
 
-By following these guidelines, you can ensure clean, efficient, and maintainable C++ code.
\ No newline at end of file
+By following these guidelines, you can ensure clean, efficient, and maintainable C++ code.
+
+<!-- headroom:rtk-instructions -->
+# RTK (Rust Token Killer) - Token-Optimized Commands
+
+When running shell commands, **always prefix with `rtk`**. This reduces context
+usage by 60-90% with zero behavior change. If rtk has no filter for a command,
+it passes through unchanged — so it is always safe to use.
+
+## Key Commands
+```bash
+# Git (59-80% savings)
+rtk git status          rtk git diff            rtk git log
+
+# Files & Search (60-75% savings)
+rtk ls <path>           rtk read <file>         rtk grep <pattern>
+rtk find <pattern>      rtk diff <file>
+
+# Test (90-99% savings) — shows failures only
+rtk pytest tests/       rtk cargo test          rtk test <cmd>
+
+# Build & Lint (80-90% savings) — shows errors only
+rtk tsc                 rtk lint                rtk cargo build
+rtk prettier --check    rtk mypy                rtk ruff check
+
+# Analysis (70-90% savings)
+rtk err <cmd>           rtk log <file>          rtk json <file>
+rtk summary <cmd>       rtk deps                rtk env
+
+# GitHub (26-87% savings)
+rtk gh pr view <n>      rtk gh run list         rtk gh issue list
+
+# Infrastructure (85% savings)
+rtk docker ps           rtk kubectl get         rtk docker logs <c>
+
+# Package managers (70-90% savings)
+rtk pip list            rtk pnpm install        rtk npm run <script>
+```
+
+## Rules
+- In command chains, prefix each segment: `rtk git add . && rtk git commit -m "msg"`
+- For debugging, use raw command without rtk prefix
+- `rtk proxy <cmd>` runs command without filtering but tracks usage
+<!-- /headroom:rtk-instructions -->
diff --git a/.serena/memories/library-best-practices.md b/.serena/memories/library-best-practices.md
new file mode 100644
index 00000000..220446d0
--- /dev/null
+++ b/.serena/memories/library-best-practices.md
@@ -0,0 +1,49 @@
+# 3MF Library Best Practices
+
+## What Makes a Good Library Item?
+
+### Required Metadata
+- **Name**: lower_snake_case, descriptive, no spaces or special chars except hyphens/underscores
+- **Description**: One sentence explaining what the item does and key parameters
+- **Tags**: Minimum 5 relevant keywords for discoverability (e.g., "primitive", "cone", "taper", "basic")
+- **Tagged Function**: Exactly one function marked as tagged. Return type depends on purpose:
+  - `float shape` for SDF primitives/modifiers
+  - `vec3 result` for position transformations (symmetry, rotation, etc.)
+  - `vec3 color` for textures/materials
+
+### Code Quality
+- Clean bounding box suitable for thumbnail rendering
+- Well-named parameters with meaningful defaults where appropriate
+- A `main` function demonstrating typical usage
+- No duplicate function definitions (each name should have unique ID)
+- Proper dependency ordering in program snippet
+
+### Visual Appeal (for Thumbnails)
+- Geometry fills 70-85% of thumbnail frame
+- Isometric camera angle showing 3D form clearly
+- Consistent lighting: directional light from upper-left, ambient fill
+- Neutral background (light gray or white)
+- Characteristic features visible at thumbnail size (256x256 minimum)
+
+## Anti-Patterns to Avoid
+- Empty entries (no description/tags/tagged functions)
+- Missing tags on any entry
+- Duplicate function names within same file
+- Nearly duplicate entries (e.g., unionWithColor vs union_with_color)
+
+## Naming Conventions
+- Primitives: `sphere`, `cylinder`, `cone`, etc.
+- Modifiers: `round`, `shell`, `offset` (verb-based)
+- Operations: `polar_repetition`, `symmetryX` (noun-based with parameter suffix)
+- Mechanical: `helix_spring`, `involute_gear` (compound nouns)
+
+## Category Structure
+```
+primitives/     - Basic SDF shapes (sphere, cylinder, cone, etc.)
+csg/           - Boolean operations (union, intersection, subtraction)
+modifiers/     - Shape deformations (round, shell, offset)
+operations/    - Domain transformations (symmetryX, polar_repetition)
+lattices/      - Periodic structures (gyroid, honeycomb)
+mechanical/    - Engineering parts (gear, spring, thread)
+textures/      - Procedural textures (WoodTexture)
+```
diff --git a/docs/architecture/gpu_access_coordination.md b/docs/architecture/gpu_access_coordination.md
new file mode 100644
index 00000000..020f8d7f
--- /dev/null
+++ b/docs/architecture/gpu_access_coordination.md
@@ -0,0 +1,53 @@
+# GPU Access Coordination
+
+Gladius uses multiple OpenCL command queues: one lazily-created queue per calling thread plus explicit worker queues for async rendering. OpenCL queues do not implicitly synchronize with each other, so shared buffers/images must be ordered explicitly.
+
+## Core invariant
+
+Every shared OpenCL memory-object access across queues must be ordered by one of:
+
+1. an event wait list produced by `GpuAccessCoordinator`, or
+2. an explicit host wait that is reported back to the coordinator.
+
+Host-side mutexes are not sufficient unless they are held until the GPU command using the protected resource has completed.
+
+## Main types
+
+- `GpuAccessCoordinator` is the pure, GPU-free state model. It tracks resource IDs, generations, read/write leases, fake/production event IDs, stale generations, and deferred retirement.
+- `OpenClEventRegistry` maps coordinator event IDs to `cl::Event` objects and polls or waits for completion.
+- `GpuKernelAccessGuard` is the production RAII bridge. It begins one or more resource accesses, converts dependency IDs to OpenCL wait lists, and records the returned kernel event when the enqueue succeeds.
+- `RenderPayloadSnapshot` captures the generation handles for the common render payload: primitive metadata, primitive data, precomputed SDF, parameter buffer, and command buffer.
+
+## Published generations
+
+Each `Buffer<T>` and `ImageImpl<T>` owns a stable coordinator resource ID and a current generation. Host writes, buffer reallocations, image reallocations, and clears retire the previous generation before mutating or releasing the backing OpenCL object.
+
+A kernel launch should use the generation handles captured at launch time. If a later host write advances a generation, stale snapshots can be rejected instead of silently reading mixed old/new state.
+
+## Conservative first-slice policy
+
+The first implementation is whole-resource based:
+
+- reads can overlap with reads;
+- writes wait for previous readers and writers;
+- reads wait for the previous writer;
+- `Primitives::data` is tracked as one conservative resource even though it contains several logical regions;
+- old generations are not released until known events have completed.
+
+This is intentionally safer than region-level aliasing. Region-level optimization can be added later once workflow tests prove the invariants.
+
+The current production rollout also prefers conservative generation retirement over immediate physical double-buffering. Host writes and reallocations wait for tracked readers/writers before mutating the backing object, so the implementation is safe even when only one physical buffer exists. Targeted double buffers can still be introduced later for performance/overlap (`PreComputedSdf`, `DistanceInitBuffer`, low-res preview images, and small parameter/command buffers), but they are no longer required to prevent cross-queue memory-object races.
+
+## Safe mode
+
+Guarded GPU access uses the conservative serialized mode by default. Each guarded launch drains tracked GPU work before enqueue and waits for its own returned event before returning. This is slower than maximally overlapping command queues, but it keeps the production behavior deterministic and avoids environment-dependent synchronization semantics.
+
+## Adding a new kernel launch
+
+1. Identify every shared OpenCL buffer/image argument.
+2. Capture the relevant generation handles before enqueue.
+3. Create a `GpuKernelAccessGuard` with read/write modes.
+4. Pass `guard.waitEvents()` into `CLProgram::runNonBlockingWithWaitList(...)`.
+5. Call `guard.complete(returnedEvent)` immediately after a successful enqueue.
+
+If a launch cannot declare all shared resources yet, prefer a conservative whole-resource access over leaving the path untracked.
diff --git a/gladius/CMakeLists.txt b/gladius/CMakeLists.txt
index bce885a1..82566e38 100644
--- a/gladius/CMakeLists.txt
+++ b/gladius/CMakeLists.txt
@@ -101,7 +101,21 @@ include(cmake/Coverage.cmake)
 set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY OFF)
 
 if (MSVC)
-    add_compile_options(/bigobj /utf-8 /Zc:__cplusplus)
+    # /Zm200 gives MSVC more internal compiler heap for large template-heavy translation units.
+    # Keep it global so executable-only sources such as the MCP tools get the same protection as libraries.
+    add_compile_options(/bigobj /utf-8 /Zc:__cplusplus /Zm200 /WX)
+
+    if(CMAKE_GENERATOR MATCHES "Ninja")
+      set(GLADIUS_MSVC_COMPILE_JOBS "2" CACHE STRING "Maximum concurrent MSVC compile jobs for Ninja builds")
+      set(GLADIUS_MSVC_HEAVY_COMPILE_JOBS "1" CACHE STRING "Maximum concurrent memory-heavy MSVC compile jobs for Ninja builds")
+
+      set_property(GLOBAL PROPERTY JOB_POOLS
+        gladius_msvc_compile_pool=${GLADIUS_MSVC_COMPILE_JOBS}
+        gladius_msvc_heavy_compile_pool=${GLADIUS_MSVC_HEAVY_COMPILE_JOBS}
+        gladius_msvc_link_pool=1)
+      set(CMAKE_JOB_POOL_COMPILE gladius_msvc_compile_pool)
+      set(CMAKE_JOB_POOL_LINK gladius_msvc_link_pool)
+    endif()
 
     if (CMAKE_BUILD_TYPE STREQUAL "Debug")
         add_compile_options(/RTC1) 
@@ -123,6 +137,9 @@ if (MSVC)
 
     # no console
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
+else()
+    # Treat all compiler warnings as errors on GCC/Clang to keep the Linux build clean.
+    add_compile_options(-Werror)
 endif()
 add_definitions(-DTBB_SUPPRESS_DEPRECATED_MESSAGES -DNOMINMAX)
 
diff --git a/gladius/CMakePresets.json b/gladius/CMakePresets.json
index f5422914..68d170f0 100644
--- a/gladius/CMakePresets.json
+++ b/gladius/CMakePresets.json
@@ -23,8 +23,10 @@
                 "VCPKG_TARGET_TRIPLET": "x64-windows-gladius",
                 "VCPKG_OVERLAY_TRIPLETS": "${sourceDir}/vcpkg-triplets",
                 "VCPKG_OVERLAY_PORTS": "${sourceDir}/vcpkg-overlay-ports",
-                "CMAKE_BUILD_PARALLEL_LEVEL": "8",
                 "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            },
+            "environment": {
+                "CMAKE_BUILD_PARALLEL_LEVEL": "8"
             }
         },
         {
@@ -111,7 +113,9 @@
                 "VCPKG_OVERLAY_PORTS": "${sourceDir}/vcpkg-overlay-ports",
                 "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
                 "ENABLE_COVERAGE": "OFF",
-                "ENABLE_TRACY": "TRUE",
+                "ENABLE_TRACY": "TRUE"
+            },
+            "environment": {
                 "CMAKE_BUILD_PARALLEL_LEVEL": "8"
             }
         },
@@ -154,6 +158,58 @@
         }
     ],
     "version": 3,
+    "buildPresets": [
+        {
+            "name": "x64-debug",
+            "displayName": "x64 Debug",
+            "configurePreset": "x64-debug",
+            "jobs": 2
+        },
+        {
+            "name": "x64-release",
+            "displayName": "x64 Release",
+            "configurePreset": "x64-release",
+            "jobs": 2
+        },
+        {
+            "name": "x64-release-debug",
+            "displayName": "x64 Release with Debug",
+            "configurePreset": "x64-release-debug",
+            "jobs": 2
+        },
+        {
+            "name": "x64-release-debug-asan",
+            "displayName": "x64 Release with Debug and ASAN",
+            "configurePreset": "x64-release-debug-asan",
+            "jobs": 2
+        },
+        {
+            "name": "x64-release-debug-noOpenCL",
+            "displayName": "x64 Release with Debug (No OpenCL Tests)",
+            "configurePreset": "x64-release-debug-noOpenCL",
+            "jobs": 2
+        },
+        {
+            "name": "linux-debug",
+            "configurePreset": "linux-debug",
+            "jobs": 8
+        },
+        {
+            "name": "linux-release",
+            "configurePreset": "linux-release",
+            "jobs": 8
+        },
+        {
+            "name": "linux-releaseWithDebug",
+            "configurePreset": "linux-releaseWithDebug",
+            "jobs": 8
+        },
+        {
+            "name": "linux-releaseWithDebug-noOpenCL",
+            "configurePreset": "linux-releaseWithDebug-noOpenCL",
+            "jobs": 8
+        }
+    ],
     "testPresets": [
         {
             "name": "ReleaseWithDebug",
diff --git a/gladius/library/mechanical/helix_spring.3mf b/gladius/library/mechanical/helix_spring.3mf
new file mode 100644
index 00000000..274e97a3
Binary files /dev/null and b/gladius/library/mechanical/helix_spring.3mf differ
diff --git a/gladius/library/mechanical/involute_gear.3mf b/gladius/library/mechanical/involute_gear.3mf
index 6555b0c4..f0f1897b 100644
Binary files a/gladius/library/mechanical/involute_gear.3mf and b/gladius/library/mechanical/involute_gear.3mf differ
diff --git a/gladius/library/mechanical/iso_external_thread.3mf b/gladius/library/mechanical/iso_external_thread.3mf
index d9088e7b..86b5419c 100644
Binary files a/gladius/library/mechanical/iso_external_thread.3mf and b/gladius/library/mechanical/iso_external_thread.3mf differ
diff --git a/gladius/library/mechanical/metric_nut.3mf b/gladius/library/mechanical/metric_nut.3mf
new file mode 100644
index 00000000..28aede6e
Binary files /dev/null and b/gladius/library/mechanical/metric_nut.3mf differ
diff --git a/gladius/library/mechanical/socket_cap_screw.3mf b/gladius/library/mechanical/socket_cap_screw.3mf
new file mode 100644
index 00000000..8a873337
Binary files /dev/null and b/gladius/library/mechanical/socket_cap_screw.3mf differ
diff --git a/gladius/library/mechanical/tube.3mf b/gladius/library/mechanical/tube.3mf
new file mode 100644
index 00000000..9f2862af
Binary files /dev/null and b/gladius/library/mechanical/tube.3mf differ
diff --git a/gladius/library/operations/polar_repetition.3mf b/gladius/library/operations/polar_repetition.3mf
new file mode 100644
index 00000000..355edbf1
Binary files /dev/null and b/gladius/library/operations/polar_repetition.3mf differ
diff --git a/gladius/library/operations/twist.3mf b/gladius/library/operations/twist.3mf
new file mode 100644
index 00000000..87c89687
Binary files /dev/null and b/gladius/library/operations/twist.3mf differ
diff --git a/gladius/library/primitives/capsule.3mf b/gladius/library/primitives/capsule.3mf
new file mode 100644
index 00000000..99e5c5a3
Binary files /dev/null and b/gladius/library/primitives/capsule.3mf differ
diff --git a/gladius/library/primitives/cone.3mf b/gladius/library/primitives/cone.3mf
new file mode 100644
index 00000000..2b137d0e
Binary files /dev/null and b/gladius/library/primitives/cone.3mf differ
diff --git a/gladius/library/primitives/cylinder.3mf b/gladius/library/primitives/cylinder.3mf
new file mode 100644
index 00000000..032e314c
Binary files /dev/null and b/gladius/library/primitives/cylinder.3mf differ
diff --git a/gladius/library/primitives/diamond.3mf b/gladius/library/primitives/diamond.3mf
new file mode 100644
index 00000000..a1a1b497
Binary files /dev/null and b/gladius/library/primitives/diamond.3mf differ
diff --git a/gladius/library/primitives/ellipsoid.3mf b/gladius/library/primitives/ellipsoid.3mf
new file mode 100644
index 00000000..14ebaddf
Binary files /dev/null and b/gladius/library/primitives/ellipsoid.3mf differ
diff --git a/gladius/library/primitives/hexagon.3mf b/gladius/library/primitives/hexagon.3mf
new file mode 100644
index 00000000..77ce729d
Binary files /dev/null and b/gladius/library/primitives/hexagon.3mf differ
diff --git a/gladius/library/primitives/rounded_box.3mf b/gladius/library/primitives/rounded_box.3mf
new file mode 100644
index 00000000..bbb1a16d
Binary files /dev/null and b/gladius/library/primitives/rounded_box.3mf differ
diff --git a/gladius/library/primitives/sphere.3mf b/gladius/library/primitives/sphere.3mf
new file mode 100644
index 00000000..01e32966
Binary files /dev/null and b/gladius/library/primitives/sphere.3mf differ
diff --git a/gladius/library/primitives/torus.3mf b/gladius/library/primitives/torus.3mf
new file mode 100644
index 00000000..44e90466
Binary files /dev/null and b/gladius/library/primitives/torus.3mf differ
diff --git a/gladius/library/primitives/triangular_prism.3mf b/gladius/library/primitives/triangular_prism.3mf
new file mode 100644
index 00000000..e6f2a70d
Binary files /dev/null and b/gladius/library/primitives/triangular_prism.3mf differ
diff --git a/gladius/library/primitives/truncated_cone.3mf b/gladius/library/primitives/truncated_cone.3mf
new file mode 100644
index 00000000..fe1529ff
Binary files /dev/null and b/gladius/library/primitives/truncated_cone.3mf differ
diff --git a/gladius/src/Buffer.h b/gladius/src/Buffer.h
index 255d9ef3..768fa1fe 100644
--- a/gladius/src/Buffer.h
+++ b/gladius/src/Buffer.h
@@ -3,6 +3,7 @@
 #include "ComputeContext.h"
 #include <cmath>
 #include <iostream>
+#include <stdexcept>
 #include <typeinfo>
 #include <vector>
 
@@ -14,19 +15,31 @@ namespace gladius
       public:
         explicit Buffer(ComputeContext & context)
             : m_ComputeContext(context)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                GpuResourceKind::Buffer, typeid(T).name()))
         {
         }
 
         ~Buffer()
         {
-            // Release tracked bytes when buffer goes out of scope
-            if (m_buffer && m_size > 0)
+            try
             {
-                m_ComputeContext.onBufferReleased(sizeof(T) * m_size);
+                // Release tracked bytes only after known GPU users have completed.
+                if (m_buffer && m_size > 0)
+                {
+                    m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+                    m_ComputeContext.onBufferReleased(sizeof(T) * m_size);
+                }
+            }
+            catch (...)
+            {
+                // Destructors must not throw.
             }
         }
         Buffer(Buffer const & other)
             : m_ComputeContext(other.m_ComputeContext)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                GpuResourceKind::Buffer, typeid(T).name()))
             , m_data(other.m_data)
         {
             create();
@@ -44,6 +57,7 @@ namespace gladius
             {
                 throw std::runtime_error("Failed to read, device buffer could not be created");
             }
+            m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
             m_data.resize(m_size);
             CL_ERROR(m_ComputeContext.GetQueue().enqueueReadBuffer(
               *m_buffer.get(), CL_TRUE, 0, sizeof(T) * m_size, &m_data[0]));
@@ -59,6 +73,7 @@ namespace gladius
             // If there was a previous allocation, release its accounting first
             if (m_buffer && m_size > 0)
             {
+                retireCurrentGpuGeneration();
                 m_ComputeContext.onBufferReleased(sizeof(T) * m_size);
             }
 
@@ -73,6 +88,7 @@ namespace gladius
             m_data.clear();
             if (m_buffer && m_size > 0)
             {
+                retireCurrentGpuGeneration();
                 m_ComputeContext.onBufferReleased(sizeof(T) * m_size);
             }
             m_size = 0;
@@ -95,6 +111,7 @@ namespace gladius
                 throw std::runtime_error("Failed to write, device buffer could not be created");
             }
 
+            retireCurrentGpuGeneration();
             CL_ERROR(m_ComputeContext.GetQueue().enqueueWriteBuffer(
               *m_buffer.get(), CL_TRUE, 0, sizeof(T) * m_data.size(), &m_data[0]));
 
@@ -139,10 +156,39 @@ namespace gladius
             return *m_buffer.get();
         }
 
+        [[nodiscard]] GpuResourceHandle gpuResourceHandle() const noexcept
+        {
+            return m_gpuResource;
+        }
+
       private:
+        void retireCurrentGpuGeneration()
+        {
+            m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+
+            auto retirement = m_ComputeContext.gpuAccessCoordinator().retireCurrentGeneration(
+              m_gpuResource.resourceId);
+            if (retirement.status == GpuAccessStatus::PendingAccessWithoutEvent)
+            {
+                m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+                retirement = m_ComputeContext.gpuAccessCoordinator().retireCurrentGeneration(
+                  m_gpuResource.resourceId);
+            }
+
+            if (!retirement.granted())
+            {
+                throw std::runtime_error("Failed to retire GPU buffer generation safely");
+            }
+
+            m_ComputeContext.waitForGpuEvents(retirement.waitEvents);
+            m_ComputeContext.gpuAccessCoordinator().collectCompletedRetirements();
+            m_gpuResource = retirement.newGeneration;
+        }
+
+        ComputeContext & m_ComputeContext;
+        GpuResourceHandle m_gpuResource{};
         std::vector<T> m_data;
         size_t m_size = 0;
-        ComputeContext & m_ComputeContext;
         std::unique_ptr<cl::Buffer> m_buffer;
     };
 }
\ No newline at end of file
diff --git a/gladius/src/CLProgram.cpp b/gladius/src/CLProgram.cpp
index e8859006..fbbb9c35 100644
--- a/gladius/src/CLProgram.cpp
+++ b/gladius/src/CLProgram.cpp
@@ -33,7 +33,28 @@ namespace gladius
         // --- Diagnostic helpers (OpenCL source/options dump) ---
         inline bool isOclDumpEnabled()
         {
-            return false;
+            auto isEnabled = [](char const * value)
+            {
+                if (value == nullptr)
+                {
+                    return false;
+                }
+
+                auto normalized = std::string{value};
+                std::transform(normalized.begin(),
+                               normalized.end(),
+                               normalized.begin(),
+                               [](unsigned char character)
+                               {
+                                   return static_cast<char>(std::tolower(character));
+                               });
+
+                return normalized == "1" || normalized == "true" || normalized == "yes" ||
+                       normalized == "on";
+            };
+
+            return isEnabled(std::getenv("GLADIUS_OCL_DUMP")) ||
+                   isEnabled(std::getenv("GLADIUS_OPENCL_DUMP"));
         }
 
         std::string toLowerCopy(std::string_view text)
diff --git a/gladius/src/CLProgram.h b/gladius/src/CLProgram.h
index 5ee59d49..ec5cbe72 100644
--- a/gladius/src/CLProgram.h
+++ b/gladius/src/CLProgram.h
@@ -114,6 +114,30 @@ namespace gladius
                                                cl::NDRange origin,
                                                cl::NDRange range,
                                                const ArgumentTypes &... args)
+        {
+            return runNonBlockingImpl(queue, methodName, origin, range, nullptr, args...);
+        }
+
+        template <typename... ArgumentTypes>
+        [[nodiscard]] cl::Event runNonBlockingWithWaitList(cl::CommandQueue const & queue,
+                                                           const std::string & methodName,
+                                                           cl::NDRange origin,
+                                                           cl::NDRange range,
+                                                           std::vector<cl::Event> const & waitEvents,
+                                                           const ArgumentTypes &... args)
+        {
+            auto const * waitList = waitEvents.empty() ? nullptr : &waitEvents;
+            return runNonBlockingImpl(queue, methodName, origin, range, waitList, args...);
+        }
+
+      private:
+        template <typename... ArgumentTypes>
+        [[nodiscard]] cl::Event runNonBlockingImpl(cl::CommandQueue const & queue,
+                                                   const std::string & methodName,
+                                                   cl::NDRange origin,
+                                                   cl::NDRange range,
+                                                   std::vector<cl::Event> const * waitEvents,
+                                                   const ArgumentTypes &... args)
         {
             ProfileFunction;
 
@@ -279,8 +303,12 @@ namespace gladius
             cl::Event kernelEvent;
             try
             {
-                CL_ERROR(
-                  queue.enqueueNDRangeKernel(m_kernels[methodName], origin, range, cl::NullRange, nullptr, &kernelEvent));
+                CL_ERROR(queue.enqueueNDRangeKernel(m_kernels[methodName],
+                                                    origin,
+                                                    range,
+                                                    cl::NullRange,
+                                                    waitEvents,
+                                                    &kernelEvent));
             }
             catch (const OpenCLError & e)
             {
@@ -291,6 +319,8 @@ namespace gladius
             return kernelEvent;
         }
 
+            public:
+
         template <typename... ArgumentTypes>
         void run(cl::CommandQueue const & queue,
                  const std::string & methodName,
diff --git a/gladius/src/CMakeLists.txt b/gladius/src/CMakeLists.txt
index 3f3df275..8fc9ab87 100644
--- a/gladius/src/CMakeLists.txt
+++ b/gladius/src/CMakeLists.txt
@@ -1,12 +1,28 @@
 set(BINARY ${CMAKE_PROJECT_NAME})
 file(GLOB SOURCES LIST_DIRECTORIES true *.h *.cpp)
 
+list(APPEND SOURCES
+    io/3mf/OpenVdbShellGenerator.h
+    io/3mf/OpenVdbShellGenerator.cpp
+    io/3mf/ShellMaterialOrdering.h
+    io/3mf/ShellMaterialOrdering.cpp
+    io/3mf/ShellThicknessPartition.h
+    io/3mf/ShellThicknessPartition.cpp
+)
+
 # MCP sources are intentionally NOT part of the core targets (gladius, gladius_lib)
 # They will be added to the dedicated gladiusmcp target below
 file(GLOB MCP_SOURCES LIST_DIRECTORIES true mcp/*.h mcp/*.cpp)
 # Add MCP tools sources
 file(GLOB MCP_TOOLS_SOURCES LIST_DIRECTORIES true mcp/tools/*.h mcp/tools/*.cpp)
 
+if (MSVC AND CMAKE_GENERATOR MATCHES "Ninja")
+    set_source_files_properties(
+        ${CMAKE_CURRENT_SOURCE_DIR}/mcp/tools/ParameterManagementTool.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/mcp/tools/ResourceManagementTool.cpp
+        PROPERTIES JOB_POOL_COMPILE gladius_msvc_heavy_compile_pool)
+endif()
+
 
 
 add_library(${BINARY}_lib STATIC ${SOURCES})
@@ -105,6 +121,56 @@ target_link_libraries(${BINARY}_lib PUBLIC ${DEPENDENCIES_CORE})
 target_link_libraries(${BINARY}_lib_mcp PUBLIC ${DEPENDENCIES_CORE})
 target_link_libraries(${BINARY} PUBLIC ${BINARY}_lib)
 
+# Precompiled headers: keep the Windows PCH deliberately lean. Large template-heavy
+# dependencies such as OpenVDB/Boost/Eigen/ImGui can raise the baseline heap for every
+# MSVC translation unit that uses the PCH. Linux/Clang keeps the broader PCH because it
+# is not where we see C1060 heap exhaustion.
+set(GLADIUS_CORE_PCH_HEADERS
+    <algorithm>
+    <array>
+    <chrono>
+    <cmath>
+    <cstring>
+    <filesystem>
+    <fstream>
+    <functional>
+    <iostream>
+    <limits>
+    <map>
+    <memory>
+    <mutex>
+    <optional>
+    <set>
+    <sstream>
+    <stdexcept>
+    <string>
+    <unordered_map>
+    <unordered_set>
+    <utility>
+    <variant>
+    <vector>
+    <fmt/format.h>
+)
+
+if (NOT MSVC)
+    list(APPEND GLADIUS_CORE_PCH_HEADERS
+        <Eigen/Core>
+        <imgui.h>)
+endif()
+
+set(GLADIUS_MCP_PCH_HEADERS
+    ${GLADIUS_CORE_PCH_HEADERS}
+    <nlohmann/json.hpp>
+)
+
+target_precompile_headers(${BINARY}_lib PRIVATE ${GLADIUS_CORE_PCH_HEADERS})
+# _lib_mcp has GLADIUS_ENABLE_MCP defined so it gets its own PCH build
+target_precompile_headers(${BINARY}_lib_mcp PRIVATE ${GLADIUS_CORE_PCH_HEADERS})
+# Keep a target-local PCH for the executable. MSVC embeds the target's PDB path
+# in the PCH, so reusing the static library PCH causes C2859 when the executable
+# is compiled with its own /Fd path.
+target_precompile_headers(${BINARY} PRIVATE ${GLADIUS_CORE_PCH_HEADERS})
+
 # Enable AVX2 SIMD instructions for Phase 3 optimization
 # PUBLIC so consumers (tests, etc.) see the same Eigen alignment as the library,
 # avoiding ODR violations from mismatched struct layouts.
@@ -135,6 +201,9 @@ endif()
 target_link_libraries(gladiusmcp PUBLIC ${BINARY}_lib_mcp ${DEPENDENCIES_MCP})
 # Ensure the MCP-enabled static library is built before linking the executable
 add_dependencies(gladiusmcp ${BINARY}_lib_mcp)
+# Use an MCP-specific PCH instead of reusing the core/UI PCH; the MCP tools mostly need
+# standard library + JSON, not the full Eigen/ImGui-heavy core baseline.
+target_precompile_headers(gladiusmcp PRIVATE ${GLADIUS_MCP_PCH_HEADERS})
 if (NOT WIN32)
     target_compile_options(gladiusmcp PRIVATE -mavx2 -mfma)
 endif()
diff --git a/gladius/src/ComputeContext.cpp b/gladius/src/ComputeContext.cpp
index ca50d4eb..6796d4e2 100644
--- a/gladius/src/ComputeContext.cpp
+++ b/gladius/src/ComputeContext.cpp
@@ -450,6 +450,8 @@ namespace gladius
                     throw ThreadQueueManagementError("queue insertion", currentThreadId);
                 }
 
+                (void) registerQueueIdLocked(result.first->second);
+
                 return result.first->second;
             }
             catch (OpenCLQueueCreationError const &)
@@ -482,6 +484,106 @@ namespace gladius
         return iter->second;
     }
 
+    GpuAccessCoordinator & ComputeContext::gpuAccessCoordinator()
+    {
+        return *m_gpuAccessCoordinator;
+    }
+
+    GpuAccessCoordinator const & ComputeContext::gpuAccessCoordinator() const
+    {
+        return *m_gpuAccessCoordinator;
+    }
+
+    GpuQueueId ComputeContext::getGpuQueueId(cl::CommandQueue const & queue) const
+    {
+        std::lock_guard<std::mutex> lock(m_queuesMutex);
+        return registerQueueIdLocked(queue);
+    }
+
+    GpuEventId ComputeContext::recordGpuEvent(cl::Event const & event)
+    {
+        return m_openClEventRegistry->record(event);
+    }
+
+    std::vector<cl::Event>
+    ComputeContext::gpuWaitEvents(std::vector<GpuEventId> const & eventIds) const
+    {
+        return m_openClEventRegistry->eventsFor(eventIds);
+    }
+
+    void ComputeContext::refreshGpuAccessEvents()
+    {
+        auto completedEvents = m_openClEventRegistry->pollCompleted();
+        if (!completedEvents.empty())
+        {
+            m_gpuAccessCoordinator->markEventsCompleted(completedEvents);
+            m_gpuAccessCoordinator->collectCompletedRetirements();
+        }
+    }
+
+    void ComputeContext::waitForGpuEvents(std::vector<GpuEventId> const & eventIds)
+    {
+        auto completedEvents = m_openClEventRegistry->waitFor(eventIds);
+        if (!completedEvents.empty())
+        {
+            m_gpuAccessCoordinator->markEventsCompleted(completedEvents);
+            m_gpuAccessCoordinator->collectCompletedRetirements();
+        }
+    }
+
+    void ComputeContext::waitForGpuResourceIdle(GpuResourceHandle const resource)
+    {
+        refreshGpuAccessEvents();
+
+        auto outstanding = m_gpuAccessCoordinator->outstandingEvents(resource);
+        if (!outstanding.empty())
+        {
+            waitForGpuEvents(outstanding);
+        }
+
+        if (m_gpuAccessCoordinator->isIdle(resource))
+        {
+            return;
+        }
+
+        finishAllQueues();
+        refreshGpuAccessEvents();
+
+        outstanding = m_gpuAccessCoordinator->outstandingEvents(resource);
+        if (!outstanding.empty())
+        {
+            waitForGpuEvents(outstanding);
+        }
+
+        if (!m_gpuAccessCoordinator->isIdle(resource) && m_logger)
+        {
+            m_logger->logWarning("GPU resource remained busy after finishing known queues");
+        }
+    }
+
+    void ComputeContext::waitForAllTrackedGpuWork()
+    {
+        auto completedEvents = m_openClEventRegistry->waitForAll();
+        if (!completedEvents.empty())
+        {
+            m_gpuAccessCoordinator->markEventsCompleted(completedEvents);
+        }
+
+        finishAllQueues();
+        refreshGpuAccessEvents();
+        m_gpuAccessCoordinator->collectCompletedRetirements();
+    }
+
+    void ComputeContext::setGpuAccessSafeModeEnabled(bool const enabled) noexcept
+    {
+        m_gpuAccessSafeModeEnabled = enabled;
+    }
+
+    bool ComputeContext::isGpuAccessSafeModeEnabled() const noexcept
+    {
+        return m_gpuAccessSafeModeEnabled;
+    }
+
     bool ComputeContext::isValid() const
     {
         return m_isValid;
@@ -531,6 +633,7 @@ namespace gladius
 
         // Clear all queues as they're now invalid
         m_queues.clear();
+        m_gpuQueueIds.clear();
     }
 
     bool ComputeContext::validateQueue(const cl::CommandQueue & queue) const
@@ -902,6 +1005,47 @@ namespace gladius
         }
     }
 
+    GpuQueueId ComputeContext::registerQueueIdLocked(cl::CommandQueue const & queue) const
+    {
+        auto const nativeQueue = queue();
+        if (nativeQueue == nullptr)
+        {
+            return 0u;
+        }
+
+        auto const queueIt = m_gpuQueueIds.find(nativeQueue);
+        if (queueIt != m_gpuQueueIds.end())
+        {
+            return queueIt->second;
+        }
+
+        GpuQueueId const queueId = m_nextGpuQueueId++;
+        m_gpuQueueIds.emplace(nativeQueue, queueId);
+        return queueId;
+    }
+
+    void ComputeContext::finishAllQueues() const
+    {
+        std::vector<cl::CommandQueue> queues;
+        {
+            std::lock_guard<std::mutex> lock(m_queuesMutex);
+            queues.reserve(m_queues.size());
+            for (auto const & [threadId, queue] : m_queues)
+            {
+                (void) threadId;
+                queues.push_back(queue);
+            }
+        }
+
+        for (auto const & queue : queues)
+        {
+            if (queue() != nullptr)
+            {
+                queue.finish();
+            }
+        }
+    }
+
     void ComputeContext::initContext()
     {
         cl::Platform defaultPlatform;
diff --git a/gladius/src/ComputeContext.h b/gladius/src/ComputeContext.h
index 62babc74..de5a0999 100644
--- a/gladius/src/ComputeContext.h
+++ b/gladius/src/ComputeContext.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include "gpgpu.h"
+#include "compute/GpuAccessCoordinator.h"
+#include "compute/OpenClEventRegistry.h"
 
 #include <filesystem>
 #include <memory>
@@ -103,6 +105,19 @@ namespace gladius
         /// @return A new command queue
         cl::CommandQueue createQueue() const;
 
+        [[nodiscard]] GpuAccessCoordinator & gpuAccessCoordinator();
+        [[nodiscard]] GpuAccessCoordinator const & gpuAccessCoordinator() const;
+
+        [[nodiscard]] GpuQueueId getGpuQueueId(cl::CommandQueue const & queue) const;
+        [[nodiscard]] GpuEventId recordGpuEvent(cl::Event const & event);
+        [[nodiscard]] std::vector<cl::Event> gpuWaitEvents(std::vector<GpuEventId> const & eventIds) const;
+        void refreshGpuAccessEvents();
+        void waitForGpuEvents(std::vector<GpuEventId> const & eventIds);
+        void waitForGpuResourceIdle(GpuResourceHandle resource);
+        void waitForAllTrackedGpuWork();
+        void setGpuAccessSafeModeEnabled(bool enabled) noexcept;
+        [[nodiscard]] bool isGpuAccessSafeModeEnabled() const noexcept;
+
         [[nodiscard]] bool isValid() const;
 
         [[nodiscard]] const cl::Device & GetDevice() const;
@@ -229,12 +244,16 @@ namespace gladius
         void initContextWithAccelerator(Accelerator const & accelerator);
         void queryDeviceMemoryCaps();
         bool tryQueryVendorFreeMem(size_t & freeBytesOut) const; // best-effort
+        [[nodiscard]] GpuQueueId registerQueueIdLocked(cl::CommandQueue const & queue) const;
+        void finishAllQueues() const;
 
         std::unique_ptr<cl::Context> m_context;
 
         // queue per thread
         QueuePerThread m_queues;
         mutable std::mutex m_queuesMutex;
+        mutable std::unordered_map<cl_command_queue, GpuQueueId> m_gpuQueueIds;
+        mutable GpuQueueId m_nextGpuQueueId{1u};
 
         cl::Device m_device;
         Capabilities m_capabilities{};
@@ -248,6 +267,7 @@ namespace gladius
 
         // Debug output control (instance-level)
         bool m_debugOutputEnabled{false};
+        bool m_gpuAccessSafeModeEnabled{true};
 
         // Device memory capabilities (queried at init)
         size_t m_deviceGlobalMemBytes{0};
@@ -262,6 +282,9 @@ namespace gladius
 
         // Event logger (optional)
         events::SharedLogger m_logger{};
+
+        std::shared_ptr<GpuAccessCoordinator> m_gpuAccessCoordinator{std::make_shared<GpuAccessCoordinator>()};
+        std::shared_ptr<OpenClEventRegistry> m_openClEventRegistry{std::make_shared<OpenClEventRegistry>()};
     };
 
     using SharedComputeContext = std::shared_ptr<ComputeContext>;
diff --git a/gladius/src/Document.cpp b/gladius/src/Document.cpp
index 853019b8..625129d6 100644
--- a/gladius/src/Document.cpp
+++ b/gladius/src/Document.cpp
@@ -1,5 +1,7 @@
 #include "Document.h"
 
+#include "io/3mf/Lib3mfLoader.h"
+
 #include "BackupManager.h"
 #include "CliReader.h"
 #include "CliWriter.h"
@@ -291,6 +293,39 @@ namespace gladius
         m_backupManager.initialize();
     }
 
+    Document::~Document()
+    {
+        // Join in-flight async workers before any member is destroyed. The workers
+        // (refreshWorker / file-load) capture `this` and touch members such as
+        // m_isLoading, m_loadingError and m_buildItems that are declared after the
+        // future members. Relying on the implicit std::future destructors to join
+        // would do so only after those later-declared members are already gone,
+        // producing a use-after-free during shutdown.
+        try
+        {
+            if (m_futureModelRefresh.valid())
+            {
+                m_futureModelRefresh.wait();
+            }
+        }
+        catch (...)
+        {
+            // Never throw from a destructor.
+        }
+
+        try
+        {
+            if (m_futureFileLoad.valid())
+            {
+                m_futureFileLoad.wait();
+            }
+        }
+        catch (...)
+        {
+            // Never throw from a destructor.
+        }
+    }
+
     bool Document::refreshModelAsync()
     {
         if (!m_assembly || !m_core)
@@ -298,8 +333,14 @@ namespace gladius
             return false;
         }
 
-        // Validation moved to refreshWorker() to avoid blocking the UI thread.
-        // The worker validates first and exits early if the model is invalid.
+        // Run a lightweight graph sync + validation pass before scheduling any
+        // background refresh work. This keeps invalid graphs from entering the
+        // expensive payload/compile path and avoids transient "compiling"
+        // states while the user is still resolving graph issues.
+        if (!prepareAssemblyForRefresh())
+        {
+            return false;
+        }
 
         // Signal compilation started on the UI thread BEFORE launching the worker.
         // This ensures isRendererReady() returns false immediately, preventing
@@ -336,6 +377,59 @@ namespace gladius
         return true;
     }
 
+    bool Document::prepareAssemblyForRefresh(nodes::ValidationContext const context)
+    {
+        if (!m_assembly)
+        {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> const lock(m_assemblyMutex);
+
+        std::optional<std::string> syncError;
+        try
+        {
+            m_assembly->updateInputsAndOutputs();
+        }
+        catch (std::exception const & e)
+        {
+            syncError = e.what();
+        }
+
+        markValidationDirty();
+        bool const graphValid = validateAssemblyIfDirty(context);
+
+        if (!syncError.has_value())
+        {
+            return graphValid;
+        }
+
+        nodes::ValidationIssue issue{};
+        issue.message = *syncError;
+        issue.type = nodes::IssueType::GraphSyncError;
+        if (syncError->find("function") != std::string::npos ||
+            syncError->find("Function") != std::string::npos)
+        {
+            issue.type = nodes::IssueType::FunctionNotFound;
+        }
+        issue.severity = nodes::IssueSeverity::Error;
+        issue.fixSuggestion = nodes::getFixSuggestion(issue.type);
+        issue.modelId = 0u;
+        issue.nodeId = {};
+        m_issueList.add(std::move(issue));
+
+        if (context != nodes::ValidationContext::Interactive)
+        {
+            auto logger = getSharedLogger();
+            if (logger)
+            {
+                logger->addEvent({*syncError, events::Severity::Error});
+            }
+        }
+
+        return false;
+    }
+
     void Document::loadAllMeshResources()
     {
         io::Importer3mf importer{getSharedLogger()};
@@ -369,13 +463,8 @@ namespace gladius
     void Document::refreshWorker(RefreshMode const refreshMode)
     {
         ProfileFunction;
-        auto computeToken = m_core->waitForComputeToken();
-        ScopedOptimizedRenderCompilationDeferral optimizedRenderDeferral{
-          *m_core,
-          refreshMode == RefreshMode::InteractiveFirst};
 
         auto meshResourceState = m_core->getMeshResourceState();
-        meshResourceState->signalCompilationStarted();
 
         // Capture the structural edit epoch at the start of this worker run.
         // If a new structural edit arrives while we're working, the epoch will
@@ -386,10 +475,15 @@ namespace gladius
             return m_structuralEditEpoch.load(std::memory_order_acquire) != startEpoch;
         };
 
-        // Validate early: skip expensive compilation if model is in an invalid
-        // state (e.g. nodes with missing connections during graph editing).
-        // This used to run on the UI thread; running here avoids blocking it.
-        if (!validateAssembly())
+        if (isStale())
+        {
+            meshResourceState->signalCompilationFinished();
+            return;
+        }
+
+        // Validate before taking the compute token so invalid graphs can fail
+        // fast without waiting on in-flight GPU work.
+        if (!prepareAssemblyForRefresh())
         {
             meshResourceState->signalCompilationFinished();
             return;
@@ -401,7 +495,12 @@ namespace gladius
             return;
         }
 
-        m_assembly->updateInputsAndOutputs();
+        auto computeToken = m_core->waitForComputeToken();
+        ScopedOptimizedRenderCompilationDeferral optimizedRenderDeferral{
+          *m_core,
+          refreshMode == RefreshMode::InteractiveFirst};
+
+        meshResourceState->signalCompilationStarted();
 
         // Build the lightweight 3MF resource dependency graph before extracting
         // mesh geometry, so loadAllMeshResources() can skip meshes that are not
@@ -651,9 +750,30 @@ namespace gladius
     bool Document::refreshModelIfNoCompilationIsRunning()
     {
         ProfileFunction;
-        if (m_core->getBestRenderProgram()->isCompilationInProgress() ||
-            m_core->getSlicerProgram()->isCompilationInProgress() ||
-            !m_core->getMeshResourceState()->isModelUpToDate())
+
+        // This method is called from the UI frame loop. Only use non-blocking probes here;
+        // the background load/refresh worker can hold the compute token for several seconds
+        // while importing meshes and preparing GPU resources.
+        if (m_core->isAnyCompilationInProgressNonBlocking())
+        {
+            return false;
+        }
+
+        auto const meshResourceState = m_core->getMeshResourceState();
+        if (meshResourceState && !meshResourceState->isModelUpToDate())
+        {
+            return false;
+        }
+
+        {
+            auto computeToken = m_core->requestComputeToken();
+            if (!computeToken.has_value())
+            {
+                return false;
+            }
+        }
+
+        if (m_core->isAnyCompilationInProgressNonBlocking())
         {
             return false;
         }
@@ -664,6 +784,7 @@ namespace gladius
     void Document::newModel()
     {
         ProfileFunction;
+        m_documentIdentity.fetch_add(1, std::memory_order_acq_rel);
         {
 
             m_assembly = std::make_shared<nodes::Assembly>();
@@ -684,6 +805,7 @@ namespace gladius
     void Document::newEmptyModel()
     {
         ProfileFunction;
+        m_documentIdentity.fetch_add(1, std::memory_order_acq_rel);
         {
 
             m_assembly = std::make_shared<nodes::Assembly>();
@@ -1039,6 +1161,7 @@ namespace gladius
     void Document::markFileAsChanged()
     {
         m_fileChanged = true;
+        m_saveVersion.fetch_add(1, std::memory_order_release);
         m_validationDirty = true;
     }
 
@@ -1261,6 +1384,63 @@ namespace gladius
         }
     }
 
+    io::SaveSnapshot Document::createSaveSnapshot() const
+    {
+        auto assemblyToken = waitForAssemblyToken();
+        if (!m_assembly)
+        {
+            throw std::runtime_error("Cannot create save snapshot without an assembly");
+        }
+        if (!m_3mfmodel)
+        {
+            throw std::runtime_error("Cannot create save snapshot without a 3MF model");
+        }
+
+        auto const wrapper = io::loadLib3mfScoped();
+        auto const writer = m_3mfmodel->QueryWriter("3mf");
+        std::vector<Lib3MF_uint8> buffer;
+        writer->WriteToBuffer(buffer);
+
+        auto modelCopy = wrapper->CreateModel();
+        auto reader = modelCopy->QueryReader("3mf");
+        reader->ReadFromBuffer(buffer);
+
+        io::SaveSnapshot snapshot;
+        snapshot.assembly = std::make_shared<nodes::Assembly>(*m_assembly);
+        snapshot.model = std::move(modelCopy);
+        snapshot.documentIdentity = documentIdentity();
+        snapshot.version = saveVersion();
+        return snapshot;
+    }
+
+    uint64_t Document::saveVersion() const
+    {
+        return m_saveVersion.load(std::memory_order_acquire);
+    }
+
+    io::DocumentIdentity Document::documentIdentity() const
+    {
+        return m_documentIdentity.load(std::memory_order_acquire);
+    }
+
+    bool Document::completeSave(std::filesystem::path filename,
+                                io::DocumentIdentity snapshotDocumentIdentity,
+                                uint64_t snapshotVersion)
+    {
+        if (documentIdentity() != snapshotDocumentIdentity || saveVersion() != snapshotVersion)
+        {
+            return false;
+        }
+
+        m_currentAssemblyFileName = filename;
+        m_fileChanged = false;
+        if (m_assembly)
+        {
+            m_assembly->setFilename(filename);
+        }
+        return true;
+    }
+
     nodes::SharedAssembly Document::getAssembly() const
     {
 
@@ -1456,6 +1636,62 @@ namespace gladius
         return summary;
     }
 
+    MeshQualityIssueSummary Document::getMeshQualityIssueSummary() const
+    {
+        MeshQualityIssueSummary summary{};
+        std::string firstMessage;
+
+        for (auto const & [key, resource] : getResourceManager().getResourceMap())
+        {
+            if (key.getResourceType() != ResourceType::Mesh)
+            {
+                continue;
+            }
+
+            auto const * spatialMesh = dynamic_cast<SpatialMeshResource const *>(resource.get());
+            if (spatialMesh == nullptr || !spatialMesh->hasMeshQualityIssues())
+            {
+                continue;
+            }
+
+            ++summary.affectedMeshCount;
+            summary.hasIssue = true;
+
+            auto const & quality = spatialMesh->getMeshQualityDiagnostics();
+            summary.degenerateTriangleCount +=
+              static_cast<std::size_t>(quality.degenerateTriangleCount);
+            summary.boundaryEdgeCount += static_cast<std::size_t>(quality.boundaryEdgeCount);
+            summary.nonManifoldEdgeCount +=
+              static_cast<std::size_t>(quality.nonManifoldEdgeCount);
+
+            if (firstMessage.empty())
+            {
+                firstMessage = spatialMesh->formatMeshQualityMessage(key.getDisplayName());
+            }
+        }
+
+        if (!summary.hasIssue)
+        {
+            return summary;
+        }
+
+        if (summary.affectedMeshCount == 1u)
+        {
+            summary.message = std::move(firstMessage);
+            return summary;
+        }
+
+        summary.message = fmt::format(
+          "Mesh topology diagnostics affect {} mesh resources ({} boundary edges, {} "
+          "non-manifold edges, {} degenerate triangles total). First issue: {}",
+          summary.affectedMeshCount,
+          summary.boundaryEdgeCount,
+          summary.nonManifoldEdgeCount,
+          summary.degenerateTriangleCount,
+          firstMessage);
+        return summary;
+    }
+
     events::SharedLogger Document::getSharedLogger() const
     {
         if (!m_core)
@@ -1720,6 +1956,7 @@ namespace gladius
 
         if (filename.extension() == ".3mf")
         {
+            m_documentIdentity.fetch_add(1, std::memory_order_acq_rel);
             {
 
                 m_assembly = {};
@@ -1819,6 +2056,27 @@ namespace gladius
                     ++changedResources;
                 }
 
+                if (spatialMesh->evaluationConfig().method == MeshSdfMethod::NanoVDB &&
+                    spatialMesh->hasMeshQualityIssues())
+                {
+                    auto const message = spatialMesh->formatMeshQualityMessage(
+                      key.getDisplayName());
+                    auto logger = getSharedLogger();
+                    if (logger)
+                    {
+                        logger->addEvent(
+                          {message,
+                           nanovdbBuildPolicy.failurePolicy == NanoVdbFailurePolicy::Fail
+                             ? events::Severity::Error
+                             : events::Severity::Warning});
+                    }
+
+                    if (nanovdbBuildPolicy.failurePolicy == NanoVdbFailurePolicy::Fail)
+                    {
+                        throw NanoVdbBuildRejectedError(message);
+                    }
+                }
+
                 if (changed && spatialMesh->evaluationConfig().method == MeshSdfMethod::NanoVDB &&
                     spatialMesh->hasNanoVdbBuildIssue())
                 {
@@ -2665,6 +2923,11 @@ namespace gladius
 
     bool Document::dispatchStructuralUpdate()
     {
+        if (!prepareAssemblyForRefresh())
+        {
+            return false;
+        }
+
         if (refreshModelIfNoCompilationIsRunning())
         {
             return true;
diff --git a/gladius/src/Document.h b/gladius/src/Document.h
index 4e1eaa61..ddd7efd9 100644
--- a/gladius/src/Document.h
+++ b/gladius/src/Document.h
@@ -8,6 +8,7 @@
 #include "io/3mf/Importer3mf.h"
 #include "io/3mf/ImageStackCreator.h"
 #include "io/3mf/ResourceDependencyGraph.h"
+#include "io/3mf/SaveSnapshot.h"
 #include "io/SurfaceExtractionOptions.h"
 #include "nodes/Assembly.h"
 #include "nodes/BuildItem.h"
@@ -129,6 +130,14 @@ namespace gladius
 
         void resetGeneratorContext();
         explicit Document(std::shared_ptr<ComputeCore> core);
+
+        /// Blocks until any in-flight asynchronous file-load / model-refresh worker
+        /// has finished before member teardown begins. Without this, the implicit
+        /// std::future destructors join the workers only after members declared after
+        /// them (e.g. m_isLoading, m_buildItems) are already destroyed, which is a
+        /// use-after-free hazard while the worker is still running.
+        ~Document();
+
         [[nodiscard]] bool refreshModelIfNoCompilationIsRunning();
 
         /// Signal that a structural graph edit occurred.
@@ -177,6 +186,26 @@ namespace gladius
         [[nodiscard]] std::string getLoadingError() const;
         void saveAs(std::filesystem::path filename, bool writeThumbnail = true);
 
+        /**
+         * @brief Captures independent document data for background native 3MF serialization.
+         * @throws std::runtime_error if the document has no assembly or Lib3MF model.
+         */
+        [[nodiscard]] io::SaveSnapshot createSaveSnapshot() const;
+
+        /// @return Monotonically increasing version of persisted document changes.
+        [[nodiscard]] uint64_t saveVersion() const;
+
+        /// @return Identity of the logical document contents currently loaded in this object.
+        [[nodiscard]] io::DocumentIdentity documentIdentity() const;
+
+        /**
+         * @brief Applies bookkeeping for a completed background save.
+         * @return true when the saved snapshot is still the current document version.
+         */
+        bool completeSave(std::filesystem::path filename,
+                  io::DocumentIdentity snapshotDocumentIdentity,
+                  uint64_t snapshotVersion);
+
         void newModel();
         void newEmptyModel();
         void newFromTemplate();
@@ -459,6 +488,9 @@ namespace gladius
         /// Summarize NanoVDB build issues on currently loaded mesh resources, if any.
         [[nodiscard]] NanoVdbBuildIssueSummary getNanoVdbBuildIssueSummary() const;
 
+        /// Summarize mesh topology diagnostics on currently loaded mesh resources, if any.
+        [[nodiscard]] MeshQualityIssueSummary getMeshQualityIssueSummary() const;
+
         /// Queue applying the mesh-SDF evaluation configuration to existing mesh resources.
         /// Heavy resource rebuild/upload work is folded into the debounced background refresh so
         /// the UI can keep showing the current preview.
@@ -482,6 +514,8 @@ namespace gladius
         void loadImpl(const std::filesystem::path & filename);
         void mergeImpl(const std::filesystem::path & filename);
         [[nodiscard]] bool refreshModelAsync();
+                [[nodiscard]] bool prepareAssemblyForRefresh(
+                    nodes::ValidationContext context = nodes::ValidationContext::Interactive);
         void loadAllMeshResources();
         void refreshWorker(RefreshMode refreshMode = RefreshMode::Normal);
         [[nodiscard]] std::optional<MeshSdfEvaluationConfig> takePendingMeshSdfEvaluationConfig();
@@ -503,6 +537,8 @@ namespace gladius
         std::optional<std::filesystem::path> m_currentAssemblyFileName;
         std::shared_ptr<ComputeCore> m_core;
         bool m_fileChanged{false};
+        std::atomic<uint64_t> m_saveVersion{0};
+        std::atomic<io::DocumentIdentity> m_documentIdentity{0};
         std::atomic<bool> m_parameterDirty{false};
         std::atomic<bool> m_contoursDirty{false};
 
diff --git a/gladius/src/GLImageBuffer.cpp b/gladius/src/GLImageBuffer.cpp
index 8d4de96f..2872ed8f 100644
--- a/gladius/src/GLImageBuffer.cpp
+++ b/gladius/src/GLImageBuffer.cpp
@@ -38,7 +38,10 @@ namespace gladius
         if (m_ComputeContext.outputMethod() == OutputMethod::readpixel)
         {
             setupForReadPixel();
+            write();
         }
+
+        m_dirty = false;
     }
 
     GLImageBuffer::~GLImageBuffer()
diff --git a/gladius/src/ImageRGBA.h b/gladius/src/ImageRGBA.h
index 49f4851e..8d97b8d6 100644
--- a/gladius/src/ImageRGBA.h
+++ b/gladius/src/ImageRGBA.h
@@ -6,6 +6,8 @@
 #include <algorithm>
 #include <cmath>
 #include <iostream>
+#include <stdexcept>
+#include <typeinfo>
 #include <vector>
 
 namespace gladius
@@ -19,6 +21,8 @@ namespace gladius
             , m_height(512)
             , m_size(m_width * m_height * m_depth)
             , m_ComputeContext(context)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                resourceKindForDepth(m_depth), typeid(ImageDataPoint).name()))
         {
         }
 
@@ -27,6 +31,8 @@ namespace gladius
             , m_height(height)
             , m_size(m_width * m_height * m_depth)
             , m_ComputeContext(ComputeContext)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                resourceKindForDepth(m_depth), typeid(ImageDataPoint).name()))
         {
         }
 
@@ -36,6 +42,8 @@ namespace gladius
             , m_depth(depth)
             , m_size(m_width * m_height * m_depth)
             , m_ComputeContext(ComputeContext)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                resourceKindForDepth(m_depth), typeid(ImageDataPoint).name()))
         {
         }
 
@@ -43,11 +51,15 @@ namespace gladius
         ImageImpl(ImageImpl<ImageDataPoint> & src)
             : m_width(src.getWidth())
             , m_height(src.getHeight())
-            , m_size(m_width * m_height)
+            , m_depth(src.getDepth())
+            , m_size(m_width * m_height * m_depth)
             , m_ComputeContext(src.m_ComputeContext)
+            , m_gpuResource(m_ComputeContext.gpuAccessCoordinator().registerResource(
+                resourceKindForDepth(m_depth), typeid(ImageDataPoint).name()))
         {
             ImageImpl<ImageDataPoint>::allocateOnDevice();
 
+            m_ComputeContext.waitForGpuResourceIdle(src.gpuResourceHandle());
             CL_ERROR(m_ComputeContext.GetQueue().enqueueCopyImage(
               src.getBuffer(), getBuffer(), {0, 0, 0}, {0, 0, 0}, {m_width, m_height, m_depth}));
             CL_ERROR(m_ComputeContext.GetQueue().finish());
@@ -55,10 +67,18 @@ namespace gladius
 
         virtual ~ImageImpl()
         {
-            if (m_buffer && m_allocatedBytes > 0)
+            try
             {
-                m_ComputeContext.onBufferReleased(m_allocatedBytes);
-                m_allocatedBytes = 0;
+                if (m_buffer && m_allocatedBytes > 0)
+                {
+                    m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+                    m_ComputeContext.onBufferReleased(m_allocatedBytes);
+                    m_allocatedBytes = 0;
+                }
+            }
+            catch (...)
+            {
+                // Destructors must not throw.
             }
         }
 
@@ -75,6 +95,7 @@ namespace gladius
 
         void read()
         {
+            m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
             CL_ERROR(m_ComputeContext.GetQueue().finish());
             CL_ERROR(m_ComputeContext.GetQueue().enqueueReadImage(
               *m_buffer, CL_TRUE, {0, 0, 0}, {m_width, m_height, m_depth}, 0, 0, m_data.data()));
@@ -83,6 +104,7 @@ namespace gladius
 
         void write()
         {
+            retireCurrentGpuGeneration();
             CL_ERROR(m_ComputeContext.GetQueue().finish());
             CL_ERROR(m_ComputeContext.GetQueue().enqueueWriteImage(
               *m_buffer, CL_TRUE, {0, 0, 0}, {m_width, m_height, m_depth}, 0, 0, m_data.data()));
@@ -103,6 +125,7 @@ namespace gladius
             // If re-allocating, release previous accounting tracked
             if (m_buffer && m_allocatedBytes > 0)
             {
+                retireCurrentGpuGeneration();
                 m_ComputeContext.onBufferReleased(m_allocatedBytes);
                 m_allocatedBytes = 0;
             }
@@ -192,6 +215,11 @@ namespace gladius
             return m_buffer.get();
         }
 
+        [[nodiscard]] GpuResourceHandle gpuResourceHandle() const noexcept
+        {
+            return m_gpuResource;
+        }
+
         [[nodiscard]] size_t getWidth() const
         {
             return m_width;
@@ -242,9 +270,39 @@ namespace gladius
         ComputeContext & m_ComputeContext;
         std::unique_ptr<cl::Image> m_buffer;
 
+        GpuResourceHandle m_gpuResource{};
+
         // Track bytes accounted in ComputeContext for this device image
         size_t m_allocatedBytes{0};
 
+        void retireCurrentGpuGeneration()
+        {
+            m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+
+            auto retirement = m_ComputeContext.gpuAccessCoordinator().retireCurrentGeneration(
+              m_gpuResource.resourceId);
+            if (retirement.status == GpuAccessStatus::PendingAccessWithoutEvent)
+            {
+                m_ComputeContext.waitForGpuResourceIdle(m_gpuResource);
+                retirement = m_ComputeContext.gpuAccessCoordinator().retireCurrentGeneration(
+                  m_gpuResource.resourceId);
+            }
+
+            if (!retirement.granted())
+            {
+                throw std::runtime_error("Failed to retire GPU image generation safely");
+            }
+
+            m_ComputeContext.waitForGpuEvents(retirement.waitEvents);
+            m_ComputeContext.gpuAccessCoordinator().collectCompletedRetirements();
+            m_gpuResource = retirement.newGeneration;
+        }
+
+        [[nodiscard]] static GpuResourceKind resourceKindForDepth(size_t const depth) noexcept
+        {
+            return depth > 1u ? GpuResourceKind::Image3D : GpuResourceKind::Image2D;
+        }
+
         static cl::ImageFormat determineImageFormat()
         {
             if constexpr (std::is_same_v<ImageDataPoint, cl_int>)
diff --git a/gladius/src/MeshBVH.cpp b/gladius/src/MeshBVH.cpp
index bd89f3b6..d2769968 100644
--- a/gladius/src/MeshBVH.cpp
+++ b/gladius/src/MeshBVH.cpp
@@ -9,6 +9,7 @@
 #include <chrono>
 #include <cmath>
 #include <cstdint>
+#include <cstring>
 #include <limits>
 #include <numbers>
 #include <numeric>
@@ -16,6 +17,96 @@
 
 namespace gladius
 {
+    namespace
+    {
+        std::uint32_t floatKeyBits(float const value) noexcept
+        {
+            float normalized = value;
+            if (normalized == 0.0f)
+            {
+                normalized = 0.0f; // canonicalise -0.0f to +0.0f
+            }
+
+            std::uint32_t bits = 0u;
+            std::memcpy(&bits, &normalized, sizeof(bits));
+            return bits;
+        }
+
+        struct PointKey
+        {
+            std::uint32_t x = 0u;
+            std::uint32_t y = 0u;
+            std::uint32_t z = 0u;
+
+            bool operator==(PointKey const & other) const noexcept
+            {
+                return x == other.x && y == other.y && z == other.z;
+            }
+        };
+
+        struct PointKeyHash
+        {
+            std::size_t operator()(PointKey const & key) const noexcept
+            {
+                std::size_t seed = std::hash<std::uint32_t>{}(key.x);
+                seed ^= std::hash<std::uint32_t>{}(key.y) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
+                seed ^= std::hash<std::uint32_t>{}(key.z) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
+                return seed;
+            }
+        };
+
+        [[nodiscard]] PointKey makePointKey(float4 const & point) noexcept
+        {
+            return PointKey{floatKeyBits(point.x), floatKeyBits(point.y), floatKeyBits(point.z)};
+        }
+
+        [[nodiscard]] bool lessPointKey(PointKey const & lhs, PointKey const & rhs) noexcept
+        {
+            if (lhs.x != rhs.x)
+            {
+                return lhs.x < rhs.x;
+            }
+            if (lhs.y != rhs.y)
+            {
+                return lhs.y < rhs.y;
+            }
+            return lhs.z < rhs.z;
+        }
+
+        struct EdgeKey
+        {
+            PointKey a;
+            PointKey b;
+
+            bool operator==(EdgeKey const & other) const noexcept
+            {
+                return a == other.a && b == other.b;
+            }
+        };
+
+        struct EdgeKeyHash
+        {
+            std::size_t operator()(EdgeKey const & key) const noexcept
+            {
+                std::size_t seed = PointKeyHash{}(key.a);
+                auto const bHash = PointKeyHash{}(key.b);
+                seed ^= bHash + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
+                return seed;
+            }
+        };
+
+        [[nodiscard]] EdgeKey makeEdgeKey(float4 const & lhs, float4 const & rhs) noexcept
+        {
+            auto a = makePointKey(lhs);
+            auto b = makePointKey(rhs);
+            if (lessPointKey(b, a))
+            {
+                std::swap(a, b);
+            }
+            return EdgeKey{a, b};
+        }
+    }
+
     // ========================================================================
     // Build Context
     // ========================================================================
@@ -197,6 +288,10 @@ namespace gladius
             ? static_cast<float>(totalLeafPrims) / static_cast<float>(m_lastStats.leafNodes)
             : 0.0f;
 
+        result.quality.degenerateTriangleCount = m_lastStats.degenerateTriangleCount;
+        result.quality.boundaryEdgeCount = m_lastStats.boundaryEdgeCount;
+        result.quality.nonManifoldEdgeCount = m_lastStats.nonManifoldEdgeCount;
+
         return result;
     }
 
@@ -219,6 +314,32 @@ namespace gladius
             vn.normal = {0.0f, 0.0f, 0.0f, 0.0f};
         }
 
+        struct AccumulatedNormal
+        {
+            float x = 0.0f;
+            float y = 0.0f;
+            float z = 0.0f;
+        };
+
+        // Accumulate by exact vertex position, not only by vertex index. Many STL-style
+        // triangle soups duplicate vertex records per face while still being geometrically
+        // watertight. Exact positional grouping preserves deterministic behaviour without
+        // silently modifying the mesh like a weld repair would.
+        std::unordered_map<PointKey, AccumulatedNormal, PointKeyHash> normalSums;
+        normalSums.reserve(vertexCount);
+
+        auto const addNormal = [&](float4 const & vertex,
+                                   float const angle,
+                                   float const normalX,
+                                   float const normalY,
+                                   float const normalZ)
+        {
+            auto & sum = normalSums[makePointKey(vertex)];
+            sum.x += angle * normalX;
+            sum.y += angle * normalY;
+            sum.z += angle * normalZ;
+        };
+
         // Accumulate angle-weighted face normals for each vertex
         for (size_t i = 0; i < indices.size(); ++i)
         {
@@ -278,23 +399,23 @@ namespace gladius
             float angle2 = std::numbers::pi_v<float> - angle0 - angle1;
 
             // Add weighted face normal to each vertex
-            data.vertexNormals[idx.i0].normal.x += angle0 * fnx;
-            data.vertexNormals[idx.i0].normal.y += angle0 * fny;
-            data.vertexNormals[idx.i0].normal.z += angle0 * fnz;
-
-            data.vertexNormals[idx.i1].normal.x += angle1 * fnx;
-            data.vertexNormals[idx.i1].normal.y += angle1 * fny;
-            data.vertexNormals[idx.i1].normal.z += angle1 * fnz;
-
-            data.vertexNormals[idx.i2].normal.x += angle2 * fnx;
-            data.vertexNormals[idx.i2].normal.y += angle2 * fny;
-            data.vertexNormals[idx.i2].normal.z += angle2 * fnz;
+            addNormal(p0, angle0, fnx, fny, fnz);
+            addNormal(p1, angle1, fnx, fny, fnz);
+            addNormal(p2, angle2, fnx, fny, fnz);
         }
 
         // Normalize all vertex normals
         for (size_t i = 0; i < vertexCount; ++i)
         {
             auto & n = data.vertexNormals[i].normal;
+            auto const it = normalSums.find(makePointKey(vertices[i]));
+            if (it != normalSums.end())
+            {
+                n.x = it->second.x;
+                n.y = it->second.y;
+                n.z = it->second.z;
+            }
+
             float len = std::sqrt(n.x * n.x + n.y * n.y + n.z * n.z);
             if (len > 1e-10f)
             {
@@ -357,24 +478,6 @@ namespace gladius
             faceNormals[t] = float4{fnx * invLen, fny * invLen, fnz * invLen, 1.0f};
         }
 
-        // Hash undirected edges to (triIdx, edgeIdx). On second hit we know both sides.
-        struct EdgeKey
-        {
-            uint64_t key;
-            bool operator==(EdgeKey const & o) const { return key == o.key; }
-        };
-        struct EdgeKeyHash
-        {
-            size_t operator()(EdgeKey const & k) const noexcept { return std::hash<uint64_t>{}(k.key); }
-        };
-
-        auto const makeKey = [](uint32_t a, uint32_t b) -> EdgeKey
-        {
-            uint32_t lo = std::min(a, b);
-            uint32_t hi = std::max(a, b);
-            return EdgeKey{(static_cast<uint64_t>(hi) << 32) | static_cast<uint64_t>(lo)};
-        };
-
         struct EdgeRef
         {
             int triIdx;
@@ -395,7 +498,7 @@ namespace gladius
             for (int e = 0; e < 3; ++e)
             {
                 auto [va, vb] = edgeVertices(idx, e);
-                EdgeKey const key = makeKey(va, vb);
+                EdgeKey const key = makeEdgeKey(vertices[va], vertices[vb]);
                 edgeMap[key].push_back(EdgeRef{static_cast<int>(t), e});
             }
         }
diff --git a/gladius/src/MeshBVH.h b/gladius/src/MeshBVH.h
index 68208c01..238a671a 100644
--- a/gladius/src/MeshBVH.h
+++ b/gladius/src/MeshBVH.h
@@ -139,6 +139,24 @@ namespace gladius
         }
     };
 
+    /// Topology diagnostics that affect deterministic signed-distance evaluation.
+    struct MeshQualityDiagnostics
+    {
+        /// Number of triangles skipped during normal computation due to a degenerate
+        /// edge length or zero face-normal magnitude.
+        int degenerateTriangleCount = 0;
+        /// Number of undirected edges incident to exactly one face (open boundary).
+        int boundaryEdgeCount = 0;
+        /// Number of undirected edges incident to three or more faces (non-manifold).
+        int nonManifoldEdgeCount = 0;
+
+        [[nodiscard]] bool hasIssues() const noexcept
+        {
+            return degenerateTriangleCount != 0 || boundaryEdgeCount != 0 ||
+                   nonManifoldEdgeCount != 0;
+        }
+    };
+
     /// Host-side container for mesh BVH data before serialization
     struct SpatialMeshData
     {
@@ -150,6 +168,7 @@ namespace gladius
         std::vector<MeshBVHFwnAggregate> fwnAggregates;          ///< 1 aggregate per BVH node (same order as nodes); empty when not built
         size_t originalTriangleCount = 0;         ///< Source mesh triangle count
         BoundingBox boundingBox;                  ///< Axis-aligned bounding box
+        MeshQualityDiagnostics quality;           ///< Topology diagnostics collected during BVH construction
 
         /// Check if data is empty
         bool empty() const
diff --git a/gladius/src/MeshSdfMethod.h b/gladius/src/MeshSdfMethod.h
index 6a92d60e..f12d1d76 100644
--- a/gladius/src/MeshSdfMethod.h
+++ b/gladius/src/MeshSdfMethod.h
@@ -106,6 +106,19 @@ namespace gladius
         float suggestedVoxelSize_mm = 0.0f;
     };
 
+    /// User-facing aggregate of mesh topology diagnostics that can make signed-distance
+    /// evaluation ambiguous unless the mesh is repaired or an orientation-independent
+    /// sign strategy is selected.
+    struct MeshQualityIssueSummary
+    {
+        bool hasIssue = false;
+        std::size_t affectedMeshCount = 0u;
+        std::size_t degenerateTriangleCount = 0u;
+        std::size_t boundaryEdgeCount = 0u;
+        std::size_t nonManifoldEdgeCount = 0u;
+        std::string message;
+    };
+
     /// Raised when a strict NanoVDB policy rejects the requested load/build.
     class NanoVdbBuildRejectedError : public std::runtime_error
     {
diff --git a/gladius/src/MeshVoxelGridManager.cpp b/gladius/src/MeshVoxelGridManager.cpp
index 375be609..82eaccda 100644
--- a/gladius/src/MeshVoxelGridManager.cpp
+++ b/gladius/src/MeshVoxelGridManager.cpp
@@ -5,6 +5,7 @@
 #include "MeshVoxelGridManager.h"
 
 #include "CLProgram.h"
+#include "compute/GpuKernelAccessGuard.h"
 
 namespace gladius
 {
@@ -13,35 +14,48 @@ namespace gladius
     {
     }
 
-    bool MeshVoxelGridManager::buildGrid(CLProgram& program,
-                                          cl::Buffer& primitiveDataBuffer,
-                                          MeshVoxelGridBuildParams const& params)
+    bool MeshVoxelGridManager::buildGrid(CLProgram & program,
+                                         PrimitiveDataBuffer & primitiveData,
+                                         MeshVoxelGridBuildParams const & params)
     {
         if (params.voxelCount <= 0)
         {
-            return false;  // No voxels to build
+            return false; // No voxels to build
         }
-        
+
         // Run the build kernel
         // Global work size = total voxels
         cl::NDRange const globalRange(static_cast<size_t>(params.voxelCount));
-        
-        cl::Event event = program.runNonBlocking(m_context->GetQueue(),
-                                                  "buildMeshVoxelGrid",
-                                                  cl::NullRange,
-                                                  globalRange,
-                                                  primitiveDataBuffer,
-                                                  params.headerStart,
-                                                  params.voxelDataOffset,
-                                                  params.nodesOffset,
-                                                  params.trianglesOffset,
-                                                  params.normalsOffset,
-                                                  params.indicesOffset,
-                                                  params.edgeNeighborsOffset,
-                                                  params.nodeCount,
-                                                  params.triCount,
-                                                  params.vertexNormalCount);
-        
+
+        auto const & queue = m_context->GetQueue();
+        GpuKernelAccessGuard gpuAccess(
+          *m_context,
+          queue,
+          "buildMeshVoxelGrid",
+          {{primitiveData.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+        if (!gpuAccess.granted())
+        {
+            return false;
+        }
+
+        cl::Event event = program.runNonBlockingWithWaitList(queue,
+                                                             "buildMeshVoxelGrid",
+                                                             cl::NullRange,
+                                                             globalRange,
+                                                             gpuAccess.waitEvents(),
+                                                             primitiveData.getBuffer(),
+                                                             params.headerStart,
+                                                             params.voxelDataOffset,
+                                                             params.nodesOffset,
+                                                             params.trianglesOffset,
+                                                             params.normalsOffset,
+                                                             params.indicesOffset,
+                                                             params.edgeNeighborsOffset,
+                                                             params.nodeCount,
+                                                             params.triCount,
+                                                             params.vertexNormalCount);
+        gpuAccess.complete(event);
+
         // Check if the event is valid (non-null cl_event indicates success)
         return event() != nullptr;
     }
@@ -51,19 +65,20 @@ namespace gladius
         m_buildQueue.push_back(params);
     }
 
-    void MeshVoxelGridManager::executeQueuedBuilds(CLProgram& program, cl::Buffer& primitiveDataBuffer)
+    void MeshVoxelGridManager::executeQueuedBuilds(CLProgram & program,
+                                                   PrimitiveDataBuffer & primitiveData)
     {
-        for (auto const& params : m_buildQueue)
+        for (auto const & params : m_buildQueue)
         {
-            buildGrid(program, primitiveDataBuffer, params);
+            buildGrid(program, primitiveData, params);
         }
-        
+
         // Wait for all builds to complete
         if (!m_buildQueue.empty())
         {
             CL_ERROR(m_context->GetQueue().finish());
         }
-        
+
         m_buildQueue.clear();
     }
 
diff --git a/gladius/src/MeshVoxelGridManager.h b/gladius/src/MeshVoxelGridManager.h
index 644d5663..7328ec9c 100644
--- a/gladius/src/MeshVoxelGridManager.h
+++ b/gladius/src/MeshVoxelGridManager.h
@@ -7,6 +7,7 @@
 
 #include "ComputeContext.h"
 #include "MeshVoxelGrid.h"
+#include "Primitives.h"
 #include "ResourceKey.h"
 
 #include <optional>
@@ -98,20 +99,20 @@ namespace gladius
         
         /// Build voxel grid in-place in the primitive buffer
         /// @param program CLProgram with compiled buildMeshVoxelGrid kernel
-        /// @param primitiveDataBuffer Primitive data buffer on GPU (read BVH, write voxels)
+        /// @param primitiveData Primitive data buffer on GPU (read BVH, write voxels)
         /// @param params Build parameters (offsets and counts)
         /// @return true if the kernel was executed successfully
-        bool buildGrid(CLProgram& program,
-                       cl::Buffer& primitiveDataBuffer,
-                       MeshVoxelGridBuildParams const& params);
+        bool buildGrid(CLProgram & program,
+                   PrimitiveDataBuffer & primitiveData,
+                   MeshVoxelGridBuildParams const & params);
         
         /// Queue a build request (call during resource iteration)
         void queueBuild(MeshVoxelGridBuildParams params);
         
         /// Execute all queued builds
         /// @param program CLProgram with compiled buildMeshVoxelGrid kernel
-        /// @param primitiveDataBuffer Primitive data buffer on GPU
-        void executeQueuedBuilds(CLProgram& program, cl::Buffer& primitiveDataBuffer);
+        /// @param primitiveData Primitive data buffer on GPU
+        void executeQueuedBuilds(CLProgram & program, PrimitiveDataBuffer & primitiveData);
         
         /// Clear the build queue
         void clearQueue();
diff --git a/gladius/src/ModelState.h b/gladius/src/ModelState.h
index e8c07e57..e6a0189e 100644
--- a/gladius/src/ModelState.h
+++ b/gladius/src/ModelState.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <atomic>
+
 namespace gladius
 {
     enum class CompilationState
@@ -14,38 +16,38 @@ namespace gladius
       public:
         void signalCompilationRequired()
         {
-            m_compilationState = CompilationState::CompilationRequested;
+            m_compilationState.store(CompilationState::CompilationRequested,
+                                     std::memory_order_release);
         }
 
         void signalCompilationFinished()
         {
-            if (m_compilationState == CompilationState::CompilationInProgress)
-            {
-                m_compilationState = CompilationState::UpToDate;
-            }
+            auto expected = CompilationState::CompilationInProgress;
+            (void) m_compilationState.compare_exchange_strong(expected,
+                                                              CompilationState::UpToDate,
+                                                              std::memory_order_acq_rel,
+                                                              std::memory_order_acquire);
         }
 
         void signalCompilationStarted()
         {
-            m_compilationState = CompilationState::CompilationInProgress;
+            m_compilationState.store(CompilationState::CompilationInProgress,
+                                     std::memory_order_release);
         }
 
         [[nodiscard]] bool isCompilationRequired() const
         {
-            if (m_compilationState == CompilationState::CompilationRequested)
-            {
-                return true;
-            }
-
-            return false;
+            return m_compilationState.load(std::memory_order_acquire) ==
+                   CompilationState::CompilationRequested;
         }
 
         [[nodiscard]] bool isModelUpToDate() const
         {
-            return m_compilationState == CompilationState::UpToDate;
+            return m_compilationState.load(std::memory_order_acquire) ==
+                   CompilationState::UpToDate;
         }
 
       private:
-        CompilationState m_compilationState{CompilationState::UpToDate};
+        std::atomic<CompilationState> m_compilationState{CompilationState::UpToDate};
     };
 }
diff --git a/gladius/src/RenderProgram.cpp b/gladius/src/RenderProgram.cpp
index d774edf0..c2ca751d 100644
--- a/gladius/src/RenderProgram.cpp
+++ b/gladius/src/RenderProgram.cpp
@@ -1,6 +1,8 @@
 #include "RenderProgram.h"
 #include "Profiling.h"
 #include "ProgramBase.h"
+#include "compute/GpuKernelAccessGuard.h"
+#include "compute/RenderPayloadSnapshot.h"
 #include "gpgpu.h"
 #include "kernel/types.h"
 
@@ -11,6 +13,18 @@
 
 namespace gladius
 {
+    namespace
+    {
+        [[nodiscard]] std::vector<GpuKernelResourceAccess>
+        makeRenderPayloadReadAccesses(SharedResources const & resources, Primitives const & lines)
+        { return RenderPayloadSnapshot::capture(resources, lines).readAccesses(); }
+
+        void appendAccess(std::vector<GpuKernelResourceAccess> & accesses,
+                          GpuResourceHandle resource,
+                          GpuAccessMode mode)
+        { accesses.push_back(GpuKernelResourceAccess{.resource = resource, .mode = mode}); }
+    }
+
     /// Maximum render height per dispatch to prevent excessive GPU workload
     constexpr size_t kMaxRenderHeightPerDispatch = 16000;
 
@@ -31,11 +45,8 @@ namespace gladius
                          "renderer.cl"};
     }
 
-    RenderProgram::RenderSetup RenderProgram::prepareRenderSetup(
-        ImageRGBA & targetImage,
-        cl_float z_mm,
-        size_t startHeight,
-        size_t endHeight)
+    RenderProgram::RenderSetup
+    RenderProgram::prepareRenderSetup(ImageRGBA & targetImage, size_t startHeight, size_t endHeight)
     {
         RenderSetup setup{};
 
@@ -50,6 +61,11 @@ namespace gladius
             return setup;
         }
 
+        if (targetImage.getHeight() < 2 || targetImage.getWidth() == 0)
+        {
+            return setup;
+        }
+
         auto const start = std::clamp(startHeight, size_t(0), targetImage.getHeight() - 2);
         auto const size =
           std::clamp(endHeight - startHeight, size_t{0}, targetImage.getHeight() - start - 1);
@@ -65,9 +81,6 @@ namespace gladius
             glImageBuffer->invalidateContent();
         }
 
-        m_resources->getRenderingSettings().time_s = m_resources->getTime_s();
-        m_resources->getRenderingSettings().z_mm = z_mm;
-
         setup.origin = {0, start, 0};
         setup.globalRange = {targetImage.getWidth(), size, 1};
         setup.valid = true;
@@ -79,9 +92,7 @@ namespace gladius
                                     cl_float z_mm,
                                     size_t startHeight,
                                     size_t endHeight)
-    {
-        renderScene(m_ComputeContext->GetQueue(), lines, targetImage, z_mm, startHeight, endHeight);
-    }
+    { renderScene(m_ComputeContext->GetQueue(), lines, targetImage, z_mm, startHeight, endHeight); }
 
     void RenderProgram::renderScene(cl::CommandQueue const & queue,
                                     const Primitives & lines,
@@ -111,6 +122,34 @@ namespace gladius
         }
     }
 
+    void RenderProgram::renderScene(cl::CommandQueue const & queue,
+                                    const Primitives & lines,
+                                    ImageRGBA & targetImage,
+                                    RenderSessionInputs inputs,
+                                    size_t startHeight,
+                                    size_t endHeight)
+    {
+        ProfileFunction;
+        try
+        {
+            cl::Event const event = renderSceneAsync(
+              queue, lines, targetImage, std::move(inputs), startHeight, endHeight);
+            if (event())
+            {
+                queue.flush();
+                event.wait();
+                queue.finish();
+            }
+        }
+        catch (std::exception const & e)
+        {
+            if (m_logger)
+            {
+                m_logger->logError(std::string("RenderProgram error: ") + e.what());
+            }
+        }
+    }
+
     cl::Event RenderProgram::renderSceneAsync(cl::CommandQueue const & queue,
                                               const Primitives & lines,
                                               ImageRGBA & targetImage,
@@ -118,53 +157,62 @@ namespace gladius
                                               size_t startHeight,
                                               size_t endHeight)
     {
-        return renderSceneAsync(
-          queue, lines, targetImage, m_resources->getRenderingSettings(),
-          z_mm, startHeight, endHeight);
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        return renderSceneAsync(queue, lines, targetImage, inputs, startHeight, endHeight);
     }
 
     cl::Event RenderProgram::renderSceneAsync(cl::CommandQueue const & queue,
                                               Primitives const & lines,
                                               ImageRGBA & targetImage,
-                                              RenderingSettings settings,
-                                              cl_float z_mm,
+                                              RenderSessionInputs inputs,
                                               size_t startHeight,
                                               size_t endHeight)
     {
         ProfileFunction;
         cl::Event kernelEvent{};
 
-        auto const setup = prepareRenderSetup(targetImage, z_mm, startHeight, endHeight);
+        auto const setup = prepareRenderSetup(targetImage, startHeight, endHeight);
         if (!setup.valid)
         {
             return kernelEvent;
         }
 
-        // Ensure time and z_mm are current in the caller's copy
-        settings.time_s = m_resources->getTime_s();
-        settings.z_mm = z_mm;
-
         try
         {
-            kernelEvent = m_programFront->runNonBlocking(
+            auto accesses = makeRenderPayloadReadAccesses(m_resources, lines);
+            appendAccess(accesses, targetImage.gpuResourceHandle(), GpuAccessMode::Write);
+            GpuKernelAccessGuard gpuAccess(
+              *m_ComputeContext, queue, "renderScene", std::move(accesses));
+            if (!gpuAccess.granted())
+            {
+                return kernelEvent;
+            }
+
+            kernelEvent = m_programFront->runNonBlockingWithWaitList(
               queue,
               "renderScene",
               setup.origin,
               setup.globalRange,
+              gpuAccess.waitEvents(),
               targetImage.getBuffer(),
               m_resources->getBuildArea(),
               lines.primitives.getBuffer(),
               cl_int(lines.primitives.getSize()),
               lines.data.getBuffer(),
               cl_int(lines.data.getSize()),
-              settings,
+              inputs.settings,
               m_resources->getPrecompSdfBuffer().getBuffer(),
               m_resources->getParameterBuffer().getBuffer(),
               m_resources->getCommandBuffer().getBuffer(),
               cl_int(m_resources->getCommandBuffer().getData().size()),
               m_resources->getPreCompSdfBBox(),
-              m_resources->getEyePosition(),
-              m_resources->getModelViewPerspectiveMat());
+              inputs.eyePosition,
+              inputs.modelViewPerspectiveMat);
+            gpuAccess.complete(kernelEvent);
         }
         catch (std::exception const & e)
         {
@@ -177,6 +225,21 @@ namespace gladius
         return kernelEvent;
     }
 
+    cl::Event RenderProgram::renderSceneAsync(cl::CommandQueue const & queue,
+                                              Primitives const & lines,
+                                              ImageRGBA & targetImage,
+                                              RenderingSettings settings,
+                                              cl_float z_mm,
+                                              size_t startHeight,
+                                              size_t endHeight)
+    {
+        RenderSessionInputs inputs{
+          settings, m_resources->getEyePosition(), m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        return renderSceneAsync(queue, lines, targetImage, inputs, startHeight, endHeight);
+    }
+
     void RenderProgram::resample(ImageRGBA & sourceImage,
                                  ImageRGBA & targetImage,
                                  size_t startHeight,
@@ -213,58 +276,102 @@ namespace gladius
         }
         cl::NDRange const origin = {0, startHeight, 0};
         cl::NDRange const range = {targetImage.getWidth(), endHeight - startHeight, 1};
-        cl::Event const event = m_programFront->runNonBlocking(
-          queue, "resample", origin, range, targetImage.getBuffer(), sourceImage.getBuffer());
+        GpuKernelAccessGuard gpuAccess(*m_ComputeContext,
+                                       queue,
+                                       "resample",
+                                       {{targetImage.gpuResourceHandle(), GpuAccessMode::Write},
+                                        {sourceImage.gpuResourceHandle(), GpuAccessMode::Read}});
+        if (!gpuAccess.granted())
+        {
+            if (completionEvent)
+            {
+                *completionEvent = cl::Event{};
+            }
+            return;
+        }
+        cl::Event const event = m_programFront->runNonBlockingWithWaitList(queue,
+                                                                           "resample",
+                                                                           origin,
+                                                                           range,
+                                                                           gpuAccess.waitEvents(),
+                                                                           targetImage.getBuffer(),
+                                                                           sourceImage.getBuffer());
+        gpuAccess.complete(event);
         if (completionEvent)
         {
             *completionEvent = event;
         }
     }
 
-    cl::Event RenderProgram::renderSceneWithDistanceOutputAsync(
-        cl::CommandQueue const & queue,
-        Primitives const & lines,
-        ImageRGBA & targetImage,
-        DistanceInitBuffer & distanceOutput,
-        cl_float z_mm,
-        size_t startHeight,
-        size_t endHeight)
+    cl::Event RenderProgram::renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                                                Primitives const & lines,
+                                                                ImageRGBA & targetImage,
+                                                                DistanceInitBuffer & distanceOutput,
+                                                                cl_float z_mm,
+                                                                size_t startHeight,
+                                                                size_t endHeight)
+    {
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        return renderSceneWithDistanceOutputAsync(
+          queue, lines, targetImage, distanceOutput, inputs, startHeight, endHeight);
+    }
+
+    cl::Event RenderProgram::renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                                                Primitives const & lines,
+                                                                ImageRGBA & targetImage,
+                                                                DistanceInitBuffer & distanceOutput,
+                                                                RenderingSettings settings,
+                                                                cl_float z_mm,
+                                                                size_t startHeight,
+                                                                size_t endHeight)
     {
+        RenderSessionInputs inputs{
+          settings, m_resources->getEyePosition(), m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
         return renderSceneWithDistanceOutputAsync(
-          queue, lines, targetImage, distanceOutput,
-          m_resources->getRenderingSettings(), z_mm, startHeight, endHeight);
+          queue, lines, targetImage, distanceOutput, inputs, startHeight, endHeight);
     }
 
-    cl::Event RenderProgram::renderSceneWithDistanceOutputAsync(
-        cl::CommandQueue const & queue,
-        Primitives const & lines,
-        ImageRGBA & targetImage,
-        DistanceInitBuffer & distanceOutput,
-        RenderingSettings settings,
-        cl_float z_mm,
-        size_t startHeight,
-        size_t endHeight)
+    cl::Event RenderProgram::renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                                                Primitives const & lines,
+                                                                ImageRGBA & targetImage,
+                                                                DistanceInitBuffer & distanceOutput,
+                                                                RenderSessionInputs inputs,
+                                                                size_t startHeight,
+                                                                size_t endHeight)
     {
         ProfileFunction;
         cl::Event kernelEvent{};
 
-        auto const setup = prepareRenderSetup(targetImage, z_mm, startHeight, endHeight);
+        auto const setup = prepareRenderSetup(targetImage, startHeight, endHeight);
         if (!setup.valid)
         {
             return kernelEvent;
         }
 
-        // Ensure time and z_mm are current in the caller's copy
-        settings.time_s = m_resources->getTime_s();
-        settings.z_mm = z_mm;
-
         try
         {
-            kernelEvent = m_programFront->runNonBlocking(
+            auto accesses = makeRenderPayloadReadAccesses(m_resources, lines);
+            appendAccess(accesses, targetImage.gpuResourceHandle(), GpuAccessMode::Write);
+            appendAccess(accesses, distanceOutput.gpuResourceHandle(), GpuAccessMode::Write);
+            GpuKernelAccessGuard gpuAccess(
+              *m_ComputeContext, queue, "renderSceneWithDistanceOutput", std::move(accesses));
+            if (!gpuAccess.granted())
+            {
+                return kernelEvent;
+            }
+
+            kernelEvent = m_programFront->runNonBlockingWithWaitList(
               queue,
               "renderSceneWithDistanceOutput",
               setup.origin,
               setup.globalRange,
+              gpuAccess.waitEvents(),
               targetImage.getBuffer(),
               distanceOutput.getBuffer(),
               m_resources->getBuildArea(),
@@ -272,14 +379,15 @@ namespace gladius
               cl_int(lines.primitives.getSize()),
               lines.data.getBuffer(),
               cl_int(lines.data.getSize()),
-              settings,
+              inputs.settings,
               m_resources->getPrecompSdfBuffer().getBuffer(),
               m_resources->getParameterBuffer().getBuffer(),
               m_resources->getCommandBuffer().getBuffer(),
               cl_int(m_resources->getCommandBuffer().getData().size()),
               m_resources->getPreCompSdfBBox(),
-              m_resources->getEyePosition(),
-              m_resources->getModelViewPerspectiveMat());
+              inputs.eyePosition,
+              inputs.modelViewPerspectiveMat);
+            gpuAccess.complete(kernelEvent);
         }
         catch (std::exception const & e)
         {
@@ -292,35 +400,60 @@ namespace gladius
         return kernelEvent;
     }
 
-    cl::Event RenderProgram::renderSceneWithDistanceInitAsync(
-        cl::CommandQueue const & queue,
-        Primitives const & lines,
-        ImageRGBA & targetImage,
-        DistanceInitBuffer & distanceInit,
-        cl_float z_mm,
-        size_t startHeight,
-        size_t endHeight)
+    cl::Event RenderProgram::renderSceneWithDistanceInitAsync(cl::CommandQueue const & queue,
+                                                              Primitives const & lines,
+                                                              ImageRGBA & targetImage,
+                                                              DistanceInitBuffer & distanceInit,
+                                                              cl_float z_mm,
+                                                              size_t startHeight,
+                                                              size_t endHeight)
+    {
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation =
+          static_cast<ApproximationMode>(inputs.settings.approximation | AM_USE_DISTANCE_INIT);
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        return renderSceneWithDistanceInitAsync(
+          queue, lines, targetImage, distanceInit, inputs, startHeight, endHeight);
+    }
+
+    cl::Event RenderProgram::renderSceneWithDistanceInitAsync(cl::CommandQueue const & queue,
+                                                              Primitives const & lines,
+                                                              ImageRGBA & targetImage,
+                                                              DistanceInitBuffer & distanceInit,
+                                                              RenderSessionInputs inputs,
+                                                              size_t startHeight,
+                                                              size_t endHeight)
     {
         ProfileFunction;
         cl::Event kernelEvent{};
 
-        auto const setup = prepareRenderSetup(targetImage, z_mm, startHeight, endHeight);
+        auto const setup = prepareRenderSetup(targetImage, startHeight, endHeight);
         if (!setup.valid)
         {
             return kernelEvent;
         }
 
-        // Enable distance initialization flag (T020)
-        m_resources->getRenderingSettings().approximation = static_cast<ApproximationMode>(
-            m_resources->getRenderingSettings().approximation | AM_USE_DISTANCE_INIT);
-
         try
         {
-            kernelEvent = m_programFront->runNonBlocking(
+            auto accesses = makeRenderPayloadReadAccesses(m_resources, lines);
+            appendAccess(accesses, targetImage.gpuResourceHandle(), GpuAccessMode::Write);
+            appendAccess(accesses, distanceInit.gpuResourceHandle(), GpuAccessMode::Read);
+            GpuKernelAccessGuard gpuAccess(
+              *m_ComputeContext, queue, "renderSceneWithDistanceInit", std::move(accesses));
+            if (!gpuAccess.granted())
+            {
+                return kernelEvent;
+            }
+
+            kernelEvent = m_programFront->runNonBlockingWithWaitList(
               queue,
               "renderSceneWithDistanceInit",
               setup.origin,
               setup.globalRange,
+              gpuAccess.waitEvents(),
               targetImage.getBuffer(),
               distanceInit.getBuffer(),
               m_resources->getBuildArea(),
@@ -328,14 +461,15 @@ namespace gladius
               cl_int(lines.primitives.getSize()),
               lines.data.getBuffer(),
               cl_int(lines.data.getSize()),
-              m_resources->getRenderingSettings(),
+              inputs.settings,
               m_resources->getPrecompSdfBuffer().getBuffer(),
               m_resources->getParameterBuffer().getBuffer(),
               m_resources->getCommandBuffer().getBuffer(),
               cl_int(m_resources->getCommandBuffer().getData().size()),
               m_resources->getPreCompSdfBBox(),
-              m_resources->getEyePosition(),
-              m_resources->getModelViewPerspectiveMat());
+              inputs.eyePosition,
+              inputs.modelViewPerspectiveMat);
+            gpuAccess.complete(kernelEvent);
         }
         catch (std::exception const & e)
         {
@@ -345,26 +479,38 @@ namespace gladius
             }
         }
 
-        // Clear the distance init flag after use
-        m_resources->getRenderingSettings().approximation = static_cast<ApproximationMode>(
-            m_resources->getRenderingSettings().approximation & ~AM_USE_DISTANCE_INIT);
-
         return kernelEvent;
     }
 
-    cl::Event RenderProgram::renderSceneWithMetricsAsync(
-        cl::CommandQueue const & queue,
-        Primitives const & lines,
-        ImageRGBA & targetImage,
-        cl::Buffer & metricsBuffer,
-        cl_float z_mm,
-        size_t startHeight,
-        size_t endHeight)
+    cl::Event RenderProgram::renderSceneWithMetricsAsync(cl::CommandQueue const & queue,
+                                                         Primitives const & lines,
+                                                         ImageRGBA & targetImage,
+                                                         cl::Buffer & metricsBuffer,
+                                                         cl_float z_mm,
+                                                         size_t startHeight,
+                                                         size_t endHeight)
+    {
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = z_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        return renderSceneWithMetricsAsync(
+          queue, lines, targetImage, metricsBuffer, inputs, startHeight, endHeight);
+    }
+
+    cl::Event RenderProgram::renderSceneWithMetricsAsync(cl::CommandQueue const & queue,
+                                                         Primitives const & lines,
+                                                         ImageRGBA & targetImage,
+                                                         cl::Buffer & metricsBuffer,
+                                                         RenderSessionInputs inputs,
+                                                         size_t startHeight,
+                                                         size_t endHeight)
     {
         ProfileFunction;
         cl::Event kernelEvent{};
 
-        auto const setup = prepareRenderSetup(targetImage, z_mm, startHeight, endHeight);
+        auto const setup = prepareRenderSetup(targetImage, startHeight, endHeight);
         if (!setup.valid)
         {
             return kernelEvent;
@@ -372,11 +518,23 @@ namespace gladius
 
         try
         {
-            kernelEvent = m_programFront->runNonBlocking(
+            auto accesses = makeRenderPayloadReadAccesses(m_resources, lines);
+            appendAccess(accesses, targetImage.gpuResourceHandle(), GpuAccessMode::Write);
+            appendAccess(
+              accesses, m_resources->getMetricsBufferGpuResource(), GpuAccessMode::Write);
+            GpuKernelAccessGuard gpuAccess(
+              *m_ComputeContext, queue, "renderSceneWithMetrics", std::move(accesses));
+            if (!gpuAccess.granted())
+            {
+                return kernelEvent;
+            }
+
+            kernelEvent = m_programFront->runNonBlockingWithWaitList(
               queue,
               "renderSceneWithMetrics",
               setup.origin,
               setup.globalRange,
+              gpuAccess.waitEvents(),
               targetImage.getBuffer(),
               metricsBuffer,
               m_resources->getBuildArea(),
@@ -384,14 +542,15 @@ namespace gladius
               cl_int(lines.primitives.getSize()),
               lines.data.getBuffer(),
               cl_int(lines.data.getSize()),
-              m_resources->getRenderingSettings(),
+              inputs.settings,
               m_resources->getPrecompSdfBuffer().getBuffer(),
               m_resources->getParameterBuffer().getBuffer(),
               m_resources->getCommandBuffer().getBuffer(),
               cl_int(m_resources->getCommandBuffer().getData().size()),
               m_resources->getPreCompSdfBBox(),
-              m_resources->getEyePosition(),
-              m_resources->getModelViewPerspectiveMat());
+              inputs.eyePosition,
+              inputs.modelViewPerspectiveMat);
+            gpuAccess.complete(kernelEvent);
         }
         catch (std::exception const & e)
         {
diff --git a/gladius/src/RenderProgram.h b/gladius/src/RenderProgram.h
index b4809298..69452ebb 100644
--- a/gladius/src/RenderProgram.h
+++ b/gladius/src/RenderProgram.h
@@ -4,6 +4,7 @@
 #include "Primitives.h"
 #include "ProgramBase.h"
 #include "ResourceContext.h"
+#include "compute/RenderSessionInputs.h"
 
 namespace cl
 {
@@ -24,29 +25,42 @@ namespace gladius
                          size_t startHeight,
                          size_t endHeight);
 
-  void renderScene(cl::CommandQueue const & queue,
-       const Primitives & lines,
-       ImageRGBA & targetImage,
-       cl_float z_mm,
-       size_t startHeight,
-       size_t endHeight);
-
-  [[nodiscard]] cl::Event renderSceneAsync(cl::CommandQueue const & queue,
-             const Primitives & lines,
-             ImageRGBA & targetImage,
-             cl_float z_mm,
-             size_t startHeight,
-             size_t endHeight);
-
-        /// Overload that uses caller-provided RenderingSettings instead
-        /// of the shared settings from the resource context.
+        void renderScene(cl::CommandQueue const & queue,
+                         const Primitives & lines,
+                         ImageRGBA & targetImage,
+                         cl_float z_mm,
+                         size_t startHeight,
+                         size_t endHeight);
+
+        void renderScene(cl::CommandQueue const & queue,
+                         const Primitives & lines,
+                         ImageRGBA & targetImage,
+                         RenderSessionInputs inputs,
+                         size_t startHeight,
+                         size_t endHeight);
+
+        [[nodiscard]] cl::Event renderSceneAsync(cl::CommandQueue const & queue,
+                                                 const Primitives & lines,
+                                                 ImageRGBA & targetImage,
+                                                 cl_float z_mm,
+                                                 size_t startHeight,
+                                                 size_t endHeight);
+
+        /// Overload that uses caller-provided session inputs instead of shared camera/settings.
+        [[nodiscard]] cl::Event renderSceneAsync(cl::CommandQueue const & queue,
+                                                 Primitives const & lines,
+                                                 ImageRGBA & targetImage,
+                                                 RenderSessionInputs inputs,
+                                                 size_t startHeight,
+                                                 size_t endHeight);
+
         [[nodiscard]] cl::Event renderSceneAsync(cl::CommandQueue const & queue,
-             Primitives const & lines,
-             ImageRGBA & targetImage,
-             RenderingSettings settings,
-             cl_float z_mm,
-             size_t startHeight,
-             size_t endHeight);
+                                                 Primitives const & lines,
+                                                 ImageRGBA & targetImage,
+                                                 RenderingSettings settings,
+                                                 cl_float z_mm,
+                                                 size_t startHeight,
+                                                 size_t endHeight);
 
         void resample(ImageRGBA & sourceImage,
                       ImageRGBA & targetImage,
@@ -71,30 +85,40 @@ namespace gladius
         /// @param queue Command queue to use for execution.
         /// @param lines Primitives for rendering.
         /// @param targetImage Target image buffer for color output.
-        /// @param distanceOutput Output buffer for traveled distance (same resolution as targetImage).
+        /// @param distanceOutput Output buffer for traveled distance (same resolution as
+        /// targetImage).
         /// @param z_mm Slice height in millimeters.
         /// @param startHeight Starting row for rendering.
         /// @param endHeight Ending row for rendering.
         /// @return Completion event for synchronization.
-        [[nodiscard]] cl::Event renderSceneWithDistanceOutputAsync(
-            cl::CommandQueue const & queue,
-            Primitives const & lines,
-            ImageRGBA & targetImage,
-            DistanceInitBuffer & distanceOutput,
-            cl_float z_mm,
-            size_t startHeight,
-            size_t endHeight);
+        [[nodiscard]] cl::Event
+        renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                           Primitives const & lines,
+                                           ImageRGBA & targetImage,
+                                           DistanceInitBuffer & distanceOutput,
+                                           cl_float z_mm,
+                                           size_t startHeight,
+                                           size_t endHeight);
 
         /// Overload that uses caller-provided RenderingSettings.
-        [[nodiscard]] cl::Event renderSceneWithDistanceOutputAsync(
-            cl::CommandQueue const & queue,
-            Primitives const & lines,
-            ImageRGBA & targetImage,
-            DistanceInitBuffer & distanceOutput,
-            RenderingSettings settings,
-            cl_float z_mm,
-            size_t startHeight,
-            size_t endHeight);
+        [[nodiscard]] cl::Event
+        renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                           Primitives const & lines,
+                                           ImageRGBA & targetImage,
+                                           DistanceInitBuffer & distanceOutput,
+                                           RenderSessionInputs inputs,
+                                           size_t startHeight,
+                                           size_t endHeight);
+
+        [[nodiscard]] cl::Event
+        renderSceneWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                           Primitives const & lines,
+                                           ImageRGBA & targetImage,
+                                           DistanceInitBuffer & distanceOutput,
+                                           RenderingSettings settings,
+                                           cl_float z_mm,
+                                           size_t startHeight,
+                                           size_t endHeight);
 
         /// @brief Render scene using distance init buffer to skip empty space (T016/T018)
         /// @param queue Command queue to use for execution.
@@ -105,14 +129,21 @@ namespace gladius
         /// @param startHeight Starting row for rendering.
         /// @param endHeight Ending row for rendering.
         /// @return Completion event for synchronization.
-        [[nodiscard]] cl::Event renderSceneWithDistanceInitAsync(
-            cl::CommandQueue const & queue,
-            Primitives const & lines,
-            ImageRGBA & targetImage,
-            DistanceInitBuffer & distanceInit,
-            cl_float z_mm,
-            size_t startHeight,
-            size_t endHeight);
+        [[nodiscard]] cl::Event renderSceneWithDistanceInitAsync(cl::CommandQueue const & queue,
+                                                                 Primitives const & lines,
+                                                                 ImageRGBA & targetImage,
+                                                                 DistanceInitBuffer & distanceInit,
+                                                                 RenderSessionInputs inputs,
+                                                                 size_t startHeight,
+                                                                 size_t endHeight);
+
+        [[nodiscard]] cl::Event renderSceneWithDistanceInitAsync(cl::CommandQueue const & queue,
+                                                                 Primitives const & lines,
+                                                                 ImageRGBA & targetImage,
+                                                                 DistanceInitBuffer & distanceInit,
+                                                                 cl_float z_mm,
+                                                                 size_t startHeight,
+                                                                 size_t endHeight);
 
         /// @brief Render scene with metrics collection for performance analysis (T033)
         /// @param queue Command queue to use for execution.
@@ -123,14 +154,21 @@ namespace gladius
         /// @param startHeight Starting row for rendering.
         /// @param endHeight Ending row for rendering.
         /// @return Completion event for synchronization.
-        [[nodiscard]] cl::Event renderSceneWithMetricsAsync(
-            cl::CommandQueue const & queue,
-            Primitives const & lines,
-            ImageRGBA & targetImage,
-            cl::Buffer & metricsBuffer,
-            cl_float z_mm,
-            size_t startHeight,
-            size_t endHeight);
+        [[nodiscard]] cl::Event renderSceneWithMetricsAsync(cl::CommandQueue const & queue,
+                                                            Primitives const & lines,
+                                                            ImageRGBA & targetImage,
+                                                            cl::Buffer & metricsBuffer,
+                                                            RenderSessionInputs inputs,
+                                                            size_t startHeight,
+                                                            size_t endHeight);
+
+        [[nodiscard]] cl::Event renderSceneWithMetricsAsync(cl::CommandQueue const & queue,
+                                                            Primitives const & lines,
+                                                            ImageRGBA & targetImage,
+                                                            cl::Buffer & metricsBuffer,
+                                                            cl_float z_mm,
+                                                            size_t startHeight,
+                                                            size_t endHeight);
 
       private:
         /// @brief Result of render setup preparation
@@ -147,10 +185,7 @@ namespace gladius
         /// @param startHeight Starting row for rendering
         /// @param endHeight Ending row for rendering
         /// @return RenderSetup with origin/range and validity flag
-        [[nodiscard]] RenderSetup prepareRenderSetup(
-            ImageRGBA & targetImage,
-            cl_float z_mm,
-            size_t startHeight,
-            size_t endHeight);
+        [[nodiscard]] RenderSetup
+        prepareRenderSetup(ImageRGBA & targetImage, size_t startHeight, size_t endHeight);
     };
 }
diff --git a/gladius/src/ResourceContext.cpp b/gladius/src/ResourceContext.cpp
index 1cf51f04..29fa0154 100644
--- a/gladius/src/ResourceContext.cpp
+++ b/gladius/src/ResourceContext.cpp
@@ -17,6 +17,8 @@ namespace gladius
 {
     ResourceContext::ResourceContext(SharedComputeContext context)
         : m_ComputeContext(context)
+        , m_metricsBufferResource(m_ComputeContext->gpuAccessCoordinator().registerResource(
+            GpuResourceKind::Buffer, "RayMarchMetrics"))
     {
         m_renderingSettings = {};
         m_renderingSettings.z_mm = 1000.0f;
@@ -479,4 +481,9 @@ namespace gladius
         }
         return m_metricsBuffer.value();
     }
+
+    GpuResourceHandle ResourceContext::getMetricsBufferGpuResource() const noexcept
+    {
+        return m_metricsBufferResource;
+    }
 }
diff --git a/gladius/src/ResourceContext.h b/gladius/src/ResourceContext.h
index 39c3ff4a..a90d19cf 100644
--- a/gladius/src/ResourceContext.h
+++ b/gladius/src/ResourceContext.h
@@ -116,6 +116,8 @@ namespace gladius
         /// @return Reference to the GPU buffer for ray march metrics collection.
         [[nodiscard]] cl::Buffer & getMetricsBuffer();
 
+        [[nodiscard]] GpuResourceHandle getMetricsBufferGpuResource() const noexcept;
+
       private:
         void clearDistanceMaps();
         std::unique_ptr<Vertices> m_contourVertexPos;
@@ -172,6 +174,7 @@ namespace gladius
 
         /// @brief Buffer for ray march metrics collection (4 x uint32: totalRays, totalSteps, cacheHits, nonConverged)
         std::optional<cl::Buffer> m_metricsBuffer;
+        GpuResourceHandle m_metricsBufferResource{};
 
         bool m_resizeOfBuildAreaBufferRequired = true;
         bool m_resizeOfDistanceMapsRequired = true;
diff --git a/gladius/src/SlicerProgram.cpp b/gladius/src/SlicerProgram.cpp
index 6f0547d5..656c4e6b 100644
--- a/gladius/src/SlicerProgram.cpp
+++ b/gladius/src/SlicerProgram.cpp
@@ -1,5 +1,7 @@
 #include "SlicerProgram.h"
 #include "ProgramBase.h"
+#include "compute/GpuKernelAccessGuard.h"
+#include "compute/RenderPayloadSnapshot.h"
 #include "gpgpu.h"
 
 #include <algorithm>
@@ -10,6 +12,22 @@
 
 namespace gladius
 {
+    namespace
+    {
+        [[nodiscard]] std::vector<GpuKernelResourceAccess>
+        makeSlicerPayloadReadAccesses(SharedResources const & resources,
+                                      Primitives const & lines)
+        {
+            return RenderPayloadSnapshot::capture(resources, lines).readAccesses();
+        }
+
+        void appendAccess(std::vector<GpuKernelResourceAccess> & accesses,
+                          GpuResourceHandle resource,
+                          GpuAccessMode mode)
+        {
+            accesses.push_back(GpuKernelResourceAccess{.resource = resource, .mode = mode});
+        }
+    }
 
 #define PAYLOAD_ARGUMENTS                                                                          \
     m_resources->getBuildArea(), lines.primitives.getBuffer(),                                      \
@@ -149,8 +167,30 @@ namespace gladius
         m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
         const cl::NDRange origin = {0, 0, 0};
         const cl::NDRange range = {target.getWidth(), target.getHeight(), target.getDepth()};
-        m_programFront->run(
-          "preComputeSdf", origin, range, target.getBuffer(), boundingBox, PAYLOAD_ARGUMENTS);
+        auto accesses = makeSlicerPayloadReadAccesses(m_resources, lines);
+        appendAccess(accesses, target.gpuResourceHandle(), GpuAccessMode::ReadWrite);
+        auto const & queue = m_ComputeContext->GetQueue();
+        GpuKernelAccessGuard gpuAccess(
+          *m_ComputeContext, queue, "preComputeSdf", std::move(accesses));
+        if (!gpuAccess.granted())
+        {
+            return;
+        }
+
+        cl::Event const event = m_programFront->runNonBlockingWithWaitList(queue,
+                                                                           "preComputeSdf",
+                                                                           origin,
+                                                                           range,
+                                                                           gpuAccess.waitEvents(),
+                                                                           target.getBuffer(),
+                                                                           boundingBox,
+                                                                           PAYLOAD_ARGUMENTS);
+        gpuAccess.complete(event);
+        if (event())
+        {
+            event.wait();
+            queue.finish();
+        }
     }
 
     cl::Event SlicerProgram::precomputeSdfAsync(const Primitives & lines,
@@ -167,14 +207,25 @@ namespace gladius
         const cl::NDRange origin = {0, 0, 0};
         const cl::NDRange range = {target.getWidth(), target.getHeight(), target.getDepth()};
 
+        auto accesses = makeSlicerPayloadReadAccesses(m_resources, lines);
+        appendAccess(accesses, target.gpuResourceHandle(), GpuAccessMode::ReadWrite);
+        GpuKernelAccessGuard gpuAccess(
+          *m_ComputeContext, queue, "preComputeSdf", std::move(accesses));
+        if (!gpuAccess.granted())
+        {
+            return cl::Event{};
+        }
+
         // Use runNonBlocking to get the event without blocking
-        cl::Event sdfEvent = m_programFront->runNonBlocking(queue,
-                                                            "preComputeSdf",
-                                                            origin,
-                                                            range,
-                                                            target.getBuffer(),
-                                                            boundingBox,
-                                                            PAYLOAD_ARGUMENTS);
+        cl::Event sdfEvent = m_programFront->runNonBlockingWithWaitList(queue,
+                                        "preComputeSdf",
+                                        origin,
+                                        range,
+                                        gpuAccess.waitEvents(),
+                                        target.getBuffer(),
+                                        boundingBox,
+                                        PAYLOAD_ARGUMENTS);
+        gpuAccess.complete(sdfEvent);
 
         // Flush to ensure the kernel is submitted, but don't wait
         if (sdfEvent())
@@ -398,21 +449,41 @@ namespace gladius
         
         cl::NDRange const origin = {0, 0, 0};
         cl::NDRange const globalRange = {static_cast<size_t>(params.voxelCount), 1, 1};
+
+                auto const & queue = m_ComputeContext->GetQueue();
+                GpuKernelAccessGuard gpuAccess(
+                    *m_ComputeContext,
+                    queue,
+                    "buildMeshVoxelGrid",
+                    {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+                if (!gpuAccess.granted())
+                {
+                        return false;
+                }
         
-        m_programFront->run("buildMeshVoxelGrid",
-                            origin,
-                            globalRange,
-                            primitives.data.getBuffer(),               // 0: primitiveData
-                            static_cast<cl_int>(params.headerStart),   // 1: headerStart
-                            static_cast<cl_int>(params.voxelDataOffset), // 2: voxelDataOffset
-                            static_cast<cl_int>(params.nodesOffset),   // 3: nodesOffset
-                            static_cast<cl_int>(params.trianglesOffset), // 4: trianglesOffset
-                            static_cast<cl_int>(params.normalsOffset), // 5: normalsOffset
-                            static_cast<cl_int>(params.indicesOffset), // 6: indicesOffset
-                            static_cast<cl_int>(params.edgeNeighborsOffset), // 7: edgeNeighborsOffset
-                            static_cast<cl_int>(params.nodeCount),     // 8: nodeCount
-                            static_cast<cl_int>(params.triCount),      // 9: triCount
-                            static_cast<cl_int>(params.vertexNormalCount)); // 10: vertexNormalCount
+                cl::Event const event = m_programFront->runNonBlockingWithWaitList(
+                    queue,
+                    "buildMeshVoxelGrid",
+                    origin,
+                    globalRange,
+                    gpuAccess.waitEvents(),
+                    primitives.data.getBuffer(),                       // 0: primitiveData
+                    static_cast<cl_int>(params.headerStart),           // 1: headerStart
+                    static_cast<cl_int>(params.voxelDataOffset),       // 2: voxelDataOffset
+                    static_cast<cl_int>(params.nodesOffset),           // 3: nodesOffset
+                    static_cast<cl_int>(params.trianglesOffset),       // 4: trianglesOffset
+                    static_cast<cl_int>(params.normalsOffset),         // 5: normalsOffset
+                    static_cast<cl_int>(params.indicesOffset),         // 6: indicesOffset
+                    static_cast<cl_int>(params.edgeNeighborsOffset),   // 7: edgeNeighborsOffset
+                    static_cast<cl_int>(params.nodeCount),             // 8: nodeCount
+                    static_cast<cl_int>(params.triCount),              // 9: triCount
+                    static_cast<cl_int>(params.vertexNormalCount));    // 10: vertexNormalCount
+                gpuAccess.complete(event);
+                if (event())
+                {
+                        event.wait();
+                        queue.finish();
+                }
         
         return true;
     }
@@ -441,16 +512,29 @@ namespace gladius
         cl::NDRange const origin = {0, 0, 0};
         cl::NDRange const globalRange = {static_cast<size_t>(params.nodeCount), 1, 1};
 
-        cl::Event const event = m_programFront->runNonBlocking(queue,
-                                                               "buildMeshFwnAggregates",
-                                                               origin,
-                                                               globalRange,
-                                                               primitives.data.getBuffer(),
-                                                               static_cast<cl_int>(params.nodesOffset),
-                                                               static_cast<cl_int>(params.trianglesOffset),
-                                                               static_cast<cl_int>(params.fwnAggregatesOffset),
-                                                               static_cast<cl_int>(params.nodeCount),
-                                                               static_cast<cl_int>(params.triCount));
+                GpuKernelAccessGuard gpuAccess(
+                    *m_ComputeContext,
+                    queue,
+                    "buildMeshFwnAggregates",
+                    {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+                if (!gpuAccess.granted())
+                {
+                        return false;
+                }
+
+                cl::Event const event = m_programFront->runNonBlockingWithWaitList(
+                    queue,
+                    "buildMeshFwnAggregates",
+                    origin,
+                    globalRange,
+                    gpuAccess.waitEvents(),
+                    primitives.data.getBuffer(),
+                    static_cast<cl_int>(params.nodesOffset),
+                    static_cast<cl_int>(params.trianglesOffset),
+                    static_cast<cl_int>(params.fwnAggregatesOffset),
+                    static_cast<cl_int>(params.nodeCount),
+                    static_cast<cl_int>(params.triCount));
+                gpuAccess.complete(event);
         return event() != nullptr;
     }
 
@@ -480,34 +564,46 @@ namespace gladius
         cl::CommandQueue const & queue = m_ComputeContext->GetQueue();
         cl::NDRange const origin = {0, 0, 0};
 
+        GpuKernelAccessGuard gpuAccess(*m_ComputeContext,
+                                       queue,
+                                       "buildMeshSignCache",
+                                       {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+        if (!gpuAccess.granted())
+        {
+            return false;
+        }
+
         int const firstWord = std::clamp(params.baseWord, 0, params.wordCount);
         int const lastWord = std::min(params.wordCount, firstWord + params.wordsToBuild);
+        cl::Event lastEvent{};
         for (int baseWord = firstWord; baseWord < lastWord; baseWord += wordsPerBatch)
         {
             int const batchWordCount = std::min(wordsPerBatch, lastWord - baseWord);
             cl::NDRange const globalRange = {static_cast<size_t>(batchWordCount), 1, 1};
 
-            cl::Event const event = m_programFront->runNonBlocking(queue,
-                                                                    "buildMeshSignCache",
-                                                                    origin,
-                                                                    globalRange,
-                                                                    primitives.data.getBuffer(),
-                                                                    static_cast<cl_int>(params.headerStart),
-                                                                    static_cast<cl_int>(params.signCacheDataOffset),
-                                                                    static_cast<cl_int>(params.nodesOffset),
-                                                                    static_cast<cl_int>(params.trianglesOffset),
-                                                                    static_cast<cl_int>(params.normalsOffset),
-                                                                    static_cast<cl_int>(params.indicesOffset),
-                                                                    static_cast<cl_int>(params.edgeNeighborsOffset),
-                                                                    static_cast<cl_int>(params.fwnAggregatesOffset),
-                                                                    static_cast<cl_int>(params.nodeCount),
-                                                                    static_cast<cl_int>(params.triCount),
-                                                                    static_cast<cl_int>(params.vertexNormalCount),
-                                                                    static_cast<cl_int>(params.resolution),
-                                                                    static_cast<cl_int>(baseWord),
-                                                                    static_cast<cl_int>(params.wordCount),
-                                                                    static_cast<cl_float>(params.fwnBeta));
-            if (!event())
+            lastEvent = m_programFront->runNonBlockingWithWaitList(
+              queue,
+              "buildMeshSignCache",
+              origin,
+              globalRange,
+              gpuAccess.waitEvents(),
+              primitives.data.getBuffer(),
+              static_cast<cl_int>(params.headerStart),
+              static_cast<cl_int>(params.signCacheDataOffset),
+              static_cast<cl_int>(params.nodesOffset),
+              static_cast<cl_int>(params.trianglesOffset),
+              static_cast<cl_int>(params.normalsOffset),
+              static_cast<cl_int>(params.indicesOffset),
+              static_cast<cl_int>(params.edgeNeighborsOffset),
+              static_cast<cl_int>(params.fwnAggregatesOffset),
+              static_cast<cl_int>(params.nodeCount),
+              static_cast<cl_int>(params.triCount),
+              static_cast<cl_int>(params.vertexNormalCount),
+              static_cast<cl_int>(params.resolution),
+              static_cast<cl_int>(baseWord),
+              static_cast<cl_int>(params.wordCount),
+              static_cast<cl_float>(params.fwnBeta));
+            if (!lastEvent())
             {
                 return false;
             }
@@ -515,26 +611,31 @@ namespace gladius
 
         if (!params.completesBuild)
         {
+            gpuAccess.complete(lastEvent);
             return true;
         }
 
         // Flip the ready offset only after the final chunk kernels above complete.
         // The command queue is in-order, so any later render kernel sees either
         // offset 0 (not ready) or a fully built bitmap.
-        cl::Event const readyEvent = m_programFront->runNonBlocking(queue,
-                                                                    "markMeshSignCacheReady",
-                                                                    origin,
-                                                                    cl::NDRange{1, 1, 1},
-                                                                    primitives.data.getBuffer(),
-                                                                    static_cast<cl_int>(params.signCacheReadyOffset),
-                                                                    static_cast<cl_int>(params.signCacheDataOffset),
-                                                                    static_cast<cl_int>(params.signCacheBetaOffset),
-                                                                    static_cast<cl_float>(params.fwnBeta));
+                cl::Event const readyEvent = m_programFront->runNonBlockingWithWaitList(
+                    queue,
+                    "markMeshSignCacheReady",
+                    origin,
+                    cl::NDRange{1, 1, 1},
+                    gpuAccess.waitEvents(),
+                    primitives.data.getBuffer(),
+                    static_cast<cl_int>(params.signCacheReadyOffset),
+                    static_cast<cl_int>(params.signCacheDataOffset),
+                    static_cast<cl_int>(params.signCacheBetaOffset),
+                    static_cast<cl_float>(params.fwnBeta));
         if (!readyEvent())
         {
             return false;
         }
 
+            gpuAccess.complete(readyEvent);
+
         return true;
     }
 }
diff --git a/gladius/src/SpatialMeshResource.cpp b/gladius/src/SpatialMeshResource.cpp
index 290e34a8..d3bf43d2 100644
--- a/gladius/src/SpatialMeshResource.cpp
+++ b/gladius/src/SpatialMeshResource.cpp
@@ -45,6 +45,18 @@ namespace gladius
             return result;
         }
 
+        inline void padDataToFloatAlignment(std::vector<PrimitiveData> & data,
+                                            std::size_t const alignmentFloats)
+        {
+            if (alignmentFloats == 0u)
+            {
+                return;
+            }
+
+            auto const padding = (alignmentFloats - (data.size() % alignmentFloats)) % alignmentFloats;
+            data.insert(data.end(), padding, 0.0f);
+        }
+
         inline double bytesToMiB(std::size_t const bytes)
         {
             return static_cast<double>(bytes) / static_cast<double>(MEBIBYTE);
@@ -257,6 +269,32 @@ namespace gladius
         ResourceBase::load();
     }
 
+        std::string SpatialMeshResource::formatMeshQualityMessage(
+            std::string const & displayName) const
+        {
+                if (!hasMeshQualityIssues())
+                {
+                        return {};
+                }
+
+                auto const subject = displayName.empty() ? std::string{"mesh resource"}
+                                                                                                 : fmt::format("mesh '{}'", displayName);
+                auto const & quality = m_data.quality;
+                auto message = fmt::format(
+                    "Topology diagnostics for {}: {} boundary edges, {} non-manifold edges, "
+                    "{} degenerate triangles. Signed mesh SDF methods, including NanoVDB, are "
+                    "deterministic only for watertight, consistently oriented meshes.",
+                    subject,
+                    quality.boundaryEdgeCount,
+                    quality.nonManifoldEdgeCount,
+                    quality.degenerateTriangleCount);
+
+                message += " No repair or fallback was applied silently. Enable explicit repair-on-import "
+                                     "and re-import, or select Fast Winding Number when the input is an intentional "
+                                     "triangle soup.";
+                return message;
+        }
+
     std::string SpatialMeshResource::formatNanoVdbBuildMessage(
       std::string const & displayName) const
     {
@@ -440,6 +478,9 @@ namespace gladius
     static constexpr size_t kSignCacheResolutionSlot = 1;  // sign cache resolution per axis
     static constexpr size_t kSignCacheBetaSlot = 1;        // beta used to build the ready sign cache
     static constexpr size_t kNanoVdbOffsetSlot = 1;        // local float offset of the NanoVDB grid (0 = none)
+    static constexpr size_t kFloat2AlignmentFloats = 2;
+    static constexpr size_t kFloat4AlignmentFloats = 4;
+    static constexpr size_t kNanoVdbAlignmentFloats = 8;   // 32 bytes
 
     /// Coarse sign-cache resolution per axis (FWN acceleration). 64^3 = 262144 cells.
     /// Each cell stores a conservative 2-bit state (unknown/outside/inside), so
@@ -490,6 +531,11 @@ namespace gladius
         ProfileFunction;
         GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::write FWN payload", usesFastWindingNumber());
 
+        // Keep the absolute base aligned. Several OpenCL kernels reinterpret float payload data
+        // as float2/float4 or structs containing float4 values, and NanoVDB grids require 32-byte
+        // alignment. Padding here keeps local payload alignment valid after insertion.
+        padDataToFloatAlignment(primitives.data.getData(), kNanoVdbAlignmentFloats);
+
         // Track the base offset before adding our data
         m_dataBaseOffset = static_cast<int>(primitives.data.getSize());
         
@@ -656,6 +702,7 @@ namespace gladius
 
         // Clear previous payload
         m_payloadData.meta.clear();
+        m_payloadData.data.clear();
 
         // Create primitive metadata for the spatial mesh root
         PrimitiveMeta metaData{};
@@ -744,6 +791,7 @@ namespace gladius
 
         // Serialize BVH nodes
         // Each node: bboxMin (4), bboxMax (4), leftChild, rightChild, primStart, primCount = 12 floats
+        padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
         m_nodesOffset = m_payloadData.data.size();
         {
             GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::loadImpl serialize BVH nodes", useFwn);
@@ -766,6 +814,7 @@ namespace gladius
 
         // Serialize triangles
         // Each triangle: v0 (4), v1 (4), v2 (4), faceNormal (4) = 16 floats
+        padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
         m_trianglesOffset = m_payloadData.data.size();
         {
             GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::loadImpl serialize triangles", useFwn);
@@ -792,6 +841,7 @@ namespace gladius
 
         // Serialize vertex normals
         // Each normal: xyz + w (vertex index) = 4 floats
+        padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
         m_normalsOffset = m_payloadData.data.size();
         {
             GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::loadImpl serialize vertex normals", useFwn);
@@ -806,6 +856,7 @@ namespace gladius
 
         // Serialize triangle indices for normal lookup
         // Each triangle: 3 vertex indices = 4 ints (padded)
+        padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
         m_indicesOffset = m_payloadData.data.size();
         {
             GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::loadImpl serialize triangle indices", useFwn);
@@ -820,6 +871,7 @@ namespace gladius
 
         // Serialize per-edge adjacent face normals (3 entries per triangle, 4 floats each).
         // Used by computePseudoNormalFast in mesh_sdf.cl for robust sign on edge features.
+        padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
         m_edgeNeighborsOffset = m_payloadData.data.size();
         {
             GLADIUS_FWN_PREP_SCOPE_IF("SpatialMeshResource::loadImpl serialize edge neighbours", useFwn);
@@ -841,6 +893,7 @@ namespace gladius
         if (useFwn)
         {
             GLADIUS_FWN_PREP_SCOPE("SpatialMeshResource::loadImpl reserve FWN aggregate slots");
+            padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
             m_fwnAggregatesOffset = m_payloadData.data.size();
             size_t const aggregateFloatCount = m_data.nodes.size() * 8u;
             for (size_t i = 0; i < aggregateFloatCount; ++i)
@@ -851,6 +904,7 @@ namespace gladius
 
         // Reserve space for voxel grid data (2 floats per voxel: nearestTriIdx, signedDist)
         // This space will be filled by the buildMeshVoxelGrid kernel on GPU
+        padDataToFloatAlignment(m_payloadData.data, kFloat2AlignmentFloats);
         m_voxelDataOffset = m_payloadData.data.size();
         size_t const voxelDataSize = m_voxelCount * 2;  // 2 floats per voxel
         for (size_t i = 0; i < voxelDataSize; ++i)
@@ -866,6 +920,7 @@ namespace gladius
         if (useFwn)
         {
             GLADIUS_FWN_PREP_SCOPE("SpatialMeshResource::loadImpl reserve FWN sign-cache slots");
+            padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
             m_signCacheDataOffset = m_payloadData.data.size();
             for (size_t i = 0; i < kSignCacheWordCount; ++i)
             {
@@ -1032,6 +1087,7 @@ namespace gladius
                 // -- Companion i+1: SDF_MESH_TRIANGLES (flat vertex buffer) --------------------
                 PrimitiveMeta flatMeshCompanion{};
                 flatMeshCompanion.primitiveType = SDF_MESH_TRIANGLES;
+                padDataToFloatAlignment(m_payloadData.data, kFloat4AlignmentFloats);
                 flatMeshCompanion.start = static_cast<int>(m_payloadData.data.size());
                 for (auto const & tri : m_data.triangles)
                 {
@@ -1048,16 +1104,31 @@ namespace gladius
                 flatMeshCompanion.end = static_cast<int>(m_payloadData.data.size());
 
                 // -- Companion i+2: SDF_VDB (near signed-distance field, user-configured res) --
-                auto const nearSdfTransform = openvdb::math::Transform::createLinearTransform(
-                    static_cast<double>(voxelSize_mm));
+                // Keep the legacy VdbImporter value convention: build the SDF grid in
+                // voxel-scaled coordinates with an identity transform, then store
+                // PrimitiveMeta::scaling as the world_mm -> grid coordinate scale. The OpenCL
+                // vdbModel() sampler divides sampled grid values by the same scale to return
+                // millimetres. Building this grid directly in world space with a non-identity
+                // transform would store millimetre-valued distances and the kernel would scale
+                // them down a second time.
+                float const nearSdfScaling = 1.0f / voxelSize_mm;
+                auto nearSdfVerts = verts;
+                for (auto & vertex : nearSdfVerts)
+                {
+                    vertex *= nearSdfScaling;
+                }
+                auto const nearSdfTransform = openvdb::math::Transform::createLinearTransform(1.0);
                 float constexpr kNearHalfBandVoxels = 8.0f;
                 auto nearSdfGrid = openvdb::tools::meshToLevelSet<openvdb::FloatGrid>(
-                    *nearSdfTransform, verts, tris, kNearHalfBandVoxels);
-                openvdb::tools::changeBackground(nearSdfGrid->tree(),
-                                                 std::numeric_limits<float>::max());
+                    *nearSdfTransform, nearSdfVerts, tris, kNearHalfBandVoxels);
+                // Preserve OpenVDB's signed inactive tiles. The hybrid NanoVDB path uses this
+                // grid as its sign source while face-index grids provide the long-range
+                // magnitude. Replacing all inactive values with +max destroys the negative
+                // interior background and makes closed solids look outside once queries leave
+                // the active narrow band.
                 nearSdfGrid->pruneGrid();
                 PrimitiveMeta sdfVdbCompanion = appendVdbGrid(
-                    openvdb::GridBase::Ptr(nearSdfGrid), 1.0f / voxelSize_mm, SDF_VDB);
+                    openvdb::GridBase::Ptr(nearSdfGrid), nearSdfScaling, SDF_VDB);
                 m_nanovdbGridOffset = static_cast<size_t>(sdfVdbCompanion.start);
 
                 // -- Companion i+3: SDF_VDB_FACE_INDICES (far face-index, fixed 1mm / 150 voxels) --
diff --git a/gladius/src/SpatialMeshResource.h b/gladius/src/SpatialMeshResource.h
index 7663d2da..c18e89ad 100644
--- a/gladius/src/SpatialMeshResource.h
+++ b/gladius/src/SpatialMeshResource.h
@@ -150,6 +150,23 @@ namespace gladius
             return hasNanoVdbBuildIssue();
         }
 
+        /// Mesh topology diagnostics captured during BVH construction.
+        [[nodiscard]] MeshQualityDiagnostics const & getMeshQualityDiagnostics() const noexcept
+        {
+            return m_data.quality;
+        }
+
+        /// True when the source mesh has topology that can make signed SDF sign ambiguous.
+        [[nodiscard]] bool hasMeshQualityIssues() const noexcept
+        {
+            return m_data.quality.hasIssues();
+        }
+
+        /// Format mesh-quality diagnostics into a user-facing message. Returns an empty string
+        /// when the mesh has no recorded quality issues.
+        [[nodiscard]] std::string formatMeshQualityMessage(
+          std::string const & displayName) const;
+
         /// Format the current NanoVDB issue into a user-facing message. Returns an empty string
         /// when the resource has no NanoVDB build issue.
         [[nodiscard]] std::string formatNanoVdbBuildMessage(
diff --git a/gladius/src/compute/ComputeCore.cpp b/gladius/src/compute/ComputeCore.cpp
index 6cc8795d..383a0014 100644
--- a/gladius/src/compute/ComputeCore.cpp
+++ b/gladius/src/compute/ComputeCore.cpp
@@ -5,14 +5,17 @@
 #include <algorithm>
 #include <array>
 #include <cfloat>
+#include <chrono>
 #include <cmath>
+#include <cstdint>
+#include <iostream>
 #include <limits>
 #include <memory>
 #include <optional>
 #include <sstream>
 #include <string>
 #include <utility>
-#include <iostream>
+#include <vector>
 
 #include <fmt/core.h>
 #include <fmt/format.h>
@@ -40,39 +43,38 @@ namespace gladius
     ComputeCore::ComputeCore(SharedComputeContext context,
                              RequiredCapabilities requiredCapabilities,
                              events::SharedLogger logger)
-        : m_contour(std::make_shared<ContourExtractor>(logger))
-        , m_ComputeContext(context)
-        , m_resources(std::make_shared<ResourceContext>(context))
+        : m_ComputeContext(context)
+        , m_sceneState(
+            std::make_shared<RenderSceneGeneration>(context, requiredCapabilities, logger))
+        , m_contour(std::make_shared<ContourExtractor>(logger))
+        , m_resources(m_sceneState->getResources())
+        , m_primitives(m_sceneState->getPrimitives())
         , m_capabilities(requiredCapabilities)
         , m_eventLogger(logger)
-        , m_programs(context, requiredCapabilities, logger, m_resources)
+        , m_programs(&m_sceneState->getProgramManager())
         , m_meshResourceState(std::make_shared<ModelState>())
-    {
-        init();
-    }
+    { init(); }
 
     void ComputeCore::init()
     {
         LOG_LOCATION
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
         createBuffer();
-        m_programs.init();
     }
 
     void ComputeCore::reset()
     {
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
 
+        (void) beginOptimizedSourceGeneration();
         m_boundingBox.reset();
         m_boundingBoxStale.store(false, std::memory_order_release);
-        m_programs.reset();
+        m_programs->reset();
         setSliceHeight(0.f);
     }
 
     ComputeToken ComputeCore::waitForComputeToken()
-    {
-        return ComputeToken(m_computeMutex);
-    }
+    { return ComputeToken(m_computeMutex); }
 
     OptionalComputeToken ComputeCore::requestComputeToken()
     {
@@ -95,9 +97,6 @@ namespace gladius
 
         LOG_LOCATION
 
-        m_primitives = std::make_shared<Primitives>(*m_ComputeContext);
-        m_primitives->create();
-
         if (m_capabilities == RequiredCapabilities::OpenGLInterop)
         {
             LOG_LOCATION
@@ -145,8 +144,8 @@ namespace gladius
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
         m_resources->requestSliceBuffer();
         m_primitives->write();
-        m_programs.getSlicerProgram()->computeMarchingSquareState(*m_primitives,
-                                                                  sliceParameter.zHeight_mm);
+        m_programs->getSlicerProgram()->computeMarchingSquareState(*m_primitives,
+                                                                   sliceParameter.zHeight_mm);
         m_contour->addIsoLineFromMarchingSquare(m_resources->getMarchingSquareStates(),
                                                 m_resources->getClippingArea());
 
@@ -167,7 +166,7 @@ namespace gladius
 
                 auto verticesOut = verticesIn;
 
-                m_programs.getSlicerProgram()->adoptVertexPositions2d(
+                m_programs->getSlicerProgram()->adoptVertexPositions2d(
                   *m_primitives, verticesIn, verticesOut, sliceParameter.zHeight_mm);
                 int i = 0;
                 for (auto & vertex : contour.vertices)
@@ -187,8 +186,9 @@ namespace gladius
     {
         ProfileFunction
 
-        // --- GPU phase: acquire compute mutex, render SDF, copy data to local buffers ---
-        std::vector<cl_float2> localSdfData;
+          // --- GPU phase: acquire compute mutex, render SDF, copy data to local buffers ---
+          std::vector<cl_float2>
+            localSdfData;
         int sdfWidth = 0;
         int sdfHeight = 0;
         float xMin = 0.0f, yMin = 0.0f, xMax = 0.0f, yMax = 0.0f;
@@ -199,8 +199,8 @@ namespace gladius
             m_resources->requestDistanceMaps();
             m_primitives->write();
 
-            m_programs.getSlicerProgram()->renderLayers(
-                *m_primitives, 0.0f, sliceParameter.zHeight_mm);
+            m_programs->getSlicerProgram()->renderLayers(
+              *m_primitives, 0.0f, sliceParameter.zHeight_mm);
 
             auto const & sdfImage = *m_resources->getDistanceMipMaps().back();
             sdfWidth = static_cast<int>(sdfImage.getWidth());
@@ -236,26 +236,27 @@ namespace gladius
             float const px = (pos.x() - xMin) / domainW * static_cast<float>(sdfWidth - 1);
             float const py = (pos.y() - yMin) / domainH * static_cast<float>(sdfHeight - 1);
 
-            int const ix  = std::clamp(static_cast<int>(px), 0, sdfWidth - 1);
-            int const iy  = std::clamp(static_cast<int>(py), 0, sdfHeight - 1);
+            int const ix = std::clamp(static_cast<int>(px), 0, sdfWidth - 1);
+            int const iy = std::clamp(static_cast<int>(py), 0, sdfHeight - 1);
             int const ix1 = std::min(ix + 1, sdfWidth - 1);
             int const iy1 = std::min(iy + 1, sdfHeight - 1);
 
             float const tx = px - static_cast<float>(ix);
             float const ty = py - static_cast<float>(iy);
 
-            auto const idx = [&](int x, int y) {
+            auto const idx = [&](int x, int y)
+            {
                 return static_cast<std::size_t>(y) * static_cast<std::size_t>(sdfWidth) +
                        static_cast<std::size_t>(x);
             };
 
-            float const v00 = localSdfData[idx(ix,  iy )].x;
-            float const v10 = localSdfData[idx(ix1, iy )].x;
-            float const v01 = localSdfData[idx(ix,  iy1)].x;
+            float const v00 = localSdfData[idx(ix, iy)].x;
+            float const v10 = localSdfData[idx(ix1, iy)].x;
+            float const v01 = localSdfData[idx(ix, iy1)].x;
             float const v11 = localSdfData[idx(ix1, iy1)].x;
 
             return v00 * (1.0f - tx) * (1.0f - ty) + v10 * tx * (1.0f - ty) +
-                   v01 * (1.0f - tx) * ty           + v11 * tx * ty;
+                   v01 * (1.0f - tx) * ty + v11 * tx * ty;
         };
 
         // Compute max depth so that the finest cells match the native GPU resolution
@@ -265,8 +266,7 @@ namespace gladius
           std::max(sliceParameter.minFeatureSize_mm, nativeCellSize * 2.0f);
         float const domainSize = std::max(domainW, domainH);
         std::size_t maxDepth = 3U;
-        while (maxDepth < 14U &&
-               (domainSize / static_cast<float>(1U << maxDepth)) > targetCellSize)
+        while (maxDepth < 14U && (domainSize / static_cast<float>(1U << maxDepth)) > targetCellSize)
         {
             ++maxDepth;
         }
@@ -275,13 +275,13 @@ namespace gladius
                                                Eigen::Vector2f{xMax, yMax}};
 
         slicer::MortonQuadtreeConfig cfg;
-        cfg.initialDepth        = 3U;
-        cfg.maxDepth            = maxDepth;
-        cfg.isoValue            = 0.0f;
-        cfg.minFeatureSize      = sliceParameter.minFeatureSize_mm;
+        cfg.initialDepth = 3U;
+        cfg.maxDepth = maxDepth;
+        cfg.isoValue = 0.0f;
+        cfg.minFeatureSize = sliceParameter.minFeatureSize_mm;
         cfg.enableAdaptiveRefinement = false;
-        cfg.maxNodes            = 2000000U;
-        cfg.refinementPasses    = 1U;
+        cfg.maxNodes = 2000000U;
+        cfg.refinementPasses = 1U;
 
         slicer::MortonQuadtree quadtree(quadBounds);
         quadtree.build(cfg);
@@ -314,13 +314,12 @@ namespace gladius
 
         // Self-intersection check for manufacturing safety
         auto const selfIntersectionCount =
-            slicer::QuadtreeContourExtractor::detectSelfIntersections(sparsePolyLines);
+          slicer::QuadtreeContourExtractor::detectSelfIntersections(sparsePolyLines);
         if (selfIntersectionCount > 0U)
         {
-            logMsg(fmt::format(
-                "WARNING: Adaptive contour has {} self-intersection(s). "
-                "Result may not be watertight — do not use for manufacturing.",
-                selfIntersectionCount));
+            logMsg(fmt::format("WARNING: Adaptive contour has {} self-intersection(s). "
+                               "Result may not be watertight — do not use for manufacturing.",
+                               selfIntersectionCount));
         }
 
         // Check for unclosed polylines
@@ -334,10 +333,9 @@ namespace gladius
         }
         if (openCount > 0U)
         {
-            logMsg(fmt::format(
-                "WARNING: Adaptive contour has {} open polyline(s). "
-                "Result may not be watertight — do not use for manufacturing.",
-                openCount));
+            logMsg(fmt::format("WARNING: Adaptive contour has {} open polyline(s). "
+                               "Result may not be watertight — do not use for manufacturing.",
+                               openCount));
         }
 
         // Convert SparsePolyLine → PolyLine and insert into ContourExtractor
@@ -377,14 +375,11 @@ namespace gladius
 
           std::lock_guard<std::recursive_mutex>
             lock(m_computeMutex, std::adopt_lock);
-        if (isAutoUpdateBoundingBoxEnabled())
-        {
-            markBoundingBoxStale();
-        }
 
         auto & paramBuf = getResourceContext()->getParameterBuffer();
         auto & parameter = paramBuf.getData();
-        parameter.clear();
+        std::vector<float> updatedParameter;
+        updatedParameter.reserve(parameter.size());
 
         int currentIndex = 0;
         for (auto & model : assembly.getFunctions())
@@ -413,21 +408,21 @@ namespace gladius
                     if (auto const typedValuePtr = std::get_if<float>(&variant))
                     {
                         param->setLookUpIndex(currentIndex);
-                        parameter.push_back(*typedValuePtr);
+                        updatedParameter.push_back(*typedValuePtr);
                         ++currentIndex;
                     }
                     if (auto const typedValuePtr = std::get_if<int>(&variant))
                     {
                         param->setLookUpIndex(currentIndex);
-                        parameter.push_back(static_cast<float>(*typedValuePtr));
+                        updatedParameter.push_back(static_cast<float>(*typedValuePtr));
                         ++currentIndex;
                     }
                     if (auto const typedValuePtr = std::get_if<nodes::float3>(&variant))
                     {
                         param->setLookUpIndex(currentIndex);
-                        parameter.push_back(typedValuePtr->x);
-                        parameter.push_back(typedValuePtr->y);
-                        parameter.push_back(typedValuePtr->z);
+                        updatedParameter.push_back(typedValuePtr->x);
+                        updatedParameter.push_back(typedValuePtr->y);
+                        updatedParameter.push_back(typedValuePtr->z);
                         currentIndex += 3;
                     }
 
@@ -441,7 +436,7 @@ namespace gladius
                             for (int col = 0; col < 4; ++col)
                             {
                                 float const value = matrix[row][col];
-                                parameter.push_back(value);
+                                updatedParameter.push_back(value);
                                 ++currentIndex;
                             }
                         }
@@ -450,7 +445,23 @@ namespace gladius
             }
         }
 
+        bool const parameterChanged = updatedParameter != parameter;
+        if (parameterChanged)
+        {
+            if (isAutoUpdateBoundingBoxEnabled())
+            {
+                markBoundingBoxStale();
+            }
+        }
+        parameter = std::move(updatedParameter);
         paramBuf.write();
+        if (parameterChanged)
+        {
+            // The GPU parameter buffer now holds new values. Advancing the generation lets
+            // progressive HQ rendering detect a parameter upload that landed mid-fill and restart,
+            // instead of presenting a frame whose upper band used the previous parameters.
+            m_parameterGeneration.fetch_add(1u, std::memory_order_acq_rel);
+        }
         // NOTE: Do NOT call invalidatePreCompSdf() here!
         // We want to keep the old SDF valid for preview rendering during interactive
         // parameter editing. The UI-side m_preComputedSdfDirty flag will trigger new
@@ -462,41 +473,34 @@ namespace gladius
     }
 
     bool ComputeCore::isParameterSignatureCompatible(nodes::Assembly const & assembly) const
-    {
-        return m_programs.isParameterSignatureCompatible(assembly);
-    }
+    { return m_programs->isParameterSignatureCompatible(assembly); }
 
     ParameterSignature const & ComputeCore::getCompiledParameterSignature() const
-    {
-        return m_programs.getCompiledParameterSignature();
-    }
+    { return m_programs->getCompiledParameterSignature(); }
 
     void ComputeCore::setPreCompSdfSize(size_t size)
-    {
-        m_preCompSdfSize = size;
-    }
+    { m_preCompSdfSize = size; }
 
-    size_t ComputeCore::buildMeshVoxelGrids(std::vector<MeshVoxelGridBuildParams> const & buildParams)
+    size_t
+    ComputeCore::buildMeshVoxelGrids(std::vector<MeshVoxelGridBuildParams> const & buildParams)
     {
         ProfileFunction
 
-        if (buildParams.empty())
-        {
-            return 0;
-        }
+          if (buildParams.empty())
+        { return 0; }
 
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
-        
+
         // Ensure primitives are uploaded to GPU
         m_primitives->write();
-        
-        auto meshPreparationProgram = m_programs.getMeshPreparationProgram();
+
+        auto meshPreparationProgram = m_programs->getMeshPreparationProgram();
         if (!meshPreparationProgram)
         {
             logMsg("Cannot build voxel grids: mesh preparation program not available");
             return 0;
         }
-        
+
         size_t successCount = 0;
         for (auto const & params : buildParams)
         {
@@ -505,7 +509,7 @@ namespace gladius
                 ++successCount;
             }
         }
-        
+
         // Wait for all builds to complete
         CL_ERROR(m_ComputeContext->GetQueue().finish());
 
@@ -516,16 +520,17 @@ namespace gladius
             // not upload the original zero-filled cache again.
             m_primitives->data.read();
         }
-        
+
         logMsg(fmt::format("Built {} voxel grids", successCount));
-        
+
         return successCount;
     }
 
-    size_t ComputeCore::buildMeshFwnAggregates(std::vector<MeshFwnAggregateBuildParams> const & buildParams)
+    size_t ComputeCore::buildMeshFwnAggregates(
+      std::vector<MeshFwnAggregateBuildParams> const & buildParams)
     {
-        ProfileFunction
-        GLADIUS_FWN_PREP_SCOPE_IF("ComputeCore::buildMeshFwnAggregates total", !buildParams.empty());
+        ProfileFunction GLADIUS_FWN_PREP_SCOPE_IF("ComputeCore::buildMeshFwnAggregates total",
+                                                  !buildParams.empty());
 
         if (buildParams.empty())
         {
@@ -537,7 +542,7 @@ namespace gladius
 
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
 
-        auto meshPreparationProgram = m_programs.getMeshPreparationProgram();
+        auto meshPreparationProgram = m_programs->getMeshPreparationProgram();
         if (!meshPreparationProgram)
         {
             logMsg("Cannot build mesh FWN aggregates: mesh preparation program not available");
@@ -576,10 +581,11 @@ namespace gladius
         return successCount;
     }
 
-    size_t ComputeCore::buildMeshSignCaches(std::vector<MeshSignCacheBuildParams> const & buildParams)
+    size_t
+    ComputeCore::buildMeshSignCaches(std::vector<MeshSignCacheBuildParams> const & buildParams)
     {
-        ProfileFunction
-        GLADIUS_FWN_PREP_SCOPE_IF("ComputeCore::buildMeshSignCaches queue steps", !buildParams.empty());
+        ProfileFunction GLADIUS_FWN_PREP_SCOPE_IF("ComputeCore::buildMeshSignCaches queue steps",
+                                                  !buildParams.empty());
 
         if (buildParams.empty())
         {
@@ -591,7 +597,7 @@ namespace gladius
 
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
 
-        auto meshPreparationProgram = m_programs.getMeshPreparationProgram();
+        auto meshPreparationProgram = m_programs->getMeshPreparationProgram();
         if (!meshPreparationProgram)
         {
             logMsg("Cannot build mesh sign caches: mesh preparation program not available");
@@ -624,39 +630,27 @@ namespace gladius
         m_primitives->write();
 
         auto inputVertices = vertices;
-        m_programs.getSlicerProgram()->adoptVertexOfMeshToSurface(
+        m_programs->getSlicerProgram()->adoptVertexOfMeshToSurface(
           *m_primitives, inputVertices, vertices);
     }
 
     void ComputeCore::setAutoUpdateBoundingBox(bool autoUpdateBoundingBox)
-    {
-        m_autoUpdateBoundingBox = autoUpdateBoundingBox;
-    }
+    { m_autoUpdateBoundingBox = autoUpdateBoundingBox; }
 
     bool ComputeCore::isAutoUpdateBoundingBoxEnabled() const
-    {
-        return m_autoUpdateBoundingBox;
-    }
+    { return m_autoUpdateBoundingBox; }
 
     bool ComputeCore::isSdfComputationInProgress() const noexcept
-    {
-        return m_sdfComputationInProgress.load();
-    }
+    { return m_sdfComputationInProgress.load(); }
 
     bool ComputeCore::isBoundingBoxComputationInProgress() const noexcept
-    {
-        return m_boundingBoxComputationInProgress.load();
-    }
+    { return m_boundingBoxComputationInProgress.load(); }
 
     ProgramManager & ComputeCore::getProgramManager()
-    {
-        return m_programs;
-    }
+    { return *m_programs; }
 
     ProgramManager const & ComputeCore::getProgramManager() const
-    {
-        return m_programs;
-    }
+    { return *m_programs; }
 
     void ComputeCore::generateContours(nodes::SliceParameter sliceParameter)
     {
@@ -686,7 +680,7 @@ namespace gladius
             lock(m_computeMutex);
 
         m_primitives->write();
-        m_programs.getSlicerProgram()->renderLayers(*m_primitives, 0.0f, m_sliceHeight_mm);
+        m_programs->getSlicerProgram()->renderLayers(*m_primitives, 0.0f, m_sliceHeight_mm);
     }
 
     std::optional<BoundingBox> ComputeCore::getBoundingBox() const
@@ -696,23 +690,19 @@ namespace gladius
 
     bool ComputeCore::isBoundingBoxMeaningful(BoundingBox const & box)
     {
-        auto const values = std::array<float, 6>{box.min.x,
-                                                 box.min.y,
-                                                 box.min.z,
-                                                 box.max.x,
-                                                 box.max.y,
-                                                 box.max.z};
+        auto const values =
+          std::array<float, 6>{box.min.x, box.min.y, box.min.z, box.max.x, box.max.y, box.max.z};
 
-        auto const finite =
-          std::all_of(values.begin(), values.end(), [](float value) { return std::isfinite(value); });
+        auto const finite = std::all_of(
+          values.begin(), values.end(), [](float value) { return std::isfinite(value); });
 
         if (!finite)
         {
             return false;
         }
 
-        bool const ordered = (box.min.x <= box.max.x) && (box.min.y <= box.max.y) &&
-                              (box.min.z <= box.max.z);
+        bool const ordered =
+          (box.min.x <= box.max.x) && (box.min.y <= box.max.y) && (box.min.z <= box.max.z);
 
         return ordered;
     }
@@ -781,9 +771,7 @@ namespace gladius
         ProfileFunction
 
           if (!m_boundingBox)
-        {
-            throw std::runtime_error("Bounding box is not available");
-        }
+        { throw std::runtime_error("Bounding box is not available"); }
 
         cl_float4 const newClippingArea{
           {m_boundingBox->min.x, m_boundingBox->min.y, m_boundingBox->max.x, m_boundingBox->max.y}};
@@ -815,14 +803,14 @@ namespace gladius
             return true;
         }
 
-        if (!m_programs.getSlicerState().isModelUpToDate())
+        if (!m_programs->getSlicerState().isModelUpToDate())
         {
             try
             {
                 logMsg("updateBoundingBoxFast: slicer state not up to date, requesting recompile");
                 recompileIfRequired();
                 logMsg("updateBoundingBoxFast: after recompileIfRequired: " +
-                       m_programs.getDebugStateSummary());
+                       m_programs->getDebugStateSummary());
             }
             catch (...)
             {
@@ -837,7 +825,7 @@ namespace gladius
 
         m_boundingBox = BoundingBox{};
 
-        if (!m_programs.getSlicerProgram()->isValid())
+        if (!m_programs->getSlicerProgram()->isValid())
         {
             try
             {
@@ -853,7 +841,7 @@ namespace gladius
 
         try
         {
-            m_programs.getSlicerProgram()->movePointsToSurface(
+            m_programs->getSlicerProgram()->movePointsToSurface(
               *m_primitives,
               m_resources->getConvexHullInitialVertices(),
               m_resources->getConvexHullVertices());
@@ -959,27 +947,27 @@ namespace gladius
     {
         ProfileFunction
 
-          std::lock_guard<std::recursive_mutex>
-            lock(m_computeMutex);
-        m_programs.setVdbRequired(requiresNanoVdbLocked());
-        m_programs.recompileIfRequired();
+        pollOptimizedSourceGeneration();
+
+        std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
+        m_programs->setVdbRequired(requiresNanoVdbLocked());
+        m_programs->recompileIfRequired();
         LOG_LOCATION;
     }
 
     bool ComputeCore::isCompilationInProgress() const
-    {
-        return m_programs.isBlockingCompilationInProgress();
-    }
+    { return m_programs->isBlockingCompilationInProgress(); }
 
     void ComputeCore::recompileBlockingNoLock()
     {
-        bool const requiresVdb = [&]() {
+        bool const requiresVdb = [&]()
+        {
             std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
             return requiresNanoVdbLocked();
         }();
 
-        m_programs.setVdbRequired(requiresVdb);
-        m_programs.recompileBlockingNoLock();
+        m_programs->setVdbRequired(requiresVdb);
+        m_programs->recompileBlockingNoLock();
     }
 
     void ComputeCore::resetBoundingBox()
@@ -989,14 +977,10 @@ namespace gladius
     }
 
     void ComputeCore::markBoundingBoxStale()
-    {
-        m_boundingBoxStale.store(true, std::memory_order_release);
-    }
+    { m_boundingBoxStale.store(true, std::memory_order_release); }
 
     bool ComputeCore::isBoundingBoxStale() const
-    {
-        return m_boundingBoxStale.load(std::memory_order_acquire);
-    }
+    { return m_boundingBoxStale.load(std::memory_order_acquire); }
 
     void ComputeCore::recomputeStaleBoundingBox()
     {
@@ -1030,7 +1014,7 @@ namespace gladius
         downSkinBuffer.setWidth(size.x);
         downSkinBuffer.setHeight(size.y);
         downSkinBuffer.allocateOnDevice();
-        m_programs.getSlicerProgram()->renderDownSkinDistance(
+        m_programs->getSlicerProgram()->renderDownSkinDistance(
           downSkinBuffer, *m_primitives, m_sliceHeight_mm);
 
         downSkinMap.pixelSize = pixelSize_mm;
@@ -1062,7 +1046,7 @@ namespace gladius
         upSkinBuffer.setWidth(size.x);
         upSkinBuffer.setHeight(size.y);
         upSkinBuffer.allocateOnDevice();
-        m_programs.getSlicerProgram()->renderUpSkinDistance(
+        m_programs->getSlicerProgram()->renderUpSkinDistance(
           upSkinBuffer, *m_primitives, m_sliceHeight_mm);
 
         upSkinMap.pixelSize = pixelSize_mm;
@@ -1078,11 +1062,63 @@ namespace gladius
         return m_ComputeContext;
     }
 
+    SharedRenderSession ComputeCore::createRenderSession() const
+    {
+        std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
+
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.time_s = m_resources->getTime_s();
+        return std::make_shared<RenderSession>(m_sceneState, std::move(inputs));
+    }
+
+    std::optional<SharedRenderSession>
+    ComputeCore::createRenderSession(RenderSceneRevision revision) const
+    {
+        std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
+
+        if (!revision.isSpecified() || !m_sceneState || m_sceneState->getRevision() != revision)
+        {
+            return std::nullopt;
+        }
+
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.time_s = m_resources->getTime_s();
+        return std::make_shared<RenderSession>(m_sceneState, std::move(inputs));
+    }
+
+    void ComputeCore::publishRenderSceneGeneration(SharedRenderSceneGeneration generation)
+    {
+        if (!generation)
+        {
+            throw std::invalid_argument("Cannot publish an empty render scene generation");
+        }
+
+        std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
+
+        auto generationContext = generation->getComputeContext();
+        if (!generationContext)
+        {
+            throw std::invalid_argument("Cannot publish a render scene without a compute context");
+        }
+
+        m_sceneState = std::move(generation);
+        m_ComputeContext = std::move(generationContext);
+        m_resources = m_sceneState->getResources();
+        m_primitives = m_sceneState->getPrimitives();
+        m_programs = &m_sceneState->getProgramManager();
+    }
+
     void ComputeCore::setComputeContext(std::shared_ptr<ComputeContext> context)
     {
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
 
-        m_ComputeContext = std::move(context);
+        auto newSceneState =
+          std::make_shared<RenderSceneGeneration>(context, m_capabilities, m_eventLogger);
+        publishRenderSceneGeneration(std::move(newSceneState));
         reset();
         init();
     }
@@ -1091,7 +1127,8 @@ namespace gladius
     {
         ProfileFunction
 
-        std::lock_guard<std::mutex> lockSliceFuture(m_sliceFutureMutex);
+          std::lock_guard<std::mutex>
+            lockSliceFuture(m_sliceFutureMutex);
 
         if (m_slicingInProgress.load(std::memory_order_acquire))
         {
@@ -1129,9 +1166,7 @@ namespace gladius
               {
                   ComputeCore & core;
                   ~SlicingGuard()
-                  {
-                      core.m_slicingInProgress.store(false, std::memory_order_release);
-                  }
+                  { core.m_slicingInProgress.store(false, std::memory_order_release); }
               } slicingGuard{*this};
 
               FrameMarkEnd("Slicing");
@@ -1160,15 +1195,10 @@ namespace gladius
     }
 
     bool ComputeCore::isSlicingInProgress() const
-    {
-        ProfileFunction
-        return m_slicingInProgress.load(std::memory_order_acquire);
-    }
+    { ProfileFunction return m_slicingInProgress.load(std::memory_order_acquire); }
 
     std::mutex & ComputeCore::getContourExtractorMutex()
-    {
-        return m_contourExtractorMutex;
-    }
+    { return m_contourExtractorMutex; }
 
     void ComputeCore::throwIfNoOpenGL() const
     {
@@ -1202,14 +1232,10 @@ namespace gladius
     }
 
     [[nodiscard]] bool ComputeCore::isAnyCompilationInProgress() const
-    {
-        return m_programs.isAnyCompilationInProgress();
-    }
+    { return m_programs->isAnyCompilationInProgress(); }
 
     [[nodiscard]] bool ComputeCore::isAnyCompilationInProgressNonBlocking() const noexcept
-    {
-        return m_programs.isAnyCompilationInProgressNonBlocking();
-    }
+    { return m_programs->isAnyCompilationInProgressNonBlocking(); }
 
     bool ComputeCore::ensureSlicerProgramReady()
     {
@@ -1218,8 +1244,8 @@ namespace gladius
         try
         {
             std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
-            m_programs.setVdbRequired(requiresNanoVdbLocked());
-            return m_programs.ensureSlicerProgramCompiled();
+            m_programs->setVdbRequired(requiresNanoVdbLocked());
+            return m_programs->ensureSlicerProgramCompiled();
         }
         catch (std::exception const & e)
         {
@@ -1229,15 +1255,109 @@ namespace gladius
     }
 
     bool ComputeCore::updateBBox()
-    {
-        return updateBoundingBoxFast();
-    }
+    { return updateBoundingBoxFast(); }
 
     void ComputeCore::updateBBoxOrThrow()
     {
         ProfileFunction if (!updateBBox())
+        { throw std::runtime_error("Bounding box computation failed"); }
+    }
+
+    std::uint64_t ComputeCore::beginOptimizedSourceGeneration()
+    { return m_optimizedSourceGenerationEpoch.fetch_add(1u, std::memory_order_acq_rel) + 1u; }
+
+    bool ComputeCore::isOptimizedSourceGenerationCurrent(std::uint64_t const generation) const
+    { return m_optimizedSourceGenerationEpoch.load(std::memory_order_acquire) == generation; }
+
+    void ComputeCore::startOptimizedSourceGeneration(nodes::SharedAssembly assembly,
+                                                     ParameterSignature parameterSignature,
+                                                     std::uint64_t const generation)
+    {
+        if (!assembly)
         {
-            throw std::runtime_error("Bounding box computation failed");
+            return;
+        }
+
+        logMsg(fmt::format("Starting optimized source generation job {}", generation));
+
+        auto job = std::async(std::launch::async,
+                              [assembly = std::move(assembly),
+                               parameterSignature = std::move(parameterSignature),
+                               generation]() mutable
+                              {
+                                  OptimizedSourceGenerationResult result;
+                                  result.generation = generation;
+                                  result.parameterSignature = std::move(parameterSignature);
+
+                                  try
+                                  {
+                                      std::stringstream optimizedKernelStream;
+                                      nodes::ToOclVisitor visitor;
+                                      assembly->visitNodes(visitor);
+                                      visitor.write(optimizedKernelStream);
+                                      result.source = optimizedKernelStream.str();
+                                  }
+                                  catch (std::exception const & e)
+                                  {
+                                      result.errorMessage = e.what();
+                                  }
+                                  catch (...)
+                                  {
+                                      result.errorMessage =
+                                        "Unknown error during optimized source generation";
+                                  }
+
+                                  return result;
+                              });
+
+        std::lock_guard<std::mutex> lock(m_optimizedSourceGenerationMutex);
+        m_optimizedSourceGenerationJobs.emplace_back(std::move(job));
+    }
+
+    void ComputeCore::pollOptimizedSourceGeneration()
+    {
+        std::vector<OptimizedSourceGenerationResult> completedResults;
+        {
+            std::lock_guard<std::mutex> lock(m_optimizedSourceGenerationMutex);
+            auto jobIt = m_optimizedSourceGenerationJobs.begin();
+            while (jobIt != m_optimizedSourceGenerationJobs.end())
+            {
+                if (jobIt->wait_for(std::chrono::seconds(0)) == std::future_status::ready)
+                {
+                    completedResults.emplace_back(jobIt->get());
+                    jobIt = m_optimizedSourceGenerationJobs.erase(jobIt);
+                    continue;
+                }
+                ++jobIt;
+            }
+        }
+
+        for (auto & result : completedResults)
+        {
+            if (!isOptimizedSourceGenerationCurrent(result.generation))
+            {
+                logMsg(fmt::format("Discarding stale optimized source generation job {}",
+                                   result.generation));
+                continue;
+            }
+
+            if (!result.errorMessage.empty())
+            {
+                logMsg(fmt::format("Optimized source generation failed: {}", result.errorMessage));
+                continue;
+            }
+
+            if (result.source.empty())
+            {
+                logMsg("Optimized source generation produced an empty source");
+                continue;
+            }
+
+            logMsg(fmt::format("Optimized source generation job {} finished: {} bytes",
+                               result.generation,
+                               result.source.size()));
+            m_programs->setOptimizedModelSource(std::move(result.source), true, true);
+            m_programs->setCompiledParameterSignature(std::move(result.parameterSignature));
         }
     }
 
@@ -1260,10 +1380,16 @@ namespace gladius
             return;
         }
 
+        auto const optimizedSourceGeneration = beginOptimizedSourceGeneration();
+        auto const parameterSignature = ParameterSignature::compute(*assembly);
+
         m_boundingBox.reset();
         invalidatePreCompSdf("refreshProgram");
         auto commandStreamKernel = std::optional<std::string>{};
         auto optimizedKernel = std::optional<std::string>{};
+        bool const generateOptimizedSourceAsync =
+          m_codeGenerator == CodeGenerator::Automatic &&
+          m_programs->isOptimizedRenderCompilationDeferred();
 
         if (m_codeGenerator == CodeGenerator::CommandStream ||
             m_codeGenerator == CodeGenerator::Automatic)
@@ -1289,7 +1415,8 @@ namespace gladius
             commandStreamKernel = modelKernel.str();
         }
 
-        if (m_codeGenerator == CodeGenerator::Code || m_codeGenerator == CodeGenerator::Automatic)
+        if (m_codeGenerator == CodeGenerator::Code ||
+            (m_codeGenerator == CodeGenerator::Automatic && !generateOptimizedSourceAsync))
         {
             std::stringstream optimizedKernelStream;
             nodes::ToOclVisitor visitor;
@@ -1301,12 +1428,32 @@ namespace gladius
 
         if (m_codeGenerator == CodeGenerator::Automatic)
         {
-            if (!commandStreamKernel.has_value() || !optimizedKernel.has_value())
+            if (!commandStreamKernel.has_value())
+            {
+                logMsg("Automatic code generation failed to create a command-stream render source");
+                return;
+            }
+
+            if (generateOptimizedSourceAsync)
+            {
+                m_programs->setPreviewModelSource(*commandStreamKernel);
+                m_programs->setCompiledParameterSignature(parameterSignature);
+                logMsg(
+                  fmt::format("Captured parameter signature: {}", parameterSignature.toString()));
+                logMsg(fmt::format("Published command-stream preview source: {} bytes; optimized "
+                                   "source generation deferred",
+                                   commandStreamKernel->size()));
+                startOptimizedSourceGeneration(
+                  assembly, parameterSignature, optimizedSourceGeneration);
+                return;
+            }
+
+            if (!optimizedKernel.has_value())
             {
                 logMsg("Automatic code generation failed to create both render sources");
                 return;
             }
-            m_programs.setModelSources(*optimizedKernel, *commandStreamKernel, true);
+            m_programs->setModelSources(*optimizedKernel, *commandStreamKernel, true);
         }
         else if (m_codeGenerator == CodeGenerator::CommandStream)
         {
@@ -1315,7 +1462,7 @@ namespace gladius
                 logMsg("Command-stream code generation failed to create a render source");
                 return;
             }
-            m_programs.setModelSources(*commandStreamKernel, *commandStreamKernel, false);
+            m_programs->setModelSources(*commandStreamKernel, *commandStreamKernel, false);
         }
         else if (m_codeGenerator == CodeGenerator::Code)
         {
@@ -1324,16 +1471,12 @@ namespace gladius
                 logMsg("Optimized code generation failed to create a render source");
                 return;
             }
-            m_programs.setModelSource(*optimizedKernel);
+            m_programs->setModelSource(*optimizedKernel);
         }
 
         // Capture parameter signature after code generation for fast-path validation
-        if (assembly)
-        {
-            auto const signature = ParameterSignature::compute(*assembly);
-            m_programs.setCompiledParameterSignature(signature);
-            logMsg(fmt::format("Captured parameter signature: {}", signature.toString()));
-        }
+        m_programs->setCompiledParameterSignature(parameterSignature);
+        logMsg(fmt::format("Captured parameter signature: {}", parameterSignature.toString()));
     }
 
     void ComputeCore::tryRefreshProgramProtected(nodes::SharedAssembly assembly)
@@ -1353,9 +1496,7 @@ namespace gladius
     }
 
     std::optional<bool> ComputeCore::tryIsRenderProgramReady() const
-    {
-        return m_programs.tryIsBestRenderProgramReady();
-    }
+    { return m_programs->tryIsBestRenderProgramReady(); }
 
     [[nodiscard]] bool ComputeCore::isRendererReady() const
     {
@@ -1373,8 +1514,8 @@ namespace gladius
     void ComputeCore::compileSlicerProgramBlocking()
     {
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
-        m_programs.setVdbRequired(requiresNanoVdbLocked());
-        m_programs.recompileBlockingNoLock();
+        m_programs->setVdbRequired(requiresNanoVdbLocked());
+        m_programs->recompileBlockingNoLock();
 
         updateBBox();
     }
@@ -1391,7 +1532,7 @@ namespace gladius
     {
         ProfileFunction std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
         mesh.write();
-        m_programs.getSlicerProgram()->calculateNormals(*m_primitives, mesh);
+        m_programs->getSlicerProgram()->calculateNormals(*m_primitives, mesh);
         mesh.read();
     }
 
@@ -1405,9 +1546,7 @@ namespace gladius
     }
 
     std::string ComputeCore::getProgramStateSummary() const
-    {
-        return m_programs.getDebugStateSummary();
-    }
+    { return m_programs->getDebugStateSummary(); }
 
     cl_int2 ComputeCore::determineBufferSize(float2 pixelSize_mm) const
     {
@@ -1449,33 +1588,33 @@ namespace gladius
     {
         ProfileFunction
 
-                    logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: begin");
+          logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: begin");
 
-        if (!m_programs.getSlicerState().isModelUpToDate())
+        if (!m_programs->getSlicerState().isModelUpToDate())
         {
             recompileIfRequired();
-                        logMsg(fmt::format(
-                            "ComputeCore::precomputeSdfForWholeBuildPlatform: post-recompile state {}",
-                            m_programs.getDebugStateSummary()));
+            logMsg(fmt::format(
+              "ComputeCore::precomputeSdfForWholeBuildPlatform: post-recompile state {}",
+              m_programs->getDebugStateSummary()));
             return false;
         }
 
-        if (!m_programs.getSlicerProgram()->isValid())
+        if (!m_programs->getSlicerProgram()->isValid())
         {
-                        logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: slicer program invalid");
+            logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: slicer program invalid");
             return false;
         }
 
         if (m_precompSdfIsValid.load(std::memory_order_acquire))
         {
-                        logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: SDF already valid");
+            logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: SDF already valid");
             return true;
         }
         updateBBox();
 
         if (!m_boundingBox.has_value())
         {
-                        logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: no bounding box available");
+            logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: no bounding box available");
             return false;
         }
 
@@ -1494,7 +1633,7 @@ namespace gladius
 
         m_resources->allocatePreComputedSdf(m_preCompSdfSize, m_preCompSdfSize, m_preCompSdfSize);
         m_resources->setPreCompSdfBBox(prevCompSdfBBox);
-        m_programs.getSlicerProgram()->precomputeSdf(*m_primitives, prevCompSdfBBox);
+        m_programs->getSlicerProgram()->precomputeSdf(*m_primitives, prevCompSdfBBox);
         m_precompSdfIsValid.store(true, std::memory_order_release);
         logMsg("ComputeCore::precomputeSdfForWholeBuildPlatform: completed successfully");
         return true;
@@ -1509,7 +1648,7 @@ namespace gladius
 
         m_resources->allocatePreComputedSdf(m_preCompSdfSize, m_preCompSdfSize, m_preCompSdfSize);
         m_resources->setPreCompSdfBBox(boundingBox);
-        m_programs.getSlicerProgram()->precomputeSdf(*m_primitives, boundingBox);
+        m_programs->getSlicerProgram()->precomputeSdf(*m_primitives, boundingBox);
     }
 
     cl::Event ComputeCore::precomputeSdfAsync(cl::CommandQueue const & queue)
@@ -1520,29 +1659,33 @@ namespace gladius
 
         // No mutex lock for async operation - caller must ensure thread safety
         // Validate preconditions
-        if (!m_programs.getSlicerState().isModelUpToDate())
+        if (!m_programs->getSlicerState().isModelUpToDate())
         {
-            logMsg("ComputeCore::precomputeSdfAsync: model not up to date, requesting recompilation");
+            logMsg(
+              "ComputeCore::precomputeSdfAsync: model not up to date, requesting recompilation");
             recompileIfRequired();
 
-            if (!m_programs.getSlicerState().isModelUpToDate())
+            if (!m_programs->getSlicerState().isModelUpToDate())
             {
-                logMsg("ComputeCore::precomputeSdfAsync: model still not up to date after recompilation");
+                logMsg("ComputeCore::precomputeSdfAsync: model still not up to date after "
+                       "recompilation");
                 m_sdfComputationInProgress.store(false);
                 return cl::Event{};
             }
             else
             {
-                logMsg("ComputeCore::precomputeSdfAsync: model marked up to date after recompilation");
+                logMsg(
+                  "ComputeCore::precomputeSdfAsync: model marked up to date after recompilation");
             }
         }
 
-        if (!m_programs.getSlicerProgram()->isValid())
+        if (!m_programs->getSlicerProgram()->isValid())
         {
-            logMsg("ComputeCore::precomputeSdfAsync: slicer program invalid, requesting recompilation");
+            logMsg(
+              "ComputeCore::precomputeSdfAsync: slicer program invalid, requesting recompilation");
             recompileIfRequired();
 
-            if (!m_programs.getSlicerProgram()->isValid())
+            if (!m_programs->getSlicerProgram()->isValid())
             {
                 logMsg("ComputeCore::precomputeSdfAsync: slicer program remained invalid");
                 m_sdfComputationInProgress.store(false);
@@ -1550,7 +1693,8 @@ namespace gladius
             }
             else
             {
-                logMsg("ComputeCore::precomputeSdfAsync: slicer program became valid after recompilation");
+                logMsg("ComputeCore::precomputeSdfAsync: slicer program became valid after "
+                       "recompilation");
             }
         }
 
@@ -1577,14 +1721,14 @@ namespace gladius
         }
 
         auto const & bbox = m_boundingBox.value();
-        logMsg(fmt::format(
-          "ComputeCore::precomputeSdfAsync: using bbox min=({:.3f},{:.3f},{:.3f}) max=({:.3f},{:.3f},{:.3f})",
-          bbox.min.x,
-          bbox.min.y,
-          bbox.min.z,
-          bbox.max.x,
-          bbox.max.y,
-          bbox.max.z));
+        logMsg(fmt::format("ComputeCore::precomputeSdfAsync: using bbox min=({:.3f},{:.3f},{:.3f}) "
+                           "max=({:.3f},{:.3f},{:.3f})",
+                           bbox.min.x,
+                           bbox.min.y,
+                           bbox.min.z,
+                           bbox.max.x,
+                           bbox.max.y,
+                           bbox.max.z));
 
         // Expand bounding box with margin
         // When bbox is stale (parameter changed but not yet recomputed), use a larger
@@ -1610,19 +1754,19 @@ namespace gladius
         m_resources->allocatePreComputedSdf(m_preCompSdfSize, m_preCompSdfSize, m_preCompSdfSize);
         m_resources->setPreCompSdfBBox(sdfBBox);
 
-                logMsg(fmt::format(
-                    "ComputeCore::precomputeSdfAsync: launching kernel with bbox min=({:.3f},{:.3f},{:.3f}) max=({:.3f},{:.3f},{:.3f}) size={}",
-                    sdfBBox.min.x,
-                    sdfBBox.min.y,
-                    sdfBBox.min.z,
-                    sdfBBox.max.x,
-                    sdfBBox.max.y,
-                    sdfBBox.max.z,
-                    m_preCompSdfSize));
+        logMsg(fmt::format("ComputeCore::precomputeSdfAsync: launching kernel with bbox "
+                           "min=({:.3f},{:.3f},{:.3f}) max=({:.3f},{:.3f},{:.3f}) size={}",
+                           sdfBBox.min.x,
+                           sdfBBox.min.y,
+                           sdfBBox.min.z,
+                           sdfBBox.max.x,
+                           sdfBBox.max.y,
+                           sdfBBox.max.z,
+                           m_preCompSdfSize));
 
         // Launch async SDF kernel
         cl::Event sdfEvent =
-          m_programs.getSlicerProgram()->precomputeSdfAsync(*m_primitives, sdfBBox, queue);
+          m_programs->getSlicerProgram()->precomputeSdfAsync(*m_primitives, sdfBBox, queue);
 
         if (sdfEvent())
         {
@@ -1655,26 +1799,26 @@ namespace gladius
                    << " precompValid="
                    << (m_precompSdfIsValid.load(std::memory_order_acquire) ? 1 : 0)
                    << " renderProgValid="
-                   << (m_programs.getBestRenderProgram() &&
-                       !m_programs.getBestRenderProgram()->isCompilationInProgress())
+                   << (m_programs->getBestRenderProgram() &&
+                       !m_programs->getBestRenderProgram()->isCompilationInProgress())
                    << " slicerValid="
-                   << (m_programs.getSlicerProgram() && m_programs.getSlicerProgram()->isValid());
+                   << (m_programs->getSlicerProgram() && m_programs->getSlicerProgram()->isValid());
                 logMsg(ss.str());
             }
             catch (...)
             {
             }
             // Ensure model is compiled and up to date
-            if (!m_programs.getSlicerState().isModelUpToDate())
+            if (!m_programs->getSlicerState().isModelUpToDate())
             {
                 // Add explicit debug about model source and states
                 try
                 {
                     logMsg(std::string(
                              "prepareThumbnailGeneration: slicer not up to date; hasModelSource=") +
-                           (m_programs.hasModelSource() ? "1" : "0"));
+                           (m_programs->hasModelSource() ? "1" : "0"));
                     logMsg("prepareThumbnailGeneration: before recompile: " +
-                           m_programs.getDebugStateSummary());
+                           m_programs->getDebugStateSummary());
                 }
                 catch (...)
                 {
@@ -1683,7 +1827,7 @@ namespace gladius
                 recompileIfRequired();
 
                 // Check again after recompilation
-                if (!m_programs.getSlicerState().isModelUpToDate())
+                if (!m_programs->getSlicerState().isModelUpToDate())
                 {
                     // Try a blocking compile as a last resort in headless mode
                     try
@@ -1693,9 +1837,9 @@ namespace gladius
                     catch (...)
                     {
                     }
-                    m_programs.setVdbRequired(requiresNanoVdbLocked());
-                    m_programs.recompileBlockingNoLock();
-                    if (!m_programs.getSlicerState().isModelUpToDate())
+                    m_programs->setVdbRequired(requiresNanoVdbLocked());
+                    m_programs->recompileBlockingNoLock();
+                    if (!m_programs->getSlicerState().isModelUpToDate())
                     {
                         logMsg("Model compilation failed during thumbnail preparation (blocking)");
                         return false;
@@ -1704,7 +1848,7 @@ namespace gladius
                 try
                 {
                     logMsg("prepareThumbnailGeneration: after compile: " +
-                           m_programs.getDebugStateSummary());
+                           m_programs->getDebugStateSummary());
                 }
                 catch (...)
                 {
@@ -1757,14 +1901,10 @@ namespace gladius
     }
 
     SharedGLImageBuffer ComputeCore::getResultImage() const
-    {
-        return m_resultImage.load(std::memory_order_acquire);
-    }
+    { return m_resultImage.load(std::memory_order_acquire); }
 
     SharedGLImageBuffer ComputeCore::getLowResPreviewImage() const
-    {
-        return m_lowResPreviewImage.load(std::memory_order_acquire);
-    }
+    { return m_lowResPreviewImage.load(std::memory_order_acquire); }
 
     SharedContourExtractor ComputeCore::getContour() const
     {
@@ -1783,9 +1923,7 @@ namespace gladius
     }
 
     cl_float ComputeCore::getSliceHeight() const
-    {
-        return m_sliceHeight_mm;
-    }
+    { return m_sliceHeight_mm; }
 
     void ComputeCore::setSliceHeight(cl_float z_mm)
     {
@@ -1795,18 +1933,18 @@ namespace gladius
     }
     SharedSlicerProgram ComputeCore::getSlicerProgram() const
     {
-        return std::shared_ptr<SlicerProgram>(m_programs.getSlicerProgram(),
+        return std::shared_ptr<SlicerProgram>(m_programs->getSlicerProgram(),
                                               [](SlicerProgram *) {}); // Non-owning shared_ptr
     }
     SharedRenderProgram ComputeCore::getBestRenderProgram() const
     {
-        return std::shared_ptr<RenderProgram>(m_programs.getBestRenderProgram(),
+        return std::shared_ptr<RenderProgram>(m_programs->getBestRenderProgram(),
                                               [](RenderProgram *) {}); // Non-owning shared_ptr
     }
 
     std::optional<SharedRenderProgram> ComputeCore::tryGetBestRenderProgram() const
     {
-        auto renderProgram = m_programs.tryGetBestRenderProgram();
+        auto renderProgram = m_programs->tryGetBestRenderProgram();
         if (!renderProgram.has_value() || *renderProgram == nullptr)
         {
             return std::nullopt;
@@ -1815,30 +1953,25 @@ namespace gladius
     }
 
     RenderBackend ComputeCore::getSelectedRenderBackend() const
-    {
-        return m_programs.getSelectedRenderBackend();
-    }
+    { return m_programs->getSelectedRenderBackend(); }
 
     std::optional<RenderBackend> ComputeCore::tryGetSelectedRenderBackend() const
-    {
-        return m_programs.tryGetSelectedRenderBackend();
-    }
+    { return m_programs->tryGetSelectedRenderBackend(); }
 
     SharedRenderProgram ComputeCore::getPreviewRenderProgram() const
     {
-        return std::shared_ptr<RenderProgram>(m_programs.getPreviewRenderProgram(),
+        return std::shared_ptr<RenderProgram>(m_programs->getPreviewRenderProgram(),
                                               [](RenderProgram *) {}); // Non-owning shared_ptr
     }
     SharedRenderProgram ComputeCore::getOptimzedRenderProgram() const
     {
-        return std::shared_ptr<RenderProgram>(m_programs.getOptimizedRenderProgram(),
+        return std::shared_ptr<RenderProgram>(m_programs->getOptimizedRenderProgram(),
                                               [](RenderProgram *) {}); // Non-owning shared_ptr
     }
 
     bool ComputeCore::setScreenResolution(size_t width, size_t height)
     {
-        ProfileFunction auto const currentImage =
-          m_resultImage.load(std::memory_order_acquire);
+        ProfileFunction auto const currentImage = m_resultImage.load(std::memory_order_acquire);
         if (currentImage && (width == currentImage->getWidth()) &&
             (height == currentImage->getHeight()))
         {
@@ -1865,8 +1998,7 @@ namespace gladius
 
     bool ComputeCore::setLowResPreviewResolution(size_t width, size_t height)
     {
-        auto const currentImage =
-          m_lowResPreviewImage.load(std::memory_order_acquire);
+        auto const currentImage = m_lowResPreviewImage.load(std::memory_order_acquire);
         if (currentImage && (width == currentImage->getWidth()) &&
             (height == currentImage->getHeight()))
         {
@@ -1878,8 +2010,7 @@ namespace gladius
         }
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
 
-        auto const latestImage =
-          m_lowResPreviewImage.load(std::memory_order_acquire);
+        auto const latestImage = m_lowResPreviewImage.load(std::memory_order_acquire);
         if (latestImage && (width == latestImage->getWidth()) &&
             (height == latestImage->getHeight()))
         {
@@ -1894,8 +2025,7 @@ namespace gladius
 
     std::pair<size_t, size_t> ComputeCore::getLowResPreviewResolution() const
     {
-        auto const image =
-          m_lowResPreviewImage.load(std::memory_order_acquire);
+        auto const image = m_lowResPreviewImage.load(std::memory_order_acquire);
         if (!image)
         {
             return {0u, 0u};
@@ -1904,14 +2034,10 @@ namespace gladius
     }
 
     SharedPrimitives ComputeCore::getPrimitives() const
-    {
-        return m_primitives;
-    }
+    { return m_primitives; }
 
     SharedResources ComputeCore::getResourceContext() const
-    {
-        return m_resources;
-    }
+    { return m_resources; }
 
     void ComputeCore::renderResultImageInterOp(DistanceMap & sourceImage,
                                                GLImageBuffer & targetImage) const
@@ -1950,7 +2076,7 @@ namespace gladius
           std::lock_guard<std::recursive_mutex>
             lock(m_computeMutex);
         throwIfNoOpenGL();
-        m_programs.getSlicerProgram()->renderResultImageReadPixel(sourceImage, targetImage);
+        m_programs->getSlicerProgram()->renderResultImageReadPixel(sourceImage, targetImage);
     }
 
     void ComputeCore::renderImage(DistanceMap & sourceImage) const
@@ -1995,14 +2121,21 @@ namespace gladius
         ProfileFunction
 
           if (!m_computeMutex.try_lock())
-        {
-            return false;
-        }
+        { return false; }
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
         throwIfNoOpenGL();
         recompileIfRequired();
 
-        if (getBestRenderProgram()->isCompilationInProgress())
+        // Use the non-blocking variant: getBestRenderProgram() would block on
+        // ProgramManager::m_modelSourceMutex while a background compile/model-source
+        // swap holds it, stalling the UI frame. Keep the previous frame instead.
+        auto renderProgram = tryGetBestRenderProgram();
+        if (!renderProgram.has_value())
+        {
+            return false;
+        }
+
+        if ((*renderProgram)->isCompilationInProgress())
         {
             LOG_LOCATION
             return false;
@@ -2015,12 +2148,21 @@ namespace gladius
             return false;
         }
 
-        m_resources->getRenderingSettings().approximation = AM_HYBRID;
+        auto inputs = RenderSessionInputs{m_resources->getRenderingSettings(),
+                                          m_resources->getEyePosition(),
+                                          m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation = AM_HYBRID;
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
         m_lastUsedApproximation = AM_HYBRID;
         m_lastUsedHQApproximation = AM_HYBRID;
-        getBestRenderProgram()->renderScene(
-          *m_primitives, *resultImage, m_sliceHeight_mm, startLine, endLine);
-        m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
+        (*renderProgram)
+          ->renderScene(m_ComputeContext->GetQueue(),
+                        *m_primitives,
+                        *resultImage,
+                        std::move(inputs),
+                        startLine,
+                        endLine);
 
         resultImage->invalidateContent();
 
@@ -2044,29 +2186,38 @@ namespace gladius
           // It does NOT require GL context and does NOT call GL functions
 
           if (!m_computeMutex.try_lock())
-        {
-            return false;
-        }
+        { return false; }
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
 
         // Don't call throwIfNoOpenGL() - we don't need GL for pure compute!
         recompileIfRequired();
 
-        if (getBestRenderProgram()->isCompilationInProgress())
+        auto renderProgram = tryGetBestRenderProgram();
+        if (!renderProgram.has_value())
+        {
+            return false;
+        }
+
+        if ((*renderProgram)->isCompilationInProgress())
         {
             LOG_LOCATION
             return false;
         }
 
-        m_resources->getRenderingSettings().approximation = AM_HYBRID;
+        auto inputs = RenderSessionInputs{m_resources->getRenderingSettings(),
+                                          m_resources->getEyePosition(),
+                                          m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation = AM_HYBRID;
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
         m_lastUsedApproximation = AM_HYBRID;
         m_lastUsedHQApproximation = AM_HYBRID;
 
         // Render directly to the target CL image buffer (no GL involved)
-        cl::Event const renderEvent = getBestRenderProgram()->renderSceneAsync(
-          commandQueue, *m_primitives, targetImage, m_sliceHeight_mm, startLine, endLine);
-
-        m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
+        cl::Event const renderEvent =
+          (*renderProgram)
+            ->renderSceneAsync(
+              commandQueue, *m_primitives, targetImage, std::move(inputs), startLine, endLine);
 
         if (completionEvent != nullptr)
         {
@@ -2084,14 +2235,68 @@ namespace gladius
         return false;
     }
 
-    LowResPreviewRenderStatus ComputeCore::renderLowResPreview() const
+    bool ComputeCore::renderSceneComputeOnlyWithSettings(cl::CommandQueue const & commandQueue,
+                                                         size_t startLine,
+                                                         size_t endLine,
+                                                         ImageRGBA & targetImage,
+                                                         RenderingSettings settings,
+                                                         cl::Event * completionEvent)
     {
         ProfileFunction
 
-        if (!m_computeMutex.try_lock())
+          if (!m_computeMutex.try_lock())
+        { return false; }
+        std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
+
+        recompileIfRequired();
+
+        auto renderProgram = tryGetBestRenderProgram();
+        if (!renderProgram.has_value())
         {
-            return LowResPreviewRenderStatus::Skipped;
+            return false;
         }
+
+        if ((*renderProgram)->isCompilationInProgress())
+        {
+            LOG_LOCATION
+            return false;
+        }
+
+        m_lastUsedApproximation = settings.approximation;
+        m_lastUsedHQApproximation = settings.approximation;
+        m_lastUsedPreviewApproximation = settings.approximation;
+
+        RenderSessionInputs inputs{
+          settings, m_resources->getEyePosition(), m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        cl::Event const renderEvent =
+          (*renderProgram)
+            ->renderSceneAsync(
+              commandQueue, *m_primitives, targetImage, std::move(inputs), startLine, endLine);
+
+        if (completionEvent != nullptr)
+        {
+            *completionEvent = renderEvent;
+        }
+
+        if (renderEvent())
+        {
+            commandQueue.flush();
+            LOG_LOCATION
+            return true;
+        }
+
+        LOG_LOCATION
+        return false;
+    }
+
+    LowResPreviewRenderStatus ComputeCore::renderLowResPreview() const
+    {
+        ProfileFunction
+
+          if (!m_computeMutex.try_lock())
+        { return LowResPreviewRenderStatus::Skipped; }
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
 
         // Low-res preview must stay cheap and independent of mesh complexity.
@@ -2104,32 +2309,43 @@ namespace gladius
 
         throwIfNoOpenGL();
 
+        // Use the non-blocking variant so a background compile holding
+        // ProgramManager::m_modelSourceMutex cannot stall the UI frame.
+        auto renderProgram = tryGetBestRenderProgram();
+        if (!renderProgram.has_value())
+        {
+            return LowResPreviewRenderStatus::Skipped;
+        }
+
         glFinish();
-        auto lowResPreviewImage =
-          m_lowResPreviewImage.load(std::memory_order_acquire);
+        auto lowResPreviewImage = m_lowResPreviewImage.load(std::memory_order_acquire);
         auto resultImage = m_resultImage.load(std::memory_order_acquire);
         if (!lowResPreviewImage || !resultImage)
         {
             return LowResPreviewRenderStatus::Failed;
         }
 
-        m_resources->getRenderingSettings().approximation = AM_ONLY_PRECOMPSDF;
+        auto inputs = RenderSessionInputs{m_resources->getRenderingSettings(),
+                                          m_resources->getEyePosition(),
+                                          m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation = AM_ONLY_PRECOMPSDF;
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
         m_lastUsedApproximation = AM_ONLY_PRECOMPSDF;
         m_lastUsedPreviewApproximation = AM_ONLY_PRECOMPSDF;
 
         // Disable shadows and AO for low-res preview — consistent with precomp-SDF path
         // and avoids expensive shadow rays and AO samples during interactive editing
-        m_resources->getRenderingSettings().flags |= RF_DISABLE_SHADOWS | RF_DISABLE_AO;
-
-        getBestRenderProgram()->renderScene(*m_primitives,
-                                            *lowResPreviewImage,
-                                            m_sliceHeight_mm,
-                                            0,
-                                            lowResPreviewImage->getHeight());
-        m_resources->getRenderingSettings().flags &= ~(RF_DISABLE_SHADOWS | RF_DISABLE_AO);
-        m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
-        getBestRenderProgram()->resample(
-          *lowResPreviewImage, *resultImage, 0, resultImage->getHeight());
+        inputs.settings.flags |= RF_DISABLE_SHADOWS | RF_DISABLE_AO;
+
+        (*renderProgram)
+          ->renderScene(m_ComputeContext->GetQueue(),
+                        *m_primitives,
+                        *lowResPreviewImage,
+                        std::move(inputs),
+                        0,
+                        lowResPreviewImage->getHeight());
+        (*renderProgram)->resample(*lowResPreviewImage, *resultImage, 0, resultImage->getHeight());
         resultImage->invalidateContent();
 
         // Ensure GL texture is updated (especially important for readpixel mode)
@@ -2143,13 +2359,11 @@ namespace gladius
     {
         ProfileFunction
 
-        // Note: No mutex lock - caller is responsible for thread safety
-        // Note: No glFinish() - this is async, caller handles sync via returned event
+          // Note: No mutex lock - caller is responsible for thread safety
+          // Note: No glFinish() - this is async, caller handles sync via returned event
 
-        if (!m_precompSdfIsValid.load(std::memory_order_acquire))
-        {
-            return cl::Event{};
-        }
+          if (!m_precompSdfIsValid.load(std::memory_order_acquire))
+        { return cl::Event{}; }
 
         // Work with a local copy of settings to avoid mutating shared state
         // across threads (the worker thread calls this during streaming preview)
@@ -2162,13 +2376,12 @@ namespace gladius
         // Disable shadows and AO for low-res preview — consistent with precomp-SDF path
         settings.flags |= RF_DISABLE_SHADOWS | RF_DISABLE_AO;
 
-        cl::Event renderEvent = getBestRenderProgram()->renderSceneAsync(queue,
-                                                                         *m_primitives,
-                                                                         targetImage,
-                                                                         settings,
-                                                                         m_sliceHeight_mm,
-                                                                         0,
-                                                                         targetImage.getHeight());
+        RenderSessionInputs inputs{
+          settings, m_resources->getEyePosition(), m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        cl::Event renderEvent = getBestRenderProgram()->renderSceneAsync(
+          queue, *m_primitives, targetImage, std::move(inputs), 0, targetImage.getHeight());
 
         // Flush to ensure commands are submitted to the GPU before returning
         // This is important for proper event completion signaling
@@ -2177,14 +2390,14 @@ namespace gladius
         return renderEvent;
     }
 
-    cl::Event ComputeCore::renderLowResPreviewWithDistanceOutputAsync(
-        cl::CommandQueue const & queue,
-        ImageRGBA & targetImage) const
+    cl::Event
+    ComputeCore::renderLowResPreviewWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                                            ImageRGBA & targetImage) const
     {
         ProfileFunction
 
-        // Ensure distance buffer is allocated for low-res dimensions
-        auto * distanceBuffer = m_resources->getDistanceInitBuffer();
+          // Ensure distance buffer is allocated for low-res dimensions
+          auto * distanceBuffer = m_resources->getDistanceInitBuffer();
         if (!distanceBuffer)
         {
             // Buffer not allocated yet - fall back to regular preview
@@ -2206,34 +2419,34 @@ namespace gladius
         // Disable shadows and AO for low-res preview — consistent with precomp-SDF path
         settings.flags |= RF_DISABLE_SHADOWS | RF_DISABLE_AO;
 
-        cl::Event renderEvent = getBestRenderProgram()->renderSceneWithDistanceOutputAsync(
-            queue,
-            *m_primitives,
-            targetImage,
-            *distanceBuffer,
-            settings,
-            m_sliceHeight_mm,
-            0,
-            targetImage.getHeight());
+        RenderSessionInputs inputs{
+          settings, m_resources->getEyePosition(), m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+        cl::Event renderEvent =
+          getBestRenderProgram()->renderSceneWithDistanceOutputAsync(queue,
+                                                                     *m_primitives,
+                                                                     targetImage,
+                                                                     *distanceBuffer,
+                                                                     std::move(inputs),
+                                                                     0,
+                                                                     targetImage.getHeight());
 
         queue.flush();
 
         return renderEvent;
     }
 
-    bool ComputeCore::renderSceneWithDistanceInit(
-        cl::CommandQueue const & commandQueue,
-        size_t startLine,
-        size_t endLine,
-        ImageRGBA & targetImage,
-        cl::Event * completionEvent)
+    bool ComputeCore::renderSceneWithDistanceInit(cl::CommandQueue const & commandQueue,
+                                                  size_t startLine,
+                                                  size_t endLine,
+                                                  ImageRGBA & targetImage,
+                                                  cl::Event * completionEvent)
     {
         ProfileFunction
 
-        if (!m_computeMutex.try_lock())
-        {
-            return false;
-        }
+          if (!m_computeMutex.try_lock())
+        { return false; }
         std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
 
         recompileIfRequired();
@@ -2248,21 +2461,25 @@ namespace gladius
         if (!distanceBuffer || !m_distanceInitBufferValid.load(std::memory_order_acquire))
         {
             // Fall back to standard rendering if distance buffer not available
-            return renderSceneComputeOnly(commandQueue, startLine, endLine, targetImage, completionEvent);
-        }
-
-        m_resources->getRenderingSettings().approximation = AM_HYBRID;
-
-        cl::Event const renderEvent = getBestRenderProgram()->renderSceneWithDistanceInitAsync(
-            commandQueue,
-            *m_primitives,
-            targetImage,
-            *distanceBuffer,
-            m_sliceHeight_mm,
-            startLine,
-            endLine);
-
-        m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
+            return renderSceneComputeOnly(
+              commandQueue, startLine, endLine, targetImage, completionEvent);
+        }
+
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation = AM_HYBRID;
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+
+        cl::Event const renderEvent =
+          getBestRenderProgram()->renderSceneWithDistanceInitAsync(commandQueue,
+                                                                   *m_primitives,
+                                                                   targetImage,
+                                                                   *distanceBuffer,
+                                                                   std::move(inputs),
+                                                                   startLine,
+                                                                   endLine);
 
         if (completionEvent != nullptr)
         {
@@ -2287,21 +2504,16 @@ namespace gladius
     }
 
     void ComputeCore::invalidateDistanceInitBuffer()
-    {
-        m_distanceInitBufferValid.store(false, std::memory_order_release);
-    }
+    { m_distanceInitBufferValid.store(false, std::memory_order_release); }
 
     void ComputeCore::setDistanceInitBufferValid()
-    {
-        m_distanceInitBufferValid.store(true, std::memory_order_release);
-    }
+    { m_distanceInitBufferValid.store(true, std::memory_order_release); }
 
-    bool ComputeCore::renderSceneWithMetrics(
-        cl::CommandQueue const & commandQueue,
-        size_t startLine,
-        size_t endLine,
-        ImageRGBA & targetImage,
-        cl::Event * completionEvent)
+    bool ComputeCore::renderSceneWithMetrics(cl::CommandQueue const & commandQueue,
+                                             size_t startLine,
+                                             size_t endLine,
+                                             ImageRGBA & targetImage,
+                                             cl::Event * completionEvent)
     {
         ProfileFunction;
 
@@ -2322,18 +2534,21 @@ namespace gladius
         // Get the metrics buffer from ResourceContext
         auto & metricsBuffer = m_resources->getMetricsBuffer();
 
-        m_resources->getRenderingSettings().approximation = AM_HYBRID;
-
-        cl::Event const renderEvent = getBestRenderProgram()->renderSceneWithMetricsAsync(
-            commandQueue,
-            *m_primitives,
-            targetImage,
-            metricsBuffer,
-            m_sliceHeight_mm,
-            startLine,
-            endLine);
-
-        m_resources->getRenderingSettings().approximation = AM_FULL_MODEL;
+        RenderSessionInputs inputs{m_resources->getRenderingSettings(),
+                                   m_resources->getEyePosition(),
+                                   m_resources->getModelViewPerspectiveMat()};
+        inputs.settings.approximation = AM_HYBRID;
+        inputs.settings.z_mm = m_sliceHeight_mm;
+        inputs.settings.time_s = m_resources->getTime_s();
+
+        cl::Event const renderEvent =
+          getBestRenderProgram()->renderSceneWithMetricsAsync(commandQueue,
+                                                              *m_primitives,
+                                                              targetImage,
+                                                              metricsBuffer,
+                                                              std::move(inputs),
+                                                              startLine,
+                                                              endLine);
 
         if (completionEvent != nullptr)
         {
@@ -2356,12 +2571,11 @@ namespace gladius
 
         auto & metricsBuffer = m_resources->getMetricsBuffer();
         RayMarchMetrics zeroMetrics{};
-        cl_int err = m_ComputeContext->GetQueue().enqueueWriteBuffer(
-            metricsBuffer,
-            CL_TRUE,  // blocking write
-            0,
-            sizeof(RayMarchMetrics),
-            &zeroMetrics);
+        cl_int err = m_ComputeContext->GetQueue().enqueueWriteBuffer(metricsBuffer,
+                                                                     CL_TRUE, // blocking write
+                                                                     0,
+                                                                     sizeof(RayMarchMetrics),
+                                                                     &zeroMetrics);
         CL_ERROR(err);
     }
 
@@ -2373,12 +2587,11 @@ namespace gladius
         RayMarchMetrics metrics{};
         auto & metricsBuffer = m_resources->getMetricsBuffer();
 
-        cl_int err = m_ComputeContext->GetQueue().enqueueReadBuffer(
-            metricsBuffer,
-            CL_TRUE,  // blocking read
-            0,
-            sizeof(RayMarchMetrics),
-            &metrics);
+        cl_int err = m_ComputeContext->GetQueue().enqueueReadBuffer(metricsBuffer,
+                                                                    CL_TRUE, // blocking read
+                                                                    0,
+                                                                    sizeof(RayMarchMetrics),
+                                                                    &metrics);
         CL_ERROR(err);
 
         return metrics;
@@ -2400,64 +2613,46 @@ namespace gladius
     }
 
     bool ComputeCore::isSdfValid() const
-    {
-        return m_precompSdfIsValid.load(std::memory_order_acquire);
-    }
+    { return m_precompSdfIsValid.load(std::memory_order_acquire); }
 
     ApproximationMode ComputeCore::getLastUsedApproximation() const
-    {
-        return m_lastUsedApproximation;
-    }
+    { return m_lastUsedApproximation; }
 
     ApproximationMode ComputeCore::getLastUsedPreviewApproximation() const
-    {
-        return m_lastUsedPreviewApproximation;
-    }
+    { return m_lastUsedPreviewApproximation; }
 
     ApproximationMode ComputeCore::getLastUsedHQApproximation() const
-    {
-        return m_lastUsedHQApproximation;
-    }
+    { return m_lastUsedHQApproximation; }
 
     events::SharedLogger ComputeCore::getSharedLogger() const
-    {
-        return m_eventLogger;
-    }
+    { return m_eventLogger; }
 
     CodeGenerator ComputeCore::getCodeGenerator() const
-    {
-        return m_codeGenerator;
-    }
+    { return m_codeGenerator; }
 
     void ComputeCore::setCodeGenerator(CodeGenerator generator)
     {
         m_codeGenerator = generator;
-        m_programs.setCodeGenerator(generator);
+        m_programs->setCodeGenerator(generator);
     }
 
     void ComputeCore::setOptimizedRenderCompilationDeferred(bool const deferred)
-    {
-        m_programs.setOptimizedRenderCompilationDeferred(deferred);
-    }
+    { m_programs->setOptimizedRenderCompilationDeferred(deferred); }
 
     bool ComputeCore::isOptimizedRenderCompilationDeferred() const
-    {
-        return m_programs.isOptimizedRenderCompilationDeferred();
-    }
+    { return m_programs->isOptimizedRenderCompilationDeferred(); }
 
     void ComputeCore::setSlicerCompilationDeferred(bool const deferred)
-    {
-        m_programs.setSlicerCompilationDeferred(deferred);
-    }
+    { m_programs->setSlicerCompilationDeferred(deferred); }
 
     bool ComputeCore::isSlicerCompilationDeferred() const
-    {
-        return m_programs.isSlicerCompilationDeferred();
-    }
+    { return m_programs->isSlicerCompilationDeferred(); }
 
     std::shared_ptr<ModelState> ComputeCore::getMeshResourceState() const
     {
-        std::lock_guard<std::recursive_mutex> lock(m_computeMutex);
+        // The model-state object is created once in the constructor and is never replaced.
+        // Keep this getter lock-free so UI-frame status polling cannot block behind long-running
+        // mesh loading, GPU preparation, or compilation work that owns the compute token.
         return m_meshResourceState;
     }
 
@@ -2472,7 +2667,7 @@ namespace gladius
         }
 
         if (m_codeGenerator != CodeGenerator::CommandStream &&
-            !m_programs.getRendererState().isModelUpToDate())
+            !m_programs->getRendererState().isModelUpToDate())
         {
             logMsg("ComputeCore.createThumbnail: renderer state not up to date");
             throw std::runtime_error("Model is not up to date");
@@ -2512,10 +2707,10 @@ namespace gladius
 
         thumbnailCamera.setAngle(0.6f, -2.0f);
         thumbnailCamera.centerView(bb);
-        thumbnailCamera.update(10000.f);
+        thumbnailCamera.snapToTarget();
         thumbnailCamera.adjustDistanceToTarget(bb, thumbnailSize, thumbnailSize);
 
-        thumbnailCamera.update(10000.f);
+        thumbnailCamera.snapToTarget();
 
         applyCamera(thumbnailCamera);
 
diff --git a/gladius/src/compute/ComputeCore.h b/gladius/src/compute/ComputeCore.h
index 07f05cf1..e48cc50f 100644
--- a/gladius/src/compute/ComputeCore.h
+++ b/gladius/src/compute/ComputeCore.h
@@ -5,7 +5,6 @@
 #include <EventLogger.h>
 #include <GLImageBuffer.h>
 #include <ImageRGBA.h>
-#include <kernel/types.h>
 #include <MeshVoxelGridManager.h>
 #include <ModelState.h>
 #include <RenderProgram.h>
@@ -13,19 +12,26 @@
 #include <SlicerProgram.h>
 #include <compute/Rendering.h>
 #include <compute/types.h>
+#include <kernel/types.h>
 #include <nodes/BuildParameter.h>
 #include <nodes/Model.h>
 #include <nodes/nodesfwd.h>
 #include <ui/OrbitalCamera.h>
 
+#include <compute/ParameterSignature.h>
 #include <compute/ProgramManager.h>
+#include <compute/RenderSceneGeneration.h>
+#include <compute/RenderSession.h>
 
 #include <array>
 #include <atomic>
+#include <cstdint>
 #include <future>
 #include <mutex>
 #include <optional>
+#include <string>
 #include <string_view>
+#include <vector>
 
 namespace cl
 {
@@ -62,45 +68,25 @@ namespace gladius
 
         // Forward methods to the underlying ContourExtractor
         auto & getContour()
-        {
-            return m_contourExtractor->getContour();
-        }
+        { return m_contourExtractor->getContour(); }
         const auto & getContour() const
-        {
-            return m_contourExtractor->getContour();
-        }
+        { return m_contourExtractor->getContour(); }
         auto & getOpenContours()
-        {
-            return m_contourExtractor->getOpenContours();
-        }
+        { return m_contourExtractor->getOpenContours(); }
         auto & getNormals()
-        {
-            return m_contourExtractor->getNormals();
-        }
+        { return m_contourExtractor->getNormals(); }
         const auto & getNormals() const
-        {
-            return m_contourExtractor->getNormals();
-        }
+        { return m_contourExtractor->getNormals(); }
         auto & getSourceVertices()
-        {
-            return m_contourExtractor->getSourceVertices();
-        }
+        { return m_contourExtractor->getSourceVertices(); }
         const auto & getSourceVertices() const
-        {
-            return m_contourExtractor->getSourceVertices();
-        }
+        { return m_contourExtractor->getSourceVertices(); }
         const auto & getSliceQuality() const
-        {
-            return m_contourExtractor->getSliceQuality();
-        }
+        { return m_contourExtractor->getSliceQuality(); }
         void clear()
-        {
-            m_contourExtractor->clear();
-        }
+        { m_contourExtractor->clear(); }
         void setSimplificationTolerance(float tol)
-        {
-            m_contourExtractor->setSimplificationTolerance(tol);
-        }
+        { m_contourExtractor->setSimplificationTolerance(tol); }
         void addIsoLineFromMarchingSquare(MarchingSquaresStates & states,
                                           float4 const & clippingArea)
         {
@@ -108,21 +94,13 @@ namespace gladius
             m_contourExtractor->addIsoLineFromMarchingSquare(states, clippingArea);
         }
         void runPostProcessing()
-        {
-            m_contourExtractor->runPostProcessing();
-        }
+        { m_contourExtractor->runPostProcessing(); }
         void calcAreas()
-        {
-            m_contourExtractor->calcAreas();
-        }
+        { m_contourExtractor->calcAreas(); }
         void calcSign()
-        {
-            m_contourExtractor->calcSign();
-        }
+        { m_contourExtractor->calcSign(); }
         PolyLines generateOffsetContours(float offset, const PolyLines & contours) const
-        {
-            return m_contourExtractor->generateOffsetContours(offset, contours);
-        }
+        { return m_contourExtractor->generateOffsetContours(offset, contours); }
         // Simple version for backward compatibility
         PolyLines generateOffsetContours(float offset) const
         {
@@ -132,19 +110,13 @@ namespace gladius
 
         // Allow direct access to the underlying shared_ptr when needed
         SharedContourExtractor getSharedPtr() const
-        {
-            return m_contourExtractor;
-        }
+        { return m_contourExtractor; }
 
         // Allow using the wrapper as a ContourExtractor reference
         operator ContourExtractor &()
-        {
-            return *m_contourExtractor;
-        }
+        { return *m_contourExtractor; }
         operator const ContourExtractor &() const
-        {
-            return *m_contourExtractor;
-        }
+        { return *m_contourExtractor; }
 
       private:
         SharedContourExtractor m_contourExtractor;
@@ -162,105 +134,57 @@ namespace gladius
         {
         } // Forward methods to the underlying ResourceContext
         auto & getRenderingSettings()
-        {
-            return m_resources->getRenderingSettings();
-        }
+        { return m_resources->getRenderingSettings(); }
         auto & getParameterBuffer()
-        {
-            return m_resources->getParameterBuffer();
-        }
+        { return m_resources->getParameterBuffer(); }
         auto & getCommandBuffer()
-        {
-            return m_resources->getCommandBuffer();
-        }
+        { return m_resources->getCommandBuffer(); }
         auto & getPrecompSdfBuffer()
-        {
-            return m_resources->getPrecompSdfBuffer();
-        }
+        { return m_resources->getPrecompSdfBuffer(); }
         auto getClippingArea() const
-        {
-            return m_resources->getClippingArea();
-        }
+        { return m_resources->getClippingArea(); }
         void setClippingArea(cl_float4 area, float padding = 0.0f)
-        {
-            m_resources->setClippingArea(area, padding);
-        }
+        { m_resources->setClippingArea(area, padding); }
         MarchingSquaresStates & getMarchingSquareStates()
-        {
-            return m_resources->getMarchingSquareStates();
-        }
+        { return m_resources->getMarchingSquareStates(); }
         void requestSliceBuffer()
-        {
-            m_resources->requestSliceBuffer();
-        }
+        { m_resources->requestSliceBuffer(); }
         void requestDistanceMaps()
-        {
-            m_resources->requestDistanceMaps();
-        }
+        { m_resources->requestDistanceMaps(); }
         DistanceMipMaps & getDistanceMipMaps()
-        {
-            return m_resources->getDistanceMipMaps();
-        }
+        { return m_resources->getDistanceMipMaps(); }
         auto getEyePosition() const
-        {
-            return m_resources->getEyePosition();
-        }
+        { return m_resources->getEyePosition(); }
         void setEyePosition(cl_float4 position)
-        {
-            m_resources->setEyePosition(position);
-        }
+        { m_resources->setEyePosition(position); }
         auto getModelViewPerspectiveMat() const
-        {
-            return m_resources->getModelViewPerspectiveMat();
-        }
+        { return m_resources->getModelViewPerspectiveMat(); }
         void setModelViewPerspectiveMat(cl_float16 mat)
-        {
-            m_resources->setModelViewPerspectiveMat(mat);
-        }
+        { m_resources->setModelViewPerspectiveMat(mat); }
         auto & getConvexHullVertices()
-        {
-            return m_resources->getConvexHullVertices();
-        }
+        { return m_resources->getConvexHullVertices(); }
         auto & getConvexHullInitialVertices()
-        {
-            return m_resources->getConvexHullInitialVertices();
-        }
+        { return m_resources->getConvexHullInitialVertices(); }
         void initConvexHullVertices()
-        {
-            m_resources->initConvexHullVertices();
-        }
+        { m_resources->initConvexHullVertices(); }
         void allocatePreComputedSdf(size_t width = 0, size_t height = 0, size_t depth = 0)
-        {
-            m_resources->allocatePreComputedSdf(width, height, depth);
-        }
+        { m_resources->allocatePreComputedSdf(width, height, depth); }
         void setPreCompSdfBBox(const BoundingBox & box)
-        {
-            m_resources->setPreCompSdfBBox(box);
-        }
+        { m_resources->setPreCompSdfBBox(box); }
         void releasePreComputedSdf()
-        {
-            m_resources->releasePreComputedSdf();
-        }
+        { m_resources->releasePreComputedSdf(); }
         void clearImageStacks()
-        {
-            m_resources->clearImageStacks();
-        }
+        { m_resources->clearImageStacks(); }
 
         // Allow direct access to the underlying shared_ptr when needed
         SharedResources getSharedPtr() const
-        {
-            return m_resources;
-        }
+        { return m_resources; }
 
         // Allow using the wrapper as a ResourceContext reference
         operator ResourceContext &()
-        {
-            return *m_resources;
-        }
+        { return *m_resources; }
         operator const ResourceContext &() const
-        {
-            return *m_resources;
-        }
+        { return *m_resources; }
 
       private:
         SharedResources m_resources;
@@ -280,33 +204,21 @@ namespace gladius
         {
         } // Forward methods to the underlying ComputeContext
         bool isValid() const
-        {
-            return m_context->isValid();
-        }
+        { return m_context->isValid(); }
         const cl::CommandQueue & GetQueue()
-        {
-            return m_context->GetQueue();
-        }
+        { return m_context->GetQueue(); }
         OutputMethod outputMethod() const
-        {
-            return m_context->outputMethod();
-        }
+        { return m_context->outputMethod(); }
 
         // Allow direct access to the underlying shared_ptr when needed
         SharedComputeContext getSharedPtr() const
-        {
-            return m_context;
-        }
+        { return m_context; }
 
         // Allow using the wrapper as a ComputeContext reference
         operator ComputeContext &()
-        {
-            return *m_context;
-        }
+        { return *m_context; }
         operator const ComputeContext &() const
-        {
-            return *m_context;
-        }
+        { return *m_context; }
 
       private:
         SharedComputeContext m_context;
@@ -328,33 +240,21 @@ namespace gladius
 
         // Forward methods to the underlying ModelState
         bool isModelUpToDate() const
-        {
-            return m_modelState->isModelUpToDate();
-        }
+        { return m_modelState->isModelUpToDate(); }
         void signalCompilationStarted()
-        {
-            m_modelState->signalCompilationStarted();
-        }
+        { m_modelState->signalCompilationStarted(); }
         void signalCompilationFinished()
-        {
-            m_modelState->signalCompilationFinished();
-        }
+        { m_modelState->signalCompilationFinished(); }
 
         // Allow direct access to the underlying shared_ptr when needed
         std::shared_ptr<ModelState> getSharedPtr() const
-        {
-            return m_modelState;
-        }
+        { return m_modelState; }
 
         // Allow using the wrapper as a ModelState reference
         operator ModelState &()
-        {
-            return *m_modelState;
-        }
+        { return *m_modelState; }
         operator const ModelState &() const
-        {
-            return *m_modelState;
-        }
+        { return *m_modelState; }
 
       private:
         std::shared_ptr<ModelState> m_modelState;
@@ -374,29 +274,19 @@ namespace gladius
 
         // Forward methods to access the underlying Primitives data
         auto & data()
-        {
-            return m_primitives->data;
-        }
+        { return m_primitives->data; }
         const auto & data() const
-        {
-            return m_primitives->data;
-        }
+        { return m_primitives->data; }
 
         // Allow direct access to the underlying shared_ptr when needed
         SharedPrimitives getSharedPtr() const
-        {
-            return m_primitives;
-        }
+        { return m_primitives; }
 
         // Allow using the wrapper as a Primitives reference
         operator Primitives &()
-        {
-            return *m_primitives;
-        }
+        { return *m_primitives; }
         operator const Primitives &() const
-        {
-            return *m_primitives;
-        }
+        { return *m_primitives; }
 
       private:
         SharedPrimitives m_primitives;
@@ -434,21 +324,39 @@ namespace gladius
                                                   ImageRGBA & targetImage,
                                                   cl::Event * completionEvent = nullptr);
 
+        /// @brief Render scene to a pure OpenCL image buffer with caller-provided settings.
+        /// @param commandQueue OpenCL command queue used for dispatch
+        /// @param startLine Starting line for rendering
+        /// @param endLine Ending line for rendering
+        /// @param targetImage Pure CL image buffer to render into (no GL texture)
+        /// @param settings Rendering settings copy used for this dispatch
+        /// @param completionEvent Optional event for async completion tracking
+        /// @return true if rendering was enqueued successfully, false otherwise
+        /// @thread Any thread with compute context access
+        [[nodiscard]] bool
+        renderSceneComputeOnlyWithSettings(cl::CommandQueue const & commandQueue,
+                                           size_t startLine,
+                                           size_t endLine,
+                                           ImageRGBA & targetImage,
+                                           RenderingSettings settings,
+                                           cl::Event * completionEvent = nullptr);
+
         /// @brief Render the current low-resolution preview when the precomputed SDF is ready.
-        /// @return Rendered when a preview frame was produced, Skipped when the SDF is not ready, or Failed on an execution/precondition error.
+        /// @return Rendered when a preview frame was produced, Skipped when the SDF is not ready,
+        /// or Failed on an execution/precondition error.
         [[nodiscard]] LowResPreviewRenderStatus renderLowResPreview() const;
 
         /**
          * @brief Starts asynchronous low-resolution preview render (non-blocking).
-         * 
+         *
          * Unlike renderLowResPreview(), this method does not call glFinish() and returns
          * an OpenCL event for async completion tracking. The caller is responsible for
          * synchronization and texture binding.
-         * 
+         *
          * @param queue OpenCL command queue to use for async execution
          * @param targetImage Pure CL image buffer to render into (no GL texture)
          * @return OpenCL event that signals when rendering is complete
-         * 
+         *
          * @thread Any thread with compute context access
          * @note Does not call bind() on result image - caller must handle GL texture update
          */
@@ -468,9 +376,9 @@ namespace gladius
          * @thread Any thread with compute context access
          * @see renderSceneWithDistanceInit for using the distance buffer
          */
-        [[nodiscard]] cl::Event renderLowResPreviewWithDistanceOutputAsync(
-            cl::CommandQueue const & queue,
-            ImageRGBA & targetImage) const;
+        [[nodiscard]] cl::Event
+        renderLowResPreviewWithDistanceOutputAsync(cl::CommandQueue const & queue,
+                                                   ImageRGBA & targetImage) const;
 
         /**
          * @brief Renders scene using distance initialization from a previous low-res pass.
@@ -485,18 +393,19 @@ namespace gladius
          * @param completionEvent Optional event for async completion tracking
          * @return true if rendering succeeded, false otherwise
          *
-         * @pre Distance init buffer must be populated via renderLowResPreviewWithDistanceOutputAsync
+         * @pre Distance init buffer must be populated via
+         * renderLowResPreviewWithDistanceOutputAsync
          * @thread Any thread with compute context access
          */
-        [[nodiscard]] bool renderSceneWithDistanceInit(
-            cl::CommandQueue const & commandQueue,
-            size_t startLine,
-            size_t endLine,
-            ImageRGBA & targetImage,
-            cl::Event * completionEvent = nullptr);
+        [[nodiscard]] bool renderSceneWithDistanceInit(cl::CommandQueue const & commandQueue,
+                                                       size_t startLine,
+                                                       size_t endLine,
+                                                       ImageRGBA & targetImage,
+                                                       cl::Event * completionEvent = nullptr);
 
         /**
-         * @brief Returns true if the distance init buffer is valid and can be used for HQ rendering.
+         * @brief Returns true if the distance init buffer is valid and can be used for HQ
+         * rendering.
          * @return true if distance buffer has been populated and matches current parameters
          */
         [[nodiscard]] bool isDistanceInitBufferValid() const;
@@ -514,7 +423,7 @@ namespace gladius
 
         /**
          * @brief Render scene with metrics collection for performance analysis (T033/SC-002).
-         * 
+         *
          * Renders the scene while collecting ray marching metrics (total rays, total steps,
          * cache hits, non-converged rays). Use readMetricsBuffer() after completion to retrieve.
          *
@@ -525,12 +434,11 @@ namespace gladius
          * @param completionEvent Optional event for async completion tracking
          * @return true if rendering succeeded, false otherwise
          */
-        [[nodiscard]] bool renderSceneWithMetrics(
-            cl::CommandQueue const & commandQueue,
-            size_t startLine,
-            size_t endLine,
-            ImageRGBA & targetImage,
-            cl::Event * completionEvent = nullptr);
+        [[nodiscard]] bool renderSceneWithMetrics(cl::CommandQueue const & commandQueue,
+                                                  size_t startLine,
+                                                  size_t endLine,
+                                                  ImageRGBA & targetImage,
+                                                  cl::Event * completionEvent = nullptr);
 
         /// @brief Clear metrics buffer before starting a metrics collection pass
         void clearMetricsBuffer();
@@ -552,11 +460,11 @@ namespace gladius
         /// @return true if preparation succeeded, false otherwise
         bool prepareImageRendering();
         [[nodiscard]] SharedGLImageBuffer getResultImage() const;
-        
+
         /// @brief Returns the low-resolution preview image buffer.
         /// @return Shared pointer to the low-res preview image, may be null if not initialized.
         [[nodiscard]] SharedGLImageBuffer getLowResPreviewImage() const;
-        
+
         [[nodiscard]] SharedContourExtractor getContour() const;
 
         [[nodiscard]] cl_float getSliceHeight() const;
@@ -609,6 +517,23 @@ namespace gladius
 
         [[nodiscard]] SharedComputeContext getComputeContext() const;
 
+        /// @brief Retain the current scene and copy its camera/settings for one render session.
+        [[nodiscard]] SharedRenderSession createRenderSession() const;
+
+        /// @brief Retain the current scene only when it represents the requested document revision.
+        /// @return A session for the exact revision, or std::nullopt for an untagged/mismatched
+        /// generation.
+        [[nodiscard]] std::optional<SharedRenderSession>
+        createRenderSession(RenderSceneRevision revision) const;
+
+        /// @brief Publish a fully materialized render generation.
+        ///
+        /// The generation becomes the source for new render sessions and the legacy aliases
+        /// exposed by ComputeCore are rebound as one operation. Existing sessions retain their
+        /// previous generation through their shared ownership. The caller must hold the compute
+        /// resource/build barrier while materializing the generation.
+        void publishRenderSceneGeneration(SharedRenderSceneGeneration generation);
+
         void compileSlicerProgramBlocking();
 
         void logMsg(std::string msg) const;
@@ -618,7 +543,7 @@ namespace gladius
 
         void recompileIfRequired();
         void recompileBlockingNoLock();
-        
+
         /// Check if OpenCL program compilation is currently in progress
         [[nodiscard]] bool isCompilationInProgress() const;
 
@@ -641,7 +566,8 @@ namespace gladius
 
         bool requestContourUpdate(nodes::SliceParameter sliceParameter);
 
-        /// Invalidate cached contour height so the next requestContourUpdate triggers a recomputation.
+        /// Invalidate cached contour height so the next requestContourUpdate triggers a
+        /// recomputation.
         void invalidateContourCache();
 
         bool isSlicingInProgress() const;
@@ -680,6 +606,15 @@ namespace gladius
         [[nodiscard]] bool tryToupdateParameter(nodes::Assembly & assembly);
         [[nodiscard]] bool updateParameterBlocking(nodes::Assembly & assembly);
 
+        /// @brief Monotonic counter of GPU parameter-buffer uploads that actually changed the
+        /// model parameters. Incremented inside updateParameterBlocking() right after the new
+        /// values are written to the parameter buffer. Progressive HQ rendering uses this to
+        /// detect a parameter upload that lands mid-fill (which would otherwise leave the upper
+        /// band rendered with the old parameters and the lower band with the new ones).
+        /// @return The current parameter generation.
+        [[nodiscard]] std::uint64_t getParameterGeneration() const
+        { return m_parameterGeneration.load(std::memory_order_acquire); }
+
         /// Check if parameter structure matches compiled signature (fast path possible)
         [[nodiscard]] bool isParameterSignatureCompatible(nodes::Assembly const & assembly) const;
 
@@ -687,15 +622,17 @@ namespace gladius
         [[nodiscard]] ParameterSignature const & getCompiledParameterSignature() const;
 
         void setPreCompSdfSize(size_t size);
-        
+
         /// Build voxel acceleration grids for spatial mesh resources
-        /// @param buildParams Vector of build parameters from ResourceManager::collectVoxelGridBuildParams()
+        /// @param buildParams Vector of build parameters from
+        /// ResourceManager::collectVoxelGridBuildParams()
         /// @return Number of grids successfully built
         size_t buildMeshVoxelGrids(std::vector<MeshVoxelGridBuildParams> const & buildParams);
 
         /// Build Fast-Winding-Number aggregate buffers for spatial mesh resources.
         /// This is a prerequisite for FWN rendering and sign-cache construction.
-        /// @param buildParams Vector of build parameters from ResourceManager::collectFwnAggregateBuildParams()
+        /// @param buildParams Vector of build parameters from
+        /// ResourceManager::collectFwnAggregateBuildParams()
         /// @return Number of aggregate buffers successfully built
         size_t buildMeshFwnAggregates(std::vector<MeshFwnAggregateBuildParams> const & buildParams);
 
@@ -703,7 +640,8 @@ namespace gladius
         /// The kernels and final ready-offset patch are queued without waiting;
         /// until the ready patch executes, the render kernel sees offset 0 and
         /// falls back to full FWN.
-        /// @param buildParams Vector of build parameters from ResourceManager::collectSignCacheBuildParams()
+        /// @param buildParams Vector of build parameters from
+        /// ResourceManager::collectSignCacheBuildParams()
         /// @return Number of sign-cache build steps successfully queued
         size_t buildMeshSignCaches(std::vector<MeshSignCacheBuildParams> const & buildParams);
 
@@ -726,8 +664,8 @@ namespace gladius
 
       private:
         bool updateBoundingBoxFast();
-                [[nodiscard]] static bool isBoundingBoxMeaningful(BoundingBox const & box);
-                [[nodiscard]] std::optional<BoundingBox> computeBoundingBoxFromPrimitives() const;
+        [[nodiscard]] static bool isBoundingBoxMeaningful(BoundingBox const & box);
+        [[nodiscard]] std::optional<BoundingBox> computeBoundingBoxFromPrimitives() const;
         [[nodiscard]] bool ensureSlicerProgramReady();
         void throwIfNoOpenGL() const;
         [[nodiscard]] events::Logger & getLogger() const;
@@ -747,16 +685,39 @@ namespace gladius
         void generateContourMarchingSquare(nodes::SliceParameter const & sliceParameter);
         void generateContourQuadtree(nodes::SliceParameter const & sliceParameter);
 
+        struct OptimizedSourceGenerationResult
+        {
+            std::uint64_t generation = 0u;
+            std::string source;
+            ParameterSignature parameterSignature;
+            std::string errorMessage;
+        };
+
+        [[nodiscard]] std::uint64_t beginOptimizedSourceGeneration();
+        [[nodiscard]] bool isOptimizedSourceGenerationCurrent(std::uint64_t generation) const;
+        void startOptimizedSourceGeneration(nodes::SharedAssembly assembly,
+                                            ParameterSignature parameterSignature,
+                                            std::uint64_t generation);
+        void pollOptimizedSourceGeneration();
+
         mutable std::recursive_mutex m_computeMutex; // TODO: replace with std::mutex
+
+        // Keep the OpenCL context before every member that owns buffers/images referencing it.
+        // Members are destroyed in reverse declaration order; the context must therefore be
+        // declared first so GPU resources can release themselves while the context is still alive.
+        SharedComputeContext m_ComputeContext;
+
+        /// Owns the context-bound scene resources and programs. The aliases below preserve the
+        /// existing ComputeCore API while the render-session refactor is completed.
+        SharedRenderSceneGeneration m_sceneState;
+
         SharedContourExtractor m_contour;
+        SharedResources m_resources;
         mutable std::atomic<SharedGLImageBuffer> m_resultImage;
         mutable std::atomic<SharedGLImageBuffer> m_lowResPreviewImage;
         std::shared_ptr<ImageRGBA> m_thumbnailImage;
         std::shared_ptr<ImageRGBA> m_thumbnailImageHighRes;
-
         SharedPrimitives m_primitives;
-        SharedComputeContext m_ComputeContext;
-        SharedResources m_resources;
 
         double layerThickness_mm = 0.05;
         cl_float m_sliceHeight_mm{0.0f};
@@ -804,6 +765,13 @@ namespace gladius
 
         SharedKernelReplacements m_kernelReplacements;
 
-        ProgramManager m_programs;
+        std::atomic<std::uint64_t> m_optimizedSourceGenerationEpoch{0u};
+        std::mutex m_optimizedSourceGenerationMutex;
+        std::vector<std::future<OptimizedSourceGenerationResult>> m_optimizedSourceGenerationJobs;
+
+        /// Monotonic generation of GPU parameter-buffer uploads that changed the parameters.
+        std::atomic<std::uint64_t> m_parameterGeneration{1u};
+
+        ProgramManager * m_programs;
     };
 }
diff --git a/gladius/src/compute/GpuAccessCoordinator.cpp b/gladius/src/compute/GpuAccessCoordinator.cpp
new file mode 100644
index 00000000..2db21fa6
--- /dev/null
+++ b/gladius/src/compute/GpuAccessCoordinator.cpp
@@ -0,0 +1,451 @@
+#include "GpuAccessCoordinator.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace gladius
+{
+    namespace
+    {
+        [[nodiscard]] bool isValidEvent(GpuEventId const eventId) noexcept
+        {
+            return eventId != 0u;
+        }
+
+        void appendUniqueEvent(std::vector<GpuEventId> & events, GpuEventId const eventId)
+        {
+            if (!isValidEvent(eventId))
+            {
+                return;
+            }
+
+            if (std::find(events.begin(), events.end(), eventId) == events.end())
+            {
+                events.push_back(eventId);
+            }
+        }
+    }
+
+    GpuResourceHandle GpuAccessCoordinator::registerResource(GpuResourceKind const kind,
+                                                             std::string debugName,
+                                                             GpuResourceGeneration initialGeneration)
+    {
+        if (initialGeneration == 0u)
+        {
+            initialGeneration = 1u;
+        }
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        GpuResourceId const resourceId = m_nextResourceId++;
+        ResourceState resource{};
+        resource.resourceId = resourceId;
+        resource.currentGeneration = initialGeneration;
+        resource.kind = kind;
+        resource.debugName = std::move(debugName);
+        resource.generations.emplace(initialGeneration,
+                                     GenerationState{.generation = initialGeneration});
+
+        m_resources.emplace(resourceId, std::move(resource));
+        return GpuResourceHandle{.resourceId = resourceId, .generation = initialGeneration};
+    }
+
+    std::optional<GpuResourceHandle>
+    GpuAccessCoordinator::currentHandle(GpuResourceId const resourceId) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        auto const resourceIt = m_resources.find(resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return std::nullopt;
+        }
+
+        return GpuResourceHandle{.resourceId = resourceId,
+                                 .generation = resourceIt->second.currentGeneration};
+    }
+
+    std::optional<GpuResourceDebugInfo>
+    GpuAccessCoordinator::debugInfo(GpuResourceId const resourceId) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        auto const resourceIt = m_resources.find(resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return std::nullopt;
+        }
+
+        auto const & resource = resourceIt->second;
+        return GpuResourceDebugInfo{.resourceId = resource.resourceId,
+                                    .currentGeneration = resource.currentGeneration,
+                                    .kind = resource.kind,
+                                    .debugName = resource.debugName};
+    }
+
+    GpuAccessPlan GpuAccessCoordinator::beginAccess(GpuAccessRequest request)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        auto resourceIt = m_resources.find(request.resource.resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return GpuAccessPlan{.status = GpuAccessStatus::UnknownResource};
+        }
+
+        auto & resource = resourceIt->second;
+        if (request.resource.generation != resource.currentGeneration)
+        {
+            return GpuAccessPlan{.status = GpuAccessStatus::StaleGeneration};
+        }
+
+        auto generationIt = resource.generations.find(request.resource.generation);
+        if (generationIt == resource.generations.end() || generationIt->second.retired)
+        {
+            return GpuAccessPlan{.status = GpuAccessStatus::StaleGeneration};
+        }
+
+        auto & generation = generationIt->second;
+        pruneCompletedEventsLocked(generation);
+
+        if (hasConflictingPendingAccessLocked(request.resource, request.mode))
+        {
+            return GpuAccessPlan{.status = GpuAccessStatus::PendingAccessWithoutEvent};
+        }
+
+        GpuAccessToken const token = m_nextAccessToken++;
+        auto waitEvents = collectDependenciesLocked(generation, request.mode);
+        m_activeAccesses.emplace(token,
+                                 ActiveAccess{.token = token,
+                                              .resource = request.resource,
+                                              .queueId = request.queueId,
+                                              .mode = request.mode,
+                                              .operationName = std::move(request.operationName)});
+
+        return GpuAccessPlan{.status = GpuAccessStatus::Granted,
+                             .token = token,
+                             .waitEvents = std::move(waitEvents)};
+    }
+
+    GpuAccessStatus GpuAccessCoordinator::completeAccess(GpuAccessToken const token,
+                                                         GpuEventId const eventId)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        auto activeIt = m_activeAccesses.find(token);
+        if (activeIt == m_activeAccesses.end())
+        {
+            return GpuAccessStatus::UnknownAccessToken;
+        }
+
+        auto const active = std::move(activeIt->second);
+        m_activeAccesses.erase(activeIt);
+
+        auto resourceIt = m_resources.find(active.resource.resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return GpuAccessStatus::UnknownResource;
+        }
+
+        auto generationIt = resourceIt->second.generations.find(active.resource.generation);
+        if (generationIt == resourceIt->second.generations.end())
+        {
+            return GpuAccessStatus::StaleGeneration;
+        }
+
+        if (!isValidEvent(eventId))
+        {
+            return GpuAccessStatus::Granted;
+        }
+
+        auto & generation = generationIt->second;
+        if (writesResource(active.mode))
+        {
+            generation.lastWriterEvent = eventId;
+            generation.readerEvents.clear();
+        }
+        else
+        {
+            appendUniqueEvent(generation.readerEvents, eventId);
+        }
+
+        return GpuAccessStatus::Granted;
+    }
+
+    void GpuAccessCoordinator::markEventCompleted(GpuEventId const eventId)
+    {
+        if (!isValidEvent(eventId))
+        {
+            return;
+        }
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_completedEvents.insert(eventId);
+    }
+
+    void GpuAccessCoordinator::markEventsCompleted(std::vector<GpuEventId> const & eventIds)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        for (auto const eventId : eventIds)
+        {
+            if (isValidEvent(eventId))
+            {
+                m_completedEvents.insert(eventId);
+            }
+        }
+    }
+
+    bool GpuAccessCoordinator::isEventCompleted(GpuEventId const eventId) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return isCompletedLocked(eventId);
+    }
+
+    bool GpuAccessCoordinator::isIdle(GpuResourceHandle const resource) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        auto const resourceIt = m_resources.find(resource.resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return true;
+        }
+
+        auto const generationIt = resourceIt->second.generations.find(resource.generation);
+        if (generationIt == resourceIt->second.generations.end())
+        {
+            return true;
+        }
+
+        if (std::any_of(m_activeAccesses.begin(),
+                        m_activeAccesses.end(),
+                        [resource](auto const & entry) { return entry.second.resource == resource; }))
+        {
+            return false;
+        }
+
+        return outstandingEventsLocked(resource).empty();
+    }
+
+    std::vector<GpuEventId>
+    GpuAccessCoordinator::outstandingEvents(GpuResourceHandle const resource) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        return outstandingEventsLocked(resource);
+    }
+
+    std::vector<GpuEventId>
+    GpuAccessCoordinator::outstandingEventsLocked(GpuResourceHandle const resource) const
+    {
+
+        auto const resourceIt = m_resources.find(resource.resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return {};
+        }
+
+        auto const generationIt = resourceIt->second.generations.find(resource.generation);
+        if (generationIt == resourceIt->second.generations.end())
+        {
+            return {};
+        }
+
+        std::vector<GpuEventId> events;
+        auto const & generation = generationIt->second;
+        if (generation.lastWriterEvent.has_value() && !isCompletedLocked(*generation.lastWriterEvent))
+        {
+            appendUniqueEvent(events, *generation.lastWriterEvent);
+        }
+
+        for (auto const eventId : generation.readerEvents)
+        {
+            if (!isCompletedLocked(eventId))
+            {
+                appendUniqueEvent(events, eventId);
+            }
+        }
+
+        for (auto const eventId : generation.retirementWaitEvents)
+        {
+            if (!isCompletedLocked(eventId))
+            {
+                appendUniqueEvent(events, eventId);
+            }
+        }
+
+        return events;
+    }
+
+    GpuGenerationRetirement
+    GpuAccessCoordinator::retireCurrentGeneration(GpuResourceId const resourceId)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        auto resourceIt = m_resources.find(resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return GpuGenerationRetirement{.status = GpuAccessStatus::UnknownResource};
+        }
+
+        auto & resource = resourceIt->second;
+        GpuResourceHandle const retiredHandle{.resourceId = resourceId,
+                                              .generation = resource.currentGeneration};
+
+        if (hasConflictingPendingAccessLocked(retiredHandle, GpuAccessMode::Write))
+        {
+            return GpuGenerationRetirement{.status = GpuAccessStatus::PendingAccessWithoutEvent,
+                                           .retiredGeneration = retiredHandle};
+        }
+
+        auto generationIt = resource.generations.find(resource.currentGeneration);
+        if (generationIt == resource.generations.end())
+        {
+            return GpuGenerationRetirement{.status = GpuAccessStatus::StaleGeneration,
+                                           .retiredGeneration = retiredHandle};
+        }
+
+        auto & retiredGeneration = generationIt->second;
+        pruneCompletedEventsLocked(retiredGeneration);
+        auto waitEvents = collectDependenciesLocked(retiredGeneration, GpuAccessMode::Write);
+        retiredGeneration.retired = true;
+        retiredGeneration.retirementWaitEvents = waitEvents;
+
+        GpuResourceGeneration const newGeneration = resource.currentGeneration + 1u;
+        resource.currentGeneration = newGeneration;
+        resource.generations.emplace(newGeneration, GenerationState{.generation = newGeneration});
+
+        return GpuGenerationRetirement{
+          .status = GpuAccessStatus::Granted,
+          .retiredGeneration = retiredHandle,
+          .newGeneration = GpuResourceHandle{.resourceId = resourceId, .generation = newGeneration},
+          .waitEvents = std::move(waitEvents)};
+    }
+
+    void GpuAccessCoordinator::collectCompletedRetirements()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        for (auto & [resourceId, resource] : m_resources)
+        {
+            (void) resourceId;
+            for (auto generationIt = resource.generations.begin();
+                 generationIt != resource.generations.end();)
+            {
+                auto & generation = generationIt->second;
+                if (!generation.retired)
+                {
+                    ++generationIt;
+                    continue;
+                }
+
+                bool const hasOutstandingRetirementEvent =
+                  std::any_of(generation.retirementWaitEvents.begin(),
+                              generation.retirementWaitEvents.end(),
+                              [this](GpuEventId const eventId)
+                              { return !isCompletedLocked(eventId); });
+
+                                GpuResourceId const currentResourceId = resource.resourceId;
+                                GpuResourceGeneration const currentGeneration = generation.generation;
+                bool const hasActiveAccess =
+                  std::any_of(m_activeAccesses.begin(),
+                              m_activeAccesses.end(),
+                                                            [currentResourceId, currentGeneration](auto const & entry)
+                              {
+                                                                    return entry.second.resource.resourceId == currentResourceId &&
+                                                                                 entry.second.resource.generation == currentGeneration;
+                              });
+
+                if (!hasOutstandingRetirementEvent && !hasActiveAccess)
+                {
+                    generationIt = resource.generations.erase(generationIt);
+                }
+                else
+                {
+                    ++generationIt;
+                }
+            }
+        }
+    }
+
+    size_t GpuAccessCoordinator::retiredGenerationCount(GpuResourceId const resourceId) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        auto const resourceIt = m_resources.find(resourceId);
+        if (resourceIt == m_resources.end())
+        {
+            return 0u;
+        }
+
+        return static_cast<size_t>(std::count_if(
+          resourceIt->second.generations.begin(),
+          resourceIt->second.generations.end(),
+          [](auto const & entry) { return entry.second.retired; }));
+    }
+
+    bool GpuAccessCoordinator::isCompletedLocked(GpuEventId const eventId) const
+    {
+        return !isValidEvent(eventId) || m_completedEvents.find(eventId) != m_completedEvents.end();
+    }
+
+    void GpuAccessCoordinator::pruneCompletedEventsLocked(GenerationState & generation) const
+    {
+        if (generation.lastWriterEvent.has_value() && isCompletedLocked(*generation.lastWriterEvent))
+        {
+            generation.lastWriterEvent.reset();
+        }
+
+        std::erase_if(generation.readerEvents,
+                      [this](GpuEventId const eventId) { return isCompletedLocked(eventId); });
+
+        std::erase_if(generation.retirementWaitEvents,
+                      [this](GpuEventId const eventId) { return isCompletedLocked(eventId); });
+    }
+
+    std::vector<GpuEventId>
+    GpuAccessCoordinator::collectDependenciesLocked(GenerationState const & generation,
+                                                    GpuAccessMode const mode) const
+    {
+        std::vector<GpuEventId> dependencies;
+
+        if (generation.lastWriterEvent.has_value() && !isCompletedLocked(*generation.lastWriterEvent))
+        {
+            appendUniqueEvent(dependencies, *generation.lastWriterEvent);
+        }
+
+        if (writesResource(mode))
+        {
+            for (auto const eventId : generation.readerEvents)
+            {
+                if (!isCompletedLocked(eventId))
+                {
+                    appendUniqueEvent(dependencies, eventId);
+                }
+            }
+        }
+
+        return dependencies;
+    }
+
+    bool GpuAccessCoordinator::hasConflictingPendingAccessLocked(GpuResourceHandle const resource,
+                                                                 GpuAccessMode const mode) const
+    {
+        return std::any_of(m_activeAccesses.begin(),
+                           m_activeAccesses.end(),
+                           [resource, mode](auto const & entry)
+                           {
+                               auto const & active = entry.second;
+                               return active.resource == resource && accessesConflict(active.mode, mode);
+                           });
+    }
+
+    bool GpuAccessCoordinator::accessesConflict(GpuAccessMode const lhs,
+                                                GpuAccessMode const rhs) noexcept
+    {
+        return writesResource(lhs) || writesResource(rhs);
+    }
+
+    bool GpuAccessCoordinator::writesResource(GpuAccessMode const mode) noexcept
+    {
+        return mode == GpuAccessMode::Write || mode == GpuAccessMode::ReadWrite;
+    }
+}
diff --git a/gladius/src/compute/GpuAccessCoordinator.h b/gladius/src/compute/GpuAccessCoordinator.h
new file mode 100644
index 00000000..6c6efc00
--- /dev/null
+++ b/gladius/src/compute/GpuAccessCoordinator.h
@@ -0,0 +1,181 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <mutex>
+
+namespace gladius
+{
+    using GpuResourceId = uint64_t;
+    using GpuResourceGeneration = uint64_t;
+    using GpuQueueId = uint64_t;
+    using GpuEventId = uint64_t;
+    using GpuAccessToken = uint64_t;
+
+    enum class GpuResourceKind
+    {
+        Buffer,
+        Image2D,
+        Image3D,
+        ImageGL,
+        HostSnapshot
+    };
+
+    enum class GpuAccessMode
+    {
+        Read,
+        Write,
+        ReadWrite
+    };
+
+    enum class GpuAccessStatus
+    {
+        Granted,
+        UnknownResource,
+        StaleGeneration,
+        PendingAccessWithoutEvent,
+        UnknownAccessToken
+    };
+
+    struct GpuResourceHandle
+    {
+        GpuResourceId resourceId{};
+        GpuResourceGeneration generation{};
+
+        [[nodiscard]] friend bool operator==(GpuResourceHandle const & lhs,
+                                             GpuResourceHandle const & rhs) noexcept
+        {
+            return lhs.resourceId == rhs.resourceId && lhs.generation == rhs.generation;
+        }
+    };
+
+    struct GpuAccessRequest
+    {
+        GpuResourceHandle resource{};
+        GpuQueueId queueId{};
+        GpuAccessMode mode{GpuAccessMode::Read};
+        std::string operationName;
+    };
+
+    struct GpuAccessPlan
+    {
+        GpuAccessStatus status{GpuAccessStatus::UnknownResource};
+        GpuAccessToken token{};
+        std::vector<GpuEventId> waitEvents;
+
+        [[nodiscard]] bool granted() const noexcept
+        {
+            return status == GpuAccessStatus::Granted;
+        }
+    };
+
+    struct GpuGenerationRetirement
+    {
+        GpuAccessStatus status{GpuAccessStatus::UnknownResource};
+        GpuResourceHandle retiredGeneration{};
+        GpuResourceHandle newGeneration{};
+        std::vector<GpuEventId> waitEvents;
+
+        [[nodiscard]] bool granted() const noexcept
+        {
+            return status == GpuAccessStatus::Granted;
+        }
+
+        [[nodiscard]] bool canReleaseImmediately() const noexcept
+        {
+            return granted() && waitEvents.empty();
+        }
+    };
+
+    struct GpuResourceDebugInfo
+    {
+        GpuResourceId resourceId{};
+        GpuResourceGeneration currentGeneration{};
+        GpuResourceKind kind{GpuResourceKind::Buffer};
+        std::string debugName;
+    };
+
+    class GpuAccessCoordinator
+    {
+      public:
+        [[nodiscard]] GpuResourceHandle registerResource(GpuResourceKind kind,
+                                                         std::string debugName,
+                                                         GpuResourceGeneration initialGeneration = 1u);
+
+        [[nodiscard]] std::optional<GpuResourceHandle>
+        currentHandle(GpuResourceId resourceId) const;
+
+        [[nodiscard]] std::optional<GpuResourceDebugInfo>
+        debugInfo(GpuResourceId resourceId) const;
+
+        [[nodiscard]] GpuAccessPlan beginAccess(GpuAccessRequest request);
+
+        [[nodiscard]] GpuAccessStatus completeAccess(GpuAccessToken token, GpuEventId eventId);
+
+        void markEventCompleted(GpuEventId eventId);
+        void markEventsCompleted(std::vector<GpuEventId> const & eventIds);
+
+        [[nodiscard]] bool isEventCompleted(GpuEventId eventId) const;
+
+        [[nodiscard]] bool isIdle(GpuResourceHandle resource) const;
+
+        [[nodiscard]] std::vector<GpuEventId> outstandingEvents(GpuResourceHandle resource) const;
+
+        [[nodiscard]] GpuGenerationRetirement retireCurrentGeneration(GpuResourceId resourceId);
+
+        void collectCompletedRetirements();
+
+        [[nodiscard]] size_t retiredGenerationCount(GpuResourceId resourceId) const;
+
+      private:
+        struct GenerationState
+        {
+            GpuResourceGeneration generation{};
+            std::optional<GpuEventId> lastWriterEvent;
+            std::vector<GpuEventId> readerEvents;
+            bool retired{false};
+            std::vector<GpuEventId> retirementWaitEvents;
+        };
+
+        struct ResourceState
+        {
+            GpuResourceId resourceId{};
+            GpuResourceGeneration currentGeneration{};
+            GpuResourceKind kind{GpuResourceKind::Buffer};
+            std::string debugName;
+            std::unordered_map<GpuResourceGeneration, GenerationState> generations;
+        };
+
+        struct ActiveAccess
+        {
+            GpuAccessToken token{};
+            GpuResourceHandle resource{};
+            GpuQueueId queueId{};
+            GpuAccessMode mode{GpuAccessMode::Read};
+            std::string operationName;
+        };
+
+        [[nodiscard]] bool isCompletedLocked(GpuEventId eventId) const;
+        void pruneCompletedEventsLocked(GenerationState & generation) const;
+        [[nodiscard]] std::vector<GpuEventId>
+        outstandingEventsLocked(GpuResourceHandle resource) const;
+        [[nodiscard]] std::vector<GpuEventId>
+        collectDependenciesLocked(GenerationState const & generation, GpuAccessMode mode) const;
+        [[nodiscard]] bool hasConflictingPendingAccessLocked(GpuResourceHandle resource,
+                                                             GpuAccessMode mode) const;
+        [[nodiscard]] static bool accessesConflict(GpuAccessMode lhs, GpuAccessMode rhs) noexcept;
+        [[nodiscard]] static bool writesResource(GpuAccessMode mode) noexcept;
+
+        mutable std::mutex m_mutex;
+        GpuResourceId m_nextResourceId{1u};
+        GpuAccessToken m_nextAccessToken{1u};
+        std::unordered_map<GpuResourceId, ResourceState> m_resources;
+        std::unordered_map<GpuAccessToken, ActiveAccess> m_activeAccesses;
+        std::unordered_set<GpuEventId> m_completedEvents;
+    };
+}
diff --git a/gladius/src/compute/GpuKernelAccessGuard.cpp b/gladius/src/compute/GpuKernelAccessGuard.cpp
new file mode 100644
index 00000000..9da37ae5
--- /dev/null
+++ b/gladius/src/compute/GpuKernelAccessGuard.cpp
@@ -0,0 +1,180 @@
+#include "GpuKernelAccessGuard.h"
+
+#include "ComputeContext.h"
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <utility>
+
+namespace gladius
+{
+    namespace
+    {
+        void appendUnique(std::vector<GpuEventId> & target, std::vector<GpuEventId> const & source)
+        {
+            for (auto const eventId : source)
+            {
+                if (eventId == 0u)
+                {
+                    continue;
+                }
+
+                if (std::find(target.begin(), target.end(), eventId) == target.end())
+                {
+                    target.push_back(eventId);
+                }
+            }
+        }
+    }
+
+    GpuKernelAccessGuard::GpuKernelAccessGuard(ComputeContext & context,
+                                               cl::CommandQueue const & queue,
+                                               std::string operationName,
+                                               std::vector<GpuKernelResourceAccess> accesses)
+        : m_context(context)
+        , m_operationName(std::move(operationName))
+    {
+        if (m_context.isGpuAccessSafeModeEnabled())
+        {
+            m_context.waitForAllTrackedGpuWork();
+        }
+
+        m_context.refreshGpuAccessEvents();
+
+        auto const queueId = m_context.getGpuQueueId(queue);
+        auto mergedAccesses = mergeAccesses(std::move(accesses));
+        m_tokens.reserve(mergedAccesses.size());
+
+        for (auto const & access : mergedAccesses)
+        {
+            auto plan = m_context.gpuAccessCoordinator().beginAccess(
+              GpuAccessRequest{.resource = access.resource,
+                               .queueId = queueId,
+                               .mode = access.mode,
+                               .operationName = m_operationName});
+            if (!plan.granted())
+            {
+                m_status = plan.status;
+                abandon();
+                return;
+            }
+
+            m_tokens.push_back(plan.token);
+            appendUnique(m_waitEventIds, plan.waitEvents);
+        }
+
+        m_waitEvents = m_context.gpuWaitEvents(m_waitEventIds);
+
+        if (m_context.isDebugOutputEnabled())
+        {
+            if (auto logger = m_context.getLogger())
+            {
+                logger->logInfo(fmt::format("GPU access: op='{}', queue={}, resources={}, waits={}, safeMode={}",
+                                            m_operationName,
+                                            queueId,
+                                            mergedAccesses.size(),
+                                            m_waitEvents.size(),
+                                            m_context.isGpuAccessSafeModeEnabled()));
+            }
+        }
+    }
+
+    GpuKernelAccessGuard::~GpuKernelAccessGuard()
+    {
+        if (!m_completed)
+        {
+            abandon();
+        }
+    }
+
+    bool GpuKernelAccessGuard::granted() const noexcept
+    {
+        return m_status == GpuAccessStatus::Granted;
+    }
+
+    GpuAccessStatus GpuKernelAccessGuard::status() const noexcept
+    {
+        return m_status;
+    }
+
+    std::vector<cl::Event> const & GpuKernelAccessGuard::waitEvents() const noexcept
+    {
+        return m_waitEvents;
+    }
+
+    size_t GpuKernelAccessGuard::waitEventCount() const noexcept
+    {
+        return m_waitEvents.size();
+    }
+
+    void GpuKernelAccessGuard::complete(cl::Event const & event)
+    {
+        if (m_completed)
+        {
+            return;
+        }
+
+        auto const eventId = m_context.recordGpuEvent(event);
+        for (auto const token : m_tokens)
+        {
+            (void) m_context.gpuAccessCoordinator().completeAccess(token, eventId);
+        }
+        if (m_context.isGpuAccessSafeModeEnabled() && eventId != 0u)
+        {
+            m_context.waitForGpuEvents({eventId});
+        }
+        m_completed = true;
+    }
+
+    void GpuKernelAccessGuard::abandon()
+    {
+        for (auto const token : m_tokens)
+        {
+            (void) m_context.gpuAccessCoordinator().completeAccess(token, 0u);
+        }
+        m_tokens.clear();
+        m_completed = true;
+    }
+
+    std::vector<GpuKernelResourceAccess>
+    GpuKernelAccessGuard::mergeAccesses(std::vector<GpuKernelResourceAccess> accesses)
+    {
+        std::vector<GpuKernelResourceAccess> merged;
+        merged.reserve(accesses.size());
+
+        for (auto const & access : accesses)
+        {
+            auto existingIt = std::find_if(merged.begin(),
+                                           merged.end(),
+                                           [&access](GpuKernelResourceAccess const & existing)
+                                           { return existing.resource == access.resource; });
+            if (existingIt == merged.end())
+            {
+                merged.push_back(access);
+            }
+            else
+            {
+                existingIt->mode = mergeMode(existingIt->mode, access.mode);
+            }
+        }
+
+        return merged;
+    }
+
+    GpuAccessMode GpuKernelAccessGuard::mergeMode(GpuAccessMode const lhs,
+                                                  GpuAccessMode const rhs) noexcept
+    {
+        if (lhs == GpuAccessMode::ReadWrite || rhs == GpuAccessMode::ReadWrite)
+        {
+            return GpuAccessMode::ReadWrite;
+        }
+
+        if (lhs == rhs)
+        {
+            return lhs;
+        }
+
+        return GpuAccessMode::ReadWrite;
+    }
+}
diff --git a/gladius/src/compute/GpuKernelAccessGuard.h b/gladius/src/compute/GpuKernelAccessGuard.h
new file mode 100644
index 00000000..5586cf63
--- /dev/null
+++ b/gladius/src/compute/GpuKernelAccessGuard.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "GpuAccessCoordinator.h"
+#include "gpgpu.h"
+
+#include <string>
+#include <vector>
+
+namespace gladius
+{
+    class ComputeContext;
+
+    struct GpuKernelResourceAccess
+    {
+        GpuResourceHandle resource{};
+        GpuAccessMode mode{GpuAccessMode::Read};
+    };
+
+    class GpuKernelAccessGuard
+    {
+      public:
+        GpuKernelAccessGuard(ComputeContext & context,
+                             cl::CommandQueue const & queue,
+                             std::string operationName,
+                             std::vector<GpuKernelResourceAccess> accesses);
+        ~GpuKernelAccessGuard();
+
+        GpuKernelAccessGuard(GpuKernelAccessGuard const &) = delete;
+        GpuKernelAccessGuard & operator=(GpuKernelAccessGuard const &) = delete;
+        GpuKernelAccessGuard(GpuKernelAccessGuard &&) = delete;
+        GpuKernelAccessGuard & operator=(GpuKernelAccessGuard &&) = delete;
+
+        [[nodiscard]] bool granted() const noexcept;
+        [[nodiscard]] GpuAccessStatus status() const noexcept;
+        [[nodiscard]] std::vector<cl::Event> const & waitEvents() const noexcept;
+        [[nodiscard]] size_t waitEventCount() const noexcept;
+
+        void complete(cl::Event const & event);
+        void abandon();
+
+      private:
+        [[nodiscard]] static std::vector<GpuKernelResourceAccess>
+        mergeAccesses(std::vector<GpuKernelResourceAccess> accesses);
+        [[nodiscard]] static GpuAccessMode mergeMode(GpuAccessMode lhs, GpuAccessMode rhs) noexcept;
+
+        ComputeContext & m_context;
+        std::string m_operationName;
+        GpuAccessStatus m_status{GpuAccessStatus::Granted};
+        std::vector<GpuAccessToken> m_tokens;
+        std::vector<GpuEventId> m_waitEventIds;
+        std::vector<cl::Event> m_waitEvents;
+        bool m_completed{false};
+    };
+}
diff --git a/gladius/src/compute/MeshPreparationProgram.cpp b/gladius/src/compute/MeshPreparationProgram.cpp
index 2a7d4adb..1308cfc0 100644
--- a/gladius/src/compute/MeshPreparationProgram.cpp
+++ b/gladius/src/compute/MeshPreparationProgram.cpp
@@ -1,6 +1,7 @@
 #include "compute/MeshPreparationProgram.h"
 
 #include "Profiling.h"
+#include "compute/GpuKernelAccessGuard.h"
 
 #include <algorithm>
 #include <utility>
@@ -99,20 +100,40 @@ namespace gladius
         cl::NDRange const origin = {0, 0, 0};
         cl::NDRange const globalRange = {static_cast<size_t>(params.voxelCount), 1, 1};
 
-        m_program.run("buildMeshVoxelGrid",
-                      origin,
-                      globalRange,
-                      primitives.data.getBuffer(),
-                      static_cast<cl_int>(params.headerStart),
-                      static_cast<cl_int>(params.voxelDataOffset),
-                      static_cast<cl_int>(params.nodesOffset),
-                      static_cast<cl_int>(params.trianglesOffset),
-                      static_cast<cl_int>(params.normalsOffset),
-                      static_cast<cl_int>(params.indicesOffset),
-                      static_cast<cl_int>(params.edgeNeighborsOffset),
-                      static_cast<cl_int>(params.nodeCount),
-                      static_cast<cl_int>(params.triCount),
-                      static_cast<cl_int>(params.vertexNormalCount));
+                cl::CommandQueue const & queue = m_computeContext->GetQueue();
+                GpuKernelAccessGuard gpuAccess(
+                    *m_computeContext,
+                    queue,
+                    "buildMeshVoxelGrid",
+                    {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+                if (!gpuAccess.granted())
+                {
+                        return false;
+                }
+
+                cl::Event const event = m_program.runNonBlockingWithWaitList(
+                    queue,
+                    "buildMeshVoxelGrid",
+                    origin,
+                    globalRange,
+                    gpuAccess.waitEvents(),
+                    primitives.data.getBuffer(),
+                    static_cast<cl_int>(params.headerStart),
+                    static_cast<cl_int>(params.voxelDataOffset),
+                    static_cast<cl_int>(params.nodesOffset),
+                    static_cast<cl_int>(params.trianglesOffset),
+                    static_cast<cl_int>(params.normalsOffset),
+                    static_cast<cl_int>(params.indicesOffset),
+                    static_cast<cl_int>(params.edgeNeighborsOffset),
+                    static_cast<cl_int>(params.nodeCount),
+                    static_cast<cl_int>(params.triCount),
+                    static_cast<cl_int>(params.vertexNormalCount));
+                gpuAccess.complete(event);
+                if (event())
+                {
+                        event.wait();
+                        queue.finish();
+                }
 
         return true;
     }
@@ -141,17 +162,29 @@ namespace gladius
         cl::NDRange const origin = {0, 0, 0};
         cl::NDRange const globalRange = {static_cast<size_t>(params.nodeCount), 1, 1};
 
+            GpuKernelAccessGuard gpuAccess(
+              *m_computeContext,
+              queue,
+              "buildMeshFwnAggregates",
+              {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+            if (!gpuAccess.granted())
+            {
+                return false;
+            }
+
         cl::Event const event =
-          m_program.runNonBlocking(queue,
+              m_program.runNonBlockingWithWaitList(queue,
                                    "buildMeshFwnAggregates",
                                    origin,
                                    globalRange,
+                                   gpuAccess.waitEvents(),
                                    primitives.data.getBuffer(),
                                    static_cast<cl_int>(params.nodesOffset),
                                    static_cast<cl_int>(params.trianglesOffset),
                                    static_cast<cl_int>(params.fwnAggregatesOffset),
                                    static_cast<cl_int>(params.nodeCount),
                                    static_cast<cl_int>(params.triCount));
+            gpuAccess.complete(event);
         return event() != nullptr;
     }
 
@@ -177,35 +210,46 @@ namespace gladius
         cl::CommandQueue const & queue = m_computeContext->GetQueue();
         cl::NDRange const origin = {0, 0, 0};
 
+        GpuKernelAccessGuard gpuAccess(*m_computeContext,
+                                       queue,
+                                       "buildMeshSignCache",
+                                       {{primitives.data.gpuResourceHandle(), GpuAccessMode::ReadWrite}});
+        if (!gpuAccess.granted())
+        {
+            return false;
+        }
+
         int const firstWord = std::clamp(params.baseWord, 0, params.wordCount);
         int const lastWord = std::min(params.wordCount, firstWord + params.wordsToBuild);
+        cl::Event lastEvent{};
         for (int baseWord = firstWord; baseWord < lastWord; baseWord += wordsPerBatch)
         {
             int const batchWordCount = std::min(wordsPerBatch, lastWord - baseWord);
             cl::NDRange const globalRange = {static_cast<size_t>(batchWordCount), 1, 1};
 
-            cl::Event const event =
-              m_program.runNonBlocking(queue,
-                                       "buildMeshSignCache",
-                                       origin,
-                                       globalRange,
-                                       primitives.data.getBuffer(),
-                                       static_cast<cl_int>(params.headerStart),
-                                       static_cast<cl_int>(params.signCacheDataOffset),
-                                       static_cast<cl_int>(params.nodesOffset),
-                                       static_cast<cl_int>(params.trianglesOffset),
-                                       static_cast<cl_int>(params.normalsOffset),
-                                       static_cast<cl_int>(params.indicesOffset),
-                                       static_cast<cl_int>(params.edgeNeighborsOffset),
-                                       static_cast<cl_int>(params.fwnAggregatesOffset),
-                                       static_cast<cl_int>(params.nodeCount),
-                                       static_cast<cl_int>(params.triCount),
-                                       static_cast<cl_int>(params.vertexNormalCount),
-                                       static_cast<cl_int>(params.resolution),
-                                       static_cast<cl_int>(baseWord),
-                                       static_cast<cl_int>(params.wordCount),
-                                       static_cast<cl_float>(params.fwnBeta));
-            if (!event())
+                        lastEvent = m_program.runNonBlockingWithWaitList(
+                            queue,
+                            "buildMeshSignCache",
+                            origin,
+                            globalRange,
+                            gpuAccess.waitEvents(),
+                            primitives.data.getBuffer(),
+                            static_cast<cl_int>(params.headerStart),
+                            static_cast<cl_int>(params.signCacheDataOffset),
+                            static_cast<cl_int>(params.nodesOffset),
+                            static_cast<cl_int>(params.trianglesOffset),
+                            static_cast<cl_int>(params.normalsOffset),
+                            static_cast<cl_int>(params.indicesOffset),
+                            static_cast<cl_int>(params.edgeNeighborsOffset),
+                            static_cast<cl_int>(params.fwnAggregatesOffset),
+                            static_cast<cl_int>(params.nodeCount),
+                            static_cast<cl_int>(params.triCount),
+                            static_cast<cl_int>(params.vertexNormalCount),
+                            static_cast<cl_int>(params.resolution),
+                            static_cast<cl_int>(baseWord),
+                            static_cast<cl_int>(params.wordCount),
+                            static_cast<cl_float>(params.fwnBeta));
+                        if (!lastEvent())
             {
                 return false;
             }
@@ -213,24 +257,28 @@ namespace gladius
 
         if (!params.completesBuild)
         {
+                        gpuAccess.complete(lastEvent);
             return true;
         }
 
         cl::Event const readyEvent =
-          m_program.runNonBlocking(queue,
-                                   "markMeshSignCacheReady",
-                                   origin,
-                                   cl::NDRange{1, 1, 1},
-                                   primitives.data.getBuffer(),
-                                   static_cast<cl_int>(params.signCacheReadyOffset),
-                                   static_cast<cl_int>(params.signCacheDataOffset),
-                                   static_cast<cl_int>(params.signCacheBetaOffset),
-                                   static_cast<cl_float>(params.fwnBeta));
+                    m_program.runNonBlockingWithWaitList(queue,
+                                                                                             "markMeshSignCacheReady",
+                                                                                             origin,
+                                                                                             cl::NDRange{1, 1, 1},
+                                                                                             gpuAccess.waitEvents(),
+                                                                                             primitives.data.getBuffer(),
+                                                                                             static_cast<cl_int>(params.signCacheReadyOffset),
+                                                                                             static_cast<cl_int>(params.signCacheDataOffset),
+                                                                                             static_cast<cl_int>(params.signCacheBetaOffset),
+                                                                                             static_cast<cl_float>(params.fwnBeta));
         if (!readyEvent())
         {
             return false;
         }
 
+            gpuAccess.complete(readyEvent);
+
         return true;
     }
 }
diff --git a/gladius/src/compute/OpenClEventRegistry.cpp b/gladius/src/compute/OpenClEventRegistry.cpp
new file mode 100644
index 00000000..b1eca160
--- /dev/null
+++ b/gladius/src/compute/OpenClEventRegistry.cpp
@@ -0,0 +1,123 @@
+#include "OpenClEventRegistry.h"
+
+#include <algorithm>
+
+namespace gladius
+{
+    GpuEventId OpenClEventRegistry::record(cl::Event const & event)
+    {
+        if (event() == nullptr)
+        {
+            return 0u;
+        }
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+        GpuEventId const eventId = m_nextEventId++;
+        m_events.emplace(eventId, event);
+        return eventId;
+    }
+
+    std::vector<cl::Event>
+    OpenClEventRegistry::eventsFor(std::vector<GpuEventId> const & eventIds) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        std::vector<cl::Event> events;
+        events.reserve(eventIds.size());
+        for (auto const eventId : eventIds)
+        {
+            auto const eventIt = m_events.find(eventId);
+            if (eventIt != m_events.end() && eventIt->second() != nullptr)
+            {
+                events.push_back(eventIt->second);
+            }
+        }
+        return events;
+    }
+
+    std::vector<GpuEventId> OpenClEventRegistry::pollCompleted()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        std::vector<GpuEventId> completed;
+        for (auto eventIt = m_events.begin(); eventIt != m_events.end();)
+        {
+            if (isComplete(eventIt->second))
+            {
+                completed.push_back(eventIt->first);
+                eventIt = m_events.erase(eventIt);
+            }
+            else
+            {
+                ++eventIt;
+            }
+        }
+        return completed;
+    }
+
+    std::vector<GpuEventId> OpenClEventRegistry::waitFor(std::vector<GpuEventId> const & eventIds)
+    {
+        auto events = eventsFor(eventIds);
+        for (auto const & event : events)
+        {
+            if (event() != nullptr)
+            {
+                event.wait();
+            }
+        }
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::vector<GpuEventId> completed;
+        completed.reserve(eventIds.size());
+        for (auto const eventId : eventIds)
+        {
+            auto const eventIt = m_events.find(eventId);
+            if (eventIt != m_events.end())
+            {
+                completed.push_back(eventId);
+                m_events.erase(eventIt);
+            }
+        }
+        return completed;
+    }
+
+    std::vector<GpuEventId> OpenClEventRegistry::waitForAll()
+    {
+        std::vector<GpuEventId> eventIds;
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            eventIds.reserve(m_events.size());
+            for (auto const & [eventId, event] : m_events)
+            {
+                (void) event;
+                eventIds.push_back(eventId);
+            }
+        }
+
+        return waitFor(eventIds);
+    }
+
+    bool OpenClEventRegistry::contains(GpuEventId const eventId) const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_events.find(eventId) != m_events.end();
+    }
+
+    bool OpenClEventRegistry::isComplete(cl::Event const & event) noexcept
+    {
+        if (event() == nullptr)
+        {
+            return true;
+        }
+
+        try
+        {
+            auto const status = event.getInfo<CL_EVENT_COMMAND_EXECUTION_STATUS>();
+            return status == CL_COMPLETE;
+        }
+        catch (...)
+        {
+            return true;
+        }
+    }
+}
diff --git a/gladius/src/compute/OpenClEventRegistry.h b/gladius/src/compute/OpenClEventRegistry.h
new file mode 100644
index 00000000..96419c9a
--- /dev/null
+++ b/gladius/src/compute/OpenClEventRegistry.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "GpuAccessCoordinator.h"
+#include "gpgpu.h"
+
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace gladius
+{
+    class OpenClEventRegistry
+    {
+      public:
+        [[nodiscard]] GpuEventId record(cl::Event const & event);
+        [[nodiscard]] std::vector<cl::Event> eventsFor(std::vector<GpuEventId> const & eventIds) const;
+        [[nodiscard]] std::vector<GpuEventId> pollCompleted();
+        [[nodiscard]] std::vector<GpuEventId> waitFor(std::vector<GpuEventId> const & eventIds);
+        [[nodiscard]] std::vector<GpuEventId> waitForAll();
+        [[nodiscard]] bool contains(GpuEventId eventId) const;
+
+      private:
+        [[nodiscard]] static bool isComplete(cl::Event const & event) noexcept;
+
+        mutable std::mutex m_mutex;
+        GpuEventId m_nextEventId{1u};
+        std::unordered_map<GpuEventId, cl::Event> m_events;
+    };
+}
diff --git a/gladius/src/compute/ProgramManager.cpp b/gladius/src/compute/ProgramManager.cpp
index d8c6d1b1..7dfaefb3 100644
--- a/gladius/src/compute/ProgramManager.cpp
+++ b/gladius/src/compute/ProgramManager.cpp
@@ -442,11 +442,13 @@ namespace gladius
         m_slicerState.signalCompilationFinished();
     }
 
-    void ProgramManager::setComputeContext(std::shared_ptr<ComputeContext> context)
+    void ProgramManager::setComputeContext(std::shared_ptr<ComputeContext> context,
+                                           SharedResources resources)
     {
         ProfileFunction std::lock_guard<std::recursive_mutex> lockCompute(m_computeMutex);
 
         m_ComputeContext = std::move(context);
+        m_resources = std::move(resources);
         reset();
         init();
     }
@@ -933,6 +935,60 @@ namespace gladius
         setModelSources(std::move(source), std::nullopt, true);
     }
 
+    void ProgramManager::setPreviewModelSource(std::string previewSource)
+    {
+        std::lock_guard<std::mutex> lock(m_modelSourceMutex);
+        invalidateCachedBestRenderProgram();
+
+        m_previewModelSource = std::move(previewSource);
+        m_hasPreviewModelSource = true;
+
+        // A preview-only publication represents a new model revision whose optimized source is
+        // not available yet. Disable optimized selection so an older optimized program cannot win.
+        m_modelSource.clear();
+        m_compileOptimizedRenderProgram = false;
+
+        if (m_eventLogger)
+        {
+            auto const message = fmt::format(
+              "ProgramManager.setPreviewModelSource: preview={} bytes",
+              m_previewModelSource.size());
+            getLogger().addEvent({message, events::Severity::Info});
+        }
+
+        m_previewRenderState.signalCompilationRequired();
+    }
+
+    void ProgramManager::setOptimizedModelSource(std::string optimizedSource,
+                                                 bool const compileOptimizedRenderProgram,
+                                                 bool const compileSlicerProgram)
+    {
+        std::lock_guard<std::mutex> lock(m_modelSourceMutex);
+        invalidateCachedBestRenderProgram();
+
+        m_modelSource = std::move(optimizedSource);
+        m_compileOptimizedRenderProgram = compileOptimizedRenderProgram;
+
+        if (m_eventLogger)
+        {
+            auto const message = fmt::format(
+              "ProgramManager.setOptimizedModelSource: optimized={} bytes optimizedRender={} slicer={}",
+              m_modelSource.size(),
+              m_compileOptimizedRenderProgram ? 1 : 0,
+              compileSlicerProgram ? 1 : 0);
+            getLogger().addEvent({message, events::Severity::Info});
+        }
+
+        if (m_compileOptimizedRenderProgram)
+        {
+            m_renderState.signalCompilationRequired();
+        }
+        if (compileSlicerProgram)
+        {
+            m_slicerState.signalCompilationRequired();
+        }
+    }
+
     void ProgramManager::setModelSources(std::string optimizedSource,
                                          std::optional<std::string> previewSource,
                                          bool compileOptimizedRenderProgram)
diff --git a/gladius/src/compute/ProgramManager.h b/gladius/src/compute/ProgramManager.h
index b4513589..9498d54b 100644
--- a/gladius/src/compute/ProgramManager.h
+++ b/gladius/src/compute/ProgramManager.h
@@ -110,7 +110,7 @@ namespace gladius
         void ensureHierarchicalDcProgramCompiled();
         void ensureManifoldDcProgramCompiled();
 
-        void setComputeContext(std::shared_ptr<ComputeContext> context);
+        void setComputeContext(std::shared_ptr<ComputeContext> context, SharedResources resources);
 
         [[nodiscard]] events::SharedLogger getSharedLogger() const;
 
@@ -131,6 +131,10 @@ namespace gladius
         void setModelSources(std::string optimizedSource,
                  std::optional<std::string> previewSource,
                  bool compileOptimizedRenderProgram);
+        void setPreviewModelSource(std::string previewSource);
+        void setOptimizedModelSource(std::string optimizedSource,
+                   bool compileOptimizedRenderProgram,
+                   bool compileSlicerProgram);
 
         void setVdbRequired(bool required);
         [[nodiscard]] bool isVdbSupported() const;
diff --git a/gladius/src/compute/RenderPayloadSnapshot.h b/gladius/src/compute/RenderPayloadSnapshot.h
new file mode 100644
index 00000000..f7af40a5
--- /dev/null
+++ b/gladius/src/compute/RenderPayloadSnapshot.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "GpuKernelAccessGuard.h"
+#include "Primitives.h"
+#include "ResourceContext.h"
+
+#include <vector>
+
+namespace gladius
+{
+    struct RenderPayloadSnapshot
+    {
+        GpuResourceHandle primitiveMeta{};
+        GpuResourceHandle primitiveData{};
+        GpuResourceHandle precomputedSdf{};
+        GpuResourceHandle parameterBuffer{};
+        GpuResourceHandle commandBuffer{};
+
+        [[nodiscard]] static RenderPayloadSnapshot capture(SharedResources const & resources,
+                                                           Primitives const & primitives)
+        {
+            return RenderPayloadSnapshot{
+              .primitiveMeta = primitives.primitives.gpuResourceHandle(),
+              .primitiveData = primitives.data.gpuResourceHandle(),
+              .precomputedSdf = resources->getPrecompSdfBuffer().gpuResourceHandle(),
+              .parameterBuffer = resources->getParameterBuffer().gpuResourceHandle(),
+              .commandBuffer = resources->getCommandBuffer().gpuResourceHandle()};
+        }
+
+        [[nodiscard]] std::vector<GpuKernelResourceAccess> readAccesses() const
+        {
+            return {{primitiveMeta, GpuAccessMode::Read},
+                    {primitiveData, GpuAccessMode::Read},
+                    {precomputedSdf, GpuAccessMode::Read},
+                    {parameterBuffer, GpuAccessMode::Read},
+                    {commandBuffer, GpuAccessMode::Read}};
+        }
+
+        [[nodiscard]] bool isCurrent(GpuAccessCoordinator const & coordinator) const
+        {
+            return isHandleCurrent(coordinator, primitiveMeta) &&
+                   isHandleCurrent(coordinator, primitiveData) &&
+                   isHandleCurrent(coordinator, precomputedSdf) &&
+                   isHandleCurrent(coordinator, parameterBuffer) &&
+                   isHandleCurrent(coordinator, commandBuffer);
+        }
+
+      private:
+        [[nodiscard]] static bool isHandleCurrent(GpuAccessCoordinator const & coordinator,
+                                                  GpuResourceHandle handle)
+        {
+            auto current = coordinator.currentHandle(handle.resourceId);
+            return current.has_value() && *current == handle;
+        }
+    };
+}
diff --git a/gladius/src/compute/RenderSceneGeneration.cpp b/gladius/src/compute/RenderSceneGeneration.cpp
new file mode 100644
index 00000000..d93c5468
--- /dev/null
+++ b/gladius/src/compute/RenderSceneGeneration.cpp
@@ -0,0 +1,47 @@
+#include "RenderSceneGeneration.h"
+
+namespace gladius
+{
+    RenderSceneGeneration::RenderSceneGeneration(SharedComputeContext context,
+                                                 RequiredCapabilities requiredCapabilities,
+                                                 events::SharedLogger logger,
+                                                 RenderSceneRevision revision)
+        : m_computeContext(std::move(context))
+        , m_resources(std::make_shared<ResourceContext>(m_computeContext))
+        , m_primitives(std::make_shared<Primitives>(*m_computeContext))
+        , m_revision(revision)
+        , m_programs(m_computeContext, requiredCapabilities, std::move(logger), m_resources)
+    {
+        m_primitives->create();
+    }
+
+    SharedComputeContext RenderSceneGeneration::getComputeContext() const
+    {
+        return m_computeContext;
+    }
+
+    SharedResources RenderSceneGeneration::getResources() const
+    {
+        return m_resources;
+    }
+
+    SharedPrimitives RenderSceneGeneration::getPrimitives() const
+    {
+        return m_primitives;
+    }
+
+    RenderSceneRevision RenderSceneGeneration::getRevision() const noexcept
+    {
+        return m_revision;
+    }
+
+    ProgramManager & RenderSceneGeneration::getProgramManager()
+    {
+        return m_programs;
+    }
+
+    ProgramManager const & RenderSceneGeneration::getProgramManager() const
+    {
+        return m_programs;
+    }
+} // namespace gladius
diff --git a/gladius/src/compute/RenderSceneGeneration.h b/gladius/src/compute/RenderSceneGeneration.h
new file mode 100644
index 00000000..64d0a107
--- /dev/null
+++ b/gladius/src/compute/RenderSceneGeneration.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "Primitives.h"
+#include "ProgramManager.h"
+#include "ResourceContext.h"
+
+#include <compare>
+#include <cstdint>
+
+namespace gladius
+{
+    /**
+     * @brief Identifies the document contents materialized into a render generation.
+     *
+     * A zero identity denotes an untagged transitional generation. Such a generation must not
+     * be paired with a revision-sensitive operation such as native-save thumbnail generation.
+     */
+    struct RenderSceneRevision
+    {
+        std::uint64_t documentIdentity{0};
+        std::uint64_t documentVersion{0};
+
+        [[nodiscard]] bool isSpecified() const noexcept
+        { return documentIdentity != 0; }
+
+        auto operator<=>(RenderSceneRevision const &) const = default;
+    };
+
+    /**
+     * @brief One retained renderable scene generation.
+     *
+     * The generation owns every context-bound input consumed by render kernels: primitive payload,
+     * render resources, and the programs compiled for that payload. A render session retains this
+     * object instead of observing ComputeCore's mutable working state.
+     *
+     * During the migration, ComputeCore still materializes the generation from its working scene.
+     * Once published, this owner must not be rebound to another context or reused for a different
+     * model payload.
+     */
+    class RenderSceneGeneration
+    {
+      public:
+        RenderSceneGeneration(SharedComputeContext context,
+                              RequiredCapabilities requiredCapabilities,
+                              events::SharedLogger logger,
+                              RenderSceneRevision revision = {});
+
+        [[nodiscard]] SharedComputeContext getComputeContext() const;
+        [[nodiscard]] SharedResources getResources() const;
+        [[nodiscard]] SharedPrimitives getPrimitives() const;
+        [[nodiscard]] RenderSceneRevision getRevision() const noexcept;
+        [[nodiscard]] ProgramManager & getProgramManager();
+        [[nodiscard]] ProgramManager const & getProgramManager() const;
+
+      private:
+        SharedComputeContext m_computeContext;
+        SharedResources m_resources;
+        SharedPrimitives m_primitives;
+        RenderSceneRevision m_revision;
+        ProgramManager m_programs;
+    };
+
+    using SharedRenderSceneGeneration = std::shared_ptr<RenderSceneGeneration>;
+} // namespace gladius
diff --git a/gladius/src/compute/RenderSceneState.cpp b/gladius/src/compute/RenderSceneState.cpp
new file mode 100644
index 00000000..af9f2bc7
--- /dev/null
+++ b/gladius/src/compute/RenderSceneState.cpp
@@ -0,0 +1,36 @@
+#include "RenderSceneState.h"
+
+#include "Primitives.h"
+
+namespace gladius
+{
+    RenderSceneState::RenderSceneState(SharedComputeContext context,
+                                       RequiredCapabilities requiredCapabilities,
+                                       events::SharedLogger logger)
+        : m_computeContext(std::move(context))
+        , m_resources(std::make_shared<ResourceContext>(m_computeContext))
+        , m_primitives(std::make_shared<Primitives>(*m_computeContext))
+        , m_programs(m_computeContext, requiredCapabilities, std::move(logger), m_resources)
+    { m_primitives->create(); }
+
+    SharedComputeContext RenderSceneState::getComputeContext() const
+    { return m_computeContext; }
+
+    SharedResources & RenderSceneState::getResourceContext()
+    { return m_resources; }
+
+    SharedResources RenderSceneState::getResourceContext() const
+    { return m_resources; }
+
+    SharedPrimitives & RenderSceneState::getPrimitives()
+    { return m_primitives; }
+
+    SharedPrimitives RenderSceneState::getPrimitives() const
+    { return m_primitives; }
+
+    ProgramManager & RenderSceneState::getProgramManager()
+    { return m_programs; }
+
+    ProgramManager const & RenderSceneState::getProgramManager() const
+    { return m_programs; }
+} // namespace gladius
\ No newline at end of file
diff --git a/gladius/src/compute/RenderSceneState.h b/gladius/src/compute/RenderSceneState.h
new file mode 100644
index 00000000..692706f3
--- /dev/null
+++ b/gladius/src/compute/RenderSceneState.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "ProgramManager.h"
+
+namespace gladius
+{
+    /**
+     * @brief Owns the context-bound resources used to evaluate one renderable scene.
+     *
+     * This object is deliberately separate from ComputeCore's camera, presentation images, and
+     * interactive state. It is the first ownership boundary for retained scene generations:
+     * resource payload buffers, primitive buffers, and compiled OpenCL programs stay alive as one
+     * unit while render sessions use them.
+     *
+     * The state is materialized once and is never rebound to another compute context. During this
+     * migration, the payload buffers and program manager remain mutable for normal model updates;
+     * retained render sessions must therefore treat this owner as a lifetime boundary, not yet as
+     * a fully immutable generation.
+     */
+    class RenderSceneState
+    {
+      public:
+        RenderSceneState(SharedComputeContext context,
+                         RequiredCapabilities requiredCapabilities,
+                         events::SharedLogger logger);
+
+        [[nodiscard]] SharedComputeContext getComputeContext() const;
+
+        [[nodiscard]] SharedResources & getResourceContext();
+        [[nodiscard]] SharedResources getResourceContext() const;
+
+        [[nodiscard]] SharedPrimitives & getPrimitives();
+        [[nodiscard]] SharedPrimitives getPrimitives() const;
+
+        [[nodiscard]] ProgramManager & getProgramManager();
+        [[nodiscard]] ProgramManager const & getProgramManager() const;
+
+      private:
+        SharedComputeContext m_computeContext;
+        SharedResources m_resources;
+        SharedPrimitives m_primitives;
+        ProgramManager m_programs;
+    };
+
+    using SharedRenderSceneState = std::shared_ptr<RenderSceneState>;
+} // namespace gladius
diff --git a/gladius/src/compute/RenderSession.cpp b/gladius/src/compute/RenderSession.cpp
new file mode 100644
index 00000000..3b3eb083
--- /dev/null
+++ b/gladius/src/compute/RenderSession.cpp
@@ -0,0 +1,30 @@
+#include "RenderSession.h"
+
+namespace gladius
+{
+    RenderSession::RenderSession(SharedRenderSceneGeneration generation, RenderSessionInputs inputs)
+        : m_generation(std::move(generation))
+        , m_inputs(std::move(inputs))
+        , m_payloadSnapshot(RenderPayloadSnapshot::capture(m_generation->getResources(),
+                                                           *m_generation->getPrimitives()))
+    {
+    }
+
+    SharedComputeContext RenderSession::getComputeContext() const
+    { return m_generation->getComputeContext(); }
+
+    RenderSceneRevision RenderSession::getRevision() const noexcept
+    { return m_generation->getRevision(); }
+
+    RenderSessionInputs const & RenderSession::getInputs() const
+    { return m_inputs; }
+
+    RenderPayloadSnapshot const & RenderSession::getPayloadSnapshot() const
+    { return m_payloadSnapshot; }
+
+    bool RenderSession::isPayloadCurrent() const
+    {
+        return m_payloadSnapshot.isCurrent(
+          m_generation->getComputeContext()->gpuAccessCoordinator());
+    }
+} // namespace gladius
diff --git a/gladius/src/compute/RenderSession.h b/gladius/src/compute/RenderSession.h
new file mode 100644
index 00000000..a7536598
--- /dev/null
+++ b/gladius/src/compute/RenderSession.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "RenderPayloadSnapshot.h"
+#include "RenderSceneGeneration.h"
+#include "RenderSessionInputs.h"
+
+namespace gladius
+{
+    /**
+     * @brief Retains the scene resources and inputs used by one render session.
+     *
+     * A session owns no duplicate scene payloads. It retains the scene owner, copies the
+     * per-session camera/settings values, and records the GPU handles that were current when the
+     * session was created. The scene owner remains alive until the session is released.
+     *
+     * Scene publication is still mutable during this migration. Callers must obtain sessions only
+     * after scene materialization and must not use a session as a substitute for a published
+     * immutable generation yet. The scene owner is intentionally not exposed by this type.
+     */
+    class RenderSession
+    {
+      public:
+        RenderSession(SharedRenderSceneGeneration generation, RenderSessionInputs inputs);
+
+        [[nodiscard]] SharedComputeContext getComputeContext() const;
+        [[nodiscard]] RenderSceneRevision getRevision() const noexcept;
+        [[nodiscard]] RenderSessionInputs const & getInputs() const;
+        [[nodiscard]] RenderPayloadSnapshot const & getPayloadSnapshot() const;
+
+        [[nodiscard]] bool isPayloadCurrent() const;
+
+      private:
+        SharedRenderSceneGeneration m_generation;
+        RenderSessionInputs m_inputs;
+        RenderPayloadSnapshot m_payloadSnapshot;
+    };
+
+    using SharedRenderSession = std::shared_ptr<RenderSession>;
+} // namespace gladius
diff --git a/gladius/src/compute/RenderSessionInputs.h b/gladius/src/compute/RenderSessionInputs.h
new file mode 100644
index 00000000..839d2263
--- /dev/null
+++ b/gladius/src/compute/RenderSessionInputs.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "kernel/types.h"
+
+namespace gladius
+{
+    /**
+     * @brief Per-dispatch values for a render session.
+     *
+     * This value contains only copied camera and rendering parameters. GPU scene payloads remain
+     * owned by the retained scene generation and are passed separately to render programs.
+     */
+    struct RenderSessionInputs
+    {
+        RenderingSettings settings{};
+        cl_float3 eyePosition{};
+        cl_float16 modelViewPerspectiveMat{};
+    };
+} // namespace gladius
diff --git a/gladius/src/compute/Rendering.cpp b/gladius/src/compute/Rendering.cpp
index 62e11d12..7176c116 100644
--- a/gladius/src/compute/Rendering.cpp
+++ b/gladius/src/compute/Rendering.cpp
@@ -416,10 +416,11 @@ namespace gladius
         const auto thumbnailSize = 256.0f;
         thumbnailCamera.centerView(bb);
         thumbnailCamera.setAngle(0.6f, -2.0f);
+        thumbnailCamera.snapToTarget();
 
         thumbnailCamera.adjustDistanceToTarget(bb, thumbnailSize, thumbnailSize);
 
-        thumbnailCamera.update(10000.f);
+        thumbnailCamera.snapToTarget();
 
         applyCamera(thumbnailCamera);
 
diff --git a/gladius/src/io/3mf/FrontlitThicknessSolver.cpp b/gladius/src/io/3mf/FrontlitThicknessSolver.cpp
index 303d1dcf..087aca87 100644
--- a/gladius/src/io/3mf/FrontlitThicknessSolver.cpp
+++ b/gladius/src/io/3mf/FrontlitThicknessSolver.cpp
@@ -16,6 +16,52 @@
 
 namespace gladius::io
 {
+    namespace
+    {
+        void quantizeClampThicknesses(ThicknessConstraints const& constraints, std::vector<float>& values)
+        {
+            float const maxT = constraints.maxThickness;
+            float const minT = constraints.minThickness;
+
+            for (float& value : values)
+            {
+                if (value <= 0.0f)
+                {
+                    value = (minT > 0.0f) ? minT : 0.0f;
+                    continue;
+                }
+
+                value = std::clamp(value, 0.0f, maxT);
+                if (minT > 0.0f)
+                {
+                    value = std::max(value, minT);
+                }
+
+                if (constraints.layerHeight > 0.0f)
+                {
+                    value = std::round(value / constraints.layerHeight) * constraints.layerHeight;
+                    value = std::clamp(value, 0.0f, maxT);
+                    if (minT > 0.0f && value > 0.0f)
+                    {
+                        value = std::max(value, minT);
+                    }
+                }
+            }
+
+            if (constraints.totalMaxThickness > 0.0f)
+            {
+                float const sum = std::accumulate(values.begin(), values.end(), 0.0f);
+                if (sum > constraints.totalMaxThickness && sum > 0.0f)
+                {
+                    float const scale = constraints.totalMaxThickness / sum;
+                    for (float& value : values)
+                    {
+                        value *= scale;
+                    }
+                }
+            }
+        }
+    } // namespace
 
     FrontlitThicknessSolver::FrontlitThicknessSolver(FilamentStack const& stack,
                                                      ThicknessConstraints const& constraints,
@@ -42,59 +88,17 @@ namespace gladius::io
             ThicknessSolution solution;
             solution.targetColor = targetColor;
             solution.achievedColor = Eigen::Vector3f::Ones(); // White (no filament)
-            solution.colorError = (solution.achievedColor - targetColor).squaredNorm();
+            solution.colorError = std::sqrt((solution.achievedColor - targetColor).squaredNorm());
             solution.converged = true;
             return solution;
         }
 
-        // Helper to quantize/clamp a thickness vector allowing zeros but respecting bounds/quantization and total max
-        auto quantizeClampVec = [this](std::vector<float>& values) {
-            float const maxT = m_constraints.maxThickness;
-            float const minT = m_constraints.minThickness;
-
-            for (float& v : values)
-            {
-                if (v <= 0.0f)
-                {
-                    v = 0.0f;
-                    continue;
-                }
-
-                v = std::clamp(v, 0.0f, maxT);
-                if (minT > 0.0f)
-                {
-                    v = std::max(v, minT);
-                }
-                if (m_constraints.layerHeight > 0.0f)
-                {
-                    v = std::round(v / m_constraints.layerHeight) * m_constraints.layerHeight;
-                    v = std::clamp(v, 0.0f, maxT);
-                    if (minT > 0.0f && v > 0.0f)
-                    {
-                        v = std::max(v, minT);
-                    }
-                }
-            }
-
-            if (m_constraints.totalMaxThickness > 0.0f)
-            {
-                float const sum = std::accumulate(values.begin(), values.end(), 0.0f);
-                if (sum > m_constraints.totalMaxThickness && sum > 0.0f)
-                {
-                    float const scale = m_constraints.totalMaxThickness / sum;
-                    for (float& v : values)
-                    {
-                        v *= scale;
-                    }
-                }
-            }
-        };
-
         Eigen::Vector3f const target = targetColor.cwiseMax(0.0f).cwiseMin(1.0f);
+        auto evaluateCandidate = [this, &target](std::vector<float> const& values) {
+            return computeError(predictColor(values), target);
+        };
 
-        // Attempt global optimization (DIRECT-L + local polish) via NLopt
-        std::vector<float> thicknesses(n, 0.0f);
-        auto tryGlobalOptimize = [&](std::vector<float>& out) -> bool {
+        auto refineWithNlopt = [this, &target, n](std::vector<float>& values, bool includeGlobalPass) {
             if (n == 0)
             {
                 return false;
@@ -110,7 +114,9 @@ namespace gladius::io
 
             auto objective = [](std::vector<double> const& x, std::vector<double>& /*grad*/, void* data) {
                 auto* c = static_cast<NloptContext*>(data);
-                std::vector<float> xf(x.begin(), x.end());
+                std::vector<float> xf;
+                xf.reserve(x.size());
+                std::transform(x.begin(), x.end(), std::back_inserter(xf), [](double v) { return static_cast<float>(v); });
                 Eigen::Vector3f const predicted = c->solver->predictColor(xf);
                 double err = static_cast<double>((predicted - c->targetColor).squaredNorm());
 
@@ -134,31 +140,32 @@ namespace gladius::io
                 std::vector<double> lb(n, 0.0);
                 std::vector<double> ub(n, static_cast<double>(m_constraints.maxThickness));
 
-                // Global deterministic search
-                nlopt::opt globalOpt(nlopt::GN_DIRECT_L, static_cast<unsigned>(n));
-                globalOpt.set_lower_bounds(lb);
-                globalOpt.set_upper_bounds(ub);
-                globalOpt.set_min_objective(objective, &ctx);
-                globalOpt.set_maxeval(800);
-                globalOpt.set_maxtime(0.5);
-
-                // Seed point: light bias toward target dominant channels
-                std::vector<double> x(n, m_constraints.maxThickness * 0.25);
+                std::vector<double> x(values.begin(), values.end());
                 double f = 0.0;
-                globalOpt.optimize(x, f);
 
-                // Local polish
+                if (includeGlobalPass)
+                {
+                    nlopt::opt globalOpt(nlopt::GN_DIRECT_L, static_cast<unsigned>(n));
+                    globalOpt.set_lower_bounds(lb);
+                    globalOpt.set_upper_bounds(ub);
+                    globalOpt.set_min_objective(objective, &ctx);
+                    globalOpt.set_maxeval(350);
+                    globalOpt.set_maxtime(0.15);
+                    globalOpt.optimize(x, f);
+                }
+
                 nlopt::opt localOpt(nlopt::LN_BOBYQA, static_cast<unsigned>(n));
                 localOpt.set_lower_bounds(lb);
                 localOpt.set_upper_bounds(ub);
                 localOpt.set_min_objective(objective, &ctx);
                 localOpt.set_ftol_rel(1e-6);
                 localOpt.set_xtol_rel(1e-6);
-                localOpt.set_maxeval(500);
+                localOpt.set_maxeval(includeGlobalPass ? 300 : 200);
                 localOpt.optimize(x, f);
 
-                out.assign(x.begin(), x.end());
-                quantizeClampVec(out);
+                values.resize(x.size());
+                std::transform(x.begin(), x.end(), values.begin(), [](double v) { return static_cast<float>(v); });
+                quantizeClampThicknesses(m_constraints, values);
                 return true;
             }
             catch (std::exception const&)
@@ -167,89 +174,133 @@ namespace gladius::io
             }
         };
 
-        if (!tryGlobalOptimize(thicknesses))
-        {
-            // Fallback: color-biased heuristic to avoid gray equal-thickness
-            std::vector<float> weights(n, 0.0f);
-            float weightSum = 0.0f;
-            for (std::size_t i = 0; i < n; ++i)
-            {
-                Eigen::Vector3f tint = m_stack[i].reflectanceColor.cwiseMax(0.0f).cwiseMin(1.0f);
-                float w = std::max(0.0f, tint.dot(target));
-                weights[i] = w;
-                weightSum += w;
-            }
-            for (std::size_t i = 0; i < n; ++i)
+        auto refineWithGradient = [this, &target](std::vector<float>& thicknesses,
+                                                  ProgressCallback const& callback) -> bool {
+            float prevError = std::numeric_limits<float>::max();
+
+            for (int iter = 0; iter < m_maxIterations; ++iter)
             {
-                float const maxT = m_constraints.maxThickness;
-                float bias = (weightSum > 0.0f) ? (weights[i] / weightSum) : 1.0f / static_cast<float>(n);
-                float const raw = bias * maxT;
-                thicknesses[i] = raw;
-            }
-            quantizeClampVec(thicknesses);
-        }
+                Eigen::Vector3f const predicted = predictColor(thicknesses);
+                float const error = computeError(predicted, target);
 
-        // Projected gradient descent
-        float prevError = std::numeric_limits<float>::max();
+                if (callback)
+                {
+                    callback(iter, error);
+                }
 
-        for (int iter = 0; iter < m_maxIterations; ++iter)
-        {
-            Eigen::Vector3f const predicted = predictColor(thicknesses);
-            float const error = computeError(predicted, targetColor);
+                if (std::abs(prevError - error) < m_convergenceTolerance)
+                {
+                    return true;
+                }
+                prevError = error;
 
-            if (progressCallback)
-            {
-                progressCallback(iter, error);
-            }
+                std::vector<float> gradient = computeGradient(thicknesses, target);
+                float stepSize = m_stepSize;
+                std::vector<float> newThicknesses = thicknesses;
+                bool improved = false;
 
-            // Check convergence
-            if (std::abs(prevError - error) < m_convergenceTolerance)
-            {
-                ThicknessSolution solution(n);
-                solution.targetColor = targetColor;
-                solution.achievedColor = predicted;
-                solution.thicknesses = thicknesses;
-                solution.colorError = std::sqrt(error); // Return RMS error
-                solution.converged = true;
-                return solution;
-            }
-            prevError = error;
+                for (int backtrack = 0; backtrack < 10; ++backtrack)
+                {
+                    for (std::size_t i = 0; i < thicknesses.size(); ++i)
+                    {
+                        newThicknesses[i] = thicknesses[i] - stepSize * gradient[i];
+                    }
+                    projectOntoConstraints(newThicknesses);
 
-            // Compute gradient and take step
-            std::vector<float> gradient = computeGradient(thicknesses, targetColor);
+                    Eigen::Vector3f const newPredicted = predictColor(newThicknesses);
+                    float const newError = computeError(newPredicted, target);
 
-            // Adaptive step size with backtracking line search
-            float stepSize = m_stepSize;
-            std::vector<float> newThicknesses = thicknesses;
+                    if (newError < error)
+                    {
+                        thicknesses = newThicknesses;
+                        improved = true;
+                        break;
+                    }
+                    stepSize *= 0.5f;
+                }
 
-            for (int backtrack = 0; backtrack < 10; ++backtrack)
-            {
-                for (std::size_t i = 0; i < n; ++i)
+                if (!improved)
                 {
-                    newThicknesses[i] = thicknesses[i] - stepSize * gradient[i];
+                    return false;
                 }
-                projectOntoConstraints(newThicknesses);
+            }
 
-                Eigen::Vector3f const newPredicted = predictColor(newThicknesses);
-                float const newError = computeError(newPredicted, targetColor);
+            return false;
+        };
 
-                if (newError < error)
-                {
-                    thicknesses = newThicknesses;
-                    break;
-                }
-                stepSize *= 0.5f;
+        std::vector<std::vector<float>> candidates;
+        candidates.reserve(4U + 2U * n);
+
+        auto addCandidate = [this, &candidates](std::vector<float> candidate) {
+            quantizeClampThicknesses(m_constraints, candidate);
+            candidates.push_back(std::move(candidate));
+        };
+
+        addCandidate(std::vector<float>(n, 0.0f));
+        addCandidate(std::vector<float>(n, m_constraints.maxThickness * 0.25f));
+
+        std::vector<float> weights(n, 0.0f);
+        float weightSum = 0.0f;
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            Eigen::Vector3f const tint = m_stack[i].reflectanceColor.cwiseMax(0.0f).cwiseMin(1.0f);
+            float const weight = std::max(0.0f, tint.dot(target));
+            weights[i] = weight;
+            weightSum += weight;
+        }
+
+        std::vector<float> colorBiased(n, 0.0f);
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            float const bias = (weightSum > 0.0f) ? (weights[i] / weightSum) : (1.0f / static_cast<float>(n));
+            colorBiased[i] = bias * m_constraints.maxThickness;
+        }
+        addCandidate(colorBiased);
+
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            std::vector<float> singleLayer(n, 0.0f);
+            singleLayer[i] = m_constraints.maxThickness;
+            addCandidate(singleLayer);
+        }
+
+        std::vector<float> globalCandidate(n, m_constraints.maxThickness * 0.25f);
+        bool const haveGlobalCandidate = refineWithNlopt(globalCandidate, true);
+        if (haveGlobalCandidate)
+        {
+            addCandidate(globalCandidate);
+        }
+
+        std::vector<float> thicknesses = candidates.front();
+        float bestError = std::numeric_limits<float>::max();
+
+        bool converged = false;
+        for (std::size_t candidateIndex = 0; candidateIndex < candidates.size(); ++candidateIndex)
+        {
+            std::vector<float> candidate = candidates[candidateIndex];
+            refineWithNlopt(candidate, false);
+            bool const candidateConverged = refineWithGradient(candidate, nullptr);
+
+            float const error = evaluateCandidate(candidate);
+            if (error < bestError)
+            {
+                bestError = error;
+                thicknesses = std::move(candidate);
+                converged = candidateConverged;
             }
         }
 
-        // Max iterations reached
+        converged = refineWithGradient(thicknesses, progressCallback) && converged;
+
+        quantizeClampThicknesses(m_constraints, thicknesses);
+
         Eigen::Vector3f const predicted = predictColor(thicknesses);
         ThicknessSolution solution(n);
         solution.targetColor = targetColor;
         solution.achievedColor = predicted;
         solution.thicknesses = thicknesses;
         solution.colorError = std::sqrt(computeError(predicted, targetColor));
-        solution.converged = false;
+        solution.converged = converged && std::isfinite(solution.colorError);
         return solution;
     }
 
@@ -394,8 +445,9 @@ namespace gladius::io
             return gradient;
         }
 
-        // Numerical gradient using central differences
-        float const h = 1e-4f;
+        float const h = m_constraints.layerHeight > 0.0f
+            ? std::min(1e-4f, m_constraints.layerHeight * 0.25f)
+            : 1e-4f;
 
         for (std::size_t i = 0; i < n; ++i)
         {
@@ -419,32 +471,7 @@ namespace gladius::io
 
     void FrontlitThicknessSolver::projectOntoConstraints(std::vector<float>& thicknesses) const
     {
-        float totalThickness = 0.0f;
-
-        for (std::size_t i = 0; i < thicknesses.size(); ++i)
-        {
-            if (thicknesses[i] <= 0.0f)
-            {
-                thicknesses[i] = 0.0f;
-            }
-            else
-            {
-                thicknesses[i] = m_constraints.constrain(thicknesses[i]);
-            }
-
-            totalThickness += thicknesses[i];
-        }
-
-        // Handle total thickness constraint by scaling if needed
-        if (m_constraints.totalMaxThickness > 0.0f && totalThickness > m_constraints.totalMaxThickness)
-        {
-            float const scale = m_constraints.totalMaxThickness / totalThickness;
-            for (float& t : thicknesses)
-            {
-                t *= scale;
-                t = m_constraints.constrain(t);
-            }
-        }
+        quantizeClampThicknesses(m_constraints, thicknesses);
     }
 
     float FrontlitThicknessSolver::computeError(Eigen::Vector3f const& predicted,
diff --git a/gladius/src/io/3mf/Importer3mf.cpp b/gladius/src/io/3mf/Importer3mf.cpp
index 5433b2fb..361d430b 100644
--- a/gladius/src/io/3mf/Importer3mf.cpp
+++ b/gladius/src/io/3mf/Importer3mf.cpp
@@ -1170,6 +1170,77 @@ namespace gladius::io
         }
     }
 
+    void Importer3mf::collectBooleanReferencedMeshIds(
+      Lib3MF::PModel const & model,
+      Lib3MF::PBooleanObject const & booleanObject,
+      std::set<Lib3MF_uint32> & meshIds,
+      std::set<Lib3MF_uint32> & visitedBooleanIds) const
+    {
+        if (!model || !booleanObject)
+        {
+            return;
+        }
+
+        auto const booleanId = booleanObject->GetModelResourceID();
+        if (!visitedBooleanIds.insert(booleanId).second)
+        {
+            return;
+        }
+
+        try
+        {
+            auto const baseObject = booleanObject->GetBaseObject();
+            if (baseObject && baseObject->IsMeshObject())
+            {
+                meshIds.insert(baseObject->GetModelResourceID());
+            }
+            else if (baseObject && baseObject->IsBooleanObject())
+            {
+                auto const baseBoolean =
+                  model->GetBooleanObjectByID(baseObject->GetUniqueResourceID());
+                collectBooleanReferencedMeshIds(model, baseBoolean, meshIds, visitedBooleanIds);
+            }
+        }
+        catch (std::exception const & e)
+        {
+            if (m_eventLogger)
+            {
+                m_eventLogger->addEvent(
+                  {fmt::format("Could not collect boolean base mesh references for resource {}: {}",
+                               booleanId,
+                               e.what()),
+                   events::Severity::Warning});
+            }
+        }
+
+        auto const operandCount = booleanObject->GetOperandCount();
+        for (Lib3MF_uint32 operandIndex = 0; operandIndex < operandCount; ++operandIndex)
+        {
+            try
+            {
+                Lib3MF::PMeshObject operandMesh;
+                (void) booleanObject->GetOperand(operandIndex, operandMesh);
+                if (operandMesh)
+                {
+                    meshIds.insert(operandMesh->GetModelResourceID());
+                }
+            }
+            catch (std::exception const & e)
+            {
+                if (m_eventLogger)
+                {
+                    m_eventLogger->addEvent(
+                      {fmt::format("Could not collect boolean operand {} mesh reference for "
+                                   "resource {}: {}",
+                                   operandIndex,
+                                   booleanId,
+                                   e.what()),
+                       events::Severity::Warning});
+                }
+            }
+        }
+    }
+
     std::set<Lib3MF_uint32> Importer3mf::collectBboxOnlyMeshIds(Lib3MF::PModel const & model) const
     {
         std::set<Lib3MF_uint32> bboxOnlyIds;
@@ -1204,6 +1275,16 @@ namespace gladius::io
             }
         }
 
+        auto booleanIterator = model->GetBooleanObjects();
+        while (booleanIterator->MoveNext())
+        {
+            std::set<Lib3MF_uint32> visitedBooleanIds;
+            collectBooleanReferencedMeshIds(model,
+                                            booleanIterator->GetCurrentBooleanObject(),
+                                            regularIds,
+                                            visitedBooleanIds);
+        }
+
         // Return only IDs that are exclusively used as bounding boxes (not also as real geometry)
         std::set<Lib3MF_uint32> result;
         for (auto const id : bboxOnlyIds)
@@ -1392,6 +1473,24 @@ namespace gladius::io
 
         auto * resource = resourceManager.getResourcePtr(key);
         auto * spatialMesh = dynamic_cast<SpatialMeshResource *>(resource);
+        if (spatialMesh != nullptr && spatialMesh->hasMeshQualityIssues())
+        {
+            auto const message = spatialMesh->formatMeshQualityMessage(key.getDisplayName());
+            bool const strictNanoVdb = m_meshSdfEvaluationConfig.method == MeshSdfMethod::NanoVDB &&
+                                       m_nanovdbBuildPolicy.failurePolicy ==
+                                           NanoVdbFailurePolicy::Fail;
+            if (m_eventLogger)
+            {
+                m_eventLogger->addEvent({message,
+                                         strictNanoVdb ? gladius::events::Severity::Error
+                                                       : gladius::events::Severity::Warning});
+            }
+            if (strictNanoVdb)
+            {
+                resourceManager.deleteResource(key);
+                throw NanoVdbBuildRejectedError(message);
+            }
+        }
         if (spatialMesh != nullptr && spatialMesh->hasNanoVdbBuildIssue())
         {
             auto const message = spatialMesh->formatNanoVdbBuildMessage(key.getDisplayName());
@@ -1712,6 +1811,314 @@ namespace gladius::io
         }
     }
 
+    nodes::Port & Importer3mf::createMeshSdfNode(ResourceKey const & key,
+                                                 nodes::Port & coordinateSystemPort,
+                                                 nodes::Model & target)
+    {
+        auto resourceNode = target.create<nodes::Resource>();
+        resourceNode->parameter().at(nodes::FieldNames::ResourceId) =
+          nodes::VariantParameter(key.getResourceId().value_or(0));
+
+        auto meshSdfNode = target.create<nodes::SignedDistanceToMesh>();
+        meshSdfNode->parameter().at(nodes::FieldNames::Pos).setInputFromPort(coordinateSystemPort);
+        meshSdfNode->parameter()
+          .at(nodes::FieldNames::Mesh)
+          .setInputFromPort(resourceNode->getOutputValue());
+
+        return meshSdfNode->getOutputs().at(nodes::FieldNames::Distance);
+    }
+
+    nodes::Port & Importer3mf::combineSdf(nodes::Model & target,
+                                          nodes::Port & lhs,
+                                          nodes::Port & rhs,
+                                          Lib3MF::eBooleanOperation operation)
+    {
+        switch (operation)
+        {
+        case Lib3MF::eBooleanOperation::Union:
+        {
+            auto unionNode = target.create<nodes::Min>();
+            unionNode->setInputA(lhs);
+            unionNode->setInputB(rhs);
+            return unionNode->getResultOutputPort();
+        }
+        case Lib3MF::eBooleanOperation::Intersection:
+        {
+            auto intersectionNode = target.create<nodes::Max>();
+            intersectionNode->setInputA(lhs);
+            intersectionNode->setInputB(rhs);
+            return intersectionNode->getResultOutputPort();
+        }
+        case Lib3MF::eBooleanOperation::Difference:
+        {
+            auto negateNode = target.create<nodes::Multiplication>();
+            auto & minusOne =
+              nodes::Builder::ensureConstantScalar(target, "BooleanDifferenceNegate", -1.0f);
+            negateNode->setInputA(rhs);
+            negateNode->parameter().at(nodes::FieldNames::B).setInputFromPort(minusOne);
+
+            auto differenceNode = target.create<nodes::Max>();
+            differenceNode->setInputA(lhs);
+            differenceNode->setInputB(negateNode->getResultOutputPort());
+            return differenceNode->getResultOutputPort();
+        }
+        default:
+            throw std::runtime_error("Unsupported 3MF boolean operation");
+        }
+    }
+
+    nodes::Port & Importer3mf::createLevelSetSdfNode(Lib3MF::PModel const & model,
+                                                     Lib3MF::PLevelSet const & levelSet,
+                                                     nodes::Port & coordinateSystemPort,
+                                                     nodes::Model & target,
+                                                     Document & doc)
+    {
+        if (!levelSet)
+        {
+            throw std::runtime_error("Cannot build SDF for null level set base object");
+        }
+
+        auto function = levelSet->GetFunction();
+        if (!function)
+        {
+            throw std::runtime_error("No function found for boolean level set base object");
+        }
+
+        auto const functionResourceId = function->GetResourceID();
+        auto const functionResource = model->GetResourceByID(functionResourceId);
+        if (!functionResource)
+        {
+            throw std::runtime_error(
+              fmt::format("Could not resolve level set function resource {}", functionResourceId));
+        }
+
+        auto const modelFunctionId = functionResource->GetModelResourceID();
+        auto const gladiusFunction = doc.getAssembly()->findModel(modelFunctionId);
+        if (!gladiusFunction)
+        {
+            throw std::runtime_error(
+              fmt::format("Could not find imported level set function {}", modelFunctionId));
+        }
+
+        auto mesh = levelSet->GetMesh();
+        if (!mesh)
+        {
+            throw std::runtime_error("No mesh domain found for boolean level set base object");
+        }
+
+        auto channelName = levelSet->GetChannelName();
+        if (channelName.empty())
+        {
+            channelName = nodes::FieldNames::Shape;
+        }
+
+        nodes::Builder builder;
+        auto const levelSetTransform = matrix4x4From3mfTransform(levelSet->GetTransform());
+        auto & functionCoordinateSystemPort =
+          builder.insertTransformation(target, coordinateSystemPort, levelSetTransform, 1.0f);
+
+        auto const boundingBox = computeBoundingBox(mesh);
+        auto boundingBoxNode = target.create<nodes::BoxMinMax>();
+        boundingBoxNode->parameter()
+          .at(nodes::FieldNames::Pos)
+          .setInputFromPort(coordinateSystemPort);
+
+        auto minVectorNode = target.create<nodes::ConstantVector>();
+        minVectorNode->parameter().at(nodes::FieldNames::X) =
+          nodes::VariantParameter(boundingBox.min.x);
+        minVectorNode->parameter().at(nodes::FieldNames::Y) =
+          nodes::VariantParameter(boundingBox.min.y);
+        minVectorNode->parameter().at(nodes::FieldNames::Z) =
+          nodes::VariantParameter(boundingBox.min.z);
+
+        auto maxVectorNode = target.create<nodes::ConstantVector>();
+        maxVectorNode->parameter().at(nodes::FieldNames::X) =
+          nodes::VariantParameter(boundingBox.max.x);
+        maxVectorNode->parameter().at(nodes::FieldNames::Y) =
+          nodes::VariantParameter(boundingBox.max.y);
+        maxVectorNode->parameter().at(nodes::FieldNames::Z) =
+          nodes::VariantParameter(boundingBox.max.z);
+
+        boundingBoxNode->parameter()
+          .at(nodes::FieldNames::Min)
+          .setInputFromPort(minVectorNode->getVectorOutputPort());
+        boundingBoxNode->parameter()
+          .at(nodes::FieldNames::Max)
+          .setInputFromPort(maxVectorNode->getVectorOutputPort());
+
+        auto resourceNode = target.create<nodes::Resource>();
+        resourceNode->parameter().at(nodes::FieldNames::ResourceId) =
+          nodes::VariantParameter(gladiusFunction->getResourceId());
+
+        auto functionCallNode = target.create<nodes::FunctionCall>();
+        functionCallNode->parameter()
+          .at(nodes::FieldNames::FunctionId)
+          .setInputFromPort(resourceNode->getOutputValue());
+        functionCallNode->updateInputsAndOutputs(*gladiusFunction);
+        target.registerInputs(*functionCallNode);
+        target.registerOutputs(*functionCallNode);
+
+        auto positionInput = functionCallNode->parameter().find(nodes::FieldNames::Pos);
+        if (positionInput == functionCallNode->parameter().end())
+        {
+            throw std::runtime_error("Level set function has no pos input");
+        }
+        positionInput->second.setInputFromPort(functionCoordinateSystemPort);
+
+        auto shapeOutput = functionCallNode->getOutputs().find(channelName);
+        if (shapeOutput == functionCallNode->getOutputs().end())
+        {
+            throw std::runtime_error(
+              fmt::format("Level set function has no output named {}", channelName));
+        }
+        if (shapeOutput->second.getTypeIndex() != nodes::ParameterTypeIndex::Float)
+        {
+            throw std::runtime_error(
+              fmt::format("Level set output {} is not scalar", channelName));
+        }
+
+        auto intersectionNode = target.create<nodes::Max>();
+        intersectionNode->setInputA(boundingBoxNode->getOutputs().at(nodes::FieldNames::Shape));
+        intersectionNode->setInputB(shapeOutput->second);
+        return intersectionNode->getResultOutputPort();
+    }
+
+    nodes::Port & Importer3mf::buildObjectSdf(Lib3MF::PModel const & model,
+                                              Lib3MF::PObject const & object,
+                                              nodes::Port & coordinateSystemPort,
+                                              nodes::Model & target,
+                                              Document & doc)
+    {
+        if (!object)
+        {
+            throw std::runtime_error("Cannot build SDF for null 3MF object");
+        }
+
+        if (object->IsMeshObject())
+        {
+            auto key = ResourceKey{static_cast<uint32_t>(object->GetModelResourceID()),
+                                   ResourceType::Mesh};
+            key.setDisplayName(object->GetName());
+            return createMeshSdfNode(key, coordinateSystemPort, target);
+        }
+
+        if (object->IsBooleanObject())
+        {
+            auto const booleanObject = model->GetBooleanObjectByID(object->GetUniqueResourceID());
+            return buildBooleanSdf(model, booleanObject, coordinateSystemPort, target, doc);
+        }
+
+        if (object->IsLevelSetObject())
+        {
+            auto const levelSet = model->GetLevelSetByID(object->GetUniqueResourceID());
+            return createLevelSetSdfNode(model, levelSet, coordinateSystemPort, target, doc);
+        }
+
+        auto const message = fmt::format("Unsupported base object type in boolean resource {}",
+                                         object->GetModelResourceID());
+        if (m_eventLogger)
+        {
+            m_eventLogger->addEvent({message, events::Severity::Error});
+        }
+        throw std::runtime_error(message);
+    }
+
+    nodes::Port & Importer3mf::buildBooleanSdf(Lib3MF::PModel const & model,
+                                               Lib3MF::PBooleanObject const & booleanObject,
+                                               nodes::Port & coordinateSystemPort,
+                                               nodes::Model & target,
+                                               Document & doc)
+    {
+        if (!booleanObject)
+        {
+            throw std::runtime_error("Cannot build SDF for null boolean object");
+        }
+
+        nodes::Builder builder;
+        auto const baseTransform =
+          inverseMatrix(matrix4x4From3mfTransform(booleanObject->GetBaseTransform()));
+        auto & baseCoordinateSystemPort =
+          builder.insertTransformation(target, coordinateSystemPort, baseTransform, 1.0f);
+
+        auto baseObject = booleanObject->GetBaseObject();
+        auto * currentSdf =
+          &buildObjectSdf(model, baseObject, baseCoordinateSystemPort, target, doc);
+
+        auto const operandCount = booleanObject->GetOperandCount();
+        if (operandCount == 0u && m_eventLogger)
+        {
+            m_eventLogger->addEvent(
+              {fmt::format("Boolean resource {} has no operands; using base object only",
+                           booleanObject->GetModelResourceID()),
+               events::Severity::Warning});
+        }
+
+        for (Lib3MF_uint32 operandIndex = 0; operandIndex < operandCount; ++operandIndex)
+        {
+            Lib3MF::PMeshObject operandMesh;
+            auto const operandTransform =
+              inverseMatrix(matrix4x4From3mfTransform(booleanObject->GetOperand(operandIndex,
+                                                                                 operandMesh)));
+            if (!operandMesh)
+            {
+                throw std::runtime_error(
+                  fmt::format("Boolean resource {} has null operand {}",
+                              booleanObject->GetModelResourceID(),
+                              operandIndex));
+            }
+
+            auto & operandCoordinateSystemPort =
+              builder.insertTransformation(target, coordinateSystemPort, operandTransform, 1.0f);
+            auto operandKey = ResourceKey{static_cast<uint32_t>(operandMesh->GetModelResourceID()),
+                                          ResourceType::Mesh};
+            operandKey.setDisplayName(operandMesh->GetName());
+            auto & operandSdf = createMeshSdfNode(operandKey, operandCoordinateSystemPort, target);
+            currentSdf =
+              &combineSdf(target, *currentSdf, operandSdf, booleanObject->GetOperation());
+        }
+
+        return *currentSdf;
+    }
+
+    void Importer3mf::addBooleanObject(Lib3MF::PModel model,
+                                       Lib3MF::PBooleanObject booleanObject,
+                                       nodes::Matrix4x4 const & trafo,
+                                       Document & doc)
+    {
+        if (!booleanObject)
+        {
+            if (m_eventLogger)
+            {
+                m_eventLogger->addEvent({"No boolean object to import", events::Severity::Error});
+            }
+            return;
+        }
+
+        nodes::Builder builder;
+        auto & target = *doc.getAssembly()->assemblyModel();
+        float const units_per_mm = computeUnitsPerMM(model);
+        auto & coordinateSystemPort = builder.addTransformationToInputCs(target, trafo, units_per_mm);
+        auto & booleanSdf = buildBooleanSdf(model, booleanObject, coordinateSystemPort, target, doc);
+
+        auto * shapeSink = target.getEndNode()->getParameter(nodes::FieldNames::Shape);
+        if (!shapeSink)
+        {
+            throw std::runtime_error("End node is required to have a shape parameter");
+        }
+
+        auto * lastShapePort = builder.getLastShape(target);
+        if (!lastShapePort)
+        {
+            shapeSink->setInputFromPort(booleanSdf);
+            return;
+        }
+
+        auto unionNode = target.create<nodes::Min>();
+        unionNode->setInputA(*lastShapePort);
+        unionNode->setInputB(booleanSdf);
+        shapeSink->setInputFromPort(unionNode->getResultOutputPort());
+    }
+
     void Importer3mf::addLevelSetObject(Lib3MF::PModel model,
                                         ResourceKey const & key,
                                         Lib3MF::PLevelSet levelSet,
@@ -2089,6 +2496,11 @@ namespace gladius::io
             auto levelSet = model->GetLevelSetByID(objectRes.GetUniqueResourceID());
             addLevelSetObject(model, key, levelSet, trafo, doc);
         }
+        else if (objectRes.IsBooleanObject())
+        {
+            auto booleanObject = model->GetBooleanObjectByID(objectRes.GetUniqueResourceID());
+            addBooleanObject(model, booleanObject, trafo, doc);
+        }
     }
 
     void Importer3mf::load(std::filesystem::path const & filename, Document & doc)
diff --git a/gladius/src/io/3mf/Importer3mf.h b/gladius/src/io/3mf/Importer3mf.h
index a2b2b3e6..4faf5156 100644
--- a/gladius/src/io/3mf/Importer3mf.h
+++ b/gladius/src/io/3mf/Importer3mf.h
@@ -210,6 +210,38 @@ namespace gladius::io
                                nodes::Matrix4x4 const & trafo,
                                Document & doc);
 
+        void addBooleanObject(Lib3MF::PModel model,
+                      Lib3MF::PBooleanObject booleanObject,
+                      nodes::Matrix4x4 const & trafo,
+                      Document & doc);
+
+        nodes::Port & buildBooleanSdf(Lib3MF::PModel const & model,
+                           Lib3MF::PBooleanObject const & booleanObject,
+                           nodes::Port & coordinateSystemPort,
+                           nodes::Model & target,
+                           Document & doc);
+
+        nodes::Port & buildObjectSdf(Lib3MF::PModel const & model,
+                          Lib3MF::PObject const & object,
+                          nodes::Port & coordinateSystemPort,
+                          nodes::Model & target,
+                          Document & doc);
+
+        nodes::Port & createLevelSetSdfNode(Lib3MF::PModel const & model,
+                              Lib3MF::PLevelSet const & levelSet,
+                              nodes::Port & coordinateSystemPort,
+                              nodes::Model & target,
+                              Document & doc);
+
+        static nodes::Port & createMeshSdfNode(ResourceKey const & key,
+                                 nodes::Port & coordinateSystemPort,
+                                 nodes::Model & target);
+
+        static nodes::Port & combineSdf(nodes::Model & target,
+                             nodes::Port & lhs,
+                             nodes::Port & rhs,
+                             Lib3MF::eBooleanOperation operation);
+
         void loadImageStacks(std::filesystem::path const & filename,
                              Lib3MF::PModel model,
                              Document & doc);
@@ -277,6 +309,11 @@ namespace gladius::io
         /// @return Set of model resource IDs that should be skipped during mesh loading.
         std::set<Lib3MF_uint32> collectBboxOnlyMeshIds(Lib3MF::PModel const & model) const;
 
+        void collectBooleanReferencedMeshIds(Lib3MF::PModel const & model,
+                                             Lib3MF::PBooleanObject const & booleanObject,
+                                             std::set<Lib3MF_uint32> & meshIds,
+                                             std::set<Lib3MF_uint32> & visitedBooleanIds) const;
+
         Lib3MF::PWrapper m_wrapper{};
 
         MeshResources m_meshObjects;
diff --git a/gladius/src/io/3mf/LibraryExampleExtractor.cpp b/gladius/src/io/3mf/LibraryExampleExtractor.cpp
new file mode 100644
index 00000000..a97546e9
--- /dev/null
+++ b/gladius/src/io/3mf/LibraryExampleExtractor.cpp
@@ -0,0 +1,254 @@
+#include "LibraryExampleExtractor.h"
+
+#include "LibraryMetadata.h"
+
+#include <lib3mf_implicit.hpp>
+
+#include <algorithm>
+#include <cctype>
+
+namespace gladius::io
+{
+    namespace
+    {
+        /// @brief Replaces non-alphanumeric characters with underscores, matching the
+        ///        transformation the importer applies to all node/parameter identifiers.
+        std::string makeValidVariableName(std::string const & name)
+        {
+            std::string result;
+            result.reserve(name.size());
+            for (auto const c : name)
+            {
+                result += std::isalnum(static_cast<unsigned char>(c)) ? c : '_';
+            }
+            return result;
+        }
+    } // namespace
+    std::vector<ExampleConstantValue>
+    extractExampleConstants(std::filesystem::path const & filePath,
+                            std::string const & taggedFunctionDisplayName)
+    {
+        try
+        {
+            auto wrapper = Lib3MF::CWrapper::loadLibrary();
+            auto model = wrapper->CreateModel();
+            auto reader = model->QueryReader("3mf");
+            reader->ReadFromFile(filePath.string());
+
+            auto const libMeta = readLibraryMetadata(model);
+            if (!libMeta)
+            {
+                return {};
+            }
+
+            auto const taggedIds = parseResourceIds(libMeta->libraryFunctions);
+            if (taggedIds.empty())
+            {
+                return {};
+            }
+
+            // Find the tagged function's model resource ID by matching its display name.
+            Lib3MF_uint32 taggedFunctionResourceId = 0;
+            {
+                auto resIter = model->GetResources();
+                while (resIter->MoveNext())
+                {
+                    auto res = resIter->GetCurrent();
+                    auto const modelId = res->GetModelResourceID();
+                    if (std::find(taggedIds.begin(), taggedIds.end(), modelId) == taggedIds.end())
+                    {
+                        continue;
+                    }
+                    auto implicitFunc = std::dynamic_pointer_cast<Lib3MF::CImplicitFunction>(res);
+                    if (implicitFunc &&
+                        implicitFunc->GetDisplayName() == taggedFunctionDisplayName)
+                    {
+                        taggedFunctionResourceId = modelId;
+                        break;
+                    }
+                }
+            }
+
+            if (taggedFunctionResourceId == 0)
+            {
+                return {};
+            }
+
+            // Scan all implicit functions to find one that calls the tagged function.
+            // Typically this is the assembly/example function used for thumbnail generation.
+            auto resIter = model->GetResources();
+            while (resIter->MoveNext())
+            {
+                auto res = resIter->GetCurrent();
+                auto implicitFunc = std::dynamic_pointer_cast<Lib3MF::CImplicitFunction>(res);
+                if (!implicitFunc)
+                {
+                    continue;
+                }
+                // Skip tagged functions (the library function itself).
+                auto const modelId = res->GetModelResourceID();
+                if (std::find(taggedIds.begin(), taggedIds.end(), modelId) != taggedIds.end())
+                {
+                    continue;
+                }
+
+                // Search for a FunctionCall node that references the tagged function.
+                auto nodeIter = implicitFunc->GetNodes();
+                while (nodeIter->MoveNext())
+                {
+                    auto node = nodeIter->GetCurrent();
+                    auto funcCallNode =
+                      std::dynamic_pointer_cast<Lib3MF::CFunctionCallNode>(node);
+                    if (!funcCallNode)
+                    {
+                        continue;
+                    }
+
+                    // Resolve the called function's resource ID via the functionid reference.
+                    auto const funcIdPort = funcCallNode->GetInputFunctionID();
+                    if (!funcIdPort || funcIdPort->GetReference().empty())
+                    {
+                        continue;
+                    }
+
+                    std::string const & refName = funcIdPort->GetReference();
+                    auto const dotPos = refName.find('.');
+                    std::string const sourceNodeId =
+                      dotPos != std::string::npos ? refName.substr(0, dotPos) : refName;
+
+                    Lib3MF_uint32 calledFunctionId = 0;
+                    {
+                        auto scanIter = implicitFunc->GetNodes();
+                        while (scanIter->MoveNext())
+                        {
+                            auto scanNode = scanIter->GetCurrent();
+                            if (scanNode->GetIdentifier() != sourceNodeId)
+                            {
+                                continue;
+                            }
+                            auto resourceIdNode =
+                              std::dynamic_pointer_cast<Lib3MF::CResourceIdNode>(scanNode);
+                            if (resourceIdNode && resourceIdNode->GetResource())
+                            {
+                                calledFunctionId =
+                                  resourceIdNode->GetResource()->GetModelResourceID();
+                            }
+                            break;
+                        }
+                    }
+
+                    if (calledFunctionId != taggedFunctionResourceId)
+                    {
+                        continue;
+                    }
+
+                    // Found the FunctionCall — collect constants wired to its argument inputs.
+                    std::vector<ExampleConstantValue> result;
+                    auto inputIter = funcCallNode->GetInputs();
+                    while (inputIter->MoveNext())
+                    {
+                        auto input = inputIter->GetCurrent();
+
+                        // Skip the special functionid input (case-insensitive: lib3mf may
+                        // produce "functionID" or "functionid" depending on source).
+                        auto const inputId = input->GetIdentifier();
+                        if (inputId.size() == 10 &&
+                            std::equal(inputId.begin(), inputId.end(), "functionid",
+                                       [](unsigned char a, unsigned char b)
+                                       {
+                                           return std::tolower(a) == std::tolower(b);
+                                       }))
+                        {
+                            continue;
+                        }
+
+                        std::string const & inputRef = input->GetReference();
+                        if (inputRef.empty())
+                        {
+                            continue;
+                        }
+
+                        auto const inputDotPos = inputRef.find('.');
+                        std::string const srcNodeId = inputDotPos != std::string::npos
+                                                        ? inputRef.substr(0, inputDotPos)
+                                                        : inputRef;
+
+                        // Find the source node and extract its constant value.
+                        auto srcIter = implicitFunc->GetNodes();
+                        while (srcIter->MoveNext())
+                        {
+                            auto srcNode = srcIter->GetCurrent();
+                            if (srcNode->GetIdentifier() != srcNodeId)
+                            {
+                                continue;
+                            }
+
+                            if (srcNode->GetNodeType() == Lib3MF::eImplicitNodeType::Constant)
+                            {
+                                auto scalarNode =
+                                  std::dynamic_pointer_cast<Lib3MF::CConstantNode>(srcNode);
+                                if (scalarNode)
+                                {
+                                    ExampleConstantValue val;
+                                    val.kind = ExampleConstantValue::Kind::Scalar;
+                                    val.parameterName = makeValidVariableName(input->GetIdentifier());
+                                    val.scalarValue =
+                                      static_cast<float>(scalarNode->GetConstant());
+                                    result.push_back(std::move(val));
+                                }
+                            }
+                            else if (srcNode->GetNodeType() == Lib3MF::eImplicitNodeType::ConstVec)
+                            {
+                                auto vecNode =
+                                  std::dynamic_pointer_cast<Lib3MF::CConstVecNode>(srcNode);
+                                if (vecNode)
+                                {
+                                    auto const v = vecNode->GetVector();
+                                    ExampleConstantValue val;
+                                    val.kind = ExampleConstantValue::Kind::Vector;
+                                    val.parameterName = makeValidVariableName(input->GetIdentifier());
+                                    val.vectorValue = {
+                                      static_cast<float>(v.m_Coordinates[0]),
+                                      static_cast<float>(v.m_Coordinates[1]),
+                                      static_cast<float>(v.m_Coordinates[2])};
+                                    result.push_back(std::move(val));
+                                }
+                            }
+                            else if (srcNode->GetNodeType() == Lib3MF::eImplicitNodeType::ConstMat)
+                            {
+                                auto matNode =
+                                  std::dynamic_pointer_cast<Lib3MF::CConstMatNode>(srcNode);
+                                if (matNode)
+                                {
+                                    auto const m = matNode->GetMatrix();
+                                    ExampleConstantValue val;
+                                    val.kind = ExampleConstantValue::Kind::Matrix;
+                                    val.parameterName = makeValidVariableName(input->GetIdentifier());
+                                    for (int row = 0; row < 4; ++row)
+                                    {
+                                        for (int col = 0; col < 4; ++col)
+                                        {
+                                            val.matrixValue[row][col] =
+                                              static_cast<float>(m.m_Field[row][col]);
+                                        }
+                                    }
+                                    result.push_back(std::move(val));
+                                }
+                            }
+                            break;
+                        }
+                    }
+
+                    return result;
+                }
+            }
+        }
+        catch (...)
+        {
+            // Example constant extraction is best-effort; return empty on any failure.
+        }
+
+        return {};
+    }
+
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/LibraryExampleExtractor.h b/gladius/src/io/3mf/LibraryExampleExtractor.h
new file mode 100644
index 00000000..0917404f
--- /dev/null
+++ b/gladius/src/io/3mf/LibraryExampleExtractor.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "nodes/types.h"
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace gladius::io
+{
+    /// @brief A constant value extracted from a library .3mf example function.
+    ///
+    /// Represents a ConstantScalar or ConstantVector node that feeds into
+    /// a FunctionCall argument in the library file's embedded example.
+    struct ExampleConstantValue
+    {
+        enum class Kind
+        {
+            Scalar,
+            Vector,
+            Matrix
+        };
+
+        Kind kind = Kind::Scalar;
+        std::string parameterName; ///< The FunctionCall argument name this value feeds into
+        float scalarValue = 0.0f;
+        nodes::float3 vectorValue = {};
+        nodes::Matrix4x4 matrixValue = {};
+    };
+
+    /// @brief Extract example constant values for a tagged library function from a .3mf file.
+    ///
+    /// Loads the file, finds the assembly/example function that calls the tagged function
+    /// (matched by display name), and returns the constant node values wired to its
+    /// FunctionCall arguments.  Used to pre-populate constant nodes when the user drops a
+    /// library item onto the node editor canvas.
+    ///
+    /// @param filePath                  Path to the .3mf library file.
+    /// @param taggedFunctionDisplayName Display name of the tagged library function.
+    /// @return Example constants (empty if none found, or on any error).
+    [[nodiscard]] std::vector<ExampleConstantValue>
+    extractExampleConstants(std::filesystem::path const & filePath,
+                            std::string const & taggedFunctionDisplayName);
+
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/OpenVdbShellGenerator.cpp b/gladius/src/io/3mf/OpenVdbShellGenerator.cpp
new file mode 100644
index 00000000..a03efd92
--- /dev/null
+++ b/gladius/src/io/3mf/OpenVdbShellGenerator.cpp
@@ -0,0 +1,550 @@
+#include "OpenVdbShellGenerator.h"
+
+#include "../MeshExporter.h"
+#include "DualContouringSamplingProgram.h"
+#include "ResourceContext.h"
+#include "compute/ComputeCore.h"
+
+#include <algorithm>
+#include <unordered_map>
+
+namespace gladius::io
+{
+    namespace
+    {
+        [[nodiscard]] openvdb::math::Transform::Ptr createGridTransform(
+            BoundingBox const& bbox,
+            std::size_t width,
+            std::size_t height,
+            std::size_t depth)
+        {
+            double const voxelX = width > 1U
+                ? static_cast<double>(bbox.max.x - bbox.min.x) / static_cast<double>(width - 1U)
+                : 1.0;
+            double const voxelY = height > 1U
+                ? static_cast<double>(bbox.max.y - bbox.min.y) / static_cast<double>(height - 1U)
+                : 1.0;
+            double const voxelZ = depth > 1U
+                ? static_cast<double>(bbox.max.z - bbox.min.z) / static_cast<double>(depth - 1U)
+                : 1.0;
+
+            auto transform = openvdb::math::Transform::createLinearTransform();
+            transform->preScale(openvdb::Vec3d{voxelX, voxelY, voxelZ});
+            transform->postTranslate(openvdb::Vec3d{
+                static_cast<double>(bbox.min.x),
+                static_cast<double>(bbox.min.y),
+                static_cast<double>(bbox.min.z)});
+            return transform;
+        }
+
+        /// Releases the precomputed SDF buffer when the guard goes out of scope.
+        /// This ensures cleanup on all exit paths, including exceptions.
+        class PreCompSdfReleaseGuard
+        {
+          public:
+            explicit PreCompSdfReleaseGuard(SharedResources resources)
+                : m_resources(std::move(resources))
+            {
+            }
+
+            ~PreCompSdfReleaseGuard()
+            {
+                if (m_resources != nullptr)
+                {
+                    m_resources->releasePreComputedSdf();
+                }
+            }
+
+            PreCompSdfReleaseGuard(PreCompSdfReleaseGuard const&) = delete;
+            PreCompSdfReleaseGuard& operator=(PreCompSdfReleaseGuard const&) = delete;
+            PreCompSdfReleaseGuard(PreCompSdfReleaseGuard&&) = delete;
+            PreCompSdfReleaseGuard& operator=(PreCompSdfReleaseGuard&&) = delete;
+
+          private:
+            SharedResources m_resources;
+        };
+
+        struct Vector3fHash
+        {
+            [[nodiscard]] std::size_t operator()(Eigen::Vector3f const& value) const noexcept
+            {
+                std::uint32_t const x = std::bit_cast<std::uint32_t>(value.x());
+                std::uint32_t const y = std::bit_cast<std::uint32_t>(value.y());
+                std::uint32_t const z = std::bit_cast<std::uint32_t>(value.z());
+                std::size_t const h1 = std::hash<std::uint32_t>{}(x);
+                std::size_t const h2 = std::hash<std::uint32_t>{}(y);
+                std::size_t const h3 = std::hash<std::uint32_t>{}(z);
+                return h1 ^ (h2 + 0x9e3779b9U + (h1 << 6) + (h1 >> 2)) ^
+                       (h3 + 0x9e3779b97f4a7c15ULL + (h2 << 6) + (h2 >> 2));
+            }
+        };
+
+        struct Vector3fEqual
+        {
+            [[nodiscard]] bool operator()(Eigen::Vector3f const& lhs, Eigen::Vector3f const& rhs) const noexcept
+            {
+                return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
+            }
+        };
+    }
+
+    OpenVdbShellGenerator::OpenVdbShellGenerator(ComputeCore& core)
+        : m_core(core)
+    {
+    }
+
+    std::vector<ShellGenerator::ShellMesh> OpenVdbShellGenerator::generateUniformShells(
+        FilamentStack const& stack,
+        ThicknessSolution const& solution,
+        ManifoldDualContouringOptions const& options,
+        std::function<bool()> cancellationCheck)
+    {
+        std::vector<ShellGenerator::ShellMesh> shells;
+
+        if (stack.size() != solution.thicknesses.size())
+        {
+            return shells;
+        }
+
+        if (!m_core.updateBBox())
+        {
+            return shells;
+        }
+
+        auto const bbox = m_core.getBoundingBox();
+        if (!bbox.has_value())
+        {
+            return shells;
+        }
+
+        auto const intervals = ShellThicknessPartition::buildIntervals(solution);
+        if (intervals.empty())
+        {
+            return shells;
+        }
+
+        std::size_t const sdfResolution = selectSdfResolution(options);
+        m_core.setPreCompSdfSize(sdfResolution);
+        m_core.precomputeSdfForBBox(*bbox);
+
+        auto resources = m_core.getResourceContext();
+        if (!resources)
+        {
+            return shells;
+        }
+
+        PreCompSdfReleaseGuard const sdfGuard{resources};
+        auto& sdfBuffer = resources->getPrecompSdfBuffer();
+
+        float const totalDepth = ShellThicknessPartition::computeMaxDepth(solution.thicknesses);
+        float const voxelX = sdfResolution > 1U
+            ? (bbox->max.x - bbox->min.x) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelY = sdfResolution > 1U
+            ? (bbox->max.y - bbox->min.y) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelZ = sdfResolution > 1U
+            ? (bbox->max.z - bbox->min.z) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelSize = std::max({voxelX, voxelY, voxelZ, 1e-4F});
+        float const narrowBandWidth = std::max(totalDepth + voxelSize * 2.0F, voxelSize * 4.0F);
+
+        for (auto const& interval : intervals)
+        {
+            if (cancellationCheck && cancellationCheck())
+            {
+                shells.clear();
+                break;
+            }
+
+            auto shellGrid = createShellGrid(sdfBuffer, *bbox, interval, narrowBandWidth);
+            if (!shellGrid)
+            {
+                continue;
+            }
+
+            auto mesh = vdb::gridToMesh(shellGrid, *m_core.getComputeContext());
+            if (mesh.getNumberOfFaces() == 0U)
+            {
+                continue;
+            }
+
+            shells.push_back(meshToShellMesh(
+                mesh,
+                stack[interval.layerIndex].name,
+                static_cast<int>(interval.layerIndex)));
+        }
+
+        return shells;
+    }
+
+    float OpenVdbShellGenerator::evaluateShellSignedDistance(
+        float modelSdf,
+        ShellLayerDepthInterval const& interval) noexcept
+    {
+        float const outerConstraint = modelSdf + interval.outerDepth;
+        float const innerConstraint = -(modelSdf + interval.innerDepth);
+        return std::max(outerConstraint, innerConstraint);
+    }
+
+    float OpenVdbShellGenerator::evaluateVariableShellSignedDistance(
+        float modelSdf,
+        float outerDepth,
+        float innerDepth,
+        bool isInnermostLayer) noexcept
+    {
+        float const outerConstraint = modelSdf + outerDepth;
+        if (isInnermostLayer)
+        {
+            return outerConstraint;
+        }
+
+        float const innerConstraint = -(modelSdf + innerDepth);
+        return std::max(outerConstraint, innerConstraint);
+    }
+
+    openvdb::FloatGrid::Ptr OpenVdbShellGenerator::createShellGrid(
+        PreComputedSdf& sdf,
+        BoundingBox const& bbox,
+        ShellLayerDepthInterval const& interval,
+        float narrowBandWidth) const
+    {
+        using namespace openvdb;
+
+        sdf.read();
+
+        FloatGrid::Ptr grid = FloatGrid::create(narrowBandWidth);
+        grid->setGridClass(GRID_LEVEL_SET);
+        grid->setName("OpenVDB shell band");
+
+        FloatGrid::Accessor accessor = grid->getAccessor();
+
+        auto const width = sdf.getWidth();
+        auto const height = sdf.getHeight();
+        auto const depth = sdf.getDepth();
+
+        for (int z = 0; z < static_cast<int>(depth); ++z)
+        {
+            for (int y = 0; y < static_cast<int>(height); ++y)
+            {
+                for (int x = 0; x < static_cast<int>(width); ++x)
+                {
+                    float const modelSdf = sdf.getValue(x, y, z).s[3];
+                    float const shellSdf = evaluateShellSignedDistance(modelSdf, interval);
+
+                    if (shellSdf < narrowBandWidth)
+                    {
+                        accessor.setValue(Coord{x, y, z}, std::max(shellSdf, -narrowBandWidth));
+                    }
+                }
+            }
+        }
+
+        grid->pruneGrid();
+        grid->setTransform(createGridTransform(bbox, width, height, depth));
+        return grid;
+    }
+
+    openvdb::FloatGrid::Ptr OpenVdbShellGenerator::createVariableShellGrid(
+        PreComputedSdf& sdf,
+        BoundingBox const& bbox,
+        SurfaceThicknessField const* outerField,
+        SurfaceThicknessField const* innerField,
+        float narrowBandWidth) const
+    {
+        using namespace openvdb;
+
+        sdf.read();
+
+        FloatGrid::Ptr grid = FloatGrid::create(narrowBandWidth);
+        grid->setGridClass(GRID_LEVEL_SET);
+        grid->setName("OpenVDB variable shell band");
+
+        FloatGrid::Accessor accessor = grid->getAccessor();
+
+        auto const width = sdf.getWidth();
+        auto const height = sdf.getHeight();
+        auto const depth = sdf.getDepth();
+
+        float const voxelX = width > 1U ? (bbox.max.x - bbox.min.x) / static_cast<float>(width - 1U) : 1.0F;
+        float const voxelY = height > 1U ? (bbox.max.y - bbox.min.y) / static_cast<float>(height - 1U) : 1.0F;
+        float const voxelZ = depth > 1U ? (bbox.max.z - bbox.min.z) / static_cast<float>(depth - 1U) : 1.0F;
+
+        bool const isInnermostLayer = innerField == nullptr;
+        bool const isOutermostLayer = outerField == nullptr;
+
+        for (int z = 0; z < static_cast<int>(depth); ++z)
+        {
+            float const worldZ = bbox.min.z + static_cast<float>(z) * voxelZ;
+            for (int y = 0; y < static_cast<int>(height); ++y)
+            {
+                float const worldY = bbox.min.y + static_cast<float>(y) * voxelY;
+                for (int x = 0; x < static_cast<int>(width); ++x)
+                {
+                    float const worldX = bbox.min.x + static_cast<float>(x) * voxelX;
+                    Eigen::Vector3f const worldPos{worldX, worldY, worldZ};
+
+                    float const modelSdf = sdf.getValue(x, y, z).s[3];
+                    float const outerDepth = isOutermostLayer ? 0.0F : outerField->sampleAt(worldPos);
+                    float const innerDepth = isInnermostLayer
+                        ? outerDepth
+                        : innerField->sampleAt(worldPos);
+
+                    float const shellSdf = evaluateVariableShellSignedDistance(
+                        modelSdf,
+                        outerDepth,
+                        innerDepth,
+                        isInnermostLayer);
+
+                    if (shellSdf < narrowBandWidth)
+                    {
+                        accessor.setValue(Coord{x, y, z}, std::max(shellSdf, -narrowBandWidth));
+                    }
+                }
+            }
+        }
+
+        grid->pruneGrid();
+        grid->setTransform(createGridTransform(bbox, width, height, depth));
+        return grid;
+    }
+
+    bool OpenVdbShellGenerator::sampleSurfaceColors(
+        std::vector<Eigen::Vector3f> const& surfaceVertices,
+        std::vector<Eigen::Vector3f>& surfaceColors) const
+    {
+        auto* samplingProgram = m_core.getProgramManager().getDualContouringSamplingProgram();
+        auto primitives = m_core.getPrimitives();
+
+        if (samplingProgram == nullptr || primitives == nullptr)
+        {
+            return false;
+        }
+
+        samplingProgram->sampleColors(surfaceVertices, surfaceColors, *primitives);
+        return surfaceColors.size() == surfaceVertices.size();
+    }
+
+    std::vector<Eigen::Vector3f> OpenVdbShellGenerator::extractSurfaceVertices(
+        PreComputedSdf& sdf,
+        BoundingBox const& bbox,
+        float narrowBandWidth) const
+    {
+        std::vector<Eigen::Vector3f> surfaceVertices;
+
+        auto grid = vdb::createGridFromSdf(sdf, narrowBandWidth);
+        if (!grid)
+        {
+            return surfaceVertices;
+        }
+
+        grid->setTransform(createGridTransform(bbox, sdf.getWidth(), sdf.getHeight(), sdf.getDepth()));
+        auto mesh = vdb::gridToMesh(grid, *m_core.getComputeContext());
+
+        std::size_t const faceCount = mesh.getNumberOfFaces();
+        std::unordered_map<Eigen::Vector3f, std::uint32_t, Vector3fHash, Vector3fEqual> indexMap;
+        indexMap.reserve(faceCount * 3U);
+        surfaceVertices.reserve(faceCount);
+
+        for (std::size_t faceIndex = 0; faceIndex < faceCount; ++faceIndex)
+        {
+            auto const face = mesh.getFace(faceIndex);
+            for (int vertexIndex = 0; vertexIndex < 3; ++vertexIndex)
+            {
+                auto const& vertex = face.vertices[vertexIndex];
+                auto const [it, inserted] = indexMap.emplace(vertex, static_cast<std::uint32_t>(surfaceVertices.size()));
+                if (inserted)
+                {
+                    surfaceVertices.push_back(vertex);
+                }
+            }
+        }
+
+        return surfaceVertices;
+    }
+
+    std::vector<std::vector<float>> OpenVdbShellGenerator::buildCumulativeLuts(
+        FilamentStack const& stack,
+        ThicknessConstraints const& constraints,
+        int lutResolution) const
+    {
+        std::vector<std::vector<float>> luts;
+        luts.reserve(stack.size());
+
+        for (std::size_t layerIndex = 0; layerIndex < stack.size(); ++layerIndex)
+        {
+            luts.push_back(ShellGenerator::buildCumulativeThicknessLut(
+                stack,
+                constraints,
+                layerIndex,
+                lutResolution));
+        }
+
+        return luts;
+    }
+
+    std::vector<ShellGenerator::ShellMesh> OpenVdbShellGenerator::generateSurfaceDrivenShells(
+        FilamentStack const& stack,
+        ManifoldDualContouringOptions const& options,
+        int lutResolution,
+        ThicknessConstraints const& thicknessConstraints,
+        std::function<bool()> cancellationCheck)
+    {
+        std::vector<ShellGenerator::ShellMesh> shells;
+
+        if (stack.empty() || lutResolution <= 1)
+        {
+            return shells;
+        }
+
+        if (!m_core.updateBBox())
+        {
+            return shells;
+        }
+
+        auto const bbox = m_core.getBoundingBox();
+        if (!bbox.has_value())
+        {
+            return shells;
+        }
+
+        std::size_t const sdfResolution = selectSdfResolution(options);
+        m_core.setPreCompSdfSize(sdfResolution);
+        m_core.precomputeSdfForBBox(*bbox);
+
+        auto resources = m_core.getResourceContext();
+        if (!resources)
+        {
+            return shells;
+        }
+
+        PreCompSdfReleaseGuard const sdfGuard{resources};
+        auto& sdfBuffer = resources->getPrecompSdfBuffer();
+        auto const cumulativeLuts = buildCumulativeLuts(stack, thicknessConstraints, lutResolution);
+        if (cumulativeLuts.empty())
+        {
+            return shells;
+        }
+
+        float const maxDepth = static_cast<float>(stack.size()) * std::max(thicknessConstraints.maxThickness, 0.1F);
+        float const voxelX = sdfResolution > 1U
+            ? (bbox->max.x - bbox->min.x) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelY = sdfResolution > 1U
+            ? (bbox->max.y - bbox->min.y) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelZ = sdfResolution > 1U
+            ? (bbox->max.z - bbox->min.z) / static_cast<float>(sdfResolution - 1U)
+            : 1.0F;
+        float const voxelSize = std::max({voxelX, voxelY, voxelZ, 1e-4F});
+        float const narrowBandWidth = std::max(maxDepth + voxelSize * 2.0F, voxelSize * 4.0F);
+
+        auto const surfaceVertices = extractSurfaceVertices(sdfBuffer, *bbox, narrowBandWidth);
+        if (surfaceVertices.empty())
+        {
+            return shells;
+        }
+
+        std::vector<Eigen::Vector3f> surfaceColors;
+        if (!sampleSurfaceColors(surfaceVertices, surfaceColors))
+        {
+            return shells;
+        }
+
+        SurfaceThicknessFieldConfig fieldConfig;
+        fieldConfig.gridResolution = static_cast<int>(sdfResolution);
+        fieldConfig.maxPropagationDistance = static_cast<int>(sdfResolution);
+        fieldConfig.defaultThickness = 0.0F;
+
+        std::vector<SurfaceThicknessField> fields(stack.size());
+        for (std::size_t layerIndex = 0; layerIndex < stack.size(); ++layerIndex)
+        {
+            if (cancellationCheck && cancellationCheck())
+            {
+                return {};
+            }
+
+            fields[layerIndex].build(
+                surfaceVertices,
+                surfaceColors,
+                cumulativeLuts[layerIndex],
+                lutResolution,
+                *bbox,
+                fieldConfig);
+        }
+
+        for (int layerIndex = static_cast<int>(stack.size()) - 1; layerIndex >= 0; --layerIndex)
+        {
+            if (cancellationCheck && cancellationCheck())
+            {
+                shells.clear();
+                break;
+            }
+
+            SurfaceThicknessField const* outerFieldPtr =
+                (layerIndex == static_cast<int>(stack.size()) - 1)
+                ? nullptr
+                : &fields[static_cast<std::size_t>(layerIndex + 1)];
+
+            SurfaceThicknessField const* innerFieldPtr =
+                (layerIndex == 0) ? nullptr : &fields[static_cast<std::size_t>(layerIndex)];
+
+            auto shellGrid = createVariableShellGrid(
+                sdfBuffer,
+                *bbox,
+                outerFieldPtr,
+                innerFieldPtr,
+                narrowBandWidth);
+            if (!shellGrid)
+            {
+                continue;
+            }
+
+            auto mesh = vdb::gridToMesh(shellGrid, *m_core.getComputeContext());
+            if (mesh.getNumberOfFaces() == 0U)
+            {
+                continue;
+            }
+
+            shells.push_back(meshToShellMesh(
+                mesh,
+                stack[static_cast<std::size_t>(layerIndex)].name,
+                layerIndex));
+        }
+
+        return shells;
+    }
+
+    ShellGenerator::ShellMesh OpenVdbShellGenerator::meshToShellMesh(
+        Mesh& mesh,
+        std::string filamentName,
+        int layerIndex) const
+    {
+        ShellGenerator::ShellMesh shell;
+        shell.filamentName = std::move(filamentName);
+        shell.layerIndex = layerIndex;
+
+        std::size_t const faceCount = mesh.getNumberOfFaces();
+        shell.vertices.reserve(faceCount * 3U);
+        shell.indices.reserve(faceCount * 3U);
+
+        for (std::size_t faceIndex = 0; faceIndex < faceCount; ++faceIndex)
+        {
+            auto const face = mesh.getFace(faceIndex);
+            for (int vertexIndex = 0; vertexIndex < 3; ++vertexIndex)
+            {
+                shell.indices.push_back(static_cast<std::uint32_t>(shell.vertices.size()));
+                shell.vertices.push_back(face.vertices[vertexIndex]);
+            }
+        }
+
+        return shell;
+    }
+
+    std::size_t OpenVdbShellGenerator::selectSdfResolution(
+        ManifoldDualContouringOptions const& options) noexcept
+    {
+        std::size_t const requested = std::size_t{1} << std::min<std::size_t>(options.maxDepth + 1U, 8U);
+        return std::clamp<std::size_t>(requested, 64U, 256U);
+    }
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/OpenVdbShellGenerator.h b/gladius/src/io/3mf/OpenVdbShellGenerator.h
new file mode 100644
index 00000000..c3303cb4
--- /dev/null
+++ b/gladius/src/io/3mf/OpenVdbShellGenerator.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include "ShellGenerator.h"
+#include "ShellThicknessPartition.h"
+#include "SurfaceThicknessField.h"
+
+#include "../vdb.h"
+
+#include <functional>
+
+namespace gladius
+{
+    class ComputeCore;
+}
+
+namespace gladius::io
+{
+    /// @brief Generates constant-thickness shell bands using an OpenVDB level-set workflow.
+    ///
+    /// This is the first implementation slice of the OpenVDB backend. It supports a uniform
+    /// shell stack derived from a constant thickness solution and produces one watertight shell
+    /// mesh per material band. Surface-color propagation is intentionally left for a later step.
+    class OpenVdbShellGenerator
+    {
+      public:
+        explicit OpenVdbShellGenerator(ComputeCore& core);
+
+        [[nodiscard]] std::vector<ShellGenerator::ShellMesh> generateUniformShells(
+            FilamentStack const& stack,
+            ThicknessSolution const& solution,
+            ManifoldDualContouringOptions const& options,
+            std::function<bool()> cancellationCheck = {});
+
+        [[nodiscard]] std::vector<ShellGenerator::ShellMesh> generateSurfaceDrivenShells(
+            FilamentStack const& stack,
+            ManifoldDualContouringOptions const& options,
+            int lutResolution,
+            ThicknessConstraints const& thicknessConstraints,
+            std::function<bool()> cancellationCheck = {});
+
+        /// @brief Signed-distance for a shell band derived from a model SDF.
+        ///
+        /// The original model SDF is negative inside the solid. A shell occupies the inward depth
+        /// interval [outerDepth, innerDepth]. The returned signed distance is negative inside the
+        /// shell band and positive outside.
+        [[nodiscard]] static float evaluateShellSignedDistance(
+            float modelSdf,
+            ShellLayerDepthInterval const& interval) noexcept;
+
+        [[nodiscard]] static float evaluateVariableShellSignedDistance(
+            float modelSdf,
+            float outerDepth,
+            float innerDepth,
+            bool isInnermostLayer) noexcept;
+
+      private:
+        [[nodiscard]] openvdb::FloatGrid::Ptr createShellGrid(
+            PreComputedSdf& sdf,
+            BoundingBox const& bbox,
+            ShellLayerDepthInterval const& interval,
+            float narrowBandWidth) const;
+
+        [[nodiscard]] openvdb::FloatGrid::Ptr createVariableShellGrid(
+            PreComputedSdf& sdf,
+            BoundingBox const& bbox,
+            SurfaceThicknessField const* outerField,
+            SurfaceThicknessField const* innerField,
+            float narrowBandWidth) const;
+
+        [[nodiscard]] bool sampleSurfaceColors(
+            std::vector<Eigen::Vector3f> const& surfaceVertices,
+            std::vector<Eigen::Vector3f>& surfaceColors) const;
+
+        [[nodiscard]] std::vector<Eigen::Vector3f> extractSurfaceVertices(
+            PreComputedSdf& sdf,
+            BoundingBox const& bbox,
+            float narrowBandWidth) const;
+
+        [[nodiscard]] std::vector<std::vector<float>> buildCumulativeLuts(
+            FilamentStack const& stack,
+            ThicknessConstraints const& constraints,
+            int lutResolution) const;
+
+        [[nodiscard]] ShellGenerator::ShellMesh meshToShellMesh(
+            Mesh& mesh,
+            std::string filamentName,
+            int layerIndex) const;
+
+        [[nodiscard]] static std::size_t selectSdfResolution(
+            ManifoldDualContouringOptions const& options) noexcept;
+
+        ComputeCore& m_core;
+    };
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/PaletteExtractor.cpp b/gladius/src/io/3mf/PaletteExtractor.cpp
index 4a8d5d8f..4b9ed43d 100644
--- a/gladius/src/io/3mf/PaletteExtractor.cpp
+++ b/gladius/src/io/3mf/PaletteExtractor.cpp
@@ -2,6 +2,7 @@
 
 #include "io/3mf/FaceColorSampler.h"
 #include "io/3mf/FaceColors.h"
+#include "io/MeshExporter.h"
 
 #include "compute/ManifoldDualContouringGpu.h"
 #include "compute/ProgramManager.h"
@@ -16,6 +17,188 @@
 
 namespace gladius::io
 {
+    namespace
+    {
+        using Triangle = std::array<std::uint32_t, 3>;
+
+        struct PaletteMesh
+        {
+            std::vector<Eigen::Vector3f> vertices;
+            std::vector<Triangle> faces;
+        };
+
+        [[nodiscard]] double alignToLayer(double value, double increment)
+        {
+            return std::floor(value / increment) * increment;
+        }
+
+        [[nodiscard]] PaletteMesh toPaletteMesh(Mesh & mesh)
+        {
+            PaletteMesh result;
+            std::size_t const faceCount = mesh.getNumberOfFaces();
+            result.vertices.reserve(faceCount * 3U);
+            result.faces.reserve(faceCount);
+
+            for (std::size_t faceIndex = 0; faceIndex < faceCount; ++faceIndex)
+            {
+                auto const face = mesh.getFace(faceIndex);
+                std::uint32_t const baseIndex = static_cast<std::uint32_t>(result.vertices.size());
+                result.faces.push_back({baseIndex, baseIndex + 1U, baseIndex + 2U});
+                for (int vertexIndex = 0; vertexIndex < 3; ++vertexIndex)
+                {
+                    auto const & vertex = face.vertices[vertexIndex];
+                    result.vertices.emplace_back(vertex.x(), vertex.y(), vertex.z());
+                }
+            }
+
+            return result;
+        }
+
+        [[nodiscard]] PaletteMesh buildManifoldPaletteMesh(
+            gladius::ComputeCore & core,
+            PaletteExtractionOptions const & options)
+        {
+            compute::ManifoldDualContouringConfig config{};
+            auto const & opt = options.manifoldOptions;
+            config.initialDepth = opt.initialDepth;
+            config.maxDepth = opt.maxDepth;
+            config.enableGpu = opt.enableGpu;
+            config.enableCpuFallback = opt.enableCpuFallback;
+            config.enableCaching = opt.enableCaching;
+            config.isoValue = opt.isoValue;
+            config.minFeatureSize = opt.minFeatureSize;
+            config.enableChunking = opt.enableChunking;
+            config.enableHierarchicalOctree = opt.enableHierarchicalOctree;
+            config.enableSharpFeaturePostProcess = opt.enableSharpFeaturePostProcess;
+            config.sharpFeatureAngleThreshold = opt.sharpFeatureAngleThreshold;
+            config.subdivisionIterations = opt.subdivisionIterations;
+            config.projectToSurface = opt.projectToSurface;
+            config.simplificationMethod = (opt.simplificationMethod == SimplificationMethod::QemSdfAware)
+                                            ? compute::SimplificationMethod::QemSdfAware
+                                            : compute::SimplificationMethod::None;
+            config.enableSimplification = opt.enableSimplification;
+            config.simplificationMaxSdfError = opt.simplificationMaxSdfError;
+            config.simplificationMaxQemError = opt.simplificationMaxQemError;
+            config.simplificationMaxNormalDeviation = opt.simplificationMaxNormalDeviation;
+            config.simplificationSdfWeight = opt.simplificationSdfWeight;
+            config.simplificationQemWeight = opt.simplificationQemWeight;
+            config.simplificationNormalWeight = opt.simplificationNormalWeight;
+            config.simplificationSharpEdgeThreshold = opt.simplificationSharpEdgeThreshold;
+            config.simplificationBatchSize = opt.simplificationBatchSize;
+            config.simplificationMaxPasses = opt.simplificationMaxPasses;
+            config.simplificationTargetTriangles = opt.simplificationTargetTriangles;
+            config.simplificationTargetReduction = opt.simplificationTargetReduction;
+
+            compute::ManifoldDualContouringGpu pipeline(core);
+            pipeline.setConfig(config);
+            pipeline.generateMesh();
+            auto const & mesh = pipeline.getMesh();
+            if (mesh.indices.empty() || mesh.positions.empty())
+            {
+                throw std::runtime_error("Mesh extraction produced no geometry");
+            }
+
+            PaletteMesh result;
+            result.vertices = mesh.positions;
+            result.faces.reserve(mesh.indices.size() / 3U);
+            for (std::size_t i = 0; i + 2 < mesh.indices.size(); i += 3)
+            {
+                result.faces.push_back({mesh.indices[i + 0], mesh.indices[i + 1], mesh.indices[i + 2]});
+            }
+            return result;
+        }
+
+        [[nodiscard]] PaletteMesh buildLayeredMarchingCubesPaletteMesh(
+            gladius::ComputeCore & core,
+            std::size_t qualityLevel)
+        {
+            core.updateClippingAreaWithPadding();
+
+            auto resources = core.getResourceContext();
+            if (!resources)
+            {
+                throw std::runtime_error("No resource context available for OpenVDB palette derivation");
+            }
+
+            resources->requestDistanceMaps();
+            auto & distanceMipMaps = resources->getDistanceMipMaps();
+            if (distanceMipMaps.empty())
+            {
+                throw std::runtime_error("No distance maps available for OpenVDB palette derivation");
+            }
+
+            if (qualityLevel >= distanceMipMaps.size())
+            {
+                qualityLevel = distanceMipMaps.size() - 1U;
+            }
+
+            auto const clippingArea = resources->getClippingArea();
+            auto const resX = distanceMipMaps[qualityLevel]->getWidth();
+            auto const widthMm = clippingArea.z - clippingArea.x;
+            auto const voxelSize = widthMm / static_cast<float>(resX);
+            auto const layerIncrementMm = static_cast<double>(voxelSize);
+            auto const bandWidthMm = voxelSize * 2.0F;
+
+            auto const bbox = core.getBoundingBox();
+            if (!bbox.has_value())
+            {
+                throw std::runtime_error("Bounding box missing for OpenVDB palette derivation");
+            }
+
+            double startHeightMm = alignToLayer(bbox->min.z - layerIncrementMm, layerIncrementMm);
+            double currentHeightMm = startHeightMm;
+            core.setSliceHeight(currentHeightMm);
+
+            auto grid = openvdb::FloatGrid::create(bandWidthMm);
+            grid->setGridClass(openvdb::GRID_LEVEL_SET);
+            grid->setName("Palette extraction grid");
+
+            auto transformation = openvdb::math::Transform::createLinearTransform();
+            transformation->preScale(static_cast<double>(voxelSize));
+            transformation->postTranslate(openvdb::Vec3d{
+                static_cast<double>(clippingArea.x),
+                static_cast<double>(clippingArea.y),
+                0.0});
+            grid->setTransform(transformation);
+
+            while (core.getSliceHeight() < bbox->max.z + layerIncrementMm)
+            {
+                core.generateSdfSlice();
+
+                auto & distMap = *distanceMipMaps[qualityLevel];
+                distMap.read();
+
+                auto accessor = grid->getAccessor();
+                int const z = static_cast<int>(std::floor(currentHeightMm / layerIncrementMm));
+
+                for (int y = 0; y < static_cast<int>(distMap.getHeight()); ++y)
+                {
+                    for (int x = 0; x < static_cast<int>(distMap.getWidth()); ++x)
+                    {
+                        openvdb::Coord xyz{x, y, z};
+                        float const value = std::clamp<float>(
+                            distMap.getValue(x, y).x,
+                            -bandWidthMm,
+                            bandWidthMm);
+                        accessor.setValue(xyz, value);
+                    }
+                }
+
+                grid->pruneGrid();
+                currentHeightMm = alignToLayer(currentHeightMm + layerIncrementMm, layerIncrementMm);
+                core.setSliceHeight(currentHeightMm);
+            }
+
+            auto mesh = vdb::gridToMesh(grid, *core.getComputeContext());
+            if (mesh.getNumberOfFaces() == 0U)
+            {
+                throw std::runtime_error("OpenVDB mesh extraction produced no geometry");
+            }
+
+            return toPaletteMesh(mesh);
+        }
+    }
+
     std::vector<Eigen::Vector3f> derivePaletteFromMesh(gladius::ComputeCore & core,
                                                        PaletteExtractionOptions const & options)
     {
@@ -30,52 +213,24 @@ namespace gladius::io
             throw std::runtime_error("Mesh generation failed, bounding box is empty");
         }
 
-        // Build GPU config from manifold options
-        compute::ManifoldDualContouringConfig config{};
-        auto const & opt = options.manifoldOptions;
-        config.initialDepth = opt.initialDepth;
-        config.maxDepth = opt.maxDepth;
-        config.enableGpu = opt.enableGpu;
-        config.enableCpuFallback = opt.enableCpuFallback;
-        config.enableCaching = opt.enableCaching;
-        config.isoValue = opt.isoValue;
-        config.minFeatureSize = opt.minFeatureSize;
-        config.enableChunking = opt.enableChunking;
-        config.enableHierarchicalOctree = opt.enableHierarchicalOctree;
-        config.enableSharpFeaturePostProcess = opt.enableSharpFeaturePostProcess;
-        config.sharpFeatureAngleThreshold = opt.sharpFeatureAngleThreshold;
-        config.subdivisionIterations = opt.subdivisionIterations;
-        config.projectToSurface = opt.projectToSurface;
-        config.simplificationMethod = (opt.simplificationMethod == SimplificationMethod::QemSdfAware)
-                                        ? compute::SimplificationMethod::QemSdfAware
-                                        : compute::SimplificationMethod::None;
-        config.enableSimplification = opt.enableSimplification;
-        config.simplificationMaxSdfError = opt.simplificationMaxSdfError;
-        config.simplificationMaxQemError = opt.simplificationMaxQemError;
-        config.simplificationMaxNormalDeviation = opt.simplificationMaxNormalDeviation;
-        config.simplificationSdfWeight = opt.simplificationSdfWeight;
-        config.simplificationQemWeight = opt.simplificationQemWeight;
-        config.simplificationNormalWeight = opt.simplificationNormalWeight;
-        config.simplificationSharpEdgeThreshold = opt.simplificationSharpEdgeThreshold;
-        config.simplificationBatchSize = opt.simplificationBatchSize;
-        config.simplificationMaxPasses = opt.simplificationMaxPasses;
-        config.simplificationTargetTriangles = opt.simplificationTargetTriangles;
-        config.simplificationTargetReduction = opt.simplificationTargetReduction;
-
-        compute::ManifoldDualContouringGpu pipeline(core);
-        pipeline.setConfig(config);
-        pipeline.generateMesh();
-        auto const & mesh = pipeline.getMesh();
-        if (mesh.indices.empty() || mesh.positions.empty())
+        PaletteMesh paletteMesh;
+        switch (options.method)
         {
-            throw std::runtime_error("Mesh extraction produced no geometry");
+        case SurfaceExtractionMethod::LayeredMarchingCubes:
+            paletteMesh = buildLayeredMarchingCubesPaletteMesh(core, options.marchingCubesQualityLevel);
+            break;
+        case SurfaceExtractionMethod::ManifoldDualContouring:
+            paletteMesh = buildManifoldPaletteMesh(core, options);
+            break;
+        case SurfaceExtractionMethod::DualContouring:
+            throw std::runtime_error("Palette derivation is not implemented for dual contouring.");
+        default:
+            throw std::runtime_error("Unsupported extraction method for palette derivation.");
         }
 
-        std::vector<std::array<std::uint32_t, 3>> faces;
-        faces.reserve(mesh.indices.size() / 3);
-        for (std::size_t i = 0; i + 2 < mesh.indices.size(); i += 3)
+        if (paletteMesh.faces.empty() || paletteMesh.vertices.empty())
         {
-            faces.push_back({mesh.indices[i + 0], mesh.indices[i + 1], mesh.indices[i + 2]});
+            throw std::runtime_error("Mesh extraction produced no geometry");
         }
 
         auto * samplingProgram = core.getProgramManager().getDualContouringSamplingProgram();
@@ -90,7 +245,12 @@ namespace gladius::io
         }
 
         auto vertexColors = FaceColorSampler::sampleVertexColors(
-          mesh.positions, faces, *samplingProgram, *primitives, nullptr, options.convertToSrgb);
+                    paletteMesh.vertices,
+                    paletteMesh.faces,
+                    *samplingProgram,
+                    *primitives,
+                    nullptr,
+                    options.convertToSrgb);
 
         std::set<std::tuple<std::uint8_t, std::uint8_t, std::uint8_t>> unique;
         for (auto const & face : vertexColors.faceVertexColors)
diff --git a/gladius/src/io/3mf/PaletteExtractor.h b/gladius/src/io/3mf/PaletteExtractor.h
index c51ce636..a47eb6f6 100644
--- a/gladius/src/io/3mf/PaletteExtractor.h
+++ b/gladius/src/io/3mf/PaletteExtractor.h
@@ -15,12 +15,14 @@ namespace gladius::io
 {
     struct PaletteExtractionOptions
     {
+        SurfaceExtractionMethod method{SurfaceExtractionMethod::ManifoldDualContouring};
+        std::size_t marchingCubesQualityLevel{1U};
         ManifoldDualContouringOptions manifoldOptions{};
         bool convertToSrgb{true};
     };
 
-    /// Derive a palette from per-vertex colors of a mesh generated with manifold dual contouring
-    /// using the provided compute core and options. Throws on failure.
+    /// Derive a palette from per-vertex colors of a mesh generated with the selected
+    /// surface extraction method using the provided compute core and options. Throws on failure.
     std::vector<Eigen::Vector3f> derivePaletteFromMesh(gladius::ComputeCore & core,
                                                        PaletteExtractionOptions const & options);
 }
diff --git a/gladius/src/io/3mf/ResourceDependencyGraph.cpp b/gladius/src/io/3mf/ResourceDependencyGraph.cpp
index 305b7228..e9470153 100644
--- a/gladius/src/io/3mf/ResourceDependencyGraph.cpp
+++ b/gladius/src/io/3mf/ResourceDependencyGraph.cpp
@@ -87,6 +87,15 @@ namespace gladius::io
                     continue;
                 }
 
+                                // BooleanObject
+                                Lib3MF::PBooleanObject booleanObject =
+                                    std::dynamic_pointer_cast<Lib3MF::CBooleanObject>(resource);
+                                if (booleanObject)
+                                {
+                                        processBooleanObject(booleanObject);
+                                        continue;
+                                }
+
                 // MeshObject
                 Lib3MF::PMeshObject meshObject =
                   std::dynamic_pointer_cast<Lib3MF::CMeshObject>(resource);
@@ -511,6 +520,61 @@ namespace gladius::io
         }
     }
 
+    void ResourceDependencyGraph::processBooleanObject(Lib3MF::PBooleanObject booleanObject)
+    {
+        if (!booleanObject)
+        {
+            return;
+        }
+
+        Lib3MF_uint32 const booleanObjectId = booleanObject->GetResourceID();
+
+        try
+        {
+            Lib3MF::PObject baseObject = booleanObject->GetBaseObject();
+            if (baseObject)
+            {
+                m_graph->addDependency(booleanObjectId, baseObject->GetResourceID());
+            }
+        }
+        catch (const std::exception & e)
+        {
+            if (m_logger)
+            {
+                m_logger->addEvent(
+                  {fmt::format("Error processing BooleanObject base dependency {}: {}",
+                               booleanObjectId,
+                               e.what()),
+                   gladius::events::Severity::Error});
+            }
+        }
+
+        try
+        {
+            auto const operandCount = booleanObject->GetOperandCount();
+            for (Lib3MF_uint32 operandIndex = 0; operandIndex < operandCount; ++operandIndex)
+            {
+                Lib3MF::PMeshObject operandObject;
+                (void) booleanObject->GetOperand(operandIndex, operandObject);
+                if (operandObject)
+                {
+                    m_graph->addDependency(booleanObjectId, operandObject->GetResourceID());
+                }
+            }
+        }
+        catch (const std::exception & e)
+        {
+            if (m_logger)
+            {
+                m_logger->addEvent(
+                  {fmt::format("Error processing BooleanObject operand dependency {}: {}",
+                               booleanObjectId,
+                               e.what()),
+                   gladius::events::Severity::Error});
+            }
+        }
+    }
+
     void ResourceDependencyGraph::processMeshObject(Lib3MF::PMeshObject meshObject)
     {
         if (!meshObject)
diff --git a/gladius/src/io/3mf/ResourceDependencyGraph.h b/gladius/src/io/3mf/ResourceDependencyGraph.h
index b2d6c02d..2dc211da 100644
--- a/gladius/src/io/3mf/ResourceDependencyGraph.h
+++ b/gladius/src/io/3mf/ResourceDependencyGraph.h
@@ -132,6 +132,12 @@ namespace gladius::io
          */
         void processComponentsObject(Lib3MF::PComponentsObject componentsObject);
 
+        /**
+         * @brief Process a BooleanObject resource and add its dependencies to the graph
+         * @param booleanObject Pointer to the BooleanObject resource
+         */
+        void processBooleanObject(Lib3MF::PBooleanObject booleanObject);
+
         /**
          * @brief Process a MeshObject resource and add its dependencies to the graph
          * @param meshObject Pointer to the MeshObject resource
diff --git a/gladius/src/io/3mf/SaveSnapshot.h b/gladius/src/io/3mf/SaveSnapshot.h
new file mode 100644
index 00000000..18352674
--- /dev/null
+++ b/gladius/src/io/3mf/SaveSnapshot.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "nodes/Assembly.h"
+
+#include <lib3mf_implicit.hpp>
+
+#include <cstdint>
+#include <memory>
+
+namespace gladius::io
+{
+
+    /**
+     * @brief Identifies the logical contents represented by a document.
+     */
+    using DocumentIdentity = std::uint64_t;
+
+    /**
+     * @brief Immutable document data captured for an asynchronous native 3MF save.
+     *
+     * The assembly and Lib3MF model are independent copies. Code operating on a snapshot must
+     * never access the live Document or its ComputeCore.
+     */
+    struct SaveSnapshot
+    {
+        std::shared_ptr<const nodes::Assembly> assembly;
+        Lib3MF::PModel model;
+        DocumentIdentity documentIdentity{0};
+        uint64_t version{0};
+    };
+
+} // namespace gladius::io
\ No newline at end of file
diff --git a/gladius/src/io/3mf/ShellMaterialOrdering.cpp b/gladius/src/io/3mf/ShellMaterialOrdering.cpp
new file mode 100644
index 00000000..5045caa2
--- /dev/null
+++ b/gladius/src/io/3mf/ShellMaterialOrdering.cpp
@@ -0,0 +1,221 @@
+#include "ShellMaterialOrdering.h"
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <numeric>
+
+namespace gladius::io
+{
+    float ShellMaterialOrdering::translucencyScore(FilamentOpticalProperties const& filament) noexcept
+    {
+        float sum = 0.0F;
+        int count = 0;
+        for (int channel = 0; channel < 3; ++channel)
+        {
+            float const td = filament.transmissionDistance[channel];
+            if (td > 0.0F)
+            {
+                sum += td;
+                ++count;
+            }
+        }
+
+        if (count > 0)
+        {
+            return sum / static_cast<float>(count);
+        }
+
+        if (filament.opacity <= 0.0F)
+        {
+            return std::numeric_limits<float>::infinity();
+        }
+
+        if (filament.opacity >= 1.0F)
+        {
+            return 0.0F;
+        }
+
+        float const safeReferenceThickness = std::max(filament.referenceThickness, 1e-6F);
+        float const oneMinusOpacity = std::max(1.0F - filament.opacity, 1e-6F);
+        float const alpha = -std::log(oneMinusOpacity) / safeReferenceThickness;
+        if (alpha <= 0.0F)
+        {
+            return std::numeric_limits<float>::infinity();
+        }
+
+        return 1.0F / alpha;
+    }
+
+    OrderedShellMaterials ShellMaterialOrdering::reorderForShells(
+        FilamentStack const& stack,
+        std::size_t backgroundIndex,
+        IlluminationMode mode)
+    {
+        OrderedShellMaterials ordered;
+        std::size_t const count = stack.size();
+        ordered.originalToOrdered.resize(count, 0U);
+
+        if (count == 0U)
+        {
+            return ordered;
+        }
+
+        std::vector<std::size_t> indices(count);
+        std::iota(indices.begin(), indices.end(), 0U);
+
+        bool const hasBackground = backgroundIndex < count;
+        if (hasBackground)
+        {
+            std::swap(indices.front(), indices[backgroundIndex]);
+        }
+
+        auto reorderBegin = indices.begin() + (hasBackground ? 1 : 0);
+        if (mode == IlluminationMode::Frontlit)
+        {
+            std::stable_sort(reorderBegin, indices.end(), [&stack](std::size_t lhs, std::size_t rhs) {
+                return translucencyScore(stack[lhs]) < translucencyScore(stack[rhs]);
+            });
+        }
+
+        ordered.stack.filaments.reserve(count);
+        ordered.orderedToOriginal.reserve(count);
+        for (std::size_t orderedIndex = 0; orderedIndex < count; ++orderedIndex)
+        {
+            std::size_t const originalIndex = indices[orderedIndex];
+            ordered.stack.push_back(stack[originalIndex]);
+            ordered.orderedToOriginal.push_back(originalIndex);
+            ordered.originalToOrdered[originalIndex] = orderedIndex;
+        }
+
+        if (hasBackground)
+        {
+            ordered.backgroundIndex = 0U;
+        }
+
+        return ordered;
+    }
+
+    OrderedShellMaterials ShellMaterialOrdering::optimizeGlobalOrderForShells(
+        FilamentStack const& stack,
+        std::size_t backgroundIndex,
+        IlluminationMode mode,
+        std::function<float(FilamentStack const&, std::size_t)> const& scorer,
+        std::size_t exhaustiveSearchLimit)
+    {
+        OrderedShellMaterials const heuristic = reorderForShells(stack, backgroundIndex, mode);
+
+        if (!scorer || stack.size() <= 1U || mode != IlluminationMode::Frontlit)
+        {
+            return heuristic;
+        }
+
+        std::size_t const count = stack.size();
+        bool const hasBackground = backgroundIndex < count;
+        std::size_t const permutableCount = count - (hasBackground ? 1U : 0U);
+
+        if (permutableCount <= 1U || count > exhaustiveSearchLimit)
+        {
+            return heuristic;
+        }
+
+        std::vector<std::size_t> indices(count);
+        std::iota(indices.begin(), indices.end(), 0U);
+
+        std::vector<std::size_t> fixedPrefix;
+        std::vector<std::size_t> permutableIndices;
+        fixedPrefix.reserve(hasBackground ? 1U : 0U);
+        permutableIndices.reserve(permutableCount);
+
+        for (std::size_t index : indices)
+        {
+            if (hasBackground && index == backgroundIndex)
+            {
+                fixedPrefix.push_back(index);
+            }
+            else
+            {
+                permutableIndices.push_back(index);
+            }
+        }
+
+        std::sort(permutableIndices.begin(), permutableIndices.end());
+
+        auto makeOrdered = [&](std::vector<std::size_t> const& orderedIndices) {
+            OrderedShellMaterials ordered;
+            ordered.originalToOrdered.resize(count, 0U);
+            ordered.stack.filaments.reserve(count);
+            ordered.orderedToOriginal.reserve(count);
+
+            for (std::size_t orderedIndex = 0; orderedIndex < orderedIndices.size(); ++orderedIndex)
+            {
+                std::size_t const originalIndex = orderedIndices[orderedIndex];
+                ordered.stack.push_back(stack[originalIndex]);
+                ordered.orderedToOriginal.push_back(originalIndex);
+                ordered.originalToOrdered[originalIndex] = orderedIndex;
+            }
+
+            if (hasBackground)
+            {
+                ordered.backgroundIndex = 0U;
+            }
+
+            return ordered;
+        };
+
+        float bestScore = scorer(heuristic.stack, heuristic.backgroundIndex);
+        OrderedShellMaterials bestOrdered = heuristic;
+
+        do
+        {
+            std::vector<std::size_t> orderedIndices = fixedPrefix;
+            orderedIndices.insert(orderedIndices.end(), permutableIndices.begin(), permutableIndices.end());
+
+            OrderedShellMaterials candidate = makeOrdered(orderedIndices);
+            float const score = scorer(candidate.stack, candidate.backgroundIndex);
+            if (score < bestScore)
+            {
+                bestScore = score;
+                bestOrdered = std::move(candidate);
+            }
+        }
+        while (std::next_permutation(permutableIndices.begin(), permutableIndices.end()));
+
+        return bestOrdered;
+    }
+
+    OrderedShellMaterials ShellMaterialOrdering::optimizeGlobalOrderForPalette(
+        FilamentStack const& stack,
+        std::size_t backgroundIndex,
+        IlluminationMode mode,
+        ThicknessConstraints const& constraints,
+        std::vector<Eigen::Vector3f> const& targetColors,
+        std::size_t exhaustiveSearchLimit)
+    {
+        if (targetColors.empty())
+        {
+            return reorderForShells(stack, backgroundIndex, mode);
+        }
+
+        auto paletteScorer = [&constraints, &targetColors, mode](FilamentStack const& candidateStack,
+                                                                 std::size_t candidateBackgroundIndex) {
+            FrontlitThicknessSolver solver{candidateStack, constraints, mode, candidateBackgroundIndex};
+
+            float totalError = 0.0F;
+            for (Eigen::Vector3f const& target : targetColors)
+            {
+                ThicknessSolution const solution = solver.solve(target);
+                totalError += solution.colorError;
+            }
+
+            return totalError / static_cast<float>(targetColors.size());
+        };
+
+        return optimizeGlobalOrderForShells(
+            stack,
+            backgroundIndex,
+            mode,
+            paletteScorer,
+            exhaustiveSearchLimit);
+    }
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/ShellMaterialOrdering.h b/gladius/src/io/3mf/ShellMaterialOrdering.h
new file mode 100644
index 00000000..0ea73b15
--- /dev/null
+++ b/gladius/src/io/3mf/ShellMaterialOrdering.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "FilamentOpticalProperties.h"
+#include "FrontlitThicknessSolver.h"
+
+#include <functional>
+#include <limits>
+#include <vector>
+
+namespace gladius::io
+{
+    struct OrderedShellMaterials
+    {
+        FilamentStack stack;
+        std::vector<std::size_t> orderedToOriginal;
+        std::vector<std::size_t> originalToOrdered;
+        std::size_t backgroundIndex{std::numeric_limits<std::size_t>::max()};
+    };
+
+    class ShellMaterialOrdering
+    {
+      public:
+        [[nodiscard]] static OrderedShellMaterials reorderForShells(
+            FilamentStack const& stack,
+            std::size_t backgroundIndex,
+            IlluminationMode mode);
+
+        [[nodiscard]] static OrderedShellMaterials optimizeGlobalOrderForShells(
+            FilamentStack const& stack,
+            std::size_t backgroundIndex,
+            IlluminationMode mode,
+            std::function<float(FilamentStack const&, std::size_t)> const& scorer,
+            std::size_t exhaustiveSearchLimit = 6U);
+
+        /// Optimize global shell order for a target palette by solving each target color
+        /// against every candidate permutation and selecting the order with the lowest
+        /// mean achieved color error. Falls back to the translucency heuristic for large
+        /// stacks or non-frontlit modes. Only the printable (non-background) layers are
+        /// permuted; the background material stays pinned in its semantic role.
+        [[nodiscard]] static OrderedShellMaterials optimizeGlobalOrderForPalette(
+            FilamentStack const& stack,
+            std::size_t backgroundIndex,
+            IlluminationMode mode,
+            ThicknessConstraints const& constraints,
+            std::vector<Eigen::Vector3f> const& targetColors,
+            std::size_t exhaustiveSearchLimit = 6U);
+
+        [[nodiscard]] static float translucencyScore(FilamentOpticalProperties const& filament) noexcept;
+    };
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/ShellThicknessPartition.cpp b/gladius/src/io/3mf/ShellThicknessPartition.cpp
new file mode 100644
index 00000000..53f3060c
--- /dev/null
+++ b/gladius/src/io/3mf/ShellThicknessPartition.cpp
@@ -0,0 +1,75 @@
+#include "ShellThicknessPartition.h"
+
+#include <cmath>
+#include <stdexcept>
+
+namespace gladius::io
+{
+    std::vector<ShellLayerDepthInterval>
+    ShellThicknessPartition::buildIntervals(ThicknessSolution const& solution)
+    {
+        return buildIntervals(solution.thicknesses);
+    }
+
+    std::vector<ShellLayerDepthInterval>
+    ShellThicknessPartition::buildIntervals(std::vector<float> const& thicknesses)
+    {
+        validateThicknesses(thicknesses);
+
+        std::vector<ShellLayerDepthInterval> intervals;
+        intervals.reserve(thicknesses.size());
+
+        float cumulativeDepth = 0.0F;
+        for (std::size_t reverseIndex = thicknesses.size(); reverseIndex > 0; --reverseIndex)
+        {
+            std::size_t const layerIndex = reverseIndex - 1;
+            float const thickness = thicknesses[layerIndex];
+            if (thickness <= 0.0F)
+            {
+                continue;
+            }
+
+            ShellLayerDepthInterval interval;
+            interval.layerIndex = layerIndex;
+            interval.outerDepth = cumulativeDepth;
+            interval.innerDepth = cumulativeDepth + thickness;
+            intervals.push_back(interval);
+
+            cumulativeDepth = interval.innerDepth;
+        }
+
+        return intervals;
+    }
+
+    float ShellThicknessPartition::computeMaxDepth(std::vector<float> const& thicknesses)
+    {
+        validateThicknesses(thicknesses);
+
+        float totalDepth = 0.0F;
+        for (float const thickness : thicknesses)
+        {
+            if (thickness > 0.0F)
+            {
+                totalDepth += thickness;
+            }
+        }
+
+        return totalDepth;
+    }
+
+    void ShellThicknessPartition::validateThicknesses(std::vector<float> const& thicknesses)
+    {
+        for (float const thickness : thicknesses)
+        {
+            if (!std::isfinite(thickness))
+            {
+                throw std::runtime_error("Shell thickness must be finite");
+            }
+
+            if (thickness < 0.0F)
+            {
+                throw std::runtime_error("Shell thickness must not be negative");
+            }
+        }
+    }
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/ShellThicknessPartition.h b/gladius/src/io/3mf/ShellThicknessPartition.h
new file mode 100644
index 00000000..149434f4
--- /dev/null
+++ b/gladius/src/io/3mf/ShellThicknessPartition.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "FilamentOpticalProperties.h"
+
+#include <cstddef>
+#include <vector>
+
+namespace gladius::io
+{
+    /// @brief Shell generation backend for shell-based color export.
+    enum class ShellGenerationMode
+    {
+        LegacyManifoldDualContouring,
+        OpenVdbColorThickness
+    };
+
+    /// @brief Depth interval for a single material shell measured inward from the visible surface.
+    struct ShellLayerDepthInterval
+    {
+        std::size_t layerIndex = 0;
+        float outerDepth = 0.0F;
+        float innerDepth = 0.0F;
+
+        [[nodiscard]] float thickness() const noexcept
+        {
+            return innerDepth - outerDepth;
+        }
+
+        [[nodiscard]] bool isEmpty(float epsilon = 1e-6F) const noexcept
+        {
+            return thickness() <= epsilon;
+        }
+    };
+
+    /// @brief Helper for converting per-layer thicknesses into touching shell depth bands.
+    ///
+    /// Thicknesses are expected in filament stack order (bottom to top). The returned
+    /// intervals are ordered from the visible outermost shell inward.
+    class ShellThicknessPartition
+    {
+      public:
+        /// @brief Build shell intervals from a thickness solution.
+        [[nodiscard]] static std::vector<ShellLayerDepthInterval>
+        buildIntervals(ThicknessSolution const& solution);
+
+        /// @brief Build shell intervals from per-layer thicknesses in bottom-to-top order.
+        [[nodiscard]] static std::vector<ShellLayerDepthInterval>
+        buildIntervals(std::vector<float> const& thicknesses);
+
+        /// @brief Compute the total occupied shell depth.
+        [[nodiscard]] static float computeMaxDepth(std::vector<float> const& thicknesses);
+
+      private:
+        static void validateThicknesses(std::vector<float> const& thicknesses);
+    };
+} // namespace gladius::io
diff --git a/gladius/src/io/3mf/Writer3mf.cpp b/gladius/src/io/3mf/Writer3mf.cpp
index bd091674..32a72bd6 100644
--- a/gladius/src/io/3mf/Writer3mf.cpp
+++ b/gladius/src/io/3mf/Writer3mf.cpp
@@ -648,18 +648,42 @@ namespace gladius::io
         }
     }
 
-    void Writer3mf::updateModel(Document const & doc)
+    bool Writer3mf::save(std::filesystem::path const & filename,
+                         SaveSnapshot const & snapshot,
+                         bool /*writeThumbnail*/)
     {
-        m_logger->logInfo("Starting updateModel operation");
-        auto model3mf = doc.get3mfModel();
+        if (!snapshot.model || !snapshot.assembly)
+        {
+            m_logger->addEvent({"Cannot save an incomplete 3MF snapshot.",
+                                events::Severity::Error});
+            return false;
+        }
 
-        if (!model3mf)
+        try
         {
-            m_logger->addEvent({"No 3MF model to update.", events::Severity::Error});
-            return;
+            addDefaultMetadata(snapshot.model);
+            updateModel(snapshot);
+            auto writer = snapshot.model->QueryWriter("3mf");
+            writer->WriteToFile(filename.string().c_str());
+            return true;
+        }
+        catch (Lib3MF::ELib3MFException const & e)
+        {
+            m_logger->addEvent({fmt::format("3MF snapshot write error: {} (Error Code: {})",
+                                            e.what(),
+                                            e.getErrorCode()),
+                                events::Severity::Error});
         }
+        catch (std::exception const & e)
+        {
+            m_logger->addEvent({fmt::format("Snapshot write error: {}", e.what()),
+                                events::Severity::Error});
+        }
+        return false;
+    }
 
-        m_logger->logInfo("Retrieved 3MF model for update");
+    void Writer3mf::updateModel(Document const & doc)
+    {
         auto assembly = doc.getAssembly();
         if (!assembly)
         {
@@ -667,7 +691,26 @@ namespace gladius::io
             return;
         }
 
-        auto functions = assembly->getFunctions();
+        updateModel(doc.get3mfModel(), *assembly);
+    }
+
+    void Writer3mf::updateModel(SaveSnapshot const & snapshot)
+    {
+        updateModel(snapshot.model, *snapshot.assembly);
+    }
+
+    void Writer3mf::updateModel(Lib3MF::PModel model3mf, nodes::Assembly const & assembly)
+    {
+        m_logger->logInfo("Starting updateModel operation");
+        if (!model3mf)
+        {
+            m_logger->addEvent({"No 3MF model to update.", events::Severity::Error});
+            return;
+        }
+
+        m_logger->logInfo("Retrieved 3MF model for update");
+
+        auto functions = assembly.getFunctions();
         m_logger->logInfo(fmt::format("Found {} functions to process", functions.size()));
 
         for (auto & [name, model] : functions)
diff --git a/gladius/src/io/3mf/Writer3mf.h b/gladius/src/io/3mf/Writer3mf.h
index 062f12a7..2eff1e92 100644
--- a/gladius/src/io/3mf/Writer3mf.h
+++ b/gladius/src/io/3mf/Writer3mf.h
@@ -8,6 +8,7 @@
 
 #include "EventLogger.h"
 #include "io/3mf/Writer3mfBase.h"
+#include "io/3mf/SaveSnapshot.h"
 #include "nodes/types.h"
 
 #include <lib3mf_implicit.hpp>
@@ -72,6 +73,21 @@ namespace gladius::io
                   Document const & doc,
                   bool writeThumbnail = true);
 
+        /**
+         * @brief Saves an independent snapshot without accessing the live document.
+         * @return true when the package was written successfully.
+         */
+        bool save(std::filesystem::path const & filename,
+            SaveSnapshot const & snapshot,
+            bool writeThumbnail = false);
+
+        /// @brief Attaches PNG bytes to a snapshot-owned Lib3MF model.
+        bool attachThumbnail(Lib3MF::PModel model3mf,
+                             std::vector<Lib3MF_uint8> const & pngData)
+        {
+            return Writer3mfBase::attachThumbnail(model3mf, pngData);
+        }
+
         /**
          * @brief Saves the function to a 3MF file with the specified filename.
          * @param filename The path to the output 3MF file.
@@ -85,6 +101,9 @@ namespace gladius::io
          */
         void updateModel(Document const & doc);
 
+        /// @brief Updates a Lib3MF model from an independent save snapshot.
+        void updateModel(SaveSnapshot const & snapshot);
+
       private:
         /**
          * @brief Adds the function to the 3MF model.
@@ -102,6 +121,8 @@ namespace gladius::io
         void fillFunction(Lib3MF::PImplicitFunction function,
                           gladius::nodes::Model & model,
                           Lib3MF::PModel model3mf);
+
+        void updateModel(Lib3MF::PModel model3mf, nodes::Assembly const & assembly);
     };
 
     /**
diff --git a/gladius/src/io/3mf/Writer3mfBase.cpp b/gladius/src/io/3mf/Writer3mfBase.cpp
index 99b6906e..363df7f1 100644
--- a/gladius/src/io/3mf/Writer3mfBase.cpp
+++ b/gladius/src/io/3mf/Writer3mfBase.cpp
@@ -36,6 +36,35 @@ namespace gladius::io
         }
     }
 
+    bool Writer3mfBase::attachThumbnail(Lib3MF::PModel model3mf,
+                                         std::vector<Lib3MF_uint8> const & pngData)
+    {
+        if (!model3mf || pngData.empty())
+        {
+            return false;
+        }
+
+        try
+        {
+            if (model3mf->HasPackageThumbnailAttachment())
+            {
+                model3mf->RemovePackageThumbnailAttachment();
+            }
+            auto thumbnail = model3mf->CreatePackageThumbnailAttachment();
+            thumbnail->ReadFromBuffer(pngData);
+            return true;
+        }
+        catch (std::exception const & e)
+        {
+            if (m_logger)
+            {
+                m_logger->addEvent({fmt::format("Failed to attach supplied thumbnail: {}", e.what()),
+                                    events::Severity::Warning});
+            }
+            return false;
+        }
+    }
+
     void Writer3mfBase::updateThumbnail(Document & doc, Lib3MF::PModel model3mf)
     {
         if (!model3mf)
diff --git a/gladius/src/io/3mf/Writer3mfBase.h b/gladius/src/io/3mf/Writer3mfBase.h
index a0d52c2f..444f42d8 100644
--- a/gladius/src/io/3mf/Writer3mfBase.h
+++ b/gladius/src/io/3mf/Writer3mfBase.h
@@ -10,6 +10,7 @@
 #include <lib3mf_implicit.hpp>
 
 #include <filesystem>
+#include <vector>
 
 namespace gladius
 {
@@ -37,6 +38,13 @@ namespace gladius::io
          */
         virtual ~Writer3mfBase() = default;
 
+        /**
+         * @brief Replaces the package thumbnail with supplied PNG bytes.
+         * @return true if the attachment was created successfully.
+         */
+        bool attachThumbnail(Lib3MF::PModel model3mf,
+                 std::vector<Lib3MF_uint8> const & pngData);
+
       protected:
         /**
          * @brief Updates the thumbnail of the 3MF model from document data.
diff --git a/gladius/src/io/ShellExporter.cpp b/gladius/src/io/ShellExporter.cpp
index ff31bb9f..3b45ba8d 100644
--- a/gladius/src/io/ShellExporter.cpp
+++ b/gladius/src/io/ShellExporter.cpp
@@ -1,6 +1,7 @@
 #include "ShellExporter.h"
 
 #include "3mf/MeshWriter3mf.h"
+#include "3mf/OpenVdbShellGenerator.h"
 #include "3mf/ShellGenerator.h"
 #include "ComputeContext.h"
 #include "ComputeCore.h"
@@ -191,6 +192,12 @@ namespace gladius::io
 
         m_progress.store(0.05, std::memory_order_release);
 
+        auto const shellIntervals = ShellThicknessPartition::buildIntervals(solution);
+        if (shellIntervals.empty())
+        {
+            throw std::runtime_error("Shell export requires at least one non-zero shell thickness");
+        }
+
         if (isCancellationRequested())
         {
             m_state.store(State::Idle, std::memory_order_release);
@@ -200,18 +207,43 @@ namespace gladius::io
         // Phase 2: Shell generation (5% - 85%)
         {
             std::lock_guard lock(m_statusMutex);
-            m_statusMessage = fmt::format("Generating {} shells...", numLayers);
+            m_statusMessage = fmt::format("Generating {} shells...", shellIntervals.size());
         }
 
-        ShellGenerator shellGenerator(generator, *const_cast<Document*>(m_document));
-        auto shells = shellGenerator.generateShells(
-            m_config.filamentStack,
-            solution,
-            m_config.mdcOptions,
-            m_config.lutResolution,
-            m_config.thicknessConstraints,
-            &m_config.precomputedLuts,
-            m_config.useSurfaceColorSampling);
+        std::vector<ShellGenerator::ShellMesh> shells;
+        if (m_config.generationMode == ShellGenerationMode::OpenVdbColorThickness)
+        {
+            OpenVdbShellGenerator shellGenerator(generator);
+            if (m_config.useSurfaceColorSampling)
+            {
+                shells = shellGenerator.generateSurfaceDrivenShells(
+                    m_config.filamentStack,
+                    m_config.mdcOptions,
+                    m_config.lutResolution,
+                    m_config.thicknessConstraints,
+                    [this]() { return isCancellationRequested(); });
+            }
+            else
+            {
+                shells = shellGenerator.generateUniformShells(
+                    m_config.filamentStack,
+                    solution,
+                    m_config.mdcOptions,
+                    [this]() { return isCancellationRequested(); });
+            }
+        }
+        else
+        {
+            ShellGenerator shellGenerator(generator, *const_cast<Document*>(m_document));
+            shells = shellGenerator.generateShells(
+                m_config.filamentStack,
+                solution,
+                m_config.mdcOptions,
+                m_config.lutResolution,
+                m_config.thicknessConstraints,
+                &m_config.precomputedLuts,
+                m_config.useSurfaceColorSampling);
+        }
 
         if (isCancellationRequested())
         {
diff --git a/gladius/src/io/ShellExporter.h b/gladius/src/io/ShellExporter.h
index 3037e3b7..80242bf9 100644
--- a/gladius/src/io/ShellExporter.h
+++ b/gladius/src/io/ShellExporter.h
@@ -3,6 +3,7 @@
 #include "IExporter.h"
 #include "3mf/FilamentOpticalProperties.h"
 #include "3mf/FrontlitThicknessSolver.h"
+#include "3mf/ShellThicknessPartition.h"
 #include "SurfaceExtractionOptions.h"
 #include "../EventLogger.h"
 
@@ -24,6 +25,7 @@ namespace gladius::io
     /// @brief Configuration for shell-based color export
     struct ShellExportConfig
     {
+        ShellGenerationMode generationMode = ShellGenerationMode::LegacyManifoldDualContouring;
         FilamentStack filamentStack;                      ///< Ordered materials (bottom to top)
         std::vector<std::vector<float>> precomputedLuts;  ///< Thickness LUTs per layer
         int lutResolution = 16;                           ///< LUT grid resolution
diff --git a/gladius/src/kernel/manifold_dual_contouring.cl b/gladius/src/kernel/manifold_dual_contouring.cl
index 44d18b0c..d6b1e068 100644
--- a/gladius/src/kernel/manifold_dual_contouring.cl
+++ b/gladius/src/kernel/manifold_dual_contouring.cl
@@ -69,7 +69,7 @@ float3 getCellExtent(float3 bboxMin, float3 bboxMax, uint depth)
 // variable shell offsets based on surface colors.
 
 /// Transform world position to field grid coordinates and sample thickness
-inline float sampleThicknessFieldMDC(
+static inline float sampleThicknessFieldMDC(
     __global const float* thicknessField,  // 3D grid of precomputed thickness values
     const int fieldResolution,              // Resolution of the 3D grid (e.g., 128)
     const float16 worldToGrid,              // 4x4 transform: world → grid coordinates
@@ -121,7 +121,7 @@ inline float sampleThicknessFieldMDC(
 /// Compute shell SDF value using thickness fields
 /// For non-innermost layers: max(SDF + outer, -(SDF + inner))
 /// For innermost layer: SDF + outer
-inline float computeShellSdfMDC(
+static inline float computeShellSdfMDC(
     const float baseSdf,
     __global const float* outerField,
     __global const float* innerField,
@@ -150,7 +150,7 @@ inline float computeShellSdfMDC(
 /// Compute gradient of shell SDF using central differences
 /// This must be used for thickness field mode instead of computeGradientWithEps,
 /// because the shell SDF is a function of both the base SDF and the thickness field.
-inline float3 computeShellGradientMDC(
+static inline float3 computeShellGradientMDC(
     const float3 pos,
     const float epsilon,
     __global const float* outerField,
diff --git a/gladius/src/kernel/sdf.cl b/gladius/src/kernel/sdf.cl
index 23526af7..6026d1a4 100644
--- a/gladius/src/kernel/sdf.cl
+++ b/gladius/src/kernel/sdf.cl
@@ -637,7 +637,7 @@ float vdbModelSimple(float3 pos, int index, PAYLOAD_ARGS)
         int3 coord = convert_int3(pos);
         pnanovdb_coord_t coordCenter = pnanovdb_make_coord(coord.x, coord.y, coord.z);
 
-        return pnanovdb_read_float_value(buf, &acc, coordCenter);
+        return pnanovdb_read_float_value(buf, &acc, coordCenter) / node.scaling;
     }
     // return boundingBox + bandwidth;
 }
diff --git a/gladius/src/mcp/tools/FunctionEvaluatorTool.cpp b/gladius/src/mcp/tools/FunctionEvaluatorTool.cpp
index 93c5598c..42e07313 100644
--- a/gladius/src/mcp/tools/FunctionEvaluatorTool.cpp
+++ b/gladius/src/mcp/tools/FunctionEvaluatorTool.cpp
@@ -10,7 +10,9 @@
 #include "../../Document.h"
 #include "../../ResourceContext.h"
 #include "../../compute/ComputeCore.h"
+#include "../../compute/GpuKernelAccessGuard.h"
 #include "../../compute/ProgramManager.h"
+#include "../../compute/RenderPayloadSnapshot.h"
 #include "../../nodes/Assembly.h"
 #include "../../nodes/Model.h"
 #include "../../nodes/Parameter.h"
@@ -677,11 +679,28 @@ namespace gladius::mcp::tools
             auto queue = computeContext->createQueue();
 
             auto primitives = core->getPrimitives();
-            evalProg.run(
+                        if (!primitives)
+                        {
+                                return createToolError("Primitive buffers are not available.");
+                        }
+
+                        auto payloadSnapshot = RenderPayloadSnapshot::capture(resources, *primitives);
+                        GpuKernelAccessGuard gpuAccess(
+                            *computeContext,
+                            queue,
+                            "gladius_eval",
+                            payloadSnapshot.readAccesses());
+                        if (!gpuAccess.granted())
+                        {
+                                return createToolError("GPU resources are not available for evaluation.");
+                        }
+
+                        cl::Event const evalEvent = evalProg.runNonBlockingWithWaitList(
               queue,
               "gladius_eval",
               cl::NullRange,
               cl::NDRange(sampleCount),
+                            gpuAccess.waitEvents(),
               *clInputBuffer,
               *clOutputBuffer,
               static_cast<cl_uint>(sampleCount),
@@ -696,6 +715,12 @@ namespace gladius::mcp::tools
               resources->getCommandBuffer().getBuffer(),
               static_cast<cl_int>(resources->getCommandBuffer().getData().size()),
               resources->getPreCompSdfBBox());
+                        gpuAccess.complete(evalEvent);
+                        if (evalEvent())
+                        {
+                                evalEvent.wait();
+                        }
+                        CL_ERROR(queue.finish());
 
             // Read back results.
             std::vector<float> outputData(outputFloatCount);
diff --git a/gladius/src/mcp/tools/RenderingTool.cpp b/gladius/src/mcp/tools/RenderingTool.cpp
index 61844577..b21583ba 100644
--- a/gladius/src/mcp/tools/RenderingTool.cpp
+++ b/gladius/src/mcp/tools/RenderingTool.cpp
@@ -276,7 +276,7 @@ namespace gladius
                     float yaw = std::atan2(direction.y(), direction.x());
 
                     customCamera.setAngle(pitch, yaw);
-                    customCamera.update(10000.0f);
+                    customCamera.snapToTarget();
 
                     // Apply the custom camera settings
                     core->applyCamera(customCamera);
@@ -416,14 +416,14 @@ namespace gladius
                 optimalCamera.centerView(bbox);
 
                 // Update camera position
-                optimalCamera.update(10000.0f);
+                optimalCamera.snapToTarget();
 
                 // Adjust distance to fit the model in view (using reasonable viewport size)
                 const float viewportSize = 512.0f;
                 optimalCamera.adjustDistanceToTarget(bbox, viewportSize, viewportSize);
 
                 // Final update
-                optimalCamera.update(10000.0f);
+                optimalCamera.snapToTarget();
 
                 // Get the calculated camera parameters
                 auto eyePosition = optimalCamera.getEyePosition();
diff --git a/gladius/src/nodes/IssueList.h b/gladius/src/nodes/IssueList.h
index b7303f0a..153e558a 100644
--- a/gladius/src/nodes/IssueList.h
+++ b/gladius/src/nodes/IssueList.h
@@ -21,7 +21,8 @@ namespace gladius::nodes
         TypeMismatch,       ///< Connected port type doesn't match parameter
         InvalidReference,   ///< Referenced node/port no longer exists
         CyclicDependency,   ///< Graph contains a cycle
-        FunctionNotFound    ///< Referenced function doesn't exist
+        FunctionNotFound,   ///< Referenced function doesn't exist
+        GraphSyncError      ///< Graph sync/validation failed unexpectedly
     };
 
     /**
diff --git a/gladius/src/nodes/Model.cpp b/gladius/src/nodes/Model.cpp
index f70f7177..971351d2 100644
--- a/gladius/src/nodes/Model.cpp
+++ b/gladius/src/nodes/Model.cpp
@@ -108,20 +108,37 @@ namespace gladius::nodes
             {
                 if (parameter.second.getSource().has_value())
                 {
-                    const auto portIter =
-                      std::find_if(std::begin(m_outPorts),
-                                   std::end(m_outPorts),
-                                   [&](auto & port)
-                                   {
-                                       return port.second->getUniqueName() ==
-                                              parameter.second.getSource().value().uniqueName;
-                                   });
+                    auto const & src = parameter.second.getSource().value();
+
+                    // Primary lookup: by uniqueName (the normal path).
+                    auto portIter = std::find_if(std::begin(m_outPorts),
+                                                 std::end(m_outPorts),
+                                                 [&](auto & port)
+                                                 {
+                                                     return port.second->getUniqueName() ==
+                                                            src.uniqueName;
+                                                 });
+
+                    // Fallback: by portId. This handles the case where a port was renamed
+                    // after the link was established and the Source::uniqueName became stale.
+                    if (portIter == std::end(m_outPorts))
+                    {
+                        portIter = m_outPorts.find(src.portId);
+                    }
 
                     if (portIter == std::end(m_outPorts))
                     {
-                        throw std::runtime_error(
-                          fmt::format("Output port with the name {} could not be found",
-                                      parameter.second.getSource().value().uniqueName));
+                        if (m_logger)
+                        {
+                            m_logger->addEvent(
+                              {fmt::format("Output port with the name {} could not be found — "
+                                           "link dropped during model copy",
+                                           src.uniqueName),
+                               events::Severity::Warning});
+                        }
+                        // Clear the stale source so the model remains in a consistent state.
+                        parameter.second.setSource(std::nullopt);
+                        continue;
                     }
                     bool const skipLinkValidation = true;
                     addLink(
diff --git a/gladius/src/nodes/NodeBase.h b/gladius/src/nodes/NodeBase.h
index e2ba53b8..4c63b7af 100644
--- a/gladius/src/nodes/NodeBase.h
+++ b/gladius/src/nodes/NodeBase.h
@@ -50,18 +50,37 @@ namespace gladius::nodes
     bool operator==(const InputTypeMap & lhs, const InputTypeMap & rhs);
     struct GeneratorContext
     {
+      private:
+        std::unique_ptr<ResourceManager> m_ownedResourceManager;
+        // Keep the resources alive for the lifetime of the GeneratorContext
+        SharedResources m_resourceContext;
+
+      public:
         GeneratorContext(SharedResources resourceContext, std::filesystem::path assemblyDir)
-            : resourceManager(resourceContext, std::move(assemblyDir))
-            , m_resourceContext(resourceContext) {};
+            : m_ownedResourceManager(
+                std::make_unique<ResourceManager>(resourceContext, std::move(assemblyDir)))
+            , m_resourceContext(resourceContext)
+            , resourceManager(*m_ownedResourceManager)
+        {
+        }
+
+        /// Creates a staging context that reuses the document's host-side resources while
+        /// targeting an independent generation resource context. The borrowed manager must
+        /// outlive this GeneratorContext and concurrent resource mutation must be excluded by
+        /// the caller's staging barrier.
+        GeneratorContext(SharedResources resourceContext,
+                         ResourceManager & borrowedResourceManager,
+                         std::filesystem::path assemblyDir)
+            : resourceManager(borrowedResourceManager)
+            , m_resourceContext(std::move(resourceContext))
+            , basePath(std::move(assemblyDir))
+        {
+        }
 
         SharedPrimitives primitives{nullptr};
-        ResourceManager resourceManager;
+        ResourceManager & resourceManager;
         std::filesystem::path basePath{};
         SharedComputeContext computeContext{nullptr};
-
-      private:
-        // Keep the resources alive for the lifetime of the GeneratorContext
-        SharedResources m_resourceContext;
     };
 
     class NodeBase
@@ -79,9 +98,7 @@ namespace gladius::nodes
         virtual ~NodeBase() = default;
 
         ParameterMap & parameter()
-        {
-            return m_parameter;
-        }
+        { return m_parameter; }
 
         VariantParameter * getParameter(ParameterName const & parameterName)
         {
@@ -96,19 +113,13 @@ namespace gladius::nodes
         }
 
         ParameterMap const & constParameter() const
-        {
-            return m_parameter;
-        }
+        { return m_parameter; }
 
         [[nodiscard]] auto name() const -> NodeName const &
-        {
-            return m_name;
-        }
+        { return m_name; }
 
         [[nodiscard]] auto getUniqueName() const -> NodeName const &
-        {
-            return m_unique_name;
-        }
+        { return m_unique_name; }
 
         void setUniqueName(const std::string & name)
         {
@@ -129,24 +140,16 @@ namespace gladius::nodes
         }
 
         void setDisplayName(const NodeName & displayName)
-        {
-            m_displayName = displayName;
-        }
+        { m_displayName = displayName; }
 
         [[nodiscard]] auto outputs() const -> Outputs const &
-        {
-            return m_outputs;
-        }
+        { return m_outputs; }
 
         [[nodiscard]] Outputs & getOutputs()
-        {
-            return m_outputs;
-        }
+        { return m_outputs; }
 
         [[nodiscard]] Outputs const & getOutputs() const
-        {
-            return m_outputs;
-        }
+        { return m_outputs; }
 
         Port * findOutputPort(PortName const & portName)
         {
@@ -159,41 +162,27 @@ namespace gladius::nodes
         }
 
         [[nodiscard]] auto getId() const -> NodeId
-        {
-            return m_id;
-        }
+        { return m_id; }
 
         void setId(NodeId id)
-        {
-            m_id = id;
-        }
+        { m_id = id; }
 
         virtual void accept(Visitor & /*unused*/) {};
 
         [[nodiscard]] auto screenPos() -> float2 &
-        {
-            return m_screenPos;
-        }
+        { return m_screenPos; }
 
         [[nodiscard]] auto screenPos() const -> float2 const &
-        {
-            return m_screenPos;
-        }
+        { return m_screenPos; }
 
         [[nodiscard]] auto getCategory() const -> Category
-        {
-            return m_category;
-        }
+        { return m_category; }
 
         void setOrder(NodeId order)
-        {
-            m_order = order;
-        }
+        { m_order = order; }
 
         [[nodiscard]] auto getOrder() const -> NodeId
-        {
-            return m_order;
-        }
+        { return m_order; }
         void addOutputPort(const PortName & portName, std::type_index typeIndex)
         {
             auto & newPort = m_outputs[portName];
@@ -211,32 +200,24 @@ namespace gladius::nodes
         }
 
         std::unique_ptr<NodeBase> clone() const
-        {
-            return std::unique_ptr<NodeBase>(this->cloneImpl());
-        }
+        { return std::unique_ptr<NodeBase>(this->cloneImpl()); }
         void updateNodeIds();
 
         [[nodiscard]] virtual bool parameterChangeInvalidatesPayload() const
-        {
-            return false;
-        }
+        { return false; }
 
         virtual void generate(GeneratorContext & /*generatorContext*/) {};
 
         virtual void updateMemoryOffsets(GeneratorContext & /*generatorContext*/) {};
 
         [[nodiscard]] virtual std::string getDescription() const
-        {
-            return {"Basic node"};
-        }
+        { return {"Basic node"}; }
 
         /// @brief Determines if this node should be exempt from input connection validation
         /// @return true if the node doesn't require input validation (e.g., input/output markers,
         /// constants)
         [[nodiscard]] virtual bool isExemptFromInputValidation() const
-        {
-            return false;
-        }
+        { return false; }
 
         bool updateTypes(nodes::Model & model);
 
@@ -331,19 +312,13 @@ namespace gladius::nodes
         }
 
         [[nodiscard]] auto getTag() const -> NodeName const &
-        {
-            return m_tag;
-        }
+        { return m_tag; }
 
         void setTag(const NodeName & tag)
-        {
-            m_tag = tag;
-        }
+        { m_tag = tag; }
 
         [[nodiscard]] RuleType getRuleType() const
-        {
-            return m_ruleType;
-        }
+        { return m_ruleType; }
 
       protected:
         ParameterMap m_parameter;
@@ -361,9 +336,7 @@ namespace gladius::nodes
 
       private:
         [[nodiscard]] virtual NodeBase * cloneImpl() const
-        {
-            return new NodeBase(*this);
-        }
+        { return new NodeBase(*this); }
     };
 
     inline void NodeBase::updateNodeIds()
diff --git a/gladius/src/nodes/ToCommandStreamVisitor.cpp b/gladius/src/nodes/ToCommandStreamVisitor.cpp
index 1db2ef90..ea82c4bb 100644
--- a/gladius/src/nodes/ToCommandStreamVisitor.cpp
+++ b/gladius/src/nodes/ToCommandStreamVisitor.cpp
@@ -288,12 +288,9 @@ namespace gladius::nodes
 
         out << m_signature.str();
         out << fmt::format("float out[{}];\n", roundUp(m_currentOutPutIndex + 1, 1024));
-        out << fmt::format("out[1]={}.x;\n",
-                           getAssemblyBegin().getOutputs().at(FieldNames::Pos).getUniqueName());
-        out << fmt::format("out[2]={}.y;\n",
-                           getAssemblyBegin().getOutputs().at(FieldNames::Pos).getUniqueName());
-        out << fmt::format("out[3]={}.z;\n",
-                           getAssemblyBegin().getOutputs().at(FieldNames::Pos).getUniqueName());
+        out << "out[1]=pos.x;\n";
+        out << "out[2]=pos.y;\n";
+        out << "out[3]=pos.z;\n";
 
         out << "for (int i = 0; i < sizeOfCmds; ++i)\n";
         out << "{\n";
@@ -1807,8 +1804,7 @@ namespace gladius::nodes
         {
             acquireOutputIndex(beginning.getOutputs().at(FieldNames::Pos), 3);
 
-            m_signature << fmt::format("float4 model(float3 {0} ,  PAYLOAD_ARGS)\n{{\n",
-                                       beginning.getOutputs().at(FieldNames::Pos).getUniqueName());
+            m_signature << "float4 model(float3 pos, PAYLOAD_ARGS)\n{\n";
         }
 
         m_partBegin = beginning;
diff --git a/gladius/src/nodes/Validator.cpp b/gladius/src/nodes/Validator.cpp
index 02dd704f..544c9389 100644
--- a/gladius/src/nodes/Validator.cpp
+++ b/gladius/src/nodes/Validator.cpp
@@ -23,6 +23,9 @@ namespace gladius::nodes
         case IssueType::FunctionNotFound:
             return "Ensure the referenced function exists or create a new function with the "
                    "expected name.";
+        case IssueType::GraphSyncError:
+            return "Review the graph for invalid nodes or broken references, then save or "
+                   "reload the model.";
         }
         return "Review and fix this issue.";
     }
@@ -108,6 +111,12 @@ namespace gladius::nodes
                                  Assembly & assembly,
                                  IssueList & issueList)
     {
+      if (auto * functionCall = dynamic_cast<FunctionCall *>(&node); functionCall != nullptr)
+      {
+        validateNode(*functionCall, model, assembly, issueList);
+        return;
+      }
+
         validateNodeImpl(node, model, issueList);
     }
 
diff --git a/gladius/src/ui/BeamLatticeView.cpp b/gladius/src/ui/BeamLatticeView.cpp
index e02722fe..823a7c08 100644
--- a/gladius/src/ui/BeamLatticeView.cpp
+++ b/gladius/src/ui/BeamLatticeView.cpp
@@ -7,6 +7,7 @@
 #include "imgui.h"
 #include <cstring>
 #include <fmt/format.h>
+#include <optional>
 
 namespace gladius::ui
 {
@@ -28,6 +29,7 @@ namespace gladius::ui
         auto const & resources = resourceManager.getResourceMap();
 
         bool propertiesChanged = false;
+        std::optional<ResourceKey> pendingResourceDeletion;
 
         renderImportDialog(document, propertiesChanged);
 
@@ -146,7 +148,7 @@ namespace gladius::ui
                     {
                         if (safeResult.canBeRemoved)
                         {
-                            document->deleteResource(key);
+                            pendingResourceDeletion = key;
                             propertiesChanged = true;
                         }
                     }
@@ -179,6 +181,11 @@ namespace gladius::ui
                   "Beam Lattice Details\n\n"
                   "View the structure and properties of this beam lattice.\n"
                   "Beam lattices define complex structural geometries using beams and nodes.");
+
+                                if (pendingResourceDeletion.has_value())
+                                {
+                                        break;
+                                }
             }
 
             if (!hasBeamLattices)
@@ -196,6 +203,11 @@ namespace gladius::ui
                      "Beam lattices are ideal for lightweight structures, supports,\n"
                      "and metamaterials with specific mechanical properties.");
 
+        if (pendingResourceDeletion.has_value())
+        {
+            document->deleteResource(*pendingResourceDeletion);
+        }
+
         return propertiesChanged;
     }
 
diff --git a/gladius/src/ui/ColorToThicknessDialog.cpp b/gladius/src/ui/ColorToThicknessDialog.cpp
index 037aa7a4..4ce1d3b6 100644
--- a/gladius/src/ui/ColorToThicknessDialog.cpp
+++ b/gladius/src/ui/ColorToThicknessDialog.cpp
@@ -1,6 +1,7 @@
 #include "ColorToThicknessDialog.h"
 
 #include "Widgets.h"
+#include "io/3mf/FaceThicknessMapper.h"
 
 #include <imgui.h>
 
@@ -125,6 +126,7 @@ namespace gladius::ui
             filament.reflectanceColor = Eigen::Vector3f(1.0F, 1.0F, 1.0F);
             filament.transmissionDistance = Eigen::Vector3f(1.0F, 1.0F, 1.0F);
             m_materials.push_back(filament);
+            invalidateComputedData();
         }
         ImGui::SameLine();
         if (ImGui::Button("Load…"))
@@ -185,6 +187,7 @@ namespace gladius::ui
                                       ImGuiColorEditFlags_NoInputs))
                 {
                     mat.reflectanceColor = Eigen::Vector3f{clamp01(color[0]), clamp01(color[1]), clamp01(color[2])};
+                    invalidateComputedData();
                 }
 
                 ImGui::TableSetColumnIndex(3);
@@ -194,6 +197,7 @@ namespace gladius::ui
                 {
                     tdValue = std::max(0.0F, tdValue);
                     mat.transmissionDistance = Eigen::Vector3f{tdValue, tdValue, tdValue};
+                    invalidateComputedData();
                 }
 
                 ImGui::TableSetColumnIndex(4);
@@ -204,6 +208,7 @@ namespace gladius::ui
                     {
                         m_backgroundIndex = m_materials.empty() ? 0 : m_materials.size() - 1;
                     }
+                    invalidateComputedData();
                     --i;
                 }
             }
@@ -233,6 +238,7 @@ namespace gladius::ui
             if (ImGui::Combo("##background", &selected, names.data(), static_cast<int>(names.size())))
             {
                 m_backgroundIndex = static_cast<std::size_t>(selected);
+                invalidateComputedData();
             }
         }
     }
@@ -276,7 +282,7 @@ namespace gladius::ui
             if (ImGui::Button("Clear palette"))
             {
                 m_palette.clear();
-                m_solutions.clear();
+                invalidateComputedData();
             }
         }
 
@@ -304,6 +310,7 @@ namespace gladius::ui
                 if (ImGui::ColorEdit3(("##pal" + std::to_string(i)).c_str(), color))
                 {
                     m_palette[i] = Eigen::Vector3f{clamp01(color[0]), clamp01(color[1]), clamp01(color[2])};
+                    m_solutions.clear();
                 }
 
                 ImGui::TableSetColumnIndex(2);
@@ -333,7 +340,7 @@ namespace gladius::ui
         if (ImGui::Combo("Illumination mode", &modeIndex, MODE_LABELS, IM_ARRAYSIZE(MODE_LABELS)))
         {
             m_illuminationMode = (modeIndex == 0) ? io::IlluminationMode::Frontlit : io::IlluminationMode::Backlit;
-            m_solutions.clear();
+            invalidateComputedData();
         }
 
         ImGui::SetNextItemWidth(140.0F);
@@ -344,24 +351,33 @@ namespace gladius::ui
             {
                 m_constraints.maxThickness = m_constraints.minThickness;
             }
+            invalidateComputedData();
         }
 
         ImGui::SetNextItemWidth(140.0F);
         if (ImGui::InputFloat("Max thickness (mm)", &m_constraints.maxThickness, 0.1F, 0.5F, "%.3f"))
         {
             m_constraints.maxThickness = std::max(m_constraints.maxThickness, m_constraints.minThickness);
+            invalidateComputedData();
         }
 
         ImGui::SetNextItemWidth(140.0F);
-        ImGui::InputFloat("Layer height (mm, optional)", &m_constraints.layerHeight, 0.01F, 0.05F, "%.3f");
+        if (ImGui::InputFloat("Layer height (mm, optional)", &m_constraints.layerHeight, 0.01F, 0.05F, "%.3f"))
+        {
+            invalidateComputedData();
+        }
 
         ImGui::SetNextItemWidth(140.0F);
-        ImGui::InputFloat("Total max thickness (mm, optional)", &m_constraints.totalMaxThickness, 0.5F, 1.0F, "%.3f");
+        if (ImGui::InputFloat("Total max thickness (mm, optional)", &m_constraints.totalMaxThickness, 0.5F, 1.0F, "%.3f"))
+        {
+            invalidateComputedData();
+        }
 
         ImGui::SetNextItemWidth(140.0F);
         if (ImGui::InputInt("LUT resolution (per axis)", &m_lutResolution))
         {
             m_lutResolution = std::clamp(m_lutResolution, 2, 64); // keep sane bounds
+            invalidateComputedData();
         }
 
         bool const canCompute = !m_materials.empty() && !m_palette.empty();
@@ -410,14 +426,26 @@ namespace gladius::ui
             return;
         }
 
-        int const columnCount = static_cast<int>(m_materials.size()) + 3;
+        auto const orderedMaterials = getOrderedShellMaterials();
+
+        int const columnCount = static_cast<int>(orderedMaterials.stack.size()) + 3;
         if (ImGui::BeginTable("ResultsTable", columnCount, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg))
         {
             ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_WidthFixed, 130.0F);
             ImGui::TableSetupColumn("Target", ImGuiTableColumnFlags_WidthFixed, 190.0F);
-            for (auto const & mat : m_materials)
+            for (std::size_t orderedIndex = 0; orderedIndex < orderedMaterials.stack.size(); ++orderedIndex)
             {
-                ImGui::TableSetupColumn(mat.name.c_str(), ImGuiTableColumnFlags_WidthFixed, 200.0F);
+                auto const & mat = orderedMaterials.stack[orderedIndex];
+                std::string columnLabel = mat.name;
+                if (orderedIndex == 0U)
+                {
+                    columnLabel += " (inner)";
+                }
+                else if (orderedIndex + 1U == orderedMaterials.stack.size())
+                {
+                    columnLabel += " (outer)";
+                }
+                ImGui::TableSetupColumn(columnLabel.c_str(), ImGuiTableColumnFlags_WidthFixed, 200.0F);
             }
             ImGui::TableSetupColumn("Error", ImGuiTableColumnFlags_WidthFixed, 80.0F);
             ImGui::TableHeadersRow();
@@ -431,19 +459,27 @@ namespace gladius::ui
                 ImGui::Text("%zu", row + 1);
 
                 ImGui::TableSetColumnIndex(1);
-                ImVec4 targetColor{solution.targetColor.x(), solution.targetColor.y(), solution.targetColor.z(), 1.0F};
+                Eigen::Vector3f const targetDisplay = io::linearToSrgb(
+                    solution.targetColor.cwiseMax(0.0F).cwiseMin(1.0F));
+                ImVec4 targetColor{targetDisplay.x(), targetDisplay.y(), targetDisplay.z(), 1.0F};
                 colorButtonWithTooltip(("##target" + std::to_string(row)).c_str(), targetColor, "Target color");
                 ImGui::SameLine();
-                ImVec4 achievedColor{solution.achievedColor.x(), solution.achievedColor.y(), solution.achievedColor.z(), 1.0F};
+                Eigen::Vector3f const achievedDisplay = io::linearToSrgb(
+                    solution.achievedColor.cwiseMax(0.0F).cwiseMin(1.0F));
+                ImVec4 achievedColor{achievedDisplay.x(), achievedDisplay.y(), achievedDisplay.z(), 1.0F};
                 colorButtonWithTooltip(("##achieved" + std::to_string(row)).c_str(), achievedColor, "Achieved color");
 
-                for (std::size_t col = 0; col < m_materials.size(); ++col)
+                for (std::size_t orderedIndex = 0; orderedIndex < orderedMaterials.stack.size(); ++orderedIndex)
                 {
-                    ImGui::TableSetColumnIndex(static_cast<int>(2 + col));
+                    ImGui::TableSetColumnIndex(static_cast<int>(2 + orderedIndex));
                     float thickness = 0.0F;
-                    if (col < solution.thicknesses.size())
+                    if (orderedIndex < orderedMaterials.orderedToOriginal.size())
                     {
-                        thickness = solution.thicknesses[col];
+                        std::size_t const originalIndex = orderedMaterials.orderedToOriginal[orderedIndex];
+                        if (originalIndex < solution.thicknesses.size())
+                        {
+                            thickness = solution.thicknesses[originalIndex];
+                        }
                     }
                     ImGui::Text("%.3f mm", thickness);
                 }
@@ -466,6 +502,11 @@ namespace gladius::ui
         return m_lutStatus;
     }
 
+    io::FilamentStack ColorToThicknessDialog::getFilamentStack() const
+    {
+        return getOrderedShellMaterials().stack;
+    }
+
     bool ColorToThicknessDialog::ensurePrecomputedLuts()
     {
         if (!m_precomputedLuts.empty())
@@ -487,10 +528,14 @@ namespace gladius::ui
             return;
         }
 
-        io::FilamentStack stack{m_materials};
-        io::FrontlitThicknessSolver solver{stack, m_constraints, m_illuminationMode, m_backgroundIndex};
+        auto const orderedMaterials = getOrderedShellMaterials();
+        io::FrontlitThicknessSolver solver{
+            orderedMaterials.stack,
+            m_constraints,
+            m_illuminationMode,
+            orderedMaterials.backgroundIndex};
 
-        std::size_t const layerCount = stack.size();
+        std::size_t const layerCount = orderedMaterials.stack.size();
         std::size_t const lutSize = static_cast<std::size_t>(m_lutResolution) *
                                    static_cast<std::size_t>(m_lutResolution) *
                                    static_cast<std::size_t>(m_lutResolution);
@@ -613,6 +658,9 @@ namespace gladius::ui
 
     void ColorToThicknessDialog::deserializeMaterials(nlohmann::json const & json)
     {
+        m_solutions.clear();
+        m_lutStatus.clear();
+
         if (!json.contains("materials") || !json["materials"].is_array())
         {
             return;
@@ -691,16 +739,77 @@ namespace gladius::ui
             return;
         }
 
-        io::FilamentStack stack{m_materials};
-        io::FrontlitThicknessSolver solver{stack, m_constraints, m_illuminationMode, m_backgroundIndex};
+        auto const orderedMaterials = getOrderedShellMaterials();
+        io::FrontlitThicknessSolver solver{
+            orderedMaterials.stack,
+            m_constraints,
+            m_illuminationMode,
+            orderedMaterials.backgroundIndex};
 
         m_solutions.clear();
         m_solutions.reserve(m_palette.size());
         for (auto const & color : m_palette)
         {
-            auto solution = solver.solve(color);
+            auto solution = solver.solve(io::srgbToLinear(color.cwiseMax(0.0F).cwiseMin(1.0F)));
+            solution.thicknesses = remapThicknessesToUiOrder(
+                solution.thicknesses,
+                orderedMaterials.orderedToOriginal,
+                m_materials.size());
             m_solutions.push_back(std::move(solution));
         }
     }
 
+    io::OrderedShellMaterials ColorToThicknessDialog::getOrderedShellMaterials() const
+    {
+        io::FilamentStack stack{m_materials};
+
+        // For small frontlit stacks with a known palette, prefer the palette-optimized
+        // global order over the generic translucency heuristic. The exhaustive search is
+        // cheap for small material counts and the benchmark showed it meaningfully
+        // reduces reproduction error for typical CMY-style stacks.
+        if (m_illuminationMode == io::IlluminationMode::Frontlit
+            && !m_palette.empty()
+            && m_materials.size() <= 6U)
+        {
+            return io::ShellMaterialOrdering::optimizeGlobalOrderForPalette(
+                stack,
+                m_backgroundIndex,
+                m_illuminationMode,
+                m_constraints,
+                m_palette);
+        }
+
+        return io::ShellMaterialOrdering::reorderForShells(stack, m_backgroundIndex, m_illuminationMode);
+    }
+
+    std::vector<float> ColorToThicknessDialog::remapThicknessesToUiOrder(
+        std::vector<float> const& orderedThicknesses,
+        std::vector<std::size_t> const& orderedToOriginal,
+        std::size_t materialCount)
+    {
+        std::vector<float> remapped(materialCount, 0.0F);
+        for (std::size_t orderedIndex = 0; orderedIndex < orderedThicknesses.size() &&
+                                           orderedIndex < orderedToOriginal.size();
+             ++orderedIndex)
+        {
+            std::size_t const originalIndex = orderedToOriginal[orderedIndex];
+            if (originalIndex < remapped.size())
+            {
+                remapped[originalIndex] = orderedThicknesses[orderedIndex];
+            }
+        }
+        return remapped;
+    }
+
+    void ColorToThicknessDialog::invalidateComputedData(bool clearPaletteStatus)
+    {
+        m_solutions.clear();
+        m_precomputedLuts.clear();
+        m_lutStatus.clear();
+        if (clearPaletteStatus)
+        {
+            m_paletteStatus.clear();
+        }
+    }
+
 } // namespace gladius::ui
diff --git a/gladius/src/ui/ColorToThicknessDialog.h b/gladius/src/ui/ColorToThicknessDialog.h
index 1567e501..2893fcd2 100644
--- a/gladius/src/ui/ColorToThicknessDialog.h
+++ b/gladius/src/ui/ColorToThicknessDialog.h
@@ -3,6 +3,7 @@
 #include "FileDialogService.h"
 #include "io/3mf/FilamentOpticalProperties.h"
 #include "io/3mf/FrontlitThicknessSolver.h"
+#include "io/3mf/ShellMaterialOrdering.h"
 
 #include <eigen3/Eigen/Core>
 #include <nlohmann/json.hpp>
@@ -68,10 +69,7 @@ namespace gladius::ui
         bool ensurePrecomputedLuts();
 
         /// Get the filament stack (bottom-to-top) currently defined in the dialog
-        [[nodiscard]] io::FilamentStack getFilamentStack() const
-        {
-            return io::FilamentStack{m_materials};
-        }
+        [[nodiscard]] io::FilamentStack getFilamentStack() const;
 
         /// Get the thickness constraints used to build LUTs
         [[nodiscard]] io::ThicknessConstraints const & getConstraints() const
@@ -94,6 +92,12 @@ namespace gladius::ui
         void handleFileDialogResult();
 
         void computePrecomputedLuts();
+        [[nodiscard]] io::OrderedShellMaterials getOrderedShellMaterials() const;
+        [[nodiscard]] static std::vector<float> remapThicknessesToUiOrder(
+          std::vector<float> const& orderedThicknesses,
+          std::vector<std::size_t> const& orderedToOriginal,
+          std::size_t materialCount);
+        void invalidateComputedData(bool clearPaletteStatus = false);
 
         void loadMaterialsFromFile(std::filesystem::path const & path);
         void saveMaterialsToFile(std::filesystem::path const & path) const;
diff --git a/gladius/src/ui/GamepadActionDispatcher.cpp b/gladius/src/ui/GamepadActionDispatcher.cpp
index bb51e33d..536f9f09 100644
--- a/gladius/src/ui/GamepadActionDispatcher.cpp
+++ b/gladius/src/ui/GamepadActionDispatcher.cpp
@@ -78,6 +78,11 @@ void GamepadActionDispatcher::dispatch(GamepadAction action, ModelEditor & edito
         handleNavigationHistory(action, editor);
         break;
 
+    case GamepadAction::Cancel:
+        // Cancellation is currently handled by the same path as deselection.
+        handleSelection(GamepadAction::Deselect, editor);
+        break;
+
     case GamepadAction::Count:
         // Invalid action, do nothing
         break;
diff --git a/gladius/src/ui/MainWindow.cpp b/gladius/src/ui/MainWindow.cpp
index d83edb1c..39b8a045 100644
--- a/gladius/src/ui/MainWindow.cpp
+++ b/gladius/src/ui/MainWindow.cpp
@@ -1,4 +1,7 @@
 #include "MainWindow.h"
+
+#include "ComputeContext.h"
+#include "io/3mf/Writer3mf.h"
 #include "Theme.h"
 
 #include <algorithm>
@@ -32,6 +35,7 @@
 #include "io/3mf/ImageStackCreator.h"
 #include "io/3mf/Writer3mf.h"
 #include "io/ImageStackExporter.h"
+#include "render/RenderModeUpdatePolicy.h"
 #include <nodes/ToCommandStreamVisitor.h>
 
 namespace gladius::ui
@@ -597,6 +601,8 @@ namespace gladius::ui
         ProfileFunction;
         m_uiScale = ImGui::GetIO().FontGlobalScale * 2.0f;
 
+        pollNativeSave();
+
         // Poll for async compute initialization completion
         pollComputeInit();
 
@@ -605,6 +611,10 @@ namespace gladius::ui
         if (m_computeAvailable && m_doc)
         {
             bool const loadingNow = m_doc->isLoadingInProgress();
+            if (loadingNow)
+            {
+                m_mainView.startAnimationMode();
+            }
             if (m_asyncLoadState != AsyncLoadState::Idle && !loadingNow)
             {
                 if (m_asyncLoadState == AsyncLoadState::LoadingWithReset)
@@ -960,6 +970,7 @@ namespace gladius::ui
                 showExitPopUp();
                 showExportInProgressWarning();
                 showSaveBeforeFileOperationPopUp();
+                showSaveAsOverwriteConfirmation();
 
                 // Render library browser only when the model editor is visible.
                 if (m_modelEditor.isVisible())
@@ -1114,12 +1125,15 @@ namespace gladius::ui
         {
             auto savePath = filename;
             savePath.replace_extension(".3mf");
-            bool writeThumbnail = m_computeAvailable && m_core;
-            m_doc->saveAs(savePath, writeThumbnail);
-            // No invalidation needed — saving doesn't change the model.
-            m_fileChanged = false;
-            m_currentAssemblyFileName = savePath;
-            addToRecentFiles(savePath);
+            if (std::filesystem::exists(savePath))
+            {
+                m_pendingSaveAsPath = savePath;
+                m_showSaveAsOverwriteConfirmation = true;
+            }
+            else
+            {
+                executeSaveAs(savePath);
+            }
             break;
         }
         case AsyncDialogOperation::SaveCurrentFunction:
@@ -1347,13 +1361,15 @@ namespace gladius::ui
         {
             return; // skip rendering UI when compute is disabled
         }
-        // Process render window shortcuts
-        if (m_renderWindow.isVisible() && m_renderWindow.isHovered() && m_renderWindow.isFocused())
+
+        m_renderWindow.renderWindow();
+
+        // Process render window shortcuts after rendering so current-frame hover/focus state is
+        // available. This lets mouse-wheel zoom work as soon as the cursor is over the preview.
+        if (m_renderWindow.isVisible() && m_renderWindow.isHovered())
         {
             processShortcuts(ShortcutContext::RenderWindow);
         }
-
-        m_renderWindow.renderWindow();
     }
 
     void MainWindow::mainMenu()
@@ -1713,6 +1729,10 @@ namespace gladius::ui
     void MainWindow::markFileAsChanged()
     {
         m_fileChanged = true;
+        if (m_doc)
+        {
+            m_doc->markFileAsChanged();
+        }
     }
 
     void MainWindow::open()
@@ -1844,25 +1864,214 @@ namespace gladius::ui
             saveAs();
             return;
         }
-        bool writeThumbnail = m_computeAvailable && m_core;
-        m_doc->saveAs(m_currentAssemblyFileName.value(), writeThumbnail);
-        m_renderWindow.invalidateViewDuetoModelUpdate();
-        m_fileChanged = false;
-
-        // Add to recent files list
-        addToRecentFiles(m_currentAssemblyFileName.value());
+        enqueueNativeSave(m_currentAssemblyFileName.value());
     }
 
-    void MainWindow::saveAs()
+    void MainWindow::saveAs(std::filesystem::path defaultPath)
     {
         // Allow saving even if compute is disabled; just skip thumbnail generation.
         if (!m_doc || m_asyncFileDialog.isActive())
         {
             return;
         }
+        if (defaultPath.empty())
+        {
+            defaultPath = m_currentAssemblyFileName.value_or(std::filesystem::path{});
+        }
         m_asyncDialogOp = AsyncDialogOperation::SaveAs;
-        m_asyncFileDialog.saveFile({"*.implicit.3mf"},
-                                   m_currentAssemblyFileName.value_or(std::filesystem::path{}));
+        m_asyncFileDialog.saveFile({"*.implicit.3mf"}, defaultPath);
+    }
+
+    void MainWindow::executeSaveAs(std::filesystem::path const & savePath)
+    {
+        if (!m_doc)
+        {
+            return;
+        }
+        enqueueNativeSave(savePath);
+    }
+
+    void MainWindow::enqueueNativeSave(std::filesystem::path filename)
+    {
+        if (!m_doc)
+        {
+            return;
+        }
+
+        try
+        {
+            PendingNativeSave save{std::move(filename), m_doc->createSaveSnapshot(), m_doc};
+            if (m_nativeSaveInProgress)
+            {
+                m_pendingNativeSave = std::move(save);
+                return;
+            }
+            startNativeSave(std::move(save));
+        }
+        catch (std::exception const & e)
+        {
+            m_logger->addEvent({fmt::format("Could not capture native 3MF save snapshot: {}",
+                                            e.what()),
+                                events::Severity::Error});
+        }
+    }
+
+    void MainWindow::startNativeSave(PendingNativeSave save)
+    {
+        auto const tempFilename = makeNativeSaveTempPath(save.filename);
+        auto snapshot = std::move(save.snapshot);
+        auto const filename = save.filename;
+        auto const snapshotDocumentIdentity = snapshot.documentIdentity;
+        auto const snapshotVersion = snapshot.version;
+        auto const sourceDocument = save.sourceDocument;
+        auto logger = m_logger;
+
+        m_nativeSaveInProgress = true;
+        m_nativeSaveFuture = std::async(
+          std::launch::async,
+          [filename,
+           tempFilename,
+           snapshotDocumentIdentity,
+           snapshotVersion,
+           sourceDocument,
+           snapshot = std::move(snapshot),
+           logger]() mutable
+          {
+              NativeSaveResult result{filename,
+                                      snapshotDocumentIdentity,
+                                      snapshotVersion,
+                                      false,
+                                      {},
+                                      sourceDocument};
+              auto thumbnailInput = tempFilename;
+              thumbnailInput.replace_extension(".3mf");
+              try
+              {
+                  io::Writer3mf writer(logger);
+                  if (!writer.save(thumbnailInput, snapshot, false))
+                  {
+                      result.error = "The 3MF writer rejected the save snapshot.";
+                  }
+                  else
+                  {
+                      auto thumbnailContext =
+                        std::make_shared<ComputeContext>(EnableGLOutput::disabled);
+                      if (!thumbnailContext->isValid())
+                      {
+                          result.error = "No valid compute context is available for thumbnail "
+                                         "generation.";
+                      }
+                      else
+                      {
+                          auto thumbnailCore = std::make_shared<ComputeCore>(
+                            thumbnailContext, RequiredCapabilities::ComputeOnly, logger);
+                          auto thumbnailDocument = std::make_shared<Document>(thumbnailCore);
+                          thumbnailDocument->setUiMode(false);
+                          thumbnailDocument->load(thumbnailInput);
+
+                          if (!thumbnailCore->prepareImageRendering())
+                          {
+                              result.error = "The isolated thumbnail renderer could not prepare "
+                                             "the snapshot model.";
+                          }
+                          else
+                          {
+                              auto thumbnail = thumbnailCore->createThumbnailPng();
+                              if (!writer.attachThumbnail(snapshot.model, thumbnail.data))
+                              {
+                                  result.error = "The generated thumbnail could not be attached "
+                                                 "to the 3MF package.";
+                              }
+                              else if (!writer.save(tempFilename, snapshot, false))
+                              {
+                                  result.error = "The 3MF writer rejected the thumbnail package.";
+                              }
+                              else
+                              {
+                                  std::error_code renameError;
+                                  std::filesystem::rename(tempFilename,
+                                                          filename,
+                                                          renameError);
+                                  if (renameError)
+                                  {
+                                      result.error = fmt::format(
+                                        "Could not publish saved file: {}", renameError.message());
+                                  }
+                                  else
+                                  {
+                                      result.success = true;
+                                  }
+                              }
+                          }
+                      }
+                  }
+              }
+              catch (std::exception const & e)
+              {
+                  result.error = e.what();
+              }
+
+              std::error_code cleanupError;
+              std::filesystem::remove(tempFilename, cleanupError);
+              std::filesystem::remove(thumbnailInput, cleanupError);
+              return result;
+          });
+    }
+
+    void MainWindow::pollNativeSave()
+    {
+        if (!m_nativeSaveInProgress || !m_nativeSaveFuture.valid() ||
+            m_nativeSaveFuture.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready)
+        {
+            return;
+        }
+
+        auto result = m_nativeSaveFuture.get();
+        m_nativeSaveInProgress = false;
+
+        if (result.success)
+        {
+            bool currentDocumentWasSaved = false;
+            auto sourceDocument = result.sourceDocument.lock();
+            bool isCurrentDocument = sourceDocument && sourceDocument.get() == m_doc.get();
+            if (isCurrentDocument)
+            {
+                currentDocumentWasSaved = m_doc->completeSave(result.filename,
+                                                               result.snapshotDocumentIdentity,
+                                                               result.snapshotVersion);
+                if (currentDocumentWasSaved)
+                {
+                    m_fileChanged = false;
+                    m_currentAssemblyFileName = result.filename;
+                }
+            }
+
+            if (isCurrentDocument && !currentDocumentWasSaved)
+            {
+                m_fileChanged = true;
+            }
+            addToRecentFiles(result.filename);
+        }
+        else
+        {
+            m_logger->addEvent({fmt::format("Native 3MF save failed: {}", result.error),
+                                events::Severity::Error});
+        }
+
+        if (m_pendingNativeSave)
+        {
+            auto nextSave = std::move(*m_pendingNativeSave);
+            m_pendingNativeSave.reset();
+            startNativeSave(std::move(nextSave));
+        }
+    }
+
+        std::filesystem::path MainWindow::makeNativeSaveTempPath(
+            std::filesystem::path const & filename)
+    {
+        auto tempFilename = filename;
+        tempFilename += fmt::format(".gladius-save-{}.tmp", ++m_nativeSaveSequence);
+        return tempFilename;
     }
 
     void MainWindow::saveCurrentFunction()
@@ -2067,6 +2276,71 @@ namespace gladius::ui
         }
     }
 
+    void MainWindow::showSaveAsOverwriteConfirmation()
+    {
+        if (!m_showSaveAsOverwriteConfirmation || !m_pendingSaveAsPath)
+        {
+            return;
+        }
+
+        auto constexpr windowTitle = "File Already Exists";
+        if (!ImGui::IsPopupOpen(windowTitle))
+        {
+            ImGui::OpenPopup(windowTitle);
+        }
+        ImGuiWindowFlags const windowFlags =
+          ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings;
+
+        if (ImGui::BeginPopupModal(windowTitle, nullptr, windowFlags))
+        {
+            ImGui::NewLine();
+
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.85f, 0.0f, 1.0f));
+            ImGui::TextUnformatted(ICON_FA_EXCLAMATION_TRIANGLE " Warning");
+            ImGui::PopStyleColor();
+
+            ImGui::TextWrapped("A file with this name already exists:");
+            ImGui::TextUnformatted(m_pendingSaveAsPath->string().c_str());
+            ImGui::TextWrapped("If you overwrite it, the existing file will be permanently lost. "
+                               "We suggest selecting another file name.");
+
+            ImGui::NewLine();
+
+            // Safe action is the default / leftmost to prevent accidental overwrites.
+            if (ImGui::Button(ICON_FA_FOLDER_OPEN "\tChoose Different Name", ImVec2(220, 0)))
+            {
+                auto const fallbackPath = *m_pendingSaveAsPath;
+                m_pendingSaveAsPath.reset();
+                m_showSaveAsOverwriteConfirmation = false;
+                ImGui::CloseCurrentPopup();
+                saveAs(fallbackPath);
+            }
+
+            ImGui::SameLine();
+            if (ImGui::Button("Cancel", ImVec2(120, 0)))
+            {
+                m_pendingSaveAsPath.reset();
+                m_showSaveAsOverwriteConfirmation = false;
+                ImGui::CloseCurrentPopup();
+            }
+
+            ImGui::SameLine();
+            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.7f, 0.0f, 0.0f, 1.0f));
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.9f, 0.0f, 0.0f, 1.0f));
+            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.0f, 0.0f, 0.0f, 1.0f));
+            if (ImGui::Button(ICON_FA_TRASH "\tOverwrite Existing File", ImVec2(220, 0)))
+            {
+                executeSaveAs(*m_pendingSaveAsPath);
+                m_pendingSaveAsPath.reset();
+                m_showSaveAsOverwriteConfirmation = false;
+                ImGui::CloseCurrentPopup();
+            }
+            ImGui::PopStyleColor(3);
+
+            ImGui::EndPopup();
+        }
+    }
+
     void MainWindow::renderExportOverlay()
     {
         if (!m_exportState.isExportInProgress())
@@ -2269,6 +2543,25 @@ namespace gladius::ui
                 }
             }
 
+            // HQ progressive render progress bar - lets the user see the progressive
+            // rendering advancing and, when the view is invalidated (camera move, model
+            // update, resize), the bar resets, making aborts and restarts visible.
+            auto const hqProgress = m_renderWindow.hqProgressiveRenderProgress();
+            if (hqProgress.active)
+            {
+                ImGui::SameLine();
+                float const barHeight = ImGui::GetTextLineHeight();
+                ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.3f, 0.7f, 0.9f, 1.0f));
+                ImGui::ProgressBar(hqProgress.fraction,
+                                   ImVec2(120.0f, barHeight),
+                                   fmt::format("HQ {:.0f}%", hqProgress.fraction * 100.0f).c_str());
+                ImGui::PopStyleColor();
+                if (ImGui::IsItemHovered())
+                {
+                    ImGui::SetTooltip("High-quality progressive render progress");
+                }
+            }
+
             auto const statusText = fmt::format("{:.0f} FPS | {}{} | Render: {}",
                                                 ImGui::GetIO().Framerate,
                                                 renderModeStr,
@@ -2637,7 +2930,7 @@ namespace gladius::ui
     void MainWindow::updateModel()
     {
         // Avoid touching document/compute state while a file is being loaded on a background thread.
-        if (m_doc && m_doc->isLoadingInProgress())
+        if (m_doc && (m_doc->isLoadingInProgress() || m_asyncLoadState != AsyncLoadState::Idle))
         {
             return;
         }
@@ -2721,13 +3014,28 @@ namespace gladius::ui
             // bypass the throttle — the debounce already elapsed, we just need to retry.
             if (m_parameterThrottle.shouldRecompile() || !m_parameterThrottle.hasPendingRecompile())
             {
+                auto const parameterDispatch = async_rendering::classifyParameterChange(
+                  async_rendering::ParameterChangeDispatchInput{
+                    .mode = m_renderWindow.realtimeRaymarchMode(),
+                    .streamingPreviewActive = m_renderWindow.isStreamingPreviewActive(),
+                    .autoRealtimeActive = m_renderWindow.isRealtimeActive()});
+
                 // Streaming preview mode: the worker coroutine becomes the sole GPU
                 // writer, reading the latest Assembly values and pushing them to the
                 // parameter buffer in a tight loop.  This eliminates the UI-frame
                 // round-trip latency that limits one-shot preview scheduling.
-                if (!m_renderWindow.isStreamingPreviewActive())
+                // In Force realtime mode, parameter changes should be served by exact
+                // full-frame raymarching instead of the low-res streaming preview.
+                if (parameterDispatch.invalidateInteraction)
                 {
                     m_renderWindow.invalidateViewDueToParameterChange();
+                }
+                if (parameterDispatch.refreshStreamingInteraction)
+                {
+                    m_renderWindow.refreshStreamingParameterInteraction();
+                }
+                if (parameterDispatch.startStreamingPreview)
+                {
                     m_renderWindow.startStreamingPreview();
                 }
                 m_parameterDirty = false;
@@ -3440,6 +3748,15 @@ namespace gladius::ui
               }
               return m_doc->getNanoVdbBuildIssueSummary();
           });
+        m_meshSdfSettingsDialog.setMeshQualityIssueProvider(
+          [this]() -> MeshQualityIssueSummary
+          {
+              if (!m_doc)
+              {
+                  return {};
+              }
+              return m_doc->getMeshQualityIssueSummary();
+          });
     }
 
     void MainWindow::setVdbSupported(bool supported, std::string const & reason)
diff --git a/gladius/src/ui/MainWindow.h b/gladius/src/ui/MainWindow.h
index aea5e2b9..62e11504 100644
--- a/gladius/src/ui/MainWindow.h
+++ b/gladius/src/ui/MainWindow.h
@@ -32,6 +32,8 @@
 #include "GamepadQuickRef.h"
 
 #include <chrono>
+#include <string>
+#include <vector>
 
 namespace ed = ax::NodeEditor;
 
@@ -217,6 +219,7 @@ namespace gladius::ui
         void showExitPopUp();
         void showExportInProgressWarning();
         void showSaveBeforeFileOperationPopUp();
+        void showSaveAsOverwriteConfirmation();
         void logViewer();
         void renderStatusBar();
         void renderComputeErrorModal();
@@ -235,7 +238,8 @@ namespace gladius::ui
         void resetEditorState();
         void save();
         void updateModel();
-        void saveAs();
+        void saveAs(std::filesystem::path defaultPath = {});
+        void executeSaveAs(std::filesystem::path const & savePath);
         void saveCurrentFunction();
         void importImageStack();
 
@@ -384,9 +388,37 @@ namespace gladius::ui
         AsyncFileDialog m_asyncFileDialog;
         AsyncDialogOperation m_asyncDialogOp{AsyncDialogOperation::None};
 
+        /// @brief Path selected by Save As that already exists and waits for overwrite confirmation
+        std::optional<std::filesystem::path> m_pendingSaveAsPath;
+        /// @brief Whether to show the Save As overwrite confirmation modal
+        bool m_showSaveAsOverwriteConfirmation{false};
+
         /// @brief Process async file dialog results and execute pending operations
         void processAsyncFileDialog();
 
+                struct NativeSaveResult
+                {
+                        std::filesystem::path filename;
+                    io::DocumentIdentity snapshotDocumentIdentity{0};
+                        uint64_t snapshotVersion{0};
+                        bool success{false};
+                        std::string error;
+                    std::weak_ptr<Document> sourceDocument;
+                };
+
+                struct PendingNativeSave
+                {
+                        std::filesystem::path filename;
+                        io::SaveSnapshot snapshot;
+                        std::weak_ptr<Document> sourceDocument;
+                };
+
+                void enqueueNativeSave(std::filesystem::path filename);
+                void startNativeSave(PendingNativeSave save);
+                void pollNativeSave();
+                [[nodiscard]] std::filesystem::path makeNativeSaveTempPath(
+                    std::filesystem::path const & filename);
+
         // Export state for blocking UI modifications during mesh export
         ExportState m_exportState;
 
@@ -412,6 +444,12 @@ namespace gladius::ui
         /// @brief Future for async compute initialization
         std::future<ComputeEnumResult> m_computeInitFuture;
 
+        /// @brief Active background native 3MF save. The worker owns only snapshot data.
+        std::future<NativeSaveResult> m_nativeSaveFuture;
+        std::optional<PendingNativeSave> m_pendingNativeSave;
+        uint64_t m_nativeSaveSequence{0};
+        bool m_nativeSaveInProgress{false};
+
         /// @brief Start async compute initialization
         void startAsyncComputeInit();
 
diff --git a/gladius/src/ui/MeshExportDialog.cpp b/gladius/src/ui/MeshExportDialog.cpp
index 063b05ab..06b5b2c8 100644
--- a/gladius/src/ui/MeshExportDialog.cpp
+++ b/gladius/src/ui/MeshExportDialog.cpp
@@ -103,6 +103,27 @@ namespace gladius::ui
             }
             return stem;
         }
+
+        [[nodiscard]] bool supportsShellExport(io::SurfaceExtractionMethod method) noexcept
+        {
+            return method == io::SurfaceExtractionMethod::LayeredMarchingCubes ||
+                   method == io::SurfaceExtractionMethod::ManifoldDualContouring;
+        }
+
+        [[nodiscard]] io::ShellGenerationMode shellGenerationModeFor(
+            io::SurfaceExtractionMethod method) noexcept
+        {
+            return method == io::SurfaceExtractionMethod::LayeredMarchingCubes
+                ? io::ShellGenerationMode::OpenVdbColorThickness
+                : io::ShellGenerationMode::LegacyManifoldDualContouring;
+        }
+
+        [[nodiscard]] char const * shellBackendLabelFor(io::SurfaceExtractionMethod method) noexcept
+        {
+            return method == io::SurfaceExtractionMethod::LayeredMarchingCubes
+                ? "OpenVDB color-thickness shells"
+                : "Legacy manifold dual contouring shells";
+        }
     }
 
     template <typename Exporter>
@@ -876,8 +897,7 @@ namespace gladius::ui
                 auto const & precomputedLuts = m_colorToThicknessDialog.getPrecomputedLuts();
                 bool const lutReady = !precomputedLuts.empty();
                 int const lutResolution = m_colorToThicknessDialog.getLutResolution();
-                bool const shellExportSupported = colorExportAvailable &&
-                    (m_selectedMethod == io::SurfaceExtractionMethod::ManifoldDualContouring);
+                bool const shellExportSupported = colorExportAvailable && supportsShellExport(m_selectedMethod);
 
                 ImGui::BeginDisabled(!shellExportSupported);
                 ImGui::Checkbox("Export shells with LUT", &m_enableShellBasedExport);
@@ -885,22 +905,43 @@ namespace gladius::ui
                 {
                         ImGui::SetTooltip(
                             "Shell-based export requires 3MF format, volumetric color, "
-                            "and the Manifold Dual Contouring method.");
+                            "and a shell-capable extraction method selected in the Mesh Extraction tab.");
                 }
                 ImGui::SameLine();
                 ImGui::TextDisabled("One build item per shell with solid colors.");
                 ImGui::EndDisabled();
 
+                ImGui::BeginDisabled(!shellExportSupported || !m_enableShellBasedExport);
+                ImGui::Indent();
+                ImGui::Text("Shell backend: %s", shellBackendLabelFor(m_selectedMethod));
+                if (ImGui::IsItemHovered())
+                {
+                    ImGui::SetTooltip(
+                        "Shell export uses the method selected in the Mesh Extraction tab.\n"
+                        "Choose layered marching cubes for the OpenVDB path or manifold dual contouring for the legacy shell path.");
+                }
+                if (m_selectedMethod == io::SurfaceExtractionMethod::LayeredMarchingCubes)
+                {
+                    ImGui::TextColored(ImVec4(1.0F, 0.8F, 0.2F, 1.0F),
+                                       "Current scope: constant-thickness shell bands and surface-driven variable shell depths.");
+                }
+                else
+                {
+                    ImGui::TextDisabled("Current scope: legacy manifold shell generation.");
+                }
+                ImGui::Unindent();
+                ImGui::EndDisabled();
+
                 // Surface color sampling option (nested under shell export)
                 ImGui::BeginDisabled(!shellExportSupported || !m_enableShellBasedExport);
                 ImGui::Indent();
                 ImGui::Checkbox("Use surface color sampling", &m_useSurfaceColorSampling);
                 if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
                 {
-                        ImGui::SetTooltip(
-                            "Sample colors at the model surface (SDF=0) instead of interior.\n"
-                            "This fixes color accuracy for projected images and textures.\n"
-                            "Recommended for HueForge-style multi-color prints.");
+                    ImGui::SetTooltip(
+                        "Sample colors at the model surface (SDF=0) instead of interior.\n"
+                        "This fixes color accuracy for projected images and textures.\n"
+                        "Recommended for HueForge-style multi-color prints.");
                 }
                 ImGui::Unindent();
                 ImGui::EndDisabled();
@@ -1088,12 +1129,12 @@ namespace gladius::ui
             return;
         }
 
-        // Only support manifold dual contouring for palette derivation (matches color export path)
-        if (m_selectedMethod != io::SurfaceExtractionMethod::ManifoldDualContouring)
+                if (m_selectedMethod == io::SurfaceExtractionMethod::DualContouring)
         {
             m_colorToThicknessDialog.notifyPaletteDeriveFailed(
-              "Palette derivation is only available with manifold dual contouring.");
-            m_statusMessage = "Palette derivation currently supported only for Manifold dual contouring.";
+                            "Palette derivation is not implemented for dual contouring.");
+                        m_statusMessage =
+                            "Palette derivation currently supports OpenVDB and manifold dual contouring.";
             m_statusIsError = true;
             return;
         }
@@ -1119,8 +1160,10 @@ namespace gladius::ui
 
         auto * core = m_computeCore;
         io::PaletteExtractionOptions paletteOptions{};
+        paletteOptions.method = m_selectedMethod;
+        paletteOptions.marchingCubesQualityLevel = m_marchingCubesQuality;
         paletteOptions.manifoldOptions = options;
-        paletteOptions.convertToSrgb = m_convertToSrgb;
+        paletteOptions.convertToSrgb = true;
 
         m_paletteDeriveInProgress = true;
         m_colorToThicknessDialog.notifyPaletteDeriveStarted();
@@ -1189,6 +1232,7 @@ namespace gladius::ui
 
         // Build shell export config
         io::ShellExportConfig config;
+        config.generationMode = shellGenerationModeFor(m_selectedMethod);
         config.filamentStack = std::move(stack);
         config.precomputedLuts = precomputedLuts;
         config.lutResolution = lutResolution;
@@ -1223,8 +1267,7 @@ namespace gladius::ui
 
                 bool const is3mf = (m_outputFormat == MeshOutputFormat::ThreeMF);
                 bool const wantsShellExport =
-                    is3mf && m_enableShellBasedExport &&
-                    m_selectedMethod == io::SurfaceExtractionMethod::ManifoldDualContouring;
+                    is3mf && m_enableShellBasedExport && supportsShellExport(m_selectedMethod);
 
                 if (wantsShellExport && !m_colorToThicknessDialog.hasPrecomputedLuts())
                 {
@@ -1242,7 +1285,6 @@ namespace gladius::ui
                         }
                 }
 
-                bool const shellLutReady = m_colorToThicknessDialog.hasPrecomputedLuts();
                 bool const is3mfMethodAllowed =
                     m_selectedMethod == io::SurfaceExtractionMethod::LayeredMarchingCubes ||
                     m_selectedMethod == io::SurfaceExtractionMethod::ManifoldDualContouring;
@@ -1251,10 +1293,16 @@ namespace gladius::ui
                 {
                         throw std::runtime_error(
                             "3MF export is currently only supported with layered marching cubes, "
-                            "manifold dual contouring, or shell-based hierarchical dual contouring when LUTs are "
-                            "available.");
+                            "manifold dual contouring, or shell-based export when a shell-capable extraction "
+                            "method is selected.");
                 }
 
+        if (wantsShellExport)
+        {
+            exportShellsTo3mf(core);
+            return;
+        }
+
         switch (m_selectedMethod)
         {
         case io::SurfaceExtractionMethod::LayeredMarchingCubes:
@@ -1300,12 +1348,6 @@ namespace gladius::ui
         }
         case io::SurfaceExtractionMethod::ManifoldDualContouring:
         {
-            if (is3mf && wantsShellExport)
-            {
-                exportShellsTo3mf(core);
-                return;
-            }
-
             io::ManifoldDualContouringOptions options{};
             options.qualityPreset = m_manifoldQualityPreset;
             options.applyPreset();
diff --git a/gladius/src/ui/MeshSdfSettingsDialog.cpp b/gladius/src/ui/MeshSdfSettingsDialog.cpp
index 70a36b70..a117cd66 100644
--- a/gladius/src/ui/MeshSdfSettingsDialog.cpp
+++ b/gladius/src/ui/MeshSdfSettingsDialog.cpp
@@ -21,6 +21,11 @@ namespace gladius::ui
         m_nanovdbIssueProvider = std::move(provider);
     }
 
+    void MeshSdfSettingsDialog::setMeshQualityIssueProvider(MeshQualityIssueProvider provider)
+    {
+        m_meshQualityIssueProvider = std::move(provider);
+    }
+
     void MeshSdfSettingsDialog::show()
     {
         syncFromSettings();
@@ -92,6 +97,38 @@ namespace gladius::ui
         // ---- Evaluation method ------------------------------------------------
         if (ImGui::CollapsingHeader("Evaluation", ImGuiTreeNodeFlags_DefaultOpen))
         {
+            if (m_meshQualityIssueProvider)
+            {
+                auto const qualityIssue = m_meshQualityIssueProvider();
+                if (qualityIssue.hasIssue)
+                {
+                    ImGui::TextColored(ImVec4(1.0f, 0.68f, 0.18f, 1.0f),
+                                       "Mesh topology diagnostics detected");
+                    ImGui::PushTextWrapPos(ImGui::GetFontSize() * 46.0f);
+                    ImGui::TextUnformatted(qualityIssue.message.c_str());
+                    ImGui::PopTextWrapPos();
+                    ImGui::TextDisabled(
+                      "No silent repair or fallback was applied; choose an explicit recovery and Apply.");
+
+                    if (ImGui::Button("Enable repair for next import"))
+                    {
+                        m_repair.weld = true;
+                        m_repair.removeDegenerate = true;
+                        m_repair.orientConsistently = true;
+                        m_repair.fillHoles = true;
+                        m_dirty = true;
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::Button("Use FWN sign"))
+                    {
+                        m_eval.method = MeshSdfMethod::FastWindingNumber;
+                        m_eval.fwnUseSignCache = false;
+                        m_dirty = true;
+                    }
+                    ImGui::Separator();
+                }
+            }
+
             char const * preview = methodLabel(m_eval.method);
             if (ImGui::BeginCombo("Method", preview))
             {
diff --git a/gladius/src/ui/MeshSdfSettingsDialog.h b/gladius/src/ui/MeshSdfSettingsDialog.h
index 6ec5961a..81f386d7 100644
--- a/gladius/src/ui/MeshSdfSettingsDialog.h
+++ b/gladius/src/ui/MeshSdfSettingsDialog.h
@@ -24,6 +24,7 @@ namespace gladius::ui
       public:
         using ApplyCallback = std::function<void()>;
         using NanoVdbIssueProvider = std::function<NanoVdbBuildIssueSummary()>;
+        using MeshQualityIssueProvider = std::function<MeshQualityIssueSummary()>;
 
         MeshSdfSettingsDialog() = default;
         ~MeshSdfSettingsDialog() = default;
@@ -42,6 +43,9 @@ namespace gladius::ui
         /// Provide the callback used to query runtime NanoVDB build issues.
         void setNanoVdbIssueProvider(NanoVdbIssueProvider provider);
 
+        /// Provide the callback used to query runtime mesh-quality diagnostics.
+        void setMeshQualityIssueProvider(MeshQualityIssueProvider provider);
+
         void show();
         void hide();
         [[nodiscard]] bool isVisible() const noexcept;
@@ -60,6 +64,7 @@ namespace gladius::ui
         MeshSdfSettings * m_settings = nullptr;
         ApplyCallback m_applyCallback;
         NanoVdbIssueProvider m_nanovdbIssueProvider;
+        MeshQualityIssueProvider m_meshQualityIssueProvider;
 
         bool m_visible = false;
         bool m_dirty = false;
diff --git a/gladius/src/ui/ModelEditor.cpp b/gladius/src/ui/ModelEditor.cpp
index da723860..959aa082 100644
--- a/gladius/src/ui/ModelEditor.cpp
+++ b/gladius/src/ui/ModelEditor.cpp
@@ -1862,7 +1862,15 @@ namespace gladius::ui
 
                 // Export overlay is now rendered at MainWindow level to block entire UI
 
-                if (m_nodeViewVisitor.haveParameterChanged())
+                // Read per-frame flags before clearing them. clearPerFrameFlags() is called
+                // unconditionally BEFORE storeState() so that if storeState() throws, the
+                // flags are already cleared and won't re-trigger the same exception every
+                // subsequent frame (which would flood the ImGui log and cause a segfault).
+                bool const nodeViewParamChanged = m_nodeViewVisitor.haveParameterChanged();
+                m_modelWasModified |= m_nodeViewVisitor.hasModelChanged();
+                m_nodeViewVisitor.clearPerFrameFlags();
+
+                if (nodeViewParamChanged)
                 {
                     m_dirty = true;
                     parameterChanged = true;
@@ -1877,14 +1885,6 @@ namespace gladius::ui
                     }
                 }
 
-                m_modelWasModified |= m_nodeViewVisitor.hasModelChanged();
-
-                // Clear per-frame flags so they don't persist into the next frame.
-                // Without this, a single parameter change causes showAndEdit() to
-                // return true every subsequent frame, continuously bumping the async
-                // epoch and preventing HQ progressive rendering from ever starting.
-                m_nodeViewVisitor.clearPerFrameFlags();
-
                 if (m_currentTabMode == TabMode::Graph)
                 {
                     updateInitialAutoLayoutReadiness();
@@ -1908,6 +1908,11 @@ namespace gladius::ui
         }
         catch (std::exception const & e)
         {
+            // Ensure ImGui window state is properly terminated even when an exception
+            // is thrown inside the Begin/End block, otherwise ImGui becomes corrupt.
+            ImGui::End();
+            ImGui::PopStyleVar();
+
             if (m_doc && m_doc->getSharedLogger())
             {
                 m_doc->getSharedLogger()->addEvent(
@@ -2280,6 +2285,14 @@ namespace gladius::ui
             targetFunctionName = fileInfo.libraryFunctionNames.front();
         }
 
+        // Extract example constants from the library file before pruning modifies it.
+        std::vector<io::ExampleConstantValue> exampleConstants;
+        if (!targetFunctionName.empty())
+        {
+            exampleConstants =
+              io::extractExampleConstants(fileInfo.filePath, targetFunctionName);
+        }
+
         // Refresh the assembly pointer — the document may have replaced it
         // since we last captured it (e.g. during file load).
         refreshAssembly();
@@ -2309,11 +2322,13 @@ namespace gladius::ui
             return;
         }
 
-        createFunctionCallNodeAtCursor(match.id, match.model);
+        createFunctionCallNodeAtCursor(match.id, match.model, exampleConstants);
     }
 
-    void ModelEditor::createFunctionCallNodeAtCursor(nodes::ResourceId functionId,
-                                                      nodes::SharedModel const & sourceModel)
+    void ModelEditor::createFunctionCallNodeAtCursor(
+      nodes::ResourceId functionId,
+      nodes::SharedModel const & sourceModel,
+      std::vector<io::ExampleConstantValue> const & exampleConstants)
     {
         createUndoRestorePoint("Import library function");
 
@@ -2328,6 +2343,82 @@ namespace gladius::ui
         auto * createdNode = m_currentModel->createFunctionCallNode(functionId, *sourceModel);
         ed::SetNodePosition(createdNode->getId(), posOnCanvas);
 
+        // Create pre-wired constant nodes for any argument that has an example value.
+        if (!exampleConstants.empty())
+        {
+            auto const & arguments = createdNode->getArguments();
+            constexpr float kConstantOffsetX = -250.0f;
+            constexpr float kConstantSpacingY = 80.0f;
+
+            int constantIndex = 0;
+            for (auto const & argument : arguments)
+            {
+                auto const & argName = argument.first;
+                auto const & argParam = argument.second;
+                auto it = std::find_if(
+                  exampleConstants.begin(),
+                  exampleConstants.end(),
+                  [&argName](io::ExampleConstantValue const & cv)
+                  { return cv.parameterName == argName; });
+
+                if (it == exampleConstants.end())
+                {
+                    continue;
+                }
+
+                ImVec2 const constPos{posOnCanvas.x + kConstantOffsetX,
+                                      posOnCanvas.y + constantIndex * kConstantSpacingY};
+
+                if (it->kind == io::ExampleConstantValue::Kind::Scalar)
+                {
+                    auto * constNode = m_currentModel->create<ConstantScalar>();
+                    constNode->parameter().at(FieldNames::Value).setValue(it->scalarValue);
+                    constNode->setDisplayName(NodeName(argName));
+                    ed::SetNodePosition(constNode->getId(), constPos);
+                    m_currentModel->addLink(constNode->getValueOutputPort().getId(),
+                                            argParam->getId());
+                }
+                else if (it->kind == io::ExampleConstantValue::Kind::Vector)
+                {
+                    auto * constNode = m_currentModel->create<ConstantVector>();
+                    constNode->parameter().at(FieldNames::X).setValue(it->vectorValue.x);
+                    constNode->parameter().at(FieldNames::Y).setValue(it->vectorValue.y);
+                    constNode->parameter().at(FieldNames::Z).setValue(it->vectorValue.z);
+                    constNode->setDisplayName(NodeName(argName));
+                    ed::SetNodePosition(constNode->getId(), constPos);
+                    m_currentModel->addLink(constNode->getVectorOutputPort().getId(),
+                                            argParam->getId());
+                }
+                else if (it->kind == io::ExampleConstantValue::Kind::Matrix)
+                {
+                    auto * constNode = m_currentModel->create<ConstantMatrix>();
+                    auto const & mat = it->matrixValue;
+                    constNode->parameter().at(FieldNames::M00).setValue(mat[0][0]);
+                    constNode->parameter().at(FieldNames::M01).setValue(mat[0][1]);
+                    constNode->parameter().at(FieldNames::M02).setValue(mat[0][2]);
+                    constNode->parameter().at(FieldNames::M03).setValue(mat[0][3]);
+                    constNode->parameter().at(FieldNames::M10).setValue(mat[1][0]);
+                    constNode->parameter().at(FieldNames::M11).setValue(mat[1][1]);
+                    constNode->parameter().at(FieldNames::M12).setValue(mat[1][2]);
+                    constNode->parameter().at(FieldNames::M13).setValue(mat[1][3]);
+                    constNode->parameter().at(FieldNames::M20).setValue(mat[2][0]);
+                    constNode->parameter().at(FieldNames::M21).setValue(mat[2][1]);
+                    constNode->parameter().at(FieldNames::M22).setValue(mat[2][2]);
+                    constNode->parameter().at(FieldNames::M23).setValue(mat[2][3]);
+                    constNode->parameter().at(FieldNames::M30).setValue(mat[3][0]);
+                    constNode->parameter().at(FieldNames::M31).setValue(mat[3][1]);
+                    constNode->parameter().at(FieldNames::M32).setValue(mat[3][2]);
+                    constNode->parameter().at(FieldNames::M33).setValue(mat[3][3]);
+                    constNode->setDisplayName(NodeName(argName));
+                    ed::SetNodePosition(constNode->getId(), constPos);
+                    m_currentModel->addLink(constNode->getMatrixOutputPort().getId(),
+                                            argParam->getId());
+                }
+
+                ++constantIndex;
+            }
+        }
+
         requestNodeFocus(createdNode->getId());
         markModelAsModified();
     }
diff --git a/gladius/src/ui/ModelEditor.h b/gladius/src/ui/ModelEditor.h
index c54389fa..69287c9d 100644
--- a/gladius/src/ui/ModelEditor.h
+++ b/gladius/src/ui/ModelEditor.h
@@ -30,6 +30,7 @@
 
 #include "Outline.h"
 #include "ResourceView.h"
+#include "io/3mf/LibraryExampleExtractor.h"
 #include "io/VdbImporter.h"
 #include "Style.h"
 #include "compute/ComputeCore.h"
@@ -257,10 +258,14 @@ namespace gladius::ui
         void importStlDrop(std::filesystem::path const & path, ImVec2 screenPos);
 
         /// @brief Create a FunctionCall node at the current cursor position.
-        /// @param functionId The resource ID of the function to call.
-        /// @param sourceModel The model providing inputs/outputs for the FunctionCall.
-        void createFunctionCallNodeAtCursor(nodes::ResourceId functionId,
-                                            nodes::SharedModel const & sourceModel);
+        /// @param functionId      The resource ID of the function to call.
+        /// @param sourceModel     The model providing inputs/outputs for the FunctionCall.
+        /// @param exampleConstants Optional constant nodes (with example values) to create and
+        ///                         wire to the FunctionCall arguments.
+        void createFunctionCallNodeAtCursor(
+          nodes::ResourceId functionId,
+          nodes::SharedModel const & sourceModel,
+          std::vector<io::ExampleConstantValue> const & exampleConstants = {});
 
         // Helper method to check if a string matches the current filter
         bool matchesNodeFilter(const std::string & text) const;
diff --git a/gladius/src/ui/OrbitalCamera.cpp b/gladius/src/ui/OrbitalCamera.cpp
index f6f8aeac..3ed609ca 100644
--- a/gladius/src/ui/OrbitalCamera.cpp
+++ b/gladius/src/ui/OrbitalCamera.cpp
@@ -1,5 +1,6 @@
 #include "OrbitalCamera.h"
 #include <CL/cl_platform.h>
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <eigen3/Eigen/Core>
@@ -104,17 +105,9 @@ namespace gladius::ui
     bool OrbitalCamera::update(float deltaTime_ms)
     {
         bool changed = false;
-        auto constexpr tolerance = 0.0001f;
+        auto constexpr tolerance = 0.1f;
         auto const speedFactor = 15.E-3f;
-        // if (deltaTime_ms > 50.f)
-        {
-            m_pitch = m_pitchTarget;
-            m_yaw = m_yawTarget;
-            m_eyeDist = m_eyeDistTarget;
-            m_lookAt = m_lookAtTarget;
-            return false;
-        }
-        // deltaTime_ms = std::min(deltaTime_ms, 50.f);
+        deltaTime_ms = std::min(deltaTime_ms, 50.f);
 
         auto const pitchDelta = (m_pitchTarget - m_pitch);
         if (fabs(pitchDelta) > tolerance)
@@ -147,6 +140,14 @@ namespace gladius::ui
         return changed;
     }
 
+    void OrbitalCamera::snapToTarget()
+    {
+        m_pitch = m_pitchTarget;
+        m_yaw = m_yawTarget;
+        m_eyeDist = m_eyeDistTarget;
+        m_lookAt = m_lookAtTarget;
+    }
+
     void OrbitalCamera::centerView(BoundingBox const & bbox)
     {
         m_lookAtTarget = {(bbox.max.x + bbox.min.x) * 0.5f,
@@ -311,19 +312,3 @@ namespace gladius::ui
         m_lookAtTarget = lookAt;
     }
 }
-// Alternative MVP-based approach (for reference):
-// We could also use a proper 4x4 view matrix and transform the corners:
-//
-// Eigen::Matrix4f viewMatrix;
-// viewMatrix.setIdentity();
-// viewMatrix.block<3,1>(0,0) = uu;  // right
-// viewMatrix.block<3,1>(0,1) = vv;  // up
-// viewMatrix.block<3,1>(0,2) = ww;  // forward
-// viewMatrix.block<3,1>(0,3) = -(viewMatrix.block<3,3>(0,0) * eyePos);  // translation
-//
-// Then for each corner:
-// Eigen::Vector4f homogeneousCorner(corner.x(), corner.y(), corner.z(), 1.0f);
-// Eigen::Vector4f cameraSpaceCorner = viewMatrix * homogeneousCorner;
-// float cameraX = cameraSpaceCorner.x();
-// float cameraY = cameraSpaceCorner.y();
-// float cameraZ = cameraSpaceCorner.z();
\ No newline at end of file
diff --git a/gladius/src/ui/OrbitalCamera.h b/gladius/src/ui/OrbitalCamera.h
index c77d8dd6..8a42fc1e 100644
--- a/gladius/src/ui/OrbitalCamera.h
+++ b/gladius/src/ui/OrbitalCamera.h
@@ -24,6 +24,9 @@ namespace gladius::ui
         auto computeModelViewPerspectiveMatrix() const -> cl_float16;
         bool update(float deltaTime_ms);
 
+        /// @brief Immediately applies all target camera values without interpolation.
+        void snapToTarget();
+
         void centerView(BoundingBox const & bbox);
         void
         adjustDistanceToTarget(BoundingBox const & bbox, float viewportWidth, float viewportHeight);
diff --git a/gladius/src/ui/RenderWindow.cpp b/gladius/src/ui/RenderWindow.cpp
index a9fd48e2..b00bd79f 100644
--- a/gladius/src/ui/RenderWindow.cpp
+++ b/gladius/src/ui/RenderWindow.cpp
@@ -5,6 +5,8 @@
 #include <coroutine>
 #include <cstddef>
 #include <fmt/core.h>
+#include <iterator>
+#include <thread>
 
 #include "../CLMath.h"
 #include "../ComputeContext.h"
@@ -23,6 +25,11 @@
 #include "OverflowMenuBar.h"
 #include "compute/ComputeCore.h"
 #include "imgui.h"
+#include "render/DisplayFrameSelector.h"
+#include "render/ProgressiveBufferPolicy.h"
+#include "render/RenderModeUpdatePolicy.h"
+#include "render/PreviewBackendPolicy.h"
+#include "render/PreviewResultAcceptancePolicy.h"
 #include <nodes/Model.h>
 
 namespace gladius::ui
@@ -109,6 +116,37 @@ namespace gladius::ui
             co_await ClEventAwaiter(std::move(event));
         }
 
+        [[nodiscard]] bool waitForEventBlocking(cl::Event const & event)
+        {
+            if (!event())
+            {
+                return false;
+            }
+
+            while (true)
+            {
+                try
+                {
+                    cl_int status = CL_QUEUED;
+                    event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS, &status);
+                    if (status == CL_COMPLETE)
+                    {
+                        return true;
+                    }
+                    if (status < 0)
+                    {
+                        return false;
+                    }
+                }
+                catch (...)
+                {
+                    return false;
+                }
+
+                std::this_thread::sleep_for(std::chrono::microseconds(500));
+            }
+        }
+
         constexpr size_t kInitialProgressiveStepSize = 8;
         constexpr float kAdaptivePreviewTargetFrameTimeMs = 25.0f;
         constexpr float kAdaptivePreviewMinErrorMs = 0.5f;
@@ -119,7 +157,58 @@ namespace gladius::ui
         constexpr float kAdaptivePreviewMinQuality = 0.05f;
         constexpr float kAdaptivePreviewMinDimension = 1.0f;
         constexpr float kAdaptivePreviewMaxDimension = 16000.0f;
-        constexpr float kAdaptivePreviewResizeThresholdPercent = 5.0f;
+        constexpr float kAdaptivePreviewResizeThresholdPercent = 20.0f;
+
+        struct AsyncPreviewLaunch
+        {
+            cl::Event event{};
+            bool producedDistanceInit{false};
+        };
+
+        [[nodiscard]] AsyncPreviewLaunch launchAsyncPreviewRender(
+          ComputeCore & core,
+          cl::CommandQueue const & commandQueue,
+          ImageRGBA & lowResImage)
+        {
+            auto const backend = async_rendering::choosePreviewBackend(
+              async_rendering::PreviewBackendInput{.rendererReady = core.isRendererReady(),
+                                                   .lowResTargetAvailable = true,
+                                                   .precomputedSdfValid = core.isSdfValid(),
+                                                   .allowDynamicFullModelFallback = true});
+
+            AsyncPreviewLaunch launch{};
+            switch (backend)
+            {
+            case async_rendering::PreviewBackend::PrecomputedSdfWithDistanceInit:
+                launch.event =
+                  core.renderLowResPreviewWithDistanceOutputAsync(commandQueue, lowResImage);
+                launch.producedDistanceInit = launch.event();
+                return launch;
+
+            case async_rendering::PreviewBackend::DynamicFullModel:
+            {
+                auto settings = core.getResourceContext()->getRenderingSettings();
+                settings.approximation = AM_FULL_MODEL;
+                settings.flags |= RF_DISABLE_SHADOWS | RF_DISABLE_AO;
+                bool const advanced = core.renderSceneComputeOnlyWithSettings(
+                  commandQueue,
+                  0,
+                  static_cast<size_t>(lowResImage.getHeight()),
+                  lowResImage,
+                  settings,
+                  &launch.event);
+                if (!advanced)
+                {
+                    launch.event = cl::Event{};
+                }
+                return launch;
+            }
+
+            case async_rendering::PreviewBackend::None:
+            default:
+                return launch;
+            }
+        }
     }
 
     void RenderWindow::initialize(ComputeCore * core,
@@ -147,6 +236,9 @@ namespace gladius::ui
               m_configManager->getValue<bool>("renderWindow", "permanentCenteringEnabled", false);
         }
 
+        auto const realtimeConfig = loadRealtimeRaymarchConfig();
+        m_renderUpdateCoordinator.configureRealtime(realtimeConfig);
+
         // Don't initialize async rendering here - will be done lazily on first render
     }
 
@@ -202,11 +294,18 @@ namespace gladius::ui
             m_asyncController->start();
             m_asyncEpochCounter.store(0, std::memory_order_release);
             m_asyncCurrentEpoch.store(0, std::memory_order_release);
+            m_asyncViewEpoch.store(0, std::memory_order_release);
             m_asyncInFlightEpoch.store(0, std::memory_order_release);
+            m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
             m_asyncFrameCounter.store(0, std::memory_order_release);
             m_asyncJobInFlight.store(false, std::memory_order_release);
+            m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+            m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
             m_asyncSdfJobInFlight.store(false, std::memory_order_release);
             m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
+            m_renderUpdateCoordinator = async_rendering::RenderUpdateCoordinator{};
+            m_renderUpdateCoordinator.configureRealtime(loadRealtimeRaymarchConfig());
+            m_pendingRenderCommands.clear();
             notifyAsyncEpochIncrement();
         }
         else
@@ -218,9 +317,13 @@ namespace gladius::ui
             }
             m_asyncEpochCounter.store(0, std::memory_order_release);
             m_asyncCurrentEpoch.store(0, std::memory_order_release);
+            m_asyncViewEpoch.store(0, std::memory_order_release);
             m_asyncInFlightEpoch.store(0, std::memory_order_release);
+            m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
             m_asyncFrameCounter.store(0, std::memory_order_release);
             m_asyncJobInFlight.store(false, std::memory_order_release);
+            m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+            m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
             m_asyncSdfJobInFlight.store(false, std::memory_order_release);
             m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
         }
@@ -237,11 +340,7 @@ namespace gladius::ui
         auto const oldEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
         auto const newEpoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
         m_asyncCurrentEpoch.store(newEpoch, std::memory_order_release);
-        m_asyncInFlightEpoch.store(0, std::memory_order_release);
-        m_asyncJobInFlight.store(false, std::memory_order_release);
-        m_asyncSdfJobInFlight.store(false, std::memory_order_release);
-        m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
-        m_asyncBboxJobInFlight.store(false, std::memory_order_release);
+        m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel);
         
         // Invalidate distance init buffer on epoch change - camera/scene changed (FR-005)
         if (m_core)
@@ -249,24 +348,401 @@ namespace gladius::ui
             m_core->invalidateDistanceInitBuffer();
         }
 
-        // Release progressive buffer on epoch change
-        if (m_asyncProgressiveBuffer)
+        // Do not release Writing buffers or clear in-flight render flags here. Once an OpenCL
+        // kernel has been submitted, the buffer remains GPU-owned until the worker observes the
+        // completion event. Recycling it early can race a later render/parameter upload against
+        // memory still used by the old kernel, which is illegal on several OpenCL stacks.
+        if (m_asyncController)
+        {
+            m_asyncController->releaseStaleBuffers(oldEpoch);
+            m_asyncController->setLatestEpoch(newEpoch);
+        }
+    }
+
+    void RenderWindow::invalidateCameraView()
+    {
+        ProfileFunction;
+        m_dirty = true;
+        // Camera interaction supersedes parameter streaming. Leaving the streaming flag
+        // latched blocks realtime admission and makes Force mode hold a stale frame even
+        // when no exact realtime job is actually in flight.
+        m_streamingPreviewActive.store(false, std::memory_order_release);
+        m_streamingFrameConsumed.store(true, std::memory_order_release);
+        m_renderWindowState.isMoving = true;
+        m_renderWindowState.currentLine = 0;
+        m_renderWindowState.renderingStepSize = kInitialProgressiveStepSize;
+        m_renderWindowState.isRendering = false;
+        bool const forceLowResPreview =
+            m_renderUpdateCoordinator.realtimeConfig().mode == async_rendering::RealtimeRaymarchMode::Off;
+        m_forceLowResRenderOnNextFrame.store(forceLowResPreview, std::memory_order_release);
+        if (forceLowResPreview)
+        {
+            m_lastLowResRenderTime = std::chrono::system_clock::now();
+        }
+        else
+        {
+            m_lowResFeedbackPending.store(false, std::memory_order_release);
+        }
+        m_suppressHQDisplay.store(false, std::memory_order_release);
+        auto const newViewEpoch = m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel) + 1;
+        if (m_asyncController)
+        {
+            m_asyncController->setLatestViewEpoch(newViewEpoch);
+        }
+        queueRenderDecision(m_renderUpdateCoordinator.notifyCameraChanged());
+
+        if (m_core)
+        {
+            m_core->invalidateDistanceInitBuffer();
+        }
+
+        if (m_asyncController && m_asyncProgressiveBuffer &&
+            !m_asyncJobInFlight.load(std::memory_order_acquire))
         {
             [[maybe_unused]] bool const released =
               m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
                                                      async_rendering::FrameState::Writing,
                                                      async_rendering::FrameState::Idle);
             m_asyncProgressiveBuffer = nullptr;
+            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+            m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
         }
-        m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+    }
 
-        // IMPORTANT: Release any other Writing buffers from old epoch
-        // (they belong to cancelled jobs and should be returned to Idle)
-        if (m_asyncController)
+    async_rendering::RealtimeRaymarchConfig RenderWindow::loadRealtimeRaymarchConfig() const
+    {
+        async_rendering::RealtimeRaymarchConfig config{};
+        if (!m_configManager)
         {
-            m_asyncController->releaseStaleBuffers(oldEpoch);
-            m_asyncController->setLatestEpoch(newEpoch);
+            return config;
+        }
+
+        auto const mode = m_configManager->getValue<std::string>(
+          "renderWindow", "realtimeRaymarchMode", "auto");
+        config.mode = async_rendering::realtimeRaymarchModeFromString(mode);
+        config.targetFrameTimeMs =
+          m_configManager->getValue<float>("renderWindow", "realtimeRaymarchTargetMs", 25.0f);
+        return config;
+    }
+
+    void RenderWindow::saveRealtimeRaymarchMode(
+      async_rendering::RealtimeRaymarchMode mode) const
+    {
+        if (!m_configManager)
+        {
+            return;
+        }
+
+        m_configManager->setValue("renderWindow",
+                                  "realtimeRaymarchMode",
+                                  std::string(async_rendering::realtimeRaymarchModeToString(mode)));
+        m_configManager->save();
+    }
+
+    void RenderWindow::queueRenderDecision(async_rendering::RenderUpdateDecision decision)
+    {
+        m_pendingRenderCommands.insert(m_pendingRenderCommands.end(),
+                                       std::make_move_iterator(decision.commands.begin()),
+                                       std::make_move_iterator(decision.commands.end()));
+    }
+
+    bool RenderWindow::executeQueuedRenderCommands(RenderWindowState & state)
+    {
+        bool startedWork = false;
+        size_t processedCommands = 0;
+        while (!m_pendingRenderCommands.empty() && processedCommands < 64)
+        {
+            auto command = std::move(m_pendingRenderCommands.front());
+            m_pendingRenderCommands.erase(m_pendingRenderCommands.begin());
+            startedWork = executeRenderCommand(command, state) || startedWork;
+            ++processedCommands;
+        }
+        return startedWork;
+    }
+
+    bool RenderWindow::executeRenderCommand(async_rendering::RenderCommand const & command,
+                                            RenderWindowState & state)
+    {
+        if (command.type != async_rendering::RenderCommandType::StartTask)
+        {
+            return false;
+        }
+
+        return scheduleCoordinatorTask(command.task, state);
+    }
+
+    bool RenderWindow::scheduleCoordinatorTask(async_rendering::RenderTaskRequest const & task,
+                                               RenderWindowState & state)
+    {
+        auto const failTask = [&]()
+        { completeCoordinatorTask(task, async_rendering::RenderTaskStatus::Failed); };
+
+        switch (task.type)
+        {
+        case async_rendering::RenderTaskType::ProgramCompilation:
+            if (m_core && m_core->tryIsRenderProgramReady().value_or(false))
+            {
+                queueRenderDecision(m_renderUpdateCoordinator.notifyProgramCompilationCompleted());
+            }
+            return false;
+
+        case async_rendering::RenderTaskType::ParameterUpload:
+        {
+            bool updated = false;
+            if (m_core && m_document)
+            {
+                if (auto assembly = m_document->getAssembly(); assembly && m_core->isRendererReady())
+                {
+                    updated = m_core->tryToupdateParameter(*assembly);
+                }
+            }
+            completeCoordinatorTask(task,
+                                    updated ? async_rendering::RenderTaskStatus::Completed
+                                            : async_rendering::RenderTaskStatus::Failed);
+            return false;
+        }
+
+        case async_rendering::RenderTaskType::BoundingBoxUpdate:
+        {
+            bool const wasInFlight = m_asyncBboxJobInFlight.load(std::memory_order_acquire);
+            scheduleAsyncBboxUpdate(&task);
+            bool const started = !wasInFlight && m_asyncBboxJobInFlight.load(std::memory_order_acquire);
+            if (!started)
+            {
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::SdfPrecomputation:
+        {
+            bool const started = scheduleAsyncSdfPrecomputation(&task);
+            if (!started)
+            {
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::RealtimeFullFrame:
+        {
+                        auto const executionPath = async_rendering::chooseRealtimeFrameExecutionPath(
+                            async_rendering::RealtimeInteractionActivityInput{
+                                .mode = m_renderUpdateCoordinator.realtimeConfig().mode,
+                                .interactionState = m_renderUpdateCoordinator.interactionState(),
+                                .autoRealtimeActive = m_renderUpdateCoordinator.isRealtimeActive(),
+                                .autoPreviewFallbackActive = m_renderUpdateCoordinator.isAutoPreviewFallbackActive(),
+                                .exactRealtimeJobInFlight = m_asyncRealtimeJobInFlight.load(std::memory_order_acquire)});
+                        if (executionPath == async_rendering::RealtimeFrameExecutionPath::SynchronousUiThread)
+            {
+                bool const rendered = tryRenderRealtimeFrameSync(task);
+                                queueRenderDecision(m_renderUpdateCoordinator.completeTask(
+                                    async_rendering::RenderTaskResult{
+                                        .requestId = task.requestId,
+                                        .type = task.type,
+                                        .stamp = task.stamp,
+                                        .status = rendered ? async_rendering::RenderTaskStatus::Completed
+                                                                             : async_rendering::RenderTaskStatus::Failed,
+                                        .producedDisplayFrame = rendered,
+                                        .completedFrame = rendered}));
+                if (!rendered)
+                {
+                    m_renderUpdateCoordinator.recordRealtimeRejectedAttempt();
+                }
+                return false; // no async job started; task is already completed above
+            }
+
+            bool const started = scheduleFullFrameRenderJob(state, &task);
+            if (!started)
+            {
+                m_renderUpdateCoordinator.recordRealtimeRejectedAttempt();
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::StaticFullFrameProbe:
+        {
+            bool const started = scheduleFullFrameRenderJob(
+              state, &task, async_rendering::RenderJobType::StaticFullFrameProbe);
+            if (!started)
+            {
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::LowResolutionPreview:
+            if (isRealtimeRaymarchInteractionActive())
+            {
+                completeCoordinatorTask(task, async_rendering::RenderTaskStatus::Cancelled);
+                return false;
+            }
+            if (!m_core)
+            {
+                failTask();
+                return false;
+            }
+        {
+            bool const started = scheduleAsyncPreviewJob(&task);
+            if (!started)
+            {
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::StreamingPreview:
+            m_streamingPreviewActive.store(true, std::memory_order_release);
+        {
+            bool const started = scheduleStreamingPreviewJob(&task);
+            if (!started)
+            {
+                failTask();
+            }
+            return started;
+        }
+
+        case async_rendering::RenderTaskType::ProgressiveHighQualityChunk:
+            state.isRendering = true;
+            if (!scheduleAsyncRenderJob(state, &task))
+            {
+                state.isRendering = false;
+                failTask();
+                return false;
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    bool RenderWindow::isRealtimeRaymarchInteractionActive() const noexcept
+    {
+                return async_rendering::isExactRealtimeInteractionActive(
+                    async_rendering::RealtimeInteractionActivityInput{
+                        .mode = m_renderUpdateCoordinator.realtimeConfig().mode,
+                        .interactionState = m_renderUpdateCoordinator.interactionState(),
+                        .autoRealtimeActive = m_renderUpdateCoordinator.isRealtimeActive(),
+                        .autoPreviewFallbackActive = m_renderUpdateCoordinator.isAutoPreviewFallbackActive(),
+                        .exactRealtimeJobInFlight = m_asyncRealtimeJobInFlight.load(std::memory_order_acquire)});
+    }
+
+    bool RenderWindow::isForceRealtimeMode() const noexcept
+    {
+        return m_renderUpdateCoordinator.realtimeConfig().mode ==
+               async_rendering::RealtimeRaymarchMode::Force;
+    }
+
+    bool RenderWindow::scheduleAsyncSdfPrecomputation(
+      async_rendering::RenderTaskRequest const * coordinatorTask)
+    {
+        if (!m_asyncController || !m_asyncController->isRunning() ||
+            m_asyncSdfJobInFlight.load(std::memory_order_acquire))
+        {
+            return false;
+        }
+
+        async_rendering::RenderJob sdfJob{};
+        sdfJob.type = async_rendering::RenderJobType::SDFPrecomputation;
+        if (coordinatorTask != nullptr)
+        {
+            sdfJob.coordinatorRequestId = coordinatorTask->requestId;
+            sdfJob.coordinatorStamp = coordinatorTask->stamp;
+        }
+        sdfJob.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+        if (sdfJob.epoch == 0)
+        {
+            sdfJob.epoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
+            m_asyncCurrentEpoch.store(sdfJob.epoch, std::memory_order_release);
+        }
+        m_asyncController->setLatestEpoch(sdfJob.epoch);
+        m_asyncSdfJobInFlight.store(true, std::memory_order_release);
+        m_asyncSdfInFlightEpoch.store(sdfJob.epoch, std::memory_order_release);
+        m_asyncController->enqueueJob(sdfJob);
+        return true;
+    }
+
+    void RenderWindow::completeCoordinatorTask(async_rendering::RenderTaskRequest const & request,
+                                               async_rendering::RenderTaskStatus status)
+    {
+        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
+          async_rendering::RenderTaskResult{.requestId = request.requestId,
+                                            .type = request.type,
+                                            .stamp = request.stamp,
+                                            .status = status}));
+    }
+
+    void RenderWindow::completeCoordinatorTask(async_rendering::FrameResultMeta const & result,
+                                               bool producedDisplayFrame)
+    {
+        if (result.coordinatorRequestId == 0)
+        {
+            return;
+        }
+
+        auto taskType = async_rendering::RenderTaskType::ProgressiveHighQualityChunk;
+        switch (result.jobType)
+        {
+        case async_rendering::RenderJobType::RealtimeHighQuality:
+            taskType = async_rendering::RenderTaskType::RealtimeFullFrame;
+            break;
+        case async_rendering::RenderJobType::StaticFullFrameProbe:
+            taskType = async_rendering::RenderTaskType::StaticFullFrameProbe;
+            break;
+        case async_rendering::RenderJobType::LowResPreview:
+            taskType = async_rendering::RenderTaskType::LowResolutionPreview;
+            break;
+        case async_rendering::RenderJobType::StreamingPreview:
+            taskType = async_rendering::RenderTaskType::StreamingPreview;
+            break;
+        case async_rendering::RenderJobType::BoundingBoxUpdate:
+            taskType = async_rendering::RenderTaskType::BoundingBoxUpdate;
+            break;
+        case async_rendering::RenderJobType::ParameterUpdate:
+            taskType = async_rendering::RenderTaskType::ParameterUpload;
+            break;
+        case async_rendering::RenderJobType::SDFPrecomputation:
+            taskType = async_rendering::RenderTaskType::SdfPrecomputation;
+            break;
+        case async_rendering::RenderJobType::ProgramCompilation:
+            taskType = async_rendering::RenderTaskType::ProgramCompilation;
+            break;
+        case async_rendering::RenderJobType::HighQuality:
+        default:
+            taskType = async_rendering::RenderTaskType::ProgressiveHighQualityChunk;
+            break;
+        }
+
+        auto const status = result.cancelled ? async_rendering::RenderTaskStatus::Cancelled
+                                             : async_rendering::RenderTaskStatus::Completed;
+        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
+          async_rendering::RenderTaskResult{.requestId = result.coordinatorRequestId,
+                                            .type = taskType,
+                                            .stamp = result.coordinatorStamp,
+                                            .status = status,
+                                            .durationNs = result.computeDurationNs,
+                                            .producedDisplayFrame = producedDisplayFrame,
+                                            .completedFrame = result.completedFrame}));
+    }
+
+    void RenderWindow::completeCoordinatorPreviewTask(async_rendering::PreviewResultMeta const & result)
+    {
+        if (result.coordinatorRequestId == 0)
+        {
+            return;
         }
+
+        auto const status = result.cancelled ? async_rendering::RenderTaskStatus::Cancelled
+                                             : async_rendering::RenderTaskStatus::Completed;
+        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
+          async_rendering::RenderTaskResult{.requestId = result.coordinatorRequestId,
+                                            .type = async_rendering::RenderTaskType::LowResolutionPreview,
+                                            .stamp = result.coordinatorStamp,
+                                            .status = status,
+                                            .durationNs = result.latencyNs,
+                                            .producedDisplayFrame = !result.cancelled,
+                                            .completedFrame = !result.cancelled}));
     }
 
     void RenderWindow::renderWindow()
@@ -303,34 +779,54 @@ namespace gladius::ui
             // Use the front buffer from triple buffering system
             auto * frontBuf = m_asyncController->frontBuffer();
             auto const currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+            auto const currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
 
             // For HQ frames (front buffer from progressive rendering) we require an epoch match
-            // to avoid showing stale HQ results from an old parameter set.
-            // For low-res preview during rapid parameter edits, we fall back to m_resultImage
-            // which is updated synchronously and always shows *something* recent.
-            bool const epochMatches = frontBuf && frontBuf->epoch == currentEpoch;
-            bool const useFrontBuffer = frontBuf && frontBuf->image && epochMatches &&
-                                        !m_renderWindowState.isRendering &&
-                                        !m_renderWindowState.isMoving &&
-                                        !m_suppressHQDisplay.load(std::memory_order_acquire);
-            bool const useProgressiveBuffer =
-              m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image &&
-              m_asyncProgressiveEpoch.load(std::memory_order_acquire) == currentEpoch &&
-              !m_renderWindowState.isMoving &&
-              !m_suppressHQDisplay.load(std::memory_order_acquire);
-
-            if (useFrontBuffer)
+            // to avoid showing stale HQ results from an old parameter set. Exact realtime
+            // interaction may keep a current-epoch front buffer visible while the view epoch is
+            // catching up, and all other cases fall back to m_resultImage to avoid blanking.
+            bool const exactRealtimeInteraction = isRealtimeRaymarchInteractionActive();
+            bool const exactRealtimeJobInFlight =
+                            m_asyncRealtimeJobInFlight.load(std::memory_order_acquire);
+            bool const fullFrameRenderJobInFlight =
+                            exactRealtimeJobInFlight ||
+                            m_asyncStaticFullFrameJobInFlight.load(std::memory_order_acquire);
+            auto const resultImage = m_core->getResultImage();
+                        auto const frontState = async_rendering::DisplayFrameBufferState{
+                            .hasImage = frontBuf && frontBuf->image != nullptr,
+                            .epoch = frontBuf ? frontBuf->epoch.load(std::memory_order_acquire) : 0u,
+                            .viewEpoch = frontBuf ? frontBuf->viewEpoch.load(std::memory_order_acquire) : 0u};
+                        auto const progressiveState = async_rendering::DisplayFrameBufferState{
+                            .hasImage = m_asyncProgressiveBuffer &&
+                                                    m_asyncProgressiveBuffer->image != nullptr,
+                            .epoch = m_asyncProgressiveEpoch.load(std::memory_order_acquire),
+                            .viewEpoch = m_asyncProgressiveViewEpoch.load(std::memory_order_acquire)};
+            auto const displaySource = async_rendering::selectDisplayFrameSource(
+                            async_rendering::DisplayFrameSelectionInput{
+                                .frontBuffer = frontState,
+                                .progressiveBuffer = progressiveState,
+                                .currentEpoch = currentEpoch,
+                                .currentViewEpoch = currentViewEpoch,
+                                .exactRealtimeInteraction = exactRealtimeInteraction,
+                                .exactRealtimeJobInFlight = exactRealtimeJobInFlight,
+                                .isRendering = m_renderWindowState.isRendering,
+                                .isMoving = m_renderWindowState.isMoving,
+                                .fullFrameRenderJobInFlight = fullFrameRenderJobInFlight,
+                                .suppressHqDisplay = m_suppressHQDisplay.load(std::memory_order_acquire),
+                                .resultImageAvailable = resultImage != nullptr,
+                                .presentedFrame = m_presentedFrames.presentedFrame()});
+
+            if (displaySource == async_rendering::DisplayFrameSource::FrontBuffer && frontBuf)
             {
                 displayImage = frontBuf->image;
             }
-            else if (useProgressiveBuffer)
+            else if (displaySource == async_rendering::DisplayFrameSource::ProgressiveBuffer)
             {
                 displayImage = m_asyncProgressiveBuffer->image;
             }
-            else
+            else if (displaySource == async_rendering::DisplayFrameSource::ResultImage)
             {
-                // Fallback to result image for progressive rendering or when no valid front buffer
-                displayImage = m_core->getResultImage();
+                displayImage = resultImage;
             }
         }
         else
@@ -343,6 +839,10 @@ namespace gladius::ui
         {
             // No image yet (early init / between resize and re-allocation).
             // Skip drawing this frame instead of dereferencing a null shared_ptr.
+            if (isFileLoading)
+            {
+                renderLoadingOverlay();
+            }
             return;
         }
 
@@ -357,7 +857,11 @@ namespace gladius::ui
 
         // Cache window state for isHovered() and isFocused() methods
         m_isWindowHovered = ImGui::IsWindowHovered();
-        m_isWindowFocused = ImGui::IsWindowFocused();
+        if (m_isWindowHovered && !ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows))
+        {
+            ImGui::SetWindowFocus();
+        }
+        m_isWindowFocused = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows);
 
         // if has focus, but not any item has focus, handle key input and content area is hovered
         if (ImGui::IsWindowFocused() && !ImGui::IsAnyItemFocused() &&
@@ -426,31 +930,31 @@ namespace gladius::ui
                                 &m_enableHQRendering);
                           });
 
-            overflow.item("Rendering Options",
-                          [&]
-                          {
-                              int renderingFlags =
-                                m_core->getResourceContext()->getRenderingSettings().flags;
-
-                              bool flagsChanged = false;
-                              if (ImGui::BeginMenu("..."))
-                              {
-                                  flagsChanged |= ImGui::CheckboxFlags(
-                                    "Show Build Plate", &renderingFlags, RF_SHOW_BUILDPLATE);
-                                  flagsChanged |= ImGui::CheckboxFlags(
-                                    "Cut Off Object", &renderingFlags, RF_CUT_OFF_OBJECT);
-                                  flagsChanged |= ImGui::CheckboxFlags(
-                                    "Show Field", &renderingFlags, RF_SHOW_FIELD);
-                                  flagsChanged |= ImGui::CheckboxFlags(
-                                    "Show Stack", &renderingFlags, RF_SHOW_STACK);
-                                  flagsChanged |= ImGui::CheckboxFlags(
-                                    "Show Coordinate System",
-                                    &renderingFlags,
-                                    RF_SHOW_COORDINATE_SYSTEM);
-
-                                  ImGui::Separator();
-                                  float quality =
-                                    m_core->getResourceContext()->getRenderingSettings().quality;
+                        overflow.item("Rendering Options",
+                                                    [&]
+                                                    {
+                                                            int renderingFlags =
+                                                                m_core->getResourceContext()->getRenderingSettings().flags;
+
+                                                            bool flagsChanged = false;
+                                                            if (ImGui::BeginMenu("..."))
+                                                            {
+                                                                    flagsChanged |= ImGui::CheckboxFlags(
+                                                                        "Show Build Plate", &renderingFlags, RF_SHOW_BUILDPLATE);
+                                                                    flagsChanged |= ImGui::CheckboxFlags(
+                                                                        "Cut Off Object", &renderingFlags, RF_CUT_OFF_OBJECT);
+                                                                    flagsChanged |= ImGui::CheckboxFlags(
+                                                                        "Show Field", &renderingFlags, RF_SHOW_FIELD);
+                                                                    flagsChanged |= ImGui::CheckboxFlags(
+                                                                        "Show Stack", &renderingFlags, RF_SHOW_STACK);
+                                                                    flagsChanged |= ImGui::CheckboxFlags(
+                                                                        "Show Coordinate System",
+                                                                        &renderingFlags,
+                                                                        RF_SHOW_COORDINATE_SYSTEM);
+
+                                                                    ImGui::Separator();
+                                                                    float quality =
+                                                                        m_core->getResourceContext()->getRenderingSettings().quality;
                                   ImGui::SetNextItemWidth(150.f * m_uiScale);
                                   bool qualityChanged =
                                     ImGui::SliderFloat("Quality", &quality, 0.1f, 2.0f);
@@ -470,6 +974,45 @@ namespace gladius::ui
                                   }
                                   m_renderWindowState.renderQuality = quality;
 
+                                  ImGui::Separator();
+                                  if (ImGui::BeginMenu("Realtime Raymarch"))
+                                  {
+                                      auto config = m_renderUpdateCoordinator.realtimeConfig();
+                                      auto const setMode = [&](async_rendering::RealtimeRaymarchMode mode)
+                                      {
+                                          config.mode = mode;
+                                          m_renderUpdateCoordinator.configureRealtime(config);
+                                          saveRealtimeRaymarchMode(mode);
+                                      };
+
+                                      if (ImGui::MenuItem(
+                                            "Auto", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Auto))
+                                      {
+                                          setMode(async_rendering::RealtimeRaymarchMode::Auto);
+                                      }
+                                      if (ImGui::MenuItem(
+                                            "Off", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Off))
+                                      {
+                                          setMode(async_rendering::RealtimeRaymarchMode::Off);
+                                      }
+                                      if (ImGui::MenuItem(
+                                            "Force", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Force))
+                                      {
+                                          setMode(async_rendering::RealtimeRaymarchMode::Force);
+                                      }
+
+                                      ImGui::Separator();
+                                      ImGui::Text("Budget: %.1f ms", config.targetFrameTimeMs);
+                                      if (ImGui::IsItemHovered())
+                                      {
+                                          ImGui::SetTooltip(
+                                            "Auto attempts full-resolution async raymarching when "
+                                            "recent timings fit this budget; otherwise Gladius "
+                                            "falls back to low-res preview/progressive rendering.");
+                                      }
+                                      ImGui::EndMenu();
+                                  }
+
                                   ImGui::EndMenu();
                               }
 
@@ -551,7 +1094,17 @@ namespace gladius::ui
         // Update camera and set isMoving based on whether camera is currently animating.
         // Note: Parameter changes use forceLowResRender and lowResFeedbackPending flags,
         // not isMoving. isMoving is specifically for camera movement.
-        m_renderWindowState.isMoving = m_camera.update(io.DeltaTime * 1000.f);
+        bool const cameraActuallyMoving = m_camera.update(io.DeltaTime * 1000.f);
+        if (cameraActuallyMoving) {
+            m_cameraIdleFrames = 0;
+            m_renderWindowState.isMoving = true;
+            // Reset idle timer when camera starts moving again
+            m_lastCameraIdleTime = TimeStamp{};
+        } else {
+            m_cameraIdleFrames++;
+            // Keep isMoving true for 10 frames after last movement to debounce fast refresh rates
+            m_renderWindowState.isMoving = m_cameraIdleFrames < 10;
+        }
         m_dirty = m_dirty || m_renderWindowState.isMoving;
 
         // Floating cut-height slider overlay (inside the Preview window)
@@ -567,7 +1120,7 @@ namespace gladius::ui
 
             if (m_camera.mouseMotionHandler(mousePos.x, mousePos.y))
             {
-                invalidateView();
+                invalidateCameraView();
             }
             if (!ImGui::IsAnyMouseDown())
             {
@@ -597,11 +1150,14 @@ namespace gladius::ui
         ImGui::PopStyleVar();
         displayImage->unbind();
 
+        if (isFileLoading)
+        {
+            showProgressSpinner(windowCenter, "loading", ImVec4(0.2f, 0.6f, 1.0f, 0.8f));
+        }
         // Show the progress indicator only when no renderable program is available.
         // In automatic mode the optimized OpenCL program may still compile in the
         // background while the command-stream preview program is already usable.
-        bool const showBusyIndicator = !m_core->tryIsRenderProgramReady().value_or(false);
-        if (showBusyIndicator)
+        else if (!m_core->tryIsRenderProgramReady().value_or(false))
         {
             m_view->startAnimationMode();
             ImGuiWindowFlags window_flags =
@@ -619,7 +1175,7 @@ namespace gladius::ui
 
             if (ImGui::Begin("ProgressIndicator", &open, window_flags))
             {
-                // Red color for compilation (loading case is handled by early return)
+                // Red color for compilation; file loading keeps a blue spinner above.
                 ImVec4 const indicatorColor = ImVec4(1.0f, 0.0f, 0.0f, 0.8f);
                 ui::loadingIndicatorCircle("compiling",
                                            30,
@@ -646,6 +1202,40 @@ namespace gladius::ui
         return m_renderWindowState.isRendering;
     }
 
+    RenderWindow::HqProgressiveRenderProgress RenderWindow::hqProgressiveRenderProgress() const
+    {
+        HqProgressiveRenderProgress progress;
+
+        // HQ progressive rendering only advances while the camera is still. While the
+        // camera is moving we show low-res previews or realtime frames instead, so there
+        // is no meaningful progressive progress to report.
+        if (!m_renderWindowState.isRendering || m_renderWindowState.isMoving)
+        {
+            return progress;
+        }
+
+        size_t totalHeight = 0;
+        if (m_core)
+        {
+            if (auto const image = m_core->getResultImage())
+            {
+                totalHeight = static_cast<size_t>(image->getHeight());
+            }
+        }
+
+        if (totalHeight == 0)
+        {
+            return progress;
+        }
+
+        progress.active = true;
+        progress.fraction = std::clamp(
+          static_cast<float>(m_renderWindowState.currentLine) / static_cast<float>(totalHeight),
+          0.0f,
+          1.0f);
+        return progress;
+    }
+
     void RenderWindow::invalidateView()
     {
         ProfileFunction;
@@ -679,6 +1269,7 @@ namespace gladius::ui
 
         // Force a low-res render on next frame for immediate visual feedback
         m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+        queueRenderDecision(m_renderUpdateCoordinator.notifyStructuralModelChanged());
 
         invalidateView();
         
@@ -690,9 +1281,6 @@ namespace gladius::ui
         // Mark model as modified for permanent centering
         m_modelModifiedSinceLastCenter = true;
 
-        // Reset first-time bounding box availability for new model
-        m_boundingBoxEverAvailable = false;
-
         // Reset bounding box so it will be recomputed
         m_core->resetBoundingBox();
 
@@ -721,8 +1309,24 @@ namespace gladius::ui
         m_core->setSdfValid(false);
 
         m_dirty = true;
-        m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
-        m_lastLowResRenderTime = std::chrono::system_clock::now();
+
+        // In realtime mode, mirror invalidateCameraView(): skip the legacy low-res preview
+        // path entirely. The coordinator already schedules a RealtimeFullFrame, and
+        // m_forceLowResRenderOnNextFrame / m_lowResFeedbackPending would trigger the old
+        // voxel-SDF preview path, producing a stale flash instead of instant feedback.
+        bool const isRealtimeMode =
+            m_renderUpdateCoordinator.realtimeConfig().mode !=
+            async_rendering::RealtimeRaymarchMode::Off;
+        m_forceLowResRenderOnNextFrame.store(!isRealtimeMode, std::memory_order_release);
+        if (isRealtimeMode)
+        {
+            m_lowResFeedbackPending.store(false, std::memory_order_release);
+        }
+        else
+        {
+            m_lastLowResRenderTime = std::chrono::system_clock::now();
+            m_lowResFeedbackPending.store(true, std::memory_order_release);
+        }
 
         // Cancel any in-progress progressive render (stale parameters)
         m_renderWindowState.currentLine = 0;
@@ -731,8 +1335,9 @@ namespace gladius::ui
 
         m_preComputedSdfDirty.store(true, std::memory_order_release);
         m_parameterDirty.store(true, std::memory_order_release);
-        m_lowResFeedbackPending.store(true, std::memory_order_release);
         m_modelModifiedSinceLastCenter = true;
+        m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel);
+        queueRenderDecision(m_renderUpdateCoordinator.notifyParameterChanged(true));
 
         // Mark bbox stale instead of resetting — preserves cached bbox for reuse with extra margin
         m_core->markBoundingBoxStale();
@@ -829,7 +1434,7 @@ namespace gladius::ui
     void RenderWindow::centerView()
     {
         m_centerViewRequested = true;
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setTopView()
@@ -837,7 +1442,7 @@ namespace gladius::ui
         // Top view: looking down the Z axis (pitch = +90°, yaw = 0°)
         m_camera.setAngle(CL_M_PI_F / 2.0f, 0.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setFrontView()
@@ -845,7 +1450,7 @@ namespace gladius::ui
         // Front view: looking along the Y axis (pitch = 0°, yaw = -90°)
         m_camera.setAngle(0.0f, -CL_M_PI_F / 2.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setLeftView()
@@ -853,7 +1458,7 @@ namespace gladius::ui
         // Left view: looking along the X axis (pitch = 0°, yaw = 0°)
         m_camera.setAngle(0.0f, 0.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setRightView()
@@ -861,7 +1466,7 @@ namespace gladius::ui
         // Right view: looking along the negative X axis (pitch = 0°, yaw = 180°)
         m_camera.setAngle(0.0f, CL_M_PI_F);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setBackView()
@@ -869,7 +1474,7 @@ namespace gladius::ui
         // Back view: looking along the negative Y axis (pitch = 0°, yaw = 90°)
         m_camera.setAngle(0.0f, CL_M_PI_F / 2.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setBottomView()
@@ -877,7 +1482,7 @@ namespace gladius::ui
         // Bottom view: looking up the Z axis (pitch = -90°, yaw = 0°)
         m_camera.setAngle(-CL_M_PI_F / 2.0f, 0.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setIsometricView()
@@ -887,7 +1492,7 @@ namespace gladius::ui
         float const yaw = CL_M_PI_F / 4.0f;                     // 45 degrees
         m_camera.setAngle(pitch, yaw);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::togglePerspective()
@@ -895,7 +1500,7 @@ namespace gladius::ui
         // This would require camera implementation to support orthographic/perspective toggle
         // For now, we'll save current view and restore it
         saveCurrentView();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::frameAll()
@@ -914,7 +1519,7 @@ namespace gladius::ui
         }
 
         m_camera.adjustDistanceToTarget(*bbox, m_renderWindowSize_px.x, m_renderWindowSize_px.y);
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::zoomSelected()
@@ -930,7 +1535,7 @@ namespace gladius::ui
         Position newLookAt{currentLookAt.x - m_panSensitivity, currentLookAt.y, currentLookAt.z};
         m_camera.setLookAt(newLookAt);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::panRight()
@@ -940,7 +1545,7 @@ namespace gladius::ui
         Position newLookAt{currentLookAt.x + m_panSensitivity, currentLookAt.y, currentLookAt.z};
         m_camera.setLookAt(newLookAt);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::panUp()
@@ -950,7 +1555,7 @@ namespace gladius::ui
         Position newLookAt{currentLookAt.x, currentLookAt.y, currentLookAt.z + m_panSensitivity};
         m_camera.setLookAt(newLookAt);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::panDown()
@@ -960,35 +1565,35 @@ namespace gladius::ui
         Position newLookAt{currentLookAt.x, currentLookAt.y, currentLookAt.z - m_panSensitivity};
         m_camera.setLookAt(newLookAt);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::rotateLeft()
     {
         m_camera.rotate(0.0f, -m_rotateSensitivity);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::rotateRight()
     {
         m_camera.rotate(0.0f, m_rotateSensitivity);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::rotateUp()
     {
         m_camera.rotate(m_rotateSensitivity, 0.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::rotateDown()
     {
         m_camera.rotate(-m_rotateSensitivity, 0.0f);
         onCameraManuallyMoved();
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::previousView()
@@ -1000,7 +1605,7 @@ namespace gladius::ui
 
             // Restore the view (this would require camera API support)
             // For now, we'll invalidate the view
-            invalidateView();
+            invalidateCameraView();
         }
     }
 
@@ -1013,7 +1618,7 @@ namespace gladius::ui
 
             // Restore the view (this would require camera API support)
             // For now, we'll invalidate the view
-            invalidateView();
+            invalidateCameraView();
         }
     }
 
@@ -1052,7 +1657,7 @@ namespace gladius::ui
         {
             // Restore the saved view (this would require camera API support)
             // For now, we'll invalidate the view
-            invalidateView();
+            invalidateCameraView();
         }
     }
 
@@ -1060,7 +1665,7 @@ namespace gladius::ui
     {
         m_flyModeEnabled = !m_flyModeEnabled;
         m_cameraMode = m_flyModeEnabled ? CameraMode::Fly : CameraMode::Orbit;
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::setOrbitMode()
@@ -1212,9 +1817,18 @@ namespace gladius::ui
         {
             // Discard any pending async preview so the streaming worker doesn't
             // stall waiting for m_streamingFrameConsumed.
-            if (m_asyncController && m_asyncController->tryConsumePreviewResult().has_value())
+            if (m_asyncController)
             {
-                m_streamingFrameConsumed.store(true, std::memory_order_release);
+                if (auto preview = m_asyncController->tryConsumePreviewResult())
+                {
+                    // The result references old-size CL images and cannot be presented, but the
+                    // coordinator still has this preview marked in-flight. Release it (cancelled)
+                    // so its interactive task slot does not leak — otherwise preview scheduling
+                    // stays blocked until the next camera move reclaims it.
+                    preview->cancelled = true;
+                    completeCoordinatorPreviewTask(*preview);
+                    m_streamingFrameConsumed.store(true, std::memory_order_release);
+                }
             }
             return;
         }
@@ -1259,6 +1873,7 @@ namespace gladius::ui
             // path has no PID, so we reset to the nominal 50% of full quality here.
             state.renderQualityWhileMoving = state.renderQuality * 0.5f;
             invalidateViewDuetoModelUpdate();
+            queueRenderDecision(m_renderUpdateCoordinator.notifyProgramCompilationCompleted());
         }
 
         // Lazy initialization: only initialize async rendering once renderer is ready
@@ -1522,12 +2137,171 @@ namespace gladius::ui
 
         // Update camera now that we know core is ready
         m_core->applyCamera(m_camera);
-
         processAsyncResults(state);
 
         // Process async preview results (separate from HQ progressive results)
         processAsyncPreviewResults();
 
+                int const desiredScreenWidth = static_cast<int>(
+                    std::clamp(m_renderWindowSize_px.x * state.renderQuality, 1.f, 16000.f));
+                int const desiredScreenHeight = static_cast<int>(
+                    std::clamp(m_renderWindowSize_px.y * state.renderQuality, 1.f, 16000.f));
+                auto const resultImage = m_core->getResultImage();
+                bool screenResizeRequired =
+                    resultImage && (static_cast<int>(resultImage->getWidth()) != desiredScreenWidth ||
+                                                    static_cast<int>(resultImage->getHeight()) != desiredScreenHeight);
+
+        // Treat render-target resize as a scheduling barrier: the pure coordinator's
+        // viewport stamp must not be advanced until the concrete CL/GL images have the
+        // matching size. Otherwise an old-size render job can complete with the new
+        // viewport stamp, making HQ/static catch-up and Auto realtime learning believe
+        // the resized viewport is already current.
+        bool const shouldDeferResize = m_preserveContentDuringResize && m_deferredResizePending;
+        bool const hqRenderInFlight = m_asyncJobInFlight.load(std::memory_order_acquire);
+        if (!shouldDeferResize && screenResizeRequired)
+        {
+            if (hqRenderInFlight)
+            {
+                m_dirty = true;
+                m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+                state.isRendering = false;
+                return;
+            }
+
+            if (m_asyncController && m_asyncProgressiveBuffer != nullptr)
+            {
+                [[maybe_unused]] bool const released =
+                  m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
+                                                         async_rendering::FrameState::Writing,
+                                                         async_rendering::FrameState::Idle);
+                m_asyncProgressiveBuffer = nullptr;
+                m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+                state.currentLine = 0;
+                state.isRendering = false;
+            }
+
+            bool const resized = m_core->setScreenResolution(desiredScreenWidth, desiredScreenHeight);
+            auto const latestImage = m_core->getResultImage();
+            bool const resizeStillRequired =
+              !latestImage || static_cast<int>(latestImage->getWidth()) != desiredScreenWidth ||
+              static_cast<int>(latestImage->getHeight()) != desiredScreenHeight;
+            if (resizeStillRequired)
+            {
+                // setScreenResolution can legitimately fail while another compute operation
+                // holds the token. Keep the old frame visible and retry next UI frame instead
+                // of scheduling work against stale dimensions.
+                m_dirty = true;
+                m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+                state.isRendering = false;
+                return;
+            }
+
+            screenResizeRequired = false;
+            if (resized)
+            {
+                invalidateView();
+            }
+        }
+        
+        // Clear preserve flags once rendering may resume. The early render() guard normally
+        // handles this on the first stable-size frame; this branch is a defensive fallback.
+        if (shouldDeferResize && m_forceLowResRenderOnNextFrame.load(std::memory_order_acquire))
+        {
+            m_preserveContentDuringResize = false;
+            m_deferredResizePending = false;
+        }
+
+        if (m_asyncController && m_asyncController->isRunning())
+        {
+                        queueRenderDecision(m_renderUpdateCoordinator.configureViewport(
+                            static_cast<uint32_t>(desiredScreenWidth), static_cast<uint32_t>(desiredScreenHeight)));
+
+            m_renderUpdateCoordinator.setRealtimeGuards(
+              async_rendering::RealtimeRaymarchGuards{
+                .hardBlocker = !m_enableHQRendering ||
+                               m_asyncSdfJobInFlight.load(std::memory_order_acquire) ||
+                               m_asyncBboxJobInFlight.load(std::memory_order_acquire) ||
+                               m_core->isAnyCompilationInProgressNonBlocking(),
+                .renderJobInFlight = m_asyncJobInFlight.load(std::memory_order_acquire),
+                .previewJobInFlight = m_asyncPreviewJobInFlight.load(std::memory_order_acquire),
+                .streamingActive = m_streamingPreviewActive.load(std::memory_order_acquire),
+                .streamingJobInFlight = m_streamingJobInFlight.load(std::memory_order_acquire),
+                .resizePending = m_deferredResizePending || screenResizeRequired});
+
+            // Defer transition from CameraInteracting to Static state until camera has been idle
+            // for at least 1 second. This prevents HQ progressive rendering from starting and
+            // getting aborted repeatedly during stop-and-go camera movements.
+            if (!state.isMoving &&
+                m_renderUpdateCoordinator.interactionState() ==
+                  async_rendering::RenderInteractionState::CameraInteracting)
+            {
+                auto const now = std::chrono::system_clock::now();
+                if (m_lastCameraIdleTime == TimeStamp{})
+                {
+                    // First frame idle — record the time
+                    m_lastCameraIdleTime = now;
+                }
+                else
+                {
+                    auto const timeSinceIdle = now - m_lastCameraIdleTime;
+                    if (timeSinceIdle >= std::chrono::seconds(1))
+                    {
+                        queueRenderDecision(m_renderUpdateCoordinator.notifyCameraInteractionEnded());
+                        m_lastCameraIdleTime = TimeStamp{}; // Reset for next interaction
+                    }
+                }
+            }
+
+            // Parameter-drag settle: once no parameter change has arrived for the debounce
+            // window, end the parameter interaction so the coordinator's static catch-up
+            // (bbox -> SDF -> high-quality) resumes and the static view shows full detail.
+            //
+            // This MUST run here, before the early-returning executeQueuedRenderCommands()
+            // below. In Auto mode that is not yet proven fast (and in any streaming-preview
+            // case) an interactive low-res preview frame is scheduled on every tick, so
+            // executeQueuedRenderCommands() returns true and renderAsync() returns early.
+            // The legacy settle path further down would then never be reached, leaving the
+            // view stuck on the low-res preview until the next camera move forces a
+            // notifyCameraInteractionEnded() transition. Driving the settle from here makes
+            // the transition independent of which interactive feedback path is active.
+            bool const paramInteracting =
+              m_renderUpdateCoordinator.interactionState() ==
+              async_rendering::RenderInteractionState::ParameterInteracting;
+            bool const bboxStaleForSettle = m_core->isBoundingBoxStale();
+            bool const bboxJobForSettle = m_asyncBboxJobInFlight.load(std::memory_order_acquire);
+            bool const sdfJobForSettle = m_asyncSdfJobInFlight.load(std::memory_order_acquire);
+            auto const sinceParamChange =
+              std::chrono::steady_clock::now() - m_lastParameterChangeTime;
+            bool const debounceElapsedForSettle = sinceParamChange >= kBboxDebounceDelay;
+
+            if (paramInteracting && bboxStaleForSettle && !bboxJobForSettle && !sdfJobForSettle &&
+                debounceElapsedForSettle)
+            {
+                // Parameter drag has ended. This is a semantic interaction transition,
+                // independent of whether the active feedback path used streaming preview
+                // (Force mode does not start streaming preview at all).
+                finishParameterInteraction();
+
+                m_core->recomputeStaleBoundingBox();
+                m_core->setSdfValid(false);
+                m_preComputedSdfDirty.store(true, std::memory_order_release);
+
+                // Bump epoch to invalidate the stale HQ/preview front buffer from before the
+                // drag so the fresh bbox -> SDF -> HQ pipeline starts clean.
+                notifyAsyncEpochIncrement();
+                m_suppressHQDisplay.store(false, std::memory_order_release);
+            }
+
+            queueRenderDecision(m_renderUpdateCoordinator.tick());
+            bool const queuedWorkStarted = executeQueuedRenderCommands(state);
+
+            if (queuedWorkStarted)
+            {
+                return;
+            }
+        }
+
         if (m_asyncController && m_asyncController->isRunning())
         {
             bool const sdfDirty = m_preComputedSdfDirty.load(std::memory_order_acquire);
@@ -1546,7 +2320,22 @@ namespace gladius::ui
               !bboxStale ||
               (std::chrono::steady_clock::now() - m_lastParameterChangeTime >= kBboxDebounceDelay);
 
-            if (sdfDirty && !sdfJobActive && sdfDebounceElapsed)
+            // Don't schedule SDF precomputation while the camera is actively moving in
+            // realtime mode: the realtime renderer evaluates SDF on-the-fly and doesn't
+            // need the precomputed version. Starting the SDF job now would set
+            // hardBlocker=true, preventing canAttemptRealtime() from returning true for
+            // the entire SDF compute duration. The coordinator will schedule SDF via
+            // scheduleStaticCatchUp() once notifyCameraInteractionEnded() fires.
+            bool const cameraInteracting =
+              m_renderUpdateCoordinator.interactionState() ==
+              async_rendering::RenderInteractionState::CameraInteracting;
+            bool const isRealtimeForSdfGuard =
+              m_renderUpdateCoordinator.realtimeConfig().mode !=
+              async_rendering::RealtimeRaymarchMode::Off;
+            bool const suppressSdfDuringCameraInteraction =
+              cameraInteracting && isRealtimeForSdfGuard;
+
+            if (sdfDirty && !sdfJobActive && sdfDebounceElapsed && !suppressSdfDuringCameraInteraction)
             {
                 async_rendering::RenderJob sdfJob{};
                 sdfJob.type = async_rendering::RenderJobType::SDFPrecomputation;
@@ -1573,35 +2362,15 @@ namespace gladius::ui
                 scheduleAsyncBboxUpdate();
             }
 
-            // Debounce: recompute stale bounding box after slider drag stops.
-            // recomputeStaleBoundingBox() clears the cached bbox so the next SDF job
-            // does a full bbox recompute with the current parameters.
-            if (m_core->isBoundingBoxStale() && !bboxJobActive && !sdfJobActive)
-            {
-                auto const now = std::chrono::steady_clock::now();
-                if (now - m_lastParameterChangeTime >= kBboxDebounceDelay)
-                {
-                    // Stop the streaming preview loop — drag has ended.
-                    // The streaming coroutine's last iteration already pushed the
-                    // final parameter values to the GPU buffer.
-                    stopStreamingPreview();
-
-                    m_core->recomputeStaleBoundingBox();
-                    m_core->setSdfValid(false);
-                    m_preComputedSdfDirty = true;
-
-                    // Parameter drag has stopped — bump epoch to invalidate the stale
-                    // HQ front buffer from before the drag and start fresh.
-                    notifyAsyncEpochIncrement();
-                    m_suppressHQDisplay.store(false, std::memory_order_release);
-                }
-            }
+            // Note: the parameter-drag settle transition (finishParameterInteraction +
+            // stale-bbox recompute + epoch bump) now runs earlier, in the coordinator block
+            // above, so it cannot be skipped by the early return when an interactive preview
+            // frame is scheduled. See the ParameterInteracting settle block in this function.
 
             if (lowResPending)
             {
                 // Delay progressive rendering until low-res feedback is presented
                 state.isRendering = false;
-                m_asyncJobInFlight.store(false, std::memory_order_release);
             }
         }
 
@@ -1677,15 +2446,11 @@ namespace gladius::ui
                 }
             }
 
-            // Camera-only change from centering — don't bump epoch.
-            // SDF/bbox jobs are not camera-dependent and must not be cancelled.
-            m_dirty = true;
-            state.isMoving = true;
-            state.currentLine = 0;
-            state.renderingStepSize = kInitialProgressiveStepSize;
-            state.isRendering = false;
-            m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
-            m_lastLowResRenderTime = std::chrono::system_clock::now();
+            // Auto-centering changed the camera.  Route this through the normal camera
+            // invalidation path so the coordinator sees a view change and exact realtime
+            // modes schedule a RealtimeFullFrame instead of falling back to the legacy
+            // low-res preview via state.isMoving in Static state.
+            invalidateCameraView();
         }
 
         if (state.isMoving && m_preComputedSdfDirty)
@@ -1693,64 +2458,6 @@ namespace gladius::ui
             m_core->getResourceContext()->getRenderingSettings().approximation = AM_FULL_MODEL;
         }
 
-        // Defer buffer reallocation during resize to preserve visible content. Also wait until
-        // async HQ rendering has fully drained before reallocating the displayed CL/GL image:
-        // worker jobs copy their staging image back into m_resultImage after the render kernel
-        // completes, and resizing that image concurrently can crash inside clEnqueueCopyImage.
-        bool const shouldDeferResize = m_preserveContentDuringResize && m_deferredResizePending;
-        int const desiredScreenWidth = static_cast<int>(
-          std::clamp(m_renderWindowSize_px.x * state.renderQuality, 1.f, 16000.f));
-        int const desiredScreenHeight = static_cast<int>(
-          std::clamp(m_renderWindowSize_px.y * state.renderQuality, 1.f, 16000.f));
-        auto const resultImage = m_core->getResultImage();
-        bool const screenResizeRequired =
-          resultImage && (static_cast<int>(resultImage->getWidth()) != desiredScreenWidth ||
-                          static_cast<int>(resultImage->getHeight()) != desiredScreenHeight);
-        bool const hqRenderInFlight = m_asyncJobInFlight.load(std::memory_order_acquire);
-
-        if (!shouldDeferResize && screenResizeRequired && !hqRenderInFlight &&
-            m_asyncProgressiveBuffer != nullptr)
-        {
-            [[maybe_unused]] bool const released =
-              m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
-                                                     async_rendering::FrameState::Writing,
-                                                     async_rendering::FrameState::Idle);
-            m_asyncProgressiveBuffer = nullptr;
-            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
-            state.currentLine = 0;
-            state.isRendering = false;
-        }
-
-        if (!shouldDeferResize && screenResizeRequired && hqRenderInFlight)
-        {
-            m_dirty = true;
-            m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
-            state.isRendering = false;
-            return;
-        }
-
-        if (!shouldDeferResize &&
-            m_core->setScreenResolution(desiredScreenWidth, desiredScreenHeight))
-        {
-            // Resolution changed - mark dirty but DON'T bump epoch if already rendering
-            // (bumping epoch would cancel in-flight jobs)
-            if (!state.isRendering && !m_asyncJobInFlight.load(std::memory_order_acquire))
-            {
-                invalidateView();
-            }
-            else
-            {
-                m_dirty = true;
-            }
-        }
-        
-        // Clear preserve flags once low-res preview starts rendering
-        if (shouldDeferResize && m_forceLowResRenderOnNextFrame.load(std::memory_order_acquire))
-        {
-            m_preserveContentDuringResize = false;
-            m_deferredResizePending = false;
-        }
-
         std::pair<int, int> const lowResPreviewResolution = m_core->getLowResPreviewResolution();
 
         int newWidth = static_cast<int>(
@@ -1779,7 +2486,24 @@ namespace gladius::ui
         bool const lowResPending = m_lowResFeedbackPending.load(std::memory_order_acquire);
         bool const previewJobInFlight = m_asyncPreviewJobInFlight.load(std::memory_order_acquire);
 
-        if (state.isMoving || forceLowResRender || lowResPending)
+        if (m_asyncRealtimeJobInFlight.load(std::memory_order_acquire))
+        {
+            m_lowResFeedbackPending.store(false, std::memory_order_release);
+            state.isRendering = true;
+            return;
+        }
+
+                bool const shouldUseLowResPreview = async_rendering::shouldUseLegacyLowResPreview(
+                    async_rendering::LegacyLowResPreviewInput{
+                        .mode = m_renderUpdateCoordinator.realtimeConfig().mode,
+                        .interactionState = m_renderUpdateCoordinator.interactionState(),
+                        .autoRealtimeActive = m_renderUpdateCoordinator.isRealtimeActive(),
+                        .stateIsMoving = state.isMoving,
+                        .forceLowResRender = forceLowResRender,
+                        .lowResFeedbackPending = lowResPending,
+                        .exactRealtimeJobInFlight = m_asyncRealtimeJobInFlight.load(std::memory_order_acquire)});
+
+                if (shouldUseLowResPreview)
         {
             bool const hadActiveProgressive =
               state.isRendering || m_asyncJobInFlight.load(std::memory_order_acquire);
@@ -1787,7 +2511,16 @@ namespace gladius::ui
             if (lowResPending && hadActiveProgressive &&
                 !m_streamingPreviewActive.load(std::memory_order_acquire))
             {
-                notifyAsyncEpochIncrement();
+                // Do not bump the global epoch here.
+                //
+                // lowResPending is also used by adaptive preview quality tuning and
+                // camera/preview handoffs. Incrementing the epoch on every such handoff
+                // repeatedly invalidates HQ work and can cause visible restart churn.
+                //
+                // Semantic invalidation (parameter/model changes) already bumps epoch in
+                // dedicated paths (e.g. settle/finish transitions). Here we only reset the
+                // local progressive state so preview can take over without forcing another
+                // global invalidation cycle.
                 state.currentLine = 0;
                 state.renderingStepSize = kInitialProgressiveStepSize;
                 state.isRendering = false;
@@ -1797,10 +2530,8 @@ namespace gladius::ui
             // - Async preview keeps the UI thread non-blocking for smooth parameter drag
             // - Sync preview is the fallback when async is unavailable
             // During parameter drag, SDF jobs are debounced so there's no GPU contention.
-            bool const sdfValid = m_core->isSdfValid();
-            bool const sdfJobRunning = m_asyncSdfJobInFlight.load(std::memory_order_acquire);
             bool const streamingActive = m_streamingPreviewActive.load(std::memory_order_acquire);
-            bool const useAsyncPreview = !previewJobInFlight && sdfValid;
+            bool const useAsyncPreview = !previewJobInFlight;
 
             if (streamingActive)
             {
@@ -1883,8 +2614,13 @@ namespace gladius::ui
         // Only enforce timeout if we're NOT already in middle of progressive rendering
         // (otherwise chunks would be blocked after any interaction)
         bool const isProgressiveRenderInProgress = state.isRendering && state.currentLine > 0;
+        auto const realtimeMode = m_renderUpdateCoordinator.realtimeConfig().mode;
+        bool const preferExactRealtime =
+            realtimeMode == async_rendering::RealtimeRaymarchMode::Force ||
+            m_renderUpdateCoordinator.isRealtimeActive();
+        bool const useLowResPreviewBeforeHq = !preferExactRealtime;
 
-        if (!isProgressiveRenderInProgress)
+        if (!isProgressiveRenderInProgress && useLowResPreviewBeforeHq)
         {
             auto const timeSinceLastLowResRender =
               std::chrono::system_clock::now() - m_lastLowResRenderTime;
@@ -1938,6 +2674,20 @@ namespace gladius::ui
 
             auto const currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
             bool const isOutdated = result.epoch < currentEpoch;
+                        auto const currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+                        auto const jobType = result.jobType;
+                        bool const isExactRealtimeJob = jobType == async_rendering::RenderJobType::RealtimeHighQuality;
+                        bool const isStaticFullFrameProbe =
+                            jobType == async_rendering::RenderJobType::StaticFullFrameProbe;
+                        bool const isFullFrameRenderJob = isExactRealtimeJob || isStaticFullFrameProbe;
+                        bool const isHqRenderJob = jobType == async_rendering::RenderJobType::HighQuality ||
+                                                                             isFullFrameRenderJob;
+                        auto const currentResultImage = m_core ? m_core->getResultImage() : SharedGLImageBuffer{};
+                        bool const isTargetSizeOutdated =
+                            isHqRenderJob && currentResultImage &&
+                            (static_cast<uint32_t>(currentResultImage->getWidth()) != result.width ||
+                             static_cast<uint32_t>(currentResultImage->getHeight()) != result.height);
+                        bool const isViewOutdated = isHqRenderJob && result.viewEpoch < currentViewEpoch;
 
             if (result.jobType == async_rendering::RenderJobType::SDFPrecomputation)
             {
@@ -1953,12 +2703,24 @@ namespace gladius::ui
                 if (result.precomputedSdfUpdated && !isOutdated)
                 {
                     m_preComputedSdfDirty.store(false, std::memory_order_release);
-                    m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+                    // In realtime mode the coordinator drives the next render through
+                    // scheduleStaticCatchUp (fired via completeCoordinatorTask below).
+                    // Setting forceLowResRenderOnNextFrame here would cause a spurious
+                    // low-res preview one frame after the RealtimeFullFrame is already
+                    // queued, because the flag persists past the coordinator's early-return
+                    // and usesExactRealtimeInteraction returns false for Static state.
+                    if (!m_renderUpdateCoordinator.isRealtimeSchedulingActive())
+                    {
+                        m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+                    }
                     // SDF computation already updated bbox (via updateBBox() in
                     // precomputeSdfAsync and commitSdfSuccess). Clear pending bbox
                     // to avoid scheduling a redundant bbox job.
                     m_asyncBboxUpdatePending.store(false, std::memory_order_release);
                 }
+                auto coordinatorResult = result;
+                coordinatorResult.cancelled = coordinatorResult.cancelled || isOutdated;
+                completeCoordinatorTask(coordinatorResult, false);
                 continue;
             }
 
@@ -1970,6 +2732,9 @@ namespace gladius::ui
                 {
                     scheduleAsyncBboxUpdate();
                 }
+                auto coordinatorResult = result;
+                coordinatorResult.cancelled = coordinatorResult.cancelled || isOutdated;
+                completeCoordinatorTask(coordinatorResult, false);
                 continue;
             }
 
@@ -1989,60 +2754,211 @@ namespace gladius::ui
                 continue;
             }
 
-            // From here on, only HQ progressive render results are processed.
+            // From here on, only HQ/full-frame render results are processed.
+
+            if (isHqRenderJob && result.computeDurationNs > 0)
+            {
+                size_t const renderedLines = result.completedLine > result.startLine
+                                             ? result.completedLine - result.startLine
+                                             : size_t{0};
+                auto const durationMs = static_cast<float>(
+                    static_cast<double>(result.computeDurationNs) / 1'000'000.0);
+                async_rendering::RealtimeRaymarchSample sample{};
+                sample.durationMs = durationMs;
+                sample.width = result.width;
+                sample.height = result.height;
+                sample.renderedLines = renderedLines;
+                sample.totalLines = result.height;
+                sample.completedFrame = result.completedFrame && result.startLine == 0 &&
+                                        renderedLines >= static_cast<size_t>(result.height);
+                sample.cancelled = result.cancelled;
+                if (isStaticFullFrameProbe && !isOutdated && !isViewOutdated &&
+                    !isTargetSizeOutdated)
+                {
+                    m_renderUpdateCoordinator.recordStaticFullFrameSample(sample);
+                }
+                else if (isExactRealtimeJob && !isTargetSizeOutdated)
+                {
+                    if (m_renderUpdateCoordinator.interactionState() ==
+                        async_rendering::RenderInteractionState::Static)
+                    {
+                        m_renderUpdateCoordinator.recordStaticFullFrameSample(sample);
+                    }
+                    else
+                    {
+                        m_renderUpdateCoordinator.recordInteractiveRealtimeSample(sample);
+                    }
+                }
+                else if (!isOutdated && !isViewOutdated &&
+                         !isTargetSizeOutdated &&
+                         m_renderUpdateCoordinator.interactionState() == async_rendering::RenderInteractionState::Static)
+                {
+                    m_renderUpdateCoordinator.recordStaticProgressiveSample(sample);
+                }
+            }
 
             if (result.cancelled)
             {
+                if (isExactRealtimeJob)
+                {
+                    m_renderUpdateCoordinator.recordRealtimeRejectedAttempt();
+                }
+                if (m_asyncProgressiveBuffer &&
+                    m_asyncProgressiveEpoch.load(std::memory_order_acquire) == result.epoch)
+                {
+                    [[maybe_unused]] bool const released =
+                      m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
+                                                             async_rendering::FrameState::Writing,
+                                                             async_rendering::FrameState::Idle);
+                    m_asyncProgressiveBuffer = nullptr;
+                    m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                    m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+                }
                 if (result.epoch == m_asyncInFlightEpoch.load(std::memory_order_acquire))
                 {
                     m_asyncJobInFlight.store(false, std::memory_order_release);
+                    if (isExactRealtimeJob)
+                    {
+                        m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+                    }
+                    if (isStaticFullFrameProbe)
+                    {
+                        m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
+                    }
                     m_asyncInFlightEpoch.store(0, std::memory_order_release);
+                    m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
                     state.isRendering = false;
                 }
+                if (isStaticFullFrameProbe)
+                {
+                    m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
+                }
+                completeCoordinatorTask(result, false);
                 continue;
             }
 
-            // Update progressive scheduling state only for current-epoch results.
-            // Outdated results are still presented, but must not affect scheduling.
-            if (!isOutdated)
+            // Update progressive scheduling state only for current scene/view results.
+            if (!isOutdated && !isViewOutdated && !isTargetSizeOutdated &&
+                result.jobType == async_rendering::RenderJobType::HighQuality)
             {
                 size_t const maxHeight = static_cast<size_t>(result.height);
                 state.currentLine = std::min(result.completedLine, maxHeight);
                 adjustProgressFromDuration(state, result.computeDurationNs);
             }
 
-            // Promote the newest Ready buffer to Front for display
-            // Note: Only happens when completedFrame=true (buffer was published)
+            // Promote the newest Ready buffer to Front for display.
+            // Stale scene/view results are deliberately discarded before promotion; otherwise
+            // a late realtime frame could replace a valid front buffer with an old camera or
+            // parameter state.
+            // Interactive realtime raymarching frames (both Auto and Force) need to be displayed even if
+            // the view epoch has incremented, otherwise continuous camera motion freezes.
+            bool const allowForcedRealtimeStaleView = isExactRealtimeJob;
+                        bool const discardForStaleView =
+                            isTargetSizeOutdated || (isViewOutdated && !allowForcedRealtimeStaleView);
+
             if (result.completedFrame)
             {
-                ZoneScopedN("PromoteReadyToFront");
-                auto * newFront = m_asyncController->promoteReadyToFront();
-                if (newFront && newFront->image)
+                if (isOutdated || discardForStaleView)
                 {
-                    // Bind the new frame to ensure GL texture is updated
-                    newFront->image->invalidateContent();
-                    newFront->image->bind();
-                    newFront->image->unbind();
-
-                    bool const promoted = m_asyncController->finalizeFrontPromotion(newFront);
+                    m_asyncController->discardReadyFrame(
+                      result.frameId, result.epoch, result.viewEpoch);
                 }
+                                else
+                                {
+                                        ZoneScopedN("PromoteReadyToFront");
+                                        auto const requiredPresentationStamp = isExactRealtimeJob
+                                                                                                                         ? result.coordinatorStamp
+                                                                                                                         : m_renderUpdateCoordinator.latestStamp();
+                                        auto * newFront = m_asyncController->promoteReadyToFront(
+                                            requiredPresentationStamp, async_rendering::RenderStampMask::displayFrame());
+                                        if (newFront && newFront->image)
+                                        {
+                                                // Bind the new frame to ensure GL texture is updated
+                                                newFront->image->invalidateContent();
+                                                newFront->image->bind();
+                                                newFront->image->unbind();
+
+                                                bool const wasPromoted = m_asyncController->finalizeFrontPromotion(newFront);
+                                                if (wasPromoted)
+                                                {
+                                                        auto const source = isExactRealtimeJob
+                                                                                                    ? async_rendering::FramePresentationSource::ExactRealtime
+                                                                                                    : async_rendering::FramePresentationSource::ProgressiveHighQuality;
+                                                        auto const candidate = async_rendering::FramePresentationCandidate{
+                                                            .frameId = result.frameId,
+                                                            .stamp = result.coordinatorStamp,
+                                                            .quality = async_rendering::FramePresentationQuality::FullQuality,
+                                                            .source = source,
+                                                            .completedFrame = true};
+                                                        [[maybe_unused]] bool const presented =
+                                                            m_presentedFrames.presentCandidate(candidate, requiredPresentationStamp);
+                                                }
+                                        }
+                                }
             }
 
             if (result.completedFrame)
             {
-                if (!isOutdated)
+                if (!isOutdated && !discardForStaleView)
                 {
-                    m_dirty = false;
+                    m_dirty = isViewOutdated && allowForcedRealtimeStaleView;
                     state.isRendering = false;
                     // DON'T force state.isMoving = false - let camera update control this
                     // If camera is still animating, it will set isMoving=true on next frame
                     state.currentLine = 0; // Reset for next frame
-                    m_view->stopAnimationMode();
+                    // A complete HQ frame for the current view+size is now ready. If partial HQ
+                    // display was suppressed because this frame was seeded from a stale-view
+                    // preview (see scheduleAsyncRenderJob), re-enable HQ display so the finished,
+                    // view-consistent frame swaps in cleanly instead of staying on the low-res
+                    // preview.
+                    m_suppressHQDisplay.store(false, std::memory_order_release);
+                    if (isExactRealtimeJob)
+                    {
+                        m_lowResFeedbackPending.store(false, std::memory_order_release);
+                        m_lastLowResPreviewEpoch.store(result.epoch, std::memory_order_release);
+                    }
+                    if (isViewOutdated && allowForcedRealtimeStaleView)
+                    {
+                        m_view->startAnimationMode();
+                    }
+                    else
+                    {
+                        m_view->stopAnimationMode();
+                    }
                 }
             }
             else
             {
-                if (!isOutdated && m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
+                if ((isViewOutdated || isTargetSizeOutdated) && m_asyncProgressiveBuffer &&
+                    m_asyncProgressiveViewEpoch.load(std::memory_order_acquire) == result.viewEpoch)
+                {
+                    [[maybe_unused]] bool const released =
+                      m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
+                                                             async_rendering::FrameState::Writing,
+                                                             async_rendering::FrameState::Idle);
+                    m_asyncProgressiveBuffer = nullptr;
+                    m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                    m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+                    state.isRendering = false;
+                }
+                else if (m_asyncStaticFullFrameJobInFlight.load(std::memory_order_acquire) &&
+                         m_asyncProgressiveBuffer &&
+                         m_asyncProgressiveEpoch.load(std::memory_order_acquire) == result.epoch)
+                {
+                    // A full-frame probe was scheduled while this chunk was in-flight.
+                    // The chunk kernel is now done (result has arrived), so it is safe to release
+                    // the progressive buffer. This prevents the partial chunk content (stale bottom)
+                    // from being displayed while the probe renders.
+                    [[maybe_unused]] bool const released =
+                      m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
+                                                             async_rendering::FrameState::Writing,
+                                                             async_rendering::FrameState::Idle);
+                    m_asyncProgressiveBuffer = nullptr;
+                    m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                    m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+                }
+                else if (!isOutdated && !isViewOutdated && m_asyncProgressiveBuffer &&
+                         m_asyncProgressiveBuffer->image)
                 {
                     m_asyncProgressiveBuffer->image->invalidateContent();
                     m_view->startAnimationMode();
@@ -2052,28 +2968,377 @@ namespace gladius::ui
                 // state.isRendering remains true to trigger next chunk scheduling
             }
 
-            // Clear in-flight state only for the job that is actually in flight.
-            if (result.epoch == m_asyncInFlightEpoch.load(std::memory_order_acquire))
-            {
-                m_asyncJobInFlight.store(false, std::memory_order_release);
-                m_asyncInFlightEpoch.store(0, std::memory_order_release);
+            // Clear in-flight state only for the job that is actually in flight.
+            if (result.epoch == m_asyncInFlightEpoch.load(std::memory_order_acquire))
+            {
+                m_asyncJobInFlight.store(false, std::memory_order_release);
+                if (isExactRealtimeJob)
+                {
+                    m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+                }
+                if (isStaticFullFrameProbe)
+                {
+                    m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
+                }
+                m_asyncInFlightEpoch.store(0, std::memory_order_release);
+                m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+
+                // If we just consumed an outdated job result, ensure we don't block scheduling for
+                // the new epoch.
+                if (isOutdated || isViewOutdated || isTargetSizeOutdated)
+                {
+                    state.isRendering = false;
+
+                    // An HQ progressive job that was scheduled for an older epoch (typical
+                    // during a window resize, where the epoch bumps several times as low-res
+                    // previews are re-issued) is discarded here without advancing currentLine
+                    // or producing a completed frame. Nothing else re-triggers the HQ render
+                    // for the now-current epoch: the coordinator's static catch-up only fires
+                    // on viewport change, and after the resize settles m_dirty is false so the
+                    // render loop early-returns before reaching the HQ-gate. Keep the loop
+                    // alive so the HQ-gate reschedules HQ once the low-res preview is current.
+                    if (isHqRenderJob)
+                    {
+                        m_dirty = true;
+                    }
+                }
+            }
+
+            // A StaticFullFrameProbe result clears the flag regardless of the epoch match,
+            // because when a progressive chunk was in-flight when the probe was scheduled the
+            // chunk's result consumes m_asyncInFlightEpoch first, leaving no epoch match for
+            // the later probe result.
+            if (isStaticFullFrameProbe)
+            {
+                m_asyncStaticFullFrameJobInFlight.store(false, std::memory_order_release);
+            }
+
+            completeCoordinatorTask(result,
+                                    result.completedFrame && !isOutdated && !isViewOutdated &&
+                                      !isTargetSizeOutdated);
+        }
+    }
+
+    bool RenderWindow::scheduleAsyncRenderJob(RenderWindowState & state,
+                                              async_rendering::RenderTaskRequest const * coordinatorTask)
+    {
+        ZoneScoped;
+        ZoneName("scheduleAsyncRenderJob", strlen("scheduleAsyncRenderJob"));
+
+        if (!m_asyncController || !m_asyncController->isRunning())
+        {
+            return false;
+        }
+
+        auto const image = m_core->getResultImage();
+        if (!image)
+        {
+            return false;
+        }
+
+        size_t const height = static_cast<size_t>(image->getHeight());
+
+        if (height == 0 || state.currentLine >= height)
+        {
+            m_dirty = false;
+            state.isRendering = false;
+            return false;
+        }
+
+        // Initialize async resources (worker queue + staging buffer) if needed
+        size_t const width = static_cast<size_t>(image->getWidth());
+        m_asyncController->initializeAsyncResources(*m_core->getComputeContext(), width, height);
+
+        async_rendering::RenderJob job{};
+        job.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+        if (job.epoch == 0)
+        {
+            job.epoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
+            m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
+        }
+        m_asyncController->setLatestEpoch(job.epoch);
+        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+        job.paramGeneration = m_core->getParameterGeneration();
+        job.frameHint = m_asyncFrameCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
+        job.type = async_rendering::RenderJobType::HighQuality;
+        job.width = static_cast<uint32_t>(width);
+        job.height = static_cast<uint32_t>(height);
+
+        // A non-zero start line means we intend to CONTINUE filling a progressive buffer that was
+        // already seeded with a full-frame resample at line 0. If that buffer is gone or no longer
+        // matches the current epoch/view/size — which happens when a stale-size/stale-view discard,
+        // a window resize released it without rewinding state.currentLine, or a parameter change
+        // advanced only the view epoch — the worker would acquire a fresh, unseeded buffer and
+        // render only [startLine, height). The untouched top band [0, startLine) would then be
+        // promoted as a "completed" frame, producing the partial / half-updated HQ image seen
+        // after resizing. The view epoch is essential here: a parameter change bumps ONLY the view
+        // epoch (not the scene epoch), yet it changes the model content of every pixel — continuing
+        // a buffer whose un-overwritten region still holds the previous parameters yields the torn
+        // fresh-top / stale-bottom frame. Restart from line 0 in any of these cases so the buffer
+        // is re-seeded and every horizontal line is rendered for the current state.
+        async_rendering::ProgressiveBufferState const progressiveBufferState{
+          .hasImage =
+            m_asyncProgressiveBuffer != nullptr && m_asyncProgressiveBuffer->image != nullptr,
+          .epoch = m_asyncProgressiveEpoch.load(std::memory_order_acquire),
+          .viewEpoch = m_asyncProgressiveViewEpoch.load(std::memory_order_acquire),
+          .paramGeneration = m_asyncProgressiveParamGeneration.load(std::memory_order_acquire),
+          .width = (m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
+                     ? static_cast<uint32_t>(m_asyncProgressiveBuffer->image->getWidth())
+                     : 0u,
+          .height = (m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
+                      ? static_cast<uint32_t>(m_asyncProgressiveBuffer->image->getHeight())
+                      : 0u};
+        async_rendering::ProgressiveJobTarget const progressiveJobTarget{
+          .epoch = job.epoch,
+          .viewEpoch = job.viewEpoch,
+          .paramGeneration = job.paramGeneration,
+          .width = job.width,
+          .height = job.height};
+        bool const hasSeededProgressiveContinuation =
+          async_rendering::isProgressiveBufferContinuable(progressiveBufferState,
+                                                          progressiveJobTarget);
+        if (state.currentLine > 0 && !hasSeededProgressiveContinuation)
+        {
+            state.currentLine = 0;
+        }
+
+        job.startLine = std::min(state.currentLine, height);
+        if (job.startLine == 0)
+        {
+            state.renderingStepSize =
+              std::min(state.renderingStepSize, kInitialProgressiveStepSize);
+        }
+        job.stepSize =
+          std::max<size_t>(1, std::min(state.renderingStepSize, height - job.startLine));
+        job.precomputeSdf = false;
+        job.enableHighQuality = m_enableHQRendering;
+        job.coordinatorStamp = m_renderUpdateCoordinator.latestStamp();
+        if (coordinatorTask != nullptr)
+        {
+            job.coordinatorRequestId = coordinatorTask->requestId;
+            job.coordinatorStamp = coordinatorTask->stamp;
+        }
+
+        if (job.startLine == 0 && !hasSeededProgressiveContinuation)
+        {
+            // The progressive HQ buffer is seeded by resampling the result image (the low-res
+            // preview) so lines not yet rendered at high quality still show content. If the
+            // result image still holds a *previous* view — which happens during rapid window
+            // resizing, where the view epoch advances faster than the low-res preview can
+            // refresh — the stale-view seed (unrendered region) would mix with the freshly
+            // rendered current-view top band, producing torn frames that show different states
+            // of the view. Detect that here and suppress partial HQ display for this job so the
+            // clean low-res result image is shown until the full HQ frame completes and swaps in.
+            bool const seedViewIsStale =
+              m_lastLowResPreviewViewEpoch.load(std::memory_order_acquire) != job.viewEpoch;
+            if (seedViewIsStale)
+            {
+                m_suppressHQDisplay.store(true, std::memory_order_release);
+            }
+
+            auto * seedBuffer = m_asyncController->acquireWriteBuffer(job.epoch);
+            auto renderProgram = m_core->tryGetBestRenderProgram().value_or(SharedRenderProgram{});
+            bool const seedSourceFits = image->getWidth() >= width && image->getHeight() >= height;
+            bool const seedTargetFits = seedBuffer && seedBuffer->image &&
+                                        seedBuffer->image->getWidth() >= width &&
+                                        seedBuffer->image->getHeight() >= height;
+            if (seedBuffer && seedBuffer->image && renderProgram &&
+                seedSourceFits && seedTargetFits)
+            {
+                renderProgram->resample(*image, *seedBuffer->image, 0, height);
+                seedBuffer->image->invalidateContent();
+                m_asyncProgressiveBuffer = seedBuffer;
+                m_asyncProgressiveEpoch.store(job.epoch, std::memory_order_release);
+                m_asyncProgressiveViewEpoch.store(job.viewEpoch, std::memory_order_release);
+                m_asyncProgressiveParamGeneration.store(job.paramGeneration,
+                                                        std::memory_order_release);
+            }
+            else if (seedBuffer)
+            {
+                [[maybe_unused]] bool const released =
+                  m_asyncController->tryTransitionBuffer(seedBuffer,
+                                                         async_rendering::FrameState::Writing,
+                                                         async_rendering::FrameState::Idle);
+            }
+        }
+
+        ZoneValue(job.startLine);
+        ZoneValue(job.stepSize);
+        ZoneValue(job.epoch);
+
+        m_asyncInFlightEpoch.store(job.epoch, std::memory_order_release);
+        m_asyncJobInFlight.store(true, std::memory_order_release);
+        m_asyncController->enqueueJob(job);
+
+        ZoneText("JobEnqueued", 11);
+        return true;
+    }
+
+    bool RenderWindow::tryRenderRealtimeFrameSync(
+      async_rendering::RenderTaskRequest const & task)
+    {
+        ProfileFunction;
+
+        if (!m_asyncController || !m_core || !m_document)
+        {
+            return false;
+        }
+
+        auto assembly = m_document->getAssembly();
+        if (!assembly || !m_core->isRendererReady())
+        {
+            return false;
+        }
+
+        // Push latest parameters — the coordinator has already done one upload, but the
+        // assembly may have been updated between that upload and now (e.g. another UI event
+        // fired between the ParameterUpload task and the RealtimeFullFrame task).
+        (void) m_core->tryToupdateParameter(*assembly);
+
+        // Initialize async resources (allocates triple-buffer images at current resolution)
+        auto const image = m_core->getResultImage();
+        if (!image)
+        {
+            return false;
+        }
+        size_t const width = static_cast<size_t>(image->getWidth());
+        size_t const height = static_cast<size_t>(image->getHeight());
+        if (width == 0 || height == 0)
+        {
+            return false;
+        }
+        m_asyncController->initializeAsyncResources(*m_core->getComputeContext(), width, height);
+
+        // Acquire an Idle triple-buffer slot to render into
+        uint64_t const epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+        auto * writeBuffer = m_asyncController->acquireWriteBuffer(epoch);
+        if (!writeBuffer || !writeBuffer->image)
+        {
+            return false;
+        }
+
+        auto const releaseBuffer = [&]()
+        {
+            [[maybe_unused]] bool const released =
+              m_asyncController->tryTransitionBuffer(writeBuffer,
+                                                     async_rendering::FrameState::Writing,
+                                                     async_rendering::FrameState::Idle);
+        };
+
+        if (writeBuffer->image->getWidth() < static_cast<int>(width) ||
+            writeBuffer->image->getHeight() < static_cast<int>(height))
+        {
+            releaseBuffer();
+            return false;
+        }
+
+        // Reuse the worker's command queue — it is idle (no async job enqueued) and avoids
+        // GL-interop synchronization overhead of the main queue.
+        auto queueOwner = m_asyncController->workerQueueShared();
+        if (!queueOwner)
+        {
+            releaseBuffer();
+            return false;
+        }
+        cl::CommandQueue const & queue = *queueOwner;
+
+        auto computeToken = m_core->requestComputeToken();
+        if (!computeToken.has_value())
+        {
+            releaseBuffer();
+            return false;
+        }
+
+        auto settings = m_core->getResourceContext()->getRenderingSettings();
+        settings.approximation = AM_FULL_MODEL;
+
+        auto const startTime = std::chrono::steady_clock::now();
+
+        cl::Event renderEvent{};
+        bool const advanced = m_core->renderSceneComputeOnlyWithSettings(
+          queue, 0, height, *writeBuffer->image, settings, &renderEvent);
+
+        if (!advanced || !renderEvent())
+        {
+            releaseBuffer();
+            return false;
+        }
+
+        // Block until the GPU is done.  In realtime mode the user has opted into lower
+        // peak throughput in exchange for zero-latency feedback, and Auto mode only takes
+        // this path once performance has been measured to fit within the frame budget.
+        if (!waitForEventBlocking(renderEvent))
+        {
+            releaseBuffer();
+            return false;
+        }
+
+        auto const endTime = std::chrono::steady_clock::now();
 
-                // If we just consumed an outdated job result, ensure we don't block scheduling for
-                // the new epoch.
-                if (isOutdated)
-                {
-                    state.isRendering = false;
-                }
-            }
+        // Publish the completed buffer, then promote immediately to front for display
+        uint64_t const viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+        m_asyncController->publishFrame(writeBuffer,
+                                                                                task.requestId,
+                                                                                epoch,
+                                                                                viewEpoch,
+                                                                                task.stamp,
+                                                                                async_rendering::FramePresentationQuality::FullQuality);
+
+                auto * newFront = m_asyncController->promoteReadyToFront(
+                    task.stamp, async_rendering::RenderStampMask::displayFrame());
+        if (newFront && newFront->image)
+        {
+            newFront->image->invalidateContent();
+            newFront->image->bind();
+            newFront->image->unbind();
+                        bool const promoted = m_asyncController->finalizeFrontPromotion(newFront);
+                        if (promoted)
+                        {
+                                [[maybe_unused]] bool const presented = m_presentedFrames.presentCandidate(
+                                    async_rendering::FramePresentationCandidate{
+                                        .frameId = task.requestId,
+                                        .stamp = task.stamp,
+                                        .quality = async_rendering::FramePresentationQuality::FullQuality,
+                                        .source = async_rendering::FramePresentationSource::ExactRealtime,
+                                        .completedFrame = true},
+                                    task.stamp);
+                        }
         }
+
+        // Feed the timing sample to the realtime learning controller so Auto mode can track
+        // whether performance is still within budget and deactivate realtime if it degrades.
+        uint64_t const durationNs = static_cast<uint64_t>(
+          std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count());
+        float const durationMs =
+          static_cast<float>(static_cast<double>(durationNs) / 1'000'000.0);
+        async_rendering::RealtimeRaymarchSample sample{};
+        sample.durationMs = durationMs;
+        sample.width = static_cast<uint32_t>(width);
+        sample.height = static_cast<uint32_t>(height);
+        sample.renderedLines = height;
+        sample.totalLines = height;
+        sample.completedFrame = true;
+        sample.cancelled = false;
+        m_renderUpdateCoordinator.recordInteractiveRealtimeSample(sample);
+
+        m_dirty = false;
+        m_suppressHQDisplay.store(false, std::memory_order_release);
+        m_lowResFeedbackPending.store(false, std::memory_order_release);
+        m_lastLowResPreviewEpoch.store(epoch, std::memory_order_release);
+        m_view->stopAnimationMode();
+
+        return true;
     }
 
-    bool RenderWindow::scheduleAsyncRenderJob(RenderWindowState & state)
+        bool RenderWindow::scheduleFullFrameRenderJob(
+      RenderWindowState & state,
+            async_rendering::RenderTaskRequest const * coordinatorTask,
+            async_rendering::RenderJobType jobType)
     {
         ZoneScoped;
-        ZoneName("scheduleAsyncRenderJob", strlen("scheduleAsyncRenderJob"));
+                ZoneName("scheduleFullFrameRenderJob", strlen("scheduleFullFrameRenderJob"));
 
-        if (!m_asyncController || !m_asyncController->isRunning())
+        if (!m_asyncController || !m_asyncController->isRunning() || !m_enableHQRendering)
         {
             return false;
         }
@@ -2084,19 +3349,27 @@ namespace gladius::ui
             return false;
         }
 
+        size_t const width = static_cast<size_t>(image->getWidth());
         size_t const height = static_cast<size_t>(image->getHeight());
-
-        if (height == 0 || state.currentLine >= height)
+        if (width == 0 || height == 0)
         {
-            m_dirty = false;
-            state.isRendering = false;
             return false;
         }
 
-        // Initialize async resources (worker queue + staging buffer) if needed
-        size_t const width = static_cast<size_t>(image->getWidth());
         m_asyncController->initializeAsyncResources(*m_core->getComputeContext(), width, height);
 
+        if (m_asyncProgressiveBuffer && !m_asyncJobInFlight.load(std::memory_order_acquire))
+        {
+            [[maybe_unused]] bool const released =
+              m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
+                                                     async_rendering::FrameState::Writing,
+                                                     async_rendering::FrameState::Idle);
+            m_asyncProgressiveBuffer = nullptr;
+            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+            m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+            m_asyncProgressiveParamGeneration.store(0, std::memory_order_release);
+        }
+
         async_rendering::RenderJob job{};
         job.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
         if (job.epoch == 0)
@@ -2105,57 +3378,41 @@ namespace gladius::ui
             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
         }
         m_asyncController->setLatestEpoch(job.epoch);
+
+        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+        job.paramGeneration = m_core->getParameterGeneration();
         job.frameHint = m_asyncFrameCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
-        job.type = async_rendering::RenderJobType::HighQuality;
+        job.type = jobType;
         job.width = static_cast<uint32_t>(width);
         job.height = static_cast<uint32_t>(height);
-        job.startLine = std::min(state.currentLine, height);
-        if (job.startLine == 0)
-        {
-            state.renderingStepSize =
-              std::min(state.renderingStepSize, kInitialProgressiveStepSize);
-        }
-        job.stepSize =
-          std::max<size_t>(1, std::min(state.renderingStepSize, height - job.startLine));
+        job.startLine = 0;
+        job.stepSize = height;
         job.precomputeSdf = false;
-        job.enableHighQuality = m_enableHQRendering;
-
-        if (job.startLine == 0 &&
-            (!m_asyncProgressiveBuffer ||
-             m_asyncProgressiveEpoch.load(std::memory_order_acquire) != job.epoch))
+        job.enableHighQuality = true;
+        job.coordinatorStamp = m_renderUpdateCoordinator.latestStamp();
+        if (coordinatorTask != nullptr)
         {
-            auto * seedBuffer = m_asyncController->acquireWriteBuffer(job.epoch);
-            auto renderProgram = m_core->tryGetBestRenderProgram().value_or(SharedRenderProgram{});
-            bool const seedSourceFits = image->getWidth() >= width && image->getHeight() >= height;
-            bool const seedTargetFits = seedBuffer && seedBuffer->image &&
-                                        seedBuffer->image->getWidth() >= width &&
-                                        seedBuffer->image->getHeight() >= height;
-            if (seedBuffer && seedBuffer->image && renderProgram &&
-                seedSourceFits && seedTargetFits)
-            {
-                renderProgram->resample(*image, *seedBuffer->image, 0, height);
-                seedBuffer->image->invalidateContent();
-                m_asyncProgressiveBuffer = seedBuffer;
-                m_asyncProgressiveEpoch.store(job.epoch, std::memory_order_release);
-            }
-            else if (seedBuffer)
-            {
-                [[maybe_unused]] bool const released =
-                  m_asyncController->tryTransitionBuffer(seedBuffer,
-                                                         async_rendering::FrameState::Writing,
-                                                         async_rendering::FrameState::Idle);
-            }
+            job.coordinatorRequestId = coordinatorTask->requestId;
+            job.coordinatorStamp = coordinatorTask->stamp;
         }
 
-        ZoneValue(job.startLine);
-        ZoneValue(job.stepSize);
-        ZoneValue(job.epoch);
+        state.currentLine = 0;
+        state.renderingStepSize = job.stepSize;
+        state.isRendering = true;
+        m_forceLowResRenderOnNextFrame.store(false, std::memory_order_release);
+        m_lowResFeedbackPending.store(false, std::memory_order_release);
 
         m_asyncInFlightEpoch.store(job.epoch, std::memory_order_release);
+        m_asyncInFlightViewEpoch.store(job.viewEpoch, std::memory_order_release);
         m_asyncJobInFlight.store(true, std::memory_order_release);
+        m_asyncRealtimeJobInFlight.store(job.type == async_rendering::RenderJobType::RealtimeHighQuality,
+                                         std::memory_order_release);
+        m_asyncStaticFullFrameJobInFlight.store(
+            job.type == async_rendering::RenderJobType::StaticFullFrameProbe,
+            std::memory_order_release);
         m_asyncController->enqueueJob(job);
 
-        ZoneText("JobEnqueued", 11);
+        ZoneText("FullFrameJobEnqueued", 20);
         return true;
     }
 
@@ -2165,27 +3422,32 @@ namespace gladius::ui
       -> coro::task<async_rendering::FrameResultMeta>
     {
         // NOTE: No ZoneScoped here — Tracy zones are not coroutine-safe across thread hops.
-        // co_await waitForEvent() resumes on the OpenCL callback thread, so the zone destructor
-        // would fire on a different thread than where it was created.
-        // Use the inner ZoneScopedN blocks (which don't cross co_await) for profiling.
+        // Keep profiling scopes inside non-suspending blocks only.
 #ifdef TRACY_ENABLE
         tracy::SetThreadName("AsyncRenderWorker");
 #endif
 
-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
+        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
         auto const & commandQueue =
-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
-        if (workerQueue == nullptr) {}
+          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
 
         auto const cancellationRequested = [&]() -> bool { return cancelCheck && cancelCheck(); };
 
         async_rendering::FrameResultMeta result{};
         result.frameId = job.frameHint;
         result.epoch = job.epoch;
+        result.viewEpoch = job.viewEpoch;
         result.jobType = job.type;
         result.width = job.width;
         result.height = job.height;
-        result.startLine = job.startLine;
+                result.startLine = job.startLine;
+                result.coordinatorRequestId = job.coordinatorRequestId;
+                result.coordinatorStamp = job.coordinatorStamp;
+                auto const jobType = job.type;
+                bool const isExactRealtimeJob = jobType == async_rendering::RenderJobType::RealtimeHighQuality;
+                bool const isStaticFullFrameProbe =
+                    jobType == async_rendering::RenderJobType::StaticFullFrameProbe;
+                bool const usesFullModelApproximation = isExactRealtimeJob || isStaticFullFrameProbe;
 
         if (cancellationRequested())
         {
@@ -2217,13 +3479,58 @@ namespace gladius::ui
             {
                 m_asyncProgressiveBuffer = nullptr;
                 m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+                m_asyncProgressiveParamGeneration.store(0, std::memory_order_release);
             }
 
             writeBuffer = nullptr;
         };
 
-        if (!m_asyncProgressiveBuffer ||
-            m_asyncProgressiveEpoch.load(std::memory_order_acquire) != job.epoch)
+        if (usesFullModelApproximation)
+        {
+            // Full-frame jobs (StaticFullFrameProbe / RealtimeHighQuality): acquire a dedicated
+            // write buffer without reading or writing m_asyncProgressiveBuffer.  If a progressive
+            // chunk was running before this probe was scheduled, the UI thread keeps a reference
+            // to that partial chunk buffer.  Setting m_asyncProgressiveBuffer to the probe buffer
+            // from this worker thread would cause the display to show the probe's write buffer
+            // (with stale partial content) until the probe completes.
+            writeBuffer = m_asyncController->acquireWriteBuffer(job.epoch);
+            if (!writeBuffer)
+            {
+                result.cancelled = true;
+                co_return result;
+            }
+            if (writeBuffer->image)
+            {
+                if (writeBuffer->image->getWidth() < job.width ||
+                    writeBuffer->image->getHeight() < job.height)
+                {
+                    releaseProgressiveBuffer();
+                    result.cancelled = true;
+                    co_return result;
+                }
+            }
+        }
+        else if (!async_rendering::isProgressiveBufferContinuable(
+                   async_rendering::ProgressiveBufferState{
+                     .hasImage = m_asyncProgressiveBuffer != nullptr &&
+                                 m_asyncProgressiveBuffer->image != nullptr,
+                     .epoch = m_asyncProgressiveEpoch.load(std::memory_order_acquire),
+                     .viewEpoch = m_asyncProgressiveViewEpoch.load(std::memory_order_acquire),
+                     .paramGeneration =
+                       m_asyncProgressiveParamGeneration.load(std::memory_order_acquire),
+                     .width = (m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
+                                ? static_cast<uint32_t>(m_asyncProgressiveBuffer->image->getWidth())
+                                : 0u,
+                     .height =
+                       (m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
+                         ? static_cast<uint32_t>(m_asyncProgressiveBuffer->image->getHeight())
+                         : 0u},
+                   async_rendering::ProgressiveJobTarget{.epoch = job.epoch,
+                                                         .viewEpoch = job.viewEpoch,
+                                                         .paramGeneration = job.paramGeneration,
+                                                         .width = job.width,
+                                                         .height = job.height}))
         {
             writeBuffer = m_asyncController->acquireWriteBuffer(job.epoch);
             if (!writeBuffer)
@@ -2245,6 +3552,9 @@ namespace gladius::ui
 
             m_asyncProgressiveBuffer = writeBuffer;
             m_asyncProgressiveEpoch.store(job.epoch, std::memory_order_release);
+            m_asyncProgressiveViewEpoch.store(job.viewEpoch, std::memory_order_release);
+            m_asyncProgressiveParamGeneration.store(job.paramGeneration,
+                                                    std::memory_order_release);
         }
         else
         {
@@ -2273,24 +3583,57 @@ namespace gladius::ui
                 {
                     ImageRGBA & targetCLBuffer = *writeBuffer->image;
 
-                    cl::Event renderEvent{};
-                    bool advanced = false;
-                    
-                    advanced = m_core->renderSceneComputeOnly(
-                        commandQueue, job.startLine, endLine, targetCLBuffer, &renderEvent);
-
-                    if (renderEvent())
-                    {
-                        co_await waitForEvent(renderEvent, cancelCheck);
-                    }
-
-                    if (cancellationRequested())
+                    auto computeToken = m_core->requestComputeToken();
+                    if (!computeToken.has_value())
                     {
                         result.cancelled = true;
                     }
+                    else
+                    {
+                        cl::Event renderEvent{};
+                        bool advanced = false;
+
+                        if (usesFullModelApproximation)
+                        {
+                            auto assembly = m_document ? m_document->getAssembly() : nullptr;
+                            if (assembly && m_core->isRendererReady())
+                            {
+                                (void) m_core->tryToupdateParameter(*assembly);
+                            }
+
+                            auto settings = m_core->getResourceContext()->getRenderingSettings();
+                            settings.approximation = AM_FULL_MODEL;
+                            advanced = m_core->renderSceneComputeOnlyWithSettings(
+                              commandQueue,
+                              job.startLine,
+                              endLine,
+                              targetCLBuffer,
+                              settings,
+                              &renderEvent);
+                        }
+                        else
+                        {
+                            advanced = m_core->renderSceneComputeOnly(
+                              commandQueue, job.startLine, endLine, targetCLBuffer, &renderEvent);
+                        }
 
-                    result.completedLine = advanced ? endLine : job.startLine;
-                    result.completedFrame = result.completedLine >= job.height;
+                        if (renderEvent())
+                        {
+                            advanced = waitForEventBlocking(renderEvent) && advanced;
+                        }
+
+                        if (cancellationRequested())
+                        {
+                            result.cancelled = true;
+                        }
+
+                        result.completedLine = advanced ? endLine : job.startLine;
+                        result.completedFrame = result.completedLine >= job.height;
+                        if (!advanced && usesFullModelApproximation)
+                        {
+                            result.cancelled = true;
+                        }
+                    }
                 }
                 else
                 {
@@ -2309,9 +3652,21 @@ namespace gladius::ui
         }
         else if (result.completedFrame)
         {
-            m_asyncController->publishFrame(writeBuffer, result.frameId, result.epoch);
-            m_asyncProgressiveBuffer = nullptr;
-            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                        m_asyncController->publishFrame(
+                            writeBuffer,
+                            result.frameId,
+                            result.epoch,
+                            result.viewEpoch,
+                            result.coordinatorStamp,
+                            async_rendering::FramePresentationQuality::FullQuality);
+            // Only clear m_asyncProgressiveBuffer for progressive rendering (not full-frame jobs).
+            // Full-frame jobs never set m_asyncProgressiveBuffer, so there is nothing to clear.
+            if (!usesFullModelApproximation)
+            {
+                m_asyncProgressiveBuffer = nullptr;
+                m_asyncProgressiveEpoch.store(0, std::memory_order_release);
+                        m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+            }
         }
 
         auto const endTime = std::chrono::steady_clock::now();
@@ -2646,7 +4001,11 @@ namespace gladius::ui
 
         // Cache window state
         m_isWindowHovered = ImGui::IsWindowHovered();
-        m_isWindowFocused = ImGui::IsWindowFocused();
+        if (m_isWindowHovered && !ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows))
+        {
+            ImGui::SetWindowFocus();
+        }
+        m_isWindowFocused = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows);
 
         // Handle key input if focused
         if (ImGui::IsWindowFocused() && !ImGui::IsAnyItemFocused() &&
@@ -2690,7 +4049,9 @@ namespace gladius::ui
         }
     }
 
-    void RenderWindow::showProgressSpinner(ImVec2 const & windowCenter, char const * label)
+    void RenderWindow::showProgressSpinner(ImVec2 const & windowCenter,
+                                           char const * label,
+                                           ImVec4 const & indicatorColor)
     {
         m_view->startAnimationMode();
         ImGuiWindowFlags overlayFlags =
@@ -2707,7 +4068,6 @@ namespace gladius::ui
         if (ImGui::Begin("ProgressIndicator", &open, overlayFlags))
         {
             ImGui::SetWindowPos({windowCenter.x - 15.f, windowCenter.y - 15.f});
-            ImVec4 const indicatorColor = ImVec4(1.0f, 0.0f, 0.0f, 0.8f);
             ui::loadingIndicatorCircle(label,
                                        30,
                                        indicatorColor,
@@ -2747,13 +4107,13 @@ namespace gladius::ui
     void RenderWindow::zoomIn()
     {
         m_camera.zoom(-0.1f); // Negative zoom means zoom in
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::zoomOut()
     {
         m_camera.zoom(0.1f); // Positive zoom means zoom out
-        invalidateView();
+        invalidateCameraView();
     }
 
     void RenderWindow::resetZoom()
@@ -2767,10 +4127,11 @@ namespace gladius::ui
         }
 
         m_camera.adjustDistanceToTarget(*bbox, m_renderWindowSize_px.x, m_renderWindowSize_px.y);
-        invalidateView();
+        invalidateCameraView();
     }
 
-    void RenderWindow::scheduleAsyncBboxUpdate()
+    void RenderWindow::scheduleAsyncBboxUpdate(
+      async_rendering::RenderTaskRequest const * coordinatorTask)
     {
         if (!m_asyncController || !m_asyncInitialized)
         {
@@ -2791,6 +4152,11 @@ namespace gladius::ui
         async_rendering::RenderJob job{};
         job.type = async_rendering::RenderJobType::BoundingBoxUpdate;
         job.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+        if (coordinatorTask != nullptr)
+        {
+            job.coordinatorRequestId = coordinatorTask->requestId;
+            job.coordinatorStamp = coordinatorTask->stamp;
+        }
 
         m_asyncController->enqueueJob(job);
     }
@@ -2806,6 +4172,8 @@ namespace gladius::ui
         result.epoch = job.epoch;
         result.jobType = job.type;
         result.cancelled = false;
+        result.coordinatorRequestId = job.coordinatorRequestId;
+        result.coordinatorStamp = job.coordinatorStamp;
 
         auto const startTime = std::chrono::steady_clock::now();
 
@@ -2858,7 +4226,7 @@ namespace gladius::ui
       -> coro::task<async_rendering::FrameResultMeta>
     {
         // NOTE: No ZoneScoped here — Tracy zones are not coroutine-safe across thread hops.
-        // co_await waitForEvent() resumes on the OpenCL callback thread.
+        // Keep profiling scopes inside non-suspending blocks only.
 
         using namespace async_rendering;
 
@@ -2867,6 +4235,8 @@ namespace gladius::ui
         result.jobType = job.type;
         result.cancelled = false;
         result.precomputedSdfUpdated = false;
+        result.coordinatorRequestId = job.coordinatorRequestId;
+        result.coordinatorStamp = job.coordinatorStamp;
 
         auto const startTime = std::chrono::steady_clock::now();
 
@@ -2898,10 +4268,9 @@ namespace gladius::ui
         try
         {
             // Get worker queue (or fallback to main queue)
-            auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
-
-            cl::CommandQueue const * queuePtr =
-              workerQueue != nullptr ? workerQueue : &m_core->getComputeContext()->GetQueue();
+            auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
+            cl::CommandQueue const & queueRef =
+              queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
 
             // Acquire compute token non-blockingly to serialize with refreshWorker().
             // refreshWorker() holds the mutex while it rebuilds CL programs and
@@ -2915,12 +4284,11 @@ namespace gladius::ui
                 co_return result;
             }
 
-            // Launch async SDF precomputation (returns cl::Event)
-            cl::Event sdfEvent = m_core->precomputeSdfAsync(*queuePtr);
-
-            // Release the compute token — the kernel is already enqueued and the
-            // CL runtime retains its own references to the memory objects.
-            computeToken.reset();
+            // Launch async SDF precomputation (returns cl::Event). Keep the compute token until
+            // the GPU event completes: the kernel reads/writes shared resource buffers and those
+            // buffers must not be reallocated or rewritten by another host path while the event is
+            // still running.
+            cl::Event sdfEvent = m_core->precomputeSdfAsync(queueRef);
 
             if (!sdfEvent())
             {
@@ -2938,11 +4306,10 @@ namespace gladius::ui
                 co_return result;
             }
 
-            // Await SDF completion using waitForEvent helper
-            co_await waitForEvent(sdfEvent, cancelCheck);
+            bool const sdfCompleted = waitForEventBlocking(sdfEvent);
 
             // Check if cancelled during wait - don't invalidate, keep old SDF
-            if (cancelCheck && cancelCheck())
+            if (!sdfCompleted || (cancelCheck && cancelCheck()))
             {
                 result.cancelled = true;
                 co_return result;
@@ -3010,7 +4377,8 @@ namespace gladius::ui
 
     // ============== Async Preview Rendering ==============
 
-    bool RenderWindow::scheduleAsyncPreviewJob()
+    bool RenderWindow::scheduleAsyncPreviewJob(
+      async_rendering::RenderTaskRequest const * coordinatorTask)
     {
         ZoneScoped;
         ZoneName("scheduleAsyncPreviewJob", strlen("scheduleAsyncPreviewJob"));
@@ -3053,6 +4421,7 @@ namespace gladius::ui
             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
         }
         m_asyncController->setLatestEpoch(job.epoch);
+        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
 
         // Use low-res preview resolution
         auto const [previewWidth, previewHeight] = m_core->getLowResPreviewResolution();
@@ -3063,6 +4432,12 @@ namespace gladius::ui
         job.stepSize = static_cast<size_t>(previewHeight);
         job.precomputeSdf = false;
         job.enableHighQuality = false;
+        job.coordinatorStamp = m_renderUpdateCoordinator.latestStamp();
+        if (coordinatorTask != nullptr)
+        {
+            job.coordinatorRequestId = coordinatorTask->requestId;
+            job.coordinatorStamp = coordinatorTask->stamp;
+        }
 
         // Track preview job state
         m_asyncPreviewEpoch.store(job.epoch, std::memory_order_release);
@@ -3087,16 +4462,19 @@ namespace gladius::ui
 
         using namespace async_rendering;
 
-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
+        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
         auto const & commandQueue =
-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
+          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
 
         FrameResultMeta result{};
         result.frameId = job.frameHint;
         result.epoch = job.epoch;
+        result.viewEpoch = job.viewEpoch;
         result.jobType = job.type;
         result.width = job.width;
         result.height = job.height;
+        result.coordinatorRequestId = job.coordinatorRequestId;
+        result.coordinatorStamp = job.coordinatorStamp;
 
         // Note: We do NOT cancel preview jobs based on epoch changes.
         // This ensures smooth visual feedback during camera movement.
@@ -3109,12 +4487,20 @@ namespace gladius::ui
         auto const startTime = std::chrono::steady_clock::now();
 
         // Perform the async preview render using the low-res preview infrastructure.
-        // Preview rendering intentionally waits for the precomputed SDF so the
-        // feedback pass stays cheap and independent of mesh complexity.
+        // When the precomputed SDF is unavailable (e.g. parameter edits invalidated it),
+        // fall back to a low-resolution full-model render instead of producing no
+        // feedback frame at all.
         {
             ZoneScopedN("RenderLowResPreviewAsync");
             auto computeToken = m_core->waitForComputeToken();
 
+            // Push latest parameters so the preview reflects the current assembly state.
+            if (auto assembly = m_document ? m_document->getAssembly() : nullptr;
+                assembly && m_core->isRendererReady())
+            {
+                (void) m_core->tryToupdateParameter(*assembly);
+            }
+
             // Use the non-blocking async preview render
             // This renders at low resolution and returns a cl::Event for completion tracking
             auto lowResImage = m_core->getLowResPreviewImage();
@@ -3125,9 +4511,10 @@ namespace gladius::ui
                 co_return result;
             }
 
-            // Kick off the async render with distance output for HQ initialization (FR-005)
-            // This populates the distance init buffer for use by subsequent HQ renders
-            cl::Event renderEvent = m_core->renderLowResPreviewWithDistanceOutputAsync(commandQueue, *lowResImage);
+                        auto const launch =
+                            launchAsyncPreviewRender(*m_core, commandQueue, *lowResImage);
+                        bool const producedDistanceInit = launch.producedDistanceInit;
+                        cl::Event renderEvent = launch.event;
 
             if (!renderEvent())
             {
@@ -3137,52 +4524,12 @@ namespace gladius::ui
                 co_return result;
             }
 
-            // Wait for GPU completion using polling with timeout instead of blocking wait.
-            // Some OpenCL implementations (e.g., rusticl) have issues with event.wait().
-            // Poll with short sleeps and timeout to avoid hangs.
-            auto const pollStart = std::chrono::steady_clock::now();
-            auto constexpr timeout = std::chrono::milliseconds(500);
-            bool eventCompleted = false;
-            
-            while (!eventCompleted)
+            bool const eventCompleted = waitForEventBlocking(renderEvent);
+            if (!eventCompleted)
             {
-                try
-                {
-                    cl_int status = CL_QUEUED;
-                    renderEvent.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS, &status);
-                    
-                    if (status == CL_COMPLETE)
-                    {
-                        eventCompleted = true;
-                    }
-                    else if (status < 0)
-                    {
-                        // Error status
-                        result.cancelled = true;
-                        m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
-                        co_return result;
-                    }
-                    else
-                    {
-                        // Check timeout
-                        auto const elapsed = std::chrono::steady_clock::now() - pollStart;
-                        if (elapsed > timeout)
-                        {
-                            result.cancelled = true;
-                            m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
-                            co_return result;
-                        }
-                        
-                        // Sleep to avoid busy-waiting (500us reduces CPU usage while staying responsive)
-                        std::this_thread::sleep_for(std::chrono::microseconds(500));
-                    }
-                }
-                catch (std::exception const &)
-                {
-                    result.cancelled = true;
-                    m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
-                    co_return result;
-                }
+                result.cancelled = true;
+                m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
+                co_return result;
             }
 
             // Only check for shutdown, not epoch-based cancellation
@@ -3195,9 +4542,12 @@ namespace gladius::ui
 
             // Finish the queue to ensure all work is complete before UI thread reads the buffer.
             commandQueue.finish();
-            
-            // Mark distance init buffer as valid - HQ renders can now use it (FR-005)
-            m_core->setDistanceInitBufferValid();
+
+            // Mark distance init buffer as valid only when the preview actually populated it.
+            if (producedDistanceInit)
+            {
+                m_core->setDistanceInitBufferValid();
+            }
 
             // NOTE: We intentionally do NOT resample here because resample writes to
             // m_resultImage which is a GL-interop buffer. GL operations must happen
@@ -3214,9 +4564,14 @@ namespace gladius::ui
         PreviewResultMeta previewMeta{};
         previewMeta.frameId = job.frameHint;
         previewMeta.epoch = job.epoch;
+        previewMeta.viewEpoch = job.viewEpoch;
         previewMeta.latencyNs = result.computeDurationNs;
         previewMeta.cancelled = false;
         previewMeta.sdfWasValid = m_core->isSdfValid();
+        previewMeta.quality = async_rendering::FramePresentationQuality::Preview;
+        previewMeta.source = async_rendering::FramePresentationSource::LowResolutionPreview;
+        previewMeta.coordinatorRequestId = job.coordinatorRequestId;
+        previewMeta.coordinatorStamp = job.coordinatorStamp;
 
         m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
         // Note: Don't set m_asyncPreviewFrameId here - it's set in processAsyncPreviewResults
@@ -3246,22 +4601,57 @@ namespace gladius::ui
 
         auto const & meta = result.value();
 
-        // Skip frames that are older than what we've already displayed.
-        // This ensures we never show an older frame after a newer one.
-        // Use frameId (which is monotonically increasing) for ordering.
-        auto const lastDisplayedFrame = m_asyncPreviewFrameId.load(std::memory_order_acquire);
-        if (meta.frameId <= lastDisplayedFrame)
+        auto presentedFrame = m_presentedFrames.presentedFrame();
+        if (!presentedFrame.has_value())
         {
-            ZoneText("OutOfOrderPreviewSkipped", 24);
-            m_streamingFrameConsumed.store(true, std::memory_order_release);
-            return;
+            if (auto mirroredFront = m_asyncController->mirroredFrontPresentationBuffer();
+                mirroredFront.has_value())
+            {
+                presentedFrame = async_rendering::PresentedFrame{
+                  .frameId = mirroredFront->frameId,
+                  .stamp = mirroredFront->stamp,
+                  .quality = mirroredFront->quality,
+                  .source = async_rendering::FramePresentationSource::ProgressiveHighQuality,
+                  .completedFrame = mirroredFront->quality ==
+                                    async_rendering::FramePresentationQuality::FullQuality};
+                m_presentedFrames.seedPresentedFrame(*presentedFrame);
+            }
         }
 
-        // Skip cancelled results
-        if (meta.cancelled)
+        auto const requiredPresentationStamp = m_renderUpdateCoordinator.latestStamp();
+
+                bool const cameraLowResInteraction =
+                    m_renderUpdateCoordinator.interactionState() ==
+                        async_rendering::RenderInteractionState::CameraInteracting &&
+                    !isRealtimeRaymarchInteractionActive();
+
+                auto const acceptance = async_rendering::evaluatePreviewResultAcceptance(
+          meta,
+          async_rendering::PreviewResultAcceptanceContext{
+            .requiredStamp = requiredPresentationStamp,
+            .presentedFrame = presentedFrame,
+            .currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire),
+            .currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire),
+            .lastPresentedPreviewFrameId =
+              m_asyncPreviewFrameId.load(std::memory_order_acquire),
+                        .realtimeRaymarchInteractionActive = isRealtimeRaymarchInteractionActive() ||
+                                                                                                m_asyncRealtimeJobInFlight.load(
+                                                                                                    std::memory_order_acquire),
+                        .allowStaleViewDuringCameraInteraction = cameraLowResInteraction});
+
+        if (!acceptance.accepted())
         {
-            ZoneText("CancelledPreviewSkipped", 23);
+            ZoneText("PreviewRejectedByPolicy", 23);
+            if (auto logger = m_core->getSharedLogger())
+            {
+                logger->logInfo(std::string("[Preview] Rejected: ") +
+                                async_rendering::previewResultRejectionReasonName(
+                                  acceptance.rejectionReason));
+            }
             m_streamingFrameConsumed.store(true, std::memory_order_release);
+            auto rejectedMeta = meta;
+            rejectedMeta.cancelled = acceptance.shouldCompleteAsCancelled();
+            completeCoordinatorPreviewTask(rejectedMeta);
             return;
         }
 
@@ -3274,6 +4664,10 @@ namespace gladius::ui
         auto resultImage = m_core->getResultImage();
         auto renderProgram = m_core->tryGetBestRenderProgram().value_or(SharedRenderProgram{});
         bool scheduleAdaptivePreview = false;
+        
+        if (auto logger = m_core->getSharedLogger()) {
+            logger->logInfo(std::string("[Preview] Result Consumed, Latency ") + std::to_string(meta.latencyNs / 1000000) + "ms. Resampling!");
+        }
 
         if (lowResImage && resultImage && renderProgram)
         {
@@ -3290,6 +4684,17 @@ namespace gladius::ui
             resultImage->bind();
             resultImage->unbind();
 
+            auto const previewPresentationStamp = acceptance.presentAsRequiredStamp
+                                                    ? requiredPresentationStamp
+                                                    : meta.coordinatorStamp;
+            [[maybe_unused]] bool const presented = m_presentedFrames.presentCandidate(
+              async_rendering::FramePresentationCandidate{.frameId = meta.frameId,
+                                                          .stamp = previewPresentationStamp,
+                                                          .quality = meta.quality,
+                                                          .source = meta.source,
+                                                          .completedFrame = true},
+              requiredPresentationStamp);
+
             // Update the last displayed frame ID for ordering
             m_asyncPreviewFrameId.store(meta.frameId, std::memory_order_release);
 
@@ -3338,8 +4743,8 @@ namespace gladius::ui
                           std::abs(newHeight - static_cast<int>(currentHeight)) /
                           static_cast<float>(currentHeight) * 100.0f;
 
-                        if (widthChangePercent > kAdaptivePreviewResizeThresholdPercent ||
-                            heightChangePercent > kAdaptivePreviewResizeThresholdPercent)
+                        if (widthChangePercent >= kAdaptivePreviewResizeThresholdPercent ||
+                            heightChangePercent >= kAdaptivePreviewResizeThresholdPercent)
                         {
                             if (m_core->setLowResPreviewResolution(
                                   static_cast<size_t>(newWidth), static_cast<size_t>(newHeight)))
@@ -3360,6 +4765,17 @@ namespace gladius::ui
         m_lowResFeedbackPending.store(false, std::memory_order_release);
         m_lastLowResRenderTime = std::chrono::system_clock::now();
         m_lastLowResPreviewEpoch.store(meta.epoch, std::memory_order_release);
+        m_lastLowResPreviewViewEpoch.store(meta.viewEpoch, std::memory_order_release);
+        auto presentedMeta = meta;
+        if (acceptance.presentAsRequiredStamp)
+        {
+            presentedMeta.coordinatorStamp = requiredPresentationStamp;
+            presentedMeta.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+        }
+        completeCoordinatorPreviewTask(presentedMeta);
+        if (auto logger = m_core->getSharedLogger()) {
+            logger->logInfo("[Preview] Task Complete triggered!");
+        }
 
         if (scheduleAdaptivePreview)
         {
@@ -3370,6 +4786,22 @@ namespace gladius::ui
 
     void RenderWindow::startStreamingPreview()
     {
+        if (m_core)
+        {
+            auto const image = m_core->getResultImage();
+            if (image && image->getWidth() > 0 && image->getHeight() > 0)
+            {
+                auto const width = static_cast<uint32_t>(image->getWidth());
+                auto const height = static_cast<uint32_t>(image->getHeight());
+                queueRenderDecision(m_renderUpdateCoordinator.configureViewport(width, height));
+
+                if (m_asyncJobInFlight.load(std::memory_order_acquire))
+                {
+                    return;
+                }
+            }
+        }
+
         m_streamingPreviewActive.store(true, std::memory_order_release);
 
         // (Re-)schedule the streaming job if none is currently running.
@@ -3383,8 +4815,19 @@ namespace gladius::ui
     }
 
     void RenderWindow::stopStreamingPreview()
+    {
+        finishParameterInteraction();
+    }
+
+    void RenderWindow::finishParameterInteraction()
     {
         m_streamingPreviewActive.store(false, std::memory_order_release);
+        m_streamingFrameConsumed.store(true, std::memory_order_release);
+        if (m_renderUpdateCoordinator.interactionState() ==
+            async_rendering::RenderInteractionState::ParameterInteracting)
+        {
+            queueRenderDecision(m_renderUpdateCoordinator.notifyParameterInteractionEnded());
+        }
     }
 
     void RenderWindow::cancelAllAsyncWork()
@@ -3413,7 +4856,33 @@ namespace gladius::ui
         return m_streamingPreviewActive.load(std::memory_order_acquire);
     }
 
-    bool RenderWindow::scheduleStreamingPreviewJob()
+    async_rendering::RealtimeRaymarchMode RenderWindow::realtimeRaymarchMode() const noexcept
+    {
+        return m_renderUpdateCoordinator.realtimeConfig().mode;
+    }
+
+    bool RenderWindow::isRealtimeActive() const noexcept
+    {
+        return m_renderUpdateCoordinator.isRealtimeSchedulingActive();
+    }
+
+    void RenderWindow::refreshStreamingParameterInteraction()
+    {
+        if (m_core)
+        {
+            m_core->setSdfValid(false);
+            m_core->markBoundingBoxStale();
+        }
+
+        m_dirty = true;
+        m_preComputedSdfDirty.store(true, std::memory_order_release);
+        m_parameterDirty.store(true, std::memory_order_release);
+        m_modelModifiedSinceLastCenter = true;
+        m_lastParameterChangeTime = std::chrono::steady_clock::now();
+    }
+
+    bool RenderWindow::scheduleStreamingPreviewJob(
+      async_rendering::RenderTaskRequest const * coordinatorTask)
     {
         if (!m_asyncController || !m_asyncController->isRunning())
         {
@@ -3444,6 +4913,7 @@ namespace gladius::ui
             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
         }
         m_asyncController->setLatestEpoch(job.epoch);
+        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
 
         auto const [previewWidth, previewHeight] = m_core->getLowResPreviewResolution();
         job.width = static_cast<uint32_t>(previewWidth);
@@ -3453,6 +4923,12 @@ namespace gladius::ui
         job.stepSize = static_cast<size_t>(previewHeight);
         job.precomputeSdf = false;
         job.enableHighQuality = false;
+        job.coordinatorStamp = m_renderUpdateCoordinator.latestStamp();
+        if (coordinatorTask != nullptr)
+        {
+            job.coordinatorRequestId = coordinatorTask->requestId;
+            job.coordinatorStamp = coordinatorTask->stamp;
+        }
 
         m_streamingJobInFlight.store(true, std::memory_order_release);
         m_asyncPreviewJobInFlight.store(true, std::memory_order_release);
@@ -3471,15 +4947,18 @@ namespace gladius::ui
 #endif
         using namespace async_rendering;
 
-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
+        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
         auto const & commandQueue =
-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
+          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
 
         FrameResultMeta result{};
         result.epoch = job.epoch;
+        result.viewEpoch = job.viewEpoch;
         result.jobType = job.type;
         result.width = job.width;
         result.height = job.height;
+        result.coordinatorRequestId = job.coordinatorRequestId;
+        result.coordinatorStamp = job.coordinatorStamp;
 
         auto const shouldStop = [&]() -> bool {
             return !m_streamingPreviewActive.load(std::memory_order_acquire) ||
@@ -3541,6 +5020,14 @@ namespace gladius::ui
 
             auto const iterStart = std::chrono::steady_clock::now();
 
+            auto computeToken = m_core->requestComputeToken();
+            if (!computeToken.has_value())
+            {
+                m_streamingFrameConsumed.store(true, std::memory_order_release);
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                continue;
+            }
+
             // Push latest Assembly parameter values to GPU.
             // Skip when the renderer is not ready (compilation in progress) —
             // refreshWorker modifies the Assembly without a dedicated lock,
@@ -3550,14 +5037,16 @@ namespace gladius::ui
                 (void) m_core->tryToupdateParameter(*assembly);
             }
 
-            // Render low-res preview
-            cl::Event renderEvent =
-              m_core->renderLowResPreviewWithDistanceOutputAsync(commandQueue, *lowResImage);
+                        auto const launch =
+                            launchAsyncPreviewRender(*m_core, commandQueue, *lowResImage);
+                        bool const producedDistanceInit = launch.producedDistanceInit;
+                        cl::Event renderEvent = launch.event;
 
             if (!renderEvent())
             {
                 // Precondition failed — program not valid or similar.
                 // Retry a few times in case compilation is finishing.
+                m_streamingFrameConsumed.store(true, std::memory_order_release);
                 ++consecutiveFailures;
                 if (consecutiveFailures >= kMaxConsecutiveFailures)
                 {
@@ -3567,49 +5056,11 @@ namespace gladius::ui
                 continue;
             }
 
-            // Poll GPU completion. Use a generous timeout for driver hiccups,
-            // but preview rendering itself never falls back to full-model SDF.
-            auto constexpr timeout = std::chrono::milliseconds(5000);
-            auto const pollStart = std::chrono::steady_clock::now();
-            bool eventCompleted = false;
-
-            while (!eventCompleted)
-            {
-                try
-                {
-                    cl_int status = CL_QUEUED;
-                    renderEvent.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS, &status);
-
-                    if (status == CL_COMPLETE)
-                    {
-                        eventCompleted = true;
-                    }
-                    else if (status < 0)
-                    {
-                        break; // Error
-                    }
-                    else
-                    {
-                        if (std::chrono::steady_clock::now() - pollStart > timeout)
-                        {
-                            break; // Timeout
-                        }
-                        std::this_thread::sleep_for(std::chrono::microseconds(500));
-                    }
-                }
-                catch (std::exception const &)
-                {
-                    eventCompleted = false;
-                    break;
-                }
-            }
+            bool const eventCompleted = waitForEventBlocking(renderEvent);
 
             if (!eventCompleted)
             {
-                // GPU work timed out or errored — flush (not finish!) so
-                // we don't block the coroutine indefinitely on a GPU stall.
-                // The next enqueue will be ordered after pending work.
-                try { commandQueue.flush(); } catch (...) {}
+                m_streamingFrameConsumed.store(true, std::memory_order_release);
                 ++consecutiveFailures;
                 if (consecutiveFailures >= kMaxConsecutiveFailures)
                 {
@@ -3620,15 +5071,23 @@ namespace gladius::ui
 
             consecutiveFailures = 0;
             commandQueue.finish();
-            m_core->setDistanceInitBufferValid();
+            if (producedDistanceInit)
+            {
+                m_core->setDistanceInitBufferValid();
+            }
 
             // Publish frame for UI thread consumption
             ++frameCounter;
             PreviewResultMeta previewMeta{};
             previewMeta.frameId = frameCounter;
             previewMeta.epoch = job.epoch;
+            previewMeta.viewEpoch = job.viewEpoch;
             previewMeta.cancelled = false;
             previewMeta.sdfWasValid = m_core->isSdfValid();
+            previewMeta.quality = async_rendering::FramePresentationQuality::Preview;
+            previewMeta.source = async_rendering::FramePresentationSource::StreamingPreview;
+            previewMeta.coordinatorRequestId = job.coordinatorRequestId;
+            previewMeta.coordinatorStamp = job.coordinatorStamp;
 
             auto const iterEnd = std::chrono::steady_clock::now();
             previewMeta.latencyNs = static_cast<uint64_t>(
diff --git a/gladius/src/ui/RenderWindow.h b/gladius/src/ui/RenderWindow.h
index 23e01660..4ac4c3ee 100644
--- a/gladius/src/ui/RenderWindow.h
+++ b/gladius/src/ui/RenderWindow.h
@@ -5,6 +5,9 @@
 #include "OrbitalCamera.h"
 #include "compute/ComputeCore.h"
 #include "render/AsyncRenderController.h"
+#include "render/PresentedFrameLedger.h"
+#include "render/RealtimeRaymarchController.h"
+#include "render/RenderUpdateCoordinator.h"
 #include <CL/cl_platform.h>
 #include <atomic>
 #include <chrono>
@@ -63,9 +66,22 @@ namespace gladius::ui
         /// an export is in progress to avoid GPU contention.
         void setExportState(ExportState const * exportState);
 
+        /// @brief Snapshot of high-quality progressive render progress for status display.
+        struct HqProgressiveRenderProgress
+        {
+            bool active = false;   ///< true while an HQ progressive render is advancing
+            float fraction = 0.0f; ///< completion in [0, 1]
+        };
+
         void renderWindow();
         void updateCamera();
         bool isRenderingInProgress() const;
+
+        /// @brief Returns a snapshot of the current HQ progressive render progress.
+        ///
+        /// Used by the status bar to visualize progressive rendering, including when a
+        /// render is aborted and restarted (the fraction jumps back toward zero).
+        [[nodiscard]] HqProgressiveRenderProgress hqProgressiveRenderProgress() const;
         void invalidateView();
         void invalidateViewDuetoModelUpdate();
         void invalidateViewDueToParameterChange();
@@ -80,7 +96,13 @@ namespace gladius::ui
         /// scheduling round-trip through the UI thread.
         void startStreamingPreview();
         void stopStreamingPreview();
+        void refreshStreamingParameterInteraction();
         [[nodiscard]] bool isStreamingPreviewActive() const;
+        [[nodiscard]] async_rendering::RealtimeRaymarchMode realtimeRaymarchMode() const noexcept;
+        /// Returns true when the realtime learning controller has confirmed the GPU can
+        /// sustain realtime frames at the current resolution (Auto mode) or when Force mode
+        /// is active.  Mirrors @ref RenderUpdateCoordinator::isRealtimeSchedulingActive().
+        [[nodiscard]] bool isRealtimeActive() const noexcept;
 
         /// Cancel all in-flight async work (streaming preview, SDF, bbox, render jobs)
         /// by stopping streaming and bumping the epoch. Call before operations that
@@ -158,29 +180,58 @@ namespace gladius::ui
          */
         [[nodiscard]] bool isCameraMoving() const;
 
+        [[nodiscard]] bool isForceRealtimeMode() const noexcept;
+
       private:
         void render(RenderWindowState & state);
         void renderLoadingOverlay();
         void renderBusyOverlay();
         void renderExistingFrame(std::shared_ptr<GLImageBuffer> const & displayImage);
-        void showProgressSpinner(ImVec2 const & windowCenter, char const * label);
+        void showProgressSpinner(ImVec2 const & windowCenter,
+               char const * label,
+               ImVec4 const & indicatorColor = ImVec4(1.0f, 0.0f, 0.0f, 0.8f));
         void slider(ImVec2 const & areaMin, ImVec2 const & areaMax);
         void initializeAsyncRendering();
         void renderSync(RenderWindowState & state);
         void renderAsync(RenderWindowState & state);
         void processAsyncResults(RenderWindowState & state);
-        bool scheduleAsyncRenderJob(RenderWindowState & state);
+        bool scheduleAsyncRenderJob(
+          RenderWindowState & state,
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+        bool scheduleFullFrameRenderJob(
+          RenderWindowState & state,
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr,
+          async_rendering::RenderJobType jobType =
+            async_rendering::RenderJobType::RealtimeHighQuality);
         coro::task<async_rendering::FrameResultMeta> executeAsyncRenderJob(
           async_rendering::RenderJob const & job,
           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
         void notifyAsyncEpochIncrement();
+        void invalidateCameraView();
         void adjustProgressFromDuration(RenderWindowState & state, uint64_t computeDurationNs);
+        [[nodiscard]] async_rendering::RealtimeRaymarchConfig loadRealtimeRaymarchConfig() const;
+        void saveRealtimeRaymarchMode(async_rendering::RealtimeRaymarchMode mode) const;
+        void queueRenderDecision(async_rendering::RenderUpdateDecision decision);
+        [[nodiscard]] bool executeQueuedRenderCommands(RenderWindowState & state);
+        [[nodiscard]] bool executeRenderCommand(async_rendering::RenderCommand const & command,
+                                                RenderWindowState & state);
+        [[nodiscard]] bool scheduleCoordinatorTask(async_rendering::RenderTaskRequest const & task,
+                                                   RenderWindowState & state);
+        [[nodiscard]] bool isRealtimeRaymarchInteractionActive() const noexcept;
+        [[nodiscard]] bool scheduleAsyncSdfPrecomputation(
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+        void completeCoordinatorTask(async_rendering::RenderTaskRequest const & request,
+                                     async_rendering::RenderTaskStatus status);
+        void completeCoordinatorTask(async_rendering::FrameResultMeta const & result,
+                                     bool producedDisplayFrame);
+        void completeCoordinatorPreviewTask(async_rendering::PreviewResultMeta const & result);
 
         [[nodiscard]] bool isAsyncBackendActive() const noexcept;
         [[nodiscard]] std::optional<BoundingBox> tryFetchBoundingBox(bool requestAsyncUpdate);
 
         // Async bounding box computation
-        void scheduleAsyncBboxUpdate();
+        void scheduleAsyncBboxUpdate(
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
         coro::task<async_rendering::FrameResultMeta> executeAsyncBboxUpdate(
           async_rendering::RenderJob const & job,
           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
@@ -196,17 +247,32 @@ namespace gladius::ui
           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
 
         // Async preview rendering (non-blocking low-res preview during camera movement)
-        bool scheduleAsyncPreviewJob();
+        bool scheduleAsyncPreviewJob(
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
         coro::task<async_rendering::FrameResultMeta> executeAsyncPreviewJob(
           async_rendering::RenderJob const & job,
           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
         void processAsyncPreviewResults();
 
         // Streaming preview loop (tight render loop during parameter drag)
-        bool scheduleStreamingPreviewJob();
+        bool scheduleStreamingPreviewJob(
+          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
         coro::task<async_rendering::FrameResultMeta> executeStreamingPreviewJob(
           async_rendering::RenderJob const & job,
           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+        void finishParameterInteraction();
+
+        /// Render a single full-quality realtime frame synchronously on the UI thread.
+        /// Pushes the latest parameters to the GPU, submits the OpenCL render kernel,
+        /// blocks until the GPU is done, then immediately promotes the result to the
+        /// front buffer for display.  Returns true on success.
+        ///
+        /// Used when @ref RenderUpdateCoordinator::isRealtimeSchedulingActive() is true so
+        /// that both Force mode and Auto mode (once performance is proven) get direct,
+        /// zero-latency parameter feedback without going through the async job queue.
+        /// SDF precomputation and bounding-box updates remain asynchronous.
+        [[nodiscard]] bool tryRenderRealtimeFrameSync(
+          async_rendering::RenderTaskRequest const & task);
 
         GLView * m_view{};
 
@@ -235,12 +301,14 @@ namespace gladius::ui
         RenderWindowState m_renderWindowState{};
 
         bool m_centerViewRequested = false;
+        int m_cameraIdleFrames{0};
         bool m_enableHQRendering = true;
 
         ImVec2 m_contentAreaMin;
         ImVec2 m_contentAreaMax;
 
         TimeStamp m_lastLowResRenderTime;
+        TimeStamp m_lastCameraIdleTime; ///< When camera last became idle (for interaction end debounce)
 
         float m_uiScale = 1.0f;
 
@@ -316,12 +384,21 @@ namespace gladius::ui
         void onCameraManuallyMoved();
 
         async_rendering::AsyncRenderFeatureConfig m_asyncConfig{};
+        async_rendering::RenderUpdateCoordinator m_renderUpdateCoordinator{};
+        async_rendering::PresentedFrameLedger m_presentedFrames{};
+        std::vector<async_rendering::RenderCommand> m_pendingRenderCommands;
         std::shared_ptr<async_rendering::AsyncRenderController> m_asyncController;
         std::atomic<uint64_t> m_asyncEpochCounter{0};
         std::atomic<uint64_t> m_asyncCurrentEpoch{0};
+          std::atomic<uint64_t> m_asyncViewEpoch{0};
         std::atomic<uint64_t> m_asyncInFlightEpoch{0};
+          std::atomic<uint64_t> m_asyncInFlightViewEpoch{0};
         std::atomic<uint64_t> m_asyncFrameCounter{0};
         std::atomic<bool> m_asyncJobInFlight{false};
+        std::atomic<bool> m_asyncRealtimeJobInFlight{false};
+        /// Set when a StaticFullFrameProbe job is in-flight; used to suppress the progressive
+        /// buffer from display so the partial chunk content is not shown while the probe renders.
+        std::atomic<bool> m_asyncStaticFullFrameJobInFlight{false};
         std::atomic<bool> m_asyncBboxJobInFlight{false};
         std::atomic<bool> m_asyncBboxUpdatePending{
           false}; // Tracks if bbox needs update after current job
@@ -333,12 +410,22 @@ namespace gladius::ui
         std::atomic<uint64_t> m_asyncSdfInFlightEpoch{0};
         std::atomic<bool> m_lowResFeedbackPending{false};
         std::atomic<uint64_t> m_lastLowResPreviewEpoch{0};
+        /// View epoch of the content currently held by the result image (the low-res preview
+        /// that seeds the progressive HQ buffer). Used to avoid seeding an HQ frame from a
+        /// stale-view preview, which would produce torn (mixed-view) progressive frames during
+        /// rapid window resizing.
+        std::atomic<uint64_t> m_lastLowResPreviewViewEpoch{0};
         bool m_asyncInitialized{false};
         bool m_compilationInvalidated{false};
 
         // Progressive rendering: reuse same buffer for all chunks in a frame
         async_rendering::FrameBuffer * m_asyncProgressiveBuffer{nullptr};
         std::atomic<uint64_t> m_asyncProgressiveEpoch{0};
+        std::atomic<uint64_t> m_asyncProgressiveViewEpoch{0};
+        /// GPU parameter-buffer generation the progressive buffer's HQ lines were rendered with.
+        /// A mismatch against the live generation means a parameter upload landed mid-fill, so the
+        /// buffer must be re-seeded to avoid a torn (old-params top / new-params bottom) frame.
+        std::atomic<uint64_t> m_asyncProgressiveParamGeneration{0};
 
         // Async preview rendering state (separate from HQ progressive rendering)
         std::atomic<uint64_t> m_asyncPreviewEpoch{0};       ///< Current preview epoch for cancellation
diff --git a/gladius/src/ui/ResourceView.cpp b/gladius/src/ui/ResourceView.cpp
index ad184890..4a16619f 100644
--- a/gladius/src/ui/ResourceView.cpp
+++ b/gladius/src/ui/ResourceView.cpp
@@ -15,6 +15,7 @@
 #include "imgui.h"
 #include <imgui_stdlib.h>      // For InputText with std::string
 #include <lib3mf_implicit.hpp> // For VolumeData interfaces
+#include <optional>
 
 namespace gladius::ui
 {
@@ -137,6 +138,7 @@ namespace gladius::ui
 
         // Check if export is in progress - disable modifications
         bool const exportInProgress = m_exportState != nullptr && m_exportState->isExportInProgress();
+        std::optional<ResourceKey> pendingResourceDeletion;
         
         auto & resourceManager = document->getGeneratorContext().resourceManager;
 
@@ -366,7 +368,7 @@ namespace gladius::ui
                     {
                         if (safeResult.canBeRemoved)
                         {
-                            document->deleteResource(key);
+                            pendingResourceDeletion = key;
                         }
                     }
 
@@ -397,6 +399,11 @@ namespace gladius::ui
                              "Mesh Resource Details\n\n"
                              "View vertices, triangles, and properties of this mesh.\n"
                              "Meshes define the shape of objects using triangular surfaces.");
+
+                if (pendingResourceDeletion.has_value())
+                {
+                    break;
+                }
             }
             ImGui::TreePop();
         }
@@ -734,7 +741,7 @@ namespace gladius::ui
                     {
                         if (safeResult.canBeRemoved)
                         {
-                            document->deleteResource(key);
+                            pendingResourceDeletion = key;
                         }
                     }
 
@@ -765,6 +772,11 @@ namespace gladius::ui
                              "Image Stack Details\n\n"
                              "View and edit the 3D image data used in volumetric models.\n"
                              "These stacked images create a full 3D representation.");
+
+                if (pendingResourceDeletion.has_value())
+                {
+                    break;
+                }
             }
             ImGui::TreePop();
         }
@@ -774,6 +786,11 @@ namespace gladius::ui
                      "3D image data for volumetric models.\n"
                      "Image stacks store information as voxels (3D pixels) and allow you to\n"
                      "represent object properties that vary throughout the volume.");
+
+        if (pendingResourceDeletion.has_value())
+        {
+            document->deleteResource(*pendingResourceDeletion);
+        }
     }
 
     void ResourceView::addMesh(SharedDocument document)
diff --git a/gladius/src/ui/render/AsyncRenderController.cpp b/gladius/src/ui/render/AsyncRenderController.cpp
index 98c76c6c..cba830b0 100644
--- a/gladius/src/ui/render/AsyncRenderController.cpp
+++ b/gladius/src/ui/render/AsyncRenderController.cpp
@@ -18,6 +18,7 @@
 #include <algorithm>
 #include <chrono>
 #include <condition_variable>
+#include <deque>
 #include <mutex>
 #include <optional>
 #include <string>
@@ -45,10 +46,11 @@ namespace gladius::ui::async_rendering
             coro::queue<RenderJob> jobQueue;
             std::atomic<bool> shutdownRequested{false};
             std::atomic<uint64_t> latestEpoch{0};
+            std::atomic<uint64_t> latestViewEpoch{0};
             AsyncRenderController::JobExecutor jobExecutor;
 
             std::mutex resultMutex;
-            std::optional<FrameResultMeta> pendingResult;
+            std::deque<FrameResultMeta> pendingResults;
             std::atomic<bool> hasPendingResult{false};
 
             std::mutex lifecycleMutex;
@@ -60,6 +62,33 @@ namespace gladius::ui::async_rendering
             {
             }
         };
+
+        [[nodiscard]] FrameResultMeta makeCancelledResult(RenderJob const & job)
+        {
+            return FrameResultMeta{.frameId = job.frameHint,
+                                   .epoch = job.epoch,
+                                   .viewEpoch = job.viewEpoch,
+                                   .jobType = job.type,
+                                   .width = job.width,
+                                   .height = job.height,
+                                   .cancelled = true,
+                                   .completedFrame = false,
+                                   .precomputedSdfUpdated = false,
+                                   .startLine = job.startLine,
+                                   .completedLine = job.startLine,
+                                   .computeDurationNs = 0,
+                                   .compilationProgress = 0.0f,
+                                   .compilationSucceeded = false,
+                                   .coordinatorRequestId = job.coordinatorRequestId,
+                                   .coordinatorStamp = job.coordinatorStamp};
+        }
+
+        void publishResult(ControllerStateData & data, FrameResultMeta result)
+        {
+            std::lock_guard<std::mutex> guard(data.resultMutex);
+            data.pendingResults.push_back(std::move(result));
+            data.hasPendingResult.store(true, std::memory_order_release);
+        }
     }
 
     struct AsyncRenderController::ControllerState
@@ -133,9 +162,10 @@ namespace gladius::ui::async_rendering
 
         m_state->data.shutdownRequested.store(false, std::memory_order_release);
         m_state->data.latestEpoch.store(0, std::memory_order_release);
+        m_state->data.latestViewEpoch.store(0, std::memory_order_release);
         {
             std::lock_guard<std::mutex> resultLock(m_state->data.resultMutex);
-            m_state->data.pendingResult.reset();
+            m_state->data.pendingResults.clear();
             m_state->data.hasPendingResult.store(false, std::memory_order_release);
         }
 
@@ -199,6 +229,22 @@ namespace gladius::ui::async_rendering
         }
     }
 
+    void AsyncRenderController::setLatestViewEpoch(uint64_t viewEpoch)
+    {
+        if (!m_state)
+        {
+            return;
+        }
+
+        auto & latestViewEpoch = m_state->data.latestViewEpoch;
+        auto current = latestViewEpoch.load(std::memory_order_acquire);
+        while (viewEpoch > current &&
+               !latestViewEpoch.compare_exchange_weak(
+                 current, viewEpoch, std::memory_order_acq_rel, std::memory_order_acquire))
+        {
+        }
+    }
+
     void AsyncRenderController::setJobExecutor(JobExecutor executor)
     {
         if (!m_state)
@@ -224,15 +270,15 @@ namespace gladius::ui::async_rendering
         }
 
         std::lock_guard<std::mutex> lock(data.resultMutex);
-        if (!data.pendingResult.has_value())
+        if (data.pendingResults.empty())
         {
             data.hasPendingResult.store(false, std::memory_order_release);
             return std::nullopt;
         }
 
-        FrameResultMeta result = std::move(*data.pendingResult);
-        data.pendingResult.reset();
-        data.hasPendingResult.store(false, std::memory_order_release);
+        FrameResultMeta result = std::move(data.pendingResults.front());
+        data.pendingResults.pop_front();
+        data.hasPendingResult.store(!data.pendingResults.empty(), std::memory_order_release);
         return result;
     }
 
@@ -255,9 +301,8 @@ namespace gladius::ui::async_rendering
     {
         // NOTE: No ZoneScoped / DebugText / ZoneScopedN in the outer coroutine scope here.
         // This coroutine crosses thread boundaries via co_await pop() (push() resumes the consumer
-        // inline on the caller's thread) and co_await waitForEvent() (resumes on the OpenCL
-        // callback thread). Tracy zones must begin and end on the same OS thread — any zone that
-        // spans a co_await that changes threads will corrupt Tracy's per-thread zone stack.
+        // inline on the caller's thread). Tracy zones must begin and end on the same OS thread —
+        // any zone that spans a co_await that changes threads will corrupt Tracy's per-thread zone stack.
         // Inner ZoneScopedN blocks (inside the job executors, which don't cross co_await) are fine.
 #ifdef TRACY_ENABLE
         tracy::SetThreadName("AsyncRenderWorker");
@@ -298,20 +343,54 @@ namespace gladius::ui::async_rendering
             // (the UI thread). Without this, the entire job runs on the UI thread, blocking it.
             co_await data->workerPool->schedule();
 
-            auto cancellationCheck = [data, jobEpoch = job.epoch]() -> bool
+            // Pre-execution checks: stale queued work is cancelled before entering the job
+            // executor so obsolete OpenCL kernels are not launched.  The worker still publishes
+            // a cancelled result, allowing the UI/coordinator to clear any in-flight bookkeeping.
+            auto const epochOnlyCheck = [data, jobEpoch = job.epoch]() -> bool
             {
                 return data->shutdownRequested.load(std::memory_order_acquire) ||
                        data->latestEpoch.load(std::memory_order_acquire) > jobEpoch;
             };
 
+            // In-execution check: also cancels HQ progressive jobs when the view epoch advances
+            // (camera moved), so the GPU is released quickly for realtime rendering.
+            // Realtime jobs are intentionally excluded: they complete fast and are always shown
+            // even with a stale view (allowForcedRealtimeStaleView = true).
+            bool const needsCurrentViewBeforeLaunch = job.type == RenderJobType::HighQuality ||
+                                                      job.type == RenderJobType::StaticFullFrameProbe;
+            auto cancellationCheck = [data,
+                                      jobEpoch = job.epoch,
+                                      jobViewEpoch = job.viewEpoch,
+                                      needsCurrentViewBeforeLaunch]() -> bool
+            {
+                if (data->shutdownRequested.load(std::memory_order_acquire))
+                    return true;
+                if (data->latestEpoch.load(std::memory_order_acquire) > jobEpoch)
+                    return true;
+                if (needsCurrentViewBeforeLaunch && jobViewEpoch > 0 &&
+                    data->latestViewEpoch.load(std::memory_order_acquire) > jobViewEpoch)
+                    return true;
+                return false;
+            };
+
             // Preview/streaming jobs must not be skipped here — their executors
             // manage m_asyncPreviewJobInFlight and m_streamingJobInFlight flags
             // that are only cleared inside the executor. Skipping the job would
             // leave those flags stuck at true, preventing any future scheduling.
             bool const isPreviewJob = (job.type == RenderJobType::LowResPreview ||
                                        job.type == RenderJobType::StreamingPreview);
-            if (!isPreviewJob && cancellationCheck())
+            if (!isPreviewJob && epochOnlyCheck())
             {
+                publishResult(*data, makeCancelledResult(job));
+                continue;
+            }
+
+            auto const latestViewEpoch = data->latestViewEpoch.load(std::memory_order_acquire);
+            bool const staleViewBeforeLaunch = needsCurrentViewBeforeLaunch && job.viewEpoch > 0 &&
+                                               latestViewEpoch > job.viewEpoch;
+            if (staleViewBeforeLaunch)
+            {
+                publishResult(*data, makeCancelledResult(job));
                 continue;
             }
 
@@ -327,16 +406,10 @@ namespace gladius::ui::async_rendering
             }
             catch (...)
             {
-                result.epoch = job.epoch;
-                result.frameId = job.frameHint;
-                result.cancelled = true;
+                result = makeCancelledResult(job);
             }
 
-            {
-                std::lock_guard<std::mutex> guard(data->resultMutex);
-                data->pendingResult = std::move(result);
-                data->hasPendingResult.store(true, std::memory_order_release);
-            }
+            publishResult(*data, std::move(result));
         }
 
         {
@@ -357,11 +430,25 @@ namespace gladius::ui::async_rendering
           if (m_stagingWidth != width || m_stagingHeight != height || !m_workerQueue ||
               !m_stagingBuffer)
         {
-            m_stagingBuffer.reset();
-            m_workerQueue.reset();
+            std::lock_guard<std::mutex> lock(m_bufferMutex);
+            bool const hasGpuOwnedFrame = std::any_of(
+              m_frameBuffers.begin(),
+              m_frameBuffers.end(),
+              [](FrameBuffer const & buffer)
+              {
+                  auto const state = buffer.state.load(std::memory_order_acquire);
+                  return state == FrameState::Writing || state == FrameState::Resampling;
+              });
+            if (hasGpuOwnedFrame)
+            {
+                return;
+            }
 
-            // Create dedicated worker command queue (no GL interop needed)
-            m_workerQueue = std::make_unique<cl::CommandQueue>(context.createQueue());
+            m_stagingBuffer.reset();
+            {
+                std::lock_guard<std::mutex> queueLock(m_workerQueueMutex);
+                m_workerQueue = std::make_shared<cl::CommandQueue>(context.createQueue());
+            }
 
             // Create CL-only staging buffer for async rendering
             static cl::ImageFormat const format = {CL_RGBA, CL_FLOAT};
@@ -377,7 +464,6 @@ namespace gladius::ui::async_rendering
             m_stagingHeight = height;
 
             // Initialize frame buffers with GLImageBuffer instances
-            std::lock_guard<std::mutex> lock(m_bufferMutex);
             for (size_t i = 0; i < m_frameBuffers.size(); ++i)
             {
                 auto & fb = m_frameBuffers[i];
@@ -386,12 +472,14 @@ namespace gladius::ui::async_rendering
                 fb.state.store(FrameState::Idle, std::memory_order_release);
                 fb.frameId.store(0, std::memory_order_release);
                 fb.epoch.store(0, std::memory_order_release);
+                fb.viewEpoch.store(0, std::memory_order_release);
                 fb.readyTimestampNs.store(0, std::memory_order_release);
                 fb.publishTimestampNs.store(0, std::memory_order_release);
             }
 
             // First buffer starts as Front
             m_frameBuffers[0].state.store(FrameState::Front, std::memory_order_release);
+            m_framePresentation.reset(m_frameBuffers.size());
             m_frontBufferIndex.store(0, std::memory_order_release);
         }
     }
@@ -401,6 +489,12 @@ namespace gladius::ui::async_rendering
         return m_workerQueue.get();
     }
 
+    std::shared_ptr<cl::CommandQueue> AsyncRenderController::workerQueueShared() const noexcept
+    {
+        std::lock_guard<std::mutex> lock(m_workerQueueMutex);
+        return m_workerQueue;
+    }
+
     cl::Image2D * AsyncRenderController::stagingBuffer() noexcept
     {
         return m_stagingBuffer.get();
@@ -446,20 +540,56 @@ namespace gladius::ui::async_rendering
         return nullptr;
     }
 
-    bool AsyncRenderController::tryTransitionBuffer(FrameBuffer * buffer,
-                                                    FrameState expectedState,
-                                                    FrameState newState) noexcept
+    std::optional<size_t>
+    AsyncRenderController::frameBufferIndex(FrameBuffer const * buffer) const noexcept
     {
-        ProfileFunction
+        if (buffer == nullptr)
+        {
+            return std::nullopt;
+        }
 
-          if (!buffer)
+        for (size_t index = 0; index < m_frameBuffers.size(); ++index)
+        {
+            if (&m_frameBuffers[index] == buffer)
+            {
+                return index;
+            }
+        }
+        return std::nullopt;
+    }
+
+    bool AsyncRenderController::tryTransitionBufferLocked(FrameBuffer * buffer,
+                                                          FrameState expectedState,
+                                                          FrameState newState) noexcept
+    {
+        if (buffer == nullptr)
         {
             return false;
         }
 
         FrameState expected = expectedState;
-        return buffer->state.compare_exchange_strong(
+        bool const transitioned = buffer->state.compare_exchange_strong(
           expected, newState, std::memory_order_acq_rel, std::memory_order_acquire);
+        if (!transitioned)
+        {
+            return false;
+        }
+
+        if (auto const index = frameBufferIndex(buffer); index.has_value())
+        {
+            [[maybe_unused]] bool const mirrored =
+              m_framePresentation.tryTransitionBuffer(*index, expectedState, newState);
+        }
+        return true;
+    }
+
+    bool AsyncRenderController::tryTransitionBuffer(FrameBuffer * buffer,
+                                                    FrameState expectedState,
+                                                    FrameState newState) noexcept
+    {
+        ProfileFunction
+        std::lock_guard<std::mutex> lock(m_bufferMutex);
+        return tryTransitionBufferLocked(buffer, expectedState, newState);
     }
 
     FrameBuffer * AsyncRenderController::frontBuffer() noexcept
@@ -473,24 +603,51 @@ namespace gladius::ui::async_rendering
     {
         ProfileFunction std::lock_guard<std::mutex> lock(m_bufferMutex);
 
-        // Find an Idle buffer to write to
-        for (auto & buffer : m_frameBuffers)
+        auto const bufferId =
+          m_framePresentation.acquireWriteBuffer(RenderStamp{.sceneEpoch = epoch});
+        if (!bufferId.has_value() || *bufferId >= m_frameBuffers.size())
         {
-            if (tryTransitionBuffer(&buffer, FrameState::Idle, FrameState::Writing))
-            {
-                buffer.epoch.store(epoch, std::memory_order_release);
-                return &buffer;
-            }
+            return nullptr;
         }
 
-        // No Idle buffer available - this shouldn't happen with triple buffering
-        // but can happen with double buffering if UI is slow
-        return nullptr;
+        auto & buffer = m_frameBuffers[*bufferId];
+        FrameState expected = FrameState::Idle;
+        bool const transitioned = buffer.state.compare_exchange_strong(
+          expected, FrameState::Writing, std::memory_order_acq_rel, std::memory_order_acquire);
+        if (!transitioned)
+        {
+            [[maybe_unused]] bool const rolledBack =
+              m_framePresentation.tryTransitionBuffer(*bufferId,
+                                                      FrameState::Writing,
+                                                      FrameState::Idle);
+            return nullptr;
+        }
+
+        buffer.epoch.store(epoch, std::memory_order_release);
+        buffer.viewEpoch.store(0, std::memory_order_release);
+        return &buffer;
+    }
+
+    void AsyncRenderController::publishFrame(FrameBuffer * buffer,
+                                             uint64_t frameId,
+                                             uint64_t epoch,
+                                             uint64_t viewEpoch,
+                                             FramePresentationQuality quality) noexcept
+    {
+        publishFrame(buffer,
+                     frameId,
+                     epoch,
+                     viewEpoch,
+                     RenderStamp{.sceneEpoch = epoch, .viewEpoch = viewEpoch},
+                     quality);
     }
 
     void AsyncRenderController::publishFrame(FrameBuffer * buffer,
                                              uint64_t frameId,
-                                             uint64_t epoch) noexcept
+                                             uint64_t epoch,
+                                             uint64_t viewEpoch,
+                                             RenderStamp const & stamp,
+                                             FramePresentationQuality quality) noexcept
     {
         ProfileFunction if (!buffer)
         {
@@ -501,6 +658,7 @@ namespace gladius::ui::async_rendering
 
         buffer->frameId.store(frameId, std::memory_order_release);
         buffer->epoch.store(epoch, std::memory_order_release);
+        buffer->viewEpoch.store(viewEpoch, std::memory_order_release);
 
         // Get current timestamp (nanoseconds since epoch)
         auto const now = std::chrono::high_resolution_clock::now();
@@ -510,39 +668,88 @@ namespace gladius::ui::async_rendering
 
         // Transition Writing → Ready
         FrameState expected = FrameState::Writing;
-        buffer->state.compare_exchange_strong(
+        bool const transitioned = buffer->state.compare_exchange_strong(
           expected, FrameState::Ready, std::memory_order_release, std::memory_order_acquire);
+        if (transitioned)
+        {
+            if (auto const index = frameBufferIndex(buffer); index.has_value())
+            {
+                [[maybe_unused]] bool const mirrored = m_framePresentation.publishFrame(
+                  *index, frameId, stamp, quality);
+            }
+        }
     }
 
-    FrameBuffer * AsyncRenderController::promoteReadyToFront() noexcept
+    std::optional<PresentationBuffer>
+    AsyncRenderController::mirroredPresentationBuffer(FrameBuffer const * buffer) const noexcept
     {
-        ProfileFunction std::lock_guard<std::mutex> lock(m_bufferMutex);
+        if (buffer == nullptr)
+        {
+            return std::nullopt;
+        }
 
-        // Find the newest Ready buffer (highest frameId)
-        FrameBuffer * newestReady = nullptr;
-        uint64_t highestFrameId = 0;
+        std::lock_guard<std::mutex> lock(m_bufferMutex);
+        auto const index = frameBufferIndex(buffer);
+        if (!index.has_value())
+        {
+            return std::nullopt;
+        }
 
-        for (auto & buffer : m_frameBuffers)
+        auto const * mirrored = m_framePresentation.buffer(*index);
+        if (mirrored == nullptr)
         {
-            if (buffer.state.load(std::memory_order_acquire) == FrameState::Ready)
-            {
-                auto const frameId = buffer.frameId.load(std::memory_order_acquire);
-                if (frameId > highestFrameId)
-                {
-                    highestFrameId = frameId;
-                    newestReady = &buffer;
-                }
-            }
+            return std::nullopt;
+        }
+
+        return *mirrored;
+    }
+
+    std::optional<PresentationBuffer>
+    AsyncRenderController::mirroredFrontPresentationBuffer() const noexcept
+    {
+        std::lock_guard<std::mutex> lock(m_bufferMutex);
+        auto const frontId = m_framePresentation.frontBufferId();
+        if (!frontId.has_value())
+        {
+            return std::nullopt;
         }
 
-        if (!newestReady)
+        auto const * mirrored = m_framePresentation.buffer(*frontId);
+        if (mirrored == nullptr)
+        {
+            return std::nullopt;
+        }
+
+        return *mirrored;
+    }
+
+    FrameBuffer * AsyncRenderController::promoteReadyToFront() noexcept
+    {
+        return promoteReadyToFront(RenderStamp{}, RenderStampMask::none());
+    }
+
+    FrameBuffer * AsyncRenderController::promoteReadyToFront(RenderStamp const & required,
+                                                            RenderStampMask mask) noexcept
+    {
+        ProfileFunction std::lock_guard<std::mutex> lock(m_bufferMutex);
+
+        auto const newestReadyIndex =
+          m_framePresentation.selectBestReadyForPresentation(required, mask);
+        if (!newestReadyIndex.has_value() || *newestReadyIndex >= m_frameBuffers.size())
         {
             return nullptr; // No Ready buffer available
         }
 
+        auto * newestReady = &m_frameBuffers[*newestReadyIndex];
+
         // Transition Ready → Resampling
-        if (!tryTransitionBuffer(newestReady, FrameState::Ready, FrameState::Resampling))
+        FrameState expected = FrameState::Ready;
+        bool const transitioned = newestReady->state.compare_exchange_strong(
+          expected, FrameState::Resampling, std::memory_order_acq_rel, std::memory_order_acquire);
+        if (!transitioned)
         {
+            [[maybe_unused]] bool const rolledBack = m_framePresentation.tryTransitionBuffer(
+              *newestReadyIndex, FrameState::Resampling, FrameState::Ready);
             return nullptr; // Lost race
         }
 
@@ -551,6 +758,44 @@ namespace gladius::ui::async_rendering
         return newestReady;
     }
 
+    bool AsyncRenderController::canPresentFrame(RenderStamp const & candidateStamp,
+                                                FramePresentationQuality candidateQuality,
+                                                RenderStamp const & required,
+                                                RenderStampMask mask) const noexcept
+    {
+        std::lock_guard<std::mutex> lock(m_bufferMutex);
+        return m_framePresentation.canPresentCandidate(
+          FramePresentationCandidate{.stamp = candidateStamp, .quality = candidateQuality},
+          required,
+          mask);
+    }
+
+    void AsyncRenderController::discardReadyFrame(uint64_t frameId,
+                                                  uint64_t epoch,
+                                                  uint64_t viewEpoch) noexcept
+    {
+        std::lock_guard<std::mutex> lock(m_bufferMutex);
+
+        for (auto & buffer : m_frameBuffers)
+        {
+            if (buffer.state.load(std::memory_order_acquire) != FrameState::Ready)
+            {
+                continue;
+            }
+
+            if (buffer.frameId.load(std::memory_order_acquire) != frameId ||
+                buffer.epoch.load(std::memory_order_acquire) != epoch ||
+                buffer.viewEpoch.load(std::memory_order_acquire) != viewEpoch)
+            {
+                continue;
+            }
+
+            [[maybe_unused]] bool const released =
+              tryTransitionBufferLocked(&buffer, FrameState::Ready, FrameState::Idle);
+            return;
+        }
+    }
+
     bool AsyncRenderController::finalizeFrontPromotion(FrameBuffer * buffer) noexcept
     {
         ProfileFunction
@@ -575,7 +820,10 @@ namespace gladius::ui::async_rendering
             return false;
         }
 
-        if (!tryTransitionBuffer(&(*it), FrameState::Resampling, FrameState::Front))
+        FrameState expected = FrameState::Resampling;
+        bool const transitioned = it->state.compare_exchange_strong(
+          expected, FrameState::Front, std::memory_order_acq_rel, std::memory_order_acquire);
+        if (!transitioned)
         {
             return false;
         }
@@ -595,6 +843,8 @@ namespace gladius::ui::async_rendering
                                                           std::memory_order_acquire);
         }
 
+        [[maybe_unused]] bool const mirrored = m_framePresentation.finalizeFrontPromotion(newIndex);
+
         it->publishTimestampNs.store(static_cast<uint64_t>(ns), std::memory_order_release);
         return true;
     }
@@ -613,11 +863,13 @@ namespace gladius::ui::async_rendering
             auto const state = buffer.state.load(std::memory_order_acquire);
             auto const bufEpoch = buffer.epoch.load(std::memory_order_acquire);
 
-            // Release Writing buffers from old epochs
-            if (state == FrameState::Writing && bufEpoch <= oldEpoch)
+            // Ready frames are already complete and may be discarded when their epoch is stale.
+            // Writing/Resampling frames are still owned by an OpenCL kernel or the UI upload path;
+            // recycling them here can cause use-after-free/racing writes on the GPU.
+            if (state == FrameState::Ready && bufEpoch <= oldEpoch)
             {
                 [[maybe_unused]] bool const released =
-                  tryTransitionBuffer(&buffer, FrameState::Writing, FrameState::Idle);
+                  tryTransitionBufferLocked(&buffer, FrameState::Ready, FrameState::Idle);
             }
         }
     }
@@ -740,10 +992,12 @@ namespace gladius::ui::async_rendering
             auto const state = buffer.state.load(std::memory_order_acquire);
             auto const bufEpoch = buffer.epoch.load(std::memory_order_acquire);
 
-            // Release Writing buffers from old epochs
-            if (state == FrameState::Writing && bufEpoch <= oldEpoch)
+            // Ready preview frames are complete and may be discarded when stale.
+            // Writing frames are still owned by a worker/GPU operation; recycling them here can
+            // race an in-flight kernel or host download.
+            if (state == FrameState::Ready && bufEpoch <= oldEpoch)
             {
-                auto expected = FrameState::Writing;
+                auto expected = FrameState::Ready;
                 buffer.state.compare_exchange_strong(expected, FrameState::Idle,
                                                      std::memory_order_acq_rel);
             }
diff --git a/gladius/src/ui/render/AsyncRenderController.h b/gladius/src/ui/render/AsyncRenderController.h
index 29a04718..d6954448 100644
--- a/gladius/src/ui/render/AsyncRenderController.h
+++ b/gladius/src/ui/render/AsyncRenderController.h
@@ -12,6 +12,7 @@
 #include <coro/coro.hpp>
 
 #include "AsyncRenderTypes.h"
+#include "FramePresentationController.h"
 
 // Include OpenCL platform types for cl_float4
 #include <CL/cl_platform.h>
@@ -81,6 +82,7 @@ namespace gladius::ui::async_rendering
 
         void enqueueJob(RenderJob job);
         void setLatestEpoch(uint64_t epoch);
+        void setLatestViewEpoch(uint64_t viewEpoch);
         void setJobExecutor(JobExecutor executor);
         [[nodiscard]] std::optional<FrameResultMeta> tryConsumeResult();
 
@@ -92,6 +94,9 @@ namespace gladius::ui::async_rendering
 
         /// Get worker-specific command queue (used by worker thread for rendering)
         [[nodiscard]] cl::CommandQueue * workerQueue() noexcept;
+        /// Thread-safe snapshot — safe to call from worker threads concurrently with
+        /// initializeAsyncResources(). Holds the queue alive for the caller's lifetime.
+        [[nodiscard]] std::shared_ptr<cl::CommandQueue> workerQueueShared() const noexcept;
 
         /// Get staging buffer (used by worker thread for rendering output)
         [[nodiscard]] cl::Image2D * stagingBuffer() noexcept;
@@ -114,13 +119,46 @@ namespace gladius::ui::async_rendering
         [[nodiscard]] FrameBuffer * acquireWriteBuffer(uint64_t epoch) noexcept;
 
         /// Publish a finished frame (Writing → Ready)
-        void publishFrame(FrameBuffer * buffer, uint64_t frameId, uint64_t epoch) noexcept;
+        void publishFrame(FrameBuffer * buffer,
+                          uint64_t frameId,
+                          uint64_t epoch,
+                          uint64_t viewEpoch = 0,
+                          FramePresentationQuality quality =
+                            FramePresentationQuality::Unknown) noexcept;
+
+        /// Publish a finished frame with the coordinator stamp used for presentation policy.
+        void publishFrame(FrameBuffer * buffer,
+                          uint64_t frameId,
+                          uint64_t epoch,
+                          uint64_t viewEpoch,
+                          RenderStamp const & stamp,
+                          FramePresentationQuality quality) noexcept;
+
+        /// Snapshot mirrored presentation metadata for a specific HQ buffer.
+        [[nodiscard]] std::optional<PresentationBuffer>
+          mirroredPresentationBuffer(FrameBuffer const * buffer) const noexcept;
+
+        /// Snapshot mirrored presentation metadata for the currently presented front buffer.
+        [[nodiscard]] std::optional<PresentationBuffer> mirroredFrontPresentationBuffer() const noexcept;
 
         /// Promote a Ready buffer to Front (for UI display)
         [[nodiscard]] FrameBuffer * promoteReadyToFront() noexcept;
 
-  /// Finalize promotion by transitioning Resampling → Front and updating indices
-  [[nodiscard]] bool finalizeFrontPromotion(FrameBuffer * buffer) noexcept;
+        /// Promote the best Ready buffer that is acceptable for the requested display stamp.
+        [[nodiscard]] FrameBuffer * promoteReadyToFront(RenderStamp const & required,
+                                                        RenderStampMask mask) noexcept;
+
+        /// Check whether an external/non-HQ candidate may be presented against the current front.
+        [[nodiscard]] bool canPresentFrame(RenderStamp const & candidateStamp,
+                                           FramePresentationQuality candidateQuality,
+                                           RenderStamp const & required,
+                                           RenderStampMask mask) const noexcept;
+
+          /// Release a completed Ready frame that should no longer be displayed.
+          void discardReadyFrame(uint64_t frameId, uint64_t epoch, uint64_t viewEpoch) noexcept;
+
+          /// Finalize promotion by transitioning Resampling → Front and updating indices
+          [[nodiscard]] bool finalizeFrontPromotion(FrameBuffer * buffer) noexcept;
 
         /// Release any Writing buffers from old epochs back to Idle
         /// (used when epoch changes to clean up cancelled jobs)
@@ -156,17 +194,25 @@ namespace gladius::ui::async_rendering
         [[nodiscard]] static auto workerLoop(std::shared_ptr<ControllerState> state)
           -> coro::task<void>;
 
+        [[nodiscard]] std::optional<size_t>
+          frameBufferIndex(FrameBuffer const * buffer) const noexcept;
+        [[nodiscard]] bool tryTransitionBufferLocked(FrameBuffer * buffer,
+                                                     FrameState expectedState,
+                                                     FrameState newState) noexcept;
+
         std::shared_ptr<ControllerState> m_state;
         std::atomic<bool> m_running{false};
 
         // OpenCL resources for async rendering (Option A: separate CL queue, no GL interop)
-        std::unique_ptr<cl::CommandQueue> m_workerQueue;
+        mutable std::mutex m_workerQueueMutex;
+        std::shared_ptr<cl::CommandQueue> m_workerQueue;
         std::unique_ptr<cl::Image2D> m_stagingBuffer;
         size_t m_stagingWidth{0};
         size_t m_stagingHeight{0};
 
         // Triple buffer state machine (for HQ progressive rendering)
         std::array<FrameBuffer, 3> m_frameBuffers;
+        FramePresentationController m_framePresentation{m_frameBuffers.size()};
         std::atomic<size_t> m_frontBufferIndex{0};
         mutable std::mutex m_bufferMutex;
 
diff --git a/gladius/src/ui/render/AsyncRenderTypes.h b/gladius/src/ui/render/AsyncRenderTypes.h
index be32899b..e04566dc 100644
--- a/gladius/src/ui/render/AsyncRenderTypes.h
+++ b/gladius/src/ui/render/AsyncRenderTypes.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "FramePresentationTypes.h"
+#include "RenderUpdateTypes.h"
+
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
@@ -44,6 +47,8 @@ namespace gladius::ui::async_rendering
     enum class RenderJobType
     {
         HighQuality,
+        RealtimeHighQuality,
+        StaticFullFrameProbe,
         LowResPreview,
         StreamingPreview,     // Continuous preview loop during parameter drag
         BoundingBoxUpdate,
@@ -58,6 +63,8 @@ namespace gladius::ui::async_rendering
     struct RenderJob
     {
         uint64_t epoch{0};
+        uint64_t viewEpoch{0};
+        uint64_t paramGeneration{0}; ///< GPU parameter-buffer generation captured when scheduled.
         uint64_t frameHint{0};
         RenderJobType type{RenderJobType::HighQuality};
         uint32_t width{0};
@@ -67,6 +74,8 @@ namespace gladius::ui::async_rendering
         bool precomputeSdf{false};
         bool enableHighQuality{true};
         bool precomputedSdf{false};  // True if SDF should be precomputed before rendering
+        uint64_t coordinatorRequestId{0};
+        RenderStamp coordinatorStamp{};
     };
 
     /**
@@ -76,6 +85,7 @@ namespace gladius::ui::async_rendering
     {
         uint64_t frameId{0};
         uint64_t epoch{0};
+        uint64_t viewEpoch{0};
         RenderJobType jobType{RenderJobType::HighQuality};
         uint32_t width{0};
         uint32_t height{0};
@@ -88,6 +98,8 @@ namespace gladius::ui::async_rendering
         float compilationProgress{0.0f};  // 0.0 - 1.0 for compilation jobs
         bool compilationSucceeded{false};
         std::string compilationError;     // Empty if no error
+        uint64_t coordinatorRequestId{0};
+        RenderStamp coordinatorStamp{};
     };
 
     /**
@@ -113,9 +125,14 @@ namespace gladius::ui::async_rendering
     {
         uint64_t frameId{0};         ///< Matches PreviewRenderJob::frameId
         uint64_t epoch{0};           ///< Matches PreviewRenderJob::epoch
+        uint64_t viewEpoch{0};       ///< Camera/view generation captured when the preview was queued
         uint64_t latencyNs{0};       ///< Time from job enqueue to completion (nanoseconds)
         bool cancelled{false};       ///< True if job was cancelled due to epoch change
         bool sdfWasValid{false};     ///< True if SDF was available during rendering
+        FramePresentationQuality quality{FramePresentationQuality::Preview};
+        FramePresentationSource source{FramePresentationSource::LowResolutionPreview};
+        uint64_t coordinatorRequestId{0};
+        RenderStamp coordinatorStamp{};
     };
 
     /**
@@ -127,6 +144,7 @@ namespace gladius::ui::async_rendering
         std::atomic<FrameState> state{FrameState::Idle};
         std::atomic<uint64_t> frameId{0};
         std::atomic<uint64_t> epoch{0};
+        std::atomic<uint64_t> viewEpoch{0};
         std::atomic<uint64_t> readyTimestampNs{0};
         std::atomic<uint64_t> publishTimestampNs{0};
 
diff --git a/gladius/src/ui/render/DisplayFrameSelector.h b/gladius/src/ui/render/DisplayFrameSelector.h
new file mode 100644
index 00000000..b1326c35
--- /dev/null
+++ b/gladius/src/ui/render/DisplayFrameSelector.h
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "FramePresentationTypes.h"
+
+#include <cstdint>
+#include <optional>
+
+namespace gladius::ui::async_rendering
+{
+    enum class DisplayFrameSource
+    {
+        None,
+        FrontBuffer,
+        ProgressiveBuffer,
+        ResultImage
+    };
+
+    struct DisplayFrameBufferState
+    {
+        bool hasImage{false};
+        uint64_t epoch{0};
+        uint64_t viewEpoch{0};
+    };
+
+    struct DisplayFrameSelectionInput
+    {
+        DisplayFrameBufferState frontBuffer{};
+        DisplayFrameBufferState progressiveBuffer{};
+        uint64_t currentEpoch{0};
+        uint64_t currentViewEpoch{0};
+        bool exactRealtimeInteraction{false};
+        bool exactRealtimeJobInFlight{false};
+        bool isRendering{false};
+        bool isMoving{false};
+        bool fullFrameRenderJobInFlight{false};
+        bool suppressHqDisplay{false};
+        bool resultImageAvailable{true};
+                std::optional<PresentedFrame> presentedFrame{};
+    };
+
+        [[nodiscard]] constexpr bool isFrontBufferPresentationSource(
+            FramePresentationSource source) noexcept
+        {
+                return source == FramePresentationSource::ExactRealtime ||
+                             source == FramePresentationSource::ProgressiveHighQuality ||
+                             source == FramePresentationSource::HeldFrame;
+        }
+
+    /**
+     * @brief Chooses which already-produced image should be drawn in the preview window.
+     *
+     * This is intentionally metadata-only so the UI can be tested without GL/OpenCL.
+     * The current behavior prefers a current HQ/front buffer, permits a current-epoch
+     * stale-view front buffer during exact realtime interaction, then falls back to a
+     * current progressive buffer, and finally to the result image to avoid blanking.
+     */
+    [[nodiscard]] constexpr DisplayFrameSource selectDisplayFrameSource(
+      DisplayFrameSelectionInput const & input) noexcept
+    {
+        bool const frontEpochMatches = input.frontBuffer.hasImage &&
+                                       input.frontBuffer.epoch == input.currentEpoch;
+        bool const frontViewMatches = input.frontBuffer.hasImage &&
+                                      input.frontBuffer.viewEpoch == input.currentViewEpoch;
+        bool const allowRealtimeFront =
+          (input.exactRealtimeInteraction || input.exactRealtimeJobInFlight) &&
+          frontEpochMatches;
+        bool const frontBlockedByRendering = input.isRendering && !allowRealtimeFront;
+                bool const frontBufferIsPresentedFrame =
+                    input.frontBuffer.hasImage && input.presentedFrame.has_value() &&
+                    isFrontBufferPresentationSource(input.presentedFrame->source);
+
+        if (input.frontBuffer.hasImage && frontEpochMatches &&
+            (frontViewMatches || allowRealtimeFront) && !frontBlockedByRendering &&
+            !input.suppressHqDisplay)
+        {
+            return DisplayFrameSource::FrontBuffer;
+        }
+
+        bool const progressiveBufferCurrent =
+          input.progressiveBuffer.hasImage &&
+          input.progressiveBuffer.epoch == input.currentEpoch &&
+          input.progressiveBuffer.viewEpoch == input.currentViewEpoch;
+
+        if (frontBufferIsPresentedFrame && !input.suppressHqDisplay &&
+            input.presentedFrame->quality == FramePresentationQuality::FullQuality)
+        {
+            return DisplayFrameSource::FrontBuffer;
+        }
+
+        if (progressiveBufferCurrent && !input.isMoving && !input.fullFrameRenderJobInFlight &&
+            !input.suppressHqDisplay)
+        {
+            return DisplayFrameSource::ProgressiveBuffer;
+        }
+
+        if (frontBufferIsPresentedFrame && !input.suppressHqDisplay)
+        {
+            return DisplayFrameSource::FrontBuffer;
+        }
+
+        return input.resultImageAvailable ? DisplayFrameSource::ResultImage
+                                          : DisplayFrameSource::None;
+    }
+}
diff --git a/gladius/src/ui/render/FramePresentationController.h b/gladius/src/ui/render/FramePresentationController.h
new file mode 100644
index 00000000..3082a8a7
--- /dev/null
+++ b/gladius/src/ui/render/FramePresentationController.h
@@ -0,0 +1,326 @@
+#pragma once
+
+#include "AsyncRenderTypes.h"
+#include "FramePresentationTypes.h"
+#include "RenderUpdateTypes.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace gladius::ui::async_rendering
+{
+    /**
+     * @brief Metadata-only buffer used by FramePresentationController.
+     */
+    struct PresentationBuffer
+    {
+        size_t id{0};
+        FrameState state{FrameState::Idle};
+        uint64_t frameId{0};
+        RenderStamp stamp{};
+        FramePresentationQuality quality{FramePresentationQuality::Unknown};
+    };
+
+    /**
+     * @brief Pure state machine for selecting, publishing, and promoting rendered frames.
+     *
+     * This class intentionally knows nothing about OpenGL/OpenCL resources. Production buffer
+     * owners can use it as the policy layer while keeping actual image allocation elsewhere.
+     */
+    class FramePresentationController
+    {
+      public:
+        explicit FramePresentationController(size_t bufferCount = 3)
+        {
+            reset(bufferCount);
+        }
+
+        void reset(size_t bufferCount)
+        {
+            m_buffers.clear();
+            m_buffers.reserve(bufferCount);
+            for (size_t index = 0; index < bufferCount; ++index)
+            {
+                m_buffers.push_back(PresentationBuffer{.id = index});
+            }
+
+            if (!m_buffers.empty())
+            {
+                m_buffers.front().state = FrameState::Front;
+                m_frontBufferId = m_buffers.front().id;
+            }
+            else
+            {
+                m_frontBufferId.reset();
+            }
+        }
+
+        [[nodiscard]] std::optional<size_t> frontBufferId() const noexcept
+        {
+            return m_frontBufferId;
+        }
+
+        [[nodiscard]] PresentationBuffer const * buffer(size_t bufferId) const noexcept
+        {
+            if (bufferId >= m_buffers.size())
+            {
+                return nullptr;
+            }
+            return &m_buffers[bufferId];
+        }
+
+        [[nodiscard]] std::optional<size_t> acquireWriteBuffer(RenderStamp const & stamp) noexcept
+        {
+            for (auto & candidate : m_buffers)
+            {
+                if (candidate.state != FrameState::Idle)
+                {
+                    continue;
+                }
+
+                candidate.state = FrameState::Writing;
+                candidate.frameId = 0;
+                candidate.stamp = stamp;
+                candidate.quality = FramePresentationQuality::Unknown;
+                return candidate.id;
+            }
+            return std::nullopt;
+        }
+
+        [[nodiscard]] bool publishFrame(size_t bufferId,
+                                        uint64_t frameId,
+                                        RenderStamp const & stamp) noexcept
+        {
+            return publishFrame(
+              bufferId, frameId, stamp, FramePresentationQuality::Unknown);
+        }
+
+        [[nodiscard]] bool publishFrame(size_t bufferId,
+                                        uint64_t frameId,
+                                        RenderStamp const & stamp,
+                                        FramePresentationQuality quality) noexcept
+        {
+            auto * target = mutableBuffer(bufferId);
+            if (target == nullptr || target->state != FrameState::Writing)
+            {
+                return false;
+            }
+
+            target->frameId = frameId;
+            target->stamp = stamp;
+            target->quality = quality;
+            target->state = FrameState::Ready;
+            return true;
+        }
+
+        [[nodiscard]] bool tryTransitionBuffer(size_t bufferId,
+                                               FrameState expectedState,
+                                               FrameState newState) noexcept
+        {
+            auto * target = mutableBuffer(bufferId);
+            if (target == nullptr || target->state != expectedState)
+            {
+                return false;
+            }
+
+            target->state = newState;
+            if (newState == FrameState::Idle)
+            {
+                target->frameId = 0;
+                target->quality = FramePresentationQuality::Unknown;
+            }
+            if (newState == FrameState::Front)
+            {
+                m_frontBufferId = target->id;
+            }
+            return true;
+        }
+
+        [[nodiscard]] std::optional<size_t> selectNewestReady() noexcept
+        {
+            return selectNewestReady(RenderStamp{}, RenderStampMask::none());
+        }
+
+        [[nodiscard]] std::optional<size_t> selectNewestReady(RenderStamp const & required,
+                                                              RenderStampMask const mask) noexcept
+        {
+            PresentationBuffer * newest = nullptr;
+            for (auto & candidate : m_buffers)
+            {
+                if (candidate.state != FrameState::Ready || !matches(candidate.stamp, required, mask))
+                {
+                    continue;
+                }
+
+                if (newest == nullptr || candidate.frameId > newest->frameId)
+                {
+                    newest = &candidate;
+                }
+            }
+
+            if (newest == nullptr)
+            {
+                return std::nullopt;
+            }
+
+            newest->state = FrameState::Resampling;
+            return newest->id;
+        }
+
+        [[nodiscard]] std::optional<size_t> selectBestReadyForPresentation(
+          RenderStamp const & required,
+          RenderStampMask const mask) noexcept
+        {
+            PresentationBuffer * best = nullptr;
+            for (auto & candidate : m_buffers)
+            {
+                if (candidate.state != FrameState::Ready ||
+                    !matches(candidate.stamp, required, mask))
+                {
+                    continue;
+                }
+
+                if (!canPresentCandidate(FramePresentationCandidate{.frameId = candidate.frameId,
+                                                                    .stamp = candidate.stamp,
+                                                                    .quality = candidate.quality},
+                                         required,
+                                         mask))
+                {
+                    continue;
+                }
+
+                if (best == nullptr)
+                {
+                    best = &candidate;
+                    continue;
+                }
+
+                auto const candidateRank = framePresentationQualityRank(candidate.quality);
+                auto const bestRank = framePresentationQualityRank(best->quality);
+                if (candidateRank > bestRank ||
+                    (candidateRank == bestRank && candidate.frameId > best->frameId))
+                {
+                    best = &candidate;
+                }
+            }
+
+            if (best == nullptr)
+            {
+                return std::nullopt;
+            }
+
+            best->state = FrameState::Resampling;
+            return best->id;
+        }
+
+        [[nodiscard]] bool canPresentCandidate(FramePresentationCandidate const & candidate,
+                                               RenderStamp const & required,
+                                               RenderStampMask const mask) const noexcept
+        {
+            if (!matches(candidate.stamp, required, mask))
+            {
+                return false;
+            }
+
+            auto const * currentFront = currentFrontMatching(required, mask);
+            if (currentFront == nullptr)
+            {
+                return true;
+            }
+
+            return framePresentationQualityRank(candidate.quality) >=
+                   framePresentationQualityRank(currentFront->quality);
+        }
+
+        [[nodiscard]] bool finalizeFrontPromotion(size_t bufferId) noexcept
+        {
+            auto * target = mutableBuffer(bufferId);
+            if (target == nullptr || target->state != FrameState::Resampling)
+            {
+                return false;
+            }
+
+            if (m_frontBufferId.has_value())
+            {
+                auto * previousFront = mutableBuffer(*m_frontBufferId);
+                if (previousFront != nullptr && previousFront->id != target->id &&
+                    previousFront->state == FrameState::Front)
+                {
+                    previousFront->state = FrameState::Idle;
+                    previousFront->frameId = 0;
+                    previousFront->quality = FramePresentationQuality::Unknown;
+                }
+            }
+
+            target->state = FrameState::Front;
+            m_frontBufferId = target->id;
+            return true;
+        }
+
+        [[nodiscard]] bool discardReadyFrame(size_t bufferId) noexcept
+        {
+            auto * target = mutableBuffer(bufferId);
+            if (target == nullptr || target->state != FrameState::Ready)
+            {
+                return false;
+            }
+
+            target->state = FrameState::Idle;
+            target->frameId = 0;
+            target->quality = FramePresentationQuality::Unknown;
+            return true;
+        }
+
+        [[nodiscard]] size_t releaseStaleWritingBuffers(RenderStamp const & required,
+                                                        RenderStampMask const mask) noexcept
+        {
+            size_t releasedCount = 0;
+            for (auto & candidate : m_buffers)
+            {
+                if (candidate.state != FrameState::Writing || !isOlderThan(candidate.stamp, required, mask))
+                {
+                    continue;
+                }
+
+                candidate.state = FrameState::Idle;
+                candidate.frameId = 0;
+                candidate.quality = FramePresentationQuality::Unknown;
+                ++releasedCount;
+            }
+            return releasedCount;
+        }
+
+      private:
+        [[nodiscard]] PresentationBuffer * mutableBuffer(size_t bufferId) noexcept
+        {
+            if (bufferId >= m_buffers.size())
+            {
+                return nullptr;
+            }
+            return &m_buffers[bufferId];
+        }
+
+        [[nodiscard]] PresentationBuffer const * currentFrontMatching(
+          RenderStamp const & required,
+          RenderStampMask const mask) const noexcept
+        {
+            if (!m_frontBufferId.has_value())
+            {
+                return nullptr;
+            }
+
+            auto const * front = buffer(*m_frontBufferId);
+            if (front == nullptr || front->state != FrameState::Front ||
+                !matches(front->stamp, required, mask))
+            {
+                return nullptr;
+            }
+            return front;
+        }
+
+        std::vector<PresentationBuffer> m_buffers;
+        std::optional<size_t> m_frontBufferId;
+    };
+}
diff --git a/gladius/src/ui/render/FramePresentationTypes.h b/gladius/src/ui/render/FramePresentationTypes.h
new file mode 100644
index 00000000..a181071b
--- /dev/null
+++ b/gladius/src/ui/render/FramePresentationTypes.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include "RenderUpdateTypes.h"
+
+#include <cstdint>
+
+namespace gladius::ui::async_rendering
+{
+    enum class FramePresentationQuality
+    {
+        Unknown,
+        Preview,
+        ProgressivePartial,
+        FullQuality
+    };
+
+    enum class FramePresentationSource
+    {
+        Unknown,
+        ExactRealtime,
+        LowResolutionPreview,
+        StreamingPreview,
+        ProgressiveHighQuality,
+        HeldFrame
+    };
+
+    [[nodiscard]] constexpr int framePresentationQualityRank(
+      FramePresentationQuality quality) noexcept
+    {
+        switch (quality)
+        {
+        case FramePresentationQuality::Preview:
+            return 1;
+        case FramePresentationQuality::ProgressivePartial:
+            return 2;
+        case FramePresentationQuality::FullQuality:
+            return 3;
+        case FramePresentationQuality::Unknown:
+        default:
+            return 0;
+        }
+    }
+
+    struct FramePresentationCandidate
+    {
+        uint64_t frameId{0};
+        RenderStamp stamp{};
+        FramePresentationQuality quality{FramePresentationQuality::Unknown};
+        FramePresentationSource source{FramePresentationSource::Unknown};
+        bool completedFrame{false};
+    };
+
+    struct PresentedFrame
+    {
+        uint64_t frameId{0};
+        RenderStamp stamp{};
+        FramePresentationQuality quality{FramePresentationQuality::Unknown};
+        FramePresentationSource source{FramePresentationSource::Unknown};
+        bool completedFrame{false};
+    };
+}
diff --git a/gladius/src/ui/render/InteractiveRenderPathPolicy.h b/gladius/src/ui/render/InteractiveRenderPathPolicy.h
new file mode 100644
index 00000000..856d50fa
--- /dev/null
+++ b/gladius/src/ui/render/InteractiveRenderPathPolicy.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "RealtimeRaymarchController.h"
+#include "RenderUpdateTypes.h"
+
+namespace gladius::ui::async_rendering
+{
+    /// Pure policy decision for which interactive frame path should be used next.
+    /// This preserves the current runtime behavior while moving the branchy mode/
+    /// interaction logic out of RenderUpdateCoordinator so it can be tested in
+    /// isolation before the larger RenderWindow refactor lands.
+    enum class InteractiveRenderPath
+    {
+        KeepCurrentFrame,
+        ExactRealtime,
+        LowResolutionPreview
+    };
+
+    struct InteractiveRenderPathInput
+    {
+        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
+        RenderInteractionState interactionState{RenderInteractionState::Static};
+        bool interactiveFrameAlreadyInFlight{false};
+        /// Auto parameter drag still keys off the learning controller's active flag.
+        bool autoParameterExactRealtimeActive{false};
+        /// Auto camera/static interaction admits exact realtime once static HQ timing
+        /// has shown the scene is fast enough at the current resolution.
+        bool autoInteractiveExactRealtimeAdmitted{false};
+        /// Per-gesture hysteresis that keeps Auto on the simpler preview path once it
+        /// has fallen back during the current interaction.
+        bool preferSimplerPreview{false};
+        /// True when the renderer/guards allow an exact realtime frame right now.
+        bool exactRealtimeAllowed{false};
+    };
+
+    [[nodiscard]] constexpr InteractiveRenderPath chooseInteractiveRenderPath(
+      InteractiveRenderPathInput const & input) noexcept
+    {
+        if (input.interactiveFrameAlreadyInFlight)
+        {
+            return InteractiveRenderPath::KeepCurrentFrame;
+        }
+
+        if (input.interactionState == RenderInteractionState::ParameterInteracting)
+        {
+            if (input.mode == RealtimeRaymarchMode::Force)
+            {
+                return input.exactRealtimeAllowed ? InteractiveRenderPath::ExactRealtime
+                                                  : InteractiveRenderPath::KeepCurrentFrame;
+            }
+
+            if (input.mode == RealtimeRaymarchMode::Auto &&
+                input.autoParameterExactRealtimeActive)
+            {
+                return input.exactRealtimeAllowed ? InteractiveRenderPath::ExactRealtime
+                                                  : InteractiveRenderPath::KeepCurrentFrame;
+            }
+
+            return InteractiveRenderPath::LowResolutionPreview;
+        }
+
+        if (input.mode == RealtimeRaymarchMode::Auto)
+        {
+            if (input.preferSimplerPreview || !input.autoInteractiveExactRealtimeAdmitted)
+            {
+                return InteractiveRenderPath::LowResolutionPreview;
+            }
+
+            return input.exactRealtimeAllowed ? InteractiveRenderPath::ExactRealtime
+                                              : InteractiveRenderPath::LowResolutionPreview;
+        }
+
+        if (input.mode == RealtimeRaymarchMode::Off)
+        {
+            return InteractiveRenderPath::LowResolutionPreview;
+        }
+
+        return input.exactRealtimeAllowed ? InteractiveRenderPath::ExactRealtime
+                                          : InteractiveRenderPath::KeepCurrentFrame;
+    }
+}
diff --git a/gladius/src/ui/render/PresentedFrameLedger.h b/gladius/src/ui/render/PresentedFrameLedger.h
new file mode 100644
index 00000000..fc017b2c
--- /dev/null
+++ b/gladius/src/ui/render/PresentedFrameLedger.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "FramePresentationTypes.h"
+
+#include <optional>
+
+namespace gladius::ui::async_rendering
+{
+    /**
+     * @brief Metadata-only ledger for the frame currently considered visible.
+     *
+     * The ledger is intentionally independent from OpenGL/OpenCL resources. It records the
+     * presentation stamp and quality of the visible frame so preview, realtime, and progressive
+     * paths can share the same freshness and quality-regression checks.
+     */
+    class PresentedFrameLedger
+    {
+      public:
+        [[nodiscard]] std::optional<PresentedFrame> const & presentedFrame() const noexcept
+        {
+            return m_presentedFrame;
+        }
+
+        void seedPresentedFrame(PresentedFrame frame)
+        {
+            m_presentedFrame = frame;
+        }
+
+        void clearPresentedFrame() noexcept
+        {
+            m_presentedFrame.reset();
+        }
+
+        [[nodiscard]] bool canPresentCandidate(
+          FramePresentationCandidate const & candidate,
+          RenderStamp const & requiredStamp,
+          RenderStampMask const mask = RenderStampMask::displayFrame()) const noexcept
+        {
+            if (!matches(candidate.stamp, requiredStamp, mask))
+            {
+                return false;
+            }
+
+            if (!m_presentedFrame.has_value())
+            {
+                return true;
+            }
+
+            auto const & current = *m_presentedFrame;
+            if (!matches(current.stamp, requiredStamp, mask))
+            {
+                return true;
+            }
+
+            return framePresentationQualityRank(candidate.quality) >=
+                   framePresentationQualityRank(current.quality);
+        }
+
+        [[nodiscard]] bool presentCandidate(
+          FramePresentationCandidate const & candidate,
+          RenderStamp const & requiredStamp,
+          RenderStampMask const mask = RenderStampMask::displayFrame()) noexcept
+        {
+            if (!canPresentCandidate(candidate, requiredStamp, mask))
+            {
+                return false;
+            }
+
+            m_presentedFrame = PresentedFrame{.frameId = candidate.frameId,
+                                              .stamp = candidate.stamp,
+                                              .quality = candidate.quality,
+                                              .source = candidate.source,
+                                              .completedFrame = candidate.completedFrame};
+            return true;
+        }
+
+      private:
+        std::optional<PresentedFrame> m_presentedFrame;
+    };
+}
diff --git a/gladius/src/ui/render/PreviewBackendPolicy.h b/gladius/src/ui/render/PreviewBackendPolicy.h
new file mode 100644
index 00000000..59f98743
--- /dev/null
+++ b/gladius/src/ui/render/PreviewBackendPolicy.h
@@ -0,0 +1,42 @@
+#pragma once
+
+namespace gladius::ui::async_rendering
+{
+    enum class PreviewBackend
+    {
+        None,
+        PrecomputedSdfWithDistanceInit,
+        DynamicFullModel
+    };
+
+    struct PreviewBackendInput
+    {
+        bool rendererReady{false};
+        bool lowResTargetAvailable{false};
+        bool precomputedSdfValid{false};
+        bool allowDynamicFullModelFallback{true};
+    };
+
+    [[nodiscard]] constexpr PreviewBackend choosePreviewBackend(
+      PreviewBackendInput const & input) noexcept
+    {
+        if (!input.rendererReady || !input.lowResTargetAvailable)
+        {
+            return PreviewBackend::None;
+        }
+
+        if (input.precomputedSdfValid)
+        {
+            return PreviewBackend::PrecomputedSdfWithDistanceInit;
+        }
+
+        return input.allowDynamicFullModelFallback ? PreviewBackend::DynamicFullModel
+                                                   : PreviewBackend::None;
+    }
+
+    [[nodiscard]] constexpr bool previewBackendProducesDistanceInit(
+      PreviewBackend backend) noexcept
+    {
+        return backend == PreviewBackend::PrecomputedSdfWithDistanceInit;
+    }
+}
diff --git a/gladius/src/ui/render/PreviewResultAcceptancePolicy.h b/gladius/src/ui/render/PreviewResultAcceptancePolicy.h
new file mode 100644
index 00000000..ace2a058
--- /dev/null
+++ b/gladius/src/ui/render/PreviewResultAcceptancePolicy.h
@@ -0,0 +1,180 @@
+#pragma once
+
+#include "AsyncRenderTypes.h"
+#include "FramePresentationTypes.h"
+
+#include <optional>
+
+namespace gladius::ui::async_rendering
+{
+    enum class PreviewResultRejectionReason
+    {
+        None,
+        Cancelled,
+        RealtimeRaymarchActive,
+        StaleFrame,
+        OutOfOrderFrame,
+        QualityRegression
+    };
+
+    struct PreviewResultAcceptanceContext
+    {
+        RenderStamp requiredStamp{};
+        std::optional<PresentedFrame> presentedFrame{};
+        uint64_t currentEpoch{0};
+        uint64_t currentViewEpoch{0};
+        uint64_t lastPresentedPreviewFrameId{0};
+        bool realtimeRaymarchInteractionActive{false};
+        bool allowStaleViewDuringCameraInteraction{false};
+        RenderStampMask freshnessMask{RenderStampMask::displayFrame()};
+    };
+
+    struct PreviewResultAcceptanceDecision
+    {
+        PreviewResultRejectionReason rejectionReason{PreviewResultRejectionReason::None};
+        bool presentAsRequiredStamp{false};
+
+        [[nodiscard]] constexpr bool accepted() const noexcept
+        {
+            return rejectionReason == PreviewResultRejectionReason::None;
+        }
+
+        [[nodiscard]] constexpr bool shouldCompleteAsCancelled() const noexcept
+        {
+            return !accepted();
+        }
+    };
+
+    [[nodiscard]] constexpr char const * previewResultRejectionReasonName(
+      PreviewResultRejectionReason reason) noexcept
+    {
+        switch (reason)
+        {
+        case PreviewResultRejectionReason::None:
+            return "none";
+        case PreviewResultRejectionReason::Cancelled:
+            return "cancelled";
+        case PreviewResultRejectionReason::RealtimeRaymarchActive:
+            return "realtime raymarch active";
+        case PreviewResultRejectionReason::StaleFrame:
+            return "stale frame";
+        case PreviewResultRejectionReason::OutOfOrderFrame:
+            return "out-of-order frame";
+        case PreviewResultRejectionReason::QualityRegression:
+            return "quality regression";
+        default:
+            return "unknown";
+        }
+    }
+
+        [[nodiscard]] constexpr RenderStampMask displayFrameIgnoringViewMask() noexcept
+        {
+                return {.scene = true,
+                                .parameters = true,
+                                .view = false,
+                                .viewport = true,
+                                .quality = true};
+        }
+
+        [[nodiscard]] constexpr bool isPreviewResultStaleViewOnly(
+            PreviewResultMeta const & meta,
+            PreviewResultAcceptanceContext const & context) noexcept
+        {
+                bool const nonViewAxesMatch = matches(meta.coordinatorStamp,
+                                                                                         context.requiredStamp,
+                                                                                         displayFrameIgnoringViewMask());
+                bool const viewEpochStale =
+                    meta.viewEpoch != 0u && meta.viewEpoch < context.currentViewEpoch;
+                bool const stampViewStale =
+                    meta.coordinatorStamp.viewEpoch < context.requiredStamp.viewEpoch;
+                bool const epochCurrent = meta.epoch >= context.currentEpoch;
+                return epochCurrent && nonViewAxesMatch && (viewEpochStale || stampViewStale);
+        }
+
+    [[nodiscard]] constexpr bool isPreviewResultStale(
+      PreviewResultMeta const & meta,
+      PreviewResultAcceptanceContext const & context) noexcept
+    {
+        bool const staleEpoch = meta.epoch < context.currentEpoch;
+                if (staleEpoch)
+                {
+                        return true;
+                }
+
+                if (context.allowStaleViewDuringCameraInteraction &&
+                        isPreviewResultStaleViewOnly(meta, context))
+                {
+                        return false;
+                }
+
+                bool const staleViewEpoch = meta.viewEpoch != 0u &&
+                                                                        meta.viewEpoch < context.currentViewEpoch;
+        bool const staleStamp = !matches(meta.coordinatorStamp,
+                                         context.requiredStamp,
+                                         context.freshnessMask);
+                return staleViewEpoch || staleStamp;
+    }
+
+    [[nodiscard]] constexpr bool wouldRegressPresentedQuality(
+      PreviewResultMeta const & meta,
+      PreviewResultAcceptanceContext const & context) noexcept
+    {
+        if (!context.presentedFrame.has_value())
+        {
+            return false;
+        }
+
+        auto const & current = *context.presentedFrame;
+        if (!matches(current.stamp, context.requiredStamp, context.freshnessMask))
+        {
+            return false;
+        }
+
+        return framePresentationQualityRank(meta.quality) <
+               framePresentationQualityRank(current.quality);
+    }
+
+    /**
+     * @brief Decides whether a completed low-resolution/streaming preview may be published.
+     *
+     * The decision is intentionally metadata-only so production can reject stale previews before
+     * resampling into the shared result image, and tests can cover user-visible presentation rules
+     * without OpenGL/OpenCL resources.
+     */
+    [[nodiscard]] constexpr PreviewResultAcceptanceDecision evaluatePreviewResultAcceptance(
+      PreviewResultMeta const & meta,
+      PreviewResultAcceptanceContext const & context) noexcept
+    {
+        if (meta.cancelled)
+        {
+            return {PreviewResultRejectionReason::Cancelled};
+        }
+
+        if (context.realtimeRaymarchInteractionActive)
+        {
+            return {PreviewResultRejectionReason::RealtimeRaymarchActive};
+        }
+
+                bool const presentAsRequiredStamp =
+                    context.allowStaleViewDuringCameraInteraction &&
+                    isPreviewResultStaleViewOnly(meta, context);
+
+                if (isPreviewResultStale(meta, context))
+        {
+            return {PreviewResultRejectionReason::StaleFrame};
+        }
+
+        if (meta.frameId <= context.lastPresentedPreviewFrameId)
+        {
+            return {PreviewResultRejectionReason::OutOfOrderFrame};
+        }
+
+        if (wouldRegressPresentedQuality(meta, context))
+        {
+            return {PreviewResultRejectionReason::QualityRegression};
+        }
+
+        return {.rejectionReason = PreviewResultRejectionReason::None,
+            .presentAsRequiredStamp = presentAsRequiredStamp};
+    }
+}
diff --git a/gladius/src/ui/render/ProgressiveBufferPolicy.h b/gladius/src/ui/render/ProgressiveBufferPolicy.h
new file mode 100644
index 00000000..13652fa2
--- /dev/null
+++ b/gladius/src/ui/render/ProgressiveBufferPolicy.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <cstdint>
+
+namespace gladius::ui::async_rendering
+{
+    /// Snapshot of the currently held progressive high-quality accumulation buffer.
+    struct ProgressiveBufferState
+    {
+        bool hasImage{false};       ///< A progressive buffer with a backing image exists.
+        uint64_t epoch{0};          ///< Scene/model-topology generation the buffer was seeded for.
+        uint64_t viewEpoch{0};      ///< Camera/parameter generation the buffer content reflects.
+        uint64_t paramGeneration{0}; ///< GPU parameter-buffer generation the buffer's HQ lines used.
+        uint32_t width{0};          ///< Allocated buffer width in pixels.
+        uint32_t height{0};         ///< Allocated buffer height in pixels.
+    };
+
+    /// Target of the high-quality render job about to be scheduled.
+    struct ProgressiveJobTarget
+    {
+        uint64_t epoch{0};          ///< Scene/model-topology generation of the new job.
+        uint64_t viewEpoch{0};      ///< Camera/parameter generation of the new job.
+        uint64_t paramGeneration{0}; ///< GPU parameter-buffer generation the new job will render with.
+        uint32_t width{0};          ///< Requested render width in pixels.
+        uint32_t height{0};         ///< Requested render height in pixels.
+    };
+
+    /**
+     * @brief Decides whether an existing progressive HQ buffer may be continued or reused
+     *        without re-seeding for a new render job.
+     *
+     * A progressive buffer is filled top-to-bottom over several frames; the not-yet-rendered
+     * region keeps whatever content it was last seeded with. Continuing (rendering from a
+     * non-zero start line) or reusing it without re-seeding is only safe when its content
+     * matches the new job in every dimension that affects the displayed pixels:
+     *
+     *  - @b scene/model-topology epoch: structural model changes invalidate all pixels.
+     *  - @b view epoch: a camera move OR a parameter change bumps the view epoch. Critically,
+     *    a parameter change bumps @e only the view epoch (not the scene epoch) yet changes the
+     *    model content of every pixel. If the view epoch is ignored, a parameter-changed job
+     *    reuses a buffer whose un-overwritten region still shows the previous parameters,
+     *    producing a torn frame: fresh-model top band, stale-model bottom band.
+     *  - @b parameter generation: the GPU parameter buffer is uploaded asynchronously and
+     *    independently of the view epoch. A single fill carries one view epoch, but if a
+     *    parameter upload lands between two chunks the upper band is rendered with the old
+     *    parameters and the lower band with the new ones -- a torn frame the view epoch alone
+     *    cannot detect. Requiring an equal parameter generation forces a re-seed in that case.
+     *  - @b size: the buffer must be at least as large as the requested render target.
+     *
+     * @return true if the buffer is safe to continue/reuse as-is; false if it must be
+     *         re-seeded (or a fresh buffer acquired) so every line is rendered for the new state.
+     */
+    [[nodiscard]] constexpr bool isProgressiveBufferContinuable(
+      ProgressiveBufferState const & buffer, ProgressiveJobTarget const & job) noexcept
+    {
+        return buffer.hasImage && buffer.epoch == job.epoch &&
+               buffer.viewEpoch == job.viewEpoch &&
+               buffer.paramGeneration == job.paramGeneration && buffer.width >= job.width &&
+               buffer.height >= job.height;
+    }
+}
diff --git a/gladius/src/ui/render/RealtimeRaymarchController.cpp b/gladius/src/ui/render/RealtimeRaymarchController.cpp
new file mode 100644
index 00000000..78246786
--- /dev/null
+++ b/gladius/src/ui/render/RealtimeRaymarchController.cpp
@@ -0,0 +1,413 @@
+#include "RealtimeRaymarchController.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+
+namespace gladius::ui::async_rendering
+{
+    namespace
+    {
+        [[nodiscard]] std::string normalizeModeString(std::string value)
+        {
+            std::transform(value.begin(),
+                           value.end(),
+                           value.begin(),
+                           [](unsigned char character)
+                           { return static_cast<char>(std::tolower(character)); });
+            return value;
+        }
+    }
+
+    RealtimeRaymarchMode realtimeRaymarchModeFromString(std::string const & value)
+    {
+        auto const normalized = normalizeModeString(value);
+        if (normalized == "off" || normalized == "disabled" || normalized == "false")
+        {
+            return RealtimeRaymarchMode::Off;
+        }
+        if (normalized == "force" || normalized == "forced" || normalized == "on")
+        {
+            return RealtimeRaymarchMode::Force;
+        }
+        return RealtimeRaymarchMode::Auto;
+    }
+
+    char const * realtimeRaymarchModeToString(RealtimeRaymarchMode mode) noexcept
+    {
+        switch (mode)
+        {
+        case RealtimeRaymarchMode::Off:
+            return "off";
+        case RealtimeRaymarchMode::Force:
+            return "force";
+        case RealtimeRaymarchMode::Auto:
+        default:
+            return "auto";
+        }
+    }
+
+    void RealtimeRaymarchController::configure(RealtimeRaymarchConfig config)
+    {
+        config.targetFrameTimeMs = std::max(config.targetFrameTimeMs, 1.0f);
+        config.enterBudgetRatio = std::clamp(config.enterBudgetRatio, 0.1f, 1.0f);
+        config.exitBudgetRatio = std::max(config.exitBudgetRatio, config.enterBudgetRatio);
+        config.severeMissRatio = std::max(config.severeMissRatio, config.exitBudgetRatio);
+        config.ewmaAlpha = std::clamp(config.ewmaAlpha, 0.01f, 1.0f);
+        config.requiredFastSamples = std::max(config.requiredFastSamples, 1);
+        config.maxSlowSamples = std::max(config.maxSlowSamples, 1);
+        config.cooldownFrames = std::max(config.cooldownFrames, 0);
+        config.staticFullFrameBudgetMs = std::max(config.staticFullFrameBudgetMs, config.targetFrameTimeMs);
+        config.realtimeDropBudgetMs = std::max(config.realtimeDropBudgetMs, config.targetFrameTimeMs);
+
+        m_config = config;
+        if (m_config.mode == RealtimeRaymarchMode::Off)
+        {
+            m_realtimeActive = false;
+        }
+    }
+
+    RealtimeRaymarchConfig const & RealtimeRaymarchController::config() const noexcept
+    {
+        return m_config;
+    }
+
+    void RealtimeRaymarchController::reset()
+    {
+        m_estimatedFullFrameMs.reset();
+        m_width = 0;
+        m_height = 0;
+        m_fastSampleStreak = 0;
+        m_slowSampleStreak = 0;
+        m_cooldownFramesRemaining = 0;
+        m_realtimeActive = false;
+        m_staticFullFramePreferred = false;
+    }
+
+    void RealtimeRaymarchController::resetForResolution(uint32_t width, uint32_t height)
+    {
+        if (m_width == width && m_height == height)
+        {
+            return;
+        }
+
+        auto const previousEstimate = m_estimatedFullFrameMs;
+        auto const previousWidth = m_width;
+        auto const previousHeight = m_height;
+        bool const wasRealtimeActive = m_realtimeActive;
+
+        reset();
+        m_width = width;
+        m_height = height;
+
+        if (!previousEstimate.has_value() || previousWidth == 0 || previousHeight == 0 || width == 0 || height == 0)
+        {
+            return;
+        }
+
+        auto const previousPixels = static_cast<double>(previousWidth) * static_cast<double>(previousHeight);
+        auto const currentPixels = static_cast<double>(width) * static_cast<double>(height);
+        if (previousPixels <= 0.0 || currentPixels <= 0.0)
+        {
+            return;
+        }
+
+        auto const scale = std::clamp(currentPixels / previousPixels, 0.1, 10.0);
+        auto const scaledEstimate = static_cast<float>(*previousEstimate * scale);
+        if (!std::isfinite(scaledEstimate) || scaledEstimate <= 0.0f)
+        {
+            return;
+        }
+
+        m_estimatedFullFrameMs = scaledEstimate;
+
+        if (wasRealtimeActive && scaledEstimate <= m_config.realtimeDropBudgetMs)
+        {
+            m_fastSampleStreak = m_config.requiredFastSamples;
+            m_realtimeActive = m_config.mode == RealtimeRaymarchMode::Auto;
+            m_staticFullFramePreferred = scaledEstimate < m_config.staticFullFrameBudgetMs;
+            return;
+        }
+
+        if (scaledEstimate < m_config.staticFullFrameBudgetMs)
+        {
+            m_staticFullFramePreferred = true;
+        }
+    }
+
+    void RealtimeRaymarchController::beginFrame()
+    {
+        if (m_cooldownFramesRemaining > 0)
+        {
+            --m_cooldownFramesRemaining;
+        }
+    }
+
+    void RealtimeRaymarchController::recordStaticProgressiveSample(RealtimeRaymarchSample const & sample)
+    {
+        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled)
+        {
+            return;
+        }
+
+        if (sample.width == 0 || sample.height == 0)
+        {
+            return;
+        }
+
+        if (!hasValidResolution(sample.width, sample.height))
+        {
+            resetForResolution(sample.width, sample.height);
+        }
+
+        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
+        if (!estimatedMs.has_value())
+        {
+            return;
+        }
+
+        recordEstimatedTime(*estimatedMs);
+        m_staticFullFramePreferred = *estimatedMs < m_config.staticFullFrameBudgetMs;
+        if (m_staticFullFramePreferred)
+        {
+            m_slowSampleStreak = 0;
+        }
+    }
+
+    void RealtimeRaymarchController::recordStaticFullFrameSample(RealtimeRaymarchSample const & sample)
+    {
+        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled || !sample.completedFrame)
+        {
+            return;
+        }
+
+        if (sample.width == 0 || sample.height == 0)
+        {
+            return;
+        }
+
+        if (!hasValidResolution(sample.width, sample.height))
+        {
+            resetForResolution(sample.width, sample.height);
+        }
+
+        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
+        if (!estimatedMs.has_value())
+        {
+            return;
+        }
+
+        recordEstimatedTime(*estimatedMs);
+        m_staticFullFramePreferred = *estimatedMs < m_config.staticFullFrameBudgetMs;
+
+        if (*estimatedMs < m_config.staticFullFrameBudgetMs)
+        {
+            ++m_fastSampleStreak;
+            m_slowSampleStreak = 0;
+            if (m_fastSampleStreak >= m_config.requiredFastSamples)
+            {
+                m_realtimeActive = true;
+            }
+            return;
+        }
+
+        m_fastSampleStreak = 0;
+        if (*estimatedMs > m_config.realtimeDropBudgetMs)
+        {
+            deactivateRealtime();
+        }
+    }
+
+    void RealtimeRaymarchController::recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample)
+    {
+        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled || !sample.completedFrame)
+        {
+            return;
+        }
+
+        if (sample.width == 0 || sample.height == 0)
+        {
+            return;
+        }
+
+        if (!hasValidResolution(sample.width, sample.height))
+        {
+            resetForResolution(sample.width, sample.height);
+        }
+
+        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
+        if (!estimatedMs.has_value())
+        {
+            return;
+        }
+
+        recordEstimatedTime(*estimatedMs);
+        if (*estimatedMs > m_config.realtimeDropBudgetMs)
+        {
+            deactivateRealtime();
+        }
+    }
+
+    void RealtimeRaymarchController::recordRejectedAttempt()
+    {
+        deactivateRealtime();
+        m_fastSampleStreak = 0;
+        ++m_slowSampleStreak;
+        if (m_slowSampleStreak >= m_config.maxSlowSamples)
+        {
+            enterCooldown();
+        }
+    }
+
+    bool RealtimeRaymarchController::canAttemptRealtime(
+      uint32_t width,
+      uint32_t height,
+      RealtimeRaymarchGuards const & guards) const noexcept
+    {
+        if (m_config.mode == RealtimeRaymarchMode::Off)
+        {
+            return false;
+        }
+        if (!hasValidResolution(width, height))
+        {
+            return false;
+        }
+        if (!guardsAllowAttempt(guards))
+        {
+            return false;
+        }
+        if (m_config.mode == RealtimeRaymarchMode::Force)
+        {
+            return true;
+        }
+        if (m_cooldownFramesRemaining > 0)
+        {
+            return false;
+        }
+        return m_realtimeActive;
+    }
+
+    bool RealtimeRaymarchController::canAttemptStaticFullFrame(
+      uint32_t width,
+      uint32_t height,
+      RealtimeRaymarchGuards const & guards) const noexcept
+    {
+        if (m_config.mode != RealtimeRaymarchMode::Auto)
+        {
+            return false;
+        }
+        if (!m_staticFullFramePreferred || m_cooldownFramesRemaining > 0)
+        {
+            return false;
+        }
+        if (!hasValidResolution(width, height))
+        {
+            return false;
+        }
+        return guardsAllowAttempt(guards);
+    }
+
+    bool RealtimeRaymarchController::isRealtimeActive() const noexcept
+    {
+        return m_realtimeActive;
+    }
+
+    bool RealtimeRaymarchController::isCoolingDown() const noexcept
+    {
+        return m_cooldownFramesRemaining > 0;
+    }
+
+    std::optional<float> RealtimeRaymarchController::estimatedFullFrameTimeMs() const noexcept
+    {
+        return m_estimatedFullFrameMs;
+    }
+
+    char const * RealtimeRaymarchController::modeLabel() const noexcept
+    {
+        if (m_config.mode == RealtimeRaymarchMode::Force)
+        {
+            return "RT Force";
+        }
+        if (m_config.mode == RealtimeRaymarchMode::Off)
+        {
+            return "RT Off";
+        }
+        if (m_realtimeActive)
+        {
+            return "RT Auto";
+        }
+        if (m_cooldownFramesRemaining > 0)
+        {
+            return "RT Cooldown";
+        }
+        return "RT Learning";
+    }
+
+    bool RealtimeRaymarchController::hasValidResolution(uint32_t width, uint32_t height) const noexcept
+    {
+        return width > 0 && height > 0 && m_width == width && m_height == height;
+    }
+
+    bool RealtimeRaymarchController::guardsAllowAttempt(
+      RealtimeRaymarchGuards const & guards) const noexcept
+    {
+        return !guards.hardBlocker && !guards.renderJobInFlight && !guards.previewJobInFlight &&
+               !guards.streamingActive && !guards.streamingJobInFlight && !guards.resizePending;
+    }
+
+    std::optional<float> RealtimeRaymarchController::estimateSampleFullFrameTimeMs(
+      RealtimeRaymarchSample const & sample) const noexcept
+    {
+        if (sample.durationMs <= 0.0f || !std::isfinite(sample.durationMs))
+        {
+            return std::nullopt;
+        }
+
+        if (sample.completedFrame)
+        {
+            return sample.durationMs;
+        }
+
+        if (sample.renderedLines == 0 || sample.totalLines == 0)
+        {
+            return std::nullopt;
+        }
+
+        auto const clampedLines = std::min(sample.renderedLines, sample.totalLines);
+        if (clampedLines == 0)
+        {
+            return std::nullopt;
+        }
+
+        auto const scale = static_cast<float>(sample.totalLines) / static_cast<float>(clampedLines);
+        return sample.durationMs * scale;
+    }
+
+    void RealtimeRaymarchController::recordEstimatedTime(float estimatedMs)
+    {
+        if (!m_estimatedFullFrameMs.has_value())
+        {
+            m_estimatedFullFrameMs = estimatedMs;
+        }
+        else
+        {
+            m_estimatedFullFrameMs = (*m_estimatedFullFrameMs * (1.0f - m_config.ewmaAlpha)) +
+                                     (estimatedMs * m_config.ewmaAlpha);
+        }
+    }
+
+    void RealtimeRaymarchController::deactivateRealtime()
+    {
+        m_realtimeActive = false;
+        m_fastSampleStreak = 0;
+        m_staticFullFramePreferred = false;
+    }
+
+    void RealtimeRaymarchController::enterCooldown()
+    {
+        deactivateRealtime();
+        m_fastSampleStreak = 0;
+        m_slowSampleStreak = 0;
+        m_cooldownFramesRemaining = m_config.cooldownFrames;
+    }
+}
diff --git a/gladius/src/ui/render/RealtimeRaymarchController.h b/gladius/src/ui/render/RealtimeRaymarchController.h
new file mode 100644
index 00000000..2db68921
--- /dev/null
+++ b/gladius/src/ui/render/RealtimeRaymarchController.h
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace gladius::ui::async_rendering
+{
+    enum class RealtimeRaymarchMode
+    {
+        Off,
+        Auto,
+        Force
+    };
+
+    [[nodiscard]] RealtimeRaymarchMode realtimeRaymarchModeFromString(std::string const & value);
+    [[nodiscard]] char const * realtimeRaymarchModeToString(RealtimeRaymarchMode mode) noexcept;
+
+    struct RealtimeRaymarchConfig
+    {
+        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
+        float targetFrameTimeMs{25.0f};
+        float enterBudgetRatio{1.0f};
+        float exitBudgetRatio{1.1f};
+        float severeMissRatio{2.0f};
+        float ewmaAlpha{0.35f};
+        int requiredFastSamples{1};
+        int maxSlowSamples{2};
+        int cooldownFrames{30};
+        float staticFullFrameBudgetMs{100.0f};
+        float realtimeDropBudgetMs{100.0f};
+    };
+
+    struct RealtimeRaymarchGuards
+    {
+        bool hardBlocker{false};
+        bool renderJobInFlight{false};
+        bool previewJobInFlight{false};
+        bool streamingActive{false};
+        bool streamingJobInFlight{false};
+        bool resizePending{false};
+    };
+
+    struct RealtimeRaymarchSample
+    {
+        float durationMs{0.0f};
+        uint32_t width{0};
+        uint32_t height{0};
+        size_t renderedLines{0};
+        size_t totalLines{0};
+        bool completedFrame{false};
+        bool cancelled{false};
+    };
+
+    class RealtimeRaymarchController
+    {
+      public:
+        void configure(RealtimeRaymarchConfig config);
+        [[nodiscard]] RealtimeRaymarchConfig const & config() const noexcept;
+
+        void reset();
+        void resetForResolution(uint32_t width, uint32_t height);
+        void beginFrame();
+
+        void recordStaticProgressiveSample(RealtimeRaymarchSample const & sample);
+        void recordStaticFullFrameSample(RealtimeRaymarchSample const & sample);
+        void recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample);
+        void recordRejectedAttempt();
+
+        [[nodiscard]] bool canAttemptRealtime(uint32_t width,
+                                              uint32_t height,
+                                              RealtimeRaymarchGuards const & guards) const noexcept;
+        [[nodiscard]] bool canAttemptStaticFullFrame(uint32_t width,
+                                                     uint32_t height,
+                                                     RealtimeRaymarchGuards const & guards) const noexcept;
+        [[nodiscard]] bool isRealtimeActive() const noexcept;
+        [[nodiscard]] bool isCoolingDown() const noexcept;
+        [[nodiscard]] std::optional<float> estimatedFullFrameTimeMs() const noexcept;
+        [[nodiscard]] char const * modeLabel() const noexcept;
+        [[nodiscard]] bool guardsAllowAttempt(RealtimeRaymarchGuards const & guards) const noexcept;
+
+      private:
+        [[nodiscard]] bool hasValidResolution(uint32_t width, uint32_t height) const noexcept;
+        [[nodiscard]] std::optional<float> estimateSampleFullFrameTimeMs(
+          RealtimeRaymarchSample const & sample) const noexcept;
+        void recordEstimatedTime(float estimatedMs);
+        void deactivateRealtime();
+        void enterCooldown();
+
+        RealtimeRaymarchConfig m_config{};
+        std::optional<float> m_estimatedFullFrameMs{};
+        uint32_t m_width{0};
+        uint32_t m_height{0};
+        int m_fastSampleStreak{0};
+        int m_slowSampleStreak{0};
+        int m_cooldownFramesRemaining{0};
+        bool m_realtimeActive{false};
+        bool m_staticFullFramePreferred{false};
+    };
+}
diff --git a/gladius/src/ui/render/RenderModeUpdatePolicy.h b/gladius/src/ui/render/RenderModeUpdatePolicy.h
new file mode 100644
index 00000000..22e15212
--- /dev/null
+++ b/gladius/src/ui/render/RenderModeUpdatePolicy.h
@@ -0,0 +1,147 @@
+#pragma once
+
+#include "RealtimeRaymarchController.h"
+#include "RenderUpdateTypes.h"
+
+namespace gladius::ui::async_rendering
+{
+    struct LegacyLowResPreviewInput
+    {
+        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
+        RenderInteractionState interactionState{RenderInteractionState::Static};
+        bool autoRealtimeActive{false};
+        bool stateIsMoving{false};
+        bool forceLowResRender{false};
+        bool lowResFeedbackPending{false};
+        bool exactRealtimeJobInFlight{false};
+    };
+
+    [[nodiscard]] constexpr bool usesExactRealtimeInteraction(
+      LegacyLowResPreviewInput const & input) noexcept
+    {
+        if (input.mode == RealtimeRaymarchMode::Force)
+        {
+            return true;
+        }
+
+        // Auto mode: once the learning controller has proven the GPU is fast enough,
+        // suppress the legacy low-res path entirely.  The coordinator either schedules
+        // exact realtime directly or keeps the current HQ frame while guards block.
+        return input.mode == RealtimeRaymarchMode::Auto && input.autoRealtimeActive;
+    }
+
+    [[nodiscard]] constexpr bool shouldUseLegacyLowResPreview(
+      LegacyLowResPreviewInput const & input) noexcept
+    {
+        bool const lowResRequested = input.stateIsMoving || input.forceLowResRender ||
+                                     input.lowResFeedbackPending;
+        if (!lowResRequested || input.exactRealtimeJobInFlight)
+        {
+            return false;
+        }
+
+        if (usesExactRealtimeInteraction(input))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    struct RealtimeInteractionActivityInput
+    {
+        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
+        RenderInteractionState interactionState{RenderInteractionState::Static};
+        bool autoRealtimeActive{false};
+        /// True when Auto has fallen back to the simpler low-res preview path for the
+        /// current gesture.  While this latch is active, preview tasks/results are the
+        /// intended feedback path and must not be cancelled as "realtime active".
+        bool autoPreviewFallbackActive{false};
+        bool exactRealtimeJobInFlight{false};
+    };
+
+    [[nodiscard]] constexpr bool isExactRealtimeInteractionActive(
+      RealtimeInteractionActivityInput const & input) noexcept
+    {
+        if (input.interactionState == RenderInteractionState::Static)
+        {
+            return false;
+        }
+
+        if (input.exactRealtimeJobInFlight)
+        {
+            return true;
+        }
+
+        if (input.mode == RealtimeRaymarchMode::Force)
+        {
+            return true;
+        }
+
+        return input.mode == RealtimeRaymarchMode::Auto && input.autoRealtimeActive &&
+               !input.autoPreviewFallbackActive;
+    }
+
+    enum class RealtimeFrameExecutionPath
+    {
+        AsyncWorker,
+        SynchronousUiThread
+    };
+
+    [[nodiscard]] constexpr RealtimeFrameExecutionPath chooseRealtimeFrameExecutionPath(
+      RealtimeInteractionActivityInput const & input) noexcept
+    {
+        return isExactRealtimeInteractionActive(input)
+                 ? RealtimeFrameExecutionPath::SynchronousUiThread
+                 : RealtimeFrameExecutionPath::AsyncWorker;
+    }
+
+    struct ParameterChangeDispatchInput
+    {
+        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
+        bool streamingPreviewActive{false};
+        /// Set to true when the realtime learning controller has confirmed the GPU can
+        /// render within the frame budget.  When true in Auto mode, parameter changes
+        /// should use the direct realtime path rather than starting a streaming preview.
+        bool autoRealtimeActive{false};
+    };
+
+    struct ParameterChangeDispatch
+    {
+        bool invalidateInteraction{false};
+        bool refreshStreamingInteraction{false};
+        bool startStreamingPreview{false};
+    };
+
+    [[nodiscard]] constexpr ParameterChangeDispatch classifyParameterChange(
+      ParameterChangeDispatchInput const & input) noexcept
+    {
+        if (input.mode == RealtimeRaymarchMode::Force)
+        {
+            return {.invalidateInteraction = true,
+                    .refreshStreamingInteraction = false,
+                    .startStreamingPreview = false};
+        }
+
+        // Auto mode with realtime proven fast: treat like Force — just invalidate so the
+        // coordinator can schedule a realtime frame.  Starting a streaming preview would
+        // race with the sync realtime path and produce redundant low-res frames.
+        if (input.mode == RealtimeRaymarchMode::Auto && input.autoRealtimeActive)
+        {
+            return {.invalidateInteraction = true,
+                    .refreshStreamingInteraction = false,
+                    .startStreamingPreview = false};
+        }
+
+        if (input.streamingPreviewActive)
+        {
+            return {.invalidateInteraction = false,
+                    .refreshStreamingInteraction = true,
+                    .startStreamingPreview = false};
+        }
+
+        return {.invalidateInteraction = true,
+                .refreshStreamingInteraction = false,
+                .startStreamingPreview = true};
+    }
+}
\ No newline at end of file
diff --git a/gladius/src/ui/render/RenderUpdateCoordinator.h b/gladius/src/ui/render/RenderUpdateCoordinator.h
new file mode 100644
index 00000000..bef0094b
--- /dev/null
+++ b/gladius/src/ui/render/RenderUpdateCoordinator.h
@@ -0,0 +1,614 @@
+#pragma once
+
+#include "InteractiveRenderPathPolicy.h"
+#include "RealtimeRaymarchController.h"
+#include "RenderUpdateTypes.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace gladius::ui::async_rendering
+{
+    enum class RenderCommandType
+    {
+        StartTask,
+        PresentFrame,
+        DiscardTaskResult,
+        KeepCurrentFrame
+    };
+
+    struct RenderCommand
+    {
+        RenderCommandType type{RenderCommandType::KeepCurrentFrame};
+        RenderTaskRequest task{};
+        RenderTaskResult result{};
+        RenderStamp stamp{};
+    };
+
+    struct RenderUpdateDecision
+    {
+        std::vector<RenderCommand> commands;
+    };
+
+    /**
+     * @brief Pure render/update policy that converts semantic UI/render events into task commands.
+     *
+     * The coordinator intentionally has no ImGui, OpenGL, OpenCL, GLImageBuffer, or ComputeCore
+     * dependency. Production code should translate these semantic commands into concrete work,
+     * while unit tests can drive the full epoch/backpressure/stale-result behavior directly.
+     */
+    class RenderUpdateCoordinator
+    {
+      public:
+        RenderUpdateCoordinator()
+        {
+            m_realtime.resetForResolution(m_width, m_height);
+        }
+
+        void configureRealtime(RealtimeRaymarchConfig config)
+        {
+            m_realtime.configure(config);
+            m_realtime.resetForResolution(m_width, m_height);
+        }
+
+        [[nodiscard]] RealtimeRaymarchConfig const & realtimeConfig() const noexcept
+        {
+            return m_realtime.config();
+        }
+
+        [[nodiscard]] bool isRealtimeActive() const noexcept
+        {
+            return m_realtime.isRealtimeActive();
+        }
+
+        /// Returns true when realtime frame rendering is expected to succeed at interactive rates.
+        /// This covers Force mode (always) and Auto mode once the controller has measured
+        /// sufficient GPU performance.  Use this — rather than checking the mode directly —
+        /// to gate the synchronous render path so Auto-mode users get the same low-latency
+        /// feedback as Force-mode users.
+        [[nodiscard]] bool isRealtimeSchedulingActive() const noexcept
+        {
+            return m_realtime.config().mode == RealtimeRaymarchMode::Force ||
+                   (m_realtime.config().mode == RealtimeRaymarchMode::Auto &&
+                    m_realtime.isRealtimeActive());
+        }
+
+        /// Returns true when Auto mode has latched the current interaction to the
+        /// simpler preview path after a guard blocked exact realtime.  This latch is
+        /// cleared when the gesture ends and prevents mid-gesture path switching.
+        [[nodiscard]] bool isAutoPreviewFallbackActive() const noexcept
+        {
+            return m_realtime.config().mode == RealtimeRaymarchMode::Auto &&
+                   m_interactionState != RenderInteractionState::Static &&
+                   m_autoGestureLockedSimpler;
+        }
+
+        void setRealtimeGuards(RealtimeRaymarchGuards guards) noexcept
+        {
+            m_realtimeGuards = guards;
+        }
+
+        void recordStaticProgressiveSample(RealtimeRaymarchSample const & sample)
+        {
+            m_realtime.recordStaticProgressiveSample(sample);
+        }
+
+        void recordStaticFullFrameSample(RealtimeRaymarchSample const & sample)
+        {
+            m_realtime.recordStaticFullFrameSample(sample);
+        }
+
+        void recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample)
+        {
+            m_realtime.recordInteractiveRealtimeSample(sample);
+        }
+
+        void recordRealtimeRejectedAttempt()
+        {
+            m_realtime.recordRejectedAttempt();
+        }
+
+        [[nodiscard]] RenderStamp latestStamp() const noexcept
+        {
+            return m_latestStamp;
+        }
+
+        [[nodiscard]] RenderInteractionState interactionState() const noexcept
+        {
+            return m_interactionState;
+        }
+
+        [[nodiscard]] bool isBoundingBoxCurrent() const noexcept
+        {
+            return m_boundingBoxStamp.has_value() &&
+                   matches(*m_boundingBoxStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
+        }
+
+        [[nodiscard]] bool isSdfCurrent() const noexcept
+        {
+            return m_sdfStamp.has_value() &&
+                   matches(*m_sdfStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
+        }
+
+        [[nodiscard]] bool isHeavyGeometryCurrent() const noexcept
+        {
+            return isBoundingBoxCurrent() && isSdfCurrent();
+        }
+
+        [[nodiscard]] bool isHighQualityFrameCurrent() const noexcept
+        {
+            return m_highQualityFrameStamp.has_value() &&
+                   matches(*m_highQualityFrameStamp, m_latestStamp, RenderStampMask::displayFrame());
+        }
+
+        [[nodiscard]] RenderUpdateDecision configureViewport(uint32_t width, uint32_t height)
+        {
+            RenderUpdateDecision decision{};
+            if (width == 0 || height == 0 || (width == m_width && height == m_height))
+            {
+                return decision;
+            }
+
+            m_width = width;
+            m_height = height;
+            ++m_latestStamp.viewportEpoch;
+            m_realtime.resetForResolution(m_width, m_height);
+            scheduleStaticCatchUp(decision);
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyCameraChanged()
+        {
+            RenderUpdateDecision decision{};
+            auto const previousState = m_interactionState;
+            ++m_latestStamp.viewEpoch;
+            if (previousState != RenderInteractionState::CameraInteracting)
+            {
+                releaseStaleInteractiveInFlight();
+            }
+            m_interactionState = RenderInteractionState::CameraInteracting;
+            scheduleInteractiveFrame(decision);
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyCameraInteractionEnded()
+        {
+            RenderUpdateDecision decision{};
+            if (m_interactionState == RenderInteractionState::CameraInteracting)
+            {
+                m_interactionState = RenderInteractionState::Static;
+            }
+            m_autoGestureLockedSimpler = false;
+            scheduleStaticCatchUp(decision);
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyParameterChanged(bool interactionActive)
+        {
+            RenderUpdateDecision decision{};
+            auto const previousState = m_interactionState;
+            ++m_latestStamp.parameterEpoch;
+            resetRealtimeLearning();
+            m_parameterUploadStamp.reset();
+            m_boundingBoxStamp.reset();
+            m_sdfStamp.reset();
+            m_interactionState = interactionActive ? RenderInteractionState::ParameterInteracting
+                                                   : RenderInteractionState::Static;
+            if (interactionActive && previousState != RenderInteractionState::ParameterInteracting)
+            {
+                releaseStaleInteractiveInFlight();
+            }
+            startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
+            if (interactionActive)
+            {
+                scheduleInteractiveFrame(decision);
+            }
+            else
+            {
+                scheduleStaticCatchUp(decision);
+            }
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyParameterInteractionEnded()
+        {
+            RenderUpdateDecision decision{};
+            m_interactionState = RenderInteractionState::Static;
+            m_autoGestureLockedSimpler = false;
+            scheduleStaticCatchUp(decision);
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyStructuralModelChanged()
+        {
+            RenderUpdateDecision decision{};
+            ++m_latestStamp.sceneEpoch;
+            ++m_latestStamp.parameterEpoch;
+            resetRealtimeLearning();
+            m_programStamp.reset();
+            m_parameterUploadStamp.reset();
+            m_boundingBoxStamp.reset();
+            m_sdfStamp.reset();
+            m_interactionState = RenderInteractionState::Static;
+            scheduleStaticCatchUp(decision);
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision notifyProgramCompilationCompleted()
+        {
+            return completeTask(RenderTaskResult{.type = RenderTaskType::ProgramCompilation,
+                                                .stamp = m_latestStamp,
+                                                .status = RenderTaskStatus::Completed});
+        }
+
+        [[nodiscard]] RenderUpdateDecision tick()
+        {
+            RenderUpdateDecision decision{};
+            m_realtime.beginFrame();
+            // Self-heal: reclaim any in-flight task the translation layer failed to complete and
+            // that is already stale, so a single orphaned entry cannot wedge the catch-up pipeline.
+            reconcileStaleInFlight();
+            if (m_interactionState == RenderInteractionState::Static)
+            {
+                scheduleStaticCatchUp(decision);
+            }
+            else
+            {
+                if (m_interactionState == RenderInteractionState::ParameterInteracting &&
+                    !areParametersUploaded())
+                {
+                    startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
+                }
+                scheduleInteractiveFrame(decision);
+            }
+            return decision;
+        }
+
+        [[nodiscard]] RenderUpdateDecision completeTask(RenderTaskResult const & result)
+        {
+            RenderUpdateDecision decision{};
+            removeInFlight(result);
+
+            auto const mask = freshnessMaskFor(result.type);
+            if (!result.isCurrentFor(m_latestStamp, mask))
+            {
+                decision.commands.push_back(RenderCommand{.type = RenderCommandType::DiscardTaskResult,
+                                                          .result = result,
+                                                          .stamp = m_latestStamp});
+                return decision;
+            }
+
+            switch (result.type)
+            {
+            case RenderTaskType::ProgramCompilation:
+                m_programStamp = result.stamp;
+                break;
+            case RenderTaskType::ParameterUpload:
+                m_parameterUploadStamp = result.stamp;
+                break;
+            case RenderTaskType::BoundingBoxUpdate:
+                m_boundingBoxStamp = result.stamp;
+                break;
+            case RenderTaskType::SdfPrecomputation:
+                m_sdfStamp = result.stamp;
+                break;
+            case RenderTaskType::RealtimeFullFrame:
+            case RenderTaskType::StaticFullFrameProbe:
+            case RenderTaskType::ProgressiveHighQualityChunk:
+            case RenderTaskType::LowResolutionPreview:
+            case RenderTaskType::StreamingPreview:
+                if (result.producedDisplayFrame)
+                {
+                    if (result.completedFrame &&
+                        (result.type == RenderTaskType::ProgressiveHighQualityChunk ||
+                         result.type == RenderTaskType::RealtimeFullFrame ||
+                         result.type == RenderTaskType::StaticFullFrameProbe))
+                    {
+                        m_highQualityFrameStamp = result.stamp;
+                    }
+                    decision.commands.push_back(RenderCommand{.type = RenderCommandType::PresentFrame,
+                                                              .result = result,
+                                                              .stamp = result.stamp});
+                }
+                break;
+            }
+
+            if (m_interactionState == RenderInteractionState::Static)
+            {
+                scheduleStaticCatchUp(decision);
+            }
+            return decision;
+        }
+
+      private:
+        struct InFlightTask
+        {
+            uint64_t requestId{0};
+            RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
+            RenderStamp stamp{};
+        };
+
+        [[nodiscard]] static constexpr RenderStampMask freshnessMaskFor(RenderTaskType type) noexcept
+        {
+            switch (type)
+            {
+            case RenderTaskType::ProgramCompilation:
+                return RenderStampMask::sceneOnly();
+            case RenderTaskType::ParameterUpload:
+            case RenderTaskType::BoundingBoxUpdate:
+            case RenderTaskType::SdfPrecomputation:
+                return RenderStampMask::heavyGeometryTask();
+            case RenderTaskType::RealtimeFullFrame:
+            case RenderTaskType::StaticFullFrameProbe:
+            case RenderTaskType::ProgressiveHighQualityChunk:
+            case RenderTaskType::LowResolutionPreview:
+            case RenderTaskType::StreamingPreview:
+            default:
+                return RenderStampMask::displayFrame();
+            }
+        }
+
+        [[nodiscard]] bool hasAnyInFlight(RenderTaskType type) const noexcept
+        {
+            return std::any_of(m_inFlight.begin(),
+                               m_inFlight.end(),
+                               [type](InFlightTask const & task) { return task.type == type; });
+        }
+
+        [[nodiscard]] bool hasInteractiveFrameInFlight() const noexcept
+        {
+            return hasEquivalentInFlight(RenderTaskType::RealtimeFullFrame, m_latestStamp) ||
+                   hasEquivalentInFlight(RenderTaskType::LowResolutionPreview, m_latestStamp) ||
+                   hasEquivalentInFlight(RenderTaskType::StreamingPreview, m_latestStamp);
+        }
+
+        void releaseStaleInteractiveInFlight()
+        {
+            auto const oldEnd = m_inFlight.end();
+            auto const newEnd = std::remove_if(m_inFlight.begin(),
+                                               m_inFlight.end(),
+                                               [this](InFlightTask const & task)
+                                               {
+                                                   bool const interactiveFrameTask =
+                                                     task.type == RenderTaskType::RealtimeFullFrame ||
+                                                     task.type == RenderTaskType::LowResolutionPreview ||
+                                                     task.type == RenderTaskType::StreamingPreview;
+                                                   return interactiveFrameTask &&
+                                                          !matches(task.stamp,
+                                                                   m_latestStamp,
+                                                                   RenderStampMask::displayFrame());
+                                               });
+            m_inFlight.erase(newEnd, oldEnd);
+        }
+
+        /// Drops every in-flight heavy/static task whose stamp is already stale under that task's
+        /// own freshness mask, i.e. a task whose eventual result would be discarded by
+        /// completeTask() anyway.
+        ///
+        /// This is the self-healing counterpart to the strict StartTask/completeTask pairing the
+        /// translation layer (RenderWindow) must otherwise guarantee across many early-return and
+        /// atomic code paths. If any one of those paths ever fails to drive a started task back to a
+        /// terminal completeTask()/failTask(), the orphaned entry would block all future tasks of
+        /// that type forever (hasAnyInFlight() is stamp-agnostic), stalling the static catch-up
+        /// pipeline. Reclaiming stale entries at every tick keeps the scheduler from getting wedged.
+        /// It is safe because a stale task can never become current again, and the translation layer
+        /// guards in-flight GPU jobs separately, so reclaiming here cannot cause duplicate execution.
+        ///
+        /// Interactive frame tasks (RealtimeFullFrame / LowResolutionPreview / StreamingPreview) are
+        /// intentionally excluded: stale interactive frames are retained as backpressure so only one
+        /// interactive frame is ever in flight (latest-wins on completion). Those are reclaimed by
+        /// releaseStaleInteractiveInFlight() at the appropriate interaction transitions instead.
+        void reconcileStaleInFlight()
+        {
+            auto const oldEnd = m_inFlight.end();
+            auto const newEnd = std::remove_if(m_inFlight.begin(),
+                                               m_inFlight.end(),
+                                               [this](InFlightTask const & task)
+                                               {
+                                                   bool const interactiveFrameTask =
+                                                     task.type == RenderTaskType::RealtimeFullFrame ||
+                                                     task.type == RenderTaskType::LowResolutionPreview ||
+                                                     task.type == RenderTaskType::StreamingPreview;
+                                                   return !interactiveFrameTask &&
+                                                          !matches(task.stamp,
+                                                                   m_latestStamp,
+                                                                   freshnessMaskFor(task.type));
+                                               });
+            m_inFlight.erase(newEnd, oldEnd);
+        }
+
+        [[nodiscard]] bool hasEquivalentInFlight(RenderTaskType type, RenderStamp const & stamp) const noexcept
+        {
+            auto const mask = freshnessMaskFor(type);
+            return std::any_of(m_inFlight.begin(),
+                               m_inFlight.end(),
+                               [type, stamp, mask](InFlightTask const & task)
+                               { return task.type == type && matches(task.stamp, stamp, mask); });
+        }
+
+        [[nodiscard]] bool isProgramCurrent() const noexcept
+        {
+            return m_programStamp.has_value() &&
+                   matches(*m_programStamp, m_latestStamp, RenderStampMask::sceneOnly());
+        }
+
+        [[nodiscard]] bool areParametersUploaded() const noexcept
+        {
+            return m_parameterUploadStamp.has_value() &&
+                   matches(*m_parameterUploadStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
+        }
+
+        void startTask(RenderUpdateDecision & decision,
+                       RenderTaskType type,
+                       RenderStamp const & stamp,
+                       size_t lineCount = 0)
+        {
+            if (hasAnyInFlight(type) || hasEquivalentInFlight(type, stamp))
+            {
+                keepCurrentFrame(decision);
+                return;
+            }
+
+            size_t const requestedLines = lineCount == 0 ? static_cast<size_t>(m_height) : lineCount;
+            size_t const clampedLineCount =
+                std::clamp(requestedLines, size_t{1}, static_cast<size_t>(m_height));
+
+            RenderTaskRequest request{.requestId = m_nextRequestId++,
+                                      .type = type,
+                                      .stamp = stamp,
+                                      .width = m_width,
+                                      .height = m_height,
+                                      .startLine = 0,
+                                      .lineCount = clampedLineCount};
+            m_inFlight.push_back(InFlightTask{.requestId = request.requestId,
+                                              .type = request.type,
+                                              .stamp = request.stamp});
+            decision.commands.push_back(RenderCommand{.type = RenderCommandType::StartTask,
+                                                      .task = request,
+                                                      .stamp = stamp});
+        }
+
+        void keepCurrentFrame(RenderUpdateDecision & decision) const
+        {
+            decision.commands.push_back(RenderCommand{.type = RenderCommandType::KeepCurrentFrame,
+                                                      .stamp = m_latestStamp});
+        }
+
+        void resetRealtimeLearning()
+        {
+            m_realtime.reset();
+            m_realtime.resetForResolution(m_width, m_height);
+            m_autoGestureLockedSimpler = false;
+        }
+
+        [[nodiscard]] bool autoModeAdmitsRealtime() const noexcept
+        {
+            return m_realtime.isRealtimeActive();
+        }
+
+        void scheduleInteractiveFrame(RenderUpdateDecision & decision)
+        {
+            auto const mode = m_realtime.config().mode;
+
+            bool exactRealtimeAllowed = false;
+            if (mode == RealtimeRaymarchMode::Force)
+            {
+                exactRealtimeAllowed =
+                  m_realtime.canAttemptRealtime(m_width, m_height, m_realtimeGuards);
+            }
+            else if (mode == RealtimeRaymarchMode::Auto)
+            {
+                exactRealtimeAllowed = m_realtime.guardsAllowAttempt(m_realtimeGuards);
+            }
+
+            auto const path = chooseInteractiveRenderPath(
+              InteractiveRenderPathInput{.mode = mode,
+                                         .interactionState = m_interactionState,
+                                         .interactiveFrameAlreadyInFlight = hasInteractiveFrameInFlight(),
+                                         .autoParameterExactRealtimeActive = m_realtime.isRealtimeActive(),
+                                         .autoInteractiveExactRealtimeAdmitted = autoModeAdmitsRealtime(),
+                                         .preferSimplerPreview = m_autoGestureLockedSimpler,
+                                         .exactRealtimeAllowed = exactRealtimeAllowed});
+
+            if (mode == RealtimeRaymarchMode::Auto &&
+                m_interactionState != RenderInteractionState::Static &&
+                path == InteractiveRenderPath::LowResolutionPreview)
+            {
+                m_autoGestureLockedSimpler = true;
+            }
+
+            switch (path)
+            {
+            case InteractiveRenderPath::ExactRealtime:
+                startTask(decision, RenderTaskType::RealtimeFullFrame, m_latestStamp);
+                return;
+            case InteractiveRenderPath::LowResolutionPreview:
+                startTask(decision, RenderTaskType::LowResolutionPreview, m_latestStamp);
+                return;
+            case InteractiveRenderPath::KeepCurrentFrame:
+            default:
+                keepCurrentFrame(decision);
+                return;
+            }
+        }
+
+        void scheduleStaticCatchUp(RenderUpdateDecision & decision)
+        {
+            if (!isProgramCurrent())
+            {
+                startTask(decision, RenderTaskType::ProgramCompilation, m_latestStamp);
+                return;
+            }
+            if (!areParametersUploaded())
+            {
+                startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
+                return;
+            }
+            if (!isBoundingBoxCurrent())
+            {
+                startTask(decision, RenderTaskType::BoundingBoxUpdate, m_latestStamp);
+                return;
+            }
+            if (!isSdfCurrent())
+            {
+                startTask(decision, RenderTaskType::SdfPrecomputation, m_latestStamp);
+                return;
+            }
+            if (isHighQualityFrameCurrent())
+            {
+                keepCurrentFrame(decision);
+                return;
+            }
+            if (m_realtime.canAttemptStaticFullFrame(m_width, m_height, m_realtimeGuards))
+            {
+                startTask(decision, RenderTaskType::StaticFullFrameProbe, m_latestStamp);
+                return;
+            }
+            startTask(decision, RenderTaskType::ProgressiveHighQualityChunk, m_latestStamp);
+        }
+
+        void removeInFlight(RenderTaskResult const & result)
+        {
+            auto const byRequestId = [result](InFlightTask const & task)
+            { return result.requestId != 0 && task.requestId == result.requestId; };
+            auto const byTypeAndStamp = [result](InFlightTask const & task)
+            {
+                return task.type == result.type &&
+                       matches(task.stamp, result.stamp, freshnessMaskFor(result.type));
+            };
+            auto const byTypeWithoutRequestId = [result](InFlightTask const & task)
+            { return result.requestId == 0 && task.type == result.type; };
+
+            auto const oldEnd = m_inFlight.end();
+            auto const newEnd = std::remove_if(m_inFlight.begin(),
+                                               m_inFlight.end(),
+                                               [byRequestId, byTypeAndStamp, byTypeWithoutRequestId](
+                                                 InFlightTask const & task)
+                                               {
+                                                   return byRequestId(task) || byTypeAndStamp(task) ||
+                                                          byTypeWithoutRequestId(task);
+                                               });
+            m_inFlight.erase(newEnd, oldEnd);
+        }
+
+        RenderStamp m_latestStamp{};
+        std::optional<RenderStamp> m_programStamp{m_latestStamp};
+        std::optional<RenderStamp> m_parameterUploadStamp{m_latestStamp};
+        std::optional<RenderStamp> m_boundingBoxStamp{};
+        std::optional<RenderStamp> m_sdfStamp{};
+        std::optional<RenderStamp> m_highQualityFrameStamp{};
+        std::vector<InFlightTask> m_inFlight;
+        RealtimeRaymarchController m_realtime;
+        RealtimeRaymarchGuards m_realtimeGuards{};
+        RenderInteractionState m_interactionState{RenderInteractionState::Static};
+        uint64_t m_nextRequestId{1};
+        uint32_t m_width{1};
+        uint32_t m_height{1};
+        /// Per-gesture latch: set when Auto mode first decides to use simpler rendering during
+        /// an interaction. Cleared when the gesture ends to prevent mid-gesture quality switches.
+        bool m_autoGestureLockedSimpler{false};
+    };
+}
diff --git a/gladius/src/ui/render/RenderUpdateTypes.h b/gladius/src/ui/render/RenderUpdateTypes.h
new file mode 100644
index 00000000..0b8ff98b
--- /dev/null
+++ b/gladius/src/ui/render/RenderUpdateTypes.h
@@ -0,0 +1,187 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace gladius::ui::async_rendering
+{
+    enum class RenderInteractionState
+    {
+        Static,
+        CameraInteracting,
+        ParameterInteracting
+    };
+
+    /**
+     * @brief Identifies the independently changing inputs that make a rendered artifact fresh.
+     *
+     * Scene/model, parameter, camera/view, viewport, and quality generations intentionally evolve
+     * independently. This lets camera-only interaction reject stale view frames without forcing
+     * expensive model-side work such as bounding-box or SDF recomputation.
+     */
+    struct RenderStamp
+    {
+        uint64_t sceneEpoch{0};     ///< Structural model/program generation.
+        uint64_t parameterEpoch{0}; ///< Numeric parameter payload generation.
+        uint64_t viewEpoch{0};      ///< Camera/view generation.
+        uint64_t viewportEpoch{0};  ///< Render target size/generation.
+        uint64_t qualityEpoch{0};   ///< Render settings/quality generation.
+    };
+
+    /**
+     * @brief Selects which RenderStamp axes are relevant for a freshness comparison.
+     */
+    struct RenderStampMask
+    {
+        bool scene{true};
+        bool parameters{true};
+        bool view{true};
+        bool viewport{true};
+        bool quality{true};
+
+        [[nodiscard]] static constexpr RenderStampMask all() noexcept
+        {
+            return {};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask none() noexcept
+        {
+            return {.scene = false,
+                    .parameters = false,
+                    .view = false,
+                    .viewport = false,
+                    .quality = false};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask sceneOnly() noexcept
+        {
+            return {.scene = true,
+                    .parameters = false,
+                    .view = false,
+                    .viewport = false,
+                    .quality = false};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask sceneAndParameters() noexcept
+        {
+            return {.scene = true,
+                    .parameters = true,
+                    .view = false,
+                    .viewport = false,
+                    .quality = false};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask displayFrame() noexcept
+        {
+            return {.scene = true,
+                    .parameters = true,
+                    .view = true,
+                    .viewport = true,
+                    .quality = true};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask interactiveFrame() noexcept
+        {
+            return {.scene = true,
+                    .parameters = true,
+                    .view = true,
+                    .viewport = true,
+                    .quality = false};
+        }
+
+        [[nodiscard]] static constexpr RenderStampMask heavyGeometryTask() noexcept
+        {
+            return sceneAndParameters();
+        }
+    };
+
+    [[nodiscard]] constexpr bool matches(RenderStamp const & candidate,
+                                         RenderStamp const & required,
+                                         RenderStampMask const mask = RenderStampMask::all()) noexcept
+    {
+        return (!mask.scene || candidate.sceneEpoch == required.sceneEpoch) &&
+               (!mask.parameters || candidate.parameterEpoch == required.parameterEpoch) &&
+               (!mask.view || candidate.viewEpoch == required.viewEpoch) &&
+               (!mask.viewport || candidate.viewportEpoch == required.viewportEpoch) &&
+               (!mask.quality || candidate.qualityEpoch == required.qualityEpoch);
+    }
+
+    [[nodiscard]] constexpr bool isOlderThan(RenderStamp const & candidate,
+                                             RenderStamp const & required,
+                                             RenderStampMask const mask = RenderStampMask::all()) noexcept
+    {
+        return (mask.scene && candidate.sceneEpoch < required.sceneEpoch) ||
+               (mask.parameters && candidate.parameterEpoch < required.parameterEpoch) ||
+               (mask.view && candidate.viewEpoch < required.viewEpoch) ||
+               (mask.viewport && candidate.viewportEpoch < required.viewportEpoch) ||
+               (mask.quality && candidate.qualityEpoch < required.qualityEpoch);
+    }
+
+    /**
+     * @brief Testable semantic task kinds requested by the render-update coordinator.
+     */
+    enum class RenderTaskType
+    {
+        RealtimeFullFrame,
+        StaticFullFrameProbe,
+        ProgressiveHighQualityChunk,
+        LowResolutionPreview,
+        StreamingPreview,
+        BoundingBoxUpdate,
+        SdfPrecomputation,
+        ParameterUpload,
+        ProgramCompilation
+    };
+
+    enum class RenderTaskStatus
+    {
+        Completed,
+        Cancelled,
+        Failed
+    };
+
+    /**
+     * @brief Pure description of render/update work before it is translated to GPU/UI calls.
+     */
+    struct RenderTaskRequest
+    {
+        uint64_t requestId{0};
+        RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
+        RenderStamp stamp{};
+        uint32_t width{0};
+        uint32_t height{0};
+        size_t startLine{0};
+        size_t lineCount{0};
+    };
+
+    /**
+     * @brief Pure completion metadata returned to the render-update coordinator.
+     */
+    struct RenderTaskResult
+    {
+        uint64_t requestId{0};
+        RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
+        RenderStamp stamp{};
+        RenderTaskStatus status{RenderTaskStatus::Completed};
+        uint64_t durationNs{0};
+        bool producedDisplayFrame{false};
+        bool completedFrame{false};
+
+        [[nodiscard]] constexpr bool succeeded() const noexcept
+        {
+            return status == RenderTaskStatus::Completed;
+        }
+
+        [[nodiscard]] constexpr bool isCurrentFor(RenderStamp const & required,
+                                                  RenderStampMask const mask) const noexcept
+        {
+            return succeeded() && matches(stamp, required, mask);
+        }
+
+        [[nodiscard]] constexpr bool isDisplayableFor(RenderStamp const & required,
+                                                      RenderStampMask const mask = RenderStampMask::displayFrame()) const noexcept
+        {
+            return producedDisplayFrame && isCurrentFor(required, mask);
+        }
+    };
+}
diff --git a/gladius/src/ui/render/RenderWorkflowController.h b/gladius/src/ui/render/RenderWorkflowController.h
new file mode 100644
index 00000000..215a0292
--- /dev/null
+++ b/gladius/src/ui/render/RenderWorkflowController.h
@@ -0,0 +1,260 @@
+#pragma once
+
+#include "PresentedFrameLedger.h"
+#include "RenderUpdateCoordinator.h"
+
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace gladius::ui::async_rendering
+{
+    struct RenderWorkflowDecision
+    {
+        std::vector<RenderCommand> commands;
+        std::vector<FramePresentationCandidate> acceptedFrames;
+        std::vector<FramePresentationCandidate> rejectedFrames;
+        bool presentedFrameChanged{false};
+    };
+
+    /**
+     * @brief Pure render workflow facade used to test user-visible frame decisions.
+     *
+     * The workflow controller wraps the semantic RenderUpdateCoordinator and adds the
+     * missing presentation ledger: completed display tasks become frame candidates, and
+     * candidates are accepted only if they are fresh for the latest display stamp and do
+     * not downgrade an already-current higher-quality frame.
+     */
+    class RenderWorkflowController
+    {
+      public:
+        void configureRealtime(RealtimeRaymarchConfig config)
+        {
+            m_coordinator.configureRealtime(config);
+        }
+
+        [[nodiscard]] RealtimeRaymarchConfig const & realtimeConfig() const noexcept
+        {
+            return m_coordinator.realtimeConfig();
+        }
+
+        void setRealtimeGuards(RealtimeRaymarchGuards guards) noexcept
+        {
+            m_coordinator.setRealtimeGuards(guards);
+        }
+
+        void recordStaticProgressiveSample(RealtimeRaymarchSample const & sample)
+        {
+            m_coordinator.recordStaticProgressiveSample(sample);
+        }
+
+        void recordStaticFullFrameSample(RealtimeRaymarchSample const & sample)
+        {
+            m_coordinator.recordStaticFullFrameSample(sample);
+        }
+
+        void recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample)
+        {
+            m_coordinator.recordInteractiveRealtimeSample(sample);
+        }
+
+        void recordRealtimeRejectedAttempt()
+        {
+            m_coordinator.recordRealtimeRejectedAttempt();
+        }
+
+        [[nodiscard]] bool isRealtimeSchedulingActive() const noexcept
+        {
+            return m_coordinator.isRealtimeSchedulingActive();
+        }
+
+        [[nodiscard]] bool isAutoPreviewFallbackActive() const noexcept
+        {
+            return m_coordinator.isAutoPreviewFallbackActive();
+        }
+
+        [[nodiscard]] RenderStamp latestStamp() const noexcept
+        {
+            return m_coordinator.latestStamp();
+        }
+
+        [[nodiscard]] RenderInteractionState interactionState() const noexcept
+        {
+            return m_coordinator.interactionState();
+        }
+
+        [[nodiscard]] std::optional<PresentedFrame> const & presentedFrame() const noexcept
+        {
+            return m_presentedFrames.presentedFrame();
+        }
+
+        void seedPresentedFrame(PresentedFrame frame)
+        {
+            m_presentedFrames.seedPresentedFrame(frame);
+        }
+
+        void clearPresentedFrame() noexcept
+        {
+            m_presentedFrames.clearPresentedFrame();
+        }
+
+        [[nodiscard]] RenderWorkflowDecision configureViewport(uint32_t width, uint32_t height)
+        {
+            return applyCoordinatorDecision(m_coordinator.configureViewport(width, height));
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyCameraChanged()
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyCameraChanged());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyCameraInteractionEnded()
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyCameraInteractionEnded());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyParameterChanged(bool interactionActive)
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyParameterChanged(interactionActive));
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyParameterInteractionEnded()
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyParameterInteractionEnded());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyStructuralModelChanged()
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyStructuralModelChanged());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision notifyProgramCompilationCompleted()
+        {
+            return applyCoordinatorDecision(m_coordinator.notifyProgramCompilationCompleted());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision tick()
+        {
+            return applyCoordinatorDecision(m_coordinator.tick());
+        }
+
+        [[nodiscard]] RenderWorkflowDecision completeTask(RenderTaskResult const & result)
+        {
+            return applyCoordinatorDecision(m_coordinator.completeTask(result));
+        }
+
+        [[nodiscard]] bool canPresentCandidate(
+          FramePresentationCandidate const & candidate) const noexcept
+        {
+            return m_presentedFrames.canPresentCandidate(candidate, latestStamp());
+        }
+
+        [[nodiscard]] bool presentCandidate(FramePresentationCandidate const & candidate) noexcept
+        {
+            return m_presentedFrames.presentCandidate(candidate, latestStamp());
+        }
+
+      private:
+        [[nodiscard]] static constexpr bool isDisplayTask(RenderTaskType type) noexcept
+        {
+            return type == RenderTaskType::RealtimeFullFrame ||
+                   type == RenderTaskType::StaticFullFrameProbe ||
+                   type == RenderTaskType::ProgressiveHighQualityChunk ||
+                   type == RenderTaskType::LowResolutionPreview ||
+                   type == RenderTaskType::StreamingPreview;
+        }
+
+        [[nodiscard]] static constexpr FramePresentationSource sourceForTask(
+          RenderTaskType type) noexcept
+        {
+            switch (type)
+            {
+            case RenderTaskType::RealtimeFullFrame:
+                return FramePresentationSource::ExactRealtime;
+            case RenderTaskType::StaticFullFrameProbe:
+                return FramePresentationSource::ProgressiveHighQuality;
+            case RenderTaskType::LowResolutionPreview:
+                return FramePresentationSource::LowResolutionPreview;
+            case RenderTaskType::StreamingPreview:
+                return FramePresentationSource::StreamingPreview;
+            case RenderTaskType::ProgressiveHighQualityChunk:
+                return FramePresentationSource::ProgressiveHighQuality;
+            case RenderTaskType::BoundingBoxUpdate:
+            case RenderTaskType::SdfPrecomputation:
+            case RenderTaskType::ParameterUpload:
+            case RenderTaskType::ProgramCompilation:
+            default:
+                return FramePresentationSource::Unknown;
+            }
+        }
+
+        [[nodiscard]] static constexpr FramePresentationQuality qualityForResult(
+          RenderTaskResult const & result) noexcept
+        {
+            switch (result.type)
+            {
+            case RenderTaskType::RealtimeFullFrame:
+            case RenderTaskType::StaticFullFrameProbe:
+                return FramePresentationQuality::FullQuality;
+            case RenderTaskType::ProgressiveHighQualityChunk:
+                return result.completedFrame ? FramePresentationQuality::FullQuality
+                                             : FramePresentationQuality::ProgressivePartial;
+            case RenderTaskType::LowResolutionPreview:
+            case RenderTaskType::StreamingPreview:
+                return FramePresentationQuality::Preview;
+            case RenderTaskType::BoundingBoxUpdate:
+            case RenderTaskType::SdfPrecomputation:
+            case RenderTaskType::ParameterUpload:
+            case RenderTaskType::ProgramCompilation:
+            default:
+                return FramePresentationQuality::Unknown;
+            }
+        }
+
+        [[nodiscard]] FramePresentationCandidate makeCandidate(
+          RenderTaskResult const & result) noexcept
+        {
+            auto const frameId = result.requestId == 0 ? m_nextSyntheticFrameId++
+                                                       : result.requestId;
+            return FramePresentationCandidate{.frameId = frameId,
+                                              .stamp = result.stamp,
+                                              .quality = qualityForResult(result),
+                                              .source = sourceForTask(result.type),
+                                              .completedFrame = result.completedFrame};
+        }
+
+        [[nodiscard]] RenderWorkflowDecision applyCoordinatorDecision(
+          RenderUpdateDecision coordinatorDecision)
+        {
+            RenderWorkflowDecision workflowDecision{};
+            workflowDecision.commands = std::move(coordinatorDecision.commands);
+
+            for (auto const & command : workflowDecision.commands)
+            {
+                if (command.type != RenderCommandType::PresentFrame ||
+                    !isDisplayTask(command.result.type) ||
+                    !command.result.producedDisplayFrame)
+                {
+                    continue;
+                }
+
+                auto candidate = makeCandidate(command.result);
+                if (presentCandidate(candidate))
+                {
+                    workflowDecision.acceptedFrames.push_back(candidate);
+                    workflowDecision.presentedFrameChanged = true;
+                }
+                else
+                {
+                    workflowDecision.rejectedFrames.push_back(candidate);
+                }
+            }
+
+            return workflowDecision;
+        }
+
+        RenderUpdateCoordinator m_coordinator;
+        PresentedFrameLedger m_presentedFrames;
+        uint64_t m_nextSyntheticFrameId{1};
+    };
+}
diff --git a/gladius/tests/apitests/CMakeLists.txt b/gladius/tests/apitests/CMakeLists.txt
index 08d64206..ba292573 100644
--- a/gladius/tests/apitests/CMakeLists.txt
+++ b/gladius/tests/apitests/CMakeLists.txt
@@ -75,6 +75,9 @@ file(COPY "../../components/licenses" DESTINATION ".")
 file(MAKE_DIRECTORY "examples")
 file(COPY "../../examples/template.3mf" DESTINATION "examples/")
 
+# Copy library files used by integration tests
+file(COPY "../../library/mechanical/involute_gear.3mf" DESTINATION "testdata")
+
 # Use gtest_discover_tests for automatic test discovery with 'api' label
 gtest_discover_tests(${BINARY}
     PROPERTIES LABELS "api"
diff --git a/gladius/tests/apitests/LibraryExampleExtractor_tests.cpp b/gladius/tests/apitests/LibraryExampleExtractor_tests.cpp
new file mode 100644
index 00000000..6e26370b
--- /dev/null
+++ b/gladius/tests/apitests/LibraryExampleExtractor_tests.cpp
@@ -0,0 +1,372 @@
+#include "io/3mf/LibraryExampleExtractor.h"
+#include "io/3mf/LibraryMetadata.h"
+
+#include <lib3mf_implicit.hpp>
+
+#include <algorithm>
+#include <filesystem>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace gladius::io::tests
+{
+    namespace
+    {
+        /// @brief Creates a minimal library .3mf with a tagged function and an example caller.
+        ///
+        /// The tagged function has two scalar inputs (radius, height).
+        /// The example function wires ConstantScalar nodes (5.0, 10.0) to those inputs via a
+        /// FunctionCallNode.
+        std::filesystem::path createScalarConstantTestLibrary(
+          std::filesystem::path const & dir,
+          std::string const & taggedFuncName = "testFunc",
+          bool includeMetadata = true,
+          bool includeFunctionCall = true)
+        {
+            auto wrapper = Lib3MF::CWrapper::loadLibrary();
+            auto model = wrapper->CreateModel();
+
+            auto taggedFunc = model->AddImplicitFunction();
+            taggedFunc->SetDisplayName(taggedFuncName);
+            taggedFunc->AddInput("radius", "radius", Lib3MF::eImplicitPortType::Scalar);
+            taggedFunc->AddInput("height", "height", Lib3MF::eImplicitPortType::Scalar);
+            taggedFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+            auto const taggedId = taggedFunc->GetModelResourceID();
+
+            auto exampleFunc = model->AddImplicitFunction();
+            exampleFunc->SetDisplayName("main");
+            exampleFunc->AddInput("pos", "pos", Lib3MF::eImplicitPortType::Vector);
+            exampleFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+            if (includeFunctionCall)
+            {
+                auto constRadius = exampleFunc->AddConstantNode("CR", "CR", "");
+                constRadius->SetConstant(5.0);
+
+                auto constHeight = exampleFunc->AddConstantNode("CH", "CH", "");
+                constHeight->SetConstant(10.0);
+
+                auto resNode = exampleFunc->AddResourceIdNode("Res", "Res", "");
+                resNode->SetResource(std::static_pointer_cast<Lib3MF::CResource>(taggedFunc));
+
+                auto fcNode = exampleFunc->AddFunctionCallNode("FC", "FC", "");
+                fcNode->AddInput("radius", "radius");
+                fcNode->AddInput("height", "height");
+
+                exampleFunc->AddLink(resNode->GetOutputValue(), fcNode->GetInputFunctionID());
+                exampleFunc->AddLinkByNames("CR.value", "FC.radius");
+                exampleFunc->AddLinkByNames("CH.value", "FC.height");
+            }
+
+            if (includeMetadata)
+            {
+                writeLibraryMetadata(
+                  model, LibraryMetadata{std::to_string(taggedId), "Test function", ""});
+            }
+
+            auto const path = dir / "scalar_lib.3mf";
+            model->QueryWriter("3mf")->WriteToFile(path.string());
+            return path;
+        }
+
+        /// @brief Creates a library .3mf where the example function passes a ConstantVector
+        ///        to the tagged function's single vector input.
+        std::filesystem::path createVectorConstantTestLibrary(std::filesystem::path const & dir)
+        {
+            auto wrapper = Lib3MF::CWrapper::loadLibrary();
+            auto model = wrapper->CreateModel();
+
+            auto taggedFunc = model->AddImplicitFunction();
+            taggedFunc->SetDisplayName("vecFunc");
+            taggedFunc->AddInput("offset", "offset", Lib3MF::eImplicitPortType::Vector);
+            taggedFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+            auto const taggedId = taggedFunc->GetModelResourceID();
+
+            auto exampleFunc = model->AddImplicitFunction();
+            exampleFunc->SetDisplayName("main");
+            exampleFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+            auto constVec = exampleFunc->AddConstVecNode("CV", "CV", "");
+            Lib3MF::sVector vec{};
+            vec.m_Coordinates[0] = 1.0;
+            vec.m_Coordinates[1] = 2.0;
+            vec.m_Coordinates[2] = 3.0;
+            constVec->SetVector(vec);
+
+            auto resNode = exampleFunc->AddResourceIdNode("Res", "Res", "");
+            resNode->SetResource(std::static_pointer_cast<Lib3MF::CResource>(taggedFunc));
+
+            auto fcNode = exampleFunc->AddFunctionCallNode("FC", "FC", "");
+            auto offsetPort = fcNode->AddInput("offset", "offset");
+            offsetPort->SetType(Lib3MF::eImplicitPortType::Vector);
+
+            exampleFunc->AddLink(resNode->GetOutputValue(), fcNode->GetInputFunctionID());
+            exampleFunc->AddLinkByNames("CV.vector", "FC.offset");
+
+            writeLibraryMetadata(
+              model, LibraryMetadata{std::to_string(taggedId), "Vector test function", ""});
+
+            auto const path = dir / "vector_lib.3mf";
+            model->QueryWriter("3mf")->WriteToFile(path.string());
+            return path;
+        }
+    } // namespace
+
+    class LibraryExampleExtractorTest : public ::testing::Test
+    {
+    protected:
+        void SetUp() override
+        {
+            m_tempDir = std::filesystem::temp_directory_path() / "gladius_extractor_test";
+            std::filesystem::create_directories(m_tempDir);
+        }
+
+        void TearDown() override
+        {
+            std::filesystem::remove_all(m_tempDir);
+        }
+
+        std::filesystem::path m_tempDir;
+    };
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithScalarConstants_ReturnsExpectedValues)
+    {
+        // Arrange
+        auto const path = createScalarConstantTestLibrary(m_tempDir);
+
+        // Act
+        auto const constants = extractExampleConstants(path, "testFunc");
+
+        // Assert
+        ASSERT_EQ(constants.size(), 2u);
+
+        auto const findByName =
+          [&](std::string const & name) -> ExampleConstantValue const *
+        {
+            auto it = std::find_if(
+              constants.begin(), constants.end(),
+              [&](auto const & c)
+              {
+                  return c.parameterName == name;
+              });
+            return it != constants.end() ? &(*it) : nullptr;
+        };
+
+        auto const * radius = findByName("radius");
+        ASSERT_NE(radius, nullptr);
+        EXPECT_EQ(radius->kind, ExampleConstantValue::Kind::Scalar);
+        EXPECT_FLOAT_EQ(radius->scalarValue, 5.0f);
+
+        auto const * height = findByName("height");
+        ASSERT_NE(height, nullptr);
+        EXPECT_EQ(height->kind, ExampleConstantValue::Kind::Scalar);
+        EXPECT_FLOAT_EQ(height->scalarValue, 10.0f);
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithNonExistentFile_ReturnsEmpty)
+    {
+        // Act
+        auto const constants = extractExampleConstants("/nonexistent/path/file.3mf", "testFunc");
+
+        // Assert
+        EXPECT_TRUE(constants.empty());
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithWrongFunctionName_ReturnsEmpty)
+    {
+        // Arrange
+        auto const path = createScalarConstantTestLibrary(m_tempDir);
+
+        // Act
+        auto const constants = extractExampleConstants(path, "doesNotExist");
+
+        // Assert
+        EXPECT_TRUE(constants.empty());
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithNoLibraryMetadata_ReturnsEmpty)
+    {
+        // Arrange
+        auto const path = createScalarConstantTestLibrary(m_tempDir, "testFunc", false);
+
+        // Act
+        auto const constants = extractExampleConstants(path, "testFunc");
+
+        // Assert
+        EXPECT_TRUE(constants.empty());
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithNoFunctionCallInExample_ReturnsEmpty)
+    {
+        // Arrange
+        auto const path =
+          createScalarConstantTestLibrary(m_tempDir, "testFunc", true, false);
+
+        // Act
+        auto const constants = extractExampleConstants(path, "testFunc");
+
+        // Assert
+        EXPECT_TRUE(constants.empty());
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithVectorConstant_ReturnsVectorValue)
+    {
+        // Arrange
+        auto const path = createVectorConstantTestLibrary(m_tempDir);
+
+        // Act
+        auto const constants = extractExampleConstants(path, "vecFunc");
+
+        // Assert
+        ASSERT_EQ(constants.size(), 1u);
+        EXPECT_EQ(constants[0].kind, ExampleConstantValue::Kind::Vector);
+        EXPECT_EQ(constants[0].parameterName, "offset");
+        EXPECT_FLOAT_EQ(constants[0].vectorValue.x, 1.0f);
+        EXPECT_FLOAT_EQ(constants[0].vectorValue.y, 2.0f);
+        EXPECT_FLOAT_EQ(constants[0].vectorValue.z, 3.0f);
+    }
+
+    TEST_F(LibraryExampleExtractorTest,
+           extractExampleConstants_WithMatrixConstant_ReturnsMatrixValue)
+    {
+        // Arrange
+        auto wrapper = Lib3MF::CWrapper::loadLibrary();
+        auto model = wrapper->CreateModel();
+
+        auto taggedFunc = model->AddImplicitFunction();
+        taggedFunc->SetDisplayName("matFunc");
+        taggedFunc->AddInput("transform", "transform", Lib3MF::eImplicitPortType::Matrix);
+        taggedFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+        auto const taggedId = taggedFunc->GetModelResourceID();
+
+        auto exampleFunc = model->AddImplicitFunction();
+        exampleFunc->SetDisplayName("main");
+        exampleFunc->AddOutput("shape", "shape", Lib3MF::eImplicitPortType::Scalar);
+
+        auto constMat = exampleFunc->AddConstMatNode("CM", "CM", "");
+        Lib3MF::sMatrix4x4 mat{};
+        // Identity matrix with a recognizable off-diagonal value
+        mat.m_Field[0][0] = 1.0;
+        mat.m_Field[1][1] = 2.0;
+        mat.m_Field[2][2] = 3.0;
+        mat.m_Field[3][3] = 4.0;
+        mat.m_Field[0][1] = 5.0;
+        constMat->SetMatrix(mat);
+
+        auto resNode = exampleFunc->AddResourceIdNode("Res", "Res", "");
+        resNode->SetResource(std::static_pointer_cast<Lib3MF::CResource>(taggedFunc));
+
+        auto fcNode = exampleFunc->AddFunctionCallNode("FC", "FC", "");
+        auto transformPort = fcNode->AddInput("transform", "transform");
+        transformPort->SetType(Lib3MF::eImplicitPortType::Matrix);
+
+        exampleFunc->AddLink(resNode->GetOutputValue(), fcNode->GetInputFunctionID());
+        exampleFunc->AddLinkByNames("CM.matrix", "FC.transform");
+
+        writeLibraryMetadata(
+          model, LibraryMetadata{std::to_string(taggedId), "Matrix test function", ""});
+
+        auto const path = m_tempDir / "matrix_lib.3mf";
+        model->QueryWriter("3mf")->WriteToFile(path.string());
+
+        // Act
+        auto const constants = extractExampleConstants(path, "matFunc");
+
+        // Assert
+        ASSERT_EQ(constants.size(), 1u);
+        EXPECT_EQ(constants[0].kind, ExampleConstantValue::Kind::Matrix);
+        EXPECT_EQ(constants[0].parameterName, "transform");
+        EXPECT_FLOAT_EQ(constants[0].matrixValue[0][0], 1.0f);
+        EXPECT_FLOAT_EQ(constants[0].matrixValue[1][1], 2.0f);
+        EXPECT_FLOAT_EQ(constants[0].matrixValue[2][2], 3.0f);
+        EXPECT_FLOAT_EQ(constants[0].matrixValue[3][3], 4.0f);
+        EXPECT_FLOAT_EQ(constants[0].matrixValue[0][1], 5.0f);
+    }
+
+} // namespace gladius::io::tests
+
+namespace gladius::io::integration_tests
+{
+    /// @brief Integration tests that load real 3MF library files shipped with Gladius.
+    ///
+    /// These tests verify end-to-end extraction from actual library files as
+    /// they would be encountered during a library drag-drop in the node editor.
+    class LibraryExampleExtractorIntegrationTest : public ::testing::Test
+    {
+    };
+
+    /// Verifies that @c extractExampleConstants works with the real involute_gear.3mf
+    /// library file. The test dynamically discovers the tagged function display name
+    /// from metadata so it stays correct even if the file is regenerated.
+    TEST_F(LibraryExampleExtractorIntegrationTest,
+           extractExampleConstants_WithRealInvoluteGear_ReturnsNonEmptyScalars)
+    {
+        // Arrange
+        std::filesystem::path const filePath{"testdata/involute_gear.3mf"};
+        ASSERT_TRUE(std::filesystem::exists(filePath))
+          << "involute_gear.3mf not found in testdata/. "
+             "Check that the CMakeLists.txt copy step is present.";
+
+        // Discover the tagged function display name from the file's library metadata.
+        auto wrapper = Lib3MF::CWrapper::loadLibrary();
+        auto model = wrapper->CreateModel();
+        model->QueryReader("3mf")->ReadFromFile(filePath.string());
+
+        auto const libMeta = readLibraryMetadata(model);
+        ASSERT_TRUE(libMeta.has_value()) << "involute_gear.3mf has no library metadata";
+
+        auto const taggedIds = parseResourceIds(libMeta->libraryFunctions);
+        ASSERT_FALSE(taggedIds.empty()) << "No tagged function IDs in metadata";
+
+        // Find the display name of the first tagged function.
+        std::string displayName;
+        auto resIter = model->GetResources();
+        while (resIter->MoveNext())
+        {
+            auto res = resIter->GetCurrent();
+            auto const modelId = res->GetModelResourceID();
+            if (std::find(taggedIds.begin(), taggedIds.end(), modelId) == taggedIds.end())
+            {
+                continue;
+            }
+            auto implicitFunc = std::dynamic_pointer_cast<Lib3MF::CImplicitFunction>(res);
+            if (implicitFunc)
+            {
+                displayName = implicitFunc->GetDisplayName();
+                break;
+            }
+        }
+        ASSERT_FALSE(displayName.empty()) << "Could not find tagged implicit function in file";
+
+        // Act
+        auto const constants = extractExampleConstants(filePath, displayName);
+
+        // Assert — the gear example must supply at least one constant to be useful.
+        ASSERT_FALSE(constants.empty())
+          << "Expected example constants for function '" << displayName << "'";
+
+        // All gear parameters are positive scalars (module, teeth count, height, angles).
+        for (auto const & c : constants)
+        {
+            EXPECT_FALSE(c.parameterName.empty())
+              << "Every extracted constant must have a parameter name";
+            if (c.kind == ExampleConstantValue::Kind::Scalar)
+            {
+                EXPECT_GT(c.scalarValue, 0.0f)
+                  << "Scalar parameter '" << c.parameterName
+                  << "' should be positive for a gear";
+            }
+        }
+    }
+
+} // namespace gladius::io::integration_tests
diff --git a/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp b/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
index 9ae45ba6..efc10900 100644
--- a/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
+++ b/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
@@ -217,6 +217,32 @@ namespace gladius::tests
             return std::make_unique<SpatialMeshResource>(key, vertices, indices);
         }
 
+        /// Create a closed, consistently wound cube mesh for sharp-feature SDF tests.
+        static void createCubeMesh(std::vector<float4>& vertices,
+                                   std::vector<TriangleIndices>& indices,
+                                   float halfExtent)
+        {
+            vertices = {
+                makeFloat4(-halfExtent, -halfExtent, -halfExtent),
+                makeFloat4( halfExtent, -halfExtent, -halfExtent),
+                makeFloat4( halfExtent,  halfExtent, -halfExtent),
+                makeFloat4(-halfExtent,  halfExtent, -halfExtent),
+                makeFloat4(-halfExtent, -halfExtent,  halfExtent),
+                makeFloat4( halfExtent, -halfExtent,  halfExtent),
+                makeFloat4( halfExtent,  halfExtent,  halfExtent),
+                makeFloat4(-halfExtent,  halfExtent,  halfExtent),
+            };
+
+            indices = {
+                {4, 5, 6}, {4, 6, 7}, // +z
+                {1, 0, 3}, {1, 3, 2}, // -z
+                {5, 1, 2}, {5, 2, 6}, // +x
+                {0, 4, 7}, {0, 7, 3}, // -x
+                {7, 6, 2}, {7, 2, 3}, // +y
+                {0, 1, 5}, {0, 5, 4}, // -y
+            };
+        }
+
         /// Create an icosphere mesh for testing
         static void createIcosphere(std::vector<float4>& vertices,
                                     std::vector<TriangleIndices>& indices,
@@ -322,9 +348,12 @@ namespace gladius::tests
         auto primitives = core->getPrimitives();
         ASSERT_NE(primitives, nullptr);
 
+        bool const vdbSupported = core->getProgramManager().isVdbSupported();
+
         gladius::compute::ManifoldDualContouringProgram sampler(
             m_context, core->getResourceContext());
         sampler.setLogger(m_logger);
+        sampler.setEnableVdb(vdbSupported);
         sampler.setModelKernel(R"CLC(
     float4 model(float3 pos, PAYLOAD_ARGS)
     {
@@ -337,20 +366,31 @@ namespace gladius::tests
         {
             char const * label;
             MeshSdfMethod method;
+            bool requiresVdb;
         };
-        std::array<MethodCase, 3> const cases = {{
-            {"PureBVH", MeshSdfMethod::PureBVH},
-            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated},
-            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber},
+        std::array<MethodCase, 4> const cases = {{
+            {"PureBVH", MeshSdfMethod::PureBVH, false},
+            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated, false},
+            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber, false},
+            {"NanoVDB", MeshSdfMethod::NanoVDB, true},
         }};
 
         for (auto const & c : cases)
         {
+            if (c.requiresVdb && !vdbSupported)
+            {
+                std::cout << "Skipping " << c.label
+                          << " mesh SDF comparison because NanoVDB is unavailable: "
+                          << core->getProgramManager().getVdbSupportFailureReason() << std::endl;
+                continue;
+            }
+
             MeshSdfEvaluationConfig cfg{};
             cfg.method = c.method;
             cfg.useEarlyExit = false;
             cfg.fwnUseSignCache = false;
             cfg.fwnBeta = 4.0f;
+            cfg.nanovdbVoxelSize_mm = 0.1f;
 
             MeshBVHBuildParams params;
             params.maxPrimitivesPerLeaf = 4;
@@ -378,6 +418,14 @@ namespace gladius::tests
 
             primitives->clear();
             resource.write(*primitives);
+            if (c.method == MeshSdfMethod::NanoVDB)
+            {
+                ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << c.label << ": "
+                                                              << resource.getNanoVdbBuildInfo().reason;
+                ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
+                          SpatialMeshResource::NanoVdbBuildResult::Built)
+                    << c.label;
+            }
             primitives->write();
 
             if (c.method == MeshSdfMethod::VoxelAccelerated)
@@ -398,15 +446,252 @@ namespace gladius::tests
             primitives->write();
 
             auto const distances = sampler.evaluateSdfBatch(
-                {Eigen::Vector3f{0.0f, 0.0f, 0.0f}, Eigen::Vector3f{15.0f, 0.0f, 0.0f}},
+                {Eigen::Vector3f{0.0f, 0.0f, 0.0f},
+                 Eigen::Vector3f{15.0f, 0.0f, 0.0f},
+                 Eigen::Vector3f{9.75f, 0.0f, 0.0f},
+                 Eigen::Vector3f{10.25f, 0.0f, 0.0f}},
                 *primitives,
                 0.0f);
-            ASSERT_EQ(distances.size(), 2u) << c.label;
+            ASSERT_EQ(distances.size(), 4u) << c.label;
             EXPECT_LT(distances[0], -5.0f) << c.label << " center distance=" << distances[0];
             EXPECT_GT(distances[1], 2.0f) << c.label << " outside distance=" << distances[1];
+            EXPECT_LT(distances[2], -0.05f) << c.label << " near-inside distance=" << distances[2];
+            EXPECT_GT(distances[3], 0.05f) << c.label << " near-outside distance=" << distances[3];
+            EXPECT_GT(std::fabs(distances[3]), 0.10f)
+                << c.label << " near-outside magnitude should remain in millimetres, distance="
+                << distances[3];
         }
     }
 
+    TEST_F(MeshSdfPerformance_Test, GpuSdfEvaluation_AllMeshMethods_CubeSharpFeaturesKeepCorrectSign)
+    {
+        if (!m_context->isValid())
+        {
+            GTEST_SKIP() << "OpenCL context not available";
+        }
+
+        std::vector<float4> vertices;
+        std::vector<TriangleIndices> indices;
+        createCubeMesh(vertices, indices, 5.0f);
+
+        auto core = std::make_shared<ComputeCore>(
+            m_context, RequiredCapabilities::ComputeOnly, m_logger);
+        auto primitives = core->getPrimitives();
+        ASSERT_NE(primitives, nullptr);
+
+        bool const vdbSupported = core->getProgramManager().isVdbSupported();
+
+        gladius::compute::ManifoldDualContouringProgram sampler(
+            m_context, core->getResourceContext());
+        sampler.setLogger(m_logger);
+        sampler.setEnableVdb(vdbSupported);
+        sampler.setModelKernel(R"CLC(
+    float4 model(float3 pos, PAYLOAD_ARGS)
+    {
+        float const distance = payload(pos, 0, primitivesSize, PASS_PAYLOAD_ARGS);
+        return (float4)(0.0f, 0.0f, 0.0f, distance);
+    }
+    )CLC");
+
+        struct MethodCase
+        {
+            char const * label;
+            MeshSdfMethod method;
+            bool requiresVdb;
+        };
+        std::array<MethodCase, 4> const cases = {{
+            {"PureBVH", MeshSdfMethod::PureBVH, false},
+            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated, false},
+            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber, false},
+            {"NanoVDB", MeshSdfMethod::NanoVDB, true},
+        }};
+
+        std::vector<Eigen::Vector3f> const samplePositions = {
+            {0.0f, 0.0f, 0.0f},       // deep interior
+            {8.0f, 0.0f, 0.0f},       // far exterior
+            {4.75f, 0.0f, 0.0f},      // inside near face
+            {5.25f, 0.0f, 0.0f},      // outside near face
+            {4.75f, 4.75f, 0.0f},     // inside near sharp edge
+            {5.25f, 5.25f, 0.0f},     // outside near sharp edge
+            {4.75f, 4.75f, 4.75f},    // inside near sharp corner
+            {5.25f, 5.25f, 5.25f},    // outside near sharp corner
+        };
+
+        for (auto const & c : cases)
+        {
+            if (c.requiresVdb && !vdbSupported)
+            {
+                std::cout << "Skipping " << c.label
+                          << " cube sharp-feature comparison because NanoVDB is unavailable: "
+                          << core->getProgramManager().getVdbSupportFailureReason() << std::endl;
+                continue;
+            }
+
+            MeshSdfEvaluationConfig cfg{};
+            cfg.method = c.method;
+            cfg.useEarlyExit = false;
+            cfg.fwnUseSignCache = false;
+            cfg.fwnBeta = 4.0f;
+            cfg.nanovdbVoxelSize_mm = 0.1f;
+
+            MeshBVHBuildParams params;
+            params.maxPrimitivesPerLeaf = 4;
+            params.maxDepth = 32;
+            params.traversalCost = 1.0f;
+            params.intersectionCost = 1.0f;
+            MeshBVHBuilder builder;
+
+            ResourceKey key(ResourceId{1001}, ResourceType::Mesh);
+            SpatialMeshResource resource(key, builder.build(vertices, indices, params), cfg);
+
+            auto & settings = core->getResourceContext()->getRenderingSettings();
+            settings.meshInflationDistance = 0.0f;
+            settings.meshFwnBeta = cfg.fwnBeta;
+            settings.meshFwnFarFieldFactor = 0.0f;
+            settings.flags |= RF_DISABLE_MESH_EARLY_EXIT;
+            if (c.method == MeshSdfMethod::FastWindingNumber)
+            {
+                settings.flags |= RF_USE_MESH_FWN;
+            }
+            else
+            {
+                settings.flags &= ~RF_USE_MESH_FWN;
+            }
+
+            primitives->clear();
+            resource.write(*primitives);
+            if (c.method == MeshSdfMethod::NanoVDB)
+            {
+                ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << c.label << ": "
+                                                              << resource.getNanoVdbBuildInfo().reason;
+                ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
+                          SpatialMeshResource::NanoVdbBuildResult::Built)
+                    << c.label;
+            }
+            primitives->write();
+
+            if (c.method == MeshSdfMethod::VoxelAccelerated)
+            {
+                auto params = resource.getVoxelGridBuildParams();
+                ASSERT_TRUE(params.has_value()) << c.label;
+                ASSERT_EQ(core->buildMeshVoxelGrids({*params}), 1u) << c.label;
+            }
+            else if (c.method == MeshSdfMethod::FastWindingNumber)
+            {
+                auto params = resource.getFwnAggregateBuildParams();
+                ASSERT_TRUE(params.has_value()) << c.label;
+                ASSERT_EQ(core->buildMeshFwnAggregates({*params}), 1u) << c.label;
+            }
+
+            primitives->write();
+            auto const distances = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
+            ASSERT_EQ(distances.size(), samplePositions.size()) << c.label;
+
+            EXPECT_LT(distances[0], -4.0f) << c.label << " center distance=" << distances[0];
+            EXPECT_GT(distances[1], 2.0f) << c.label << " exterior distance=" << distances[1];
+            EXPECT_LT(distances[2], -0.05f) << c.label << " face-inside distance=" << distances[2];
+            EXPECT_GT(distances[3], 0.05f) << c.label << " face-outside distance=" << distances[3];
+            EXPECT_LT(distances[4], -0.05f) << c.label << " edge-inside distance=" << distances[4];
+            EXPECT_GT(distances[5], 0.05f) << c.label << " edge-outside distance=" << distances[5];
+            EXPECT_LT(distances[6], -0.05f) << c.label << " corner-inside distance=" << distances[6];
+            EXPECT_GT(distances[7], 0.05f) << c.label << " corner-outside distance=" << distances[7];
+        }
+    }
+
+    TEST_F(MeshSdfPerformance_Test, GpuSdfEvaluation_NanoVdbNearestSampling_ReturnsMillimetres)
+    {
+        if (!m_context->isValid())
+        {
+            GTEST_SKIP() << "OpenCL context not available";
+        }
+
+        std::vector<float4> vertices;
+        std::vector<TriangleIndices> indices;
+        createCubeMesh(vertices, indices, 5.0f);
+
+        auto core = std::make_shared<ComputeCore>(
+            m_context, RequiredCapabilities::ComputeOnly, m_logger);
+        auto primitives = core->getPrimitives();
+        ASSERT_NE(primitives, nullptr);
+
+        if (!core->getProgramManager().isVdbSupported())
+        {
+            GTEST_SKIP() << "NanoVDB is unavailable: "
+                         << core->getProgramManager().getVdbSupportFailureReason();
+        }
+
+        gladius::compute::ManifoldDualContouringProgram sampler(
+            m_context, core->getResourceContext());
+        sampler.setLogger(m_logger);
+        sampler.setEnableVdb(true);
+        sampler.setModelKernel(R"CLC(
+    float4 model(float3 pos, PAYLOAD_ARGS)
+    {
+        float const distance = payload(pos, 0, primitivesSize, PASS_PAYLOAD_ARGS);
+        return (float4)(0.0f, 0.0f, 0.0f, distance);
+    }
+    )CLC");
+
+        MeshSdfEvaluationConfig cfg{};
+        cfg.method = MeshSdfMethod::NanoVDB;
+        cfg.useEarlyExit = false;
+        cfg.nanovdbVoxelSize_mm = 0.1f;
+
+        MeshBVHBuildParams params;
+        params.maxPrimitivesPerLeaf = 4;
+        params.maxDepth = 32;
+        params.traversalCost = 1.0f;
+        params.intersectionCost = 1.0f;
+        MeshBVHBuilder builder;
+
+        ResourceKey key(ResourceId{1002}, ResourceType::Mesh);
+        SpatialMeshResource resource(key, builder.build(vertices, indices, params), cfg);
+
+        auto & settings = core->getResourceContext()->getRenderingSettings();
+        settings.meshInflationDistance = 0.0f;
+        settings.flags |= RF_DISABLE_MESH_EARLY_EXIT;
+        settings.flags &= ~RF_USE_MESH_FWN;
+
+        primitives->clear();
+        resource.write(*primitives);
+        ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << resource.getNanoVdbBuildInfo().reason;
+        ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
+                  SpatialMeshResource::NanoVdbBuildResult::Built);
+        primitives->write();
+
+        std::vector<Eigen::Vector3f> const samplePositions = {
+            {0.0f, 0.0f, 0.0f},
+            {8.0f, 0.0f, 0.0f},
+            {4.75f, 0.0f, 0.0f},
+            {5.25f, 0.0f, 0.0f},
+            {5.25f, 5.25f, 0.0f},
+        };
+
+        settings.approximation = AM_FULL_MODEL;
+        auto const interpolated = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
+
+        settings.approximation = static_cast<ApproximationMode>(AM_FULL_MODEL | AM_DISABLE_INTERPOLATION);
+        auto const nearest = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
+
+        ASSERT_EQ(interpolated.size(), samplePositions.size());
+        ASSERT_EQ(nearest.size(), samplePositions.size());
+
+        for (size_t i = 0u; i < samplePositions.size(); ++i)
+        {
+            EXPECT_EQ(interpolated[i] < 0.0f, nearest[i] < 0.0f)
+                << "sample " << i << " interpolated=" << interpolated[i]
+                << " nearest=" << nearest[i];
+            EXPECT_NEAR(interpolated[i], nearest[i], 0.25f)
+                << "sample " << i << " should not change units when nearest VDB sampling is used";
+        }
+
+        EXPECT_LT(nearest[0], -4.0f) << "center distance=" << nearest[0];
+        EXPECT_GT(nearest[1], 2.0f) << "exterior distance=" << nearest[1];
+        EXPECT_LT(nearest[2], -0.05f) << "face-inside distance=" << nearest[2];
+        EXPECT_GT(nearest[3], 0.05f) << "face-outside distance=" << nearest[3];
+        EXPECT_GT(nearest[4], 0.10f) << "edge-outside magnitude should remain in millimetres";
+    }
+
     /// T001-T003: Baseline performance benchmark with procedural sphere
     TEST_F(MeshSdfPerformance_Test, Baseline_ProceduralSphere_RecordsPerformance)
     {
@@ -494,7 +779,20 @@ namespace gladius::tests
     /// `GLADIUS_RUN_GPU_BENCH=1` to enable. Use a small mesh.
     TEST_F(MeshSdfPerformance_Test, GpuSdfRender_AllMethods_PrintsThroughput)
     {
-        if (std::getenv("GLADIUS_RUN_GPU_BENCH") == nullptr)
+        auto const getEnvSafe = [](char const * name) -> bool
+        {
+#ifdef _MSC_VER
+            char * val = nullptr;
+            size_t len = 0;
+            _dupenv_s(&val, &len, name);
+            std::unique_ptr<char, decltype(&free)> guard(val, &free);
+            return val != nullptr;
+#else
+            return std::getenv(name) != nullptr;
+#endif
+        };
+
+        if (!getEnvSafe("GLADIUS_RUN_GPU_BENCH"))
         {
             GTEST_SKIP() << "GPU benchmark default-skipped. Set "
                             "GLADIUS_RUN_GPU_BENCH=1 to enable. WARNING: "
@@ -563,9 +861,9 @@ namespace gladius::tests
         ui::OrbitalCamera camera;
         camera.setAngle(0.6f, -2.0f);
         camera.centerView(*bbox);
-        camera.update(10000.f);
+        camera.snapToTarget();
         camera.adjustDistanceToTarget(*bbox, static_cast<int>(kWidth), static_cast<int>(kHeight));
-        camera.update(10000.f);
+        camera.snapToTarget();
 
         auto resources = bundle.core->getResourceContext();
         resources->setEyePosition(camera.getEyePosition());
diff --git a/gladius/tests/integrationtests/PaletteExtractor_tests.cpp b/gladius/tests/integrationtests/PaletteExtractor_tests.cpp
index b9b1d032..6442577a 100644
--- a/gladius/tests/integrationtests/PaletteExtractor_tests.cpp
+++ b/gladius/tests/integrationtests/PaletteExtractor_tests.cpp
@@ -64,4 +64,29 @@ namespace gladius_tests::palette_extractor
             EXPECT_LE(c.z(), 1.0F);
         }
     }
+
+    TEST_F(PaletteExtractorTest, WebcamMountColor_DerivesPaletteWithLayeredMarchingCubes)
+    {
+        auto core = loadCoreWithDocument("testdata/webcam_mount_color.3mf");
+        ASSERT_NE(core, nullptr);
+
+        PaletteExtractionOptions opts{};
+        opts.method = SurfaceExtractionMethod::LayeredMarchingCubes;
+        opts.marchingCubesQualityLevel = 1U;
+        opts.convertToSrgb = true;
+
+        auto palette = derivePaletteFromMesh(*core, opts);
+
+        EXPECT_FALSE(palette.empty());
+        EXPECT_GT(palette.size(), 4U);
+        for (auto const & c : palette)
+        {
+            EXPECT_GE(c.x(), 0.0F);
+            EXPECT_LE(c.x(), 1.0F);
+            EXPECT_GE(c.y(), 0.0F);
+            EXPECT_LE(c.y(), 1.0F);
+            EXPECT_GE(c.z(), 0.0F);
+            EXPECT_LE(c.z(), 1.0F);
+        }
+    }
 }
diff --git a/gladius/tests/integrationtests/RayMarchPerf_tests.cpp b/gladius/tests/integrationtests/RayMarchPerf_tests.cpp
index cec3de07..dc6e9e89 100644
--- a/gladius/tests/integrationtests/RayMarchPerf_tests.cpp
+++ b/gladius/tests/integrationtests/RayMarchPerf_tests.cpp
@@ -273,14 +273,14 @@ namespace gladius::tests
         ui::OrbitalCamera camera;
         camera.setAngle(0.6f, -2.0f);  // Same as thumbnail
         camera.centerView(*bbox);
-        camera.update(10000.f);
+        camera.snapToTarget();
         
         // Use a fixed resolution for metrics test
         constexpr size_t width = 512;
         constexpr size_t height = 512;
         
         camera.adjustDistanceToTarget(*bbox, static_cast<int>(width), static_cast<int>(height));
-        camera.update(10000.f);
+        camera.snapToTarget();
 
         // Apply camera to resources
         auto resources = bundle.core->getResourceContext();
@@ -363,13 +363,13 @@ namespace gladius::tests
         ui::OrbitalCamera camera;
         camera.setAngle(0.6f, -2.0f);
         camera.centerView(*bbox);
-        camera.update(10000.f);
+        camera.snapToTarget();
         
         constexpr size_t width = 512;
         constexpr size_t height = 512;
         
         camera.adjustDistanceToTarget(*bbox, static_cast<int>(width), static_cast<int>(height));
-        camera.update(10000.f);
+        camera.snapToTarget();
 
         auto resources = bundle.core->getResourceContext();
         resources->setEyePosition(camera.getEyePosition());
@@ -477,13 +477,13 @@ namespace gladius::tests
         ui::OrbitalCamera camera;
         camera.setAngle(0.6f, -2.0f);
         camera.centerView(*bbox);
-        camera.update(10000.f);
+        camera.snapToTarget();
         
         constexpr size_t width = 512;
         constexpr size_t height = 512;
         
         camera.adjustDistanceToTarget(*bbox, static_cast<int>(width), static_cast<int>(height));
-        camera.update(10000.f);
+        camera.snapToTarget();
 
         auto resources = bundle.core->getResourceContext();
         resources->setEyePosition(camera.getEyePosition());
diff --git a/gladius/tests/unittests/CMakeLists.txt b/gladius/tests/unittests/CMakeLists.txt
index b2792359..b7de9a30 100644
--- a/gladius/tests/unittests/CMakeLists.txt
+++ b/gladius/tests/unittests/CMakeLists.txt
@@ -5,7 +5,7 @@ include(CTest) # Add this line
 enable_testing()
 
 set(BINARY ${CMAKE_PROJECT_NAME}_test)
-file(GLOB_RECURSE TEST_SOURCES LIST_DIRECTORIES false *.h *.cpp)
+file(GLOB_RECURSE TEST_SOURCES CONFIGURE_DEPENDS LIST_DIRECTORIES false *.h *.cpp)
 
 # Remove OpenCL-requiring tests if disabled
 if(NOT ENABLE_OPENCL_TESTS)
diff --git a/gladius/tests/unittests/ComputeCore_tests.cpp b/gladius/tests/unittests/ComputeCore_tests.cpp
index f53e384e..dd06d735 100644
--- a/gladius/tests/unittests/ComputeCore_tests.cpp
+++ b/gladius/tests/unittests/ComputeCore_tests.cpp
@@ -27,9 +27,7 @@ namespace gladius_tests
     class ComputeCore_Test : public ::testing::Test
     {
         void SetUp() override
-        {
-            m_logger = std::make_shared<events::Logger>();
-        }
+        { m_logger = std::make_shared<events::Logger>(); }
 
       protected:
         std::shared_ptr<ComputeCore> createCore()
@@ -42,7 +40,8 @@ namespace gladius_tests
                   "Failed to create OpenCL Context. Did you install proper GPU drivers?");
             }
 
-            return std::make_shared<ComputeCore>(context, RequiredCapabilities::ComputeOnly, m_logger);
+            return std::make_shared<ComputeCore>(
+              context, RequiredCapabilities::ComputeOnly, m_logger);
         }
 
         std::shared_ptr<ComputeCore> load3mf(std::filesystem::path const & path)
@@ -68,6 +67,7 @@ namespace gladius_tests
       private:
         std::shared_ptr<ComputeCore> m_core;
         std::shared_ptr<Document> m_doc;
+
       protected:
         events::SharedLogger m_logger;
     };
@@ -88,7 +88,8 @@ namespace gladius_tests
         EXPECT_EQ(core->getSelectedRenderBackend(), RenderBackend::Optimized);
     }
 
-    TEST_F(ComputeCore_Test, RefreshProgram_WithAutomaticCodeGenerator_SelectsPreviewUntilOptimizedIsReady)
+    TEST_F(ComputeCore_Test,
+           RefreshProgram_WithAutomaticCodeGenerator_SelectsPreviewUntilOptimizedIsReady)
     {
         SKIP_IF_OPENCL_UNAVAILABLE();
 
@@ -117,7 +118,8 @@ namespace gladius_tests
         EXPECT_EQ(core->getSelectedRenderBackend(), RenderBackend::Optimized);
     }
 
-    TEST_F(ComputeCore_Test, RecompileIfRequired_WithDeferredOptimizedRender_KeepsInteractiveBackend)
+    TEST_F(ComputeCore_Test,
+           RecompileIfRequired_WithDeferredOptimizedRender_KeepsInteractiveBackend)
     {
         SKIP_IF_OPENCL_UNAVAILABLE();
 
@@ -166,8 +168,8 @@ namespace gladius_tests
         EXPECT_EQ(core->getSelectedRenderBackend(), RenderBackend::Optimized);
     }
 
-      TEST_F(ComputeCore_Test, TryRenderProgramAccess_WithProgramManagerLockHeld_ReturnsCachedPreview)
-      {
+    TEST_F(ComputeCore_Test, TryRenderProgramAccess_WithProgramManagerLockHeld_ReturnsCachedPreview)
+    {
         SKIP_IF_OPENCL_UNAVAILABLE();
 
         auto core = createCore();
@@ -184,7 +186,7 @@ namespace gladius_tests
         core->recompileIfRequired();
         for (auto attempts = 0; attempts < 500 && core->isCompilationInProgress(); ++attempts)
         {
-          std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
         }
         ASSERT_FALSE(core->isCompilationInProgress());
         core->recompileIfRequired();
@@ -203,22 +205,22 @@ namespace gladius_tests
            &lockAcquired,
            releaseLockFuture = std::move(releaseLockFuture)]() mutable
           {
-            auto computeToken = programManager.waitForComputeToken();
-            lockAcquired.set_value();
-            releaseLockFuture.wait();
+              auto computeToken = programManager.waitForComputeToken();
+              lockAcquired.set_value();
+              releaseLockFuture.wait();
           });
 
-        auto const lockWasAcquired = lockAcquiredFuture.wait_for(std::chrono::seconds(2)) ==
-                       std::future_status::ready;
+        auto const lockWasAcquired =
+          lockAcquiredFuture.wait_for(std::chrono::seconds(2)) == std::future_status::ready;
 
         auto tryReady = std::optional<bool>{};
         auto tryBackend = std::optional<RenderBackend>{};
         auto tryProgram = std::optional<SharedRenderProgram>{};
         if (lockWasAcquired)
         {
-          tryReady = core->tryIsRenderProgramReady();
-          tryBackend = core->tryGetSelectedRenderBackend();
-          tryProgram = core->tryGetBestRenderProgram();
+            tryReady = core->tryIsRenderProgramReady();
+            tryBackend = core->tryGetSelectedRenderBackend();
+            tryProgram = core->tryGetBestRenderProgram();
         }
 
         releaseLock.set_value();
@@ -231,7 +233,7 @@ namespace gladius_tests
         EXPECT_EQ(*tryBackend, RenderBackend::CommandStream);
         ASSERT_TRUE(tryProgram.has_value());
         EXPECT_EQ(tryProgram->get(), previewProgram.get());
-      }
+    }
 
     TEST_F(ComputeCore_Test, IsRenderProgramReady_WithModelRefreshInProgress_UsesCompiledPreview)
     {
@@ -256,7 +258,8 @@ namespace gladius_tests
         core->getMeshResourceState()->signalCompilationFinished();
     }
 
-    TEST_F(ComputeCore_Test, RefreshProgram_WithCommandStreamCodeGenerator_CompilesAndRunsRenderKernel)
+    TEST_F(ComputeCore_Test,
+           RefreshProgram_WithCommandStreamCodeGenerator_CompilesAndRunsRenderKernel)
     {
         SKIP_IF_OPENCL_UNAVAILABLE();
 
@@ -282,11 +285,9 @@ namespace gladius_tests
                                    box->parameter()[nodes::FieldNames::Min].getId()));
         ASSERT_TRUE(model->addLink(maxCorner->getOutputs().at(nodes::FieldNames::Vector).getId(),
                                    box->parameter()[nodes::FieldNames::Max].getId()));
-        ASSERT_TRUE(model->addLink(box->getOutputs().at(nodes::FieldNames::Shape).getId(),
-                                   model->getEndNode()
-                                     ->parameter()
-                                     .at(nodes::FieldNames::Shape)
-                                     .getId()));
+        ASSERT_TRUE(
+          model->addLink(box->getOutputs().at(nodes::FieldNames::Shape).getId(),
+                         model->getEndNode()->parameter().at(nodes::FieldNames::Shape).getId()));
         model->updateGraphAndOrderIfNeeded();
 
         core->setCodeGenerator(CodeGenerator::CommandStream);
@@ -315,12 +316,8 @@ namespace gladius_tests
         ImageRGBA targetImage(*core->getComputeContext(), imageSize, imageSize);
         ASSERT_NO_THROW(targetImage.allocateOnDevice());
 
-        ASSERT_NO_THROW(previewProgram->renderScene(core->getComputeContext()->GetQueue(),
-                                                    *primitives,
-                                                    targetImage,
-                                                    0.0f,
-                                                    0u,
-                                                    imageSize));
+        ASSERT_NO_THROW(previewProgram->renderScene(
+          core->getComputeContext()->GetQueue(), *primitives, targetImage, 0.0f, 0u, imageSize));
         ASSERT_NO_THROW(targetImage.read());
 
         auto const & pixels = targetImage.getData();
@@ -329,10 +326,8 @@ namespace gladius_tests
                                 pixels.end(),
                                 [](cl_float4 const & pixel)
                                 {
-                                    return std::isfinite(pixel.s[0]) &&
-                                           std::isfinite(pixel.s[1]) &&
-                                           std::isfinite(pixel.s[2]) &&
-                                           std::isfinite(pixel.s[3]);
+                                    return std::isfinite(pixel.s[0]) && std::isfinite(pixel.s[1]) &&
+                                           std::isfinite(pixel.s[2]) && std::isfinite(pixel.s[3]);
                                 }));
     }
 
@@ -352,9 +347,10 @@ namespace gladius_tests
         mesh.addFace(b, c, d);
         mesh.addFace(c, a, d);
 
-        auto const meshPath = std::filesystem::temp_directory_path() /
-                              fmt::format("gladius-command-stream-mesh-{}.3mf",
-                                          std::chrono::steady_clock::now().time_since_epoch().count());
+        auto const meshPath =
+          std::filesystem::temp_directory_path() /
+          fmt::format("gladius-command-stream-mesh-{}.3mf",
+                      std::chrono::steady_clock::now().time_since_epoch().count());
 
         io::MeshWriter3mf writer(m_logger);
         ASSERT_NO_THROW(writer.exportMesh(meshPath, mesh, "TinyTetrahedron"));
@@ -378,15 +374,15 @@ namespace gladius_tests
         SpatialMeshResource const * importedMesh = nullptr;
         for (auto const & [key, resource] : document->getResourceManager().getResourceMap())
         {
-          if (key.getResourceType() != ResourceType::Mesh)
-          {
-            continue;
-          }
-          importedMesh = dynamic_cast<SpatialMeshResource const *>(resource.get());
-          if (importedMesh != nullptr)
-          {
-            break;
-          }
+            if (key.getResourceType() != ResourceType::Mesh)
+            {
+                continue;
+            }
+            importedMesh = dynamic_cast<SpatialMeshResource const *>(resource.get());
+            if (importedMesh != nullptr)
+            {
+                break;
+            }
         }
         ASSERT_NE(importedMesh, nullptr);
         EXPECT_EQ(importedMesh->evaluationConfig().method, MeshSdfMethod::PureBVH);
@@ -413,16 +409,36 @@ namespace gladius_tests
         ASSERT_NE(primitives.get(), nullptr);
         ASSERT_NO_THROW(primitives->write());
 
+        auto const & primitiveMeta = primitives->primitives.getData();
+        auto const meshPrimitiveIt = std::find_if(
+          primitiveMeta.begin(),
+          primitiveMeta.end(),
+          [](PrimitiveMeta const & meta) { return meta.primitiveType == SDF_SPATIAL_MESH_ROOT; });
+        ASSERT_NE(meshPrimitiveIt, primitiveMeta.end());
+
+        auto const & payload = primitives->data.getData();
+        auto const headerStart = static_cast<size_t>(meshPrimitiveIt->start);
+        ASSERT_GT(payload.size(), headerStart + 33u);
+
+        auto const nodesOffset = static_cast<int>(payload[headerStart + 12u]);
+        auto const trianglesOffset = static_cast<int>(payload[headerStart + 13u]);
+        auto const normalsOffset = static_cast<int>(payload[headerStart + 14u]);
+        auto const indicesOffset = static_cast<int>(payload[headerStart + 15u]);
+        auto const voxelDataOffset = static_cast<int>(payload[headerStart + 26u]);
+        auto const edgeNeighborsOffset = static_cast<int>(payload[headerStart + 28u]);
+        EXPECT_EQ(nodesOffset % 4, 0);
+        EXPECT_EQ(trianglesOffset % 4, 0);
+        EXPECT_EQ(normalsOffset % 4, 0);
+        EXPECT_EQ(indicesOffset % 4, 0);
+        EXPECT_EQ(voxelDataOffset % 2, 0);
+        EXPECT_EQ(edgeNeighborsOffset % 4, 0);
+
         constexpr size_t imageSize = 1u;
         ImageRGBA targetImage(*core->getComputeContext(), imageSize, imageSize);
         ASSERT_NO_THROW(targetImage.allocateOnDevice());
 
-        ASSERT_NO_THROW(previewProgram->renderScene(core->getComputeContext()->GetQueue(),
-                                                    *primitives,
-                                                    targetImage,
-                                                    0.0f,
-                                                    0u,
-                                                    imageSize));
+        ASSERT_NO_THROW(previewProgram->renderScene(
+          core->getComputeContext()->GetQueue(), *primitives, targetImage, 0.0f, 0u, imageSize));
         ASSERT_NO_THROW(targetImage.read());
 
         auto const & pixels = targetImage.getData();
@@ -431,59 +447,172 @@ namespace gladius_tests
                                 pixels.end(),
                                 [](cl_float4 const & pixel)
                                 {
-                                    return std::isfinite(pixel.s[0]) &&
-                                           std::isfinite(pixel.s[1]) &&
-                                           std::isfinite(pixel.s[2]) &&
-                                           std::isfinite(pixel.s[3]);
+                                    return std::isfinite(pixel.s[0]) && std::isfinite(pixel.s[1]) &&
+                                           std::isfinite(pixel.s[2]) && std::isfinite(pixel.s[3]);
                                 }));
     }
 
     TEST_F(ComputeCore_Test, DISABLED_PreComputeSDF_LoadedAssembly_EqualsExpectedResult)
     {
-      auto core = load3mf("testdata/ImplicitGyroid.3mf");
-      auto primitives = core->getPrimitives();
-      auto const & payloadData = primitives->data.getData();
-      auto const payloadDataHash = helper::computeHash(payloadData.cbegin(), payloadData.cend());
-      EXPECT_EQ(payloadDataHash, 0u);
-
-      auto resources = core->getResourceContext();
-      auto const parameter = resources->getParameterBuffer().getData();
-      for (auto const & param : parameter)
-      {
-        std::cout << param << std::endl;
-      }
-
-      auto const parameterHash = helper::computeHash(parameter.cbegin(), parameter.cend());
-      constexpr auto expectedHash = 6494502327630714298u;
-      EXPECT_EQ(parameterHash, expectedHash);
-      EXPECT_TRUE(core->precomputeSdfForWholeBuildPlatform());
-
-      // Reuse the previously defined resources variable instead of redefining it
-      auto & preComp = resources->getPrecompSdfBuffer();
-      preComp.read();
-      auto const bufSize = preComp.getData().size();
-      EXPECT_EQ(bufSize, 16777216u);
-
-      auto const & data = preComp.getData();
-      std::vector<float> distances;
-      distances.reserve(data.size());
-      for (auto const & sample : data)
-      {
-        distances.push_back(sample.s[3]);
-      }
-      auto const hash = helper::computeHash(distances.cbegin(), distances.cend());
-      EXPECT_EQ(hash, 13095517456146691086u);
-
-      auto bBox = core->getBoundingBox();
-      EXPECT_TRUE(bBox.has_value());
-
-      auto const tolerance = 1E-3f;
-      EXPECT_NEAR(bBox->min.x, -7.6475257873535156f, tolerance);
-      EXPECT_NEAR(bBox->min.y, -1.9666776657104492f, tolerance);
-      EXPECT_NEAR(bBox->min.z, -0.00098828284535557032f, tolerance);
-
-      EXPECT_NEAR(bBox->max.x, 64.728408813476562f, tolerance);
-      EXPECT_NEAR(bBox->max.y, 74.136703491210938f, tolerance);
-      EXPECT_NEAR(bBox->max.z, 50.00640869140625f, tolerance);
+        auto core = load3mf("testdata/ImplicitGyroid.3mf");
+        auto primitives = core->getPrimitives();
+        auto const & payloadData = primitives->data.getData();
+        auto const payloadDataHash = helper::computeHash(payloadData.cbegin(), payloadData.cend());
+        EXPECT_EQ(payloadDataHash, 0u);
+
+        auto resources = core->getResourceContext();
+        auto const parameter = resources->getParameterBuffer().getData();
+        for (auto const & param : parameter)
+        {
+            std::cout << param << std::endl;
+        }
+
+        auto const parameterHash = helper::computeHash(parameter.cbegin(), parameter.cend());
+        constexpr auto expectedHash = 6494502327630714298u;
+        EXPECT_EQ(parameterHash, expectedHash);
+        EXPECT_TRUE(core->precomputeSdfForWholeBuildPlatform());
+
+        // Reuse the previously defined resources variable instead of redefining it
+        auto & preComp = resources->getPrecompSdfBuffer();
+        preComp.read();
+        auto const bufSize = preComp.getData().size();
+        EXPECT_EQ(bufSize, 16777216u);
+
+        auto const & data = preComp.getData();
+        std::vector<float> distances;
+        distances.reserve(data.size());
+        for (auto const & sample : data)
+        {
+            distances.push_back(sample.s[3]);
+        }
+        auto const hash = helper::computeHash(distances.cbegin(), distances.cend());
+        EXPECT_EQ(hash, 13095517456146691086u);
+
+        auto bBox = core->getBoundingBox();
+        EXPECT_TRUE(bBox.has_value());
+
+        auto const tolerance = 1E-3f;
+        EXPECT_NEAR(bBox->min.x, -7.6475257873535156f, tolerance);
+        EXPECT_NEAR(bBox->min.y, -1.9666776657104492f, tolerance);
+        EXPECT_NEAR(bBox->min.z, -0.00098828284535557032f, tolerance);
+
+        EXPECT_NEAR(bBox->max.x, 64.728408813476562f, tolerance);
+        EXPECT_NEAR(bBox->max.y, 74.136703491210938f, tolerance);
+        EXPECT_NEAR(bBox->max.z, 50.00640869140625f, tolerance);
+    }
+
+    // Regression test for the Document lifecycle fix (review: F7).
+    // Destroying a Document while an asynchronous model refresh is in flight must join the
+    // worker before any member is torn down. Previously the implicit std::future destructors
+    // joined the worker only after later-declared members were already gone (use-after-free).
+    TEST_F(ComputeCore_Test, DocumentDestruction_WithInFlightModelRefresh_JoinsWorkerWithoutCrash)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+        auto document = std::make_unique<Document>(core);
+
+        // Launch the background refresh worker (sets m_futureModelRefresh).
+        static_cast<void>(document->refreshModelIfNoCompilationIsRunning());
+
+        // Destroy while the worker may still be running. Run the teardown on a separate
+        // thread guarded by a watchdog so a regression that deadlocks fails the test
+        // instead of hanging the whole suite.
+        auto teardown =
+          std::async(std::launch::async, [doc = std::move(document)]() mutable { doc.reset(); });
+
+        ASSERT_EQ(teardown.wait_for(std::chrono::seconds(30)), std::future_status::ready)
+          << "Document destruction deadlocked while joining the async refresh worker";
+        ASSERT_NO_THROW(teardown.get());
+    }
+
+    TEST_F(ComputeCore_Test, RenderSession_RetainsPreviousSceneAcrossContextReplacement)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+        auto session = core->createRenderSession();
+        ASSERT_NE(session, nullptr);
+
+        auto const previousContext = session->getComputeContext();
+        ASSERT_NE(previousContext, nullptr);
+        ASSERT_TRUE(session->isPayloadCurrent());
+
+        auto replacementContext = std::make_shared<ComputeContext>(EnableGLOutput::disabled);
+        ASSERT_TRUE(replacementContext->isValid());
+        core->setComputeContext(replacementContext);
+
+        EXPECT_NE(core->getComputeContext().get(), previousContext.get());
+        EXPECT_EQ(session->getComputeContext().get(), previousContext.get());
+        EXPECT_TRUE(session->isPayloadCurrent());
+    }
+
+    TEST_F(ComputeCore_Test, PublishRenderSceneGeneration_RetainsExistingSessionGeneration)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+        auto session = core->createRenderSession();
+        ASSERT_NE(session, nullptr);
+
+        auto const previousGenerationContext = session->getComputeContext();
+        ASSERT_NE(previousGenerationContext, nullptr);
+
+        auto replacement = std::make_shared<RenderSceneGeneration>(
+          previousGenerationContext, RequiredCapabilities::ComputeOnly, m_logger);
+
+        core->publishRenderSceneGeneration(replacement);
+
+        auto currentSession = core->createRenderSession();
+        ASSERT_NE(currentSession, nullptr);
+        EXPECT_EQ(currentSession->getComputeContext().get(), previousGenerationContext.get());
+        EXPECT_NE(currentSession->getPayloadSnapshot().primitiveMeta.resourceId,
+                  session->getPayloadSnapshot().primitiveMeta.resourceId);
+        EXPECT_EQ(session->getComputeContext().get(), previousGenerationContext.get());
+        EXPECT_TRUE(session->isPayloadCurrent());
+    }
+
+    TEST_F(ComputeCore_Test, CreateRenderSession_WithMatchingRevision_ReturnsTaggedGeneration)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+        auto const context = core->getComputeContext();
+        RenderSceneRevision const revision{.documentIdentity = 41, .documentVersion = 7};
+        auto generation = std::make_shared<RenderSceneGeneration>(
+          context, RequiredCapabilities::ComputeOnly, m_logger, revision);
+        core->publishRenderSceneGeneration(std::move(generation));
+
+        auto session = core->createRenderSession(revision);
+
+        ASSERT_TRUE(session.has_value());
+        ASSERT_NE(*session, nullptr);
+        EXPECT_EQ((*session)->getRevision(), revision);
+    }
+
+    TEST_F(ComputeCore_Test, CreateRenderSession_WithDifferentRevision_RejectsGeneration)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+        auto const context = core->getComputeContext();
+        RenderSceneRevision const publishedRevision{.documentIdentity = 41, .documentVersion = 7};
+        auto generation = std::make_shared<RenderSceneGeneration>(
+          context, RequiredCapabilities::ComputeOnly, m_logger, publishedRevision);
+        core->publishRenderSceneGeneration(std::move(generation));
+
+        EXPECT_FALSE(
+          core->createRenderSession({.documentIdentity = 41, .documentVersion = 8}).has_value());
+        EXPECT_FALSE(
+          core->createRenderSession({.documentIdentity = 42, .documentVersion = 7}).has_value());
+    }
+
+    TEST_F(ComputeCore_Test, CreateRenderSession_WithUntaggedRevision_RejectsGeneration)
+    {
+        SKIP_IF_OPENCL_UNAVAILABLE();
+
+        auto core = createCore();
+
+        EXPECT_FALSE(core->createRenderSession({}).has_value());
     }
 }
diff --git a/gladius/tests/unittests/DocumentSaveIdentity_tests.cpp b/gladius/tests/unittests/DocumentSaveIdentity_tests.cpp
new file mode 100644
index 00000000..571261c7
--- /dev/null
+++ b/gladius/tests/unittests/DocumentSaveIdentity_tests.cpp
@@ -0,0 +1,85 @@
+#include "Document.h"
+#include "opencl_test_helper.h"
+
+#include <compute/ComputeCore.h>
+
+#include <gtest/gtest.h>
+
+#include <filesystem>
+#include <memory>
+
+namespace gladius_tests
+{
+    using namespace gladius;
+
+    class DocumentSaveIdentityTest : public ::testing::Test
+    {
+      protected:
+        void SetUp() override
+        {
+            SKIP_IF_OPENCL_UNAVAILABLE();
+
+            m_logger = std::make_shared<events::Logger>();
+            m_context = std::make_shared<ComputeContext>(EnableGLOutput::disabled);
+            if (!m_context->isValid())
+            {
+                GTEST_SKIP() << "OpenCL context not available";
+            }
+
+            m_core =
+              std::make_shared<ComputeCore>(m_context, RequiredCapabilities::ComputeOnly, m_logger);
+            m_document = std::make_shared<Document>(m_core);
+        }
+
+        events::SharedLogger m_logger;
+        std::shared_ptr<ComputeContext> m_context;
+        std::shared_ptr<ComputeCore> m_core;
+        std::shared_ptr<Document> m_document;
+    };
+
+    TEST_F(DocumentSaveIdentityTest, RevisionChangeRejectsStaleSaveWithoutChangingFilename)
+    {
+        auto const snapshot = m_document->createSaveSnapshot();
+        auto const target = std::filesystem::temp_directory_path() / "gladius_stale_save.3mf";
+
+        m_document->markFileAsChanged();
+
+        EXPECT_FALSE(m_document->completeSave(target,
+                                              snapshot.documentIdentity,
+                                              snapshot.version));
+        EXPECT_FALSE(m_document->getCurrentAssemblyFilename().has_value());
+        EXPECT_TRUE(m_document->isFileChanged());
+    }
+
+    TEST_F(DocumentSaveIdentityTest, ReplacedDocumentRejectsSaveFromPreviousIdentity)
+    {
+        auto const snapshot = m_document->createSaveSnapshot();
+        auto const target = std::filesystem::temp_directory_path() / "gladius_replaced_save.3mf";
+        auto const previousIdentity = snapshot.documentIdentity;
+
+        m_document->newEmptyModel();
+
+        EXPECT_NE(m_document->documentIdentity(), previousIdentity);
+        EXPECT_FALSE(m_document->completeSave(target,
+                                              snapshot.documentIdentity,
+                                              snapshot.version));
+        EXPECT_FALSE(m_document->getCurrentAssemblyFilename().has_value());
+    }
+
+    TEST_F(DocumentSaveIdentityTest, CurrentIdentityAndRevisionAcceptSave)
+    {
+        auto const snapshot = m_document->createSaveSnapshot();
+        auto const target = std::filesystem::temp_directory_path() / "gladius_current_save.3mf";
+
+        m_document->markFileAsChanged();
+        auto const editedSnapshot = m_document->createSaveSnapshot();
+
+        EXPECT_TRUE(m_document->completeSave(target,
+                                             editedSnapshot.documentIdentity,
+                                             editedSnapshot.version));
+        ASSERT_TRUE(m_document->getCurrentAssemblyFilename().has_value());
+        EXPECT_EQ(*m_document->getCurrentAssemblyFilename(), target);
+        EXPECT_FALSE(m_document->isFileChanged());
+    }
+
+} // namespace gladius_tests
diff --git a/gladius/tests/unittests/FrontlitThicknessSolver_tests.cpp b/gladius/tests/unittests/FrontlitThicknessSolver_tests.cpp
index 3c098520..255dae85 100644
--- a/gladius/tests/unittests/FrontlitThicknessSolver_tests.cpp
+++ b/gladius/tests/unittests/FrontlitThicknessSolver_tests.cpp
@@ -6,13 +6,302 @@
 #include "io/3mf/FaceThicknessMapper.h"
 #include "io/3mf/FilamentOpticalProperties.h"
 #include "io/3mf/FrontlitThicknessSolver.h"
+#include "io/3mf/ShellMaterialOrdering.h"
 
 #include <gtest/gtest.h>
+#include <nlohmann/json.hpp>
 
 #include <cmath>
+#include <iostream>
+#include <filesystem>
+#include <fstream>
+#include <limits>
+#include <string>
+#include <vector>
 
 namespace gladius::io::tests
 {
+    namespace
+    {
+        struct BenchmarkMetrics
+        {
+            float meanLinearRgbError = 0.0F;
+            float maxLinearRgbError = 0.0F;
+            float meanDeltaE = 0.0F;
+            float maxDeltaE = 0.0F;
+            float convergenceRate = 0.0F;
+            std::size_t sampleCount = 0U;
+        };
+
+        struct BenchmarkOutcome
+        {
+            OrderedShellMaterials orderedMaterials;
+            BenchmarkMetrics metrics;
+        };
+
+        [[nodiscard]] Eigen::Vector3f hslToSrgb(float hueDegrees, float saturation, float lightness)
+        {
+            float const hue = std::fmod(std::fmod(hueDegrees, 360.0F) + 360.0F, 360.0F) / 60.0F;
+            float const chroma = (1.0F - std::abs(2.0F * lightness - 1.0F)) * saturation;
+            float const x = chroma * (1.0F - std::abs(std::fmod(hue, 2.0F) - 1.0F));
+
+            Eigen::Vector3f rgbPrime = Eigen::Vector3f::Zero();
+            if (hue < 1.0F)
+            {
+                rgbPrime = Eigen::Vector3f{chroma, x, 0.0F};
+            }
+            else if (hue < 2.0F)
+            {
+                rgbPrime = Eigen::Vector3f{x, chroma, 0.0F};
+            }
+            else if (hue < 3.0F)
+            {
+                rgbPrime = Eigen::Vector3f{0.0F, chroma, x};
+            }
+            else if (hue < 4.0F)
+            {
+                rgbPrime = Eigen::Vector3f{0.0F, x, chroma};
+            }
+            else if (hue < 5.0F)
+            {
+                rgbPrime = Eigen::Vector3f{x, 0.0F, chroma};
+            }
+            else
+            {
+                rgbPrime = Eigen::Vector3f{chroma, 0.0F, x};
+            }
+
+            float const match = lightness - 0.5F * chroma;
+            return (rgbPrime.array() + match).matrix().cwiseMax(0.0F).cwiseMin(1.0F);
+        }
+
+        [[nodiscard]] Eigen::Vector3f linearRgbToXyz(Eigen::Vector3f const& linearRgb)
+        {
+            Eigen::Matrix3f const matrix = (Eigen::Matrix3f() <<
+                0.4124564F, 0.3575761F, 0.1804375F,
+                0.2126729F, 0.7151522F, 0.0721750F,
+                0.0193339F, 0.1191920F, 0.9503041F).finished();
+            return matrix * linearRgb;
+        }
+
+        [[nodiscard]] Eigen::Vector3f xyzToLab(Eigen::Vector3f const& xyz)
+        {
+            Eigen::Vector3f scaled = xyz;
+            scaled.x() /= 0.95047F;
+            scaled.y() /= 1.00000F;
+            scaled.z() /= 1.08883F;
+
+            auto const f = [](float value) {
+                float const delta = 6.0F / 29.0F;
+                float const threshold = delta * delta * delta;
+                if (value > threshold)
+                {
+                    return std::cbrt(value);
+                }
+                return value / (3.0F * delta * delta) + 4.0F / 29.0F;
+            };
+
+            float const fx = f(std::max(scaled.x(), 0.0F));
+            float const fy = f(std::max(scaled.y(), 0.0F));
+            float const fz = f(std::max(scaled.z(), 0.0F));
+
+            return Eigen::Vector3f{116.0F * fy - 16.0F, 500.0F * (fx - fy), 200.0F * (fy - fz)};
+        }
+
+        [[nodiscard]] float deltaE76(Eigen::Vector3f const& lhsLinear, Eigen::Vector3f const& rhsLinear)
+        {
+            return (xyzToLab(linearRgbToXyz(lhsLinear)) - xyzToLab(linearRgbToXyz(rhsLinear))).norm();
+        }
+
+        [[nodiscard]] FilamentStack loadFilamentStackFromJson(std::string const& filePath,
+                                                               std::size_t& backgroundIndex,
+                                                               IlluminationMode& illuminationMode)
+        {
+            namespace fs = std::filesystem;
+
+            std::vector<fs::path> const candidates = {
+                fs::path{filePath},
+                fs::path{"testdata"} / fs::path{filePath}.filename(),
+                fs::path{"tests/unittests/testdata"} / fs::path{filePath}.filename(),
+                fs::path{"out/build/linux-releaseWithDebug/tests/unittests/testdata"} / fs::path{filePath}.filename()};
+
+            fs::path resolvedPath;
+            for (fs::path const& candidate : candidates)
+            {
+                if (fs::exists(candidate))
+                {
+                    resolvedPath = candidate;
+                    break;
+                }
+            }
+
+            std::ifstream stream(resolvedPath.empty() ? filePath : resolvedPath.string());
+            EXPECT_TRUE(stream.is_open()) << "Failed to open fixture: " << filePath;
+
+            nlohmann::json json;
+            stream >> json;
+
+            backgroundIndex = json.value("backgroundIndex", std::numeric_limits<std::size_t>::max());
+            std::string const mode = json.value("illuminationMode", std::string{"frontlit"});
+            illuminationMode = (mode == "backlit") ? IlluminationMode::Backlit : IlluminationMode::Frontlit;
+
+            FilamentStack stack;
+            for (auto const& material : json.at("materials"))
+            {
+                auto const reflectance = material.at("reflectanceColor").get<std::vector<float>>();
+                Eigen::Vector3f transmissionDistance = Eigen::Vector3f::Zero();
+                if (material.contains("transmissionDistance"))
+                {
+                    if (material.at("transmissionDistance").is_array())
+                    {
+                        auto const td = material.at("transmissionDistance").get<std::vector<float>>();
+                        if (td.size() == 3U)
+                        {
+                            transmissionDistance = Eigen::Vector3f{td[0], td[1], td[2]};
+                        }
+                    }
+                    else
+                    {
+                        float const td = material.at("transmissionDistance").get<float>();
+                        transmissionDistance = Eigen::Vector3f{td, td, td};
+                    }
+                }
+
+                stack.push_back(FilamentOpticalProperties{
+                    material.value("name", std::string{"Material"}),
+                    Eigen::Vector3f{reflectance.at(0), reflectance.at(1), reflectance.at(2)},
+                    0.6F,
+                    0.4F,
+                    transmissionDistance});
+            }
+
+            return stack;
+        }
+
+        [[nodiscard]] std::vector<Eigen::Vector3f> buildHslWheelSamples()
+        {
+            std::vector<Eigen::Vector3f> samples;
+            std::vector<float> const saturations = {0.55F, 0.80F, 1.0F};
+            std::vector<float> const lightnesses = {0.35F, 0.50F, 0.65F};
+
+            for (float lightness : lightnesses)
+            {
+                for (float saturation : saturations)
+                {
+                    for (int hueIndex = 0; hueIndex < 24; ++hueIndex)
+                    {
+                        float const hue = 360.0F * static_cast<float>(hueIndex) / 24.0F;
+                        samples.push_back(srgbToLinear(hslToSrgb(hue, saturation, lightness)));
+                    }
+                }
+            }
+
+            return samples;
+        }
+
+        [[nodiscard]] BenchmarkMetrics evaluateBenchmarkForOrderedStack(FilamentStack const& stack,
+                                                                         ThicknessConstraints const& constraints,
+                                                                         IlluminationMode mode,
+                                                                         std::size_t backgroundIndex,
+                                                                         std::vector<Eigen::Vector3f> const& samples)
+        {
+            FrontlitThicknessSolver solver(stack, constraints, mode, backgroundIndex);
+
+            BenchmarkMetrics metrics;
+            metrics.sampleCount = samples.size();
+
+            std::size_t convergedCount = 0U;
+            for (Eigen::Vector3f const& target : samples)
+            {
+                ThicknessSolution const solution = solver.solve(target);
+                float const linearRgbError = (solution.achievedColor - target).norm();
+                float const deltaE = deltaE76(solution.achievedColor, target);
+
+                metrics.meanLinearRgbError += linearRgbError;
+                metrics.maxLinearRgbError = std::max(metrics.maxLinearRgbError, linearRgbError);
+                metrics.meanDeltaE += deltaE;
+                metrics.maxDeltaE = std::max(metrics.maxDeltaE, deltaE);
+                if (solution.converged)
+                {
+                    ++convergedCount;
+                }
+            }
+
+            if (!samples.empty())
+            {
+                float const invCount = 1.0F / static_cast<float>(samples.size());
+                metrics.meanLinearRgbError *= invCount;
+                metrics.meanDeltaE *= invCount;
+                metrics.convergenceRate = static_cast<float>(convergedCount) * invCount;
+            }
+
+            return metrics;
+        }
+
+        [[nodiscard]] BenchmarkOutcome benchmarkHeuristicOrder(FilamentStack const& stack,
+                                                                ThicknessConstraints const& constraints,
+                                                                IlluminationMode mode,
+                                                                std::size_t backgroundIndex,
+                                                                std::vector<Eigen::Vector3f> const& samples)
+        {
+            BenchmarkOutcome outcome;
+            outcome.orderedMaterials = ShellMaterialOrdering::reorderForShells(stack, backgroundIndex, mode);
+            outcome.metrics = evaluateBenchmarkForOrderedStack(
+                outcome.orderedMaterials.stack,
+                constraints,
+                mode,
+                outcome.orderedMaterials.backgroundIndex,
+                samples);
+            return outcome;
+        }
+
+        [[nodiscard]] BenchmarkOutcome benchmarkOptimizedOrder(FilamentStack const& stack,
+                                                                ThicknessConstraints const& constraints,
+                                                                IlluminationMode mode,
+                                                                std::size_t backgroundIndex,
+                                                                std::vector<Eigen::Vector3f> const& samples)
+        {
+            BenchmarkOutcome outcome;
+            outcome.orderedMaterials = ShellMaterialOrdering::optimizeGlobalOrderForShells(
+                stack,
+                backgroundIndex,
+                mode,
+                [&](FilamentStack const& candidate, std::size_t candidateBackgroundIndex) {
+                    return evaluateBenchmarkForOrderedStack(
+                        candidate,
+                        constraints,
+                        mode,
+                        candidateBackgroundIndex,
+                        samples).meanDeltaE;
+                });
+
+            outcome.metrics = evaluateBenchmarkForOrderedStack(
+                outcome.orderedMaterials.stack,
+                constraints,
+                mode,
+                outcome.orderedMaterials.backgroundIndex,
+                samples);
+            return outcome;
+        }
+
+        void printBenchmarkOutcome(char const* label, BenchmarkOutcome const& outcome)
+        {
+            std::cout << label << ": order=";
+            for (std::size_t index = 0; index < outcome.orderedMaterials.stack.size(); ++index)
+            {
+                if (index > 0U)
+                {
+                    std::cout << " -> ";
+                }
+                std::cout << outcome.orderedMaterials.stack[index].name;
+            }
+            std::cout << ", meanRGB=" << outcome.metrics.meanLinearRgbError
+                      << ", maxRGB=" << outcome.metrics.maxLinearRgbError
+                      << ", meanDeltaE=" << outcome.metrics.meanDeltaE
+                      << ", maxDeltaE=" << outcome.metrics.maxDeltaE
+                      << ", convergence=" << outcome.metrics.convergenceRate << std::endl;
+        }
+    } // namespace
 
     class FrontlitThicknessSolverTest : public ::testing::Test
     {
@@ -22,21 +311,20 @@ namespace gladius::io::tests
             // Create a simple 3-filament stack: black (bottom), red, white (top)
             m_blackFilament = FilamentOpticalProperties{
                 "Black",
-                Eigen::Vector3f(0.05f, 0.05f, 0.05f), // Very dark
-                0.8f,                                  // High opacity
-                0.4f                                   // Reference thickness
-            };
+                Eigen::Vector3f(0.05f, 0.05f, 0.05f),
+                0.8f,
+                0.4f};
 
             m_redFilament = FilamentOpticalProperties{
                 "Red",
-                Eigen::Vector3f(0.9f, 0.1f, 0.1f), // Bright red
-                0.6f,                               // Medium opacity
+                Eigen::Vector3f(0.9f, 0.1f, 0.1f),
+                0.6f,
                 0.4f};
 
             m_whiteFilament = FilamentOpticalProperties{
                 "White",
-                Eigen::Vector3f(0.95f, 0.95f, 0.95f), // Near white
-                0.7f,                                  // High-ish opacity
+                Eigen::Vector3f(0.95f, 0.95f, 0.95f),
+                0.7f,
                 0.4f};
 
             m_stack.push_back(m_blackFilament);
@@ -50,7 +338,6 @@ namespace gladius::io::tests
         FilamentStack m_stack;
     };
 
-    // Test FilamentOpticalProperties::computeEffectiveOpacity
     TEST_F(FrontlitThicknessSolverTest, EffectiveOpacity_ZeroThickness_ReturnsZero)
     {
         float const opacity = m_blackFilament.computeEffectiveOpacity(0.0f);
@@ -59,11 +346,7 @@ namespace gladius::io::tests
 
     TEST_F(FrontlitThicknessSolverTest, EffectiveOpacity_ReferenceThickness_ReturnsNominalOpacity)
     {
-        // At reference thickness, opacity should be close to the nominal value
         float const opacity = m_blackFilament.computeEffectiveOpacity(m_blackFilament.referenceThickness);
-
-        // Due to exponential model, it won't be exactly m_blackFilament.opacity,
-        // but should be in the same ballpark
         EXPECT_GT(opacity, 0.5f);
         EXPECT_LT(opacity, 1.0f);
     }
@@ -87,16 +370,13 @@ namespace gladius::io::tests
             Eigen::Vector3f(0.5f, 0.5f, 0.5f),
             0.6f,
             0.4f,
-            Eigen::Vector3f(1.0f, 1.0f, 1.0f)}; // TD = 1mm per channel
+            Eigen::Vector3f(1.0f, 1.0f, 1.0f)};
 
         auto const rt = filament.computeKubelkaMunkRT(1.0f);
 
-        // Reflectance should be close to Rinf for moderate thickness with scattering considered
         EXPECT_NEAR(rt.reflectance.x(), 0.5f, 0.02f);
         EXPECT_NEAR(rt.reflectance.y(), 0.5f, 0.02f);
         EXPECT_NEAR(rt.reflectance.z(), 0.5f, 0.02f);
-
-        // Transmittance should be small due to absorption/scattering
         EXPECT_NEAR(rt.transmittance.x(), 0.04f, 0.02f);
         EXPECT_NEAR(rt.transmittance.y(), 0.04f, 0.02f);
         EXPECT_NEAR(rt.transmittance.z(), 0.04f, 0.02f);
@@ -126,27 +406,19 @@ namespace gladius::io::tests
         EXPECT_NEAR(predicted.z(), rt.reflectance.z(), 1e-3f);
     }
 
-    // Test FrontlitThicknessSolver::predictColor
     TEST_F(FrontlitThicknessSolverTest, PredictColor_AllZeroThickness_ReturnsBlackOrDefault)
     {
         FrontlitThicknessSolver solver(m_stack);
-
         std::vector<float> thicknesses = {0.0f, 0.0f, 0.0f};
         Eigen::Vector3f const predicted = solver.predictColor(thicknesses);
-
-        // With all zero thicknesses, no color is visible - should be black or near-black
         EXPECT_LT(predicted.norm(), 0.1f);
     }
 
     TEST_F(FrontlitThicknessSolverTest, PredictColor_OnlyTopLayerThick_ReturnsTopColor)
     {
         FrontlitThicknessSolver solver(m_stack);
-
-        // Only the white (top) layer has thickness
         std::vector<float> thicknesses = {0.0f, 0.0f, 5.0f};
         Eigen::Vector3f const predicted = solver.predictColor(thicknesses);
-
-        // Should be dominated by white
         EXPECT_GT(predicted.x(), 0.8f);
         EXPECT_GT(predicted.y(), 0.8f);
         EXPECT_GT(predicted.z(), 0.8f);
@@ -155,12 +427,8 @@ namespace gladius::io::tests
     TEST_F(FrontlitThicknessSolverTest, PredictColor_OnlyBottomLayerThick_ReturnsBottomColor)
     {
         FrontlitThicknessSolver solver(m_stack);
-
-        // Only the black (bottom) layer has thickness
         std::vector<float> thicknesses = {5.0f, 0.0f, 0.0f};
         Eigen::Vector3f const predicted = solver.predictColor(thicknesses);
-
-        // Should be dominated by black
         EXPECT_LT(predicted.x(), 0.2f);
         EXPECT_LT(predicted.y(), 0.2f);
         EXPECT_LT(predicted.z(), 0.2f);
@@ -169,61 +437,44 @@ namespace gladius::io::tests
     TEST_F(FrontlitThicknessSolverTest, PredictColor_OnlyMiddleLayerThick_ReturnsMiddleColor)
     {
         FrontlitThicknessSolver solver(m_stack);
-
-        // Only the red (middle) layer has thickness
         std::vector<float> thicknesses = {0.0f, 5.0f, 0.0f};
         Eigen::Vector3f const predicted = solver.predictColor(thicknesses);
-
-        // Should be dominated by red
-        EXPECT_GT(predicted.x(), 0.7f); // High red
-        EXPECT_LT(predicted.y(), 0.3f); // Low green
-        EXPECT_LT(predicted.z(), 0.3f); // Low blue
+        EXPECT_GT(predicted.x(), 0.7f);
+        EXPECT_LT(predicted.y(), 0.3f);
+        EXPECT_LT(predicted.z(), 0.3f);
     }
 
     TEST_F(FrontlitThicknessSolverTest, PredictColor_TopOccludesLower_ColorDominatedByTop)
     {
         FrontlitThicknessSolver solver(m_stack);
-
-        // All layers thick, but top should dominate
         std::vector<float> thicknesses = {5.0f, 5.0f, 5.0f};
         Eigen::Vector3f const predicted = solver.predictColor(thicknesses);
-
-        // Top layer (white) should dominate due to high opacity
         EXPECT_GT(predicted.x(), 0.7f);
         EXPECT_GT(predicted.y(), 0.7f);
         EXPECT_GT(predicted.z(), 0.7f);
     }
 
-    // Test FrontlitThicknessSolver::computeVisibilities
     TEST_F(FrontlitThicknessSolverTest, Visibilities_SumToApproximatelyOne)
     {
         FrontlitThicknessSolver solver(m_stack);
-
         std::vector<float> thicknesses = {1.0f, 1.0f, 1.0f};
         std::vector<float> const visibilities = solver.computeVisibilities(thicknesses);
 
         ASSERT_EQ(visibilities.size(), 3u);
-
-        // Sum of visibilities plus remaining (transmitted) light should be <= 1
         float const sum = visibilities[0] + visibilities[1] + visibilities[2];
         EXPECT_LE(sum, 1.0f);
-        EXPECT_GT(sum, 0.5f); // Should capture most of the light
+        EXPECT_GT(sum, 0.5f);
     }
 
     TEST_F(FrontlitThicknessSolverTest, Visibilities_TopLayerMostVisible)
     {
         FrontlitThicknessSolver solver(m_stack);
-
-        // Equal thicknesses - top layer should have highest visibility
         std::vector<float> thicknesses = {1.0f, 1.0f, 1.0f};
         std::vector<float> const visibilities = solver.computeVisibilities(thicknesses);
-
-        // Top layer (index 2) should have highest visibility
         EXPECT_GT(visibilities[2], visibilities[1]);
         EXPECT_GT(visibilities[1], visibilities[0]);
     }
 
-    // Test FrontlitThicknessSolver::solve (inverse problem)
     TEST_F(FrontlitThicknessSolverTest, Solve_TargetWhite_IncreaseTopLayerThickness)
     {
         ThicknessConstraints constraints;
@@ -231,17 +482,12 @@ namespace gladius::io::tests
         constraints.maxThickness = 5.0f;
 
         FrontlitThicknessSolver solver(m_stack, constraints);
-
         Eigen::Vector3f const targetWhite(0.9f, 0.9f, 0.9f);
         ThicknessSolution const solution = solver.solve(targetWhite);
 
         ASSERT_EQ(solution.thicknesses.size(), 3u);
-
-        // To achieve white, the white (top) layer should be thickest
         EXPECT_GT(solution.thicknesses[2], solution.thicknesses[0]);
         EXPECT_GT(solution.thicknesses[2], solution.thicknesses[1]);
-
-        // Error should be reasonably small
         EXPECT_LT(solution.colorError, 0.2f);
     }
 
@@ -252,17 +498,11 @@ namespace gladius::io::tests
         constraints.maxThickness = 5.0f;
 
         FrontlitThicknessSolver solver(m_stack, constraints);
-
         Eigen::Vector3f const targetRed(0.8f, 0.1f, 0.1f);
         ThicknessSolution const solution = solver.solve(targetRed);
 
         ASSERT_EQ(solution.thicknesses.size(), 3u);
-
-        // To achieve red, the red (middle) layer should be significant
-        // Top layer should be thin to not occlude the red
         EXPECT_LT(solution.thicknesses[2], 1.0f);
-
-        // Error should be reasonably small
         EXPECT_LT(solution.colorError, 0.3f);
     }
 
@@ -273,17 +513,10 @@ namespace gladius::io::tests
         constraints.maxThickness = 5.0f;
 
         FrontlitThicknessSolver solver(m_stack, constraints);
-
         Eigen::Vector3f const targetBlack(0.1f, 0.1f, 0.1f);
         ThicknessSolution const solution = solver.solve(targetBlack);
 
         ASSERT_EQ(solution.thicknesses.size(), 3u);
-
-        // To achieve black, the black (bottom) layer needs to be visible
-        // which means upper layers should be thin
-        // OR all layers are thick and the top-most contributes minimal light (unlikely with white)
-
-        // The achieved color should be dark
         EXPECT_LT(solution.achievedColor.norm(), 0.5f);
     }
 
@@ -295,7 +528,6 @@ namespace gladius::io::tests
         constraints.layerHeight = 0.04f;
 
         FrontlitThicknessSolver solver(m_stack, constraints);
-
         Eigen::Vector3f const targetGray(0.5f, 0.5f, 0.5f);
         ThicknessSolution const solution = solver.solve(targetGray);
 
@@ -304,7 +536,6 @@ namespace gladius::io::tests
             EXPECT_GE(t, constraints.minThickness - 1e-6f);
             EXPECT_LE(t, constraints.maxThickness + 1e-6f);
 
-            // Check quantization to layer height
             float const remainder = std::fmod(t, constraints.layerHeight);
             bool const isQuantized = remainder < 1e-5f || (constraints.layerHeight - remainder) < 1e-5f;
             EXPECT_TRUE(isQuantized) << "Thickness " << t << " not quantized to layer height "
@@ -312,7 +543,6 @@ namespace gladius::io::tests
         }
     }
 
-    // Test FaceThicknessMapper
     class FaceThicknessMapperTest : public FrontlitThicknessSolverTest
     {
     };
@@ -320,10 +550,8 @@ namespace gladius::io::tests
     TEST_F(FaceThicknessMapperTest, MapColors_EmptyInput_ReturnsEmptyResult)
     {
         FaceThicknessMapper mapper(m_stack);
-
         std::vector<Eigen::Vector3f> const emptyColors;
         FaceThicknessResult const result = mapper.mapColors(emptyColors);
-
         EXPECT_EQ(result.numFaces(), 0u);
         EXPECT_EQ(result.numLayers(), 3u);
         EXPECT_FLOAT_EQ(result.convergenceRate, 1.0f);
@@ -332,14 +560,10 @@ namespace gladius::io::tests
     TEST_F(FaceThicknessMapperTest, MapColors_SingleFace_ReturnsValidResult)
     {
         FaceThicknessMapper mapper(m_stack);
-
         std::vector<Eigen::Vector3f> colors = {Eigen::Vector3f(0.5f, 0.5f, 0.5f)};
         FaceThicknessResult const result = mapper.mapColors(colors);
-
         EXPECT_EQ(result.numFaces(), 1u);
         EXPECT_EQ(result.numLayers(), 3u);
-
-        // Each layer should have one thickness value
         for (auto const& layer : result.layerThicknesses)
         {
             EXPECT_EQ(layer.size(), 1u);
@@ -351,11 +575,10 @@ namespace gladius::io::tests
         FaceThicknessMapper mapper(m_stack);
 
         std::vector<Eigen::Vector3f> colors = {
-            Eigen::Vector3f(0.9f, 0.9f, 0.9f), // White-ish
-            Eigen::Vector3f(0.8f, 0.1f, 0.1f), // Red
-            Eigen::Vector3f(0.1f, 0.1f, 0.1f), // Black-ish
-            Eigen::Vector3f(0.5f, 0.5f, 0.5f)  // Gray
-        };
+            Eigen::Vector3f(0.9f, 0.9f, 0.9f),
+            Eigen::Vector3f(0.8f, 0.1f, 0.1f),
+            Eigen::Vector3f(0.1f, 0.1f, 0.1f),
+            Eigen::Vector3f(0.5f, 0.5f, 0.5f)};
 
         FaceThicknessResult const result = mapper.mapColors(colors);
 
@@ -363,8 +586,6 @@ namespace gladius::io::tests
         EXPECT_EQ(result.numLayers(), 3u);
         EXPECT_EQ(result.achievedColors.size(), 4u);
         EXPECT_EQ(result.colorErrors.size(), 4u);
-
-        // All layers should have 4 values
         for (auto const& layer : result.layerThicknesses)
         {
             EXPECT_EQ(layer.size(), 4u);
@@ -380,12 +601,9 @@ namespace gladius::io::tests
             Eigen::Vector3f(0.1f, 0.1f, 0.1f)};
 
         std::vector<std::vector<std::size_t>> const emptyAdjacency;
-
         FaceThicknessResult const resultNoSmooth = mapper.mapColors(colors);
-        FaceThicknessResult const resultSmooth =
-            mapper.mapColorsWithSmoothing(colors, emptyAdjacency, 3, 0.3f);
+        FaceThicknessResult const resultSmooth = mapper.mapColorsWithSmoothing(colors, emptyAdjacency, 3, 0.3f);
 
-        // Results should be identical when no adjacency is provided
         EXPECT_EQ(resultNoSmooth.numFaces(), resultSmooth.numFaces());
         EXPECT_EQ(resultNoSmooth.numLayers(), resultSmooth.numLayers());
     }
@@ -394,46 +612,33 @@ namespace gladius::io::tests
     {
         FaceThicknessMapper mapper(m_stack);
 
-        // Three faces with very different target colors
         std::vector<Eigen::Vector3f> colors = {
-            Eigen::Vector3f(0.9f, 0.9f, 0.9f), // Face 0: white
-            Eigen::Vector3f(0.1f, 0.1f, 0.1f), // Face 1: black
-            Eigen::Vector3f(0.9f, 0.9f, 0.9f)  // Face 2: white
-        };
+            Eigen::Vector3f(0.9f, 0.9f, 0.9f),
+            Eigen::Vector3f(0.1f, 0.1f, 0.1f),
+            Eigen::Vector3f(0.9f, 0.9f, 0.9f)};
 
-        // Face 1 is adjacent to faces 0 and 2
         std::vector<std::vector<std::size_t>> adjacency = {
-            {1},    // Face 0 neighbors face 1
-            {0, 2}, // Face 1 neighbors faces 0 and 2
-            {1}     // Face 2 neighbors face 1
-        };
+            {1},
+            {0, 2},
+            {1}};
 
         FaceThicknessResult const resultNoSmooth = mapper.mapColors(colors);
-        FaceThicknessResult const resultSmooth =
-            mapper.mapColorsWithSmoothing(colors, adjacency, 5, 0.5f);
+        FaceThicknessResult const resultSmooth = mapper.mapColorsWithSmoothing(colors, adjacency, 5, 0.5f);
 
-        // After smoothing, face 1's thicknesses should be closer to faces 0 and 2
-        // The difference between face 1 and its neighbors should be smaller
         for (std::size_t layer = 0; layer < resultSmooth.numLayers(); ++layer)
         {
             float const diffNoSmooth =
                 std::abs(resultNoSmooth.layerThicknesses[layer][1] -
-                         (resultNoSmooth.layerThicknesses[layer][0] +
-                          resultNoSmooth.layerThicknesses[layer][2]) /
-                             2.0f);
+                         (resultNoSmooth.layerThicknesses[layer][0] + resultNoSmooth.layerThicknesses[layer][2]) / 2.0f);
 
-            float const diffSmooth = std::abs(
-                resultSmooth.layerThicknesses[layer][1] -
-                (resultSmooth.layerThicknesses[layer][0] + resultSmooth.layerThicknesses[layer][2]) /
-                    2.0f);
+            float const diffSmooth =
+                std::abs(resultSmooth.layerThicknesses[layer][1] -
+                         (resultSmooth.layerThicknesses[layer][0] + resultSmooth.layerThicknesses[layer][2]) / 2.0f);
 
-            // Smoothed difference should generally be smaller
-            // (though not always guaranteed due to constraint projection)
             EXPECT_LE(diffSmooth, diffNoSmooth + 0.5f);
         }
     }
 
-    // Test color space conversions
     TEST(ColorConversionTest, SrgbToLinear_Zero_ReturnsZero)
     {
         EXPECT_FLOAT_EQ(srgbToLinear(0.0f), 0.0f);
@@ -465,7 +670,6 @@ namespace gladius::io::tests
 
     TEST(ColorConversionTest, LinearToSrgb_MidGray_IsLighter)
     {
-        // Linear 0.5 should map to a lighter sRGB value (gamma expansion)
         float const srgb = linearToSrgb(0.5f);
         EXPECT_GT(srgb, 0.5f);
         EXPECT_LT(srgb, 1.0f);
@@ -473,11 +677,66 @@ namespace gladius::io::tests
 
     TEST(ColorConversionTest, SrgbToLinear_MidGray_IsDarker)
     {
-        // sRGB 0.5 should map to a darker linear value (gamma compression)
         float const linear = srgbToLinear(0.5f);
         EXPECT_LT(linear, 0.5f);
         EXPECT_GT(linear, 0.0f);
     }
 
+    TEST(FrontlitThicknessSolverBenchmark, DISABLED_HslWheelBenchmark_PetgFixtureProducesFiniteMetrics)
+    {
+        std::size_t backgroundIndex = std::numeric_limits<std::size_t>::max();
+        IlluminationMode mode = IlluminationMode::Frontlit;
+        FilamentStack const stack = loadFilamentStackFromJson("testdata/petg_cymk.json", backgroundIndex, mode);
+
+        ASSERT_EQ(stack.size(), 4U);
+        EXPECT_EQ(mode, IlluminationMode::Frontlit);
+        EXPECT_EQ(backgroundIndex, 3U) << "Fixture is expected to be the current CMYW-style white-backed stack.";
+
+        ThicknessConstraints constraints;
+        constraints.minThickness = 0.0F;
+        constraints.maxThickness = 4.0F;
+        constraints.layerHeight = 0.04F;
+        constraints.totalMaxThickness = 6.0F;
+
+        std::vector<Eigen::Vector3f> const samples = buildHslWheelSamples();
+        ASSERT_FALSE(samples.empty());
+
+        BenchmarkOutcome const heuristic = benchmarkHeuristicOrder(stack, constraints, mode, backgroundIndex, samples);
+        printBenchmarkOutcome("heuristic", heuristic);
+
+        EXPECT_EQ(heuristic.metrics.sampleCount, samples.size());
+        EXPECT_TRUE(std::isfinite(heuristic.metrics.meanLinearRgbError));
+        EXPECT_TRUE(std::isfinite(heuristic.metrics.maxLinearRgbError));
+        EXPECT_TRUE(std::isfinite(heuristic.metrics.meanDeltaE));
+        EXPECT_TRUE(std::isfinite(heuristic.metrics.maxDeltaE));
+        EXPECT_GE(heuristic.metrics.meanLinearRgbError, 0.0F);
+        EXPECT_GE(heuristic.metrics.meanDeltaE, 0.0F);
+        EXPECT_GE(heuristic.metrics.convergenceRate, 0.0F);
+        EXPECT_LE(heuristic.metrics.convergenceRate, 1.0F);
+    }
+
+    TEST(FrontlitThicknessSolverBenchmark, DISABLED_HslWheelBenchmark_OptimizedGlobalOrderDoesNotUnderperformHeuristic)
+    {
+        std::size_t backgroundIndex = std::numeric_limits<std::size_t>::max();
+        IlluminationMode mode = IlluminationMode::Frontlit;
+        FilamentStack const stack = loadFilamentStackFromJson("testdata/petg_cymk.json", backgroundIndex, mode);
+
+        ThicknessConstraints constraints;
+        constraints.minThickness = 0.0F;
+        constraints.maxThickness = 4.0F;
+        constraints.layerHeight = 0.04F;
+        constraints.totalMaxThickness = 6.0F;
+
+        std::vector<Eigen::Vector3f> const samples = buildHslWheelSamples();
+
+        BenchmarkOutcome const heuristic = benchmarkHeuristicOrder(stack, constraints, mode, backgroundIndex, samples);
+        BenchmarkOutcome const optimized = benchmarkOptimizedOrder(stack, constraints, mode, backgroundIndex, samples);
+        printBenchmarkOutcome("heuristic", heuristic);
+        printBenchmarkOutcome("optimized", optimized);
+
+        EXPECT_LE(optimized.metrics.meanDeltaE, heuristic.metrics.meanDeltaE + 1e-4F);
+        EXPECT_LE(optimized.metrics.meanLinearRgbError, heuristic.metrics.meanLinearRgbError + 1e-4F);
+    }
+
 } // namespace gladius::io::tests
 
diff --git a/gladius/tests/unittests/Importer3mfMerge_test.cpp b/gladius/tests/unittests/Importer3mfMerge_test.cpp
index eec3ffc8..44a84429 100644
--- a/gladius/tests/unittests/Importer3mfMerge_test.cpp
+++ b/gladius/tests/unittests/Importer3mfMerge_test.cpp
@@ -5,6 +5,7 @@
 #include <SpatialMeshResource.h>
 #include <compute/ComputeCore.h>
 #include <io/3mf/Importer3mf.h>
+#include <io/VdbImporter.h>
 
 #include <chrono>
 #include <fmt/core.h>
@@ -58,6 +59,33 @@ namespace gladius_tests
             return tempPath;
         }
 
+          [[nodiscard]] std::filesystem::path createOpenQuad3mf() const
+          {
+            auto sourceDoc = std::make_shared<Document>(m_core);
+            sourceDoc->newEmptyModel();
+
+            vdb::TriangleMesh mesh;
+            mesh.vertices = {
+              openvdb::Vec3s{0.0f, 0.0f, 0.0f},
+              openvdb::Vec3s{10.0f, 0.0f, 0.0f},
+              openvdb::Vec3s{10.0f, 10.0f, 0.0f},
+              openvdb::Vec3s{0.0f, 10.0f, 0.0f},
+            };
+            mesh.indices = {
+              openvdb::Vec3I{0, 1, 2},
+              openvdb::Vec3I{0, 2, 3},
+            };
+
+            sourceDoc->addMeshResource(std::move(mesh), "open quad");
+
+            auto const uniqueSuffix =
+              std::chrono::steady_clock::now().time_since_epoch().count();
+            auto const tempPath = std::filesystem::temp_directory_path() /
+                        fmt::format("gladius_nanovdb_open_quad_{}.3mf", uniqueSuffix);
+            sourceDoc->saveAs(tempPath, false);
+            return tempPath;
+          }
+
         std::shared_ptr<Document> m_doc;
         std::shared_ptr<ComputeCore> m_core;
         events::SharedLogger m_logger;
@@ -254,6 +282,33 @@ namespace gladius_tests
             std::filesystem::remove(tempFile);
         }
 
+        TEST_F(Importer3mfMerge_Test,
+               ImporterLoad_WithOpenNanoVdbMesh_DegradeReportsMeshQualityIssue)
+        {
+            auto const tempFile = createOpenQuad3mf();
+
+            MeshSdfEvaluationConfig meshEvaluationConfig;
+            meshEvaluationConfig.method = MeshSdfMethod::NanoVDB;
+            meshEvaluationConfig.nanovdbVoxelSize_mm = 0.1f;
+
+            io::Importer3mf importer(m_logger);
+            importer.setMeshSdfEvaluationConfig(meshEvaluationConfig);
+            importer.setNanoVdbBuildPolicy(
+              NanoVdbBuildPolicy{0u, NanoVdbFailurePolicy::Degrade});
+
+            m_doc->newEmptyModel();
+            ASSERT_NO_THROW(importer.load(tempFile, *m_doc));
+
+            auto const summary = m_doc->getMeshQualityIssueSummary();
+            EXPECT_TRUE(summary.hasIssue);
+            EXPECT_EQ(summary.affectedMeshCount, 1u);
+            EXPECT_GT(summary.boundaryEdgeCount, 0u);
+            EXPECT_NE(summary.message.find("No repair or fallback was applied silently"),
+                      std::string::npos);
+
+            std::filesystem::remove(tempFile);
+        }
+
         TEST_F(Importer3mfMerge_Test, DocumentLoad_WithNanoVdbHugeMesh_ThrowsRejectedError)
         {
             auto const tempFile = createLargeBox3mf(4000.0f, 4000.0f, 4000.0f);
@@ -268,4 +323,18 @@ namespace gladius_tests
             std::filesystem::remove(tempFile);
         }
 
+    TEST_F(Importer3mfMerge_Test, DocumentLoad_WithNanoVdbOpenMesh_ThrowsRejectedError)
+    {
+      auto const tempFile = createOpenQuad3mf();
+
+      MeshSdfEvaluationConfig meshEvaluationConfig;
+      meshEvaluationConfig.method = MeshSdfMethod::NanoVDB;
+      meshEvaluationConfig.nanovdbVoxelSize_mm = 0.1f;
+      m_doc->setMeshSdfEvaluationConfig(meshEvaluationConfig);
+
+      EXPECT_THROW(m_doc->load(tempFile), NanoVdbBuildRejectedError);
+
+      std::filesystem::remove(tempFile);
+    }
+
 } // namespace gladius_tests
diff --git a/gladius/tests/unittests/MainWindow_tests.cpp b/gladius/tests/unittests/MainWindow_tests.cpp
index e804ed56..08eb7ea7 100644
--- a/gladius/tests/unittests/MainWindow_tests.cpp
+++ b/gladius/tests/unittests/MainWindow_tests.cpp
@@ -414,4 +414,154 @@ namespace gladius::ui::tests
         EXPECT_FALSE(m_logic->shouldShowSaveDialog());
         EXPECT_EQ(m_logic->getPendingOperation(), PendingFileOperation::None);
     }
+
+    /**
+     * @brief Simple test class that mimics MainWindow's Save As overwrite logic
+     */
+    class SaveAsOverwriteLogic
+    {
+      public:
+        void onSaveAsPathSelected(std::filesystem::path const & path, bool fileExists)
+        {
+            m_selectedPath = path;
+            if (fileExists)
+            {
+                m_pendingOverwritePath = path;
+                m_showConfirmation = true;
+            }
+            else
+            {
+                executeSave(path);
+            }
+        }
+
+        void confirmOverwrite()
+        {
+            if (m_pendingOverwritePath)
+            {
+                executeSave(*m_pendingOverwritePath);
+                reset();
+            }
+        }
+
+        std::optional<std::filesystem::path> chooseDifferentName()
+        {
+            auto const path = m_pendingOverwritePath;
+            reset();
+            return path;
+        }
+
+        void cancel()
+        {
+            reset();
+        }
+
+        [[nodiscard]] bool showConfirmation() const { return m_showConfirmation; }
+        [[nodiscard]] std::optional<std::filesystem::path> pendingOverwritePath() const
+        {
+            return m_pendingOverwritePath;
+        }
+        [[nodiscard]] bool wasSaved() const { return m_saved; }
+        [[nodiscard]] std::optional<std::filesystem::path> savedPath() const { return m_savedPath; }
+
+      private:
+        void executeSave(std::filesystem::path const & path)
+        {
+            m_saved = true;
+            m_savedPath = path;
+        }
+
+        void reset()
+        {
+            m_showConfirmation = false;
+            m_pendingOverwritePath.reset();
+        }
+
+        std::filesystem::path m_selectedPath;
+        std::optional<std::filesystem::path> m_pendingOverwritePath;
+        std::optional<std::filesystem::path> m_savedPath;
+        bool m_showConfirmation{false};
+        bool m_saved{false};
+    };
+
+    class MainWindowSaveAsOverwrite_Test : public ::testing::Test
+    {
+      protected:
+        SaveAsOverwriteLogic m_logic;
+    };
+
+    /**
+     * @brief Test that a new path is saved directly without confirmation
+     */
+    TEST_F(MainWindowSaveAsOverwrite_Test, NewPath_DoesNotExist_SavesDirectly)
+    {
+        auto const path = std::filesystem::path{"/test/path/new_model.implicit.3mf"};
+
+        m_logic.onSaveAsPathSelected(path, false);
+
+        EXPECT_TRUE(m_logic.wasSaved());
+        EXPECT_EQ(m_logic.savedPath().value(), path);
+        EXPECT_FALSE(m_logic.showConfirmation());
+    }
+
+    /**
+     * @brief Test that an existing path triggers the overwrite confirmation
+     */
+    TEST_F(MainWindowSaveAsOverwrite_Test, ExistingPath_TriggersConfirmation)
+    {
+        auto const path = std::filesystem::path{"/test/path/existing_model.implicit.3mf"};
+
+        m_logic.onSaveAsPathSelected(path, true);
+
+        EXPECT_FALSE(m_logic.wasSaved());
+        EXPECT_TRUE(m_logic.showConfirmation());
+        EXPECT_EQ(m_logic.pendingOverwritePath().value(), path);
+    }
+
+    /**
+     * @brief Test confirming the overwrite executes the save
+     */
+    TEST_F(MainWindowSaveAsOverwrite_Test, ConfirmOverwrite_ExecutesSave)
+    {
+        auto const path = std::filesystem::path{"/test/path/existing_model.implicit.3mf"};
+        m_logic.onSaveAsPathSelected(path, true);
+
+        m_logic.confirmOverwrite();
+
+        EXPECT_TRUE(m_logic.wasSaved());
+        EXPECT_EQ(m_logic.savedPath().value(), path);
+        EXPECT_FALSE(m_logic.showConfirmation());
+        EXPECT_FALSE(m_logic.pendingOverwritePath().has_value());
+    }
+
+    /**
+     * @brief Test choosing a different name clears the pending state and returns the path
+     */
+    TEST_F(MainWindowSaveAsOverwrite_Test, ChooseDifferentName_ClearsPendingState)
+    {
+        auto const path = std::filesystem::path{"/test/path/existing_model.implicit.3mf"};
+        m_logic.onSaveAsPathSelected(path, true);
+
+        auto const fallback = m_logic.chooseDifferentName();
+
+        EXPECT_FALSE(m_logic.wasSaved());
+        EXPECT_FALSE(m_logic.showConfirmation());
+        EXPECT_FALSE(m_logic.pendingOverwritePath().has_value());
+        EXPECT_EQ(fallback.value(), path);
+    }
+
+    /**
+     * @brief Test cancelling the overwrite dialog aborts the save
+     */
+    TEST_F(MainWindowSaveAsOverwrite_Test, Cancel_DoesNotSave)
+    {
+        auto const path = std::filesystem::path{"/test/path/existing_model.implicit.3mf"};
+        m_logic.onSaveAsPathSelected(path, true);
+
+        m_logic.cancel();
+
+        EXPECT_FALSE(m_logic.wasSaved());
+        EXPECT_FALSE(m_logic.showConfirmation());
+        EXPECT_FALSE(m_logic.pendingOverwritePath().has_value());
+    }
 }
diff --git a/gladius/tests/unittests/MeshBVH_tests.cpp b/gladius/tests/unittests/MeshBVH_tests.cpp
index 5867d50d..a6c4d3e5 100644
--- a/gladius/tests/unittests/MeshBVH_tests.cpp
+++ b/gladius/tests/unittests/MeshBVH_tests.cpp
@@ -53,6 +53,27 @@ namespace gladius::tests
             };
         }
 
+        static void createDuplicateVertexCubeMesh(std::vector<float4> & vertices,
+                                                  std::vector<TriangleIndices> & indices)
+        {
+            std::vector<float4> sharedVertices;
+            std::vector<TriangleIndices> sharedIndices;
+            createCubeMesh(sharedVertices, sharedIndices);
+
+            vertices.clear();
+            indices.clear();
+            vertices.reserve(sharedIndices.size() * 3u);
+            indices.reserve(sharedIndices.size());
+            for (auto const & tri : sharedIndices)
+            {
+                int const base = static_cast<int>(vertices.size());
+                vertices.push_back(sharedVertices[tri.i0]);
+                vertices.push_back(sharedVertices[tri.i1]);
+                vertices.push_back(sharedVertices[tri.i2]);
+                indices.emplace_back(base, base + 1, base + 2);
+            }
+        }
+
         // Helper to create a single triangle
         static void createSingleTriangle(std::vector<float4> & vertices,
                                          std::vector<TriangleIndices> & indices)
@@ -295,6 +316,25 @@ namespace gladius::tests
         EXPECT_EQ(stats.degenerateTriangleCount, 0);
         EXPECT_EQ(stats.boundaryEdgeCount, 0);
         EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
+        EXPECT_FALSE(result.quality.hasIssues());
+    }
+
+    /// Exact duplicate vertex records are common in STL-style triangle soups. They should be
+    /// certified by exact position adjacency without silently modifying the source mesh.
+    TEST_F(MeshBVHBuilder_Test, Build_DuplicateVertexWatertightCube_ReportsCleanStats)
+    {
+        std::vector<float4> vertices;
+        std::vector<TriangleIndices> indices;
+        createDuplicateVertexCubeMesh(vertices, indices);
+
+        auto result = builder.build(vertices, indices);
+        ASSERT_FALSE(result.empty());
+
+        auto const & stats = builder.getLastBuildStats();
+        EXPECT_EQ(stats.degenerateTriangleCount, 0);
+        EXPECT_EQ(stats.boundaryEdgeCount, 0);
+        EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
+        EXPECT_FALSE(result.quality.hasIssues());
     }
 
     /// A degenerate (zero-area) triangle should be counted but must not abort the build.
@@ -318,6 +358,8 @@ namespace gladius::tests
 
         auto const & stats = builder.getLastBuildStats();
         EXPECT_EQ(stats.degenerateTriangleCount, 1);
+        EXPECT_EQ(result.quality.degenerateTriangleCount, 1);
+        EXPECT_TRUE(result.quality.hasIssues());
     }
 
     /// Two triangles sharing a single edge: 5 boundary edges, 1 manifold edge.
@@ -341,6 +383,9 @@ namespace gladius::tests
         auto const & stats = builder.getLastBuildStats();
         EXPECT_EQ(stats.boundaryEdgeCount, 4);   // four outer edges
         EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
+        EXPECT_EQ(result.quality.boundaryEdgeCount, 4);
+        EXPECT_EQ(result.quality.nonManifoldEdgeCount, 0);
+        EXPECT_TRUE(result.quality.hasIssues());
     }
 
     /// Three coplanar triangles sharing one edge → non-manifold edge.
@@ -373,6 +418,8 @@ namespace gladius::tests
         auto const & stats = builder.getLastBuildStats();
         EXPECT_EQ(stats.nonManifoldEdgeCount, 1)
             << "Edge (0,1) is shared by three faces and must be flagged non-manifold";
+        EXPECT_EQ(result.quality.nonManifoldEdgeCount, 1);
+        EXPECT_TRUE(result.quality.hasIssues());
 
         // Verify that the edge entry on the perpendicular fin (tri 2) was NOT
         // assigned a neighbour — only the two coplanar triangles should be
diff --git a/gladius/tests/unittests/MeshFwnBenchmark_tests.cpp b/gladius/tests/unittests/MeshFwnBenchmark_tests.cpp
index 32bf1bff..4dcf25ce 100644
--- a/gladius/tests/unittests/MeshFwnBenchmark_tests.cpp
+++ b/gladius/tests/unittests/MeshFwnBenchmark_tests.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
+#include <numeric>
 #include <chrono>
 #include <cmath>
 #include <cstddef>
diff --git a/gladius/tests/unittests/ResourceDependencyGraph_tests.cpp b/gladius/tests/unittests/ResourceDependencyGraph_tests.cpp
index 325019e8..af8c3271 100644
--- a/gladius/tests/unittests/ResourceDependencyGraph_tests.cpp
+++ b/gladius/tests/unittests/ResourceDependencyGraph_tests.cpp
@@ -73,6 +73,15 @@ namespace gladius_tests
         gladius::events::SharedLogger m_logger;
     };
 
+    Lib3MF::sTransform createIdentityTransform()
+    {
+        Lib3MF::sTransform transform{};
+        transform.m_Fields[0][0] = 1.0f;
+        transform.m_Fields[1][1] = 1.0f;
+        transform.m_Fields[2][2] = 1.0f;
+        return transform;
+    }
+
     TEST_F(ResourceDependencyGraphTest, BuildGraph_EmptyModel_NoVerticesInGraph)
     {
         // Arrange
@@ -130,6 +139,59 @@ namespace gladius_tests
         }
     }
 
+    TEST_F(ResourceDependencyGraphTest,
+           BuildGraph_BooleanObjectDependsOnBaseAndOperandMeshes_DependencyExists)
+    {
+        // Arrange
+        auto baseMesh = m_model->AddMeshObject();
+        auto operandMesh = m_model->AddMeshObject();
+        auto booleanObject = m_model->AddBooleanObject();
+        auto const transform = createIdentityTransform();
+        booleanObject->SetBaseObject(baseMesh.get(), transform);
+        booleanObject->AddOperand(operandMesh.get(), transform);
+
+                io::ResourceDependencyGraph dependencyGraph(m_model, m_logger);
+
+                // Act
+                dependencyGraph.buildGraph();
+
+                // Assert
+                auto const & graph = dependencyGraph.getGraph();
+                EXPECT_TRUE(hasDependency(graph, booleanObject->GetResourceID(), baseMesh->GetResourceID()))
+                    << "Boolean object should depend on its base mesh";
+                EXPECT_TRUE(
+                    hasDependency(graph, booleanObject->GetResourceID(), operandMesh->GetResourceID()))
+                    << "Boolean object should depend on its operand mesh";
+        }
+
+    TEST_F(ResourceDependencyGraphTest,
+           GetAllRequiredResourceIdsForBuildItems_BooleanBuildItem_IncludesMeshes)
+    {
+        // Arrange
+        auto baseMesh = m_model->AddMeshObject();
+        auto operandMesh = m_model->AddMeshObject();
+        auto booleanObject = m_model->AddBooleanObject();
+        auto const transform = createIdentityTransform();
+        booleanObject->SetBaseObject(baseMesh.get(), transform);
+        booleanObject->AddOperand(operandMesh.get(), transform);
+        m_model->AddBuildItem(booleanObject.get(), transform);
+
+                io::ResourceDependencyGraph dependencyGraph(m_model, m_logger);
+
+                // Act
+                dependencyGraph.buildGraph();
+                auto const requiredResourceIds =
+                    dependencyGraph.getAllRequiredResourceIdsForBuildItems();
+
+                // Assert
+                EXPECT_TRUE(requiredResourceIds.count(booleanObject->GetResourceID()) != 0u)
+                    << "Required IDs should include the boolean build item resource";
+                EXPECT_TRUE(requiredResourceIds.count(baseMesh->GetResourceID()) != 0u)
+                    << "Required IDs should include the boolean base mesh";
+                EXPECT_TRUE(requiredResourceIds.count(operandMesh->GetResourceID()) != 0u)
+                    << "Required IDs should include the boolean operand mesh";
+        }
+
     TEST_F(ResourceDependencyGraphTest, BuildGraph_NullModel_GraphRemainsEmpty)
     {
         // Arrange
diff --git a/gladius/tests/unittests/SpatialMeshResource_tests.cpp b/gladius/tests/unittests/SpatialMeshResource_tests.cpp
index 3898ab0d..2c5ed223 100644
--- a/gladius/tests/unittests/SpatialMeshResource_tests.cpp
+++ b/gladius/tests/unittests/SpatialMeshResource_tests.cpp
@@ -158,6 +158,34 @@ namespace gladius::tests
         EXPECT_EQ(resource.getTriangleCount(), 1u);
     }
 
+    TEST_F(SpatialMeshResource_Test, MeshQualityDiagnostics_OpenMesh_ExposesRecoveryMessage)
+    {
+        std::vector<float4> vertices = {
+            {0.f, 0.f, 0.f, 0.f},
+            {1.f, 0.f, 0.f, 0.f},
+            {1.f, 1.f, 0.f, 0.f},
+            {0.f, 1.f, 0.f, 0.f},
+        };
+        std::vector<TriangleIndices> indices = {
+            {0, 1, 2},
+            {0, 2, 3},
+        };
+
+        ResourceKey key(ResourceId{4}, ResourceType::Mesh);
+        SpatialMeshResource resource(key, vertices, indices);
+
+        auto const & diagnostics = resource.getMeshQualityDiagnostics();
+        EXPECT_TRUE(resource.hasMeshQualityIssues());
+        EXPECT_EQ(diagnostics.boundaryEdgeCount, 4);
+        EXPECT_EQ(diagnostics.nonManifoldEdgeCount, 0);
+
+        auto const message = resource.formatMeshQualityMessage("open quad");
+        EXPECT_NE(message.find("open quad"), std::string::npos);
+        EXPECT_NE(message.find("4 boundary edges"), std::string::npos);
+        EXPECT_NE(message.find("No repair or fallback was applied silently"), std::string::npos);
+        EXPECT_NE(message.find("Fast Winding Number"), std::string::npos);
+    }
+
     // ========================================================================
     // Unsigned Distance Validation Tests (T043)
     // ========================================================================
diff --git a/gladius/tests/unittests/Validator_Test.cpp b/gladius/tests/unittests/Validator_Test.cpp
index d6c9d35b..9c9ce6f5 100644
--- a/gladius/tests/unittests/Validator_Test.cpp
+++ b/gladius/tests/unittests/Validator_Test.cpp
@@ -4,6 +4,7 @@
  */
 
 #include <gtest/gtest.h>
+#include "nodes/Assembly.h"
 #include "nodes/Validator.h"
 #include "nodes/IssueList.h"
 
@@ -120,4 +121,30 @@ namespace gladius::tests
         EXPECT_FALSE(getFixSuggestion(IssueType::FunctionNotFound).empty());
     }
 
+    TEST_F(Validator_Test, Validate_FunctionCallReferencesMissingFunction_AddsFunctionNotFoundIssue)
+    {
+        Assembly assembly;
+        constexpr ResourceId callerFunctionId = 10;
+        constexpr ResourceId missingFunctionId = 999;
+
+        assembly.addModelIfNotExisting(callerFunctionId);
+        auto callerModel = assembly.findModel(callerFunctionId);
+        ASSERT_TRUE(callerModel);
+        callerModel->createBeginEnd();
+
+        auto * functionCall = callerModel->create<FunctionCall>();
+        ASSERT_NE(functionCall, nullptr);
+        functionCall->setFunctionId(missingFunctionId);
+
+        Validator validator;
+
+        EXPECT_FALSE(validator.validate(assembly, *m_issueList));
+        ASSERT_EQ(m_issueList->size(), 1u);
+
+        auto issues = m_issueList->getAll();
+        EXPECT_EQ(issues.front().type, IssueType::FunctionNotFound);
+        EXPECT_EQ(issues.front().severity, IssueSeverity::Error);
+        EXPECT_NE(issues.front().message.find("Function reference not found"), std::string::npos);
+    }
+
 } // namespace gladius::tests
diff --git a/gladius/tests/unittests/compute/GpuAccessCoordinator_tests.cpp b/gladius/tests/unittests/compute/GpuAccessCoordinator_tests.cpp
new file mode 100644
index 00000000..6de5d875
--- /dev/null
+++ b/gladius/tests/unittests/compute/GpuAccessCoordinator_tests.cpp
@@ -0,0 +1,269 @@
+#include "compute/GpuAccessCoordinator.h"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace gladius::tests
+{
+    namespace
+    {
+        [[nodiscard]] bool containsEvent(std::vector<GpuEventId> const & events,
+                                         GpuEventId const eventId)
+        {
+            return std::find(events.begin(), events.end(), eventId) != events.end();
+        }
+
+        [[nodiscard]] GpuAccessPlan beginRead(GpuAccessCoordinator & coordinator,
+                                              GpuResourceHandle resource,
+                                              GpuQueueId queueId = 1u,
+                                              std::string operationName = "read")
+        {
+            return coordinator.beginAccess(GpuAccessRequest{.resource = resource,
+                                                            .queueId = queueId,
+                                                            .mode = GpuAccessMode::Read,
+                                                            .operationName = std::move(operationName)});
+        }
+
+        [[nodiscard]] GpuAccessPlan beginWrite(GpuAccessCoordinator & coordinator,
+                                               GpuResourceHandle resource,
+                                               GpuQueueId queueId = 1u,
+                                               std::string operationName = "write")
+        {
+            return coordinator.beginAccess(GpuAccessRequest{.resource = resource,
+                                                            .queueId = queueId,
+                                                            .mode = GpuAccessMode::Write,
+                                                            .operationName = std::move(operationName)});
+        }
+
+        void complete(GpuAccessCoordinator & coordinator,
+                      GpuAccessPlan const & plan,
+                      GpuEventId eventId)
+        {
+            ASSERT_TRUE(plan.granted());
+            EXPECT_EQ(coordinator.completeAccess(plan.token, eventId), GpuAccessStatus::Granted);
+        }
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_ReadAfterWrite_ReturnsWriterDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "parameter buffer");
+        auto const write = beginWrite(coordinator, resource, 1u, "upload parameters");
+        complete(coordinator, write, 10u);
+
+        auto const read = beginRead(coordinator, resource, 2u, "render reads parameters");
+
+        ASSERT_TRUE(read.granted());
+        ASSERT_EQ(read.waitEvents.size(), 1u);
+        EXPECT_EQ(read.waitEvents.front(), 10u);
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_WriteAfterRead_ReturnsAllReaderDependencies)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Image3D, "precomputed sdf");
+        auto const previewRead = beginRead(coordinator, resource, 1u, "preview samples sdf");
+        complete(coordinator, previewRead, 11u);
+        auto const hqRead = beginRead(coordinator, resource, 2u, "hq render samples sdf");
+        complete(coordinator, hqRead, 12u);
+
+        auto const sdfWrite = beginWrite(coordinator, resource, 3u, "recompute sdf");
+
+        ASSERT_TRUE(sdfWrite.granted());
+        ASSERT_EQ(sdfWrite.waitEvents.size(), 2u);
+        EXPECT_TRUE(containsEvent(sdfWrite.waitEvents, 11u));
+        EXPECT_TRUE(containsEvent(sdfWrite.waitEvents, 12u));
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_ReadAfterRead_ReturnsNoDependencies)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "primitive payload");
+        auto const firstRead = beginRead(coordinator, resource, 1u, "preview render");
+        complete(coordinator, firstRead, 21u);
+
+        auto const secondRead = beginRead(coordinator, resource, 2u, "hq render");
+
+        ASSERT_TRUE(secondRead.granted());
+        EXPECT_TRUE(secondRead.waitEvents.empty());
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_WriteAfterWrite_ReturnsPreviousWriterDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "command buffer");
+        auto const firstWrite = beginWrite(coordinator, resource, 1u, "build command stream");
+        complete(coordinator, firstWrite, 31u);
+
+        auto const secondWrite = beginWrite(coordinator, resource, 2u, "rebuild command stream");
+
+        ASSERT_TRUE(secondWrite.granted());
+        ASSERT_EQ(secondWrite.waitEvents.size(), 1u);
+        EXPECT_EQ(secondWrite.waitEvents.front(), 31u);
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_AfterEventCompleted_ReturnsNoDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "metrics buffer");
+        auto const write = beginWrite(coordinator, resource, 1u, "clear metrics");
+        complete(coordinator, write, 41u);
+        coordinator.markEventCompleted(41u);
+
+        auto const read = beginRead(coordinator, resource, 2u, "read metrics");
+
+        ASSERT_TRUE(read.granted());
+        EXPECT_TRUE(read.waitEvents.empty());
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_WithUnknownResource_ReturnsUnknownResource)
+    {
+        GpuAccessCoordinator coordinator;
+
+        auto const read = beginRead(coordinator,
+                                    GpuResourceHandle{.resourceId = 404u, .generation = 1u},
+                                    1u,
+                                    "read missing resource");
+
+        EXPECT_EQ(read.status, GpuAccessStatus::UnknownResource);
+        EXPECT_FALSE(read.granted());
+    }
+
+    TEST(GpuAccessCoordinator, CompleteAccess_WithSameTokenTwice_ReturnsUnknownAccessToken)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "parameter buffer");
+        auto const write = beginWrite(coordinator, resource, 1u, "upload parameters");
+        ASSERT_TRUE(write.granted());
+
+        EXPECT_EQ(coordinator.completeAccess(write.token, 42u), GpuAccessStatus::Granted);
+        EXPECT_EQ(coordinator.completeAccess(write.token, 43u), GpuAccessStatus::UnknownAccessToken);
+    }
+
+    TEST(GpuAccessCoordinator, IsIdle_WithOutstandingThenCompletedEvent_TracksState)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "command buffer");
+        auto const write = beginWrite(coordinator, resource, 1u, "write commands");
+        complete(coordinator, write, 44u);
+
+        EXPECT_FALSE(coordinator.isIdle(resource));
+
+        coordinator.markEventCompleted(44u);
+
+        EXPECT_TRUE(coordinator.isIdle(resource));
+        EXPECT_TRUE(coordinator.outstandingEvents(resource).empty());
+    }
+
+    TEST(GpuAccessCoordinator, MarkEventsCompleted_WithHostWait_ClearsOutstandingAccesses)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Image2D, "distance init");
+        auto const preview = beginWrite(coordinator, resource, 1u, "preview distance output");
+        complete(coordinator, preview, 45u);
+        ASSERT_EQ(coordinator.outstandingEvents(resource).size(), 1u);
+
+        coordinator.markEventsCompleted({45u});
+
+        auto const hqRead = beginRead(coordinator, resource, 2u, "hq distance init render");
+        ASSERT_TRUE(hqRead.granted());
+        EXPECT_TRUE(hqRead.waitEvents.empty());
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_WriteWhileReadTokenPending_ReturnsPendingAccessWithoutEvent)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Buffer, "primitive payload");
+        auto const read = beginRead(coordinator, resource, 1u, "render reads payload");
+        ASSERT_TRUE(read.granted());
+
+        auto const write = beginWrite(coordinator, resource, 2u, "mesh cache build writes payload");
+
+        EXPECT_EQ(write.status, GpuAccessStatus::PendingAccessWithoutEvent);
+        EXPECT_FALSE(write.granted());
+    }
+
+    TEST(GpuAccessCoordinator, RetireCurrentGeneration_WithOutstandingWriter_KeepsGenerationUntilEventCompletes)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const resource = coordinator.registerResource(GpuResourceKind::Image3D, "precomputed sdf");
+        auto const write = beginWrite(coordinator, resource, 1u, "write sdf generation");
+        complete(coordinator, write, 51u);
+
+        auto const retirement = coordinator.retireCurrentGeneration(resource.resourceId);
+
+        ASSERT_TRUE(retirement.granted());
+        EXPECT_FALSE(retirement.canReleaseImmediately());
+        ASSERT_EQ(retirement.waitEvents.size(), 1u);
+        EXPECT_EQ(retirement.waitEvents.front(), 51u);
+        EXPECT_EQ(coordinator.retiredGenerationCount(resource.resourceId), 1u);
+
+        coordinator.collectCompletedRetirements();
+        EXPECT_EQ(coordinator.retiredGenerationCount(resource.resourceId), 1u);
+
+        coordinator.markEventCompleted(51u);
+        coordinator.collectCompletedRetirements();
+        EXPECT_EQ(coordinator.retiredGenerationCount(resource.resourceId), 0u);
+    }
+
+    TEST(GpuAccessCoordinator, BeginAccess_WithRetiredGeneration_ReturnsStaleGeneration)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const oldGeneration = coordinator.registerResource(GpuResourceKind::Image2D, "low res preview");
+        auto const retirement = coordinator.retireCurrentGeneration(oldGeneration.resourceId);
+        ASSERT_TRUE(retirement.granted());
+
+        auto const staleRead = beginRead(coordinator, oldGeneration, 1u, "stale preview resample");
+
+        EXPECT_EQ(staleRead.status, GpuAccessStatus::StaleGeneration);
+        EXPECT_FALSE(staleRead.granted());
+    }
+
+    TEST(GpuAccessCoordinator, Workflow_SdfPrecomputeBeforePreviewRender_AddsSdfDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const sdf = coordinator.registerResource(GpuResourceKind::Image3D, "precomputed sdf");
+        auto const precompute = beginWrite(coordinator, sdf, 1u, "preComputeSdf");
+        complete(coordinator, precompute, 61u);
+
+        auto const preview = beginRead(coordinator, sdf, 2u, "renderLowResPreview");
+
+        ASSERT_TRUE(preview.granted());
+        ASSERT_EQ(preview.waitEvents.size(), 1u);
+        EXPECT_EQ(preview.waitEvents.front(), 61u);
+    }
+
+    TEST(GpuAccessCoordinator, Workflow_MeshCacheBuildBeforeRender_AddsPrimitivePayloadDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const primitivePayload =
+          coordinator.registerResource(GpuResourceKind::Buffer, "Primitives::data");
+        auto const cacheBuild = beginWrite(coordinator, primitivePayload, 1u, "buildMeshSignCache");
+        complete(coordinator, cacheBuild, 71u);
+
+        auto const render = beginRead(coordinator, primitivePayload, 2u, "renderScene");
+
+        ASSERT_TRUE(render.granted());
+        ASSERT_EQ(render.waitEvents.size(), 1u);
+        EXPECT_EQ(render.waitEvents.front(), 71u);
+    }
+
+    TEST(GpuAccessCoordinator, Workflow_DistanceInitPreviewBeforeHqRender_AddsPreviewDependency)
+    {
+        GpuAccessCoordinator coordinator;
+        auto const distanceInit =
+          coordinator.registerResource(GpuResourceKind::Image2D, "distance init buffer");
+        auto const preview = beginWrite(coordinator, distanceInit, 1u, "preview distance output");
+        complete(coordinator, preview, 81u);
+
+        auto const hqRender = beginRead(coordinator, distanceInit, 2u, "hq distance init render");
+
+        ASSERT_TRUE(hqRender.granted());
+        ASSERT_EQ(hqRender.waitEvents.size(), 1u);
+        EXPECT_EQ(hqRender.waitEvents.front(), 81u);
+    }
+}
diff --git a/gladius/tests/unittests/io/3mf/OpenVdbShellGenerator_tests.cpp b/gladius/tests/unittests/io/3mf/OpenVdbShellGenerator_tests.cpp
new file mode 100644
index 00000000..05eacf0f
--- /dev/null
+++ b/gladius/tests/unittests/io/3mf/OpenVdbShellGenerator_tests.cpp
@@ -0,0 +1,65 @@
+#include <gtest/gtest.h>
+
+#include "io/3mf/OpenVdbShellGenerator.h"
+
+namespace gladius::io::tests
+{
+    TEST(OpenVdbShellGenerator_Test, EvaluateShellSignedDistance_IsPositiveOutsideModel)
+    {
+        ShellLayerDepthInterval interval;
+        interval.layerIndex = 0U;
+        interval.outerDepth = 0.2F;
+        interval.innerDepth = 0.6F;
+
+        EXPECT_GT(OpenVdbShellGenerator::evaluateShellSignedDistance(0.1F, interval), 0.0F);
+        EXPECT_FLOAT_EQ(OpenVdbShellGenerator::evaluateShellSignedDistance(-0.2F, interval), 0.0F);
+    }
+
+    TEST(OpenVdbShellGenerator_Test, EvaluateShellSignedDistance_IsNegativeInsideShellBand)
+    {
+        ShellLayerDepthInterval interval;
+        interval.layerIndex = 1U;
+        interval.outerDepth = 0.2F;
+        interval.innerDepth = 0.6F;
+
+        EXPECT_LT(OpenVdbShellGenerator::evaluateShellSignedDistance(-0.35F, interval), 0.0F);
+        EXPECT_LT(OpenVdbShellGenerator::evaluateShellSignedDistance(-0.6F + 1e-4F, interval), 0.0F);
+    }
+
+    TEST(OpenVdbShellGenerator_Test, EvaluateShellSignedDistance_IsPositiveDeeperThanInnerBoundary)
+    {
+        ShellLayerDepthInterval interval;
+        interval.layerIndex = 2U;
+        interval.outerDepth = 0.2F;
+        interval.innerDepth = 0.6F;
+
+        EXPECT_FLOAT_EQ(OpenVdbShellGenerator::evaluateShellSignedDistance(-0.6F, interval), 0.0F);
+        EXPECT_GT(OpenVdbShellGenerator::evaluateShellSignedDistance(-0.8F, interval), 0.0F);
+    }
+
+    TEST(OpenVdbShellGenerator_Test, EvaluateVariableShellSignedDistance_IsNegativeInsideVariableBand)
+    {
+        EXPECT_LT(OpenVdbShellGenerator::evaluateVariableShellSignedDistance(
+                      -0.35F,
+                      0.2F,
+                      0.6F,
+                      false),
+                  0.0F);
+    }
+
+    TEST(OpenVdbShellGenerator_Test, EvaluateVariableShellSignedDistance_InnermostUsesOnlyOuterBoundary)
+    {
+        EXPECT_FLOAT_EQ(OpenVdbShellGenerator::evaluateVariableShellSignedDistance(
+                            -0.2F,
+                            0.2F,
+                            0.7F,
+                            true),
+                        0.0F);
+        EXPECT_LT(OpenVdbShellGenerator::evaluateVariableShellSignedDistance(
+                      -0.5F,
+                      0.2F,
+                      0.7F,
+                      true),
+                  0.0F);
+    }
+} // namespace gladius::io::tests
diff --git a/gladius/tests/unittests/io/3mf/SaveSnapshot_tests.cpp b/gladius/tests/unittests/io/3mf/SaveSnapshot_tests.cpp
new file mode 100644
index 00000000..32296b11
--- /dev/null
+++ b/gladius/tests/unittests/io/3mf/SaveSnapshot_tests.cpp
@@ -0,0 +1,70 @@
+#include "EventLogger.h"
+#include "io/3mf/Lib3mfLoader.h"
+#include "io/3mf/SaveSnapshot.h"
+#include "io/3mf/Writer3mf.h"
+
+#include <gtest/gtest.h>
+
+#include <filesystem>
+#include <memory>
+#include <vector>
+
+namespace gladius_tests
+{
+
+    size_t countResources(Lib3MF::PModel const & model)
+    {
+        auto resources = model->GetResources();
+        size_t count = 0;
+        while (resources->MoveNext())
+        {
+            ++count;
+        }
+        return count;
+    }
+
+    TEST(SaveSnapshotTest, Lib3mfWorkingCopy_IsIndependentFromSource)
+    {
+        auto wrapper = gladius::io::loadLib3mfScoped();
+        auto source = wrapper->CreateModel();
+        source->AddImplicitFunction();
+
+        auto sourceWriter = source->QueryWriter("3mf");
+        std::vector<Lib3MF_uint8> buffer;
+        sourceWriter->WriteToBuffer(buffer);
+
+        auto copy = wrapper->CreateModel();
+        auto copyReader = copy->QueryReader("3mf");
+        copyReader->ReadFromBuffer(buffer);
+
+        auto const sourceCount = countResources(source);
+        copy->AddImplicitFunction();
+
+        EXPECT_EQ(countResources(source), sourceCount);
+        EXPECT_GT(countResources(copy), sourceCount);
+    }
+
+    TEST(SaveSnapshotTest, Writer_UsesSnapshotAssemblyAndModel)
+    {
+        auto wrapper = gladius::io::loadLib3mfScoped();
+        auto model = wrapper->CreateModel();
+        auto assembly = std::make_shared<gladius::nodes::Assembly>();
+        assembly->assemblyModel()->createValidVoid();
+
+        gladius::io::SaveSnapshot snapshot;
+        snapshot.assembly = assembly;
+        snapshot.model = model;
+
+        auto const output = std::filesystem::temp_directory_path() / "gladius_snapshot_test.3mf";
+        auto logger = std::make_shared<gladius::events::Logger>(
+          gladius::events::OutputMode::Console);
+        gladius::io::Writer3mf writer(logger);
+
+        ASSERT_TRUE(writer.save(output, snapshot, false));
+        EXPECT_TRUE(std::filesystem::exists(output));
+        EXPECT_GT(std::filesystem::file_size(output), 0U);
+
+        std::filesystem::remove(output);
+    }
+
+} // namespace gladius_tests
diff --git a/gladius/tests/unittests/io/3mf/ShellMaterialOrdering_tests.cpp b/gladius/tests/unittests/io/3mf/ShellMaterialOrdering_tests.cpp
new file mode 100644
index 00000000..ced48988
--- /dev/null
+++ b/gladius/tests/unittests/io/3mf/ShellMaterialOrdering_tests.cpp
@@ -0,0 +1,138 @@
+#include "io/3mf/ShellMaterialOrdering.h"
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+namespace gladius::io::tests
+{
+    TEST(ShellMaterialOrdering_Test, ReorderForShells_MovesBackgroundToInnermost)
+    {
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"OuterCandidate", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{1.0F, 1.0F, 1.0F}});
+        stack.push_back(FilamentOpticalProperties{"Background", Eigen::Vector3f::Zero(), 0.8F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"Middle", Eigen::Vector3f::UnitX(), 0.6F, 0.4F, Eigen::Vector3f{2.0F, 2.0F, 2.0F}});
+
+        auto ordered = ShellMaterialOrdering::reorderForShells(stack, 1U, IlluminationMode::Frontlit);
+
+        ASSERT_EQ(ordered.stack.size(), 3U);
+        EXPECT_EQ(ordered.backgroundIndex, 0U);
+        EXPECT_EQ(ordered.stack[0].name, "Background");
+        EXPECT_EQ(ordered.orderedToOriginal[0], 1U);
+    }
+
+    TEST(ShellMaterialOrdering_Test, ReorderForShells_FrontlitSortsRemainingByAscendingTranslucency)
+    {
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"LeastTranslucent", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"MostTranslucent", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{3.0F, 3.0F, 3.0F}});
+        stack.push_back(FilamentOpticalProperties{"MediumTranslucent", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{1.5F, 1.5F, 1.5F}});
+
+        auto ordered = ShellMaterialOrdering::reorderForShells(
+            stack,
+            std::numeric_limits<std::size_t>::max(),
+            IlluminationMode::Frontlit);
+
+        ASSERT_EQ(ordered.stack.size(), 3U);
+        EXPECT_EQ(ordered.stack[0].name, "LeastTranslucent");
+        EXPECT_EQ(ordered.stack[1].name, "MediumTranslucent");
+        EXPECT_EQ(ordered.stack[2].name, "MostTranslucent");
+    }
+
+    TEST(ShellMaterialOrdering_Test, ReorderForShells_BacklitPreservesRemainingOrder)
+    {
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"Background", Eigen::Vector3f::Zero(), 0.8F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"First", Eigen::Vector3f::UnitX(), 0.5F, 0.4F, Eigen::Vector3f{3.0F, 3.0F, 3.0F}});
+        stack.push_back(FilamentOpticalProperties{"Second", Eigen::Vector3f::UnitY(), 0.5F, 0.4F, Eigen::Vector3f{1.0F, 1.0F, 1.0F}});
+
+        auto ordered = ShellMaterialOrdering::reorderForShells(stack, 0U, IlluminationMode::Backlit);
+
+        ASSERT_EQ(ordered.stack.size(), 3U);
+        EXPECT_EQ(ordered.stack[0].name, "Background");
+        EXPECT_EQ(ordered.stack[1].name, "First");
+        EXPECT_EQ(ordered.stack[2].name, "Second");
+    }
+
+    TEST(ShellMaterialOrdering_Test, OptimizeGlobalOrderForShells_FindsBestPermutationForSmallFrontlitStack)
+    {
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"Background", Eigen::Vector3f::Zero(), 0.8F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"A", Eigen::Vector3f::UnitX(), 0.5F, 0.4F, Eigen::Vector3f{3.0F, 3.0F, 3.0F}});
+        stack.push_back(FilamentOpticalProperties{"B", Eigen::Vector3f::UnitY(), 0.5F, 0.4F, Eigen::Vector3f{1.0F, 1.0F, 1.0F}});
+        stack.push_back(FilamentOpticalProperties{"C", Eigen::Vector3f::UnitZ(), 0.5F, 0.4F, Eigen::Vector3f{2.0F, 2.0F, 2.0F}});
+
+        auto ordered = ShellMaterialOrdering::optimizeGlobalOrderForShells(
+            stack,
+            0U,
+            IlluminationMode::Frontlit,
+            [](FilamentStack const& candidate, std::size_t backgroundIdx) {
+                std::string signature = candidate[backgroundIdx + 1U].name + candidate[backgroundIdx + 2U].name + candidate[backgroundIdx + 3U].name;
+                return (signature == "CAB") ? 0.0F : 10.0F;
+            });
+
+        ASSERT_EQ(ordered.stack.size(), 4U);
+        EXPECT_EQ(ordered.backgroundIndex, 0U);
+        EXPECT_EQ(ordered.stack[0].name, "Background");
+        EXPECT_EQ(ordered.stack[1].name, "C");
+        EXPECT_EQ(ordered.stack[2].name, "A");
+        EXPECT_EQ(ordered.stack[3].name, "B");
+    }
+
+    TEST(ShellMaterialOrdering_Test, OptimizeGlobalOrderForPalette_FallsBackToHeuristicForEmptyPalette)
+    {
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"Background", Eigen::Vector3f::Zero(), 0.8F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"LeastTranslucent", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"MostTranslucent", Eigen::Vector3f::Ones(), 0.5F, 0.4F, Eigen::Vector3f{3.0F, 3.0F, 3.0F}});
+
+        ThicknessConstraints constraints;
+        std::vector<Eigen::Vector3f> const emptyPalette;
+
+        auto ordered = ShellMaterialOrdering::optimizeGlobalOrderForPalette(
+            stack,
+            0U,
+            IlluminationMode::Frontlit,
+            constraints,
+            emptyPalette);
+
+        ASSERT_EQ(ordered.stack.size(), 3U);
+        EXPECT_EQ(ordered.backgroundIndex, 0U);
+        EXPECT_EQ(ordered.stack[0].name, "Background");
+        EXPECT_EQ(ordered.stack[1].name, "LeastTranslucent");
+        EXPECT_EQ(ordered.stack[2].name, "MostTranslucent");
+    }
+
+    TEST(ShellMaterialOrdering_Test, OptimizeGlobalOrderForPalette_PicksLowerErrorOrderForKnownPalette)
+    {
+        // Two printable layers over a background. The palette is pure red.
+        // Layer "Red" has a red reflectance; layer "Cyan" has a cyan reflectance.
+        // The optimizer should prefer the order that lets the red layer sit closer
+        // to the visible surface for the red-dominant target.
+        FilamentStack stack;
+        stack.push_back(FilamentOpticalProperties{"Background", Eigen::Vector3f::Zero(), 0.8F, 0.4F, Eigen::Vector3f{0.5F, 0.5F, 0.5F}});
+        stack.push_back(FilamentOpticalProperties{"Cyan", Eigen::Vector3f{0.1F, 0.7F, 0.8F}, 0.5F, 0.4F, Eigen::Vector3f{2.0F, 2.0F, 2.0F}});
+        stack.push_back(FilamentOpticalProperties{"Red", Eigen::Vector3f{0.9F, 0.1F, 0.1F}, 0.5F, 0.4F, Eigen::Vector3f{2.0F, 2.0F, 2.0F}});
+
+        ThicknessConstraints constraints;
+        constraints.minThickness = 0.0F;
+        constraints.maxThickness = 4.0F;
+
+        std::vector<Eigen::Vector3f> const palette = {Eigen::Vector3f{0.9F, 0.1F, 0.1F}};
+
+        auto ordered = ShellMaterialOrdering::optimizeGlobalOrderForPalette(
+            stack,
+            0U,
+            IlluminationMode::Frontlit,
+            constraints,
+            palette);
+
+        ASSERT_EQ(ordered.stack.size(), 3U);
+        EXPECT_EQ(ordered.backgroundIndex, 0U);
+        EXPECT_EQ(ordered.stack[0].name, "Background");
+
+        // The red layer should be the outermost printable layer so it can dominate
+        // the visible color for a red target.
+        EXPECT_EQ(ordered.stack[2].name, "Red");
+    }
+} // namespace gladius::io::tests
diff --git a/gladius/tests/unittests/io/3mf/ShellThicknessPartition_tests.cpp b/gladius/tests/unittests/io/3mf/ShellThicknessPartition_tests.cpp
new file mode 100644
index 00000000..68be883e
--- /dev/null
+++ b/gladius/tests/unittests/io/3mf/ShellThicknessPartition_tests.cpp
@@ -0,0 +1,74 @@
+#include <gtest/gtest.h>
+
+#include "io/3mf/ShellThicknessPartition.h"
+
+namespace gladius::io::tests
+{
+    TEST(ShellThicknessPartition_Test, BuildIntervals_OrdersShellsFromOuterToInner)
+    {
+        ThicknessSolution solution(3);
+        solution.thicknesses[0] = 1.5F; // bottom
+        solution.thicknesses[1] = 0.5F;
+        solution.thicknesses[2] = 0.25F; // top
+
+        auto const intervals = ShellThicknessPartition::buildIntervals(solution);
+
+        ASSERT_EQ(intervals.size(), 3U);
+
+        EXPECT_EQ(intervals[0].layerIndex, 2U);
+        EXPECT_FLOAT_EQ(intervals[0].outerDepth, 0.0F);
+        EXPECT_FLOAT_EQ(intervals[0].innerDepth, 0.25F);
+
+        EXPECT_EQ(intervals[1].layerIndex, 1U);
+        EXPECT_FLOAT_EQ(intervals[1].outerDepth, 0.25F);
+        EXPECT_FLOAT_EQ(intervals[1].innerDepth, 0.75F);
+
+        EXPECT_EQ(intervals[2].layerIndex, 0U);
+        EXPECT_FLOAT_EQ(intervals[2].outerDepth, 0.75F);
+        EXPECT_FLOAT_EQ(intervals[2].innerDepth, 2.25F);
+    }
+
+    TEST(ShellThicknessPartition_Test, BuildIntervals_SkipsZeroThicknessLayers)
+    {
+        std::vector<float> const thicknesses{1.0F, 0.0F, 0.5F, 0.0F};
+
+        auto const intervals = ShellThicknessPartition::buildIntervals(thicknesses);
+
+        ASSERT_EQ(intervals.size(), 2U);
+        EXPECT_EQ(intervals[0].layerIndex, 2U);
+        EXPECT_EQ(intervals[1].layerIndex, 0U);
+        EXPECT_FLOAT_EQ(intervals[1].outerDepth, 0.5F);
+        EXPECT_FLOAT_EQ(intervals[1].innerDepth, 1.5F);
+    }
+
+    TEST(ShellThicknessPartition_Test, ComputeMaxDepth_ReturnsSumOfPositiveThicknesses)
+    {
+        std::vector<float> const thicknesses{0.4F, 0.0F, 0.6F, 1.2F};
+
+        float const maxDepth = ShellThicknessPartition::computeMaxDepth(thicknesses);
+
+        EXPECT_FLOAT_EQ(maxDepth, 2.2F);
+    }
+
+    TEST(ShellThicknessPartition_Test, BuildIntervals_WithNegativeThickness_Throws)
+    {
+        std::vector<float> const thicknesses{0.4F, -0.1F, 0.3F};
+
+        EXPECT_THROW(static_cast<void>(ShellThicknessPartition::buildIntervals(thicknesses)),
+                     std::runtime_error);
+        EXPECT_THROW(static_cast<void>(ShellThicknessPartition::computeMaxDepth(thicknesses)),
+                     std::runtime_error);
+    }
+
+    TEST(ShellThicknessPartition_Test, IntervalThickness_AndEmptyState_AreConsistent)
+    {
+        ShellLayerDepthInterval interval;
+        interval.layerIndex = 1U;
+        interval.outerDepth = 1.0F;
+        interval.innerDepth = 1.0F + 1e-7F;
+
+        EXPECT_NEAR(interval.thickness(), 1e-7F, 3e-8F);
+        EXPECT_TRUE(interval.isEmpty());
+        EXPECT_FALSE(interval.isEmpty(1e-8F));
+    }
+} // namespace gladius::io::tests
diff --git a/gladius/tests/unittests/testdata/petg_cymk.json b/gladius/tests/unittests/testdata/petg_cymk.json
new file mode 100644
index 00000000..2db70442
--- /dev/null
+++ b/gladius/tests/unittests/testdata/petg_cymk.json
@@ -0,0 +1,43 @@
+{
+  "backgroundIndex": 3,
+  "illuminationMode": "frontlit",
+  "lutResolution": 16,
+  "materials": [
+    {
+      "name": "SUNLU PETG Cyan",
+      "reflectanceColor": [
+        0.239215686917305,
+        0.7764706015586853,
+        0.9098039269447327
+      ],
+      "transmissionDistance": 6.099999904632568
+    },
+    {
+      "name": "SUNLU PETG Magenta",
+      "reflectanceColor": [
+        0.729411780834198,
+        0.09803921729326248,
+        0.4627451002597809
+      ],
+      "transmissionDistance": 3.799999952316284
+    },
+    {
+      "name": "SUNLU PETG Yellow",
+      "reflectanceColor": [
+        1.0,
+        1.0,
+        0.501960813999176
+      ],
+      "transmissionDistance": 4.0
+    },
+    {
+      "name": "SUNLU PETG White",
+      "reflectanceColor": [
+        1.0,
+        1.0,
+        1.0
+      ],
+      "transmissionDistance": 6.199999809265137
+    }
+  ]
+}
\ No newline at end of file
diff --git a/gladius/tests/unittests/ui/OrbitalCamera_tests.cpp b/gladius/tests/unittests/ui/OrbitalCamera_tests.cpp
new file mode 100644
index 00000000..783d33d9
--- /dev/null
+++ b/gladius/tests/unittests/ui/OrbitalCamera_tests.cpp
@@ -0,0 +1,52 @@
+#include "ui/OrbitalCamera.h"
+
+#include <gtest/gtest.h>
+
+#include <cmath>
+
+namespace gladius::ui::tests
+{
+    namespace
+    {
+        [[nodiscard]] float distance(cl_float3 const & lhs, cl_float3 const & rhs)
+        {
+            float const dx = lhs.x - rhs.x;
+            float const dy = lhs.y - rhs.y;
+            float const dz = lhs.z - rhs.z;
+            return std::sqrt(dx * dx + dy * dy + dz * dz);
+        }
+    }
+
+    TEST(OrbitalCamera_Update, WithPendingZoom_InterpolatesTowardTargetDistance)
+    {
+        OrbitalCamera camera;
+        camera.snapToTarget();
+
+        float const initialDistance = distance(camera.getEyePosition(), camera.getLookAt());
+
+        camera.zoom(-0.5f);
+
+        float const distanceBeforeUpdate = distance(camera.getEyePosition(), camera.getLookAt());
+        EXPECT_NEAR(distanceBeforeUpdate, initialDistance, 1e-3f);
+
+        EXPECT_TRUE(camera.update(16.f));
+
+        float const distanceAfterUpdate = distance(camera.getEyePosition(), camera.getLookAt());
+        EXPECT_LT(distanceAfterUpdate, initialDistance);
+        EXPECT_GT(distanceAfterUpdate, initialDistance * 0.5f);
+    }
+
+    TEST(OrbitalCamera_SnapToTarget, WithPendingZoom_AppliesTargetDistance)
+    {
+        OrbitalCamera camera;
+        camera.snapToTarget();
+
+        float const initialDistance = distance(camera.getEyePosition(), camera.getLookAt());
+
+        camera.zoom(-0.5f);
+        camera.snapToTarget();
+
+        float const snappedDistance = distance(camera.getEyePosition(), camera.getLookAt());
+        EXPECT_NEAR(snappedDistance, initialDistance * 0.5f, 1e-3f);
+    }
+}
\ No newline at end of file
diff --git a/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp b/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp
new file mode 100644
index 00000000..d3f8e08a
--- /dev/null
+++ b/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp
@@ -0,0 +1,230 @@
+#include "ui/render/RealtimeRaymarchController.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] RealtimeRaymarchConfig makeTestConfig()
+        {
+            RealtimeRaymarchConfig config{};
+            config.targetFrameTimeMs = 25.0f;
+            config.requiredFastSamples = 3;
+            config.maxSlowSamples = 2;
+            config.cooldownFrames = 4;
+            config.ewmaAlpha = 1.0f;
+            return config;
+        }
+
+        [[nodiscard]] RealtimeRaymarchSample makeFullFrameSample(float durationMs)
+        {
+            return RealtimeRaymarchSample{.durationMs = durationMs,
+                                          .width = 800,
+                                          .height = 600,
+                                          .renderedLines = 600,
+                                          .totalLines = 600,
+                                          .completedFrame = true,
+                                          .cancelled = false};
+        }
+
+        [[nodiscard]] RealtimeRaymarchSample makeProgressiveChunkSample(float durationMs)
+        {
+            return RealtimeRaymarchSample{.durationMs = durationMs,
+                                          .width = 800,
+                                          .height = 600,
+                                          .renderedLines = 60,
+                                          .totalLines = 600,
+                                          .completedFrame = false,
+                                          .cancelled = false};
+        }
+
+        [[nodiscard]] RealtimeRaymarchGuards makeOpenGuards()
+        {
+            return RealtimeRaymarchGuards{};
+        }
+    }
+
+    TEST(RealtimeRaymarchController, RecordFastSamples_EnablesRealtime)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(19.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(20.0f));
+
+        EXPECT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
+        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 20.0f);
+    }
+
+    TEST(RealtimeRaymarchController, InteractiveSlowSample_DeactivatesRealtime)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        ASSERT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+
+        controller.recordInteractiveRealtimeSample(makeFullFrameSample(120.0f));
+
+        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchController, BeginFrame_CountsDownCooldown)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordRejectedAttempt();
+        controller.recordRejectedAttempt();
+        ASSERT_TRUE(controller.isCoolingDown());
+
+        controller.beginFrame();
+        controller.beginFrame();
+        controller.beginFrame();
+        EXPECT_TRUE(controller.isCoolingDown());
+
+        controller.beginFrame();
+        EXPECT_FALSE(controller.isCoolingDown());
+    }
+
+    TEST(RealtimeRaymarchController, RecordChunkSample_EstimatesFullFrameTime)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        RealtimeRaymarchSample sample{};
+        sample.durationMs = 2.0f;
+        sample.width = 800;
+        sample.height = 600;
+        sample.renderedLines = 60;
+        sample.totalLines = 600;
+        sample.completedFrame = false;
+
+        controller.recordStaticProgressiveSample(sample);
+
+        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
+        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 20.0f);
+        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchController, AutoLearning_CanAttemptStaticFullFrameAfterFastProgressiveSample)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+        controller.resetForResolution(800, 600);
+
+        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
+
+        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+
+        auto blockedGuards = makeOpenGuards();
+        blockedGuards.renderJobInFlight = true;
+        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, blockedGuards));
+    }
+
+    TEST(RealtimeRaymarchController, SlowProgressiveSample_DoesNotEnableStaticFullFrame)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(10.0f));
+
+        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
+        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 100.0f);
+        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchController, SlowProgressiveSample_ClearsStaticFullFramePreference)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
+        ASSERT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(10.0f));
+
+        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchController, StaticFullFrameBelowStaticBudget_ActivatesRealtime)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
+        ASSERT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+
+        controller.recordStaticFullFrameSample(makeFullFrameSample(40.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(40.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(40.0f));
+
+        EXPECT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchController, ForceMode_IgnoresLearningButNotGuards)
+    {
+        RealtimeRaymarchController controller;
+        auto config = makeTestConfig();
+        config.mode = RealtimeRaymarchMode::Force;
+        controller.configure(config);
+        controller.resetForResolution(800, 600);
+
+        EXPECT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+
+        auto blockedGuards = makeOpenGuards();
+        blockedGuards.renderJobInFlight = true;
+        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, blockedGuards));
+    }
+
+    TEST(RealtimeRaymarchController, ResolutionChange_ScalesConfidence)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
+        ASSERT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+
+        controller.resetForResolution(400, 300);
+
+        EXPECT_TRUE(controller.canAttemptRealtime(400, 300, makeOpenGuards()));
+        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
+        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 4.5f);
+    }
+
+    TEST(RealtimeRaymarchController, ResolutionChange_AfterProgressiveOnlySample_DoesNotActivateRealtime)
+    {
+        RealtimeRaymarchController controller;
+        controller.configure(makeTestConfig());
+
+        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
+        ASSERT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
+        ASSERT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
+
+        controller.resetForResolution(400, 300);
+
+        EXPECT_FALSE(controller.canAttemptRealtime(400, 300, makeOpenGuards()));
+        EXPECT_TRUE(controller.canAttemptStaticFullFrame(400, 300, makeOpenGuards()));
+    }
+
+    TEST(RealtimeRaymarchModeFromString, WithKnownValues_ParsesModes)
+    {
+        EXPECT_EQ(realtimeRaymarchModeFromString("off"), RealtimeRaymarchMode::Off);
+        EXPECT_EQ(realtimeRaymarchModeFromString("force"), RealtimeRaymarchMode::Force);
+        EXPECT_EQ(realtimeRaymarchModeFromString("auto"), RealtimeRaymarchMode::Auto);
+        EXPECT_EQ(realtimeRaymarchModeFromString("unknown"), RealtimeRaymarchMode::Auto);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp b/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp
new file mode 100644
index 00000000..c15f7614
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp
@@ -0,0 +1,202 @@
+#include "ui/render/AsyncRenderController.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    TEST(AsyncRenderControllerPresentation, PublishedFrame_CanBePromotedToFront)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+
+                controller.publishFrame(
+                    buffer, 2, 10, 3, FramePresentationQuality::FullQuality);
+        auto * promoted = controller.promoteReadyToFront();
+        ASSERT_EQ(promoted, buffer);
+
+        EXPECT_TRUE(controller.finalizeFrontPromotion(promoted));
+        EXPECT_EQ(controller.frontBuffer(), buffer);
+        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Front);
+        EXPECT_EQ(buffer->epoch.load(std::memory_order_acquire), 10u);
+        EXPECT_EQ(buffer->viewEpoch.load(std::memory_order_acquire), 3u);
+
+                auto const mirroredFront = controller.mirroredFrontPresentationBuffer();
+                ASSERT_TRUE(mirroredFront.has_value());
+                EXPECT_EQ(mirroredFront->quality, FramePresentationQuality::FullQuality);
+    }
+
+    TEST(AsyncRenderControllerPresentation,
+         FinalizeFrontPromotion_WithExistingFront_DemotesPreviousFrontForReuse)
+    {
+        AsyncRenderController controller;
+
+        auto * initialFront = controller.frontBuffer();
+        ASSERT_NE(initialFront, nullptr);
+        ASSERT_TRUE(controller.tryTransitionBuffer(initialFront, FrameState::Idle, FrameState::Front));
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+        ASSERT_NE(buffer, initialFront);
+
+                controller.publishFrame(
+                    buffer, 2, 10, 3, FramePresentationQuality::FullQuality);
+        auto * promoted = controller.promoteReadyToFront();
+        ASSERT_EQ(promoted, buffer);
+        ASSERT_TRUE(controller.finalizeFrontPromotion(promoted));
+
+        EXPECT_EQ(controller.frontBuffer(), buffer);
+        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Front);
+        EXPECT_EQ(initialFront->state.load(std::memory_order_acquire), FrameState::Idle);
+
+        auto * reacquired = controller.acquireWriteBuffer(11);
+        EXPECT_EQ(reacquired, initialFront);
+    }
+
+    TEST(AsyncRenderControllerPresentation, PromoteReadyToFront_SelectsNewestFrame)
+    {
+        AsyncRenderController controller;
+
+        auto * older = controller.acquireWriteBuffer(10);
+        auto * newer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(older, nullptr);
+        ASSERT_NE(newer, nullptr);
+        ASSERT_NE(older, newer);
+
+                controller.publishFrame(
+                    older, 5, 10, 3, FramePresentationQuality::FullQuality);
+                controller.publishFrame(
+                    newer, 6, 10, 3, FramePresentationQuality::FullQuality);
+
+        auto * promoted = controller.promoteReadyToFront();
+
+        EXPECT_EQ(promoted, newer);
+        EXPECT_EQ(newer->state.load(std::memory_order_acquire), FrameState::Resampling);
+        EXPECT_EQ(older->state.load(std::memory_order_acquire), FrameState::Ready);
+    }
+
+    TEST(AsyncRenderControllerPresentation, DiscardReadyFrame_WithMatchingMetadata_ReleasesBuffer)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+                controller.publishFrame(
+                    buffer, 2, 10, 3, FramePresentationQuality::FullQuality);
+
+        controller.discardReadyFrame(2, 10, 3);
+
+        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Idle);
+        auto * reacquired = controller.acquireWriteBuffer(11);
+        EXPECT_EQ(reacquired, buffer);
+    }
+
+    TEST(AsyncRenderControllerPresentation, ReleaseStaleBuffers_WithWritingBuffer_KeepsItReserved)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+
+        controller.releaseStaleBuffers(10);
+
+        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Writing);
+        auto * reacquired = controller.acquireWriteBuffer(11);
+        EXPECT_NE(reacquired, buffer);
+    }
+
+    TEST(AsyncRenderControllerPresentation, ReleaseStaleBuffers_WithReadyBuffer_ReleasesIt)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+        controller.publishFrame(buffer, 2, 10, 3, FramePresentationQuality::FullQuality);
+
+        controller.releaseStaleBuffers(10);
+
+        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Idle);
+        auto * reacquired = controller.acquireWriteBuffer(11);
+        EXPECT_EQ(reacquired, buffer);
+    }
+
+    TEST(AsyncRenderControllerPresentation, TryTransitionBuffer_WithWritingBuffer_KeepsMirrorReusable)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+
+        EXPECT_TRUE(controller.tryTransitionBuffer(buffer, FrameState::Writing, FrameState::Idle));
+
+        auto * reacquired = controller.acquireWriteBuffer(11);
+        EXPECT_EQ(reacquired, buffer);
+    }
+
+    TEST(AsyncRenderControllerPresentation, PublishFrame_MirrorsQualityMetadataWhileReady)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+
+        controller.publishFrame(
+          buffer, 2, 10, 3, FramePresentationQuality::ProgressivePartial);
+
+        auto const mirrored = controller.mirroredPresentationBuffer(buffer);
+        ASSERT_TRUE(mirrored.has_value());
+        EXPECT_EQ(mirrored->state, FrameState::Ready);
+        EXPECT_EQ(mirrored->quality, FramePresentationQuality::ProgressivePartial);
+        EXPECT_EQ(mirrored->frameId, 2u);
+    }
+
+    TEST(AsyncRenderControllerPresentation, PublishFrame_WithFullStamp_MirrorsStampMetadata)
+    {
+        AsyncRenderController controller;
+
+        auto * buffer = controller.acquireWriteBuffer(10);
+        ASSERT_NE(buffer, nullptr);
+
+        RenderStamp const stamp{.sceneEpoch = 1,
+                                .parameterEpoch = 2,
+                                .viewEpoch = 3,
+                                .viewportEpoch = 4,
+                                .qualityEpoch = 5};
+        controller.publishFrame(buffer, 2, 10, 3, stamp, FramePresentationQuality::FullQuality);
+
+        auto const mirrored = controller.mirroredPresentationBuffer(buffer);
+        ASSERT_TRUE(mirrored.has_value());
+        EXPECT_TRUE(matches(mirrored->stamp, stamp, RenderStampMask::displayFrame()));
+        EXPECT_EQ(mirrored->quality, FramePresentationQuality::FullQuality);
+    }
+
+    TEST(AsyncRenderControllerPresentation,
+         PromoteReadyToFront_WithCurrentFullQuality_SkipsPreviewRegression)
+    {
+        AsyncRenderController controller;
+        RenderStamp const stamp{.sceneEpoch = 1,
+                                .parameterEpoch = 2,
+                                .viewEpoch = 3,
+                                .viewportEpoch = 4,
+                                .qualityEpoch = 5};
+
+        auto * fullQuality = controller.acquireWriteBuffer(10);
+        ASSERT_NE(fullQuality, nullptr);
+        controller.publishFrame(fullQuality, 2, 10, 3, stamp, FramePresentationQuality::FullQuality);
+        auto * promoted = controller.promoteReadyToFront(stamp, RenderStampMask::displayFrame());
+        ASSERT_EQ(promoted, fullQuality);
+        ASSERT_TRUE(controller.finalizeFrontPromotion(promoted));
+
+        auto * preview = controller.acquireWriteBuffer(10);
+        ASSERT_NE(preview, nullptr);
+        controller.publishFrame(preview, 3, 10, 3, stamp, FramePresentationQuality::Preview);
+
+        EXPECT_EQ(controller.promoteReadyToFront(stamp, RenderStampMask::displayFrame()), nullptr);
+        EXPECT_EQ(preview->state.load(std::memory_order_acquire), FrameState::Ready);
+        EXPECT_FALSE(controller.canPresentFrame(stamp,
+                                               FramePresentationQuality::Preview,
+                                               stamp,
+                                               RenderStampMask::displayFrame()));
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/AsyncRenderController_tests.cpp b/gladius/tests/unittests/ui/render/AsyncRenderController_tests.cpp
new file mode 100644
index 00000000..bbc30dba
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/AsyncRenderController_tests.cpp
@@ -0,0 +1,206 @@
+#include "ui/render/AsyncRenderController.h"
+
+#include <gtest/gtest.h>
+
+#include <atomic>
+#include <chrono>
+#include <optional>
+#include <thread>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+                [[nodiscard]] RenderJob makeRenderJob(
+                    uint64_t epoch,
+                    uint64_t viewEpoch,
+                    RenderJobType type = RenderJobType::HighQuality)
+        {
+            RenderStamp stamp{};
+            stamp.viewEpoch = viewEpoch;
+            return RenderJob{.epoch = epoch,
+                             .viewEpoch = viewEpoch,
+                             .frameHint = 42,
+                                                         .type = type,
+                             .width = 640,
+                             .height = 480,
+                             .startLine = 16,
+                             .stepSize = 32,
+                             .coordinatorRequestId = 7,
+                             .coordinatorStamp = stamp};
+        }
+
+        [[nodiscard]] std::optional<FrameResultMeta> waitForResult(AsyncRenderController & controller)
+        {
+            auto const deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
+            while (std::chrono::steady_clock::now() < deadline)
+            {
+                if (auto result = controller.tryConsumeResult())
+                {
+                    return result;
+                }
+                std::this_thread::yield();
+            }
+            return std::nullopt;
+        }
+    }
+
+    TEST(AsyncRenderController, Worker_WithStaleViewProgressiveJob_CancelsBeforeExecutor)
+    {
+        AsyncRenderController controller;
+        std::atomic<int> executions{0};
+        controller.setJobExecutor(
+          [&executions](RenderJob const & job,
+                        AsyncRenderController::CancelCheck const &) -> coro::task<FrameResultMeta>
+          {
+              executions.fetch_add(1, std::memory_order_relaxed);
+              co_return FrameResultMeta{.frameId = job.frameHint,
+                                        .epoch = job.epoch,
+                                        .viewEpoch = job.viewEpoch,
+                                        .jobType = job.type,
+                                        .width = job.width,
+                                        .height = job.height,
+                                        .startLine = job.startLine,
+                                        .completedLine = job.startLine + job.stepSize,
+                                        .coordinatorRequestId = job.coordinatorRequestId,
+                                        .coordinatorStamp = job.coordinatorStamp};
+          });
+        controller.start();
+        controller.setLatestViewEpoch(2);
+
+        controller.enqueueJob(makeRenderJob(1, 1));
+
+        auto const result = waitForResult(controller);
+        controller.stop();
+
+        ASSERT_TRUE(result.has_value());
+        EXPECT_TRUE(result->cancelled);
+        EXPECT_EQ(result->jobType, RenderJobType::HighQuality);
+        EXPECT_EQ(result->viewEpoch, 1u);
+        EXPECT_EQ(result->coordinatorRequestId, 7u);
+        EXPECT_EQ(executions.load(std::memory_order_relaxed), 0);
+    }
+
+    TEST(AsyncRenderController, Worker_WithStaleEpochJob_CancelsBeforeExecutor)
+    {
+        AsyncRenderController controller;
+        std::atomic<int> executions{0};
+        controller.setJobExecutor(
+          [&executions](RenderJob const & job,
+                        AsyncRenderController::CancelCheck const &) -> coro::task<FrameResultMeta>
+          {
+              executions.fetch_add(1, std::memory_order_relaxed);
+              co_return FrameResultMeta{.frameId = job.frameHint,
+                                        .epoch = job.epoch,
+                                        .viewEpoch = job.viewEpoch,
+                                        .jobType = job.type};
+          });
+        controller.start();
+        controller.setLatestEpoch(2);
+
+        controller.enqueueJob(makeRenderJob(1, 1));
+
+        auto const result = waitForResult(controller);
+        controller.stop();
+
+        ASSERT_TRUE(result.has_value());
+        EXPECT_TRUE(result->cancelled);
+        EXPECT_EQ(result->epoch, 1u);
+        EXPECT_EQ(executions.load(std::memory_order_relaxed), 0);
+    }
+
+    TEST(AsyncRenderController, Worker_WithBackToBackStaleJobs_PublishesAllCancelledResults)
+    {
+        AsyncRenderController controller;
+        std::atomic<int> executions{0};
+        controller.setJobExecutor(
+          [&executions](RenderJob const & job,
+                        AsyncRenderController::CancelCheck const &) -> coro::task<FrameResultMeta>
+          {
+              executions.fetch_add(1, std::memory_order_relaxed);
+              co_return FrameResultMeta{.frameId = job.frameHint,
+                                        .epoch = job.epoch,
+                                        .viewEpoch = job.viewEpoch,
+                                        .jobType = job.type};
+          });
+        controller.start();
+        controller.setLatestViewEpoch(3);
+
+        controller.enqueueJob(makeRenderJob(1, 1));
+        controller.enqueueJob(makeRenderJob(1, 2));
+
+        auto const firstResult = waitForResult(controller);
+        auto const secondResult = waitForResult(controller);
+        controller.stop();
+
+        ASSERT_TRUE(firstResult.has_value());
+        ASSERT_TRUE(secondResult.has_value());
+        EXPECT_TRUE(firstResult->cancelled);
+        EXPECT_TRUE(secondResult->cancelled);
+        EXPECT_EQ(firstResult->viewEpoch, 1u);
+        EXPECT_EQ(secondResult->viewEpoch, 2u);
+        EXPECT_EQ(executions.load(std::memory_order_relaxed), 0);
+    }
+
+    TEST(AsyncRenderController, Worker_WithStaleViewStaticFullFrameProbe_CancelsBeforeExecutor)
+    {
+        AsyncRenderController controller;
+        std::atomic<int> executions{0};
+        controller.setJobExecutor(
+          [&executions](RenderJob const & job,
+                        AsyncRenderController::CancelCheck const &) -> coro::task<FrameResultMeta>
+          {
+              executions.fetch_add(1, std::memory_order_relaxed);
+              co_return FrameResultMeta{.frameId = job.frameHint,
+                                        .epoch = job.epoch,
+                                        .viewEpoch = job.viewEpoch,
+                                        .jobType = job.type};
+          });
+        controller.start();
+        controller.setLatestViewEpoch(2);
+
+        controller.enqueueJob(makeRenderJob(1, 1, RenderJobType::StaticFullFrameProbe));
+
+        auto const result = waitForResult(controller);
+        controller.stop();
+
+        ASSERT_TRUE(result.has_value());
+        EXPECT_TRUE(result->cancelled);
+        EXPECT_EQ(result->jobType, RenderJobType::StaticFullFrameProbe);
+        EXPECT_EQ(executions.load(std::memory_order_relaxed), 0);
+    }
+
+    TEST(AsyncRenderController, Worker_WithCurrentProgressiveJob_Executes)
+    {
+        AsyncRenderController controller;
+        std::atomic<int> executions{0};
+        controller.setJobExecutor(
+          [&executions](RenderJob const & job,
+                        AsyncRenderController::CancelCheck const &) -> coro::task<FrameResultMeta>
+          {
+              executions.fetch_add(1, std::memory_order_relaxed);
+              co_return FrameResultMeta{.frameId = job.frameHint,
+                                        .epoch = job.epoch,
+                                        .viewEpoch = job.viewEpoch,
+                                        .jobType = job.type,
+                                        .width = job.width,
+                                        .height = job.height,
+                                        .startLine = job.startLine,
+                                        .completedLine = job.startLine + job.stepSize,
+                                        .coordinatorRequestId = job.coordinatorRequestId,
+                                        .coordinatorStamp = job.coordinatorStamp};
+          });
+        controller.start();
+        controller.setLatestViewEpoch(1);
+
+        controller.enqueueJob(makeRenderJob(1, 1));
+
+        auto const result = waitForResult(controller);
+        controller.stop();
+
+        ASSERT_TRUE(result.has_value());
+        EXPECT_FALSE(result->cancelled);
+        EXPECT_EQ(result->jobType, RenderJobType::HighQuality);
+        EXPECT_EQ(executions.load(std::memory_order_relaxed), 1);
+    }
+}
\ No newline at end of file
diff --git a/gladius/tests/unittests/ui/render/DisplayFrameSelector_tests.cpp b/gladius/tests/unittests/ui/render/DisplayFrameSelector_tests.cpp
new file mode 100644
index 00000000..36de06af
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/DisplayFrameSelector_tests.cpp
@@ -0,0 +1,193 @@
+#include "ui/render/DisplayFrameSelector.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] constexpr DisplayFrameBufferState buffer(uint64_t epoch,
+                                                               uint64_t viewEpoch) noexcept
+        {
+            return DisplayFrameBufferState{.hasImage = true,
+                                           .epoch = epoch,
+                                           .viewEpoch = viewEpoch};
+        }
+    }
+
+    TEST(DisplayFrameSelector, WithCurrentFrontBuffer_SelectsFrontBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithStaleViewFrontBufferOutsideRealtime_FallsBackToResultImage)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 6),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithAutoPreviewFallbackResultAndStaleFront_SelectsResultImage)
+    {
+        auto const presentedPreview = PresentedFrame{.frameId = 11,
+                                                     .stamp = RenderStamp{.sceneEpoch = 3,
+                                                                          .viewEpoch = 7},
+                                                     .quality = FramePresentationQuality::Preview,
+                                                     .source = FramePresentationSource::LowResolutionPreview,
+                                                     .completedFrame = true};
+
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 6),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .exactRealtimeInteraction = false,
+                                     .resultImageAvailable = true,
+                                     .presentedFrame = presentedPreview});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithPreviouslyPresentedRealtimeFrontAfterEpochBump_HoldsFrontBuffer)
+    {
+                auto const presentedFrame = PresentedFrame{.frameId = 10,
+                                                                                                     .stamp = RenderStamp{.sceneEpoch = 3,
+                                                                                                                                                .viewEpoch = 7},
+                                                                                                     .quality = FramePresentationQuality::FullQuality,
+                                                                                                     .source = FramePresentationSource::ExactRealtime,
+                                                                                                     .completedFrame = true};
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 7),
+                                     .currentEpoch = 4,
+                                     .currentViewEpoch = 8,
+                                                                         .resultImageAvailable = true,
+                                                                         .presentedFrame = presentedFrame});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithStaleViewFrontBufferDuringRealtimeInteraction_SelectsFrontBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 6),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .exactRealtimeInteraction = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithStaleViewFrontBufferDuringRealtimeJob_SelectsFrontBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 6),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .exactRealtimeJobInFlight = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithRenderingInProgressOutsideRealtime_BlocksFrontBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .isRendering = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithRenderingInProgressDuringRealtime_AllowsFrontBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .exactRealtimeInteraction = true,
+                                     .isRendering = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithNoUsableFrontAndCurrentProgressive_SelectsProgressiveBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(2, 7),
+                                     .progressiveBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ProgressiveBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithPresentedFullFrameAndCurrentProgressive_HoldsFrontBuffer)
+    {
+        auto const presentedFrame = PresentedFrame{.frameId = 10,
+                                                   .stamp = RenderStamp{.sceneEpoch = 2,
+                                                                        .viewEpoch = 6},
+                                                   .quality = FramePresentationQuality::FullQuality,
+                                                   .source = FramePresentationSource::ProgressiveHighQuality,
+                                                   .completedFrame = true};
+
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(2, 6),
+                                     .progressiveBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .presentedFrame = presentedFrame});
+
+        EXPECT_EQ(selected, DisplayFrameSource::FrontBuffer);
+    }
+
+    TEST(DisplayFrameSelector, WithFullFrameJobInFlight_DoesNotSelectProgressiveBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(2, 7),
+                                     .progressiveBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .fullFrameRenderJobInFlight = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithMovingState_DoesNotSelectProgressiveBuffer)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.progressiveBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .isMoving = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithSuppressedHq_FallsBackToResultImage)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.frontBuffer = buffer(3, 7),
+                                     .progressiveBuffer = buffer(3, 7),
+                                     .currentEpoch = 3,
+                                     .currentViewEpoch = 7,
+                                     .suppressHqDisplay = true});
+
+        EXPECT_EQ(selected, DisplayFrameSource::ResultImage);
+    }
+
+    TEST(DisplayFrameSelector, WithoutAnyImage_ReturnsNone)
+    {
+        auto const selected = selectDisplayFrameSource(
+          DisplayFrameSelectionInput{.resultImageAvailable = false});
+
+        EXPECT_EQ(selected, DisplayFrameSource::None);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp b/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp
new file mode 100644
index 00000000..b25220ec
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp
@@ -0,0 +1,380 @@
+#include "ui/render/FramePresentationController.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
+                                                      uint64_t parameters,
+                                                      uint64_t view,
+                                                      uint64_t viewport,
+                                                      uint64_t quality) noexcept
+        {
+            return RenderStamp{.sceneEpoch = scene,
+                               .parameterEpoch = parameters,
+                               .viewEpoch = view,
+                               .viewportEpoch = viewport,
+                               .qualityEpoch = quality};
+        }
+    }
+
+    TEST(FramePresentationController, AfterReset_HasFrontBufferAndIdleBackBuffers)
+    {
+        FramePresentationController controller{3};
+
+        ASSERT_TRUE(controller.frontBufferId().has_value());
+        EXPECT_EQ(*controller.frontBufferId(), 0u);
+        ASSERT_NE(controller.buffer(0), nullptr);
+        ASSERT_NE(controller.buffer(1), nullptr);
+        ASSERT_NE(controller.buffer(2), nullptr);
+        EXPECT_EQ(controller.buffer(0)->state, FrameState::Front);
+        EXPECT_EQ(controller.buffer(1)->state, FrameState::Idle);
+        EXPECT_EQ(controller.buffer(2)->state, FrameState::Idle);
+    }
+
+    TEST(FramePresentationController, AcquireWriteBuffer_WithIdleBuffer_MarksBufferWriting)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+
+        auto const bufferId = controller.acquireWriteBuffer(stamp);
+
+        ASSERT_TRUE(bufferId.has_value());
+        ASSERT_NE(controller.buffer(*bufferId), nullptr);
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
+        EXPECT_TRUE(matches(controller.buffer(*bufferId)->stamp, stamp));
+    }
+
+    TEST(FramePresentationController, PublishFrame_WithWritingBuffer_MarksBufferReady)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(stamp);
+        ASSERT_TRUE(bufferId.has_value());
+
+        EXPECT_TRUE(controller.publishFrame(*bufferId, 17, stamp));
+
+        ASSERT_NE(controller.buffer(*bufferId), nullptr);
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Ready);
+        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 17u);
+    }
+
+        TEST(FramePresentationController, PublishFrame_WithExplicitQuality_StoresMetadata)
+        {
+                FramePresentationController controller{3};
+                auto const stamp = makeStamp(1, 2, 3, 4, 5);
+                auto const bufferId = controller.acquireWriteBuffer(stamp);
+                ASSERT_TRUE(bufferId.has_value());
+
+                EXPECT_TRUE(controller.publishFrame(
+                    *bufferId, 17, stamp, FramePresentationQuality::ProgressivePartial));
+
+                ASSERT_NE(controller.buffer(*bufferId), nullptr);
+                EXPECT_EQ(controller.buffer(*bufferId)->quality,
+                                    FramePresentationQuality::ProgressivePartial);
+        }
+
+    TEST(FramePresentationController, AcquireWriteBuffer_WithNoIdleBuffer_ReturnsNullopt)
+    {
+        FramePresentationController controller{2};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+
+        auto const firstWrite = controller.acquireWriteBuffer(stamp);
+        auto const secondWrite = controller.acquireWriteBuffer(stamp);
+
+        ASSERT_TRUE(firstWrite.has_value());
+        EXPECT_FALSE(secondWrite.has_value());
+    }
+
+    TEST(FramePresentationController, PublishFrame_WithNonWritingBuffer_ReturnsFalse)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+
+        EXPECT_FALSE(controller.publishFrame(*controller.frontBufferId(), 17, stamp));
+        EXPECT_EQ(controller.buffer(*controller.frontBufferId())->state, FrameState::Front);
+    }
+
+    TEST(FramePresentationController, TryTransitionBuffer_WithExpectedState_ReleasesWritingBuffer)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(stamp);
+        ASSERT_TRUE(bufferId.has_value());
+
+        EXPECT_TRUE(controller.tryTransitionBuffer(*bufferId, FrameState::Writing, FrameState::Idle));
+
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Idle);
+        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 0u);
+    }
+
+    TEST(FramePresentationController, TryTransitionBuffer_WithWrongExpectedState_ReturnsFalse)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(stamp);
+        ASSERT_TRUE(bufferId.has_value());
+
+        EXPECT_FALSE(controller.tryTransitionBuffer(*bufferId, FrameState::Ready, FrameState::Idle));
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
+    }
+
+    TEST(FramePresentationController, SelectNewestReady_WithMultipleReadyBuffers_SelectsHighestFrameId)
+    {
+        FramePresentationController controller{4};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const olderReady = controller.acquireWriteBuffer(latest);
+        auto const newerReady = controller.acquireWriteBuffer(latest);
+        ASSERT_TRUE(olderReady.has_value());
+        ASSERT_TRUE(newerReady.has_value());
+        ASSERT_TRUE(controller.publishFrame(*olderReady, 10, latest));
+        ASSERT_TRUE(controller.publishFrame(*newerReady, 11, latest));
+
+        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
+
+        ASSERT_TRUE(selected.has_value());
+        EXPECT_EQ(*selected, *newerReady);
+        EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Resampling);
+        EXPECT_EQ(controller.buffer(*olderReady)->state, FrameState::Ready);
+    }
+
+    TEST(FramePresentationController, SelectNewestReady_WithoutFreshnessMask_SelectsNewestRegardlessOfStamp)
+    {
+        FramePresentationController controller{4};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const oldView = makeStamp(1, 2, 2, 4, 5);
+        auto const currentReady = controller.acquireWriteBuffer(latest);
+        auto const staleButNewerReady = controller.acquireWriteBuffer(oldView);
+        ASSERT_TRUE(currentReady.has_value());
+        ASSERT_TRUE(staleButNewerReady.has_value());
+        ASSERT_TRUE(controller.publishFrame(*currentReady, 10, latest));
+        ASSERT_TRUE(controller.publishFrame(*staleButNewerReady, 11, oldView));
+
+        auto const selected = controller.selectNewestReady();
+
+        ASSERT_TRUE(selected.has_value());
+        EXPECT_EQ(*selected, *staleButNewerReady);
+    }
+
+    TEST(FramePresentationController, SelectNewestReady_WithStaleReadyBuffer_IgnoresStaleFrame)
+    {
+        FramePresentationController controller{3};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const oldCamera = makeStamp(1, 2, 2, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(oldCamera);
+        ASSERT_TRUE(bufferId.has_value());
+        ASSERT_TRUE(controller.publishFrame(*bufferId, 99, oldCamera));
+
+        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
+
+        EXPECT_FALSE(selected.has_value());
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Ready);
+    }
+
+        TEST(FramePresentationController, SelectBestReadyForPresentation_WithCurrentFullQuality_SkipsPreviewRegression)
+        {
+                FramePresentationController controller{3};
+                auto const current = makeStamp(1, 2, 3, 4, 5);
+
+                auto const fullQuality = controller.acquireWriteBuffer(current);
+                ASSERT_TRUE(fullQuality.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *fullQuality, 10, current, FramePresentationQuality::FullQuality));
+                auto const promoted =
+                    controller.selectNewestReady(current, RenderStampMask::displayFrame());
+                ASSERT_TRUE(promoted.has_value());
+                ASSERT_TRUE(controller.finalizeFrontPromotion(*promoted));
+
+                auto const preview = controller.acquireWriteBuffer(current);
+                ASSERT_TRUE(preview.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *preview, 11, current, FramePresentationQuality::Preview));
+
+                auto const selected =
+                    controller.selectBestReadyForPresentation(current, RenderStampMask::displayFrame());
+
+                EXPECT_FALSE(selected.has_value());
+                EXPECT_EQ(controller.buffer(*preview)->state, FrameState::Ready);
+        }
+
+        TEST(FramePresentationController, SelectBestReadyForPresentation_WithStaleFront_AllowsFreshPreview)
+        {
+                FramePresentationController controller{3};
+                auto const oldStamp = makeStamp(1, 2, 2, 4, 5);
+                auto const latest = makeStamp(1, 2, 3, 4, 5);
+
+                auto const oldFullQuality = controller.acquireWriteBuffer(oldStamp);
+                ASSERT_TRUE(oldFullQuality.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *oldFullQuality, 10, oldStamp, FramePresentationQuality::FullQuality));
+                auto const promoted =
+                    controller.selectNewestReady(oldStamp, RenderStampMask::displayFrame());
+                ASSERT_TRUE(promoted.has_value());
+                ASSERT_TRUE(controller.finalizeFrontPromotion(*promoted));
+
+                auto const preview = controller.acquireWriteBuffer(latest);
+                ASSERT_TRUE(preview.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *preview, 11, latest, FramePresentationQuality::Preview));
+
+                auto const selected =
+                    controller.selectBestReadyForPresentation(latest, RenderStampMask::displayFrame());
+
+                ASSERT_TRUE(selected.has_value());
+                EXPECT_EQ(*selected, *preview);
+                EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Resampling);
+        }
+
+        TEST(FramePresentationController, SelectBestReadyForPresentation_PrefersHigherQualityOverNewerPreview)
+        {
+                FramePresentationController controller{4};
+                auto const latest = makeStamp(1, 2, 3, 4, 5);
+
+                auto const fullQuality = controller.acquireWriteBuffer(latest);
+                auto const preview = controller.acquireWriteBuffer(latest);
+                ASSERT_TRUE(fullQuality.has_value());
+                ASSERT_TRUE(preview.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *fullQuality, 10, latest, FramePresentationQuality::FullQuality));
+                ASSERT_TRUE(controller.publishFrame(
+                    *preview, 11, latest, FramePresentationQuality::Preview));
+
+                auto const selected = controller.selectBestReadyForPresentation(
+                    latest, RenderStampMask::displayFrame());
+
+                ASSERT_TRUE(selected.has_value());
+                EXPECT_EQ(*selected, *fullQuality);
+                EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Resampling);
+                EXPECT_EQ(controller.buffer(*preview)->state, FrameState::Ready);
+        }
+
+        TEST(FramePresentationController, CanPresentCandidate_WithCurrentFullQuality_RejectsPreview)
+        {
+                FramePresentationController controller{3};
+                auto const current = makeStamp(1, 2, 3, 4, 5);
+
+                auto const fullQuality = controller.acquireWriteBuffer(current);
+                ASSERT_TRUE(fullQuality.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *fullQuality, 10, current, FramePresentationQuality::FullQuality));
+                auto const promoted = controller.selectBestReadyForPresentation(
+                    current, RenderStampMask::displayFrame());
+                ASSERT_TRUE(promoted.has_value());
+                ASSERT_TRUE(controller.finalizeFrontPromotion(*promoted));
+
+                EXPECT_FALSE(controller.canPresentCandidate(
+                    FramePresentationCandidate{.frameId = 11,
+                                               .stamp = current,
+                                               .quality = FramePresentationQuality::Preview},
+                    current,
+                    RenderStampMask::displayFrame()));
+        }
+
+        TEST(FramePresentationController, CanPresentCandidate_WithStaleFront_AllowsFreshPreview)
+        {
+                FramePresentationController controller{3};
+                auto const oldStamp = makeStamp(1, 2, 2, 4, 5);
+                auto const latest = makeStamp(1, 2, 3, 4, 5);
+
+                auto const oldFullQuality = controller.acquireWriteBuffer(oldStamp);
+                ASSERT_TRUE(oldFullQuality.has_value());
+                ASSERT_TRUE(controller.publishFrame(
+                    *oldFullQuality, 10, oldStamp, FramePresentationQuality::FullQuality));
+                auto const promoted = controller.selectBestReadyForPresentation(
+                    oldStamp, RenderStampMask::displayFrame());
+                ASSERT_TRUE(promoted.has_value());
+                ASSERT_TRUE(controller.finalizeFrontPromotion(*promoted));
+
+                EXPECT_TRUE(controller.canPresentCandidate(
+                    FramePresentationCandidate{.frameId = 11,
+                                               .stamp = latest,
+                                               .quality = FramePresentationQuality::Preview},
+                    latest,
+                    RenderStampMask::displayFrame()));
+        }
+
+    TEST(FramePresentationController, FinalizeFrontPromotion_WithSelectedBuffer_DemotesPreviousFront)
+    {
+        FramePresentationController controller{3};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(latest);
+        ASSERT_TRUE(bufferId.has_value());
+        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
+        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
+        ASSERT_TRUE(selected.has_value());
+
+        EXPECT_TRUE(controller.finalizeFrontPromotion(*selected));
+
+        ASSERT_TRUE(controller.frontBufferId().has_value());
+        EXPECT_EQ(*controller.frontBufferId(), *selected);
+        EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Front);
+        EXPECT_EQ(controller.buffer(0)->state, *selected == 0u ? FrameState::Front : FrameState::Idle);
+    }
+
+    TEST(FramePresentationController, FinalizeFrontPromotion_WithWrongState_ReturnsFalseAndKeepsFront)
+    {
+        FramePresentationController controller{3};
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(stamp);
+        ASSERT_TRUE(bufferId.has_value());
+        auto const originalFront = controller.frontBufferId();
+
+        EXPECT_FALSE(controller.finalizeFrontPromotion(*bufferId));
+
+        EXPECT_EQ(controller.frontBufferId(), originalFront);
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
+    }
+
+    TEST(FramePresentationController, FinalizeFrontPromotion_AfterPromotion_AllowsOldFrontReuse)
+    {
+        FramePresentationController controller{3};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(latest);
+        ASSERT_TRUE(bufferId.has_value());
+        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
+        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
+        ASSERT_TRUE(selected.has_value());
+        ASSERT_TRUE(controller.finalizeFrontPromotion(*selected));
+
+        auto const nextWrite = controller.acquireWriteBuffer(latest);
+
+        ASSERT_TRUE(nextWrite.has_value());
+        EXPECT_EQ(*nextWrite, 0u);
+        EXPECT_EQ(controller.buffer(*nextWrite)->state, FrameState::Writing);
+    }
+
+    TEST(FramePresentationController, DiscardReadyFrame_WithReadyBuffer_ReleasesItToIdle)
+    {
+        FramePresentationController controller{3};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const bufferId = controller.acquireWriteBuffer(latest);
+        ASSERT_TRUE(bufferId.has_value());
+        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
+
+        EXPECT_TRUE(controller.discardReadyFrame(*bufferId));
+
+        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Idle);
+        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 0u);
+    }
+
+    TEST(FramePresentationController, ReleaseStaleWritingBuffers_WithDifferentMasks_ReleasesRelevantStaleWork)
+    {
+        FramePresentationController controller{4};
+        auto const latest = makeStamp(1, 2, 3, 4, 5);
+        auto const oldView = makeStamp(1, 2, 2, 4, 5);
+        auto const oldScene = makeStamp(0, 2, 3, 4, 5);
+        auto const oldViewBuffer = controller.acquireWriteBuffer(oldView);
+        auto const oldSceneBuffer = controller.acquireWriteBuffer(oldScene);
+        ASSERT_TRUE(oldViewBuffer.has_value());
+        ASSERT_TRUE(oldSceneBuffer.has_value());
+
+        EXPECT_EQ(controller.releaseStaleWritingBuffers(latest, RenderStampMask::heavyGeometryTask()), 1u);
+        EXPECT_EQ(controller.buffer(*oldViewBuffer)->state, FrameState::Writing);
+        EXPECT_EQ(controller.buffer(*oldSceneBuffer)->state, FrameState::Idle);
+
+        EXPECT_EQ(controller.releaseStaleWritingBuffers(latest, RenderStampMask::displayFrame()), 1u);
+        EXPECT_EQ(controller.buffer(*oldViewBuffer)->state, FrameState::Idle);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/InteractiveRenderPathPolicy_tests.cpp b/gladius/tests/unittests/ui/render/InteractiveRenderPathPolicy_tests.cpp
new file mode 100644
index 00000000..277c4562
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/InteractiveRenderPathPolicy_tests.cpp
@@ -0,0 +1,113 @@
+#include "ui/render/InteractiveRenderPathPolicy.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    TEST(InteractiveRenderPathPolicy, WithInteractiveFrameAlreadyInFlight_KeepsCurrentFrame)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Force,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .interactiveFrameAlreadyInFlight = true,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::KeepCurrentFrame);
+    }
+
+    TEST(InteractiveRenderPathPolicy, ForceParameter_WithRealtimeAllowed_UsesExactRealtime)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Force,
+                                     .interactionState = RenderInteractionState::ParameterInteracting,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::ExactRealtime);
+    }
+
+    TEST(InteractiveRenderPathPolicy, ForceParameter_WithRealtimeBlocked_KeepsCurrentFrame)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Force,
+                                     .interactionState = RenderInteractionState::ParameterInteracting,
+                                     .exactRealtimeAllowed = false});
+
+        EXPECT_EQ(path, InteractiveRenderPath::KeepCurrentFrame);
+    }
+
+    TEST(InteractiveRenderPathPolicy, AutoParameter_WithRealtimeActiveAndAllowed_UsesExactRealtime)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Auto,
+                                     .interactionState = RenderInteractionState::ParameterInteracting,
+                                     .autoParameterExactRealtimeActive = true,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::ExactRealtime);
+    }
+
+    TEST(InteractiveRenderPathPolicy, AutoParameter_WithoutRealtimeActive_UsesLowResolutionPreview)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Auto,
+                                     .interactionState = RenderInteractionState::ParameterInteracting,
+                                     .autoParameterExactRealtimeActive = false,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::LowResolutionPreview);
+    }
+
+    TEST(InteractiveRenderPathPolicy, AutoCamera_WithGestureLocked_UsesLowResolutionPreview)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Auto,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .autoInteractiveExactRealtimeAdmitted = true,
+                                     .preferSimplerPreview = true,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::LowResolutionPreview);
+    }
+
+    TEST(InteractiveRenderPathPolicy, AutoCamera_WithRealtimeAdmittedAndAllowed_UsesExactRealtime)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Auto,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .autoInteractiveExactRealtimeAdmitted = true,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::ExactRealtime);
+    }
+
+    TEST(InteractiveRenderPathPolicy, AutoCamera_WithRealtimeAdmittedButBlocked_FallsBackToPreview)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Auto,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .autoInteractiveExactRealtimeAdmitted = true,
+                                     .exactRealtimeAllowed = false});
+
+        EXPECT_EQ(path, InteractiveRenderPath::LowResolutionPreview);
+    }
+
+    TEST(InteractiveRenderPathPolicy, OffInteraction_UsesLowResolutionPreview)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Off,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .exactRealtimeAllowed = true});
+
+        EXPECT_EQ(path, InteractiveRenderPath::LowResolutionPreview);
+    }
+
+    TEST(InteractiveRenderPathPolicy, ForceCamera_WithRealtimeBlocked_KeepsCurrentFrame)
+    {
+        auto const path = chooseInteractiveRenderPath(
+          InteractiveRenderPathInput{.mode = RealtimeRaymarchMode::Force,
+                                     .interactionState = RenderInteractionState::CameraInteracting,
+                                     .exactRealtimeAllowed = false});
+
+        EXPECT_EQ(path, InteractiveRenderPath::KeepCurrentFrame);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/PresentedFrameLedger_tests.cpp b/gladius/tests/unittests/ui/render/PresentedFrameLedger_tests.cpp
new file mode 100644
index 00000000..6639e80d
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/PresentedFrameLedger_tests.cpp
@@ -0,0 +1,123 @@
+#include "ui/render/PresentedFrameLedger.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
+                                                      uint64_t parameters,
+                                                      uint64_t view,
+                                                      uint64_t viewport,
+                                                      uint64_t quality) noexcept
+        {
+            return RenderStamp{.sceneEpoch = scene,
+                               .parameterEpoch = parameters,
+                               .viewEpoch = view,
+                               .viewportEpoch = viewport,
+                               .qualityEpoch = quality};
+        }
+
+        [[nodiscard]] constexpr PresentedFrame presentedFrame(
+          RenderStamp stamp,
+          FramePresentationQuality quality,
+          FramePresentationSource source = FramePresentationSource::HeldFrame) noexcept
+        {
+            return PresentedFrame{.frameId = 1,
+                                  .stamp = stamp,
+                                  .quality = quality,
+                                  .source = source,
+                                  .completedFrame = true};
+        }
+
+        [[nodiscard]] constexpr FramePresentationCandidate candidate(
+          RenderStamp stamp,
+          FramePresentationQuality quality,
+          FramePresentationSource source = FramePresentationSource::LowResolutionPreview,
+          uint64_t frameId = 2) noexcept
+        {
+            return FramePresentationCandidate{.frameId = frameId,
+                                              .stamp = stamp,
+                                              .quality = quality,
+                                              .source = source,
+                                              .completedFrame = true};
+        }
+    }
+
+    TEST(PresentedFrameLedger, CurrentPreview_WithNoPresentedFrame_IsAccepted)
+    {
+        PresentedFrameLedger ledger;
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+
+        EXPECT_TRUE(ledger.presentCandidate(
+          candidate(stamp, FramePresentationQuality::Preview), stamp));
+
+        ASSERT_TRUE(ledger.presentedFrame().has_value());
+        EXPECT_EQ(ledger.presentedFrame()->quality, FramePresentationQuality::Preview);
+        EXPECT_EQ(ledger.presentedFrame()->source,
+                  FramePresentationSource::LowResolutionPreview);
+    }
+
+    TEST(PresentedFrameLedger, StaleCandidate_IsRejected)
+    {
+        PresentedFrameLedger ledger;
+        auto const oldStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const latestStamp = makeStamp(1, 2, 4, 4, 5);
+
+        EXPECT_FALSE(ledger.presentCandidate(
+          candidate(oldStamp, FramePresentationQuality::Preview), latestStamp));
+        EXPECT_FALSE(ledger.presentedFrame().has_value());
+    }
+
+    TEST(PresentedFrameLedger, CurrentFullQuality_RejectsPreviewRegression)
+    {
+        PresentedFrameLedger ledger;
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        ledger.seedPresentedFrame(
+          presentedFrame(stamp, FramePresentationQuality::FullQuality));
+
+        EXPECT_FALSE(ledger.presentCandidate(
+          candidate(stamp, FramePresentationQuality::Preview), stamp));
+
+        ASSERT_TRUE(ledger.presentedFrame().has_value());
+        EXPECT_EQ(ledger.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+    }
+
+    TEST(PresentedFrameLedger, StaleFullQuality_AllowsFreshPreview)
+    {
+        PresentedFrameLedger ledger;
+        auto const oldStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const latestStamp = makeStamp(1, 2, 4, 4, 5);
+        ledger.seedPresentedFrame(
+          presentedFrame(oldStamp, FramePresentationQuality::FullQuality));
+
+        EXPECT_TRUE(ledger.presentCandidate(
+          candidate(latestStamp, FramePresentationQuality::Preview), latestStamp));
+
+        ASSERT_TRUE(ledger.presentedFrame().has_value());
+        EXPECT_EQ(ledger.presentedFrame()->quality, FramePresentationQuality::Preview);
+        EXPECT_TRUE(matches(ledger.presentedFrame()->stamp,
+                            latestStamp,
+                            RenderStampMask::displayFrame()));
+    }
+
+    TEST(PresentedFrameLedger, CurrentPreview_AllowsFreshFullQualityUpgrade)
+    {
+        PresentedFrameLedger ledger;
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        ledger.seedPresentedFrame(
+          presentedFrame(stamp, FramePresentationQuality::Preview));
+
+        EXPECT_TRUE(ledger.presentCandidate(
+          candidate(stamp,
+                    FramePresentationQuality::FullQuality,
+                    FramePresentationSource::ProgressiveHighQuality),
+          stamp));
+
+        ASSERT_TRUE(ledger.presentedFrame().has_value());
+        EXPECT_EQ(ledger.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+        EXPECT_EQ(ledger.presentedFrame()->source,
+                  FramePresentationSource::ProgressiveHighQuality);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/PreviewBackendPolicy_tests.cpp b/gladius/tests/unittests/ui/render/PreviewBackendPolicy_tests.cpp
new file mode 100644
index 00000000..e527af49
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/PreviewBackendPolicy_tests.cpp
@@ -0,0 +1,63 @@
+#include "ui/render/PreviewBackendPolicy.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    TEST(PreviewBackendPolicy, WithValidSdf_UsesPrecomputedSdfBackend)
+    {
+        auto const backend = choosePreviewBackend(
+          PreviewBackendInput{.rendererReady = true,
+                              .lowResTargetAvailable = true,
+                              .precomputedSdfValid = true,
+                              .allowDynamicFullModelFallback = true});
+
+        EXPECT_EQ(backend, PreviewBackend::PrecomputedSdfWithDistanceInit);
+        EXPECT_TRUE(previewBackendProducesDistanceInit(backend));
+    }
+
+    TEST(PreviewBackendPolicy, WithInvalidSdfAndFallbackAllowed_UsesDynamicFullModel)
+    {
+        auto const backend = choosePreviewBackend(
+          PreviewBackendInput{.rendererReady = true,
+                              .lowResTargetAvailable = true,
+                              .precomputedSdfValid = false,
+                              .allowDynamicFullModelFallback = true});
+
+        EXPECT_EQ(backend, PreviewBackend::DynamicFullModel);
+        EXPECT_FALSE(previewBackendProducesDistanceInit(backend));
+    }
+
+    TEST(PreviewBackendPolicy, WithInvalidSdfAndFallbackDisabled_ReturnsNone)
+    {
+        auto const backend = choosePreviewBackend(
+          PreviewBackendInput{.rendererReady = true,
+                              .lowResTargetAvailable = true,
+                              .precomputedSdfValid = false,
+                              .allowDynamicFullModelFallback = false});
+
+        EXPECT_EQ(backend, PreviewBackend::None);
+    }
+
+    TEST(PreviewBackendPolicy, WithoutRendererReady_ReturnsNone)
+    {
+        auto const backend = choosePreviewBackend(
+          PreviewBackendInput{.rendererReady = false,
+                              .lowResTargetAvailable = true,
+                              .precomputedSdfValid = true,
+                              .allowDynamicFullModelFallback = true});
+
+        EXPECT_EQ(backend, PreviewBackend::None);
+    }
+
+    TEST(PreviewBackendPolicy, WithoutLowResTarget_ReturnsNone)
+    {
+        auto const backend = choosePreviewBackend(
+          PreviewBackendInput{.rendererReady = true,
+                              .lowResTargetAvailable = false,
+                              .precomputedSdfValid = true,
+                              .allowDynamicFullModelFallback = true});
+
+        EXPECT_EQ(backend, PreviewBackend::None);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/PreviewResultAcceptancePolicy_tests.cpp b/gladius/tests/unittests/ui/render/PreviewResultAcceptancePolicy_tests.cpp
new file mode 100644
index 00000000..40e07b4f
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/PreviewResultAcceptancePolicy_tests.cpp
@@ -0,0 +1,190 @@
+#include "ui/render/PreviewResultAcceptancePolicy.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
+                                                      uint64_t parameters,
+                                                      uint64_t view,
+                                                      uint64_t viewport,
+                                                      uint64_t quality) noexcept
+        {
+            return RenderStamp{.sceneEpoch = scene,
+                               .parameterEpoch = parameters,
+                               .viewEpoch = view,
+                               .viewportEpoch = viewport,
+                               .qualityEpoch = quality};
+        }
+
+        [[nodiscard]] constexpr PreviewResultMeta previewResult(RenderStamp stamp) noexcept
+        {
+            return PreviewResultMeta{.frameId = 2,
+                                     .epoch = 3,
+                                     .viewEpoch = 4,
+                                     .quality = FramePresentationQuality::Preview,
+                                     .coordinatorStamp = stamp};
+        }
+
+        [[nodiscard]] constexpr PresentedFrame fullQualityFrame(RenderStamp stamp) noexcept
+        {
+            return PresentedFrame{.frameId = 1,
+                                  .stamp = stamp,
+                                  .quality = FramePresentationQuality::FullQuality,
+                                  .source = FramePresentationSource::ProgressiveHighQuality,
+                                  .completedFrame = true};
+        }
+    }
+
+    TEST(PreviewResultAcceptancePolicy, CurrentPreview_WithNoPresentedFrame_IsAccepted)
+    {
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const meta = previewResult(stamp);
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = stamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch});
+
+        EXPECT_TRUE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::None);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, StaleViewPreview_IsRejectedBeforePublish)
+    {
+        auto const oldStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const latestStamp = makeStamp(1, 2, 4, 4, 5);
+        auto meta = previewResult(oldStamp);
+        meta.viewEpoch = 3;
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = latestStamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = 4});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_TRUE(decision.shouldCompleteAsCancelled());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::StaleFrame);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, CameraInteraction_WithStaleViewPreview_AllowsPresentationAsLatestView)
+    {
+        auto const oldViewStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const latestStamp = makeStamp(1, 2, 4, 4, 5);
+        auto meta = previewResult(oldViewStamp);
+        meta.viewEpoch = 3;
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = latestStamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = 4,
+                                         .allowStaleViewDuringCameraInteraction = true});
+
+        EXPECT_TRUE(decision.accepted());
+        EXPECT_TRUE(decision.presentAsRequiredStamp);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, CameraInteraction_WithStaleParameterPreview_RemainsRejected)
+    {
+        auto const oldParameterStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const latestStamp = makeStamp(1, 3, 4, 4, 5);
+        auto meta = previewResult(oldParameterStamp);
+        meta.viewEpoch = 3;
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = latestStamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = 4,
+                                         .allowStaleViewDuringCameraInteraction = true});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::StaleFrame);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, ActiveRealtimeInteraction_RejectsPreview)
+    {
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const meta = previewResult(stamp);
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = stamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch,
+                                         .realtimeRaymarchInteractionActive = true});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason,
+                  PreviewResultRejectionReason::RealtimeRaymarchActive);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, CurrentFullQualityFrame_RejectsPreviewRegression)
+    {
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const meta = previewResult(stamp);
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = stamp,
+                                         .presentedFrame = fullQualityFrame(stamp),
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::QualityRegression);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, StaleFullQualityFrame_AllowsFreshPreview)
+    {
+        auto const oldStamp = makeStamp(1, 2, 2, 4, 5);
+        auto const latestStamp = makeStamp(1, 2, 3, 4, 5);
+        auto const meta = previewResult(latestStamp);
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = latestStamp,
+                                         .presentedFrame = fullQualityFrame(oldStamp),
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch});
+
+        EXPECT_TRUE(decision.accepted());
+    }
+
+    TEST(PreviewResultAcceptancePolicy, CancelledPreview_IsRejected)
+    {
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto meta = previewResult(stamp);
+        meta.cancelled = true;
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = stamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::Cancelled);
+    }
+
+    TEST(PreviewResultAcceptancePolicy, OlderPreviewFrameId_IsRejected)
+    {
+        auto const stamp = makeStamp(1, 2, 3, 4, 5);
+        auto const meta = previewResult(stamp);
+
+        auto const decision = evaluatePreviewResultAcceptance(
+          meta,
+          PreviewResultAcceptanceContext{.requiredStamp = stamp,
+                                         .currentEpoch = meta.epoch,
+                                         .currentViewEpoch = meta.viewEpoch,
+                                         .lastPresentedPreviewFrameId = meta.frameId});
+
+        EXPECT_FALSE(decision.accepted());
+        EXPECT_EQ(decision.rejectionReason, PreviewResultRejectionReason::OutOfOrderFrame);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/ProgressiveBufferPolicy_tests.cpp b/gladius/tests/unittests/ui/render/ProgressiveBufferPolicy_tests.cpp
new file mode 100644
index 00000000..a8616289
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/ProgressiveBufferPolicy_tests.cpp
@@ -0,0 +1,131 @@
+#include "ui/render/ProgressiveBufferPolicy.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    using async_rendering::isProgressiveBufferContinuable;
+    using async_rendering::ProgressiveBufferState;
+    using async_rendering::ProgressiveJobTarget;
+
+    /// A buffer matching the job in scene epoch, view epoch and size may be continued.
+    TEST(ProgressiveBufferPolicy_IsContinuable, MatchingEpochViewAndSize_ReturnsTrue)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+        ProgressiveJobTarget const job{.epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+
+        EXPECT_TRUE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// A larger buffer still fits a smaller job target.
+    TEST(ProgressiveBufferPolicy_IsContinuable, LargerBuffer_FitsSmallerTarget_ReturnsTrue)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 5, .viewEpoch = 9, .width = 1024, .height = 768};
+        ProgressiveJobTarget const job{.epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+
+        EXPECT_TRUE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// No backing image — nothing to continue.
+    TEST(ProgressiveBufferPolicy_IsContinuable, NoImage_ReturnsFalse)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = false, .epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+        ProgressiveJobTarget const job{.epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// A structural/scene-epoch change invalidates the buffer.
+    TEST(ProgressiveBufferPolicy_IsContinuable, SceneEpochChanged_ReturnsFalse)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+        ProgressiveJobTarget const job{.epoch = 6, .viewEpoch = 9, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// A smaller buffer cannot satisfy a larger render target (e.g. after a window enlarge).
+    TEST(ProgressiveBufferPolicy_IsContinuable, SmallerBuffer_ThanTarget_ReturnsFalse)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 5, .viewEpoch = 9, .width = 640, .height = 480};
+        ProgressiveJobTarget const job{.epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// REGRESSION (torn frame / stale-model bottom band): a parameter change bumps ONLY the view
+    /// epoch (RenderWindow::invalidateViewDueToParameterChange does m_asyncViewEpoch++ and does
+    /// NOT bump the scene epoch). The previously-seeded progressive buffer therefore still carries
+    /// the SAME scene epoch but an OLDER view epoch. It must NOT be continued/reused — otherwise
+    /// its not-yet-overwritten region keeps the previous parameters while the top is re-rendered
+    /// with the new parameters, producing the reported fresh-model-top / stale-model-bottom tear.
+    TEST(ProgressiveBufferPolicy_IsContinuable, ParameterChange_BumpsOnlyViewEpoch_ReturnsFalse)
+    {
+        // Buffer was seeded under scene epoch 5 / view epoch 9.
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 5, .viewEpoch = 9, .width = 800, .height = 600};
+
+        // Parameter change keeps the scene epoch (5) but advances the view epoch (9 -> 10).
+        ProgressiveJobTarget const jobAfterParameterChange{
+          .epoch = 5, .viewEpoch = 10, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, jobAfterParameterChange))
+          << "A parameter-changed job must re-seed the progressive buffer; reusing the stale-view "
+             "buffer causes the torn fresh-top / stale-bottom HQ frame.";
+    }
+
+    /// REGRESSION (param change followed by resize): the resize re-seeds at the new scene epoch,
+    /// but if a leftover buffer at the new size somehow still carries an older view epoch it must
+    /// be rejected too. View epoch is the deciding factor independent of size.
+    TEST(ProgressiveBufferPolicy_IsContinuable, NewSceneEpochButStaleViewEpoch_ReturnsFalse)
+    {
+        ProgressiveBufferState const buffer{
+          .hasImage = true, .epoch = 6, .viewEpoch = 9, .width = 800, .height = 600};
+        ProgressiveJobTarget const job{.epoch = 6, .viewEpoch = 11, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, job));
+    }
+
+    /// REGRESSION (parameter upload lands mid-fill): the GPU parameter buffer is uploaded
+    /// asynchronously and independently of the view epoch, so a single progressive fill carries
+    /// one uniform view epoch even when an upload changed the parameters between two chunks. The
+    /// epoch/view key alone cannot detect that, leaving the upper band rendered with the old
+    /// parameters and the lower band with the new ones — the reported tear. A change in the GPU
+    /// parameter generation must therefore reject continuation so the buffer is re-seeded.
+    TEST(ProgressiveBufferPolicy_IsContinuable, ParameterGenerationChanged_ReturnsFalse)
+    {
+        ProgressiveBufferState const buffer{.hasImage = true,
+                                            .epoch = 5,
+                                            .viewEpoch = 9,
+                                            .paramGeneration = 3,
+                                            .width = 800,
+                                            .height = 600};
+        ProgressiveJobTarget const job{
+          .epoch = 5, .viewEpoch = 9, .paramGeneration = 4, .width = 800, .height = 600};
+
+        EXPECT_FALSE(isProgressiveBufferContinuable(buffer, job))
+          << "A parameter upload that advanced the GPU parameter generation mid-fill must re-seed "
+             "the progressive buffer; reusing it produces the old-params-top / new-params-bottom "
+             "tear that carries a uniform view epoch.";
+    }
+
+    /// A matching parameter generation (alongside matching epoch/view/size) still continues.
+    TEST(ProgressiveBufferPolicy_IsContinuable, MatchingParameterGeneration_ReturnsTrue)
+    {
+        ProgressiveBufferState const buffer{.hasImage = true,
+                                            .epoch = 5,
+                                            .viewEpoch = 9,
+                                            .paramGeneration = 7,
+                                            .width = 800,
+                                            .height = 600};
+        ProgressiveJobTarget const job{
+          .epoch = 5, .viewEpoch = 9, .paramGeneration = 7, .width = 800, .height = 600};
+
+        EXPECT_TRUE(isProgressiveBufferContinuable(buffer, job));
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/ProgressiveTearReproduction_tests.cpp b/gladius/tests/unittests/ui/render/ProgressiveTearReproduction_tests.cpp
new file mode 100644
index 00000000..39679dfb
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/ProgressiveTearReproduction_tests.cpp
@@ -0,0 +1,1241 @@
+#include "ui/render/DisplayFrameSelector.h"
+#include "ui/render/ProgressiveBufferPolicy.h"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <optional>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        /// Sentinel for a line whose content is undefined (freshly acquired buffer, never written).
+        constexpr int64_t kGarbage = -1;
+
+        /// Continuation policy the simulation drives.
+        ///   SceneEpochOnly      = pre-fix: reuse keyed on scene epoch + size only.
+        ///   SceneAndView        = the committed fix: drives the real isProgressiveBufferContinuable
+        ///                         (scene + view epoch + size). Stamps the buffer view epoch at seed.
+        ///   SceneViewAndParam   = candidate fix: SceneAndView PLUS the GPU parameter-upload
+        ///                         generation, so an async parameter upload mid-fill restarts the
+        ///                         fill instead of leaving a half-old / half-new buffer.
+        enum class Policy
+        {
+            SceneEpochOnly,
+            SceneAndView,
+            SceneViewAndParam
+        };
+
+        char const * policyName(Policy p)
+        {
+            switch (p)
+            {
+            case Policy::SceneEpochOnly:
+                return "SceneEpochOnly(pre-fix)";
+            case Policy::SceneAndView:
+                return "SceneAndView(committed-fix)";
+            case Policy::SceneViewAndParam:
+                return "SceneViewAndParam(candidate-fix)";
+            }
+            return "?";
+        }
+
+        /// The actual model state a single rendered line represents: the view (camera/parameter
+        /// epoch) AND the GPU parameter-buffer generation that was uploaded when the line rendered.
+        /// Two lines that differ in EITHER field show different content => a torn frame.
+        struct LineStamp
+        {
+            int64_t viewEpoch{kGarbage};
+            int64_t paramGen{kGarbage};
+
+            bool operator<(LineStamp const & o) const
+            {
+                return viewEpoch < o.viewEpoch ||
+                       (viewEpoch == o.viewEpoch && paramGen < o.paramGen);
+            }
+
+            bool isGarbage() const
+            {
+                return viewEpoch == kGarbage || paramGen == kGarbage;
+            }
+        };
+
+        /// Mirrors a progressive / front image buffer plus its display-gating metadata.
+        struct MockImage
+        {
+            bool valid{false};
+            uint64_t epoch{0};          ///< m_asyncProgressiveEpoch (scene epoch)
+            uint64_t viewEpoch{0};      ///< m_asyncProgressiveViewEpoch (display gating)
+            uint64_t renderParamGen{0}; ///< GPU param generation this buffer's HQ lines target
+            uint32_t width{0};
+            uint32_t height{0};
+            std::vector<LineStamp> lines; ///< per-line content stamp
+
+            void allocate(uint32_t w, uint32_t h, LineStamp fill)
+            {
+                width = w;
+                height = h;
+                lines.assign(h, fill);
+                valid = true;
+            }
+
+            void clear()
+            {
+                *this = MockImage{};
+            }
+        };
+
+        std::set<LineStamp> distinctStamps(MockImage const & img)
+        {
+            return std::set<LineStamp>(img.lines.begin(), img.lines.end());
+        }
+
+        bool hasGarbage(MockImage const & img)
+        {
+            return std::any_of(
+              img.lines.begin(), img.lines.end(), [](LineStamp const & s) { return s.isGarbage(); });
+        }
+
+        struct Job
+        {
+            bool active{false};
+            uint64_t epoch{0};
+            uint64_t viewEpoch{0};
+            uint64_t paramGen{0};
+            uint32_t width{0};
+            uint32_t height{0};
+            size_t startLine{0};
+            size_t stepSize{0};
+        };
+
+        struct Result
+        {
+            bool present{false};
+            uint64_t epoch{0};
+            uint64_t viewEpoch{0};
+            uint32_t width{0};
+            uint32_t height{0};
+            size_t completedLine{0};
+            bool completedFrame{false};
+        };
+
+        struct DisplayObservation
+        {
+            DisplayFrameSource source{DisplayFrameSource::None};
+            std::set<LineStamp> shown;
+            bool torn{false};
+        };
+
+        /// GPU-free model of the RenderWindow progressive-HQ state machine, extended with a GPU
+        /// parameter-buffer generation that is uploaded ASYNCHRONOUSLY and independently of the
+        /// view epoch. The async worker runs at the end of tick N; its result is consumed at the
+        /// start of tick N+1 (one-frame latency), so resizes / parameter uploads can interleave
+        /// between a chunk being scheduled and its result being processed.
+        class RenderWindowSim
+        {
+        public:
+            RenderWindowSim(Policy policy, uint32_t width, uint32_t height, size_t chunkLines)
+                : m_policy(policy)
+                , m_resultWidth(width)
+                , m_resultHeight(height)
+                , m_chunkLines(chunkLines)
+            {
+            }
+
+            /// invalidateViewDueToParameterChange(): bumps ONLY the view epoch and records that a
+            /// NEW parameter generation has been requested. Crucially, the GPU parameter buffer is
+            /// NOT updated here — the upload happens later/asynchronously (deliverParameterUpload).
+            void parameterChange()
+            {
+                ++m_viewEpoch;
+                ++m_pendingParamGen;
+                m_currentLine = 0;
+                m_isRendering = false;
+            }
+
+            /// The async parameter upload finally lands in *m_primitives (Document::updateParameter
+            /// -> tryToupdateParameter -> updateParameterBlocking). From now on, HQ chunks render
+            /// against the new parameters. This is decoupled in time from parameterChange().
+            /// When bumpViewEpoch is true it models the candidate minimal fix: bumping the view
+            /// epoch at the moment the upload completes (not at request time) so any in-flight
+            /// fill that started against the old parameters becomes view-outdated and restarts.
+            void deliverParameterUpload(bool bumpViewEpoch)
+            {
+                m_gpuParamGen = m_pendingParamGen;
+                if (bumpViewEpoch)
+                {
+                    ++m_viewEpoch;
+                    m_currentLine = 0;
+                    m_isRendering = false;
+                }
+            }
+
+            /// A low-res preview for the current view/param resamples into the result image.
+            void lowResPreviewArrives()
+            {
+                m_resultStamp = LineStamp{static_cast<int64_t>(m_viewEpoch),
+                                          static_cast<int64_t>(m_gpuParamGen)};
+                m_lastLowResViewEpoch = m_viewEpoch;
+            }
+
+            void requestResize(uint32_t w, uint32_t h)
+            {
+                m_desiredWidth = w;
+                m_desiredHeight = h;
+            }
+
+            DisplayObservation tick()
+            {
+                processResults();
+                resizeBarrier();
+                scheduleChunkIfNeeded();
+                runWorker();
+                return observeDisplay();
+            }
+
+        private:
+            bool continuable(MockImage const & buf, Job const & job) const
+            {
+                bool baseOk = false;
+                if (m_policy == Policy::SceneEpochOnly)
+                {
+                    baseOk = buf.valid && buf.epoch == job.epoch && buf.width >= job.width &&
+                             buf.height >= job.height;
+                }
+                else
+                {
+                    // Drive the REAL production predicate for the epoch/view/size key.
+                    ProgressiveBufferState const state{.hasImage = buf.valid,
+                                                       .epoch = buf.epoch,
+                                                       .viewEpoch = buf.viewEpoch,
+                                                       .width = buf.width,
+                                                       .height = buf.height};
+                    ProgressiveJobTarget const target{.epoch = job.epoch,
+                                                      .viewEpoch = job.viewEpoch,
+                                                      .width = job.width,
+                                                      .height = job.height};
+                    baseOk = isProgressiveBufferContinuable(state, target);
+                }
+                if (m_policy == Policy::SceneViewAndParam)
+                {
+                    // Candidate fix: also require the buffer's HQ lines to target the parameter
+                    // generation currently uploaded to the GPU. If an upload landed since the
+                    // buffer was seeded, the buffer is no longer continuable and must restart.
+                    baseOk = baseOk && buf.renderParamGen == job.paramGen;
+                }
+                return baseOk;
+            }
+
+            void scheduleChunkIfNeeded()
+            {
+                if (m_returnedEarlyThisTick || m_jobInFlight)
+                {
+                    return;
+                }
+                if (!m_isRendering && !m_dirty)
+                {
+                    return;
+                }
+
+                Job job{};
+                job.active = true;
+                job.epoch = m_sceneEpoch;
+                job.viewEpoch = m_viewEpoch;
+                job.paramGen = m_gpuParamGen; // chunks render against the CURRENTLY uploaded params
+                job.width = m_resultWidth;
+                job.height = m_resultHeight;
+
+                bool const seeded = continuable(m_prog, job);
+                if (m_currentLine > 0 && !seeded)
+                {
+                    m_currentLine = 0;
+                }
+                job.startLine = std::min(m_currentLine, static_cast<size_t>(job.height));
+                job.stepSize = std::max<size_t>(
+                  1, std::min(m_chunkLines, static_cast<size_t>(job.height) - job.startLine));
+
+                if (job.startLine == 0 && !seeded)
+                {
+                    // Seed: resample the low-res result image across the whole buffer. If that
+                    // low-res preview is for an older view than the job, the seed band would mix a
+                    // stale view with the fresh HQ top, so HQ display is suppressed until a fully
+                    // view-consistent frame completes (mirrors the seedViewIsStale guard).
+                    bool const seedViewIsStale = m_lastLowResViewEpoch != job.viewEpoch;
+                    if (seedViewIsStale)
+                    {
+                        m_suppressHQDisplay = true;
+                    }
+                    m_prog.allocate(job.width, job.height, m_resultStamp);
+                    m_prog.epoch = job.epoch;
+                    m_prog.renderParamGen = job.paramGen;
+                    if (m_policy != Policy::SceneEpochOnly)
+                    {
+                        m_prog.viewEpoch = job.viewEpoch; // committed fix stamps view epoch at seed
+                    }
+                }
+
+                m_dirty = false;
+                m_isRendering = true;
+                m_jobInFlight = true;
+                m_inFlightEpoch = job.epoch;
+                m_pendingJob = job;
+            }
+
+            void runWorker()
+            {
+                if (!m_pendingJob.active)
+                {
+                    return;
+                }
+                Job const job = m_pendingJob;
+                m_pendingJob = Job{};
+
+                if (!continuable(m_prog, job))
+                {
+                    // Worker acquire-fresh branch: brand-new UNSEEDED buffer (garbage lines).
+                    m_prog.allocate(job.width, job.height, LineStamp{});
+                    m_prog.epoch = job.epoch;
+                    m_prog.viewEpoch = job.viewEpoch;
+                    m_prog.renderParamGen = job.paramGen;
+                }
+
+                // HQ chunk renders [startLine, endLine) against the GPU's CURRENT parameter buffer.
+                // renderSceneComputeOnly does NOT re-upload parameters, so the stamp is the live
+                // gpu generation — which may differ from the generation that seeded the buffer.
+                size_t const endLine =
+                  std::min(job.startLine + job.stepSize, static_cast<size_t>(job.height));
+                LineStamp const hqStamp{static_cast<int64_t>(job.viewEpoch),
+                                        static_cast<int64_t>(m_gpuParamGen)};
+                for (size_t y = job.startLine; y < endLine; ++y)
+                {
+                    m_prog.lines[y] = hqStamp;
+                }
+
+                Result r{};
+                r.present = true;
+                r.epoch = job.epoch;
+                r.viewEpoch = job.viewEpoch;
+                r.width = job.width;
+                r.height = job.height;
+                r.completedLine = endLine;
+                r.completedFrame = endLine >= static_cast<size_t>(job.height);
+
+                if (r.completedFrame)
+                {
+                    m_ready = m_prog;
+                    m_ready.epoch = job.epoch;
+                    m_ready.viewEpoch = job.viewEpoch;
+                    m_prog.clear();
+                }
+                m_pendingResult = r;
+            }
+
+            void processResults()
+            {
+                m_returnedEarlyThisTick = false;
+                if (!m_pendingResult.present)
+                {
+                    return;
+                }
+                Result const r = m_pendingResult;
+                m_pendingResult = Result{};
+
+                bool const isOutdated = r.epoch < m_sceneEpoch;
+                bool const isViewOutdated = r.viewEpoch < m_viewEpoch;
+                bool const isSizeOutdated = r.width != m_resultWidth || r.height != m_resultHeight;
+                bool const discardForStaleView = isSizeOutdated || isViewOutdated;
+
+                if (r.completedFrame)
+                {
+                    if (!(isOutdated || discardForStaleView))
+                    {
+                        m_front = m_ready;
+                        m_frontPresented = true;
+                    }
+                    m_ready.clear();
+                    if (!isOutdated && !discardForStaleView)
+                    {
+                        m_isRendering = false;
+                        m_currentLine = 0;
+                        m_suppressHQDisplay = false;
+                    }
+                }
+                else
+                {
+                    if (!isOutdated && !isViewOutdated && !isSizeOutdated)
+                    {
+                        m_currentLine = std::min(r.completedLine, static_cast<size_t>(r.height));
+                    }
+                    if ((isViewOutdated || isSizeOutdated) && m_prog.valid &&
+                        m_prog.viewEpoch == r.viewEpoch)
+                    {
+                        m_prog.clear();
+                        m_isRendering = false;
+                    }
+                }
+
+                if (r.epoch == m_inFlightEpoch)
+                {
+                    m_jobInFlight = false;
+                    m_inFlightEpoch = 0;
+                    if (isOutdated || isViewOutdated || isSizeOutdated)
+                    {
+                        m_isRendering = false;
+                        m_dirty = true;
+                    }
+                }
+            }
+
+            void resizeBarrier()
+            {
+                bool const resizeRequired =
+                  m_desiredWidth != 0 &&
+                  (m_desiredWidth != m_resultWidth || m_desiredHeight != m_resultHeight);
+                if (!resizeRequired)
+                {
+                    return;
+                }
+                if (m_jobInFlight)
+                {
+                    m_dirty = true;
+                    m_isRendering = false;
+                    m_returnedEarlyThisTick = true;
+                    return;
+                }
+                if (m_prog.valid)
+                {
+                    m_prog.clear();
+                    m_currentLine = 0;
+                    m_isRendering = false;
+                }
+                m_resultWidth = m_desiredWidth;
+                m_resultHeight = m_desiredHeight;
+                ++m_sceneEpoch; // invalidateView -> notifyAsyncEpochIncrement bumps BOTH epochs
+                ++m_viewEpoch;
+                m_currentLine = 0;
+                m_isRendering = false;
+                m_dirty = true;
+                m_desiredWidth = 0;
+                m_desiredHeight = 0;
+            }
+
+            DisplayObservation observeDisplay()
+            {
+                DisplayFrameBufferState const frontState{
+                  .hasImage = m_front.valid, .epoch = m_front.epoch, .viewEpoch = m_front.viewEpoch};
+                DisplayFrameBufferState const progState{
+                  .hasImage = m_prog.valid, .epoch = m_prog.epoch, .viewEpoch = m_prog.viewEpoch};
+
+                std::optional<PresentedFrame> presented;
+                if (m_frontPresented)
+                {
+                    presented = PresentedFrame{};
+                    presented->source = FramePresentationSource::ProgressiveHighQuality;
+                    presented->quality = FramePresentationQuality::FullQuality;
+                }
+
+                DisplayFrameSelectionInput const input{.frontBuffer = frontState,
+                                                       .progressiveBuffer = progState,
+                                                       .currentEpoch = m_sceneEpoch,
+                                                       .currentViewEpoch = m_viewEpoch,
+                                                       .exactRealtimeInteraction = false,
+                                                       .exactRealtimeJobInFlight = false,
+                                                       .isRendering = m_isRendering,
+                                                       .isMoving = false,
+                                                       .fullFrameRenderJobInFlight = false,
+                                                       .suppressHqDisplay = m_suppressHQDisplay,
+                                                       .resultImageAvailable = true,
+                                                       .presentedFrame = presented};
+
+                DisplayObservation obs{};
+                obs.source = selectDisplayFrameSource(input);
+
+                MockImage const * shown = nullptr;
+                if (obs.source == DisplayFrameSource::FrontBuffer)
+                {
+                    shown = &m_front;
+                }
+                else if (obs.source == DisplayFrameSource::ProgressiveBuffer)
+                {
+                    shown = &m_prog;
+                }
+
+                if (shown != nullptr && shown->valid)
+                {
+                    obs.shown = distinctStamps(*shown);
+                    obs.torn = obs.shown.size() > 1 || hasGarbage(*shown);
+                }
+                else
+                {
+                    obs.shown = {m_resultStamp}; // result image is a single uniform low-res frame
+                }
+                return obs;
+            }
+
+            Policy m_policy;
+            uint32_t m_resultWidth{0};
+            uint32_t m_resultHeight{0};
+            size_t m_chunkLines{0};
+
+            uint64_t m_sceneEpoch{1};
+            uint64_t m_viewEpoch{1};
+            uint64_t m_gpuParamGen{1};     ///< params currently uploaded to *m_primitives
+            uint64_t m_pendingParamGen{1}; ///< params requested but not yet uploaded
+            size_t m_currentLine{0};
+            bool m_isRendering{false};
+            bool m_dirty{false};
+            bool m_suppressHQDisplay{false};
+            bool m_returnedEarlyThisTick{false};
+
+            LineStamp m_resultStamp{1, 1};
+            uint64_t m_lastLowResViewEpoch{1};
+
+            MockImage m_prog{};
+            MockImage m_front{};
+            MockImage m_ready{};
+            bool m_frontPresented{false};
+
+            bool m_jobInFlight{false};
+            uint64_t m_inFlightEpoch{0};
+            Job m_pendingJob{};
+            Result m_pendingResult{};
+
+            uint32_t m_desiredWidth{0};
+            uint32_t m_desiredHeight{0};
+        };
+
+        std::string stampsToString(std::set<LineStamp> const & stamps)
+        {
+            std::ostringstream oss;
+            oss << "{";
+            bool first = true;
+            for (auto const & s : stamps)
+            {
+                if (!first)
+                {
+                    oss << " ";
+                }
+                oss << "v" << s.viewEpoch << "p" << s.paramGen;
+                first = false;
+            }
+            oss << "}";
+            return oss.str();
+        }
+
+        char const * sourceName(DisplayFrameSource s)
+        {
+            switch (s)
+            {
+            case DisplayFrameSource::FrontBuffer:
+                return "Front";
+            case DisplayFrameSource::ProgressiveBuffer:
+                return "Progressive";
+            case DisplayFrameSource::ResultImage:
+                return "Result";
+            default:
+                return "None";
+            }
+        }
+
+        /// Runs the param-change-then-resize scenario with an async parameter upload that lands
+        /// mid-fill, and returns true if ANY displayed frame is torn (mixed model state on screen).
+        bool runParamUploadMidFillScenario(Policy policy, bool verbose, bool bumpViewOnUpload = false)
+        {
+            RenderWindowSim sim(policy, /*w*/ 100, /*h*/ 100, /*chunk*/ 20);
+
+            // 1) Reach a clean steady state at view 1 / param 1.
+            sim.lowResPreviewArrives();
+            for (int i = 0; i < 12; ++i)
+            {
+                sim.tick();
+            }
+
+            // 2) Change a model parameter: bumps the view epoch and REQUESTS a new param gen, but
+            //    the GPU parameter buffer is not uploaded yet.
+            sim.parameterChange();
+
+            // 3) Immediately resize: forces a fresh full HQ fill against the still-stale GPU params.
+            sim.requestResize(140, 140);
+
+            bool tornEverSeen = false;
+            int const uploadAtTick = 3; // the async parameter upload lands a few frames into the fill
+            for (int t = 0; t < 16; ++t)
+            {
+                if (t == uploadAtTick)
+                {
+                    sim.deliverParameterUpload(bumpViewOnUpload); // GPU params change mid-fill
+                    sim.lowResPreviewArrives();                    // a fresh low-res preview arrives
+                }
+                DisplayObservation const obs = sim.tick();
+                tornEverSeen = tornEverSeen || obs.torn;
+                if (verbose)
+                {
+                    std::cout << "  t" << t << " src=" << sourceName(obs.source)
+                              << " shown=" << stampsToString(obs.shown)
+                              << (obs.torn ? "  <<< TORN" : "") << "\n";
+                }
+            }
+            return tornEverSeen;
+        }
+    } // namespace
+
+    /// Observation harness: print the per-tick display trace for all three policies so the real
+    /// behavior is visible. The parameter upload lands mid-fill (decoupled from the view epoch).
+    TEST(ProgressiveTearReproduction, Observe_ParamUploadMidFill_AllPolicies)
+    {
+        for (Policy policy : {Policy::SceneEpochOnly, Policy::SceneAndView, Policy::SceneViewAndParam})
+        {
+            std::cout << "\n=== " << policyName(policy) << " ===\n";
+            bool const torn = runParamUploadMidFillScenario(policy, /*verbose*/ true);
+            std::cout << "  => tornEverSeen=" << (torn ? "true" : "false") << "\n";
+        }
+    }
+
+    /// The committed view-epoch fix is INSUFFICIENT for a parameter upload that lands mid-fill:
+    /// the whole fill carries a uniform view epoch, so the epoch guards pass while the buffer
+    /// holds two different parameter generations -> a torn frame is displayed.
+    TEST(ProgressiveTearReproduction, ParamUploadMidFill_SceneAndView_StillTears)
+    {
+        EXPECT_TRUE(runParamUploadMidFillScenario(Policy::SceneAndView, /*verbose*/ false))
+          << "Expected the committed (view-epoch only) fix to STILL show a torn frame when a "
+             "parameter upload lands mid-fill — the tear is in the parameter dimension, which the "
+             "view epoch does not capture.";
+    }
+
+    /// Tying buffer continuation to the GPU parameter-upload generation restarts the fill when an
+    /// upload lands mid-fill, so the displayed frame is never torn.
+    TEST(ProgressiveTearReproduction, ParamUploadMidFill_SceneViewAndParam_NeverTears)
+    {
+        EXPECT_FALSE(runParamUploadMidFillScenario(Policy::SceneViewAndParam, /*verbose*/ false))
+          << "A parameter-generation-aware continuation predicate should restart the fill on a "
+             "mid-fill upload so no torn frame is ever displayed.";
+    }
+
+    /// Minimal candidate fix reusing the EXISTING view-epoch machinery (the committed fix): bump
+    /// the view epoch when the parameter upload actually completes, instead of only at request
+    /// time. The in-flight fill that started against the old parameters then becomes view-outdated
+    /// and restarts, so the completed frame is param-consistent and never torn.
+    TEST(ProgressiveTearReproduction, ParamUploadMidFill_SceneAndView_BumpViewOnUpload_NeverTears)
+    {
+        EXPECT_FALSE(runParamUploadMidFillScenario(
+          Policy::SceneAndView, /*verbose*/ false, /*bumpViewOnUpload*/ true))
+          << "Bumping the view epoch when the parameter upload lands should restart the in-flight "
+             "fill via the existing view-outdated machinery, eliminating the parameter tear.";
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // Reproduction of the SECOND reported regression: "after resizing the HQ rendering stays at 0%".
+    //
+    // hqProgressiveRenderProgress() (RenderWindow.cpp) reports the HQ progress bar as:
+    //   active   = m_renderWindowState.isRendering && !m_renderWindowState.isMoving && height > 0
+    //   fraction = clamp(currentLine / height)
+    // So the bar shows a STUCK 0% whenever, after a resize, one of these holds persistently:
+    //   (A) isRendering never flips back to true (HQ never re-scheduled),           OR
+    //   (B) isMoving never clears (HQ reporting permanently gated off),              OR
+    //   (C) currentLine is pinned at 0 by a perpetual re-seed loop (continuation
+    //       predicate keeps failing, so every chunk restarts at line 0).
+    //
+    // This second simulation models the renderAsync ordering around a resize, the invalidateView()
+    // side effects, the low-res settle that is supposed to flip isRendering back on, and the NEW
+    // parameter-generation continuation key (m_asyncProgressiveParamGeneration) — including the fact
+    // that the resize barrier resets the scene/view epoch but does NOT reset the parameter
+    // generation stamp (the omission at RenderWindow.cpp L2176/2786/2912/2929/407). The parameter
+    // generation stamp is modelled as a SEPARATE value from the buffer (mirroring the real atomic),
+    // so it can drift out of sync with the buffer it is supposed to describe.
+    namespace
+    {
+        /// Snapshot of hqProgressiveRenderProgress() for a given tick.
+        struct HqProgress
+        {
+            bool active{false};
+            double fraction{0.0};
+            size_t currentLine{0};
+            size_t height{0};
+        };
+
+        /// Why HQ could not resume — used purely to make failing reproductions self-describing.
+        enum class HqStallReason
+        {
+            None,
+            NotRendering,  ///< isRendering == false (HQ never re-scheduled)
+            Moving,        ///< isMoving == true (progress reporting gated off)
+            ReseedLoop     ///< currentLine pinned at 0 by repeated continuation failure
+        };
+
+        char const * stallReasonName(HqStallReason r)
+        {
+            switch (r)
+            {
+            case HqStallReason::None:
+                return "None";
+            case HqStallReason::NotRendering:
+                return "NotRendering";
+            case HqStallReason::Moving:
+                return "Moving(isMoving stuck true)";
+            case HqStallReason::ReseedLoop:
+                return "ReseedLoop(currentLine pinned at 0)";
+            }
+            return "?";
+        }
+
+        /// GPU-free model of RenderWindow's resize -> low-res settle -> progressive-HQ resume path,
+        /// with the parameter-generation continuation key. One-frame worker latency: a chunk
+        /// scheduled in tick N produces its result at the start of tick N+1.
+        class ResizeHqProgressSim
+        {
+        public:
+            ResizeHqProgressSim(uint32_t width, uint32_t height, size_t chunkLines)
+                : m_width(width)
+                , m_height(height)
+                , m_chunkLines(chunkLines)
+            {
+                // Arm the first low-res settle so the warm-up reaches a completed HQ frame.
+                m_forceLowRes = true;
+                m_dirty = true;
+            }
+
+            /// Reset the observation latches AFTER the warm-up so the trace only reflects what
+            /// happens from the resize onward (frontPresented() is otherwise sticky).
+            void beginObservation()
+            {
+                m_frontPresented = false;
+            }
+
+            /// If true, the resize barrier ALSO resets the parameter-generation stamp (the candidate
+            /// fix). Default false models the SHIPPED code, where the stamp is left stale on resize.
+            void setResetParamGenOnResize(bool enable)
+            {
+                m_resetParamGenOnResize = enable;
+            }
+
+            /// Number of upcoming UI-side seeds that should fail (models tryGetBestRenderProgram()
+            /// returning nullopt while the optimized render program is still compiling). A failed
+            /// seed leaves the buffer unseeded AND does not store the parameter-generation stamp.
+            void setSeedFailures(int count)
+            {
+                m_seedFailuresRemaining = count;
+            }
+
+            /// Models the static settle never scheduling HQ again (e.g. an orphaned in-flight task
+            /// in RenderUpdateCoordinator), so the low-res settle never flips isRendering back on.
+            void setSettleNeverResumesHq(bool enable)
+            {
+                m_settleNeverResumesHq = enable;
+            }
+
+            /// invalidateViewDueToParameterChange(): bumps the view epoch and REQUESTS a new
+            /// parameter generation. The GPU parameter buffer is uploaded later (deliverParamUpload).
+            void parameterChange()
+            {
+                ++m_viewEpoch;
+                ++m_pendingParamGen;
+                invalidateView();
+            }
+
+            /// The async parameter upload reaches *m_primitives; updateParameterBlocking increments
+            /// the parameter generation (only on an ACTUAL change).
+            void deliverParamUpload()
+            {
+                if (m_gpuParamGen != m_pendingParamGen)
+                {
+                    m_gpuParamGen = m_pendingParamGen;
+                }
+            }
+
+            void requestResize(uint32_t w, uint32_t h)
+            {
+                m_desiredWidth = w;
+                m_desiredHeight = h;
+            }
+
+            HqProgress tick()
+            {
+                updateMovingFromCamera(); // render() updates isMoving every frame BEFORE renderAsync
+                processResults();
+                if (resizeBarrier())
+                {
+                    return hqProgress(); // deferred-resize early return mirrors renderAsync
+                }
+                lowResSettle();
+                scheduleChunkIfNeeded();
+                runWorker();
+                return hqProgress();
+            }
+
+            HqProgress hqProgress() const
+            {
+                HqProgress p{};
+                p.height = m_height;
+                p.currentLine = m_currentLine;
+                if (!m_isRendering || m_isMoving || m_height == 0)
+                {
+                    return p;
+                }
+                p.active = true;
+                p.fraction = std::min(1.0,
+                                      static_cast<double>(m_currentLine) /
+                                        static_cast<double>(m_height));
+                return p;
+            }
+
+            bool frontPresented() const
+            {
+                return m_frontPresented;
+            }
+
+        private:
+            void invalidateView()
+            {
+                m_dirty = true;
+                m_isMoving = true; // invalidateView() sets isMoving = true (RenderWindow.cpp L1241)
+                m_cameraIdleFrames = 0;
+                m_currentLine = 0;
+                m_isRendering = false;
+                m_forceLowRes = true;
+                // invalidateView() disarms HQ: the progressive fill is only re-scheduled after the
+                // forced low-res preview runs and the static catch-up re-arms it. This mirrors the
+                // RenderUpdateCoordinator gate — HQ chunks are not emitted from a bare dirty flag.
+                m_hqArmed = false;
+            }
+
+            /// Mirrors RenderWindow.cpp L1100-1104: every frame, with no actual camera motion, the
+            /// idle counter advances and isMoving stays true only for a short debounce window.
+            void updateMovingFromCamera()
+            {
+                ++m_cameraIdleFrames;
+                m_isMoving = m_cameraIdleFrames < kMovingDebounceFrames;
+            }
+
+            ProgressiveBufferState bufferState() const
+            {
+                return ProgressiveBufferState{.hasImage = m_prog.valid,
+                                              .epoch = m_prog.epoch,
+                                              .viewEpoch = m_prog.viewEpoch,
+                                              .paramGeneration = m_progParamGenStamp,
+                                              .width = m_prog.width,
+                                              .height = m_prog.height};
+            }
+
+            bool continuable(Job const & job) const
+            {
+                return isProgressiveBufferContinuable(
+                  bufferState(),
+                  ProgressiveJobTarget{.epoch = job.epoch,
+                                       .viewEpoch = job.viewEpoch,
+                                       .paramGeneration = job.paramGen,
+                                       .width = job.width,
+                                       .height = job.height});
+            }
+
+            /// The low-res preview that invalidateView() forced. In the real pipeline this preview
+            /// (and the static catch-up it triggers) is what flips isRendering back on so the
+            /// progressive HQ fill resumes. If the static settle is broken, HQ never resumes.
+            void lowResSettle()
+            {
+                if (!m_forceLowRes || m_jobInFlight)
+                {
+                    return;
+                }
+                m_forceLowRes = false;
+                m_resultStamp = LineStamp{static_cast<int64_t>(m_viewEpoch),
+                                          static_cast<int64_t>(m_gpuParamGen)};
+                m_lastLowResViewEpoch = m_viewEpoch;
+                if (!m_settleNeverResumesHq)
+                {
+                    m_hqArmed = true; // static catch-up arms the progressive HQ fill
+                }
+            }
+
+            void scheduleChunkIfNeeded()
+            {
+                if (m_jobInFlight || m_isMoving)
+                {
+                    return;
+                }
+                // HQ chunks are only emitted while the fill is armed by the static catch-up.
+                // A bare dirty flag is NOT enough — that models the coordinator gate so an
+                // orphaned in-flight task (settle never re-arms) keeps HQ from ever scheduling.
+                if (!m_hqArmed)
+                {
+                    return;
+                }
+
+                Job job{};
+                job.active = true;
+                job.epoch = m_sceneEpoch;
+                job.viewEpoch = m_viewEpoch;
+                job.paramGen = m_gpuParamGen;
+                job.width = m_width;
+                job.height = m_height;
+
+                bool const seeded = continuable(job);
+                if (m_currentLine > 0 && !seeded)
+                {
+                    m_currentLine = 0;
+                }
+                job.startLine = std::min(m_currentLine, static_cast<size_t>(job.height));
+                job.stepSize = std::max<size_t>(
+                  1, std::min(m_chunkLines, static_cast<size_t>(job.height) - job.startLine));
+
+                if (job.startLine == 0 && !seeded)
+                {
+                    bool const seedFails = m_seedFailuresRemaining > 0;
+                    if (seedFails)
+                    {
+                        --m_seedFailuresRemaining;
+                        // Seed failed (no render program): buffer NOT seeded, stamp NOT stored.
+                        // isRendering is still set below, so the bar is active but currentLine
+                        // cannot advance until a seed finally succeeds.
+                    }
+                    else
+                    {
+                        m_prog.allocate(job.width, job.height, m_resultStamp);
+                        m_prog.epoch = job.epoch;
+                        m_prog.viewEpoch = job.viewEpoch;
+                        m_progParamGenStamp = job.paramGen; // seed stores stamp ONLY on success
+                    }
+                }
+
+                m_dirty = false;
+                m_isRendering = true;
+                m_jobInFlight = true;
+                m_inFlightEpoch = job.epoch;
+                m_pendingJob = job;
+            }
+
+            void runWorker()
+            {
+                if (!m_pendingJob.active)
+                {
+                    return;
+                }
+                Job const job = m_pendingJob;
+                m_pendingJob = Job{};
+
+                if (m_seedFailuresRemaining > 0 && !m_prog.valid)
+                {
+                    // Render program still unavailable: the worker cannot acquire/seed a buffer
+                    // either, so this chunk renders nothing. isRendering stays true (bar active),
+                    // but currentLine is pinned at 0 — reproduction of 'active but stuck at 0%'.
+                    Result none{};
+                    none.present = true;
+                    none.epoch = job.epoch;
+                    none.viewEpoch = job.viewEpoch;
+                    none.width = job.width;
+                    none.height = job.height;
+                    none.completedLine = job.startLine; // no progress
+                    none.completedFrame = false;
+                    m_pendingResult = none;
+                    return;
+                }
+
+                if (!continuable(job))
+                {
+                    // Worker acquire-fresh branch re-stamps the parameter generation.
+                    m_prog.allocate(job.width, job.height, LineStamp{});
+                    m_prog.epoch = job.epoch;
+                    m_prog.viewEpoch = job.viewEpoch;
+                    m_progParamGenStamp = job.paramGen;
+                }
+                else if (!m_prog.valid)
+                {
+                    // UI seed failed but predicate says "continuable" because the stale stamp still
+                    // matches: there is no buffer to render into, so this chunk produces nothing.
+                    Result none{};
+                    none.present = true;
+                    none.epoch = job.epoch;
+                    none.viewEpoch = job.viewEpoch;
+                    none.width = job.width;
+                    none.height = job.height;
+                    none.completedLine = job.startLine; // no progress
+                    none.completedFrame = false;
+                    m_pendingResult = none;
+                    return;
+                }
+
+                size_t const endLine =
+                  std::min(job.startLine + job.stepSize, static_cast<size_t>(job.height));
+                LineStamp const hqStamp{static_cast<int64_t>(job.viewEpoch),
+                                        static_cast<int64_t>(m_gpuParamGen)};
+                for (size_t y = job.startLine; y < endLine && y < m_prog.lines.size(); ++y)
+                {
+                    m_prog.lines[y] = hqStamp;
+                }
+
+                Result r{};
+                r.present = true;
+                r.epoch = job.epoch;
+                r.viewEpoch = job.viewEpoch;
+                r.width = job.width;
+                r.height = job.height;
+                r.completedLine = endLine;
+                r.completedFrame = endLine >= static_cast<size_t>(job.height);
+                if (r.completedFrame)
+                {
+                    m_ready = m_prog;
+                    m_prog.clear();
+                }
+                m_pendingResult = r;
+            }
+
+            void processResults()
+            {
+                if (!m_pendingResult.present)
+                {
+                    return;
+                }
+                Result const r = m_pendingResult;
+                m_pendingResult = Result{};
+
+                bool const isOutdated = r.epoch < m_sceneEpoch;
+                bool const isViewOutdated = r.viewEpoch < m_viewEpoch;
+                bool const isSizeOutdated = r.width != m_width || r.height != m_height;
+                bool const discard = isOutdated || isViewOutdated || isSizeOutdated;
+
+                if (r.completedFrame)
+                {
+                    if (!discard)
+                    {
+                        m_front = m_ready;
+                        m_frontPresented = true;
+                        m_isRendering = false;
+                        m_currentLine = 0;
+                        m_hqArmed = false; // a completed frame disarms until the next settle
+                    }
+                    m_ready.clear();
+                }
+                else if (!discard)
+                {
+                    m_currentLine = std::min(r.completedLine, static_cast<size_t>(r.height));
+                }
+
+                if (r.epoch == m_inFlightEpoch)
+                {
+                    m_jobInFlight = false;
+                    m_inFlightEpoch = 0;
+                    if (discard)
+                    {
+                        m_isRendering = false;
+                        m_dirty = true;
+                    }
+                }
+            }
+
+            /// Returns true if a deferred-resize early-return happened this tick.
+            bool resizeBarrier()
+            {
+                bool const resizeRequired =
+                  m_desiredWidth != 0 &&
+                  (m_desiredWidth != m_width || m_desiredHeight != m_height);
+                if (!resizeRequired)
+                {
+                    return false;
+                }
+                if (m_jobInFlight)
+                {
+                    // HQ render in flight: defer, drop to low-res, and early-return.
+                    m_dirty = true;
+                    m_forceLowRes = true;
+                    m_isRendering = false;
+                    return true;
+                }
+                if (m_prog.valid)
+                {
+                    m_prog.clear();
+                }
+                m_width = m_desiredWidth;
+                m_height = m_desiredHeight;
+                m_desiredWidth = 0;
+                m_desiredHeight = 0;
+                // Resize releases the buffer and resets scene/view epoch, but the parameter
+                // generation stamp is left stale unless the candidate fix is enabled.
+                ++m_sceneEpoch;
+                ++m_viewEpoch;
+                if (m_resetParamGenOnResize)
+                {
+                    m_progParamGenStamp = 0;
+                }
+                invalidateView();
+                return false;
+            }
+
+            uint32_t m_width{0};
+            uint32_t m_height{0};
+            size_t m_chunkLines{0};
+
+            static constexpr int kMovingDebounceFrames = 3;
+
+            uint64_t m_sceneEpoch{1};
+            uint64_t m_viewEpoch{1};
+            uint64_t m_gpuParamGen{1};
+            uint64_t m_pendingParamGen{1};
+            uint64_t m_progParamGenStamp{0}; ///< models the SEPARATE m_asyncProgressiveParamGeneration
+
+            size_t m_currentLine{0};
+            bool m_isRendering{false};
+            bool m_isMoving{false};
+            bool m_dirty{false};
+            bool m_forceLowRes{false};
+            int m_cameraIdleFrames{kMovingDebounceFrames};
+
+            bool m_resetParamGenOnResize{false};
+            int m_seedFailuresRemaining{0};
+            bool m_settleNeverResumesHq{false};
+            bool m_hqArmed{false};
+
+            LineStamp m_resultStamp{1, 1};
+            uint64_t m_lastLowResViewEpoch{1};
+
+            MockImage m_prog{};
+            MockImage m_front{};
+            MockImage m_ready{};
+            bool m_frontPresented{false};
+
+            bool m_jobInFlight{false};
+            uint64_t m_inFlightEpoch{0};
+            Job m_pendingJob{};
+            Result m_pendingResult{};
+
+            uint32_t m_desiredWidth{0};
+            uint32_t m_desiredHeight{0};
+        };
+
+        /// Summary of an HQ-progress run: peak fraction reached and whether HQ ever completed.
+        struct HqRunSummary
+        {
+            double maxFraction{0.0};
+            bool everActive{false};
+            bool completed{false};
+            HqStallReason stallReason{HqStallReason::None};
+            int ticksStuckAtZero{0}; ///< consecutive trailing ticks with fraction==0 (active or not)
+        };
+
+        /// Drive the sim forward, recording the HQ-progress trace. `setup` runs against the sim
+        /// BEFORE the observation loop (e.g. to request a resize / change a parameter).
+        template <typename SetupFn>
+        HqRunSummary observeHqAfter(ResizeHqProgressSim & sim,
+                                    int ticks,
+                                    bool verbose,
+                                    SetupFn && setup)
+        {
+            // Warm up to a clean steady state with a completed HQ frame.
+            for (int i = 0; i < 12; ++i)
+            {
+                sim.tick();
+            }
+            sim.tick(); // one extra so any pending result is consumed
+
+            sim.beginObservation(); // forget the warm-up's completed frame; observe from here on
+            setup(sim);
+
+            HqRunSummary s{};
+            int trailingZero = 0;
+            for (int t = 0; t < ticks; ++t)
+            {
+                HqProgress const p = sim.tick();
+                s.maxFraction = std::max(s.maxFraction, p.fraction);
+                s.everActive = s.everActive || p.active;
+                s.completed = s.completed || sim.frontPresented();
+                if (p.fraction == 0.0)
+                {
+                    ++trailingZero;
+                }
+                else
+                {
+                    trailingZero = 0;
+                }
+                if (verbose)
+                {
+                    std::cout << "  t" << t << " active=" << (p.active ? "1" : "0")
+                              << " frac=" << p.fraction << " line=" << p.currentLine << "/"
+                              << p.height << (sim.frontPresented() ? " [HQ done]" : "") << "\n";
+                }
+            }
+            s.ticksStuckAtZero = trailingZero;
+
+            if (!s.completed)
+            {
+                if (!s.everActive)
+                {
+                    s.stallReason = HqStallReason::NotRendering;
+                }
+                else if (s.maxFraction == 0.0)
+                {
+                    s.stallReason = HqStallReason::ReseedLoop;
+                }
+            }
+            return s;
+        }
+    } // namespace
+
+    /// Control: a plain resize (no parameter change, render program available) must let the HQ
+    /// progressive fill resume and run to completion — progress climbs above 0 and reaches 100%.
+    TEST(ResizeHqProgress, PlainResize_HqResumesAndCompletes)
+    {
+        ResizeHqProgressSim sim(/*w*/ 100, /*h*/ 100, /*chunk*/ 25);
+        HqRunSummary const s = observeHqAfter(
+          sim, /*ticks*/ 40, /*verbose*/ false, [](ResizeHqProgressSim & x) { x.requestResize(140, 140); });
+
+        EXPECT_TRUE(s.completed) << "Plain resize should let HQ run to completion (front presented).";
+        EXPECT_GT(s.maxFraction, 0.0) << "HQ progress must climb above 0% after a plain resize.";
+    }
+
+    /// Observation harness — prints the HQ-progress trace for the resize-then-parameter-upload
+    /// case so the stuck-at-0% behaviour is visible in the test log.
+    TEST(ResizeHqProgress, Observe_ParamChangeThenResize_Trace)
+    {
+        std::cout << "\n=== ParamChange -> Resize -> mid-fill param upload (shipped, stamp NOT reset) ===\n";
+        ResizeHqProgressSim sim(/*w*/ 100, /*h*/ 100, /*chunk*/ 20);
+        HqRunSummary const s = observeHqAfter(
+          sim, /*ticks*/ 24, /*verbose*/ true,
+          [](ResizeHqProgressSim & x)
+          {
+              x.parameterChange();
+              x.requestResize(140, 140);
+          });
+        std::cout << "  => maxFraction=" << s.maxFraction << " completed=" << (s.completed ? "1" : "0")
+                  << " stall=" << stallReasonName(s.stallReason) << "\n";
+    }
+
+    /// REPRODUCTION: if the optimized render program never becomes available again after the
+    /// resize (tryGetBestRenderProgram() keeps returning nullopt), neither the UI seed nor the
+    /// worker can acquire a buffer to render into. isRendering is set (the bar is ACTIVE), but
+    /// currentLine cannot advance, so the HQ bar sits at 0% indefinitely — a direct reproduction
+    /// of 'after resizing the HQ rendering stays at 0%'.
+    TEST(ResizeHqProgress, RenderProgramUnavailableAfterResize_BarActiveButStuckAtZero)
+    {
+        ResizeHqProgressSim sim(/*w*/ 100, /*h*/ 100, /*chunk*/ 20);
+        sim.setSeedFailures(1000); // render program never becomes available during the window
+        HqRunSummary const s = observeHqAfter(
+          sim, /*ticks*/ 30, /*verbose*/ false, [](ResizeHqProgressSim & x) { x.requestResize(140, 140); });
+
+        EXPECT_FALSE(s.completed) << "With the render program unavailable, HQ cannot complete.";
+        EXPECT_TRUE(s.everActive)
+          << "The HQ bar is ACTIVE (isRendering set) yet makes no progress.";
+        EXPECT_EQ(s.maxFraction, 0.0)
+          << "HQ progress is pinned at 0% — reproduction of the 'stays at 0% after resize' report.";
+        EXPECT_GT(s.ticksStuckAtZero, 0) << "The 0% state must persist (not a one-frame blip).";
+    }
+
+    /// REPRODUCTION: if the static settle never re-arms HQ after the resize (orphaned in-flight
+    /// coordinator task class), isRendering never returns to true, so the HQ bar reports inactive
+    /// forever — another way the bar 'stays at 0%'.
+    TEST(ResizeHqProgress, SettleNeverResumesHq_StuckInactive)
+    {
+        ResizeHqProgressSim sim(/*w*/ 100, /*h*/ 100, /*chunk*/ 25);
+        sim.setSettleNeverResumesHq(true);
+        HqRunSummary const s = observeHqAfter(
+          sim, /*ticks*/ 30, /*verbose*/ false, [](ResizeHqProgressSim & x) { x.requestResize(140, 140); });
+
+        EXPECT_FALSE(s.completed) << "HQ never completes if the settle never re-arms it.";
+        EXPECT_FALSE(s.everActive)
+          << "The HQ bar never becomes active — reproduction of the perpetual 0% after resize.";
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/RenderModeUpdatePolicy_tests.cpp b/gladius/tests/unittests/ui/render/RenderModeUpdatePolicy_tests.cpp
new file mode 100644
index 00000000..10462fce
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/RenderModeUpdatePolicy_tests.cpp
@@ -0,0 +1,271 @@
+#include "ui/render/RenderModeUpdatePolicy.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithForceParameterInteraction_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Force,
+                                   .interactionState = RenderInteractionState::ParameterInteracting,
+                                   .stateIsMoving = true,
+                                   .forceLowResRender = true,
+                                   .lowResFeedbackPending = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithForceCameraInteraction_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Force,
+                                   .interactionState = RenderInteractionState::CameraInteracting,
+                                   .stateIsMoving = true,
+                                   .forceLowResRender = true,
+                                   .lowResFeedbackPending = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithForceStaticMoving_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Force,
+                                   .interactionState = RenderInteractionState::Static,
+                                   .stateIsMoving = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithAutoRealtimeActive_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Auto,
+                                   .interactionState = RenderInteractionState::CameraInteracting,
+                                   .autoRealtimeActive = true,
+                                   .stateIsMoving = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithAutoRealtimeActiveStaticMoving_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Auto,
+                                   .interactionState = RenderInteractionState::Static,
+                                   .autoRealtimeActive = true,
+                                   .stateIsMoving = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithAutoPreviewParameterInteraction_IsAllowed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Auto,
+                                   .interactionState = RenderInteractionState::ParameterInteracting,
+                                   .autoRealtimeActive = false,
+                                   .lowResFeedbackPending = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_TRUE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithAutoRealtimeActiveParameterInteraction_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Auto,
+                                   .interactionState = RenderInteractionState::ParameterInteracting,
+                                   .autoRealtimeActive = true,
+                                   .lowResFeedbackPending = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithOffCameraInteraction_IsAllowed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Off,
+                                   .interactionState = RenderInteractionState::CameraInteracting,
+                                   .stateIsMoving = true,
+                                   .exactRealtimeJobInFlight = false});
+
+        EXPECT_TRUE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, LegacyLowResPreview_WithExactRealtimeInFlight_IsSuppressed)
+    {
+        auto const decision = shouldUseLegacyLowResPreview(
+          LegacyLowResPreviewInput{.mode = RealtimeRaymarchMode::Off,
+                                   .interactionState = RenderInteractionState::ParameterInteracting,
+                                   .lowResFeedbackPending = true,
+                                   .exactRealtimeJobInFlight = true});
+
+        EXPECT_FALSE(decision);
+    }
+
+    TEST(RenderModeUpdatePolicy, ExactRealtimeInteraction_WithAutoRealtimeActive_IsActive)
+    {
+        auto const active = isExactRealtimeInteractionActive(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Auto,
+                                           .interactionState = RenderInteractionState::CameraInteracting,
+                                           .autoRealtimeActive = true,
+                                           .autoPreviewFallbackActive = false,
+                                           .exactRealtimeJobInFlight = false});
+
+        EXPECT_TRUE(active);
+    }
+
+    TEST(RenderModeUpdatePolicy, ExactRealtimeInteraction_WithAutoFallbackPreview_IsNotActive)
+    {
+        auto const active = isExactRealtimeInteractionActive(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Auto,
+                                           .interactionState = RenderInteractionState::CameraInteracting,
+                                           .autoRealtimeActive = true,
+                                           .autoPreviewFallbackActive = true,
+                                           .exactRealtimeJobInFlight = false});
+
+        EXPECT_FALSE(active);
+    }
+
+    TEST(RenderModeUpdatePolicy, ExactRealtimeInteraction_WithForce_IsActive)
+    {
+        auto const active = isExactRealtimeInteractionActive(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Force,
+                                           .interactionState = RenderInteractionState::CameraInteracting});
+
+        EXPECT_TRUE(active);
+    }
+
+    TEST(RenderModeUpdatePolicy, ExactRealtimeInteraction_WithStaticState_IsNotActive)
+    {
+        auto const active = isExactRealtimeInteractionActive(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Force,
+                                           .interactionState = RenderInteractionState::Static,
+                                           .exactRealtimeJobInFlight = true});
+
+        EXPECT_FALSE(active);
+    }
+
+    TEST(RenderModeUpdatePolicy, RealtimeFrameExecution_WithStaticAutoRealtimeActive_UsesAsyncWorker)
+    {
+        auto const path = chooseRealtimeFrameExecutionPath(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Auto,
+                                           .interactionState = RenderInteractionState::Static,
+                                           .autoRealtimeActive = true});
+
+        EXPECT_EQ(path, RealtimeFrameExecutionPath::AsyncWorker);
+    }
+
+    TEST(RenderModeUpdatePolicy, RealtimeFrameExecution_WithAutoExactInteraction_UsesSynchronousUiThread)
+    {
+        auto const path = chooseRealtimeFrameExecutionPath(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Auto,
+                                           .interactionState = RenderInteractionState::CameraInteracting,
+                                           .autoRealtimeActive = true,
+                                           .autoPreviewFallbackActive = false});
+
+        EXPECT_EQ(path, RealtimeFrameExecutionPath::SynchronousUiThread);
+    }
+
+    TEST(RenderModeUpdatePolicy, RealtimeFrameExecution_WithAutoPreviewFallback_UsesAsyncWorker)
+    {
+        auto const path = chooseRealtimeFrameExecutionPath(
+          RealtimeInteractionActivityInput{.mode = RealtimeRaymarchMode::Auto,
+                                           .interactionState = RenderInteractionState::CameraInteracting,
+                                           .autoRealtimeActive = true,
+                                           .autoPreviewFallbackActive = true});
+
+        EXPECT_EQ(path, RealtimeFrameExecutionPath::AsyncWorker);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithForce_InvalidatesWithoutStreaming)
+    {
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Force,
+                                       .streamingPreviewActive = false});
+
+        EXPECT_TRUE(dispatch.invalidateInteraction);
+        EXPECT_FALSE(dispatch.refreshStreamingInteraction);
+        EXPECT_FALSE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithAutoFirstChange_StartsStreaming)
+    {
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Auto,
+                                       .streamingPreviewActive = false});
+
+        EXPECT_TRUE(dispatch.invalidateInteraction);
+        EXPECT_FALSE(dispatch.refreshStreamingInteraction);
+        EXPECT_TRUE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithOffFirstChange_StartsStreaming)
+    {
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Off,
+                                       .streamingPreviewActive = false});
+
+        EXPECT_TRUE(dispatch.invalidateInteraction);
+        EXPECT_FALSE(dispatch.refreshStreamingInteraction);
+        EXPECT_TRUE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithAutoStreamingActive_RefreshesInteraction)
+    {
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Auto,
+                                       .streamingPreviewActive = true});
+
+        EXPECT_FALSE(dispatch.invalidateInteraction);
+        EXPECT_TRUE(dispatch.refreshStreamingInteraction);
+        EXPECT_FALSE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithOffStreamingActive_RefreshesInteraction)
+    {
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Off,
+                                       .streamingPreviewActive = true});
+
+        EXPECT_FALSE(dispatch.invalidateInteraction);
+        EXPECT_TRUE(dispatch.refreshStreamingInteraction);
+        EXPECT_FALSE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithAutoRealtimeActiveNoStreaming_InvalidatesWithoutStreaming)
+    {
+        // When Auto mode has confirmed the GPU is fast enough, parameter changes should
+        // take the direct realtime path rather than starting a streaming preview.
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Auto,
+                                       .streamingPreviewActive = false,
+                                       .autoRealtimeActive = true});
+
+        EXPECT_TRUE(dispatch.invalidateInteraction);
+        EXPECT_FALSE(dispatch.refreshStreamingInteraction);
+        EXPECT_FALSE(dispatch.startStreamingPreview);
+    }
+
+    TEST(RenderModeUpdatePolicy, ParameterChangeDispatch_WithAutoRealtimeActiveStreamingActive_InvalidatesWithoutStreaming)
+    {
+        // Even when streaming preview was already active, switching to realtime should
+        // not keep feeding it.
+        auto const dispatch = classifyParameterChange(
+          ParameterChangeDispatchInput{.mode = RealtimeRaymarchMode::Auto,
+                                       .streamingPreviewActive = true,
+                                       .autoRealtimeActive = true});
+
+        EXPECT_TRUE(dispatch.invalidateInteraction);
+        EXPECT_FALSE(dispatch.refreshStreamingInteraction);
+        EXPECT_FALSE(dispatch.startStreamingPreview);
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp b/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp
new file mode 100644
index 00000000..fdc5a59b
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp
@@ -0,0 +1,855 @@
+#include "ui/render/RenderUpdateCoordinator.h"
+
+#include <gtest/gtest.h>
+
+#include <optional>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] std::optional<RenderTaskRequest> findStartedTask(RenderUpdateDecision const & decision,
+                                                                       RenderTaskType type)
+        {
+            for (auto const & command : decision.commands)
+            {
+                if (command.type == RenderCommandType::StartTask && command.task.type == type)
+                {
+                    return command.task;
+                }
+            }
+            return std::nullopt;
+        }
+
+        [[nodiscard]] bool hasCommand(RenderUpdateDecision const & decision, RenderCommandType type)
+        {
+            for (auto const & command : decision.commands)
+            {
+                if (command.type == type)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        [[nodiscard]] bool hasStartedTask(RenderUpdateDecision const & decision, RenderTaskType type)
+        {
+            return findStartedTask(decision, type).has_value();
+        }
+
+        [[nodiscard]] RenderTaskResult completed(RenderTaskRequest const & request,
+                                                 bool producedDisplayFrame = false,
+                                                 bool completedFrame = false)
+        {
+            return RenderTaskResult{.requestId = request.requestId,
+                                    .type = request.type,
+                                    .stamp = request.stamp,
+                                    .status = RenderTaskStatus::Completed,
+                                    .durationNs = 200'000'000,
+                                    .producedDisplayFrame = producedDisplayFrame,
+                                    .completedFrame = completedFrame};
+        }
+
+        [[nodiscard]] RenderTaskResult failed(RenderTaskRequest const & request)
+        {
+            auto result = completed(request);
+            result.status = RenderTaskStatus::Failed;
+            return result;
+        }
+
+        [[nodiscard]] RealtimeRaymarchConfig forcedRealtimeConfig()
+        {
+            RealtimeRaymarchConfig config{};
+            config.mode = RealtimeRaymarchMode::Force;
+            return config;
+        }
+
+        [[nodiscard]] RealtimeRaymarchSample fullFrameSample(float durationMs)
+        {
+            return RealtimeRaymarchSample{.durationMs = durationMs,
+                                          .width = 640,
+                                          .height = 480,
+                                          .renderedLines = 480,
+                                          .totalLines = 480,
+                                          .completedFrame = true,
+                                          .cancelled = false};
+        }
+
+        [[nodiscard]] RealtimeRaymarchSample progressiveChunkSample(float durationMs)
+        {
+            return RealtimeRaymarchSample{.durationMs = durationMs,
+                                          .width = 640,
+                                          .height = 480,
+                                          .renderedLines = 48,
+                                          .totalLines = 480,
+                                          .completedFrame = false,
+                                          .cancelled = false};
+        }
+
+        /// Drives the coordinator through the static pipeline until a fast progressive estimate
+        /// admits an async static full-frame probe, and the completed probe unlocks Auto exact interaction.
+        /// Call immediately after configureViewport(), passing its returned decision.
+        void primeAutoRealtimeAdmission(RenderUpdateCoordinator & coordinator,
+                                        RenderUpdateDecision const & viewportDecision)
+        {
+            auto bbox = findStartedTask(viewportDecision, RenderTaskType::BoundingBoxUpdate);
+            ASSERT_TRUE(bbox.has_value());
+            auto decision = coordinator.completeTask(completed(*bbox));
+            auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+            ASSERT_TRUE(sdf.has_value());
+            decision = coordinator.completeTask(completed(*sdf));
+            auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+            ASSERT_TRUE(hq.has_value());
+            coordinator.recordStaticProgressiveSample(progressiveChunkSample(5.0f));
+            decision = coordinator.completeTask(completed(*hq));
+            auto staticFullFrame = findStartedTask(decision, RenderTaskType::StaticFullFrameProbe);
+            ASSERT_TRUE(staticFullFrame.has_value());
+            coordinator.recordStaticFullFrameSample(fullFrameSample(50.0f));
+            [[maybe_unused]] auto const finalDecision =
+                coordinator.completeTask(completed(*staticFullFrame, true, true));
+        }
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoLearning_StartsLowResolutionPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+        auto const before = coordinator.latestStamp();
+
+        auto const decision = coordinator.notifyCameraChanged();
+        auto const after = coordinator.latestStamp();
+
+        EXPECT_EQ(after.sceneEpoch, before.sceneEpoch);
+        EXPECT_EQ(after.parameterEpoch, before.parameterEpoch);
+        EXPECT_EQ(after.viewportEpoch, before.viewportEpoch);
+        EXPECT_EQ(after.viewEpoch, before.viewEpoch + 1u);
+        EXPECT_EQ(coordinator.interactionState(), RenderInteractionState::CameraInteracting);
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoPreviewInFlight_KeepsCurrentFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto decision = coordinator.notifyCameraChanged();
+        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, StaticCatchUp_AfterFastProgressiveEstimate_StartsStaticFullFrameProbe)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.configureViewport(640, 480);
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(progressive.has_value());
+
+        coordinator.recordStaticProgressiveSample(progressiveChunkSample(5.0f));
+
+        decision = coordinator.completeTask(completed(*progressive));
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::StaticFullFrameProbe));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+    }
+
+    TEST(RenderUpdateCoordinator, StaticCatchUp_WithResizePending_DoesNotStartStaticFullFrameProbe)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.configureViewport(640, 480);
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(progressive.has_value());
+
+        coordinator.recordStaticProgressiveSample(progressiveChunkSample(5.0f));
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.resizePending = true;
+        coordinator.setRealtimeGuards(guards);
+
+        decision = coordinator.completeTask(completed(*progressive));
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::StaticFullFrameProbe));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+    }
+
+    TEST(RenderUpdateCoordinator, StaticCatchUp_AfterSlowProgressiveEstimate_ContinuesProgressive)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.configureViewport(640, 480);
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(progressive.has_value());
+
+        coordinator.recordStaticProgressiveSample(progressiveChunkSample(12.0f));
+
+        decision = coordinator.completeTask(completed(*progressive));
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::StaticFullFrameProbe));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_AfterFastProgressiveEstimateBeforeStaticProbe_ComesFromPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.configureViewport(640, 480);
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(progressive.has_value());
+
+        coordinator.recordStaticProgressiveSample(progressiveChunkSample(5.0f));
+        decision = coordinator.completeTask(completed(*progressive));
+        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::StaticFullFrameProbe));
+        EXPECT_FALSE(coordinator.isRealtimeActive());
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::StaticFullFrameProbe));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtime_StartsRealtimeFullFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto const decision = coordinator.notifyCameraChanged();
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeInFlight_KeepsCurrentFrameWithoutPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto decision = coordinator.notifyCameraChanged();
+        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeAfterFastSamples_StartsRealtimeFullFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+
+        auto const decision = coordinator.notifyCameraChanged();
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeInFlight_KeepsCurrentFrameWithoutPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+
+        auto decision = coordinator.notifyCameraChanged();
+        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeGuardBlocker_FallsBackToPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        coordinator.setRealtimeGuards(guards);
+
+        auto const decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+        EXPECT_TRUE(coordinator.isAutoPreviewFallbackActive());
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoPreviewFallbackLatch_StaysPreviewUntilGestureEnds)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        coordinator.setRealtimeGuards(guards);
+
+        auto decision = coordinator.notifyCameraChanged();
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+        EXPECT_TRUE(coordinator.isAutoPreviewFallbackActive());
+
+        coordinator.setRealtimeGuards(async_rendering::RealtimeRaymarchGuards{});
+        decision = coordinator.completeTask(completed(*preview, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
+
+        decision = coordinator.notifyCameraChanged();
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(coordinator.isAutoPreviewFallbackActive());
+
+        (void) coordinator.notifyCameraInteractionEnded();
+        EXPECT_FALSE(coordinator.isAutoPreviewFallbackActive());
+    }
+
+    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithAutoRealtimeCurrentHq_KeepsCurrentFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+
+        auto decision = coordinator.notifyCameraChanged();
+        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(realtime.has_value());
+
+        decision = coordinator.completeTask(completed(*realtime, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
+
+        decision = coordinator.notifyCameraInteractionEnded();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithStaleAutoRealtime_StartsHqNotPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+
+        auto decision = coordinator.notifyCameraChanged();
+        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(realtime.has_value());
+
+        decision = coordinator.notifyCameraChanged();
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        decision = coordinator.completeTask(completed(*realtime, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.notifyCameraInteractionEnded();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeAndCurrentHq_EndsInteractionWithoutExtraHq)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto decision = coordinator.notifyCameraChanged();
+        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(realtime.has_value());
+
+        decision = coordinator.completeTask(completed(*realtime, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
+
+        decision = coordinator.notifyCameraInteractionEnded();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeGuardBlocker_KeepsCurrentFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        coordinator.setRealtimeGuards(guards);
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto const decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraChanged_WithResizePendingEvenForcedRealtime_KeepsCurrentFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.resizePending = true;
+        coordinator.setRealtimeGuards(guards);
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto const decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, FailedForcedRealtime_DoesNotFallbackToPreviewWhileGuarded)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto decision = coordinator.notifyCameraChanged();
+        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(realtime.has_value());
+
+        decision = coordinator.completeTask(failed(*realtime));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        coordinator.setRealtimeGuards(guards);
+        decision = coordinator.tick();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, ParameterDrag_WithForcedRealtime_StartsRealtimeFullFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto const decision = coordinator.notifyParameterChanged(true);
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, ParameterDrag_WithForcedRealtimeGuardBlocker_KeepsCurrentFrame)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+        async_rendering::RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        coordinator.setRealtimeGuards(guards);
+
+        auto const decision = coordinator.notifyParameterChanged(true);
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, ContinuousParameterDrag_WithForcedRealtimeInFlight_NeverStartsPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.configureRealtime(forcedRealtimeConfig());
+        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+        auto decision = coordinator.notifyParameterChanged(true);
+        auto firstUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(firstUpload.has_value());
+        auto firstRealtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(firstRealtime.has_value());
+
+        decision = coordinator.notifyParameterChanged(true);
+        auto const latestStamp = coordinator.latestStamp();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        decision = coordinator.completeTask(completed(*firstUpload));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.tick();
+        auto latestUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(latestUpload.has_value());
+        EXPECT_TRUE(matches(latestUpload->stamp, latestStamp, RenderStampMask::heavyGeometryTask()));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+
+        decision = coordinator.completeTask(completed(*firstRealtime, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.completeTask(completed(*latestUpload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+
+        decision = coordinator.tick();
+        auto latestRealtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(latestRealtime.has_value());
+        EXPECT_TRUE(matches(latestRealtime->stamp, latestStamp, RenderStampMask::displayFrame()));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, ParameterDrag_StartsUploadAndPreviewButDefersHeavyTasks)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const before = coordinator.latestStamp();
+
+        auto const decision = coordinator.notifyParameterChanged(true);
+        auto const after = coordinator.latestStamp();
+
+        EXPECT_EQ(after.sceneEpoch, before.sceneEpoch);
+        EXPECT_EQ(after.parameterEpoch, before.parameterEpoch + 1u);
+        EXPECT_EQ(coordinator.interactionState(), RenderInteractionState::ParameterInteracting);
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+    }
+
+    TEST(RenderUpdateCoordinator, ParameterDrag_WithUploadInFlight_CoalescesToLatestUpload)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyParameterChanged(true);
+        auto firstUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(firstUpload.has_value());
+
+        decision = coordinator.notifyParameterChanged(true);
+        auto const latest = coordinator.latestStamp();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        decision = coordinator.completeTask(completed(*firstUpload));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.tick();
+        auto latestUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(latestUpload.has_value());
+        EXPECT_TRUE(matches(latestUpload->stamp, latest, RenderStampMask::heavyGeometryTask()));
+    }
+
+    TEST(RenderUpdateCoordinator, ContinuousParameterDrag_WithStaleAutoPreview_CompletesLatestPreview)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyParameterChanged(true);
+        auto firstUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(firstUpload.has_value());
+        auto firstPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(firstPreview.has_value());
+
+        decision = coordinator.notifyParameterChanged(true);
+        auto const latestStamp = coordinator.latestStamp();
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        decision = coordinator.completeTask(completed(*firstUpload));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.completeTask(completed(*firstPreview, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.tick();
+        auto latestUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(latestUpload.has_value());
+        EXPECT_TRUE(matches(latestUpload->stamp, latestStamp, RenderStampMask::heavyGeometryTask()));
+        auto latestPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(latestPreview.has_value());
+        EXPECT_TRUE(matches(latestPreview->stamp, latestStamp, RenderStampMask::displayFrame()));
+
+        decision = coordinator.completeTask(completed(*latestUpload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, ParameterChanged_AfterRealtimeLearning_ResetsToProgressiveStaticLearning)
+    {
+        RenderUpdateCoordinator coordinator;
+        coordinator.recordStaticFullFrameSample(fullFrameSample(15.0f));
+        coordinator.recordStaticFullFrameSample(fullFrameSample(16.0f));
+        coordinator.recordStaticFullFrameSample(fullFrameSample(17.0f));
+        ASSERT_TRUE(coordinator.isRealtimeActive());
+
+        auto decision = coordinator.notifyParameterChanged(false);
+        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(upload.has_value());
+        EXPECT_FALSE(coordinator.isRealtimeActive());
+
+        decision = coordinator.completeTask(completed(*upload));
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, ActiveParameterChanged_AfterFastAutoSample_ResetsInteractionAdmission)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto const viewportDecision = coordinator.configureViewport(640, 480);
+        ASSERT_FALSE(viewportDecision.commands.empty());
+        primeAutoRealtimeAdmission(coordinator, viewportDecision);
+
+        auto decision = coordinator.notifyParameterChanged(true);
+        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(upload.has_value());
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+
+        [[maybe_unused]] auto const uploadDecision = coordinator.completeTask(completed(*upload));
+        [[maybe_unused]] auto const previewDecision = coordinator.completeTask(completed(*preview, true, true));
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+    }
+
+    TEST(RenderUpdateCoordinator, StaticCatchUp_AfterParameterEdit_SequencesUploadBboxSdfThenHq)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyParameterChanged(true);
+        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(upload.has_value());
+
+        decision = coordinator.completeTask(completed(*upload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+
+        decision = coordinator.notifyParameterInteractionEnded();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+        EXPECT_TRUE(coordinator.isBoundingBoxCurrent());
+        EXPECT_FALSE(coordinator.isHeavyGeometryCurrent());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(hq.has_value());
+        EXPECT_TRUE(coordinator.isHeavyGeometryCurrent());
+        EXPECT_TRUE(matches(hq->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraBackpressure_KeepsCurrentFrameUntilOldPreviewCompletes)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyCameraChanged();
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+
+        decision = coordinator.notifyCameraChanged();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        decision = coordinator.completeTask(completed(*preview, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+
+        decision = coordinator.tick();
+        auto latestPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(latestPreview.has_value());
+        EXPECT_TRUE(matches(latestPreview->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithCurrentHeavyGeometry_StartsHqForLatestView)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.tick();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto initialHq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(initialHq.has_value());
+        ASSERT_TRUE(coordinator.isHeavyGeometryCurrent());
+        decision = coordinator.completeTask(completed(*initialHq, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
+
+        decision = coordinator.notifyCameraChanged();
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+
+        decision = coordinator.completeTask(completed(*preview, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
+
+        decision = coordinator.notifyCameraInteractionEnded();
+        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(hq.has_value());
+        EXPECT_TRUE(coordinator.isHeavyGeometryCurrent());
+        EXPECT_TRUE(matches(hq->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+    }
+
+    TEST(RenderUpdateCoordinator, StructuralModelChanged_StaleDisplayResultIsDiscarded)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyCameraChanged();
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+
+        decision = coordinator.notifyStructuralModelChanged();
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgramCompilation));
+
+        decision = coordinator.completeTask(completed(*preview, true, true));
+
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+        EXPECT_FALSE(hasCommand(decision, RenderCommandType::PresentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, ProgramCompilationCompleted_AfterStructuralChange_StartsParameterUpload)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.notifyStructuralModelChanged();
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgramCompilation));
+
+        decision = coordinator.notifyProgramCompilationCompleted();
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+    }
+
+    TEST(RenderUpdateCoordinator, StaticTick_WithFreshHeavyTasks_DoesNotStartDuplicateHqWhileInFlight)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.tick();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = coordinator.completeTask(completed(*sdf));
+        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
+        ASSERT_TRUE(hq.has_value());
+
+        decision = coordinator.tick();
+
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+    }
+
+    TEST(RenderUpdateCoordinator, FailedBoundingBox_DoesNotAdvanceToSdfAndCanRetry)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.tick();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = coordinator.completeTask(failed(*bbox));
+
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+
+        decision = coordinator.tick();
+        auto retry = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(retry.has_value());
+        EXPECT_NE(retry->requestId, bbox->requestId);
+    }
+
+    TEST(RenderUpdateCoordinator, Tick_WithOrphanedStaleTask_ReclaimsAndReschedules)
+    {
+        RenderUpdateCoordinator coordinator;
+
+        // Start a parameter upload and "leak" it: the translation layer never drives it back to a
+        // terminal completeTask()/failTask(). This models a missed completion on one of
+        // RenderWindow's many early-return paths.
+        auto decision = coordinator.notifyParameterChanged(false);
+        auto orphan = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(orphan.has_value());
+
+        // A second parameter change makes the orphan stale and resets the upload requirement, but
+        // the stamp-agnostic hasAnyInFlight() guard lets the orphan block a fresh upload.
+        decision = coordinator.notifyParameterChanged(false);
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        // tick() reconciles the stale orphan and reschedules the upload for the latest stamp,
+        // instead of staying wedged until some unrelated event clears the orphan.
+        decision = coordinator.tick();
+        auto rescheduled = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(rescheduled.has_value());
+        EXPECT_NE(rescheduled->requestId, orphan->requestId);
+        EXPECT_TRUE(
+          matches(rescheduled->stamp, coordinator.latestStamp(), RenderStampMask::heavyGeometryTask()));
+    }
+
+    TEST(RenderUpdateCoordinator, Tick_WithCurrentInFlightHeavyTask_DoesNotReclaimOrDuplicate)
+    {
+        RenderUpdateCoordinator coordinator;
+        auto decision = coordinator.tick();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        // The bbox is current and still legitimately running; reconciliation must leave it alone
+        // and must not start a duplicate.
+        decision = coordinator.tick();
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+
+        // Completing it still advances the pipeline, proving the entry was never reclaimed.
+        decision = coordinator.completeTask(completed(*bbox));
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp b/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp
new file mode 100644
index 00000000..d6f74ce8
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp
@@ -0,0 +1,126 @@
+#include "ui/render/RenderUpdateTypes.h"
+
+#include <gtest/gtest.h>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
+                                                      uint64_t parameters,
+                                                      uint64_t view,
+                                                      uint64_t viewport,
+                                                      uint64_t quality) noexcept
+        {
+            return RenderStamp{.sceneEpoch = scene,
+                               .parameterEpoch = parameters,
+                               .viewEpoch = view,
+                               .viewportEpoch = viewport,
+                               .qualityEpoch = quality};
+        }
+
+        [[nodiscard]] constexpr RenderTaskResult makeDisplayResult(RenderStamp stamp) noexcept
+        {
+            return RenderTaskResult{.requestId = 42,
+                                    .type = RenderTaskType::RealtimeFullFrame,
+                                    .stamp = stamp,
+                                    .status = RenderTaskStatus::Completed,
+                                    .durationNs = 1'000'000,
+                                    .producedDisplayFrame = true,
+                                    .completedFrame = true};
+        }
+    }
+
+    TEST(RenderStampMatches, WithSameRequiredAxes_ReturnsTrue)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const candidate = makeStamp(3, 5, 99, 101, 103);
+
+        EXPECT_TRUE(matches(candidate, latest, RenderStampMask::sceneAndParameters()));
+    }
+
+    TEST(RenderStampMatches, WithNoneMask_IgnoresAllAxes)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const completelyDifferent = makeStamp(30, 50, 70, 110, 130);
+
+        EXPECT_TRUE(matches(completelyDifferent, latest, RenderStampMask::none()));
+        EXPECT_FALSE(isOlderThan(completelyDifferent, latest, RenderStampMask::none()));
+    }
+
+    TEST(RenderStampMatches, WithDifferentView_FailsDisplayFrameButPassesHeavyGeometryTask)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const cameraOnlyStale = makeStamp(3, 5, 6, 11, 13);
+
+        EXPECT_FALSE(matches(cameraOnlyStale, latest, RenderStampMask::displayFrame()));
+        EXPECT_TRUE(matches(cameraOnlyStale, latest, RenderStampMask::heavyGeometryTask()));
+    }
+
+    TEST(RenderStampIsOlderThan, WithIgnoredAxis_DoesNotReportOlder)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const oldViewOnly = makeStamp(3, 5, 1, 11, 13);
+
+        EXPECT_FALSE(isOlderThan(oldViewOnly, latest, RenderStampMask::heavyGeometryTask()));
+        EXPECT_TRUE(isOlderThan(oldViewOnly, latest, RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderTaskResultIsDisplayableFor, WithCurrentDisplayStamp_ReturnsTrue)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const result = makeDisplayResult(latest);
+
+        EXPECT_TRUE(result.isDisplayableFor(latest));
+    }
+
+    TEST(RenderTaskResultIsDisplayableFor, WithOldCameraStamp_ReturnsFalse)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const oldCamera = makeStamp(3, 5, 6, 11, 13);
+        auto const result = makeDisplayResult(oldCamera);
+
+        EXPECT_FALSE(result.isDisplayableFor(latest));
+    }
+
+    TEST(RenderTaskResultIsDisplayableFor, WithOldParameterStamp_ReturnsFalse)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const oldParameter = makeStamp(3, 4, 7, 11, 13);
+        auto const result = makeDisplayResult(oldParameter);
+
+        EXPECT_FALSE(result.isDisplayableFor(latest));
+    }
+
+    TEST(RenderTaskResultIsCurrentFor, WithBoundingBoxResult_IgnoresCameraAndViewport)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto const bboxStamp = makeStamp(3, 5, 1, 2, 3);
+        auto const result = RenderTaskResult{.requestId = 7,
+                                             .type = RenderTaskType::BoundingBoxUpdate,
+                                             .stamp = bboxStamp,
+                                             .status = RenderTaskStatus::Completed};
+
+        EXPECT_TRUE(result.isCurrentFor(latest, RenderStampMask::heavyGeometryTask()));
+        EXPECT_FALSE(result.isCurrentFor(latest, RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderTaskResultIsCurrentFor, WithCancelledResult_ReturnsFalse)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto result = makeDisplayResult(latest);
+        result.status = RenderTaskStatus::Cancelled;
+
+        EXPECT_FALSE(result.isCurrentFor(latest, RenderStampMask::displayFrame()));
+        EXPECT_FALSE(result.isDisplayableFor(latest));
+    }
+
+    TEST(RenderTaskResultIsDisplayableFor, WithoutDisplayFrame_ReturnsFalse)
+    {
+        auto const latest = makeStamp(3, 5, 7, 11, 13);
+        auto result = makeDisplayResult(latest);
+        result.producedDisplayFrame = false;
+
+        EXPECT_FALSE(result.isDisplayableFor(latest));
+    }
+}
diff --git a/gladius/tests/unittests/ui/render/RenderWorkflowController_tests.cpp b/gladius/tests/unittests/ui/render/RenderWorkflowController_tests.cpp
new file mode 100644
index 00000000..cb87d9f0
--- /dev/null
+++ b/gladius/tests/unittests/ui/render/RenderWorkflowController_tests.cpp
@@ -0,0 +1,270 @@
+#include "ui/render/RenderWorkflowController.h"
+
+#include <gtest/gtest.h>
+
+#include <optional>
+
+namespace gladius::ui::async_rendering::tests
+{
+    namespace
+    {
+        [[nodiscard]] std::optional<RenderTaskRequest> findStartedTask(
+          RenderWorkflowDecision const & decision,
+          RenderTaskType type)
+        {
+            for (auto const & command : decision.commands)
+            {
+                if (command.type == RenderCommandType::StartTask && command.task.type == type)
+                {
+                    return command.task;
+                }
+            }
+            return std::nullopt;
+        }
+
+        [[nodiscard]] bool hasStartedTask(RenderWorkflowDecision const & decision,
+                                          RenderTaskType type)
+        {
+            return findStartedTask(decision, type).has_value();
+        }
+
+        [[nodiscard]] bool hasCommand(RenderWorkflowDecision const & decision,
+                                      RenderCommandType type)
+        {
+            for (auto const & command : decision.commands)
+            {
+                if (command.type == type)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        [[nodiscard]] std::optional<RenderTaskRequest> findFirstDisplayTask(
+          RenderWorkflowDecision const & decision)
+        {
+            if (auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame))
+            {
+                return realtime;
+            }
+            if (auto staticProbe = findStartedTask(decision, RenderTaskType::StaticFullFrameProbe))
+            {
+                return staticProbe;
+            }
+            if (auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk))
+            {
+                return progressive;
+            }
+            if (auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview))
+            {
+                return preview;
+            }
+            if (auto streaming = findStartedTask(decision, RenderTaskType::StreamingPreview))
+            {
+                return streaming;
+            }
+            return std::nullopt;
+        }
+
+        [[nodiscard]] RenderTaskResult completed(RenderTaskRequest const & request,
+                                                 bool producedDisplayFrame = false,
+                                                 bool completedFrame = false,
+                                                 uint64_t durationNs = 50'000'000)
+        {
+            return RenderTaskResult{.requestId = request.requestId,
+                                    .type = request.type,
+                                    .stamp = request.stamp,
+                                    .status = RenderTaskStatus::Completed,
+                                    .durationNs = durationNs,
+                                    .producedDisplayFrame = producedDisplayFrame,
+                                    .completedFrame = completedFrame};
+        }
+
+        [[nodiscard]] RealtimeRaymarchConfig modeConfig(RealtimeRaymarchMode mode)
+        {
+            RealtimeRaymarchConfig config{};
+            config.mode = mode;
+            return config;
+        }
+
+        [[nodiscard]] PresentedFrame heldFullQualityFrame(RenderStamp const & stamp)
+        {
+            return PresentedFrame{.frameId = 1,
+                                  .stamp = stamp,
+                                  .quality = FramePresentationQuality::FullQuality,
+                                  .source = FramePresentationSource::HeldFrame,
+                                  .completedFrame = true};
+        }
+    }
+
+    TEST(RenderWorkflowController,
+         ForceParameterDrag_WithExactAvailable_PresentsRealtimeAndNeverPreview)
+    {
+        RenderWorkflowController workflow;
+        workflow.configureRealtime(modeConfig(RealtimeRaymarchMode::Force));
+        (void) workflow.configureViewport(640, 480);
+        workflow.seedPresentedFrame(heldFullQualityFrame(workflow.latestStamp()));
+
+        auto decision = workflow.notifyParameterChanged(true);
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
+        ASSERT_TRUE(realtime.has_value());
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::StreamingPreview));
+
+        decision = workflow.completeTask(completed(*realtime, true, true));
+
+        ASSERT_EQ(decision.acceptedFrames.size(), 1u);
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->source, FramePresentationSource::ExactRealtime);
+        EXPECT_EQ(workflow.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+        EXPECT_TRUE(matches(workflow.presentedFrame()->stamp,
+                            workflow.latestStamp(),
+                            RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderWorkflowController,
+         ForceParameterDrag_WithRealtimeBlocked_HoldsCurrentFrameWithoutPreview)
+    {
+        RenderWorkflowController workflow;
+        workflow.configureRealtime(modeConfig(RealtimeRaymarchMode::Force));
+        (void) workflow.configureViewport(640, 480);
+        auto const initialFrame = heldFullQualityFrame(workflow.latestStamp());
+        workflow.seedPresentedFrame(initialFrame);
+
+        RealtimeRaymarchGuards guards{};
+        guards.hardBlocker = true;
+        workflow.setRealtimeGuards(guards);
+
+        auto const decision = workflow.notifyParameterChanged(true);
+
+        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::StreamingPreview));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->frameId, initialFrame.frameId);
+        EXPECT_EQ(workflow.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+    }
+
+    TEST(RenderWorkflowController,
+         CameraChanged_DuringParameterPreview_PreemptsAndRejectsStaleParameterPreview)
+    {
+        RenderWorkflowController workflow;
+        workflow.configureRealtime(modeConfig(RealtimeRaymarchMode::Off));
+        (void) workflow.configureViewport(640, 480);
+        workflow.seedPresentedFrame(heldFullQualityFrame(workflow.latestStamp()));
+
+        auto decision = workflow.notifyParameterChanged(true);
+        auto parameterPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(parameterPreview.has_value());
+
+        decision = workflow.notifyCameraChanged();
+        auto cameraPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(cameraPreview.has_value());
+        EXPECT_EQ(workflow.interactionState(), RenderInteractionState::CameraInteracting);
+        EXPECT_FALSE(matches(parameterPreview->stamp,
+                             workflow.latestStamp(),
+                             RenderStampMask::displayFrame()));
+        EXPECT_TRUE(matches(cameraPreview->stamp,
+                            workflow.latestStamp(),
+                            RenderStampMask::displayFrame()));
+
+        decision = workflow.completeTask(completed(*parameterPreview, true, true));
+        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
+        EXPECT_TRUE(decision.acceptedFrames.empty());
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->source, FramePresentationSource::HeldFrame);
+
+        decision = workflow.completeTask(completed(*cameraPreview, true, true));
+        ASSERT_EQ(decision.acceptedFrames.size(), 1u);
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->source, FramePresentationSource::LowResolutionPreview);
+        EXPECT_TRUE(matches(workflow.presentedFrame()->stamp,
+                            workflow.latestStamp(),
+                            RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderWorkflowController,
+         Presentation_WithCurrentFullQuality_RejectsSameStampPreviewRegression)
+    {
+        RenderWorkflowController workflow;
+        (void) workflow.configureViewport(640, 480);
+        workflow.seedPresentedFrame(heldFullQualityFrame(workflow.latestStamp()));
+
+        auto const preview = FramePresentationCandidate{
+          .frameId = 2,
+          .stamp = workflow.latestStamp(),
+          .quality = FramePresentationQuality::Preview,
+          .source = FramePresentationSource::LowResolutionPreview,
+          .completedFrame = true};
+
+        EXPECT_FALSE(workflow.presentCandidate(preview));
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+        EXPECT_EQ(workflow.presentedFrame()->source, FramePresentationSource::HeldFrame);
+    }
+
+    TEST(RenderWorkflowController,
+         Presentation_WithStaleFullQuality_AllowsFreshPreview)
+    {
+        RenderWorkflowController workflow;
+        workflow.configureRealtime(modeConfig(RealtimeRaymarchMode::Off));
+        (void) workflow.configureViewport(640, 480);
+        workflow.seedPresentedFrame(heldFullQualityFrame(workflow.latestStamp()));
+
+        auto decision = workflow.notifyCameraChanged();
+        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
+        ASSERT_TRUE(preview.has_value());
+
+        decision = workflow.completeTask(completed(*preview, true, true));
+
+        ASSERT_EQ(decision.acceptedFrames.size(), 1u);
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->quality, FramePresentationQuality::Preview);
+        EXPECT_EQ(workflow.presentedFrame()->source, FramePresentationSource::LowResolutionPreview);
+        EXPECT_TRUE(matches(workflow.presentedFrame()->stamp,
+                            workflow.latestStamp(),
+                            RenderStampMask::displayFrame()));
+    }
+
+    TEST(RenderWorkflowController,
+         ParameterInteractionEnded_SequencesUploadBboxSdfThenHighQualityCatchUp)
+    {
+        RenderWorkflowController workflow;
+        workflow.seedPresentedFrame(heldFullQualityFrame(workflow.latestStamp()));
+
+        auto decision = workflow.notifyParameterChanged(true);
+        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
+        ASSERT_TRUE(upload.has_value());
+
+        decision = workflow.completeTask(completed(*upload));
+        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
+
+        decision = workflow.notifyParameterInteractionEnded();
+        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
+        ASSERT_TRUE(bbox.has_value());
+
+        decision = workflow.completeTask(completed(*bbox));
+        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
+        ASSERT_TRUE(sdf.has_value());
+
+        decision = workflow.completeTask(completed(*sdf));
+        auto hq = findFirstDisplayTask(decision);
+        ASSERT_TRUE(hq.has_value());
+        EXPECT_NE(hq->type, RenderTaskType::LowResolutionPreview);
+        EXPECT_NE(hq->type, RenderTaskType::StreamingPreview);
+
+        decision = workflow.completeTask(completed(*hq, true, true));
+
+        ASSERT_EQ(decision.acceptedFrames.size(), 1u);
+        ASSERT_TRUE(workflow.presentedFrame().has_value());
+        EXPECT_EQ(workflow.presentedFrame()->quality, FramePresentationQuality::FullQuality);
+        EXPECT_TRUE(matches(workflow.presentedFrame()->stamp,
+                            workflow.latestStamp(),
+                            RenderStampMask::displayFrame()));
+    }
+}
diff --git a/gladius/vcpkg-overlay-ports/lib3mf/fix-lib3mf-config-root.patch b/gladius/vcpkg-overlay-ports/lib3mf/fix-lib3mf-config-root.patch
new file mode 100644
index 00000000..f870081d
--- /dev/null
+++ b/gladius/vcpkg-overlay-ports/lib3mf/fix-lib3mf-config-root.patch
@@ -0,0 +1,14 @@
+diff --git a/cmake/lib3mfConfig.cmake.in b/cmake/lib3mfConfig.cmake.in
+index 589422b3..2dbcbf95 100644
+--- a/cmake/lib3mfConfig.cmake.in
++++ b/cmake/lib3mfConfig.cmake.in
+@@ -23,8 +23,8 @@ if(NOT TARGET lib3mf::lib3mf)
+   return()
+ endif()
+ 
+ get_filename_component(_lib3mf_package_dir "${CMAKE_CURRENT_LIST_DIR}" ABSOLUTE)
+-get_filename_component(LIB3MF_ROOT_DIR "${_lib3mf_package_dir}/../../.." ABSOLUTE)
++get_filename_component(LIB3MF_ROOT_DIR "${_lib3mf_package_dir}/../.." ABSOLUTE)
+ set(LIB3MF_CDYNAMIC_ADDITIONAL_SOURCE "${LIB3MF_ROOT_DIR}/include/Bindings/CDynamic/lib3mf_dynamic.cc")
+ 
+ set(_lib3mf_library_location_definition "LIB3MF_LIBRARY_LOCATION=\"$<TARGET_FILE:lib3mf::lib3mf>\"")
diff --git a/gladius/vcpkg-overlay-ports/lib3mf/lib3mf_vcpkg.patch b/gladius/vcpkg-overlay-ports/lib3mf/lib3mf_vcpkg.patch
deleted file mode 100644
index 89578f19..00000000
--- a/gladius/vcpkg-overlay-ports/lib3mf/lib3mf_vcpkg.patch
+++ /dev/null
@@ -1,23 +0,0 @@
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -199,11 +199,9 @@ if (USE_INCLUDED_LIBZIP)
-     endif()
- 
- else()
--    find_package(PkgConfig REQUIRED)
--    pkg_check_modules(LIBZIP REQUIRED libzip)
--    target_link_libraries(${PROJECT_NAME} ${LIBZIP_LIBRARIES})
-+    find_package(LIBZIP REQUIRED)
-+    target_link_libraries(${PROJECT_NAME} PRIVATE libzip::zip)
- endif()
- 
- 
-@@ -211,11 +209,9 @@ if (USE_INCLUDED_ZLIB)
-     target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Libraries/zlib/Include)
- else()
--    find_package(PkgConfig REQUIRED)
--    pkg_check_modules(ZLIB REQUIRED zlib)
--    target_link_libraries(${PROJECT_NAME} ${ZLIB_LIBRARIES})
-+    find_package(ZLIB REQUIRED)
-+    target_link_libraries(${PROJECT_NAME} PRIVATE ZLIB::ZLIB)
- endif()
diff --git a/gladius/vcpkg-overlay-ports/lib3mf/portfile.cmake b/gladius/vcpkg-overlay-ports/lib3mf/portfile.cmake
index 5b6fdb45..820853a4 100644
--- a/gladius/vcpkg-overlay-ports/lib3mf/portfile.cmake
+++ b/gladius/vcpkg-overlay-ports/lib3mf/portfile.cmake
@@ -3,47 +3,21 @@ vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY)
 vcpkg_from_github(
     OUT_SOURCE_PATH SOURCE_PATH
     REPO 3MFConsortium/lib3mf
-    REF "f5555593f33a6ac3efe7ae3996315b1ebe6716b1" # v2.5 alpha 
-    SHA512 d26831de8fe0e659cb0f442d72fa15291732771cd26e76942f5770e87c97dc517ff1bfca49e190e6a74d752fee3bfb935486fe8f2124adf9ee49be0855ac796b
+    REF "82c524d6701a535ad11f8dae4a46a27fa199829c" # develop branch, v2.6.0 with Boolean spec support
+    SHA512 bfa93a2e087c5d0497dab7c55aee4f7e7e35e8718e250e9ad89f63b32c0b9e4dc0920b6d1c92d32b6fb9d606470c36846b39028f60992e1ada6d3b6103a8c206
+    PATCHES
+        fix-lib3mf-config-root.patch
+        fix-missing-algorithm.patch
 )
 
-# Normalize target_link_libraries signature by inserting PRIVATE for plain-signature lines
-file(READ "${SOURCE_PATH}/CMakeLists.txt" _lib3mf_cml)
-
-# Prepare literal token refs to avoid expansion during replacement
-set(_DLR "$")
-string(CONCAT _PROJ_REF "${_DLR}" "{" "PROJECT_NAME" "}")
-string(CONCAT _ZLIB_LIB_REF "${_DLR}" "{" "ZLIB_LIBRARIES" "}")
-string(CONCAT _ZLIB_INC_REF "${_DLR}" "{" "ZLIB_INCLUDE_DIRS" "}")
-string(CONCAT _ZLIB_LIBDIRS_REF "${_DLR}" "{" "ZLIB_LIBRARY_DIRS" "}")
-string(CONCAT _LIBZIP_LIB_REF "${_DLR}" "{" "LIBZIP_LIBRARIES" "}")
-string(CONCAT _LIBZIP_INC_REF "${_DLR}" "{" "LIBZIP_INCLUDE_DIRS" "}")
-string(CONCAT _LIBZIP_LIBDIRS_REF "${_DLR}" "{" "LIBZIP_LIBRARY_DIRS" "}")
-
-# Convert libzip linkage to keyword form and add include dirs
-string(REGEX REPLACE
-    [=[target_link_libraries\([ \t\r\n]*\$\{PROJECT_NAME\}[^)]*\$\{LIBZIP_LIBRARIES\}[^)]*\)]=]
-    "target_link_libraries(${_PROJ_REF} PRIVATE ${_LIBZIP_LIB_REF})\n    target_include_directories(${_PROJ_REF} PRIVATE ${_LIBZIP_INC_REF})\n    target_link_directories(${_PROJ_REF} PRIVATE ${_LIBZIP_LIBDIRS_REF})"
-    _lib3mf_cml "${_lib3mf_cml}")
-
-# Convert zlib linkage to keyword form and add include dirs
-string(REGEX REPLACE
-    [=[target_link_libraries\([ \t\r\n]*\$\{PROJECT_NAME\}[^)]*\$\{ZLIB_LIBRARIES\}[^)]*\)]=]
-    "target_link_libraries(${_PROJ_REF} PRIVATE ${_ZLIB_LIB_REF})\n    target_include_directories(${_PROJ_REF} PRIVATE ${_ZLIB_INC_REF})\n    target_link_directories(${_PROJ_REF} PRIVATE ${_ZLIB_LIBDIRS_REF})"
-    _lib3mf_cml "${_lib3mf_cml}")
-
-# Flip any hardcoded static CRT flags to dynamic to follow vcpkg defaults
-string(REPLACE " /MTd" " /MDd" _lib3mf_cml "${_lib3mf_cml}")
-string(REPLACE " /MT"  " /MD"  _lib3mf_cml "${_lib3mf_cml}")
-
-file(WRITE "${SOURCE_PATH}/CMakeLists.txt" "${_lib3mf_cml}")
-
 vcpkg_cmake_configure(
     SOURCE_PATH "${SOURCE_PATH}"
-    OPTIONS 
+    OPTIONS
         -DUSE_INCLUDED_ZLIB=OFF
         -DUSE_INCLUDED_LIBZIP=OFF
         -DUSE_INCLUDED_SSL=OFF
+        -DUSE_INCLUDED_CPPBASE64=OFF
+        -DUSE_INCLUDED_FASTFLOAT=OFF
         -DBUILD_FOR_CODECOVERAGE=OFF
         -DLIB3MF_TESTS=OFF
 )
diff --git a/gladius/vcpkg-overlay-ports/lib3mf/vcpkg.json b/gladius/vcpkg-overlay-ports/lib3mf/vcpkg.json
index cdbca47f..e8821ff0 100644
--- a/gladius/vcpkg-overlay-ports/lib3mf/vcpkg.json
+++ b/gladius/vcpkg-overlay-ports/lib3mf/vcpkg.json
@@ -1,6 +1,6 @@
 {
   "name": "lib3mf",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "description": "lib3mf is an implementation of the 3D Manufacturing Format file standard",
   "homepage": "https://github.com/3MFConsortium/lib3mf",
   "license": "BSD-2-Clause",
diff --git a/review.diff b/review.diff
new file mode 100644
index 00000000..d6b8bcc6
--- /dev/null
+++ b/review.diff
@@ -0,0 +1,6573 @@
+diff --git a/gladius/src/Document.cpp b/gladius/src/Document.cpp
+index 853019b..695f163 100644
+--- a/gladius/src/Document.cpp
++++ b/gladius/src/Document.cpp
+@@ -1456,6 +1456,62 @@ namespace gladius
+         return summary;
+     }
+ 
++    MeshQualityIssueSummary Document::getMeshQualityIssueSummary() const
++    {
++        MeshQualityIssueSummary summary{};
++        std::string firstMessage;
++
++        for (auto const & [key, resource] : getResourceManager().getResourceMap())
++        {
++            if (key.getResourceType() != ResourceType::Mesh)
++            {
++                continue;
++            }
++
++            auto const * spatialMesh = dynamic_cast<SpatialMeshResource const *>(resource.get());
++            if (spatialMesh == nullptr || !spatialMesh->hasMeshQualityIssues())
++            {
++                continue;
++            }
++
++            ++summary.affectedMeshCount;
++            summary.hasIssue = true;
++
++            auto const & quality = spatialMesh->getMeshQualityDiagnostics();
++            summary.degenerateTriangleCount +=
++              static_cast<std::size_t>(quality.degenerateTriangleCount);
++            summary.boundaryEdgeCount += static_cast<std::size_t>(quality.boundaryEdgeCount);
++            summary.nonManifoldEdgeCount +=
++              static_cast<std::size_t>(quality.nonManifoldEdgeCount);
++
++            if (firstMessage.empty())
++            {
++                firstMessage = spatialMesh->formatMeshQualityMessage(key.getDisplayName());
++            }
++        }
++
++        if (!summary.hasIssue)
++        {
++            return summary;
++        }
++
++        if (summary.affectedMeshCount == 1u)
++        {
++            summary.message = std::move(firstMessage);
++            return summary;
++        }
++
++        summary.message = fmt::format(
++          "Mesh topology diagnostics affect {} mesh resources ({} boundary edges, {} "
++          "non-manifold edges, {} degenerate triangles total). First issue: {}",
++          summary.affectedMeshCount,
++          summary.boundaryEdgeCount,
++          summary.nonManifoldEdgeCount,
++          summary.degenerateTriangleCount,
++          firstMessage);
++        return summary;
++    }
++
+     events::SharedLogger Document::getSharedLogger() const
+     {
+         if (!m_core)
+@@ -1819,6 +1875,27 @@ namespace gladius
+                     ++changedResources;
+                 }
+ 
++                if (spatialMesh->evaluationConfig().method == MeshSdfMethod::NanoVDB &&
++                    spatialMesh->hasMeshQualityIssues())
++                {
++                    auto const message = spatialMesh->formatMeshQualityMessage(
++                      key.getDisplayName());
++                    auto logger = getSharedLogger();
++                    if (logger)
++                    {
++                        logger->addEvent(
++                          {message,
++                           nanovdbBuildPolicy.failurePolicy == NanoVdbFailurePolicy::Fail
++                             ? events::Severity::Error
++                             : events::Severity::Warning});
++                    }
++
++                    if (nanovdbBuildPolicy.failurePolicy == NanoVdbFailurePolicy::Fail)
++                    {
++                        throw NanoVdbBuildRejectedError(message);
++                    }
++                }
++
+                 if (changed && spatialMesh->evaluationConfig().method == MeshSdfMethod::NanoVDB &&
+                     spatialMesh->hasNanoVdbBuildIssue())
+                 {
+diff --git a/gladius/src/Document.h b/gladius/src/Document.h
+index 4e1eaa6..759ada0 100644
+--- a/gladius/src/Document.h
++++ b/gladius/src/Document.h
+@@ -459,6 +459,9 @@ namespace gladius
+         /// Summarize NanoVDB build issues on currently loaded mesh resources, if any.
+         [[nodiscard]] NanoVdbBuildIssueSummary getNanoVdbBuildIssueSummary() const;
+ 
++        /// Summarize mesh topology diagnostics on currently loaded mesh resources, if any.
++        [[nodiscard]] MeshQualityIssueSummary getMeshQualityIssueSummary() const;
++
+         /// Queue applying the mesh-SDF evaluation configuration to existing mesh resources.
+         /// Heavy resource rebuild/upload work is folded into the debounced background refresh so
+         /// the UI can keep showing the current preview.
+diff --git a/gladius/src/GLImageBuffer.cpp b/gladius/src/GLImageBuffer.cpp
+index 8d4de96..2872ed8 100644
+--- a/gladius/src/GLImageBuffer.cpp
++++ b/gladius/src/GLImageBuffer.cpp
+@@ -38,7 +38,10 @@ namespace gladius
+         if (m_ComputeContext.outputMethod() == OutputMethod::readpixel)
+         {
+             setupForReadPixel();
++            write();
+         }
++
++        m_dirty = false;
+     }
+ 
+     GLImageBuffer::~GLImageBuffer()
+diff --git a/gladius/src/MeshBVH.cpp b/gladius/src/MeshBVH.cpp
+index bd89f3b..d276996 100644
+--- a/gladius/src/MeshBVH.cpp
++++ b/gladius/src/MeshBVH.cpp
+@@ -9,6 +9,7 @@
+ #include <chrono>
+ #include <cmath>
+ #include <cstdint>
++#include <cstring>
+ #include <limits>
+ #include <numbers>
+ #include <numeric>
+@@ -16,6 +17,96 @@
+ 
+ namespace gladius
+ {
++    namespace
++    {
++        std::uint32_t floatKeyBits(float const value) noexcept
++        {
++            float normalized = value;
++            if (normalized == 0.0f)
++            {
++                normalized = 0.0f; // canonicalise -0.0f to +0.0f
++            }
++
++            std::uint32_t bits = 0u;
++            std::memcpy(&bits, &normalized, sizeof(bits));
++            return bits;
++        }
++
++        struct PointKey
++        {
++            std::uint32_t x = 0u;
++            std::uint32_t y = 0u;
++            std::uint32_t z = 0u;
++
++            bool operator==(PointKey const & other) const noexcept
++            {
++                return x == other.x && y == other.y && z == other.z;
++            }
++        };
++
++        struct PointKeyHash
++        {
++            std::size_t operator()(PointKey const & key) const noexcept
++            {
++                std::size_t seed = std::hash<std::uint32_t>{}(key.x);
++                seed ^= std::hash<std::uint32_t>{}(key.y) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
++                seed ^= std::hash<std::uint32_t>{}(key.z) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
++                return seed;
++            }
++        };
++
++        [[nodiscard]] PointKey makePointKey(float4 const & point) noexcept
++        {
++            return PointKey{floatKeyBits(point.x), floatKeyBits(point.y), floatKeyBits(point.z)};
++        }
++
++        [[nodiscard]] bool lessPointKey(PointKey const & lhs, PointKey const & rhs) noexcept
++        {
++            if (lhs.x != rhs.x)
++            {
++                return lhs.x < rhs.x;
++            }
++            if (lhs.y != rhs.y)
++            {
++                return lhs.y < rhs.y;
++            }
++            return lhs.z < rhs.z;
++        }
++
++        struct EdgeKey
++        {
++            PointKey a;
++            PointKey b;
++
++            bool operator==(EdgeKey const & other) const noexcept
++            {
++                return a == other.a && b == other.b;
++            }
++        };
++
++        struct EdgeKeyHash
++        {
++            std::size_t operator()(EdgeKey const & key) const noexcept
++            {
++                std::size_t seed = PointKeyHash{}(key.a);
++                auto const bHash = PointKeyHash{}(key.b);
++                seed ^= bHash + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
++                return seed;
++            }
++        };
++
++        [[nodiscard]] EdgeKey makeEdgeKey(float4 const & lhs, float4 const & rhs) noexcept
++        {
++            auto a = makePointKey(lhs);
++            auto b = makePointKey(rhs);
++            if (lessPointKey(b, a))
++            {
++                std::swap(a, b);
++            }
++            return EdgeKey{a, b};
++        }
++    }
++
+     // ========================================================================
+     // Build Context
+     // ========================================================================
+@@ -197,6 +288,10 @@ namespace gladius
+             ? static_cast<float>(totalLeafPrims) / static_cast<float>(m_lastStats.leafNodes)
+             : 0.0f;
+ 
++        result.quality.degenerateTriangleCount = m_lastStats.degenerateTriangleCount;
++        result.quality.boundaryEdgeCount = m_lastStats.boundaryEdgeCount;
++        result.quality.nonManifoldEdgeCount = m_lastStats.nonManifoldEdgeCount;
++
+         return result;
+     }
+ 
+@@ -219,6 +314,32 @@ namespace gladius
+             vn.normal = {0.0f, 0.0f, 0.0f, 0.0f};
+         }
+ 
++        struct AccumulatedNormal
++        {
++            float x = 0.0f;
++            float y = 0.0f;
++            float z = 0.0f;
++        };
++
++        // Accumulate by exact vertex position, not only by vertex index. Many STL-style
++        // triangle soups duplicate vertex records per face while still being geometrically
++        // watertight. Exact positional grouping preserves deterministic behaviour without
++        // silently modifying the mesh like a weld repair would.
++        std::unordered_map<PointKey, AccumulatedNormal, PointKeyHash> normalSums;
++        normalSums.reserve(vertexCount);
++
++        auto const addNormal = [&](float4 const & vertex,
++                                   float const angle,
++                                   float const normalX,
++                                   float const normalY,
++                                   float const normalZ)
++        {
++            auto & sum = normalSums[makePointKey(vertex)];
++            sum.x += angle * normalX;
++            sum.y += angle * normalY;
++            sum.z += angle * normalZ;
++        };
++
+         // Accumulate angle-weighted face normals for each vertex
+         for (size_t i = 0; i < indices.size(); ++i)
+         {
+@@ -278,23 +399,23 @@ namespace gladius
+             float angle2 = std::numbers::pi_v<float> - angle0 - angle1;
+ 
+             // Add weighted face normal to each vertex
+-            data.vertexNormals[idx.i0].normal.x += angle0 * fnx;
+-            data.vertexNormals[idx.i0].normal.y += angle0 * fny;
+-            data.vertexNormals[idx.i0].normal.z += angle0 * fnz;
+-
+-            data.vertexNormals[idx.i1].normal.x += angle1 * fnx;
+-            data.vertexNormals[idx.i1].normal.y += angle1 * fny;
+-            data.vertexNormals[idx.i1].normal.z += angle1 * fnz;
+-
+-            data.vertexNormals[idx.i2].normal.x += angle2 * fnx;
+-            data.vertexNormals[idx.i2].normal.y += angle2 * fny;
+-            data.vertexNormals[idx.i2].normal.z += angle2 * fnz;
++            addNormal(p0, angle0, fnx, fny, fnz);
++            addNormal(p1, angle1, fnx, fny, fnz);
++            addNormal(p2, angle2, fnx, fny, fnz);
+         }
+ 
+         // Normalize all vertex normals
+         for (size_t i = 0; i < vertexCount; ++i)
+         {
+             auto & n = data.vertexNormals[i].normal;
++            auto const it = normalSums.find(makePointKey(vertices[i]));
++            if (it != normalSums.end())
++            {
++                n.x = it->second.x;
++                n.y = it->second.y;
++                n.z = it->second.z;
++            }
++
+             float len = std::sqrt(n.x * n.x + n.y * n.y + n.z * n.z);
+             if (len > 1e-10f)
+             {
+@@ -357,24 +478,6 @@ namespace gladius
+             faceNormals[t] = float4{fnx * invLen, fny * invLen, fnz * invLen, 1.0f};
+         }
+ 
+-        // Hash undirected edges to (triIdx, edgeIdx). On second hit we know both sides.
+-        struct EdgeKey
+-        {
+-            uint64_t key;
+-            bool operator==(EdgeKey const & o) const { return key == o.key; }
+-        };
+-        struct EdgeKeyHash
+-        {
+-            size_t operator()(EdgeKey const & k) const noexcept { return std::hash<uint64_t>{}(k.key); }
+-        };
+-
+-        auto const makeKey = [](uint32_t a, uint32_t b) -> EdgeKey
+-        {
+-            uint32_t lo = std::min(a, b);
+-            uint32_t hi = std::max(a, b);
+-            return EdgeKey{(static_cast<uint64_t>(hi) << 32) | static_cast<uint64_t>(lo)};
+-        };
+-
+         struct EdgeRef
+         {
+             int triIdx;
+@@ -395,7 +498,7 @@ namespace gladius
+             for (int e = 0; e < 3; ++e)
+             {
+                 auto [va, vb] = edgeVertices(idx, e);
+-                EdgeKey const key = makeKey(va, vb);
++                EdgeKey const key = makeEdgeKey(vertices[va], vertices[vb]);
+                 edgeMap[key].push_back(EdgeRef{static_cast<int>(t), e});
+             }
+         }
+diff --git a/gladius/src/MeshBVH.h b/gladius/src/MeshBVH.h
+index 68208c0..238a671 100644
+--- a/gladius/src/MeshBVH.h
++++ b/gladius/src/MeshBVH.h
+@@ -139,6 +139,24 @@ namespace gladius
+         }
+     };
+ 
++    /// Topology diagnostics that affect deterministic signed-distance evaluation.
++    struct MeshQualityDiagnostics
++    {
++        /// Number of triangles skipped during normal computation due to a degenerate
++        /// edge length or zero face-normal magnitude.
++        int degenerateTriangleCount = 0;
++        /// Number of undirected edges incident to exactly one face (open boundary).
++        int boundaryEdgeCount = 0;
++        /// Number of undirected edges incident to three or more faces (non-manifold).
++        int nonManifoldEdgeCount = 0;
++
++        [[nodiscard]] bool hasIssues() const noexcept
++        {
++            return degenerateTriangleCount != 0 || boundaryEdgeCount != 0 ||
++                   nonManifoldEdgeCount != 0;
++        }
++    };
++
+     /// Host-side container for mesh BVH data before serialization
+     struct SpatialMeshData
+     {
+@@ -150,6 +168,7 @@ namespace gladius
+         std::vector<MeshBVHFwnAggregate> fwnAggregates;          ///< 1 aggregate per BVH node (same order as nodes); empty when not built
+         size_t originalTriangleCount = 0;         ///< Source mesh triangle count
+         BoundingBox boundingBox;                  ///< Axis-aligned bounding box
++        MeshQualityDiagnostics quality;           ///< Topology diagnostics collected during BVH construction
+ 
+         /// Check if data is empty
+         bool empty() const
+diff --git a/gladius/src/MeshSdfMethod.h b/gladius/src/MeshSdfMethod.h
+index 6a92d60..f12d1d7 100644
+--- a/gladius/src/MeshSdfMethod.h
++++ b/gladius/src/MeshSdfMethod.h
+@@ -106,6 +106,19 @@ namespace gladius
+         float suggestedVoxelSize_mm = 0.0f;
+     };
+ 
++    /// User-facing aggregate of mesh topology diagnostics that can make signed-distance
++    /// evaluation ambiguous unless the mesh is repaired or an orientation-independent
++    /// sign strategy is selected.
++    struct MeshQualityIssueSummary
++    {
++        bool hasIssue = false;
++        std::size_t affectedMeshCount = 0u;
++        std::size_t degenerateTriangleCount = 0u;
++        std::size_t boundaryEdgeCount = 0u;
++        std::size_t nonManifoldEdgeCount = 0u;
++        std::string message;
++    };
++
+     /// Raised when a strict NanoVDB policy rejects the requested load/build.
+     class NanoVdbBuildRejectedError : public std::runtime_error
+     {
+diff --git a/gladius/src/SpatialMeshResource.cpp b/gladius/src/SpatialMeshResource.cpp
+index 290e34a..6b89690 100644
+--- a/gladius/src/SpatialMeshResource.cpp
++++ b/gladius/src/SpatialMeshResource.cpp
+@@ -257,6 +257,32 @@ namespace gladius
+         ResourceBase::load();
+     }
+ 
++        std::string SpatialMeshResource::formatMeshQualityMessage(
++            std::string const & displayName) const
++        {
++                if (!hasMeshQualityIssues())
++                {
++                        return {};
++                }
++
++                auto const subject = displayName.empty() ? std::string{"mesh resource"}
++                                                                                                 : fmt::format("mesh '{}'", displayName);
++                auto const & quality = m_data.quality;
++                auto message = fmt::format(
++                    "Topology diagnostics for {}: {} boundary edges, {} non-manifold edges, "
++                    "{} degenerate triangles. Signed mesh SDF methods, including NanoVDB, are "
++                    "deterministic only for watertight, consistently oriented meshes.",
++                    subject,
++                    quality.boundaryEdgeCount,
++                    quality.nonManifoldEdgeCount,
++                    quality.degenerateTriangleCount);
++
++                message += " No repair or fallback was applied silently. Enable explicit repair-on-import "
++                                     "and re-import, or select Fast Winding Number when the input is an intentional "
++                                     "triangle soup.";
++                return message;
++        }
++
+     std::string SpatialMeshResource::formatNanoVdbBuildMessage(
+       std::string const & displayName) const
+     {
+@@ -1048,16 +1074,31 @@ namespace gladius
+                 flatMeshCompanion.end = static_cast<int>(m_payloadData.data.size());
+ 
+                 // -- Companion i+2: SDF_VDB (near signed-distance field, user-configured res) --
+-                auto const nearSdfTransform = openvdb::math::Transform::createLinearTransform(
+-                    static_cast<double>(voxelSize_mm));
++                // Keep the legacy VdbImporter value convention: build the SDF grid in
++                // voxel-scaled coordinates with an identity transform, then store
++                // PrimitiveMeta::scaling as the world_mm -> grid coordinate scale. The OpenCL
++                // vdbModel() sampler divides sampled grid values by the same scale to return
++                // millimetres. Building this grid directly in world space with a non-identity
++                // transform would store millimetre-valued distances and the kernel would scale
++                // them down a second time.
++                float const nearSdfScaling = 1.0f / voxelSize_mm;
++                auto nearSdfVerts = verts;
++                for (auto & vertex : nearSdfVerts)
++                {
++                    vertex *= nearSdfScaling;
++                }
++                auto const nearSdfTransform = openvdb::math::Transform::createLinearTransform(1.0);
+                 float constexpr kNearHalfBandVoxels = 8.0f;
+                 auto nearSdfGrid = openvdb::tools::meshToLevelSet<openvdb::FloatGrid>(
+-                    *nearSdfTransform, verts, tris, kNearHalfBandVoxels);
+-                openvdb::tools::changeBackground(nearSdfGrid->tree(),
+-                                                 std::numeric_limits<float>::max());
++                    *nearSdfTransform, nearSdfVerts, tris, kNearHalfBandVoxels);
++                // Preserve OpenVDB's signed inactive tiles. The hybrid NanoVDB path uses this
++                // grid as its sign source while face-index grids provide the long-range
++                // magnitude. Replacing all inactive values with +max destroys the negative
++                // interior background and makes closed solids look outside once queries leave
++                // the active narrow band.
+                 nearSdfGrid->pruneGrid();
+                 PrimitiveMeta sdfVdbCompanion = appendVdbGrid(
+-                    openvdb::GridBase::Ptr(nearSdfGrid), 1.0f / voxelSize_mm, SDF_VDB);
++                    openvdb::GridBase::Ptr(nearSdfGrid), nearSdfScaling, SDF_VDB);
+                 m_nanovdbGridOffset = static_cast<size_t>(sdfVdbCompanion.start);
+ 
+                 // -- Companion i+3: SDF_VDB_FACE_INDICES (far face-index, fixed 1mm / 150 voxels) --
+diff --git a/gladius/src/SpatialMeshResource.h b/gladius/src/SpatialMeshResource.h
+index 7663d2d..c18e89a 100644
+--- a/gladius/src/SpatialMeshResource.h
++++ b/gladius/src/SpatialMeshResource.h
+@@ -150,6 +150,23 @@ namespace gladius
+             return hasNanoVdbBuildIssue();
+         }
+ 
++        /// Mesh topology diagnostics captured during BVH construction.
++        [[nodiscard]] MeshQualityDiagnostics const & getMeshQualityDiagnostics() const noexcept
++        {
++            return m_data.quality;
++        }
++
++        /// True when the source mesh has topology that can make signed SDF sign ambiguous.
++        [[nodiscard]] bool hasMeshQualityIssues() const noexcept
++        {
++            return m_data.quality.hasIssues();
++        }
++
++        /// Format mesh-quality diagnostics into a user-facing message. Returns an empty string
++        /// when the mesh has no recorded quality issues.
++        [[nodiscard]] std::string formatMeshQualityMessage(
++          std::string const & displayName) const;
++
+         /// Format the current NanoVDB issue into a user-facing message. Returns an empty string
+         /// when the resource has no NanoVDB build issue.
+         [[nodiscard]] std::string formatNanoVdbBuildMessage(
+diff --git a/gladius/src/compute/ComputeCore.cpp b/gladius/src/compute/ComputeCore.cpp
+index 6cc8795..2f318ad 100644
+--- a/gladius/src/compute/ComputeCore.cpp
++++ b/gladius/src/compute/ComputeCore.cpp
+@@ -12,6 +12,7 @@
+ #include <sstream>
+ #include <string>
+ #include <utility>
++#include <vector>
+ #include <iostream>
+ 
+ #include <fmt/core.h>
+@@ -377,14 +378,11 @@ namespace gladius
+ 
+           std::lock_guard<std::recursive_mutex>
+             lock(m_computeMutex, std::adopt_lock);
+-        if (isAutoUpdateBoundingBoxEnabled())
+-        {
+-            markBoundingBoxStale();
+-        }
+ 
+         auto & paramBuf = getResourceContext()->getParameterBuffer();
+         auto & parameter = paramBuf.getData();
+-        parameter.clear();
++        std::vector<float> updatedParameter;
++        updatedParameter.reserve(parameter.size());
+ 
+         int currentIndex = 0;
+         for (auto & model : assembly.getFunctions())
+@@ -413,21 +411,21 @@ namespace gladius
+                     if (auto const typedValuePtr = std::get_if<float>(&variant))
+                     {
+                         param->setLookUpIndex(currentIndex);
+-                        parameter.push_back(*typedValuePtr);
++                        updatedParameter.push_back(*typedValuePtr);
+                         ++currentIndex;
+                     }
+                     if (auto const typedValuePtr = std::get_if<int>(&variant))
+                     {
+                         param->setLookUpIndex(currentIndex);
+-                        parameter.push_back(static_cast<float>(*typedValuePtr));
++                        updatedParameter.push_back(static_cast<float>(*typedValuePtr));
+                         ++currentIndex;
+                     }
+                     if (auto const typedValuePtr = std::get_if<nodes::float3>(&variant))
+                     {
+                         param->setLookUpIndex(currentIndex);
+-                        parameter.push_back(typedValuePtr->x);
+-                        parameter.push_back(typedValuePtr->y);
+-                        parameter.push_back(typedValuePtr->z);
++                        updatedParameter.push_back(typedValuePtr->x);
++                        updatedParameter.push_back(typedValuePtr->y);
++                        updatedParameter.push_back(typedValuePtr->z);
+                         currentIndex += 3;
+                     }
+ 
+@@ -441,7 +439,7 @@ namespace gladius
+                             for (int col = 0; col < 4; ++col)
+                             {
+                                 float const value = matrix[row][col];
+-                                parameter.push_back(value);
++                                updatedParameter.push_back(value);
+                                 ++currentIndex;
+                             }
+                         }
+@@ -450,6 +448,15 @@ namespace gladius
+             }
+         }
+ 
++        bool const parameterChanged = updatedParameter != parameter;
++        if (parameterChanged)
++        {
++            if (isAutoUpdateBoundingBoxEnabled())
++            {
++                markBoundingBoxStale();
++            }
++        }
++        parameter = std::move(updatedParameter);
+         paramBuf.write();
+         // NOTE: Do NOT call invalidatePreCompSdf() here!
+         // We want to keep the old SDF valid for preview rendering during interactive
+@@ -2084,6 +2091,52 @@ namespace gladius
+         return false;
+     }
+ 
++    bool ComputeCore::renderSceneComputeOnlyWithSettings(cl::CommandQueue const & commandQueue,
++                                                         size_t startLine,
++                                                         size_t endLine,
++                                                         ImageRGBA & targetImage,
++                                                         RenderingSettings settings,
++                                                         cl::Event * completionEvent)
++    {
++        ProfileFunction
++
++          if (!m_computeMutex.try_lock())
++        {
++            return false;
++        }
++        std::lock_guard<std::recursive_mutex> lock(m_computeMutex, std::adopt_lock);
++
++        recompileIfRequired();
++
++        if (getBestRenderProgram()->isCompilationInProgress())
++        {
++            LOG_LOCATION
++            return false;
++        }
++
++        m_lastUsedApproximation = settings.approximation;
++        m_lastUsedHQApproximation = settings.approximation;
++        m_lastUsedPreviewApproximation = settings.approximation;
++
++        cl::Event const renderEvent = getBestRenderProgram()->renderSceneAsync(
++          commandQueue, *m_primitives, targetImage, settings, m_sliceHeight_mm, startLine, endLine);
++
++        if (completionEvent != nullptr)
++        {
++            *completionEvent = renderEvent;
++        }
++
++        if (renderEvent())
++        {
++            commandQueue.flush();
++            LOG_LOCATION
++            return true;
++        }
++
++        LOG_LOCATION
++        return false;
++    }
++
+     LowResPreviewRenderStatus ComputeCore::renderLowResPreview() const
+     {
+         ProfileFunction
+diff --git a/gladius/src/compute/ComputeCore.h b/gladius/src/compute/ComputeCore.h
+index 07f05cf..b75f8c5 100644
+--- a/gladius/src/compute/ComputeCore.h
++++ b/gladius/src/compute/ComputeCore.h
+@@ -434,6 +434,23 @@ namespace gladius
+                                                   ImageRGBA & targetImage,
+                                                   cl::Event * completionEvent = nullptr);
+ 
++                /// @brief Render scene to a pure OpenCL image buffer with caller-provided settings.
++                /// @param commandQueue OpenCL command queue used for dispatch
++                /// @param startLine Starting line for rendering
++                /// @param endLine Ending line for rendering
++                /// @param targetImage Pure CL image buffer to render into (no GL texture)
++                /// @param settings Rendering settings copy used for this dispatch
++                /// @param completionEvent Optional event for async completion tracking
++                /// @return true if rendering was enqueued successfully, false otherwise
++                /// @thread Any thread with compute context access
++                [[nodiscard]] bool renderSceneComputeOnlyWithSettings(
++                    cl::CommandQueue const & commandQueue,
++                    size_t startLine,
++                    size_t endLine,
++                    ImageRGBA & targetImage,
++                    RenderingSettings settings,
++                    cl::Event * completionEvent = nullptr);
++
+         /// @brief Render the current low-resolution preview when the precomputed SDF is ready.
+         /// @return Rendered when a preview frame was produced, Skipped when the SDF is not ready, or Failed on an execution/precondition error.
+         [[nodiscard]] LowResPreviewRenderStatus renderLowResPreview() const;
+diff --git a/gladius/src/io/3mf/Importer3mf.cpp b/gladius/src/io/3mf/Importer3mf.cpp
+index 5433b2f..27d90c4 100644
+--- a/gladius/src/io/3mf/Importer3mf.cpp
++++ b/gladius/src/io/3mf/Importer3mf.cpp
+@@ -1392,6 +1392,24 @@ namespace gladius::io
+ 
+         auto * resource = resourceManager.getResourcePtr(key);
+         auto * spatialMesh = dynamic_cast<SpatialMeshResource *>(resource);
++        if (spatialMesh != nullptr && spatialMesh->hasMeshQualityIssues())
++        {
++            auto const message = spatialMesh->formatMeshQualityMessage(key.getDisplayName());
++            bool const strictNanoVdb = m_meshSdfEvaluationConfig.method == MeshSdfMethod::NanoVDB &&
++                                       m_nanovdbBuildPolicy.failurePolicy ==
++                                           NanoVdbFailurePolicy::Fail;
++            if (m_eventLogger)
++            {
++                m_eventLogger->addEvent({message,
++                                         strictNanoVdb ? gladius::events::Severity::Error
++                                                       : gladius::events::Severity::Warning});
++            }
++            if (strictNanoVdb)
++            {
++                resourceManager.deleteResource(key);
++                throw NanoVdbBuildRejectedError(message);
++            }
++        }
+         if (spatialMesh != nullptr && spatialMesh->hasNanoVdbBuildIssue())
+         {
+             auto const message = spatialMesh->formatNanoVdbBuildMessage(key.getDisplayName());
+diff --git a/gladius/src/ui/MainWindow.cpp b/gladius/src/ui/MainWindow.cpp
+index d83edb1..3158f60 100644
+--- a/gladius/src/ui/MainWindow.cpp
++++ b/gladius/src/ui/MainWindow.cpp
+@@ -2721,14 +2721,21 @@ namespace gladius::ui
+             // bypass the throttle — the debounce already elapsed, we just need to retry.
+             if (m_parameterThrottle.shouldRecompile() || !m_parameterThrottle.hasPendingRecompile())
+             {
++                bool const useStreamingPreview = !m_renderWindow.isForceRealtimeMode();
++
+                 // Streaming preview mode: the worker coroutine becomes the sole GPU
+                 // writer, reading the latest Assembly values and pushing them to the
+                 // parameter buffer in a tight loop.  This eliminates the UI-frame
+                 // round-trip latency that limits one-shot preview scheduling.
++                // In Force realtime mode, parameter changes should be served by exact
++                // full-frame raymarching instead of the low-res streaming preview.
+                 if (!m_renderWindow.isStreamingPreviewActive())
+                 {
+                     m_renderWindow.invalidateViewDueToParameterChange();
+-                    m_renderWindow.startStreamingPreview();
++                    if (useStreamingPreview)
++                    {
++                        m_renderWindow.startStreamingPreview();
++                    }
+                 }
+                 m_parameterDirty = false;
+                 m_contoursDirty = true;
+@@ -3440,6 +3447,15 @@ namespace gladius::ui
+               }
+               return m_doc->getNanoVdbBuildIssueSummary();
+           });
++        m_meshSdfSettingsDialog.setMeshQualityIssueProvider(
++          [this]() -> MeshQualityIssueSummary
++          {
++              if (!m_doc)
++              {
++                  return {};
++              }
++              return m_doc->getMeshQualityIssueSummary();
++          });
+     }
+ 
+     void MainWindow::setVdbSupported(bool supported, std::string const & reason)
+diff --git a/gladius/src/ui/MeshSdfSettingsDialog.cpp b/gladius/src/ui/MeshSdfSettingsDialog.cpp
+index 70a36b7..a117cd6 100644
+--- a/gladius/src/ui/MeshSdfSettingsDialog.cpp
++++ b/gladius/src/ui/MeshSdfSettingsDialog.cpp
+@@ -21,6 +21,11 @@ namespace gladius::ui
+         m_nanovdbIssueProvider = std::move(provider);
+     }
+ 
++    void MeshSdfSettingsDialog::setMeshQualityIssueProvider(MeshQualityIssueProvider provider)
++    {
++        m_meshQualityIssueProvider = std::move(provider);
++    }
++
+     void MeshSdfSettingsDialog::show()
+     {
+         syncFromSettings();
+@@ -92,6 +97,38 @@ namespace gladius::ui
+         // ---- Evaluation method ------------------------------------------------
+         if (ImGui::CollapsingHeader("Evaluation", ImGuiTreeNodeFlags_DefaultOpen))
+         {
++            if (m_meshQualityIssueProvider)
++            {
++                auto const qualityIssue = m_meshQualityIssueProvider();
++                if (qualityIssue.hasIssue)
++                {
++                    ImGui::TextColored(ImVec4(1.0f, 0.68f, 0.18f, 1.0f),
++                                       "Mesh topology diagnostics detected");
++                    ImGui::PushTextWrapPos(ImGui::GetFontSize() * 46.0f);
++                    ImGui::TextUnformatted(qualityIssue.message.c_str());
++                    ImGui::PopTextWrapPos();
++                    ImGui::TextDisabled(
++                      "No silent repair or fallback was applied; choose an explicit recovery and Apply.");
++
++                    if (ImGui::Button("Enable repair for next import"))
++                    {
++                        m_repair.weld = true;
++                        m_repair.removeDegenerate = true;
++                        m_repair.orientConsistently = true;
++                        m_repair.fillHoles = true;
++                        m_dirty = true;
++                    }
++                    ImGui::SameLine();
++                    if (ImGui::Button("Use FWN sign"))
++                    {
++                        m_eval.method = MeshSdfMethod::FastWindingNumber;
++                        m_eval.fwnUseSignCache = false;
++                        m_dirty = true;
++                    }
++                    ImGui::Separator();
++                }
++            }
++
+             char const * preview = methodLabel(m_eval.method);
+             if (ImGui::BeginCombo("Method", preview))
+             {
+diff --git a/gladius/src/ui/MeshSdfSettingsDialog.h b/gladius/src/ui/MeshSdfSettingsDialog.h
+index 6ec5961..81f386d 100644
+--- a/gladius/src/ui/MeshSdfSettingsDialog.h
++++ b/gladius/src/ui/MeshSdfSettingsDialog.h
+@@ -24,6 +24,7 @@ namespace gladius::ui
+       public:
+         using ApplyCallback = std::function<void()>;
+         using NanoVdbIssueProvider = std::function<NanoVdbBuildIssueSummary()>;
++        using MeshQualityIssueProvider = std::function<MeshQualityIssueSummary()>;
+ 
+         MeshSdfSettingsDialog() = default;
+         ~MeshSdfSettingsDialog() = default;
+@@ -42,6 +43,9 @@ namespace gladius::ui
+         /// Provide the callback used to query runtime NanoVDB build issues.
+         void setNanoVdbIssueProvider(NanoVdbIssueProvider provider);
+ 
++        /// Provide the callback used to query runtime mesh-quality diagnostics.
++        void setMeshQualityIssueProvider(MeshQualityIssueProvider provider);
++
+         void show();
+         void hide();
+         [[nodiscard]] bool isVisible() const noexcept;
+@@ -60,6 +64,7 @@ namespace gladius::ui
+         MeshSdfSettings * m_settings = nullptr;
+         ApplyCallback m_applyCallback;
+         NanoVdbIssueProvider m_nanovdbIssueProvider;
++        MeshQualityIssueProvider m_meshQualityIssueProvider;
+ 
+         bool m_visible = false;
+         bool m_dirty = false;
+diff --git a/gladius/src/ui/OrbitalCamera.cpp b/gladius/src/ui/OrbitalCamera.cpp
+index f6f8aea..0f76f77 100644
+--- a/gladius/src/ui/OrbitalCamera.cpp
++++ b/gladius/src/ui/OrbitalCamera.cpp
+@@ -108,11 +108,15 @@ namespace gladius::ui
+         auto const speedFactor = 15.E-3f;
+         // if (deltaTime_ms > 50.f)
+         {
++            changed = fabs(m_pitchTarget - m_pitch) > tolerance ||
++                      fabs(m_yawTarget - m_yaw) > tolerance ||
++                      fabs(m_eyeDistTarget - m_eyeDist) > tolerance ||
++                      (m_lookAtTarget - m_lookAt).norm() > tolerance;
+             m_pitch = m_pitchTarget;
+             m_yaw = m_yawTarget;
+             m_eyeDist = m_eyeDistTarget;
+             m_lookAt = m_lookAtTarget;
+-            return false;
++            return changed;
+         }
+         // deltaTime_ms = std::min(deltaTime_ms, 50.f);
+ 
+diff --git a/gladius/src/ui/RenderWindow.cpp b/gladius/src/ui/RenderWindow.cpp
+index a9fd48e..885bb5e 100644
+--- a/gladius/src/ui/RenderWindow.cpp
++++ b/gladius/src/ui/RenderWindow.cpp
+@@ -5,6 +5,7 @@
+ #include <coroutine>
+ #include <cstddef>
+ #include <fmt/core.h>
++#include <iterator>
+ 
+ #include "../CLMath.h"
+ #include "../ComputeContext.h"
+@@ -147,6 +148,9 @@ namespace gladius::ui
+               m_configManager->getValue<bool>("renderWindow", "permanentCenteringEnabled", false);
+         }
+ 
++        auto const realtimeConfig = loadRealtimeRaymarchConfig();
++        m_renderUpdateCoordinator.configureRealtime(realtimeConfig);
++
+         // Don't initialize async rendering here - will be done lazily on first render
+     }
+ 
+@@ -202,11 +206,17 @@ namespace gladius::ui
+             m_asyncController->start();
+             m_asyncEpochCounter.store(0, std::memory_order_release);
+             m_asyncCurrentEpoch.store(0, std::memory_order_release);
++            m_asyncViewEpoch.store(0, std::memory_order_release);
+             m_asyncInFlightEpoch.store(0, std::memory_order_release);
++            m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+             m_asyncFrameCounter.store(0, std::memory_order_release);
+             m_asyncJobInFlight.store(false, std::memory_order_release);
++            m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+             m_asyncSdfJobInFlight.store(false, std::memory_order_release);
+             m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
++            m_renderUpdateCoordinator = async_rendering::RenderUpdateCoordinator{};
++            m_renderUpdateCoordinator.configureRealtime(loadRealtimeRaymarchConfig());
++            m_pendingRenderCommands.clear();
+             notifyAsyncEpochIncrement();
+         }
+         else
+@@ -218,9 +228,12 @@ namespace gladius::ui
+             }
+             m_asyncEpochCounter.store(0, std::memory_order_release);
+             m_asyncCurrentEpoch.store(0, std::memory_order_release);
++            m_asyncViewEpoch.store(0, std::memory_order_release);
+             m_asyncInFlightEpoch.store(0, std::memory_order_release);
++            m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+             m_asyncFrameCounter.store(0, std::memory_order_release);
+             m_asyncJobInFlight.store(false, std::memory_order_release);
++            m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+             m_asyncSdfJobInFlight.store(false, std::memory_order_release);
+             m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
+         }
+@@ -237,8 +250,11 @@ namespace gladius::ui
+         auto const oldEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+         auto const newEpoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
+         m_asyncCurrentEpoch.store(newEpoch, std::memory_order_release);
++        m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel);
+         m_asyncInFlightEpoch.store(0, std::memory_order_release);
++        m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+         m_asyncJobInFlight.store(false, std::memory_order_release);
++        m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
+         m_asyncSdfJobInFlight.store(false, std::memory_order_release);
+         m_asyncSdfInFlightEpoch.store(0, std::memory_order_release);
+         m_asyncBboxJobInFlight.store(false, std::memory_order_release);
+@@ -259,6 +275,7 @@ namespace gladius::ui
+             m_asyncProgressiveBuffer = nullptr;
+         }
+         m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++        m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+ 
+         // IMPORTANT: Release any other Writing buffers from old epoch
+         // (they belong to cancelled jobs and should be returned to Idle)
+@@ -269,6 +286,348 @@ namespace gladius::ui
+         }
+     }
+ 
++    void RenderWindow::invalidateCameraView()
++    {
++        ProfileFunction;
++        m_dirty = true;
++        // Camera interaction supersedes parameter streaming. Leaving the streaming flag
++        // latched blocks realtime admission and makes Force mode hold a stale frame even
++        // when no exact realtime job is actually in flight.
++        m_streamingPreviewActive.store(false, std::memory_order_release);
++        m_streamingFrameConsumed.store(true, std::memory_order_release);
++        m_renderWindowState.isMoving = true;
++        m_renderWindowState.currentLine = 0;
++        m_renderWindowState.renderingStepSize = kInitialProgressiveStepSize;
++        m_renderWindowState.isRendering = false;
++        bool const forceLowResPreview =
++            m_renderUpdateCoordinator.realtimeConfig().mode == async_rendering::RealtimeRaymarchMode::Off;
++        m_forceLowResRenderOnNextFrame.store(forceLowResPreview, std::memory_order_release);
++        if (forceLowResPreview)
++        {
++            m_lastLowResRenderTime = std::chrono::system_clock::now();
++        }
++        else
++        {
++            m_lowResFeedbackPending.store(false, std::memory_order_release);
++        }
++        m_suppressHQDisplay.store(false, std::memory_order_release);
++        auto const newViewEpoch = m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel) + 1;
++        if (m_asyncController)
++        {
++            m_asyncController->setLatestViewEpoch(newViewEpoch);
++        }
++        queueRenderDecision(m_renderUpdateCoordinator.notifyCameraChanged());
++
++        if (m_core)
++        {
++            m_core->invalidateDistanceInitBuffer();
++        }
++
++        if (m_asyncController && m_asyncProgressiveBuffer &&
++            !m_asyncJobInFlight.load(std::memory_order_acquire))
++        {
++            [[maybe_unused]] bool const released =
++              m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
++                                                     async_rendering::FrameState::Writing,
++                                                     async_rendering::FrameState::Idle);
++            m_asyncProgressiveBuffer = nullptr;
++            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++            m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
++        }
++    }
++
++    async_rendering::RealtimeRaymarchConfig RenderWindow::loadRealtimeRaymarchConfig() const
++    {
++        async_rendering::RealtimeRaymarchConfig config{};
++        if (!m_configManager)
++        {
++            return config;
++        }
++
++        auto const mode = m_configManager->getValue<std::string>(
++          "renderWindow", "realtimeRaymarchMode", "auto");
++        config.mode = async_rendering::realtimeRaymarchModeFromString(mode);
++        config.targetFrameTimeMs =
++          m_configManager->getValue<float>("renderWindow", "realtimeRaymarchTargetMs", 25.0f);
++        return config;
++    }
++
++    void RenderWindow::saveRealtimeRaymarchMode(
++      async_rendering::RealtimeRaymarchMode mode) const
++    {
++        if (!m_configManager)
++        {
++            return;
++        }
++
++        m_configManager->setValue("renderWindow",
++                                  "realtimeRaymarchMode",
++                                  std::string(async_rendering::realtimeRaymarchModeToString(mode)));
++        m_configManager->save();
++    }
++
++    void RenderWindow::queueRenderDecision(async_rendering::RenderUpdateDecision decision)
++    {
++        m_pendingRenderCommands.insert(m_pendingRenderCommands.end(),
++                                       std::make_move_iterator(decision.commands.begin()),
++                                       std::make_move_iterator(decision.commands.end()));
++    }
++
++    bool RenderWindow::executeQueuedRenderCommands(RenderWindowState & state)
++    {
++        bool startedWork = false;
++        size_t processedCommands = 0;
++        while (!m_pendingRenderCommands.empty() && processedCommands < 64)
++        {
++            auto command = std::move(m_pendingRenderCommands.front());
++            m_pendingRenderCommands.erase(m_pendingRenderCommands.begin());
++            startedWork = executeRenderCommand(command, state) || startedWork;
++            ++processedCommands;
++        }
++        return startedWork;
++    }
++
++    bool RenderWindow::executeRenderCommand(async_rendering::RenderCommand const & command,
++                                            RenderWindowState & state)
++    {
++        if (command.type != async_rendering::RenderCommandType::StartTask)
++        {
++            return false;
++        }
++
++        return scheduleCoordinatorTask(command.task, state);
++    }
++
++    bool RenderWindow::scheduleCoordinatorTask(async_rendering::RenderTaskRequest const & task,
++                                               RenderWindowState & state)
++    {
++        auto const failTask = [&]()
++        { completeCoordinatorTask(task, async_rendering::RenderTaskStatus::Failed); };
++
++        switch (task.type)
++        {
++        case async_rendering::RenderTaskType::ProgramCompilation:
++            if (m_core && m_core->tryIsRenderProgramReady().value_or(false))
++            {
++                queueRenderDecision(m_renderUpdateCoordinator.notifyProgramCompilationCompleted());
++            }
++            return false;
++
++        case async_rendering::RenderTaskType::ParameterUpload:
++        {
++            bool updated = false;
++            if (m_core && m_document)
++            {
++                if (auto assembly = m_document->getAssembly(); assembly && m_core->isRendererReady())
++                {
++                    updated = m_core->tryToupdateParameter(*assembly);
++                }
++            }
++            completeCoordinatorTask(task,
++                                    updated ? async_rendering::RenderTaskStatus::Completed
++                                            : async_rendering::RenderTaskStatus::Failed);
++            return false;
++        }
++
++        case async_rendering::RenderTaskType::BoundingBoxUpdate:
++        {
++            bool const wasInFlight = m_asyncBboxJobInFlight.load(std::memory_order_acquire);
++            scheduleAsyncBboxUpdate(&task);
++            bool const started = !wasInFlight && m_asyncBboxJobInFlight.load(std::memory_order_acquire);
++            if (!started)
++            {
++                failTask();
++            }
++            return started;
++        }
++
++        case async_rendering::RenderTaskType::SdfPrecomputation:
++        {
++            bool const started = scheduleAsyncSdfPrecomputation(&task);
++            if (!started)
++            {
++                failTask();
++            }
++            return started;
++        }
++
++        case async_rendering::RenderTaskType::RealtimeFullFrame:
++        {
++            bool const started = scheduleRealtimeRenderJob(state, &task);
++            if (!started)
++            {
++                m_renderUpdateCoordinator.recordRealtimeRejectedAttempt();
++                failTask();
++            }
++            return started;
++        }
++
++        case async_rendering::RenderTaskType::LowResolutionPreview:
++            if (isRealtimeRaymarchCameraInteraction())
++            {
++                completeCoordinatorTask(task, async_rendering::RenderTaskStatus::Cancelled);
++                return false;
++            }
++            if (!m_core || !m_core->isSdfValid())
++            {
++                failTask();
++                return false;
++            }
++        {
++            bool const started = scheduleAsyncPreviewJob(&task);
++            if (!started)
++            {
++                failTask();
++            }
++            return started;
++        }
++
++        case async_rendering::RenderTaskType::StreamingPreview:
++            m_streamingPreviewActive.store(true, std::memory_order_release);
++        {
++            bool const started = scheduleStreamingPreviewJob(&task);
++            if (!started)
++            {
++                failTask();
++            }
++            return started;
++        }
++
++        case async_rendering::RenderTaskType::ProgressiveHighQualityChunk:
++            state.isRendering = true;
++            if (!scheduleAsyncRenderJob(state, &task))
++            {
++                state.isRendering = false;
++                failTask();
++                return false;
++            }
++            return true;
++        }
++
++        return false;
++    }
++
++    bool RenderWindow::isRealtimeRaymarchCameraInteraction() const noexcept
++    {
++        return m_renderUpdateCoordinator.interactionState() ==
++               async_rendering::RenderInteractionState::CameraInteracting &&
++               m_asyncRealtimeJobInFlight.load(std::memory_order_acquire);
++    }
++
++    bool RenderWindow::isForceRealtimeMode() const noexcept
++    {
++        return m_renderUpdateCoordinator.realtimeConfig().mode ==
++               async_rendering::RealtimeRaymarchMode::Force;
++    }
++
++    bool RenderWindow::scheduleAsyncSdfPrecomputation(
++      async_rendering::RenderTaskRequest const * coordinatorTask)
++    {
++        if (!m_asyncController || !m_asyncController->isRunning() ||
++            m_asyncSdfJobInFlight.load(std::memory_order_acquire))
++        {
++            return false;
++        }
++
++        async_rendering::RenderJob sdfJob{};
++        sdfJob.type = async_rendering::RenderJobType::SDFPrecomputation;
++        if (coordinatorTask != nullptr)
++        {
++            sdfJob.coordinatorRequestId = coordinatorTask->requestId;
++            sdfJob.coordinatorStamp = coordinatorTask->stamp;
++        }
++        sdfJob.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
++        if (sdfJob.epoch == 0)
++        {
++            sdfJob.epoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
++            m_asyncCurrentEpoch.store(sdfJob.epoch, std::memory_order_release);
++        }
++        m_asyncController->setLatestEpoch(sdfJob.epoch);
++        m_asyncSdfJobInFlight.store(true, std::memory_order_release);
++        m_asyncSdfInFlightEpoch.store(sdfJob.epoch, std::memory_order_release);
++        m_asyncController->enqueueJob(sdfJob);
++        return true;
++    }
++
++    void RenderWindow::completeCoordinatorTask(async_rendering::RenderTaskRequest const & request,
++                                               async_rendering::RenderTaskStatus status)
++    {
++        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
++          async_rendering::RenderTaskResult{.requestId = request.requestId,
++                                            .type = request.type,
++                                            .stamp = request.stamp,
++                                            .status = status}));
++    }
++
++    void RenderWindow::completeCoordinatorTask(async_rendering::FrameResultMeta const & result,
++                                               bool producedDisplayFrame)
++    {
++        if (result.coordinatorRequestId == 0)
++        {
++            return;
++        }
++
++        auto taskType = async_rendering::RenderTaskType::ProgressiveHighQualityChunk;
++        switch (result.jobType)
++        {
++        case async_rendering::RenderJobType::RealtimeHighQuality:
++            taskType = async_rendering::RenderTaskType::RealtimeFullFrame;
++            break;
++        case async_rendering::RenderJobType::LowResPreview:
++            taskType = async_rendering::RenderTaskType::LowResolutionPreview;
++            break;
++        case async_rendering::RenderJobType::StreamingPreview:
++            taskType = async_rendering::RenderTaskType::StreamingPreview;
++            break;
++        case async_rendering::RenderJobType::BoundingBoxUpdate:
++            taskType = async_rendering::RenderTaskType::BoundingBoxUpdate;
++            break;
++        case async_rendering::RenderJobType::ParameterUpdate:
++            taskType = async_rendering::RenderTaskType::ParameterUpload;
++            break;
++        case async_rendering::RenderJobType::SDFPrecomputation:
++            taskType = async_rendering::RenderTaskType::SdfPrecomputation;
++            break;
++        case async_rendering::RenderJobType::ProgramCompilation:
++            taskType = async_rendering::RenderTaskType::ProgramCompilation;
++            break;
++        case async_rendering::RenderJobType::HighQuality:
++        default:
++            taskType = async_rendering::RenderTaskType::ProgressiveHighQualityChunk;
++            break;
++        }
++
++        auto const status = result.cancelled ? async_rendering::RenderTaskStatus::Cancelled
++                                             : async_rendering::RenderTaskStatus::Completed;
++        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
++          async_rendering::RenderTaskResult{.requestId = result.coordinatorRequestId,
++                                            .type = taskType,
++                                            .stamp = result.coordinatorStamp,
++                                            .status = status,
++                                            .durationNs = result.computeDurationNs,
++                                            .producedDisplayFrame = producedDisplayFrame,
++                                            .completedFrame = result.completedFrame}));
++    }
++
++    void RenderWindow::completeCoordinatorPreviewTask(async_rendering::PreviewResultMeta const & result)
++    {
++        if (result.coordinatorRequestId == 0)
++        {
++            return;
++        }
++
++        auto const status = result.cancelled ? async_rendering::RenderTaskStatus::Cancelled
++                                             : async_rendering::RenderTaskStatus::Completed;
++        queueRenderDecision(m_renderUpdateCoordinator.completeTask(
++          async_rendering::RenderTaskResult{.requestId = result.coordinatorRequestId,
++                                            .type = async_rendering::RenderTaskType::LowResolutionPreview,
++                                            .stamp = result.coordinatorStamp,
++                                            .status = status,
++                                            .durationNs = result.latencyNs,
++                                            .producedDisplayFrame = !result.cancelled,
++                                            .completedFrame = !result.cancelled}));
++    }
++
+     void RenderWindow::renderWindow()
+     {
+         ProfileFunction;
+@@ -303,21 +662,33 @@ namespace gladius::ui
+             // Use the front buffer from triple buffering system
+             auto * frontBuf = m_asyncController->frontBuffer();
+             auto const currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
++            auto const currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+ 
+             // For HQ frames (front buffer from progressive rendering) we require an epoch match
+             // to avoid showing stale HQ results from an old parameter set.
+             // For low-res preview during rapid parameter edits, we fall back to m_resultImage
+             // which is updated synchronously and always shows *something* recent.
++            // Exact realtime camera motion must not fall back to that preview texture.
++            bool const realtimeCameraInteraction = isRealtimeRaymarchCameraInteraction();
++            bool const exactRealtimeJobInFlight =
++                m_asyncRealtimeJobInFlight.load(std::memory_order_acquire);
+             bool const epochMatches = frontBuf && frontBuf->epoch == currentEpoch;
++            bool const viewMatches = frontBuf && frontBuf->viewEpoch == currentViewEpoch;
++                        bool const allowRealtimeFront =
++                            (realtimeCameraInteraction || exactRealtimeJobInFlight) && epochMatches;
++            bool const frontBlockedByRendering = m_renderWindowState.isRendering &&
++                                                 !allowRealtimeFront;
+             bool const useFrontBuffer = frontBuf && frontBuf->image && epochMatches &&
+-                                        !m_renderWindowState.isRendering &&
+-                                        !m_renderWindowState.isMoving &&
++                                        (viewMatches || allowRealtimeFront) &&
++                                        !frontBlockedByRendering &&
+                                         !m_suppressHQDisplay.load(std::memory_order_acquire);
+-            bool const useProgressiveBuffer =
+-              m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image &&
+-              m_asyncProgressiveEpoch.load(std::memory_order_acquire) == currentEpoch &&
+-              !m_renderWindowState.isMoving &&
+-              !m_suppressHQDisplay.load(std::memory_order_acquire);
++                        bool const progressiveBufferCurrent =
++                            m_asyncProgressiveEpoch.load(std::memory_order_acquire) == currentEpoch &&
++                            m_asyncProgressiveViewEpoch.load(std::memory_order_acquire) == currentViewEpoch;
++                        bool const useProgressiveBuffer =
++                            m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image &&
++                            progressiveBufferCurrent && !m_renderWindowState.isMoving &&
++                            !m_suppressHQDisplay.load(std::memory_order_acquire);
+ 
+             if (useFrontBuffer)
+             {
+@@ -329,7 +700,9 @@ namespace gladius::ui
+             }
+             else
+             {
+-                // Fallback to result image for progressive rendering or when no valid front buffer
++                // Fallback to result image for progressive rendering or when no valid front buffer.
++                // Preview result suppression keeps realtime camera motion from writing stale
++                // surrogate frames here; returning nullptr would blank the viewport.
+                 displayImage = m_core->getResultImage();
+             }
+         }
+@@ -470,6 +843,45 @@ namespace gladius::ui
+                                   }
+                                   m_renderWindowState.renderQuality = quality;
+ 
++                                  ImGui::Separator();
++                                  if (ImGui::BeginMenu("Realtime Raymarch"))
++                                  {
++                                      auto config = m_renderUpdateCoordinator.realtimeConfig();
++                                      auto const setMode = [&](async_rendering::RealtimeRaymarchMode mode)
++                                      {
++                                          config.mode = mode;
++                                          m_renderUpdateCoordinator.configureRealtime(config);
++                                          saveRealtimeRaymarchMode(mode);
++                                      };
++
++                                      if (ImGui::MenuItem(
++                                            "Auto", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Auto))
++                                      {
++                                          setMode(async_rendering::RealtimeRaymarchMode::Auto);
++                                      }
++                                      if (ImGui::MenuItem(
++                                            "Off", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Off))
++                                      {
++                                          setMode(async_rendering::RealtimeRaymarchMode::Off);
++                                      }
++                                      if (ImGui::MenuItem(
++                                            "Force", nullptr, config.mode == async_rendering::RealtimeRaymarchMode::Force))
++                                      {
++                                          setMode(async_rendering::RealtimeRaymarchMode::Force);
++                                      }
++
++                                      ImGui::Separator();
++                                      ImGui::Text("Budget: %.1f ms", config.targetFrameTimeMs);
++                                      if (ImGui::IsItemHovered())
++                                      {
++                                          ImGui::SetTooltip(
++                                            "Auto attempts full-resolution async raymarching when "
++                                            "recent timings fit this budget; otherwise Gladius "
++                                            "falls back to low-res preview/progressive rendering.");
++                                      }
++                                      ImGui::EndMenu();
++                                  }
++
+                                   ImGui::EndMenu();
+                               }
+ 
+@@ -551,7 +963,15 @@ namespace gladius::ui
+         // Update camera and set isMoving based on whether camera is currently animating.
+         // Note: Parameter changes use forceLowResRender and lowResFeedbackPending flags,
+         // not isMoving. isMoving is specifically for camera movement.
+-        m_renderWindowState.isMoving = m_camera.update(io.DeltaTime * 1000.f);
++        bool const cameraActuallyMoving = m_camera.update(io.DeltaTime * 1000.f);
++        if (cameraActuallyMoving) {
++            m_cameraIdleFrames = 0;
++            m_renderWindowState.isMoving = true;
++        } else {
++            m_cameraIdleFrames++;
++            // Keep isMoving true for 10 frames after last movement to debounce fast refresh rates
++            m_renderWindowState.isMoving = m_cameraIdleFrames < 10;
++        }
+         m_dirty = m_dirty || m_renderWindowState.isMoving;
+ 
+         // Floating cut-height slider overlay (inside the Preview window)
+@@ -567,7 +987,7 @@ namespace gladius::ui
+ 
+             if (m_camera.mouseMotionHandler(mousePos.x, mousePos.y))
+             {
+-                invalidateView();
++                invalidateCameraView();
+             }
+             if (!ImGui::IsAnyMouseDown())
+             {
+@@ -679,6 +1099,7 @@ namespace gladius::ui
+ 
+         // Force a low-res render on next frame for immediate visual feedback
+         m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
++        queueRenderDecision(m_renderUpdateCoordinator.notifyStructuralModelChanged());
+ 
+         invalidateView();
+         
+@@ -721,8 +1142,24 @@ namespace gladius::ui
+         m_core->setSdfValid(false);
+ 
+         m_dirty = true;
+-        m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+-        m_lastLowResRenderTime = std::chrono::system_clock::now();
++
++        // In realtime mode, mirror invalidateCameraView(): skip the legacy low-res preview
++        // path entirely. The coordinator already schedules a RealtimeFullFrame, and
++        // m_forceLowResRenderOnNextFrame / m_lowResFeedbackPending would trigger the old
++        // voxel-SDF preview path, producing a stale flash instead of instant feedback.
++        bool const isRealtimeMode =
++            m_renderUpdateCoordinator.realtimeConfig().mode !=
++            async_rendering::RealtimeRaymarchMode::Off;
++        m_forceLowResRenderOnNextFrame.store(!isRealtimeMode, std::memory_order_release);
++        if (isRealtimeMode)
++        {
++            m_lowResFeedbackPending.store(false, std::memory_order_release);
++        }
++        else
++        {
++            m_lastLowResRenderTime = std::chrono::system_clock::now();
++            m_lowResFeedbackPending.store(true, std::memory_order_release);
++        }
+ 
+         // Cancel any in-progress progressive render (stale parameters)
+         m_renderWindowState.currentLine = 0;
+@@ -731,8 +1168,9 @@ namespace gladius::ui
+ 
+         m_preComputedSdfDirty.store(true, std::memory_order_release);
+         m_parameterDirty.store(true, std::memory_order_release);
+-        m_lowResFeedbackPending.store(true, std::memory_order_release);
+         m_modelModifiedSinceLastCenter = true;
++        m_asyncViewEpoch.fetch_add(1, std::memory_order_acq_rel);
++        queueRenderDecision(m_renderUpdateCoordinator.notifyParameterChanged(true));
+ 
+         // Mark bbox stale instead of resetting — preserves cached bbox for reuse with extra margin
+         m_core->markBoundingBoxStale();
+@@ -829,7 +1267,7 @@ namespace gladius::ui
+     void RenderWindow::centerView()
+     {
+         m_centerViewRequested = true;
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setTopView()
+@@ -837,7 +1275,7 @@ namespace gladius::ui
+         // Top view: looking down the Z axis (pitch = +90°, yaw = 0°)
+         m_camera.setAngle(CL_M_PI_F / 2.0f, 0.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setFrontView()
+@@ -845,7 +1283,7 @@ namespace gladius::ui
+         // Front view: looking along the Y axis (pitch = 0°, yaw = -90°)
+         m_camera.setAngle(0.0f, -CL_M_PI_F / 2.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setLeftView()
+@@ -853,7 +1291,7 @@ namespace gladius::ui
+         // Left view: looking along the X axis (pitch = 0°, yaw = 0°)
+         m_camera.setAngle(0.0f, 0.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setRightView()
+@@ -861,7 +1299,7 @@ namespace gladius::ui
+         // Right view: looking along the negative X axis (pitch = 0°, yaw = 180°)
+         m_camera.setAngle(0.0f, CL_M_PI_F);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setBackView()
+@@ -869,7 +1307,7 @@ namespace gladius::ui
+         // Back view: looking along the negative Y axis (pitch = 0°, yaw = 90°)
+         m_camera.setAngle(0.0f, CL_M_PI_F / 2.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setBottomView()
+@@ -877,7 +1315,7 @@ namespace gladius::ui
+         // Bottom view: looking up the Z axis (pitch = -90°, yaw = 0°)
+         m_camera.setAngle(-CL_M_PI_F / 2.0f, 0.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setIsometricView()
+@@ -887,7 +1325,7 @@ namespace gladius::ui
+         float const yaw = CL_M_PI_F / 4.0f;                     // 45 degrees
+         m_camera.setAngle(pitch, yaw);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::togglePerspective()
+@@ -895,7 +1333,7 @@ namespace gladius::ui
+         // This would require camera implementation to support orthographic/perspective toggle
+         // For now, we'll save current view and restore it
+         saveCurrentView();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::frameAll()
+@@ -914,7 +1352,7 @@ namespace gladius::ui
+         }
+ 
+         m_camera.adjustDistanceToTarget(*bbox, m_renderWindowSize_px.x, m_renderWindowSize_px.y);
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::zoomSelected()
+@@ -930,7 +1368,7 @@ namespace gladius::ui
+         Position newLookAt{currentLookAt.x - m_panSensitivity, currentLookAt.y, currentLookAt.z};
+         m_camera.setLookAt(newLookAt);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::panRight()
+@@ -940,7 +1378,7 @@ namespace gladius::ui
+         Position newLookAt{currentLookAt.x + m_panSensitivity, currentLookAt.y, currentLookAt.z};
+         m_camera.setLookAt(newLookAt);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::panUp()
+@@ -950,7 +1388,7 @@ namespace gladius::ui
+         Position newLookAt{currentLookAt.x, currentLookAt.y, currentLookAt.z + m_panSensitivity};
+         m_camera.setLookAt(newLookAt);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::panDown()
+@@ -960,35 +1398,35 @@ namespace gladius::ui
+         Position newLookAt{currentLookAt.x, currentLookAt.y, currentLookAt.z - m_panSensitivity};
+         m_camera.setLookAt(newLookAt);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::rotateLeft()
+     {
+         m_camera.rotate(0.0f, -m_rotateSensitivity);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::rotateRight()
+     {
+         m_camera.rotate(0.0f, m_rotateSensitivity);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::rotateUp()
+     {
+         m_camera.rotate(m_rotateSensitivity, 0.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::rotateDown()
+     {
+         m_camera.rotate(-m_rotateSensitivity, 0.0f);
+         onCameraManuallyMoved();
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::previousView()
+@@ -1000,7 +1438,7 @@ namespace gladius::ui
+ 
+             // Restore the view (this would require camera API support)
+             // For now, we'll invalidate the view
+-            invalidateView();
++            invalidateCameraView();
+         }
+     }
+ 
+@@ -1013,7 +1451,7 @@ namespace gladius::ui
+ 
+             // Restore the view (this would require camera API support)
+             // For now, we'll invalidate the view
+-            invalidateView();
++            invalidateCameraView();
+         }
+     }
+ 
+@@ -1052,7 +1490,7 @@ namespace gladius::ui
+         {
+             // Restore the saved view (this would require camera API support)
+             // For now, we'll invalidate the view
+-            invalidateView();
++            invalidateCameraView();
+         }
+     }
+ 
+@@ -1060,7 +1498,7 @@ namespace gladius::ui
+     {
+         m_flyModeEnabled = !m_flyModeEnabled;
+         m_cameraMode = m_flyModeEnabled ? CameraMode::Fly : CameraMode::Orbit;
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::setOrbitMode()
+@@ -1259,6 +1697,7 @@ namespace gladius::ui
+             // path has no PID, so we reset to the nominal 50% of full quality here.
+             state.renderQualityWhileMoving = state.renderQuality * 0.5f;
+             invalidateViewDuetoModelUpdate();
++            queueRenderDecision(m_renderUpdateCoordinator.notifyProgramCompilationCompleted());
+         }
+ 
+         // Lazy initialization: only initialize async rendering once renderer is ready
+@@ -1522,12 +1961,51 @@ namespace gladius::ui
+ 
+         // Update camera now that we know core is ready
+         m_core->applyCamera(m_camera);
+-
+         processAsyncResults(state);
+ 
+         // Process async preview results (separate from HQ progressive results)
+         processAsyncPreviewResults();
+ 
++                int const desiredScreenWidth = static_cast<int>(
++                    std::clamp(m_renderWindowSize_px.x * state.renderQuality, 1.f, 16000.f));
++                int const desiredScreenHeight = static_cast<int>(
++                    std::clamp(m_renderWindowSize_px.y * state.renderQuality, 1.f, 16000.f));
++                auto const resultImage = m_core->getResultImage();
++                bool const screenResizeRequired =
++                    resultImage && (static_cast<int>(resultImage->getWidth()) != desiredScreenWidth ||
++                                                    static_cast<int>(resultImage->getHeight()) != desiredScreenHeight);
++
++        if (m_asyncController && m_asyncController->isRunning())
++        {
++                        queueRenderDecision(m_renderUpdateCoordinator.configureViewport(
++                            static_cast<uint32_t>(desiredScreenWidth), static_cast<uint32_t>(desiredScreenHeight)));
++
++            m_renderUpdateCoordinator.setRealtimeGuards(
++              async_rendering::RealtimeRaymarchGuards{
++                .hardBlocker = !m_enableHQRendering ||
++                               m_asyncSdfJobInFlight.load(std::memory_order_acquire) ||
++                               m_asyncBboxJobInFlight.load(std::memory_order_acquire) ||
++                               m_core->isAnyCompilationInProgressNonBlocking(),
++                .renderJobInFlight = m_asyncJobInFlight.load(std::memory_order_acquire),
++                .previewJobInFlight = m_asyncPreviewJobInFlight.load(std::memory_order_acquire),
++                .streamingActive = m_streamingPreviewActive.load(std::memory_order_acquire),
++                .streamingJobInFlight = m_streamingJobInFlight.load(std::memory_order_acquire),
++                .resizePending = m_deferredResizePending || screenResizeRequired});
++
++            if (!state.isMoving &&
++                m_renderUpdateCoordinator.interactionState() ==
++                  async_rendering::RenderInteractionState::CameraInteracting)
++            {
++                queueRenderDecision(m_renderUpdateCoordinator.notifyCameraInteractionEnded());
++            }
++
++            queueRenderDecision(m_renderUpdateCoordinator.tick());
++            if (executeQueuedRenderCommands(state))
++            {
++                return;
++            }
++        }
++
+         if (m_asyncController && m_asyncController->isRunning())
+         {
+             bool const sdfDirty = m_preComputedSdfDirty.load(std::memory_order_acquire);
+@@ -1546,7 +2024,22 @@ namespace gladius::ui
+               !bboxStale ||
+               (std::chrono::steady_clock::now() - m_lastParameterChangeTime >= kBboxDebounceDelay);
+ 
+-            if (sdfDirty && !sdfJobActive && sdfDebounceElapsed)
++            // Don't schedule SDF precomputation while the camera is actively moving in
++            // realtime mode: the realtime renderer evaluates SDF on-the-fly and doesn't
++            // need the precomputed version. Starting the SDF job now would set
++            // hardBlocker=true, preventing canAttemptRealtime() from returning true for
++            // the entire SDF compute duration. The coordinator will schedule SDF via
++            // scheduleStaticCatchUp() once notifyCameraInteractionEnded() fires.
++            bool const cameraInteracting =
++              m_renderUpdateCoordinator.interactionState() ==
++              async_rendering::RenderInteractionState::CameraInteracting;
++            bool const isRealtimeForSdfGuard =
++              m_renderUpdateCoordinator.realtimeConfig().mode !=
++              async_rendering::RealtimeRaymarchMode::Off;
++            bool const suppressSdfDuringCameraInteraction =
++              cameraInteracting && isRealtimeForSdfGuard;
++
++            if (sdfDirty && !sdfJobActive && sdfDebounceElapsed && !suppressSdfDuringCameraInteraction)
+             {
+                 async_rendering::RenderJob sdfJob{};
+                 sdfJob.type = async_rendering::RenderJobType::SDFPrecomputation;
+@@ -1601,7 +2094,6 @@ namespace gladius::ui
+             {
+                 // Delay progressive rendering until low-res feedback is presented
+                 state.isRendering = false;
+-                m_asyncJobInFlight.store(false, std::memory_order_release);
+             }
+         }
+ 
+@@ -1684,8 +2176,13 @@ namespace gladius::ui
+             state.currentLine = 0;
+             state.renderingStepSize = kInitialProgressiveStepSize;
+             state.isRendering = false;
+-            m_forceLowResRenderOnNextFrame.store(true, std::memory_order_release);
+-            m_lastLowResRenderTime = std::chrono::system_clock::now();
++            bool const forceLowResPreview =
++                m_renderUpdateCoordinator.realtimeConfig().mode == async_rendering::RealtimeRaymarchMode::Off;
++            m_forceLowResRenderOnNextFrame.store(forceLowResPreview, std::memory_order_release);
++            if (forceLowResPreview)
++            {
++                m_lastLowResRenderTime = std::chrono::system_clock::now();
++            }
+         }
+ 
+         if (state.isMoving && m_preComputedSdfDirty)
+@@ -1698,14 +2195,6 @@ namespace gladius::ui
+         // worker jobs copy their staging image back into m_resultImage after the render kernel
+         // completes, and resizing that image concurrently can crash inside clEnqueueCopyImage.
+         bool const shouldDeferResize = m_preserveContentDuringResize && m_deferredResizePending;
+-        int const desiredScreenWidth = static_cast<int>(
+-          std::clamp(m_renderWindowSize_px.x * state.renderQuality, 1.f, 16000.f));
+-        int const desiredScreenHeight = static_cast<int>(
+-          std::clamp(m_renderWindowSize_px.y * state.renderQuality, 1.f, 16000.f));
+-        auto const resultImage = m_core->getResultImage();
+-        bool const screenResizeRequired =
+-          resultImage && (static_cast<int>(resultImage->getWidth()) != desiredScreenWidth ||
+-                          static_cast<int>(resultImage->getHeight()) != desiredScreenHeight);
+         bool const hqRenderInFlight = m_asyncJobInFlight.load(std::memory_order_acquire);
+ 
+         if (!shouldDeferResize && screenResizeRequired && !hqRenderInFlight &&
+@@ -1779,6 +2268,13 @@ namespace gladius::ui
+         bool const lowResPending = m_lowResFeedbackPending.load(std::memory_order_acquire);
+         bool const previewJobInFlight = m_asyncPreviewJobInFlight.load(std::memory_order_acquire);
+ 
++        if (m_asyncRealtimeJobInFlight.load(std::memory_order_acquire))
++        {
++            m_lowResFeedbackPending.store(false, std::memory_order_release);
++            state.isRendering = true;
++            return;
++        }
++
+         if (state.isMoving || forceLowResRender || lowResPending)
+         {
+             bool const hadActiveProgressive =
+@@ -1798,7 +2294,6 @@ namespace gladius::ui
+             // - Sync preview is the fallback when async is unavailable
+             // During parameter drag, SDF jobs are debounced so there's no GPU contention.
+             bool const sdfValid = m_core->isSdfValid();
+-            bool const sdfJobRunning = m_asyncSdfJobInFlight.load(std::memory_order_acquire);
+             bool const streamingActive = m_streamingPreviewActive.load(std::memory_order_acquire);
+             bool const useAsyncPreview = !previewJobInFlight && sdfValid;
+ 
+@@ -1883,8 +2378,9 @@ namespace gladius::ui
+         // Only enforce timeout if we're NOT already in middle of progressive rendering
+         // (otherwise chunks would be blocked after any interaction)
+         bool const isProgressiveRenderInProgress = state.isRendering && state.currentLine > 0;
++        bool const useLowResPreviewBeforeHq = !m_renderUpdateCoordinator.isRealtimeActive();
+ 
+-        if (!isProgressiveRenderInProgress)
++        if (!isProgressiveRenderInProgress && useLowResPreviewBeforeHq)
+         {
+             auto const timeSinceLastLowResRender =
+               std::chrono::system_clock::now() - m_lastLowResRenderTime;
+@@ -1938,6 +2434,11 @@ namespace gladius::ui
+ 
+             auto const currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
+             bool const isOutdated = result.epoch < currentEpoch;
++            auto const currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
++            bool const isRealtimeJob = result.jobType == async_rendering::RenderJobType::RealtimeHighQuality;
++            bool const isExactRealtimeJob = isRealtimeJob;
++            bool const isHqRenderJob = result.jobType == async_rendering::RenderJobType::HighQuality || isExactRealtimeJob;
++            bool const isViewOutdated = isHqRenderJob && result.viewEpoch < currentViewEpoch;
+ 
+             if (result.jobType == async_rendering::RenderJobType::SDFPrecomputation)
+             {
+@@ -1959,6 +2460,9 @@ namespace gladius::ui
+                     // to avoid scheduling a redundant bbox job.
+                     m_asyncBboxUpdatePending.store(false, std::memory_order_release);
+                 }
++                auto coordinatorResult = result;
++                coordinatorResult.cancelled = coordinatorResult.cancelled || isOutdated;
++                completeCoordinatorTask(coordinatorResult, false);
+                 continue;
+             }
+ 
+@@ -1970,6 +2474,9 @@ namespace gladius::ui
+                 {
+                     scheduleAsyncBboxUpdate();
+                 }
++                auto coordinatorResult = result;
++                coordinatorResult.cancelled = coordinatorResult.cancelled || isOutdated;
++                completeCoordinatorTask(coordinatorResult, false);
+                 continue;
+             }
+ 
+@@ -1989,60 +2496,145 @@ namespace gladius::ui
+                 continue;
+             }
+ 
+-            // From here on, only HQ progressive render results are processed.
++            // From here on, only HQ/full exact render results are processed.
++
++            if (isHqRenderJob && result.computeDurationNs > 0)
++            {
++                size_t const renderedLines = result.completedLine > result.startLine
++                                             ? result.completedLine - result.startLine
++                                             : size_t{0};
++                auto const durationMs = static_cast<float>(
++                    static_cast<double>(result.computeDurationNs) / 1'000'000.0);
++                async_rendering::RealtimeRaymarchSample sample{};
++                sample.durationMs = durationMs;
++                sample.width = result.width;
++                sample.height = result.height;
++                sample.renderedLines = renderedLines;
++                sample.totalLines = result.height;
++                sample.completedFrame = result.completedFrame && result.startLine == 0 &&
++                                        renderedLines >= static_cast<size_t>(result.height);
++                sample.cancelled = result.cancelled;
++                if (isRealtimeJob)
++                {
++                    if (m_renderUpdateCoordinator.interactionState() ==
++                        async_rendering::RenderInteractionState::Static)
++                    {
++                        m_renderUpdateCoordinator.recordStaticFullFrameSample(sample);
++                    }
++                    else
++                    {
++                        m_renderUpdateCoordinator.recordInteractiveRealtimeSample(sample);
++                    }
++                }
++                else if (!isOutdated && !isViewOutdated &&
++                         m_renderUpdateCoordinator.interactionState() == async_rendering::RenderInteractionState::Static)
++                {
++                    m_renderUpdateCoordinator.recordStaticProgressiveSample(sample);
++                }
++            }
+ 
+             if (result.cancelled)
+             {
++                if (isExactRealtimeJob)
++                {
++                    m_renderUpdateCoordinator.recordRealtimeRejectedAttempt();
++                }
+                 if (result.epoch == m_asyncInFlightEpoch.load(std::memory_order_acquire))
+                 {
+                     m_asyncJobInFlight.store(false, std::memory_order_release);
++                    if (isExactRealtimeJob)
++                    {
++                        m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
++                    }
+                     m_asyncInFlightEpoch.store(0, std::memory_order_release);
++                    m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+                     state.isRendering = false;
+                 }
++                completeCoordinatorTask(result, false);
+                 continue;
+             }
+ 
+-            // Update progressive scheduling state only for current-epoch results.
+-            // Outdated results are still presented, but must not affect scheduling.
+-            if (!isOutdated)
++            // Update progressive scheduling state only for current scene/view results.
++            if (!isOutdated && !isViewOutdated && result.jobType == async_rendering::RenderJobType::HighQuality)
+             {
+                 size_t const maxHeight = static_cast<size_t>(result.height);
+                 state.currentLine = std::min(result.completedLine, maxHeight);
+                 adjustProgressFromDuration(state, result.computeDurationNs);
+             }
+ 
+-            // Promote the newest Ready buffer to Front for display
+-            // Note: Only happens when completedFrame=true (buffer was published)
++            // Promote the newest Ready buffer to Front for display.
++            // Stale scene/view results are deliberately discarded before promotion; otherwise
++            // a late realtime frame could replace a valid front buffer with an old camera or
++            // parameter state.
++            // Realtime raymarching frames (both Auto and Force) need to be displayed even if 
++            // the view epoch has incremented, otherwise continuous camera motion freezes.
++            bool const allowForcedRealtimeStaleView = isRealtimeJob;
++            bool const discardForStaleView = isViewOutdated && !allowForcedRealtimeStaleView;
++
+             if (result.completedFrame)
+             {
+-                ZoneScopedN("PromoteReadyToFront");
+-                auto * newFront = m_asyncController->promoteReadyToFront();
+-                if (newFront && newFront->image)
++                if (isOutdated || discardForStaleView)
++                {
++                    m_asyncController->discardReadyFrame(
++                      result.frameId, result.epoch, result.viewEpoch);
++                }
++                else
+                 {
+-                    // Bind the new frame to ensure GL texture is updated
+-                    newFront->image->invalidateContent();
+-                    newFront->image->bind();
+-                    newFront->image->unbind();
++                    ZoneScopedN("PromoteReadyToFront");
++                    auto * newFront = m_asyncController->promoteReadyToFront();
++                    if (newFront && newFront->image)
++                    {
++                        // Bind the new frame to ensure GL texture is updated
++                        newFront->image->invalidateContent();
++                        newFront->image->bind();
++                        newFront->image->unbind();
+ 
+-                    bool const promoted = m_asyncController->finalizeFrontPromotion(newFront);
++                        [[maybe_unused]] bool const promoted =
++                          m_asyncController->finalizeFrontPromotion(newFront);
++                    }
+                 }
+             }
+ 
+             if (result.completedFrame)
+             {
+-                if (!isOutdated)
++                if (!isOutdated && !discardForStaleView)
+                 {
+-                    m_dirty = false;
++                    m_dirty = isViewOutdated && allowForcedRealtimeStaleView;
+                     state.isRendering = false;
+                     // DON'T force state.isMoving = false - let camera update control this
+                     // If camera is still animating, it will set isMoving=true on next frame
+                     state.currentLine = 0; // Reset for next frame
+-                    m_view->stopAnimationMode();
++                    if (isExactRealtimeJob)
++                    {
++                        m_lowResFeedbackPending.store(false, std::memory_order_release);
++                        m_lastLowResPreviewEpoch.store(result.epoch, std::memory_order_release);
++                    }
++                    if (isViewOutdated && allowForcedRealtimeStaleView)
++                    {
++                        m_view->startAnimationMode();
++                    }
++                    else
++                    {
++                        m_view->stopAnimationMode();
++                    }
+                 }
+             }
+             else
+             {
+-                if (!isOutdated && m_asyncProgressiveBuffer && m_asyncProgressiveBuffer->image)
++                if (isViewOutdated && m_asyncProgressiveBuffer &&
++                    m_asyncProgressiveViewEpoch.load(std::memory_order_acquire) == result.viewEpoch)
++                {
++                    [[maybe_unused]] bool const released =
++                      m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
++                                                             async_rendering::FrameState::Writing,
++                                                             async_rendering::FrameState::Idle);
++                    m_asyncProgressiveBuffer = nullptr;
++                    m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++                    m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
++                    state.isRendering = false;
++                }
++                else if (!isOutdated && !isViewOutdated && m_asyncProgressiveBuffer &&
++                         m_asyncProgressiveBuffer->image)
+                 {
+                     m_asyncProgressiveBuffer->image->invalidateContent();
+                     m_view->startAnimationMode();
+@@ -2056,19 +2648,27 @@ namespace gladius::ui
+             if (result.epoch == m_asyncInFlightEpoch.load(std::memory_order_acquire))
+             {
+                 m_asyncJobInFlight.store(false, std::memory_order_release);
++                if (isExactRealtimeJob)
++                {
++                    m_asyncRealtimeJobInFlight.store(false, std::memory_order_release);
++                }
+                 m_asyncInFlightEpoch.store(0, std::memory_order_release);
++                m_asyncInFlightViewEpoch.store(0, std::memory_order_release);
+ 
+                 // If we just consumed an outdated job result, ensure we don't block scheduling for
+                 // the new epoch.
+-                if (isOutdated)
++                if (isOutdated || isViewOutdated)
+                 {
+                     state.isRendering = false;
+                 }
+             }
++
++            completeCoordinatorTask(result, result.completedFrame && !isOutdated && !isViewOutdated);
+         }
+     }
+ 
+-    bool RenderWindow::scheduleAsyncRenderJob(RenderWindowState & state)
++    bool RenderWindow::scheduleAsyncRenderJob(RenderWindowState & state,
++                                              async_rendering::RenderTaskRequest const * coordinatorTask)
+     {
+         ZoneScoped;
+         ZoneName("scheduleAsyncRenderJob", strlen("scheduleAsyncRenderJob"));
+@@ -2105,6 +2705,7 @@ namespace gladius::ui
+             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
+         }
+         m_asyncController->setLatestEpoch(job.epoch);
++        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+         job.frameHint = m_asyncFrameCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
+         job.type = async_rendering::RenderJobType::HighQuality;
+         job.width = static_cast<uint32_t>(width);
+@@ -2119,6 +2720,11 @@ namespace gladius::ui
+           std::max<size_t>(1, std::min(state.renderingStepSize, height - job.startLine));
+         job.precomputeSdf = false;
+         job.enableHighQuality = m_enableHQRendering;
++        if (coordinatorTask != nullptr)
++        {
++            job.coordinatorRequestId = coordinatorTask->requestId;
++            job.coordinatorStamp = coordinatorTask->stamp;
++        }
+ 
+         if (job.startLine == 0 &&
+             (!m_asyncProgressiveBuffer ||
+@@ -2159,6 +2765,84 @@ namespace gladius::ui
+         return true;
+     }
+ 
++    bool RenderWindow::scheduleRealtimeRenderJob(
++      RenderWindowState & state,
++      async_rendering::RenderTaskRequest const * coordinatorTask)
++    {
++        ZoneScoped;
++        ZoneName("scheduleRealtimeRenderJob", strlen("scheduleRealtimeRenderJob"));
++
++        if (!m_asyncController || !m_asyncController->isRunning() || !m_enableHQRendering)
++        {
++            return false;
++        }
++
++        auto const image = m_core->getResultImage();
++        if (!image)
++        {
++            return false;
++        }
++
++        size_t const width = static_cast<size_t>(image->getWidth());
++        size_t const height = static_cast<size_t>(image->getHeight());
++        if (width == 0 || height == 0)
++        {
++            return false;
++        }
++
++        m_asyncController->initializeAsyncResources(*m_core->getComputeContext(), width, height);
++
++        if (m_asyncProgressiveBuffer && !m_asyncJobInFlight.load(std::memory_order_acquire))
++        {
++            [[maybe_unused]] bool const released =
++              m_asyncController->tryTransitionBuffer(m_asyncProgressiveBuffer,
++                                                     async_rendering::FrameState::Writing,
++                                                     async_rendering::FrameState::Idle);
++            m_asyncProgressiveBuffer = nullptr;
++            m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++            m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
++        }
++
++        async_rendering::RenderJob job{};
++        job.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
++        if (job.epoch == 0)
++        {
++            job.epoch = m_asyncEpochCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
++            m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
++        }
++        m_asyncController->setLatestEpoch(job.epoch);
++
++        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
++        job.frameHint = m_asyncFrameCounter.fetch_add(1, std::memory_order_acq_rel) + 1;
++        job.type = async_rendering::RenderJobType::RealtimeHighQuality;
++        job.width = static_cast<uint32_t>(width);
++        job.height = static_cast<uint32_t>(height);
++        job.startLine = 0;
++        job.stepSize = height;
++        job.precomputeSdf = false;
++        job.enableHighQuality = true;
++        if (coordinatorTask != nullptr)
++        {
++            job.coordinatorRequestId = coordinatorTask->requestId;
++            job.coordinatorStamp = coordinatorTask->stamp;
++        }
++
++        state.currentLine = 0;
++        state.renderingStepSize = job.stepSize;
++        state.isRendering = true;
++        m_forceLowResRenderOnNextFrame.store(false, std::memory_order_release);
++        m_lowResFeedbackPending.store(false, std::memory_order_release);
++
++        m_asyncInFlightEpoch.store(job.epoch, std::memory_order_release);
++        m_asyncInFlightViewEpoch.store(job.viewEpoch, std::memory_order_release);
++        m_asyncJobInFlight.store(true, std::memory_order_release);
++        m_asyncRealtimeJobInFlight.store(true, std::memory_order_release);
++        m_asyncController->enqueueJob(job);
++
++        ZoneText("RealtimeJobEnqueued", 19);
++        return true;
++    }
++
+     auto RenderWindow::executeAsyncRenderJob(
+       async_rendering::RenderJob const & job,
+       async_rendering::AsyncRenderController::CancelCheck const & cancelCheck)
+@@ -2172,20 +2856,23 @@ namespace gladius::ui
+         tracy::SetThreadName("AsyncRenderWorker");
+ #endif
+ 
+-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
++        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
+         auto const & commandQueue =
+-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
+-        if (workerQueue == nullptr) {}
++          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
+ 
+         auto const cancellationRequested = [&]() -> bool { return cancelCheck && cancelCheck(); };
+ 
+         async_rendering::FrameResultMeta result{};
+         result.frameId = job.frameHint;
+         result.epoch = job.epoch;
++        result.viewEpoch = job.viewEpoch;
+         result.jobType = job.type;
+         result.width = job.width;
+         result.height = job.height;
+         result.startLine = job.startLine;
++        result.coordinatorRequestId = job.coordinatorRequestId;
++        result.coordinatorStamp = job.coordinatorStamp;
++        bool const isExactRealtimeJob = job.type == async_rendering::RenderJobType::RealtimeHighQuality;
+ 
+         if (cancellationRequested())
+         {
+@@ -2217,6 +2904,7 @@ namespace gladius::ui
+             {
+                 m_asyncProgressiveBuffer = nullptr;
+                 m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++                m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+             }
+ 
+             writeBuffer = nullptr;
+@@ -2245,6 +2933,7 @@ namespace gladius::ui
+ 
+             m_asyncProgressiveBuffer = writeBuffer;
+             m_asyncProgressiveEpoch.store(job.epoch, std::memory_order_release);
++            m_asyncProgressiveViewEpoch.store(job.viewEpoch, std::memory_order_release);
+         }
+         else
+         {
+@@ -2275,9 +2964,30 @@ namespace gladius::ui
+ 
+                     cl::Event renderEvent{};
+                     bool advanced = false;
+-                    
+-                    advanced = m_core->renderSceneComputeOnly(
+-                        commandQueue, job.startLine, endLine, targetCLBuffer, &renderEvent);
++
++                    if (isExactRealtimeJob)
++                    {
++                        auto assembly = m_document ? m_document->getAssembly() : nullptr;
++                        if (assembly && m_core->isRendererReady())
++                        {
++                            (void) m_core->tryToupdateParameter(*assembly);
++                        }
++
++                        auto settings = m_core->getResourceContext()->getRenderingSettings();
++                        settings.approximation = AM_FULL_MODEL;
++                        advanced = m_core->renderSceneComputeOnlyWithSettings(
++                          commandQueue,
++                          job.startLine,
++                          endLine,
++                          targetCLBuffer,
++                          settings,
++                          &renderEvent);
++                    }
++                    else
++                    {
++                        advanced = m_core->renderSceneComputeOnly(
++                          commandQueue, job.startLine, endLine, targetCLBuffer, &renderEvent);
++                    }
+ 
+                     if (renderEvent())
+                     {
+@@ -2291,6 +3001,10 @@ namespace gladius::ui
+ 
+                     result.completedLine = advanced ? endLine : job.startLine;
+                     result.completedFrame = result.completedLine >= job.height;
++                    if (!advanced && isExactRealtimeJob)
++                    {
++                        result.cancelled = true;
++                    }
+                 }
+                 else
+                 {
+@@ -2309,9 +3023,11 @@ namespace gladius::ui
+         }
+         else if (result.completedFrame)
+         {
+-            m_asyncController->publishFrame(writeBuffer, result.frameId, result.epoch);
++                        m_asyncController->publishFrame(
++                            writeBuffer, result.frameId, result.epoch, result.viewEpoch);
+             m_asyncProgressiveBuffer = nullptr;
+             m_asyncProgressiveEpoch.store(0, std::memory_order_release);
++                        m_asyncProgressiveViewEpoch.store(0, std::memory_order_release);
+         }
+ 
+         auto const endTime = std::chrono::steady_clock::now();
+@@ -2747,13 +3463,13 @@ namespace gladius::ui
+     void RenderWindow::zoomIn()
+     {
+         m_camera.zoom(-0.1f); // Negative zoom means zoom in
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::zoomOut()
+     {
+         m_camera.zoom(0.1f); // Positive zoom means zoom out
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+     void RenderWindow::resetZoom()
+@@ -2767,10 +3483,11 @@ namespace gladius::ui
+         }
+ 
+         m_camera.adjustDistanceToTarget(*bbox, m_renderWindowSize_px.x, m_renderWindowSize_px.y);
+-        invalidateView();
++        invalidateCameraView();
+     }
+ 
+-    void RenderWindow::scheduleAsyncBboxUpdate()
++    void RenderWindow::scheduleAsyncBboxUpdate(
++      async_rendering::RenderTaskRequest const * coordinatorTask)
+     {
+         if (!m_asyncController || !m_asyncInitialized)
+         {
+@@ -2791,6 +3508,11 @@ namespace gladius::ui
+         async_rendering::RenderJob job{};
+         job.type = async_rendering::RenderJobType::BoundingBoxUpdate;
+         job.epoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
++        if (coordinatorTask != nullptr)
++        {
++            job.coordinatorRequestId = coordinatorTask->requestId;
++            job.coordinatorStamp = coordinatorTask->stamp;
++        }
+ 
+         m_asyncController->enqueueJob(job);
+     }
+@@ -2806,6 +3528,8 @@ namespace gladius::ui
+         result.epoch = job.epoch;
+         result.jobType = job.type;
+         result.cancelled = false;
++        result.coordinatorRequestId = job.coordinatorRequestId;
++        result.coordinatorStamp = job.coordinatorStamp;
+ 
+         auto const startTime = std::chrono::steady_clock::now();
+ 
+@@ -2867,6 +3591,8 @@ namespace gladius::ui
+         result.jobType = job.type;
+         result.cancelled = false;
+         result.precomputedSdfUpdated = false;
++        result.coordinatorRequestId = job.coordinatorRequestId;
++        result.coordinatorStamp = job.coordinatorStamp;
+ 
+         auto const startTime = std::chrono::steady_clock::now();
+ 
+@@ -2898,10 +3624,9 @@ namespace gladius::ui
+         try
+         {
+             // Get worker queue (or fallback to main queue)
+-            auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
+-
+-            cl::CommandQueue const * queuePtr =
+-              workerQueue != nullptr ? workerQueue : &m_core->getComputeContext()->GetQueue();
++            auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
++            cl::CommandQueue const & queueRef =
++              queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
+ 
+             // Acquire compute token non-blockingly to serialize with refreshWorker().
+             // refreshWorker() holds the mutex while it rebuilds CL programs and
+@@ -2916,7 +3641,7 @@ namespace gladius::ui
+             }
+ 
+             // Launch async SDF precomputation (returns cl::Event)
+-            cl::Event sdfEvent = m_core->precomputeSdfAsync(*queuePtr);
++            cl::Event sdfEvent = m_core->precomputeSdfAsync(queueRef);
+ 
+             // Release the compute token — the kernel is already enqueued and the
+             // CL runtime retains its own references to the memory objects.
+@@ -3010,7 +3735,8 @@ namespace gladius::ui
+ 
+     // ============== Async Preview Rendering ==============
+ 
+-    bool RenderWindow::scheduleAsyncPreviewJob()
++    bool RenderWindow::scheduleAsyncPreviewJob(
++      async_rendering::RenderTaskRequest const * coordinatorTask)
+     {
+         ZoneScoped;
+         ZoneName("scheduleAsyncPreviewJob", strlen("scheduleAsyncPreviewJob"));
+@@ -3053,6 +3779,7 @@ namespace gladius::ui
+             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
+         }
+         m_asyncController->setLatestEpoch(job.epoch);
++        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+ 
+         // Use low-res preview resolution
+         auto const [previewWidth, previewHeight] = m_core->getLowResPreviewResolution();
+@@ -3063,6 +3790,11 @@ namespace gladius::ui
+         job.stepSize = static_cast<size_t>(previewHeight);
+         job.precomputeSdf = false;
+         job.enableHighQuality = false;
++        if (coordinatorTask != nullptr)
++        {
++            job.coordinatorRequestId = coordinatorTask->requestId;
++            job.coordinatorStamp = coordinatorTask->stamp;
++        }
+ 
+         // Track preview job state
+         m_asyncPreviewEpoch.store(job.epoch, std::memory_order_release);
+@@ -3087,16 +3819,19 @@ namespace gladius::ui
+ 
+         using namespace async_rendering;
+ 
+-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
++        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
+         auto const & commandQueue =
+-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
++          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
+ 
+         FrameResultMeta result{};
+         result.frameId = job.frameHint;
+         result.epoch = job.epoch;
++        result.viewEpoch = job.viewEpoch;
+         result.jobType = job.type;
+         result.width = job.width;
+         result.height = job.height;
++        result.coordinatorRequestId = job.coordinatorRequestId;
++        result.coordinatorStamp = job.coordinatorStamp;
+ 
+         // Note: We do NOT cancel preview jobs based on epoch changes.
+         // This ensures smooth visual feedback during camera movement.
+@@ -3214,9 +3949,12 @@ namespace gladius::ui
+         PreviewResultMeta previewMeta{};
+         previewMeta.frameId = job.frameHint;
+         previewMeta.epoch = job.epoch;
++        previewMeta.viewEpoch = job.viewEpoch;
+         previewMeta.latencyNs = result.computeDurationNs;
+         previewMeta.cancelled = false;
+         previewMeta.sdfWasValid = m_core->isSdfValid();
++        previewMeta.coordinatorRequestId = job.coordinatorRequestId;
++        previewMeta.coordinatorStamp = job.coordinatorStamp;
+ 
+         m_asyncPreviewJobInFlight.store(false, std::memory_order_release);
+         // Note: Don't set m_asyncPreviewFrameId here - it's set in processAsyncPreviewResults
+@@ -3246,6 +3984,37 @@ namespace gladius::ui
+ 
+         auto const & meta = result.value();
+ 
++                auto const currentEpoch = m_asyncCurrentEpoch.load(std::memory_order_acquire);
++                auto const currentViewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
++                bool const staleForCurrentView =
++                    meta.epoch < currentEpoch || (meta.viewEpoch != 0 && meta.viewEpoch < currentViewEpoch);
++                bool const exactRealtimeJobInFlight =
++                    m_asyncRealtimeJobInFlight.load(std::memory_order_acquire);
++                bool const suppressForRealtimeRaymarch =
++                    exactRealtimeJobInFlight || staleForCurrentView;
++
++        if (suppressForRealtimeRaymarch)
++        {
++            ZoneText("PreviewSkippedForRealtimeRaymarch", 34);
++            m_streamingFrameConsumed.store(true, std::memory_order_release);
++            auto cancelledMeta = meta;
++            cancelledMeta.cancelled = true;
++            completeCoordinatorPreviewTask(cancelledMeta);
++            return;
++        }
++
++        // FR-026: Do not replace a higher-quality frame with a lower-quality preview.
++        // If a HQ/realtime frame for the current view is already displayed, suppress the preview.
++        if (m_renderUpdateCoordinator.isHighQualityFrameCurrent())
++        {
++            ZoneText("PreviewSkippedForQualityRegression", 35);
++            m_streamingFrameConsumed.store(true, std::memory_order_release);
++            auto cancelledMeta = meta;
++            cancelledMeta.cancelled = true;
++            completeCoordinatorPreviewTask(cancelledMeta);
++            return;
++        }
++
+         // Skip frames that are older than what we've already displayed.
+         // This ensures we never show an older frame after a newer one.
+         // Use frameId (which is monotonically increasing) for ordering.
+@@ -3254,14 +4023,19 @@ namespace gladius::ui
+         {
+             ZoneText("OutOfOrderPreviewSkipped", 24);
+             m_streamingFrameConsumed.store(true, std::memory_order_release);
++            completeCoordinatorPreviewTask(meta);
+             return;
+         }
+ 
+         // Skip cancelled results
+         if (meta.cancelled)
+         {
++            if (auto logger = m_core->getSharedLogger()) {
++                logger->logInfo("[Preview] Cancelled preview skipped.");
++            }
+             ZoneText("CancelledPreviewSkipped", 23);
+             m_streamingFrameConsumed.store(true, std::memory_order_release);
++            completeCoordinatorPreviewTask(meta);
+             return;
+         }
+ 
+@@ -3274,6 +4048,10 @@ namespace gladius::ui
+         auto resultImage = m_core->getResultImage();
+         auto renderProgram = m_core->tryGetBestRenderProgram().value_or(SharedRenderProgram{});
+         bool scheduleAdaptivePreview = false;
++        
++        if (auto logger = m_core->getSharedLogger()) {
++            logger->logInfo(std::string("[Preview] Result Consumed, Latency ") + std::to_string(meta.latencyNs / 1000000) + "ms. Resampling!");
++        }
+ 
+         if (lowResImage && resultImage && renderProgram)
+         {
+@@ -3360,6 +4138,10 @@ namespace gladius::ui
+         m_lowResFeedbackPending.store(false, std::memory_order_release);
+         m_lastLowResRenderTime = std::chrono::system_clock::now();
+         m_lastLowResPreviewEpoch.store(meta.epoch, std::memory_order_release);
++        completeCoordinatorPreviewTask(meta);
++        if (auto logger = m_core->getSharedLogger()) {
++            logger->logInfo("[Preview] Task Complete triggered!");
++        }
+ 
+         if (scheduleAdaptivePreview)
+         {
+@@ -3370,6 +4152,22 @@ namespace gladius::ui
+ 
+     void RenderWindow::startStreamingPreview()
+     {
++        if (m_core)
++        {
++            auto const image = m_core->getResultImage();
++            if (image && image->getWidth() > 0 && image->getHeight() > 0)
++            {
++                auto const width = static_cast<uint32_t>(image->getWidth());
++                auto const height = static_cast<uint32_t>(image->getHeight());
++                queueRenderDecision(m_renderUpdateCoordinator.configureViewport(width, height));
++
++                if (m_asyncJobInFlight.load(std::memory_order_acquire))
++                {
++                    return;
++                }
++            }
++        }
++
+         m_streamingPreviewActive.store(true, std::memory_order_release);
+ 
+         // (Re-)schedule the streaming job if none is currently running.
+@@ -3384,7 +4182,11 @@ namespace gladius::ui
+ 
+     void RenderWindow::stopStreamingPreview()
+     {
+-        m_streamingPreviewActive.store(false, std::memory_order_release);
++        bool const wasActive = m_streamingPreviewActive.exchange(false, std::memory_order_acq_rel);
++        if (wasActive)
++        {
++            queueRenderDecision(m_renderUpdateCoordinator.notifyParameterInteractionEnded());
++        }
+     }
+ 
+     void RenderWindow::cancelAllAsyncWork()
+@@ -3413,7 +4215,8 @@ namespace gladius::ui
+         return m_streamingPreviewActive.load(std::memory_order_acquire);
+     }
+ 
+-    bool RenderWindow::scheduleStreamingPreviewJob()
++    bool RenderWindow::scheduleStreamingPreviewJob(
++      async_rendering::RenderTaskRequest const * coordinatorTask)
+     {
+         if (!m_asyncController || !m_asyncController->isRunning())
+         {
+@@ -3444,6 +4247,7 @@ namespace gladius::ui
+             m_asyncCurrentEpoch.store(job.epoch, std::memory_order_release);
+         }
+         m_asyncController->setLatestEpoch(job.epoch);
++        job.viewEpoch = m_asyncViewEpoch.load(std::memory_order_acquire);
+ 
+         auto const [previewWidth, previewHeight] = m_core->getLowResPreviewResolution();
+         job.width = static_cast<uint32_t>(previewWidth);
+@@ -3453,6 +4257,11 @@ namespace gladius::ui
+         job.stepSize = static_cast<size_t>(previewHeight);
+         job.precomputeSdf = false;
+         job.enableHighQuality = false;
++        if (coordinatorTask != nullptr)
++        {
++            job.coordinatorRequestId = coordinatorTask->requestId;
++            job.coordinatorStamp = coordinatorTask->stamp;
++        }
+ 
+         m_streamingJobInFlight.store(true, std::memory_order_release);
+         m_asyncPreviewJobInFlight.store(true, std::memory_order_release);
+@@ -3471,15 +4280,18 @@ namespace gladius::ui
+ #endif
+         using namespace async_rendering;
+ 
+-        auto * workerQueue = (m_asyncController ? m_asyncController->workerQueue() : nullptr);
++        auto queueOwner = (m_asyncController ? m_asyncController->workerQueueShared() : nullptr);
+         auto const & commandQueue =
+-          workerQueue != nullptr ? *workerQueue : m_core->getComputeContext()->GetQueue();
++          queueOwner ? *queueOwner : m_core->getComputeContext()->GetQueue();
+ 
+         FrameResultMeta result{};
+         result.epoch = job.epoch;
++        result.viewEpoch = job.viewEpoch;
+         result.jobType = job.type;
+         result.width = job.width;
+         result.height = job.height;
++        result.coordinatorRequestId = job.coordinatorRequestId;
++        result.coordinatorStamp = job.coordinatorStamp;
+ 
+         auto const shouldStop = [&]() -> bool {
+             return !m_streamingPreviewActive.load(std::memory_order_acquire) ||
+@@ -3627,8 +4439,11 @@ namespace gladius::ui
+             PreviewResultMeta previewMeta{};
+             previewMeta.frameId = frameCounter;
+             previewMeta.epoch = job.epoch;
++            previewMeta.viewEpoch = job.viewEpoch;
+             previewMeta.cancelled = false;
+             previewMeta.sdfWasValid = m_core->isSdfValid();
++            previewMeta.coordinatorRequestId = job.coordinatorRequestId;
++            previewMeta.coordinatorStamp = job.coordinatorStamp;
+ 
+             auto const iterEnd = std::chrono::steady_clock::now();
+             previewMeta.latencyNs = static_cast<uint64_t>(
+diff --git a/gladius/src/ui/RenderWindow.h b/gladius/src/ui/RenderWindow.h
+index 23e0166..b739c16 100644
+--- a/gladius/src/ui/RenderWindow.h
++++ b/gladius/src/ui/RenderWindow.h
+@@ -5,6 +5,8 @@
+ #include "OrbitalCamera.h"
+ #include "compute/ComputeCore.h"
+ #include "render/AsyncRenderController.h"
++#include "render/RealtimeRaymarchController.h"
++#include "render/RenderUpdateCoordinator.h"
+ #include <CL/cl_platform.h>
+ #include <atomic>
+ #include <chrono>
+@@ -158,6 +160,8 @@ namespace gladius::ui
+          */
+         [[nodiscard]] bool isCameraMoving() const;
+ 
++        [[nodiscard]] bool isForceRealtimeMode() const noexcept;
++
+       private:
+         void render(RenderWindowState & state);
+         void renderLoadingOverlay();
+@@ -169,18 +173,41 @@ namespace gladius::ui
+         void renderSync(RenderWindowState & state);
+         void renderAsync(RenderWindowState & state);
+         void processAsyncResults(RenderWindowState & state);
+-        bool scheduleAsyncRenderJob(RenderWindowState & state);
++        bool scheduleAsyncRenderJob(
++          RenderWindowState & state,
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
++        bool scheduleRealtimeRenderJob(
++          RenderWindowState & state,
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+         coro::task<async_rendering::FrameResultMeta> executeAsyncRenderJob(
+           async_rendering::RenderJob const & job,
+           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+         void notifyAsyncEpochIncrement();
++        void invalidateCameraView();
+         void adjustProgressFromDuration(RenderWindowState & state, uint64_t computeDurationNs);
++        [[nodiscard]] async_rendering::RealtimeRaymarchConfig loadRealtimeRaymarchConfig() const;
++        void saveRealtimeRaymarchMode(async_rendering::RealtimeRaymarchMode mode) const;
++        void queueRenderDecision(async_rendering::RenderUpdateDecision decision);
++        [[nodiscard]] bool executeQueuedRenderCommands(RenderWindowState & state);
++        [[nodiscard]] bool executeRenderCommand(async_rendering::RenderCommand const & command,
++                                                RenderWindowState & state);
++        [[nodiscard]] bool scheduleCoordinatorTask(async_rendering::RenderTaskRequest const & task,
++                                                   RenderWindowState & state);
++        [[nodiscard]] bool isRealtimeRaymarchCameraInteraction() const noexcept;
++        [[nodiscard]] bool scheduleAsyncSdfPrecomputation(
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
++        void completeCoordinatorTask(async_rendering::RenderTaskRequest const & request,
++                                     async_rendering::RenderTaskStatus status);
++        void completeCoordinatorTask(async_rendering::FrameResultMeta const & result,
++                                     bool producedDisplayFrame);
++        void completeCoordinatorPreviewTask(async_rendering::PreviewResultMeta const & result);
+ 
+         [[nodiscard]] bool isAsyncBackendActive() const noexcept;
+         [[nodiscard]] std::optional<BoundingBox> tryFetchBoundingBox(bool requestAsyncUpdate);
+ 
+         // Async bounding box computation
+-        void scheduleAsyncBboxUpdate();
++        void scheduleAsyncBboxUpdate(
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+         coro::task<async_rendering::FrameResultMeta> executeAsyncBboxUpdate(
+           async_rendering::RenderJob const & job,
+           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+@@ -196,14 +223,16 @@ namespace gladius::ui
+           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+ 
+         // Async preview rendering (non-blocking low-res preview during camera movement)
+-        bool scheduleAsyncPreviewJob();
++        bool scheduleAsyncPreviewJob(
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+         coro::task<async_rendering::FrameResultMeta> executeAsyncPreviewJob(
+           async_rendering::RenderJob const & job,
+           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+         void processAsyncPreviewResults();
+ 
+         // Streaming preview loop (tight render loop during parameter drag)
+-        bool scheduleStreamingPreviewJob();
++        bool scheduleStreamingPreviewJob(
++          async_rendering::RenderTaskRequest const * coordinatorTask = nullptr);
+         coro::task<async_rendering::FrameResultMeta> executeStreamingPreviewJob(
+           async_rendering::RenderJob const & job,
+           async_rendering::AsyncRenderController::CancelCheck const & cancelCheck);
+@@ -235,6 +264,7 @@ namespace gladius::ui
+         RenderWindowState m_renderWindowState{};
+ 
+         bool m_centerViewRequested = false;
++        int m_cameraIdleFrames{0};
+         bool m_enableHQRendering = true;
+ 
+         ImVec2 m_contentAreaMin;
+@@ -316,12 +346,17 @@ namespace gladius::ui
+         void onCameraManuallyMoved();
+ 
+         async_rendering::AsyncRenderFeatureConfig m_asyncConfig{};
++        async_rendering::RenderUpdateCoordinator m_renderUpdateCoordinator{};
++        std::vector<async_rendering::RenderCommand> m_pendingRenderCommands;
+         std::shared_ptr<async_rendering::AsyncRenderController> m_asyncController;
+         std::atomic<uint64_t> m_asyncEpochCounter{0};
+         std::atomic<uint64_t> m_asyncCurrentEpoch{0};
++          std::atomic<uint64_t> m_asyncViewEpoch{0};
+         std::atomic<uint64_t> m_asyncInFlightEpoch{0};
++          std::atomic<uint64_t> m_asyncInFlightViewEpoch{0};
+         std::atomic<uint64_t> m_asyncFrameCounter{0};
+         std::atomic<bool> m_asyncJobInFlight{false};
++        std::atomic<bool> m_asyncRealtimeJobInFlight{false};
+         std::atomic<bool> m_asyncBboxJobInFlight{false};
+         std::atomic<bool> m_asyncBboxUpdatePending{
+           false}; // Tracks if bbox needs update after current job
+@@ -339,6 +374,7 @@ namespace gladius::ui
+         // Progressive rendering: reuse same buffer for all chunks in a frame
+         async_rendering::FrameBuffer * m_asyncProgressiveBuffer{nullptr};
+         std::atomic<uint64_t> m_asyncProgressiveEpoch{0};
++        std::atomic<uint64_t> m_asyncProgressiveViewEpoch{0};
+ 
+         // Async preview rendering state (separate from HQ progressive rendering)
+         std::atomic<uint64_t> m_asyncPreviewEpoch{0};       ///< Current preview epoch for cancellation
+diff --git a/gladius/src/ui/render/AsyncRenderController.cpp b/gladius/src/ui/render/AsyncRenderController.cpp
+index 98c76c6..8793208 100644
+--- a/gladius/src/ui/render/AsyncRenderController.cpp
++++ b/gladius/src/ui/render/AsyncRenderController.cpp
+@@ -45,6 +45,7 @@ namespace gladius::ui::async_rendering
+             coro::queue<RenderJob> jobQueue;
+             std::atomic<bool> shutdownRequested{false};
+             std::atomic<uint64_t> latestEpoch{0};
++            std::atomic<uint64_t> latestViewEpoch{0};
+             AsyncRenderController::JobExecutor jobExecutor;
+ 
+             std::mutex resultMutex;
+@@ -133,6 +134,7 @@ namespace gladius::ui::async_rendering
+ 
+         m_state->data.shutdownRequested.store(false, std::memory_order_release);
+         m_state->data.latestEpoch.store(0, std::memory_order_release);
++        m_state->data.latestViewEpoch.store(0, std::memory_order_release);
+         {
+             std::lock_guard<std::mutex> resultLock(m_state->data.resultMutex);
+             m_state->data.pendingResult.reset();
+@@ -199,6 +201,22 @@ namespace gladius::ui::async_rendering
+         }
+     }
+ 
++    void AsyncRenderController::setLatestViewEpoch(uint64_t viewEpoch)
++    {
++        if (!m_state)
++        {
++            return;
++        }
++
++        auto & latestViewEpoch = m_state->data.latestViewEpoch;
++        auto current = latestViewEpoch.load(std::memory_order_acquire);
++        while (viewEpoch > current &&
++               !latestViewEpoch.compare_exchange_weak(
++                 current, viewEpoch, std::memory_order_acq_rel, std::memory_order_acquire))
++        {
++        }
++    }
++
+     void AsyncRenderController::setJobExecutor(JobExecutor executor)
+     {
+         if (!m_state)
+@@ -298,19 +316,43 @@ namespace gladius::ui::async_rendering
+             // (the UI thread). Without this, the entire job runs on the UI thread, blocking it.
+             co_await data->workerPool->schedule();
+ 
+-            auto cancellationCheck = [data, jobEpoch = job.epoch]() -> bool
++            // Pre-execution epoch-only check: safe to skip without storing a result because
++            // notifyAsyncEpochIncrement() clears the in-flight flags on epoch changes.
++            // View-epoch changes must NOT skip here — they need the executor to store a
++            // cancelled result so processAsyncResults() can clear m_asyncJobInFlight.
++            auto const epochOnlyCheck = [data, jobEpoch = job.epoch]() -> bool
+             {
+                 return data->shutdownRequested.load(std::memory_order_acquire) ||
+                        data->latestEpoch.load(std::memory_order_acquire) > jobEpoch;
+             };
+ 
++            // In-execution check: also cancels HQ progressive jobs when the view epoch advances
++            // (camera moved), so the GPU is released quickly for realtime rendering.
++            // Realtime jobs are intentionally excluded: they complete fast and are always shown
++            // even with a stale view (allowForcedRealtimeStaleView = true).
++            bool const isHqProgressiveJob = (job.type == RenderJobType::HighQuality);
++            auto cancellationCheck = [data,
++                                      jobEpoch = job.epoch,
++                                      jobViewEpoch = job.viewEpoch,
++                                      isHqProgressiveJob]() -> bool
++            {
++                if (data->shutdownRequested.load(std::memory_order_acquire))
++                    return true;
++                if (data->latestEpoch.load(std::memory_order_acquire) > jobEpoch)
++                    return true;
++                if (isHqProgressiveJob && jobViewEpoch > 0 &&
++                    data->latestViewEpoch.load(std::memory_order_acquire) > jobViewEpoch)
++                    return true;
++                return false;
++            };
++
+             // Preview/streaming jobs must not be skipped here — their executors
+             // manage m_asyncPreviewJobInFlight and m_streamingJobInFlight flags
+             // that are only cleared inside the executor. Skipping the job would
+             // leave those flags stuck at true, preventing any future scheduling.
+             bool const isPreviewJob = (job.type == RenderJobType::LowResPreview ||
+                                        job.type == RenderJobType::StreamingPreview);
+-            if (!isPreviewJob && cancellationCheck())
++            if (!isPreviewJob && epochOnlyCheck())
+             {
+                 continue;
+             }
+@@ -358,10 +400,10 @@ namespace gladius::ui::async_rendering
+               !m_stagingBuffer)
+         {
+             m_stagingBuffer.reset();
+-            m_workerQueue.reset();
+-
+-            // Create dedicated worker command queue (no GL interop needed)
+-            m_workerQueue = std::make_unique<cl::CommandQueue>(context.createQueue());
++            {
++                std::lock_guard<std::mutex> queueLock(m_workerQueueMutex);
++                m_workerQueue = std::make_shared<cl::CommandQueue>(context.createQueue());
++            }
+ 
+             // Create CL-only staging buffer for async rendering
+             static cl::ImageFormat const format = {CL_RGBA, CL_FLOAT};
+@@ -386,12 +428,14 @@ namespace gladius::ui::async_rendering
+                 fb.state.store(FrameState::Idle, std::memory_order_release);
+                 fb.frameId.store(0, std::memory_order_release);
+                 fb.epoch.store(0, std::memory_order_release);
++                fb.viewEpoch.store(0, std::memory_order_release);
+                 fb.readyTimestampNs.store(0, std::memory_order_release);
+                 fb.publishTimestampNs.store(0, std::memory_order_release);
+             }
+ 
+             // First buffer starts as Front
+             m_frameBuffers[0].state.store(FrameState::Front, std::memory_order_release);
++            m_framePresentation.reset(m_frameBuffers.size());
+             m_frontBufferIndex.store(0, std::memory_order_release);
+         }
+     }
+@@ -401,6 +445,12 @@ namespace gladius::ui::async_rendering
+         return m_workerQueue.get();
+     }
+ 
++    std::shared_ptr<cl::CommandQueue> AsyncRenderController::workerQueueShared() const noexcept
++    {
++        std::lock_guard<std::mutex> lock(m_workerQueueMutex);
++        return m_workerQueue;
++    }
++
+     cl::Image2D * AsyncRenderController::stagingBuffer() noexcept
+     {
+         return m_stagingBuffer.get();
+@@ -446,20 +496,56 @@ namespace gladius::ui::async_rendering
+         return nullptr;
+     }
+ 
+-    bool AsyncRenderController::tryTransitionBuffer(FrameBuffer * buffer,
+-                                                    FrameState expectedState,
+-                                                    FrameState newState) noexcept
++    std::optional<size_t>
++    AsyncRenderController::frameBufferIndex(FrameBuffer const * buffer) const noexcept
+     {
+-        ProfileFunction
++        if (buffer == nullptr)
++        {
++            return std::nullopt;
++        }
++
++        for (size_t index = 0; index < m_frameBuffers.size(); ++index)
++        {
++            if (&m_frameBuffers[index] == buffer)
++            {
++                return index;
++            }
++        }
++        return std::nullopt;
++    }
+ 
+-          if (!buffer)
++    bool AsyncRenderController::tryTransitionBufferLocked(FrameBuffer * buffer,
++                                                          FrameState expectedState,
++                                                          FrameState newState) noexcept
++    {
++        if (buffer == nullptr)
+         {
+             return false;
+         }
+ 
+         FrameState expected = expectedState;
+-        return buffer->state.compare_exchange_strong(
++        bool const transitioned = buffer->state.compare_exchange_strong(
+           expected, newState, std::memory_order_acq_rel, std::memory_order_acquire);
++        if (!transitioned)
++        {
++            return false;
++        }
++
++        if (auto const index = frameBufferIndex(buffer); index.has_value())
++        {
++            [[maybe_unused]] bool const mirrored =
++              m_framePresentation.tryTransitionBuffer(*index, expectedState, newState);
++        }
++        return true;
++    }
++
++    bool AsyncRenderController::tryTransitionBuffer(FrameBuffer * buffer,
++                                                    FrameState expectedState,
++                                                    FrameState newState) noexcept
++    {
++        ProfileFunction
++        std::lock_guard<std::mutex> lock(m_bufferMutex);
++        return tryTransitionBufferLocked(buffer, expectedState, newState);
+     }
+ 
+     FrameBuffer * AsyncRenderController::frontBuffer() noexcept
+@@ -473,24 +559,35 @@ namespace gladius::ui::async_rendering
+     {
+         ProfileFunction std::lock_guard<std::mutex> lock(m_bufferMutex);
+ 
+-        // Find an Idle buffer to write to
+-        for (auto & buffer : m_frameBuffers)
++        auto const bufferId =
++          m_framePresentation.acquireWriteBuffer(RenderStamp{.sceneEpoch = epoch});
++        if (!bufferId.has_value() || *bufferId >= m_frameBuffers.size())
+         {
+-            if (tryTransitionBuffer(&buffer, FrameState::Idle, FrameState::Writing))
+-            {
+-                buffer.epoch.store(epoch, std::memory_order_release);
+-                return &buffer;
+-            }
++            return nullptr;
+         }
+ 
+-        // No Idle buffer available - this shouldn't happen with triple buffering
+-        // but can happen with double buffering if UI is slow
+-        return nullptr;
++        auto & buffer = m_frameBuffers[*bufferId];
++        FrameState expected = FrameState::Idle;
++        bool const transitioned = buffer.state.compare_exchange_strong(
++          expected, FrameState::Writing, std::memory_order_acq_rel, std::memory_order_acquire);
++        if (!transitioned)
++        {
++            [[maybe_unused]] bool const rolledBack =
++              m_framePresentation.tryTransitionBuffer(*bufferId,
++                                                      FrameState::Writing,
++                                                      FrameState::Idle);
++            return nullptr;
++        }
++
++        buffer.epoch.store(epoch, std::memory_order_release);
++        buffer.viewEpoch.store(0, std::memory_order_release);
++        return &buffer;
+     }
+ 
+     void AsyncRenderController::publishFrame(FrameBuffer * buffer,
+                                              uint64_t frameId,
+-                                             uint64_t epoch) noexcept
++                                             uint64_t epoch,
++                                             uint64_t viewEpoch) noexcept
+     {
+         ProfileFunction if (!buffer)
+         {
+@@ -501,6 +598,7 @@ namespace gladius::ui::async_rendering
+ 
+         buffer->frameId.store(frameId, std::memory_order_release);
+         buffer->epoch.store(epoch, std::memory_order_release);
++        buffer->viewEpoch.store(viewEpoch, std::memory_order_release);
+ 
+         // Get current timestamp (nanoseconds since epoch)
+         auto const now = std::chrono::high_resolution_clock::now();
+@@ -510,39 +608,38 @@ namespace gladius::ui::async_rendering
+ 
+         // Transition Writing → Ready
+         FrameState expected = FrameState::Writing;
+-        buffer->state.compare_exchange_strong(
++        bool const transitioned = buffer->state.compare_exchange_strong(
+           expected, FrameState::Ready, std::memory_order_release, std::memory_order_acquire);
++        if (transitioned)
++        {
++            if (auto const index = frameBufferIndex(buffer); index.has_value())
++            {
++                [[maybe_unused]] bool const mirrored = m_framePresentation.publishFrame(
++                  *index, frameId, RenderStamp{.sceneEpoch = epoch, .viewEpoch = viewEpoch});
++            }
++        }
+     }
+ 
+     FrameBuffer * AsyncRenderController::promoteReadyToFront() noexcept
+     {
+         ProfileFunction std::lock_guard<std::mutex> lock(m_bufferMutex);
+ 
+-        // Find the newest Ready buffer (highest frameId)
+-        FrameBuffer * newestReady = nullptr;
+-        uint64_t highestFrameId = 0;
+-
+-        for (auto & buffer : m_frameBuffers)
+-        {
+-            if (buffer.state.load(std::memory_order_acquire) == FrameState::Ready)
+-            {
+-                auto const frameId = buffer.frameId.load(std::memory_order_acquire);
+-                if (frameId > highestFrameId)
+-                {
+-                    highestFrameId = frameId;
+-                    newestReady = &buffer;
+-                }
+-            }
+-        }
+-
+-        if (!newestReady)
++        auto const newestReadyIndex = m_framePresentation.selectNewestReady();
++        if (!newestReadyIndex.has_value() || *newestReadyIndex >= m_frameBuffers.size())
+         {
+             return nullptr; // No Ready buffer available
+         }
+ 
++        auto * newestReady = &m_frameBuffers[*newestReadyIndex];
++
+         // Transition Ready → Resampling
+-        if (!tryTransitionBuffer(newestReady, FrameState::Ready, FrameState::Resampling))
++        FrameState expected = FrameState::Ready;
++        bool const transitioned = newestReady->state.compare_exchange_strong(
++          expected, FrameState::Resampling, std::memory_order_acq_rel, std::memory_order_acquire);
++        if (!transitioned)
+         {
++            [[maybe_unused]] bool const rolledBack = m_framePresentation.tryTransitionBuffer(
++              *newestReadyIndex, FrameState::Resampling, FrameState::Ready);
+             return nullptr; // Lost race
+         }
+ 
+@@ -551,6 +648,32 @@ namespace gladius::ui::async_rendering
+         return newestReady;
+     }
+ 
++    void AsyncRenderController::discardReadyFrame(uint64_t frameId,
++                                                  uint64_t epoch,
++                                                  uint64_t viewEpoch) noexcept
++    {
++        std::lock_guard<std::mutex> lock(m_bufferMutex);
++
++        for (auto & buffer : m_frameBuffers)
++        {
++            if (buffer.state.load(std::memory_order_acquire) != FrameState::Ready)
++            {
++                continue;
++            }
++
++            if (buffer.frameId.load(std::memory_order_acquire) != frameId ||
++                buffer.epoch.load(std::memory_order_acquire) != epoch ||
++                buffer.viewEpoch.load(std::memory_order_acquire) != viewEpoch)
++            {
++                continue;
++            }
++
++            [[maybe_unused]] bool const released =
++              tryTransitionBufferLocked(&buffer, FrameState::Ready, FrameState::Idle);
++            return;
++        }
++    }
++
+     bool AsyncRenderController::finalizeFrontPromotion(FrameBuffer * buffer) noexcept
+     {
+         ProfileFunction
+@@ -575,7 +698,10 @@ namespace gladius::ui::async_rendering
+             return false;
+         }
+ 
+-        if (!tryTransitionBuffer(&(*it), FrameState::Resampling, FrameState::Front))
++        FrameState expected = FrameState::Resampling;
++        bool const transitioned = it->state.compare_exchange_strong(
++          expected, FrameState::Front, std::memory_order_acq_rel, std::memory_order_acquire);
++        if (!transitioned)
+         {
+             return false;
+         }
+@@ -595,6 +721,8 @@ namespace gladius::ui::async_rendering
+                                                           std::memory_order_acquire);
+         }
+ 
++        [[maybe_unused]] bool const mirrored = m_framePresentation.finalizeFrontPromotion(newIndex);
++
+         it->publishTimestampNs.store(static_cast<uint64_t>(ns), std::memory_order_release);
+         return true;
+     }
+@@ -617,7 +745,7 @@ namespace gladius::ui::async_rendering
+             if (state == FrameState::Writing && bufEpoch <= oldEpoch)
+             {
+                 [[maybe_unused]] bool const released =
+-                  tryTransitionBuffer(&buffer, FrameState::Writing, FrameState::Idle);
++                  tryTransitionBufferLocked(&buffer, FrameState::Writing, FrameState::Idle);
+             }
+         }
+     }
+diff --git a/gladius/src/ui/render/AsyncRenderController.h b/gladius/src/ui/render/AsyncRenderController.h
+index 29a0471..d7cc1d0 100644
+--- a/gladius/src/ui/render/AsyncRenderController.h
++++ b/gladius/src/ui/render/AsyncRenderController.h
+@@ -12,6 +12,7 @@
+ #include <coro/coro.hpp>
+ 
+ #include "AsyncRenderTypes.h"
++#include "FramePresentationController.h"
+ 
+ // Include OpenCL platform types for cl_float4
+ #include <CL/cl_platform.h>
+@@ -81,6 +82,7 @@ namespace gladius::ui::async_rendering
+ 
+         void enqueueJob(RenderJob job);
+         void setLatestEpoch(uint64_t epoch);
++        void setLatestViewEpoch(uint64_t viewEpoch);
+         void setJobExecutor(JobExecutor executor);
+         [[nodiscard]] std::optional<FrameResultMeta> tryConsumeResult();
+ 
+@@ -92,6 +94,9 @@ namespace gladius::ui::async_rendering
+ 
+         /// Get worker-specific command queue (used by worker thread for rendering)
+         [[nodiscard]] cl::CommandQueue * workerQueue() noexcept;
++        /// Thread-safe snapshot — safe to call from worker threads concurrently with
++        /// initializeAsyncResources(). Holds the queue alive for the caller's lifetime.
++        [[nodiscard]] std::shared_ptr<cl::CommandQueue> workerQueueShared() const noexcept;
+ 
+         /// Get staging buffer (used by worker thread for rendering output)
+         [[nodiscard]] cl::Image2D * stagingBuffer() noexcept;
+@@ -114,13 +119,19 @@ namespace gladius::ui::async_rendering
+         [[nodiscard]] FrameBuffer * acquireWriteBuffer(uint64_t epoch) noexcept;
+ 
+         /// Publish a finished frame (Writing → Ready)
+-        void publishFrame(FrameBuffer * buffer, uint64_t frameId, uint64_t epoch) noexcept;
++        void publishFrame(FrameBuffer * buffer,
++                uint64_t frameId,
++                uint64_t epoch,
++                uint64_t viewEpoch = 0) noexcept;
+ 
+         /// Promote a Ready buffer to Front (for UI display)
+         [[nodiscard]] FrameBuffer * promoteReadyToFront() noexcept;
+ 
+-  /// Finalize promotion by transitioning Resampling → Front and updating indices
+-  [[nodiscard]] bool finalizeFrontPromotion(FrameBuffer * buffer) noexcept;
++          /// Release a completed Ready frame that should no longer be displayed.
++          void discardReadyFrame(uint64_t frameId, uint64_t epoch, uint64_t viewEpoch) noexcept;
++
++          /// Finalize promotion by transitioning Resampling → Front and updating indices
++          [[nodiscard]] bool finalizeFrontPromotion(FrameBuffer * buffer) noexcept;
+ 
+         /// Release any Writing buffers from old epochs back to Idle
+         /// (used when epoch changes to clean up cancelled jobs)
+@@ -156,17 +167,25 @@ namespace gladius::ui::async_rendering
+         [[nodiscard]] static auto workerLoop(std::shared_ptr<ControllerState> state)
+           -> coro::task<void>;
+ 
++        [[nodiscard]] std::optional<size_t>
++          frameBufferIndex(FrameBuffer const * buffer) const noexcept;
++        [[nodiscard]] bool tryTransitionBufferLocked(FrameBuffer * buffer,
++                                                     FrameState expectedState,
++                                                     FrameState newState) noexcept;
++
+         std::shared_ptr<ControllerState> m_state;
+         std::atomic<bool> m_running{false};
+ 
+         // OpenCL resources for async rendering (Option A: separate CL queue, no GL interop)
+-        std::unique_ptr<cl::CommandQueue> m_workerQueue;
++        mutable std::mutex m_workerQueueMutex;
++        std::shared_ptr<cl::CommandQueue> m_workerQueue;
+         std::unique_ptr<cl::Image2D> m_stagingBuffer;
+         size_t m_stagingWidth{0};
+         size_t m_stagingHeight{0};
+ 
+         // Triple buffer state machine (for HQ progressive rendering)
+         std::array<FrameBuffer, 3> m_frameBuffers;
++        FramePresentationController m_framePresentation{m_frameBuffers.size()};
+         std::atomic<size_t> m_frontBufferIndex{0};
+         mutable std::mutex m_bufferMutex;
+ 
+diff --git a/gladius/src/ui/render/AsyncRenderTypes.h b/gladius/src/ui/render/AsyncRenderTypes.h
+index be32899..1b255a3 100644
+--- a/gladius/src/ui/render/AsyncRenderTypes.h
++++ b/gladius/src/ui/render/AsyncRenderTypes.h
+@@ -1,5 +1,7 @@
+ #pragma once
+ 
++#include "RenderUpdateTypes.h"
++
+ #include <atomic>
+ #include <cstddef>
+ #include <cstdint>
+@@ -44,6 +46,7 @@ namespace gladius::ui::async_rendering
+     enum class RenderJobType
+     {
+         HighQuality,
++        RealtimeHighQuality,
+         LowResPreview,
+         StreamingPreview,     // Continuous preview loop during parameter drag
+         BoundingBoxUpdate,
+@@ -58,6 +61,7 @@ namespace gladius::ui::async_rendering
+     struct RenderJob
+     {
+         uint64_t epoch{0};
++        uint64_t viewEpoch{0};
+         uint64_t frameHint{0};
+         RenderJobType type{RenderJobType::HighQuality};
+         uint32_t width{0};
+@@ -67,6 +71,8 @@ namespace gladius::ui::async_rendering
+         bool precomputeSdf{false};
+         bool enableHighQuality{true};
+         bool precomputedSdf{false};  // True if SDF should be precomputed before rendering
++        uint64_t coordinatorRequestId{0};
++        RenderStamp coordinatorStamp{};
+     };
+ 
+     /**
+@@ -76,6 +82,7 @@ namespace gladius::ui::async_rendering
+     {
+         uint64_t frameId{0};
+         uint64_t epoch{0};
++        uint64_t viewEpoch{0};
+         RenderJobType jobType{RenderJobType::HighQuality};
+         uint32_t width{0};
+         uint32_t height{0};
+@@ -88,6 +95,8 @@ namespace gladius::ui::async_rendering
+         float compilationProgress{0.0f};  // 0.0 - 1.0 for compilation jobs
+         bool compilationSucceeded{false};
+         std::string compilationError;     // Empty if no error
++        uint64_t coordinatorRequestId{0};
++        RenderStamp coordinatorStamp{};
+     };
+ 
+     /**
+@@ -113,9 +122,12 @@ namespace gladius::ui::async_rendering
+     {
+         uint64_t frameId{0};         ///< Matches PreviewRenderJob::frameId
+         uint64_t epoch{0};           ///< Matches PreviewRenderJob::epoch
++        uint64_t viewEpoch{0};       ///< Camera/view generation captured when the preview was queued
+         uint64_t latencyNs{0};       ///< Time from job enqueue to completion (nanoseconds)
+         bool cancelled{false};       ///< True if job was cancelled due to epoch change
+         bool sdfWasValid{false};     ///< True if SDF was available during rendering
++        uint64_t coordinatorRequestId{0};
++        RenderStamp coordinatorStamp{};
+     };
+ 
+     /**
+@@ -127,6 +139,7 @@ namespace gladius::ui::async_rendering
+         std::atomic<FrameState> state{FrameState::Idle};
+         std::atomic<uint64_t> frameId{0};
+         std::atomic<uint64_t> epoch{0};
++        std::atomic<uint64_t> viewEpoch{0};
+         std::atomic<uint64_t> readyTimestampNs{0};
+         std::atomic<uint64_t> publishTimestampNs{0};
+ 
+diff --git a/gladius/src/ui/render/FramePresentationController.h b/gladius/src/ui/render/FramePresentationController.h
+new file mode 100644
+index 0000000..222b7d9
+--- /dev/null
++++ b/gladius/src/ui/render/FramePresentationController.h
+@@ -0,0 +1,226 @@
++#pragma once
++
++#include "AsyncRenderTypes.h"
++#include "RenderUpdateTypes.h"
++
++#include <cstddef>
++#include <cstdint>
++#include <optional>
++#include <vector>
++
++namespace gladius::ui::async_rendering
++{
++    /**
++     * @brief Metadata-only buffer used by FramePresentationController.
++     */
++    struct PresentationBuffer
++    {
++        size_t id{0};
++        FrameState state{FrameState::Idle};
++        uint64_t frameId{0};
++        RenderStamp stamp{};
++    };
++
++    /**
++     * @brief Pure state machine for selecting, publishing, and promoting rendered frames.
++     *
++     * This class intentionally knows nothing about OpenGL/OpenCL resources. Production buffer
++     * owners can use it as the policy layer while keeping actual image allocation elsewhere.
++     */
++    class FramePresentationController
++    {
++      public:
++        explicit FramePresentationController(size_t bufferCount = 3)
++        {
++            reset(bufferCount);
++        }
++
++        void reset(size_t bufferCount)
++        {
++            m_buffers.clear();
++            m_buffers.reserve(bufferCount);
++            for (size_t index = 0; index < bufferCount; ++index)
++            {
++                m_buffers.push_back(PresentationBuffer{.id = index});
++            }
++
++            if (!m_buffers.empty())
++            {
++                m_buffers.front().state = FrameState::Front;
++                m_frontBufferId = m_buffers.front().id;
++            }
++            else
++            {
++                m_frontBufferId.reset();
++            }
++        }
++
++        [[nodiscard]] std::optional<size_t> frontBufferId() const noexcept
++        {
++            return m_frontBufferId;
++        }
++
++        [[nodiscard]] PresentationBuffer const * buffer(size_t bufferId) const noexcept
++        {
++            if (bufferId >= m_buffers.size())
++            {
++                return nullptr;
++            }
++            return &m_buffers[bufferId];
++        }
++
++        [[nodiscard]] std::optional<size_t> acquireWriteBuffer(RenderStamp const & stamp) noexcept
++        {
++            for (auto & candidate : m_buffers)
++            {
++                if (candidate.state != FrameState::Idle)
++                {
++                    continue;
++                }
++
++                candidate.state = FrameState::Writing;
++                candidate.frameId = 0;
++                candidate.stamp = stamp;
++                return candidate.id;
++            }
++            return std::nullopt;
++        }
++
++        [[nodiscard]] bool publishFrame(size_t bufferId,
++                                        uint64_t frameId,
++                                        RenderStamp const & stamp) noexcept
++        {
++            auto * target = mutableBuffer(bufferId);
++            if (target == nullptr || target->state != FrameState::Writing)
++            {
++                return false;
++            }
++
++            target->frameId = frameId;
++            target->stamp = stamp;
++            target->state = FrameState::Ready;
++            return true;
++        }
++
++        [[nodiscard]] bool tryTransitionBuffer(size_t bufferId,
++                                               FrameState expectedState,
++                                               FrameState newState) noexcept
++        {
++            auto * target = mutableBuffer(bufferId);
++            if (target == nullptr || target->state != expectedState)
++            {
++                return false;
++            }
++
++            target->state = newState;
++            if (newState == FrameState::Idle)
++            {
++                target->frameId = 0;
++            }
++            if (newState == FrameState::Front)
++            {
++                m_frontBufferId = target->id;
++            }
++            return true;
++        }
++
++        [[nodiscard]] std::optional<size_t> selectNewestReady() noexcept
++        {
++            return selectNewestReady(RenderStamp{}, RenderStampMask::none());
++        }
++
++        [[nodiscard]] std::optional<size_t> selectNewestReady(RenderStamp const & required,
++                                                              RenderStampMask const mask) noexcept
++        {
++            PresentationBuffer * newest = nullptr;
++            for (auto & candidate : m_buffers)
++            {
++                if (candidate.state != FrameState::Ready || !matches(candidate.stamp, required, mask))
++                {
++                    continue;
++                }
++
++                if (newest == nullptr || candidate.frameId > newest->frameId)
++                {
++                    newest = &candidate;
++                }
++            }
++
++            if (newest == nullptr)
++            {
++                return std::nullopt;
++            }
++
++            newest->state = FrameState::Resampling;
++            return newest->id;
++        }
++
++        [[nodiscard]] bool finalizeFrontPromotion(size_t bufferId) noexcept
++        {
++            auto * target = mutableBuffer(bufferId);
++            if (target == nullptr || target->state != FrameState::Resampling)
++            {
++                return false;
++            }
++
++            if (m_frontBufferId.has_value())
++            {
++                auto * previousFront = mutableBuffer(*m_frontBufferId);
++                if (previousFront != nullptr && previousFront->id != target->id &&
++                    previousFront->state == FrameState::Front)
++                {
++                    previousFront->state = FrameState::Idle;
++                    previousFront->frameId = 0;
++                }
++            }
++
++            target->state = FrameState::Front;
++            m_frontBufferId = target->id;
++            return true;
++        }
++
++        [[nodiscard]] bool discardReadyFrame(size_t bufferId) noexcept
++        {
++            auto * target = mutableBuffer(bufferId);
++            if (target == nullptr || target->state != FrameState::Ready)
++            {
++                return false;
++            }
++
++            target->state = FrameState::Idle;
++            target->frameId = 0;
++            return true;
++        }
++
++        [[nodiscard]] size_t releaseStaleWritingBuffers(RenderStamp const & required,
++                                                        RenderStampMask const mask) noexcept
++        {
++            size_t releasedCount = 0;
++            for (auto & candidate : m_buffers)
++            {
++                if (candidate.state != FrameState::Writing || !isOlderThan(candidate.stamp, required, mask))
++                {
++                    continue;
++                }
++
++                candidate.state = FrameState::Idle;
++                candidate.frameId = 0;
++                ++releasedCount;
++            }
++            return releasedCount;
++        }
++
++      private:
++        [[nodiscard]] PresentationBuffer * mutableBuffer(size_t bufferId) noexcept
++        {
++            if (bufferId >= m_buffers.size())
++            {
++                return nullptr;
++            }
++            return &m_buffers[bufferId];
++        }
++
++        std::vector<PresentationBuffer> m_buffers;
++        std::optional<size_t> m_frontBufferId;
++    };
++}
+diff --git a/gladius/src/ui/render/RealtimeRaymarchController.cpp b/gladius/src/ui/render/RealtimeRaymarchController.cpp
+new file mode 100644
+index 0000000..33e80a1
+--- /dev/null
++++ b/gladius/src/ui/render/RealtimeRaymarchController.cpp
+@@ -0,0 +1,413 @@
++#include "RealtimeRaymarchController.h"
++
++#include <algorithm>
++#include <cctype>
++#include <cmath>
++
++namespace gladius::ui::async_rendering
++{
++    namespace
++    {
++        [[nodiscard]] std::string normalizeModeString(std::string value)
++        {
++            std::transform(value.begin(),
++                           value.end(),
++                           value.begin(),
++                           [](unsigned char character)
++                           { return static_cast<char>(std::tolower(character)); });
++            return value;
++        }
++    }
++
++    RealtimeRaymarchMode realtimeRaymarchModeFromString(std::string const & value)
++    {
++        auto const normalized = normalizeModeString(value);
++        if (normalized == "off" || normalized == "disabled" || normalized == "false")
++        {
++            return RealtimeRaymarchMode::Off;
++        }
++        if (normalized == "force" || normalized == "forced" || normalized == "on")
++        {
++            return RealtimeRaymarchMode::Force;
++        }
++        return RealtimeRaymarchMode::Auto;
++    }
++
++    char const * realtimeRaymarchModeToString(RealtimeRaymarchMode mode) noexcept
++    {
++        switch (mode)
++        {
++        case RealtimeRaymarchMode::Off:
++            return "off";
++        case RealtimeRaymarchMode::Force:
++            return "force";
++        case RealtimeRaymarchMode::Auto:
++        default:
++            return "auto";
++        }
++    }
++
++    void RealtimeRaymarchController::configure(RealtimeRaymarchConfig config)
++    {
++        config.targetFrameTimeMs = std::max(config.targetFrameTimeMs, 1.0f);
++        config.enterBudgetRatio = std::clamp(config.enterBudgetRatio, 0.1f, 1.0f);
++        config.exitBudgetRatio = std::max(config.exitBudgetRatio, config.enterBudgetRatio);
++        config.severeMissRatio = std::max(config.severeMissRatio, config.exitBudgetRatio);
++        config.ewmaAlpha = std::clamp(config.ewmaAlpha, 0.01f, 1.0f);
++        config.requiredFastSamples = std::max(config.requiredFastSamples, 1);
++        config.maxSlowSamples = std::max(config.maxSlowSamples, 1);
++        config.cooldownFrames = std::max(config.cooldownFrames, 0);
++        config.staticFullFrameBudgetMs = std::max(config.staticFullFrameBudgetMs, config.targetFrameTimeMs);
++        config.realtimeDropBudgetMs = std::max(config.realtimeDropBudgetMs, config.targetFrameTimeMs);
++
++        m_config = config;
++        if (m_config.mode == RealtimeRaymarchMode::Off)
++        {
++            m_realtimeActive = false;
++        }
++    }
++
++    RealtimeRaymarchConfig const & RealtimeRaymarchController::config() const noexcept
++    {
++        return m_config;
++    }
++
++    void RealtimeRaymarchController::reset()
++    {
++        m_estimatedFullFrameMs.reset();
++        m_width = 0;
++        m_height = 0;
++        m_fastSampleStreak = 0;
++        m_slowSampleStreak = 0;
++        m_cooldownFramesRemaining = 0;
++        m_realtimeActive = false;
++        m_staticFullFramePreferred = false;
++    }
++
++    void RealtimeRaymarchController::resetForResolution(uint32_t width, uint32_t height)
++    {
++        if (m_width == width && m_height == height)
++        {
++            return;
++        }
++
++        auto const previousEstimate = m_estimatedFullFrameMs;
++        auto const previousWidth = m_width;
++        auto const previousHeight = m_height;
++        bool const wasRealtimeActive = m_realtimeActive;
++
++        reset();
++        m_width = width;
++        m_height = height;
++
++        if (!previousEstimate.has_value() || previousWidth == 0 || previousHeight == 0 || width == 0 || height == 0)
++        {
++            return;
++        }
++
++        auto const previousPixels = static_cast<double>(previousWidth) * static_cast<double>(previousHeight);
++        auto const currentPixels = static_cast<double>(width) * static_cast<double>(height);
++        if (previousPixels <= 0.0 || currentPixels <= 0.0)
++        {
++            return;
++        }
++
++        auto const scale = std::clamp(currentPixels / previousPixels, 0.1, 10.0);
++        auto const scaledEstimate = static_cast<float>(*previousEstimate * scale);
++        if (!std::isfinite(scaledEstimate) || scaledEstimate <= 0.0f)
++        {
++            return;
++        }
++
++        m_estimatedFullFrameMs = scaledEstimate;
++
++        auto const enterBudget = m_config.targetFrameTimeMs * m_config.enterBudgetRatio;
++        auto const exitBudget = m_config.targetFrameTimeMs * m_config.exitBudgetRatio;
++        if (scaledEstimate <= enterBudget || (wasRealtimeActive && scaledEstimate <= exitBudget))
++        {
++            m_fastSampleStreak = m_config.requiredFastSamples;
++            m_realtimeActive = m_config.mode == RealtimeRaymarchMode::Auto;
++            m_staticFullFramePreferred = true;
++        }
++        else if (scaledEstimate <= m_config.staticFullFrameBudgetMs)
++        {
++            m_staticFullFramePreferred = true;
++        }
++    }
++
++    void RealtimeRaymarchController::beginFrame()
++    {
++        if (m_cooldownFramesRemaining > 0)
++        {
++            --m_cooldownFramesRemaining;
++        }
++    }
++
++    void RealtimeRaymarchController::recordStaticProgressiveSample(RealtimeRaymarchSample const & sample)
++    {
++        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled)
++        {
++            return;
++        }
++
++        if (sample.width == 0 || sample.height == 0)
++        {
++            return;
++        }
++
++        if (!hasValidResolution(sample.width, sample.height))
++        {
++            resetForResolution(sample.width, sample.height);
++        }
++
++        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
++        if (!estimatedMs.has_value())
++        {
++            return;
++        }
++
++        recordEstimatedTime(*estimatedMs);
++        m_staticFullFramePreferred = *estimatedMs <= m_config.staticFullFrameBudgetMs;
++        if (m_staticFullFramePreferred)
++        {
++            m_slowSampleStreak = 0;
++        }
++    }
++
++    void RealtimeRaymarchController::recordStaticFullFrameSample(RealtimeRaymarchSample const & sample)
++    {
++        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled || !sample.completedFrame)
++        {
++            return;
++        }
++
++        if (sample.width == 0 || sample.height == 0)
++        {
++            return;
++        }
++
++        if (!hasValidResolution(sample.width, sample.height))
++        {
++            resetForResolution(sample.width, sample.height);
++        }
++
++        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
++        if (!estimatedMs.has_value())
++        {
++            return;
++        }
++
++        recordEstimatedTime(*estimatedMs);
++        m_staticFullFramePreferred = *estimatedMs <= m_config.staticFullFrameBudgetMs;
++
++        if (*estimatedMs <= m_config.targetFrameTimeMs * m_config.enterBudgetRatio)
++        {
++            ++m_fastSampleStreak;
++            m_slowSampleStreak = 0;
++            if (m_fastSampleStreak >= m_config.requiredFastSamples)
++            {
++                m_realtimeActive = true;
++            }
++            return;
++        }
++
++        m_fastSampleStreak = 0;
++        if (*estimatedMs > m_config.realtimeDropBudgetMs)
++        {
++            deactivateRealtime();
++        }
++    }
++
++    void RealtimeRaymarchController::recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample)
++    {
++        if (m_config.mode != RealtimeRaymarchMode::Auto || sample.cancelled || !sample.completedFrame)
++        {
++            return;
++        }
++
++        if (sample.width == 0 || sample.height == 0)
++        {
++            return;
++        }
++
++        if (!hasValidResolution(sample.width, sample.height))
++        {
++            resetForResolution(sample.width, sample.height);
++        }
++
++        auto const estimatedMs = estimateSampleFullFrameTimeMs(sample);
++        if (!estimatedMs.has_value())
++        {
++            return;
++        }
++
++        recordEstimatedTime(*estimatedMs);
++        if (*estimatedMs > m_config.realtimeDropBudgetMs)
++        {
++            deactivateRealtime();
++        }
++    }
++
++    void RealtimeRaymarchController::recordRejectedAttempt()
++    {
++        deactivateRealtime();
++        m_fastSampleStreak = 0;
++        ++m_slowSampleStreak;
++        if (m_slowSampleStreak >= m_config.maxSlowSamples)
++        {
++            enterCooldown();
++        }
++    }
++
++    bool RealtimeRaymarchController::canAttemptRealtime(
++      uint32_t width,
++      uint32_t height,
++      RealtimeRaymarchGuards const & guards) const noexcept
++    {
++        if (m_config.mode == RealtimeRaymarchMode::Off)
++        {
++            return false;
++        }
++        if (!hasValidResolution(width, height))
++        {
++            return false;
++        }
++        if (!guardsAllowAttempt(guards))
++        {
++            return false;
++        }
++        if (m_config.mode == RealtimeRaymarchMode::Force)
++        {
++            return true;
++        }
++        if (m_cooldownFramesRemaining > 0)
++        {
++            return false;
++        }
++        return m_realtimeActive;
++    }
++
++    bool RealtimeRaymarchController::canAttemptStaticFullFrame(
++      uint32_t width,
++      uint32_t height,
++      RealtimeRaymarchGuards const & guards) const noexcept
++    {
++        if (m_config.mode != RealtimeRaymarchMode::Auto)
++        {
++            return false;
++        }
++        if (!m_staticFullFramePreferred || m_cooldownFramesRemaining > 0)
++        {
++            return false;
++        }
++        if (!hasValidResolution(width, height))
++        {
++            return false;
++        }
++        return guardsAllowAttempt(guards);
++    }
++
++    bool RealtimeRaymarchController::isRealtimeActive() const noexcept
++    {
++        return m_config.mode == RealtimeRaymarchMode::Force || m_realtimeActive;
++    }
++
++    bool RealtimeRaymarchController::isCoolingDown() const noexcept
++    {
++        return m_cooldownFramesRemaining > 0;
++    }
++
++    std::optional<float> RealtimeRaymarchController::estimatedFullFrameTimeMs() const noexcept
++    {
++        return m_estimatedFullFrameMs;
++    }
++
++    char const * RealtimeRaymarchController::modeLabel() const noexcept
++    {
++        if (m_config.mode == RealtimeRaymarchMode::Force)
++        {
++            return "RT Force";
++        }
++        if (m_config.mode == RealtimeRaymarchMode::Off)
++        {
++            return "RT Off";
++        }
++        if (m_realtimeActive)
++        {
++            return "RT Auto";
++        }
++        if (m_cooldownFramesRemaining > 0)
++        {
++            return "RT Cooldown";
++        }
++        return "RT Learning";
++    }
++
++    bool RealtimeRaymarchController::hasValidResolution(uint32_t width, uint32_t height) const noexcept
++    {
++        return width > 0 && height > 0 && m_width == width && m_height == height;
++    }
++
++    bool RealtimeRaymarchController::guardsAllowAttempt(
++      RealtimeRaymarchGuards const & guards) const noexcept
++    {
++        return !guards.hardBlocker && !guards.renderJobInFlight && !guards.previewJobInFlight &&
++               !guards.streamingActive && !guards.streamingJobInFlight && !guards.resizePending;
++    }
++
++    std::optional<float> RealtimeRaymarchController::estimateSampleFullFrameTimeMs(
++      RealtimeRaymarchSample const & sample) const noexcept
++    {
++        if (sample.durationMs <= 0.0f || !std::isfinite(sample.durationMs))
++        {
++            return std::nullopt;
++        }
++
++        if (sample.completedFrame)
++        {
++            return sample.durationMs;
++        }
++
++        if (sample.renderedLines == 0 || sample.totalLines == 0)
++        {
++            return std::nullopt;
++        }
++
++        auto const clampedLines = std::min(sample.renderedLines, sample.totalLines);
++        if (clampedLines == 0)
++        {
++            return std::nullopt;
++        }
++
++        auto const scale = static_cast<float>(sample.totalLines) / static_cast<float>(clampedLines);
++        return sample.durationMs * scale;
++    }
++
++    void RealtimeRaymarchController::recordEstimatedTime(float estimatedMs)
++    {
++        if (!m_estimatedFullFrameMs.has_value())
++        {
++            m_estimatedFullFrameMs = estimatedMs;
++        }
++        else
++        {
++            m_estimatedFullFrameMs = (*m_estimatedFullFrameMs * (1.0f - m_config.ewmaAlpha)) +
++                                     (estimatedMs * m_config.ewmaAlpha);
++        }
++    }
++
++    void RealtimeRaymarchController::deactivateRealtime()
++    {
++        m_realtimeActive = false;
++        m_fastSampleStreak = 0;
++        m_staticFullFramePreferred = false;
++    }
++
++    void RealtimeRaymarchController::enterCooldown()
++    {
++        deactivateRealtime();
++        m_fastSampleStreak = 0;
++        m_slowSampleStreak = 0;
++        m_cooldownFramesRemaining = m_config.cooldownFrames;
++    }
++}
+diff --git a/gladius/src/ui/render/RealtimeRaymarchController.h b/gladius/src/ui/render/RealtimeRaymarchController.h
+new file mode 100644
+index 0000000..6b6b859
+--- /dev/null
++++ b/gladius/src/ui/render/RealtimeRaymarchController.h
+@@ -0,0 +1,101 @@
++#pragma once
++
++#include <cstddef>
++#include <cstdint>
++#include <optional>
++#include <string>
++
++namespace gladius::ui::async_rendering
++{
++    enum class RealtimeRaymarchMode
++    {
++        Off,
++        Auto,
++        Force
++    };
++
++    [[nodiscard]] RealtimeRaymarchMode realtimeRaymarchModeFromString(std::string const & value);
++    [[nodiscard]] char const * realtimeRaymarchModeToString(RealtimeRaymarchMode mode) noexcept;
++
++    struct RealtimeRaymarchConfig
++    {
++        RealtimeRaymarchMode mode{RealtimeRaymarchMode::Auto};
++        float targetFrameTimeMs{25.0f};
++        float enterBudgetRatio{1.0f};
++        float exitBudgetRatio{1.1f};
++        float severeMissRatio{2.0f};
++        float ewmaAlpha{0.35f};
++        int requiredFastSamples{1};
++        int maxSlowSamples{2};
++        int cooldownFrames{30};
++        float staticFullFrameBudgetMs{60.0f};
++        float realtimeDropBudgetMs{60.0f};
++    };
++
++    struct RealtimeRaymarchGuards
++    {
++        bool hardBlocker{false};
++        bool renderJobInFlight{false};
++        bool previewJobInFlight{false};
++        bool streamingActive{false};
++        bool streamingJobInFlight{false};
++        bool resizePending{false};
++    };
++
++    struct RealtimeRaymarchSample
++    {
++        float durationMs{0.0f};
++        uint32_t width{0};
++        uint32_t height{0};
++        size_t renderedLines{0};
++        size_t totalLines{0};
++        bool completedFrame{false};
++        bool cancelled{false};
++    };
++
++    class RealtimeRaymarchController
++    {
++      public:
++        void configure(RealtimeRaymarchConfig config);
++        [[nodiscard]] RealtimeRaymarchConfig const & config() const noexcept;
++
++        void reset();
++        void resetForResolution(uint32_t width, uint32_t height);
++        void beginFrame();
++
++        void recordStaticProgressiveSample(RealtimeRaymarchSample const & sample);
++        void recordStaticFullFrameSample(RealtimeRaymarchSample const & sample);
++        void recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample);
++        void recordRejectedAttempt();
++
++        [[nodiscard]] bool canAttemptRealtime(uint32_t width,
++                                              uint32_t height,
++                                              RealtimeRaymarchGuards const & guards) const noexcept;
++        [[nodiscard]] bool canAttemptStaticFullFrame(uint32_t width,
++                                                     uint32_t height,
++                                                     RealtimeRaymarchGuards const & guards) const noexcept;
++        [[nodiscard]] bool isRealtimeActive() const noexcept;
++        [[nodiscard]] bool isCoolingDown() const noexcept;
++        [[nodiscard]] std::optional<float> estimatedFullFrameTimeMs() const noexcept;
++        [[nodiscard]] char const * modeLabel() const noexcept;
++        [[nodiscard]] bool guardsAllowAttempt(RealtimeRaymarchGuards const & guards) const noexcept;
++
++      private:
++        [[nodiscard]] bool hasValidResolution(uint32_t width, uint32_t height) const noexcept;
++        [[nodiscard]] std::optional<float> estimateSampleFullFrameTimeMs(
++          RealtimeRaymarchSample const & sample) const noexcept;
++        void recordEstimatedTime(float estimatedMs);
++        void deactivateRealtime();
++        void enterCooldown();
++
++        RealtimeRaymarchConfig m_config{};
++        std::optional<float> m_estimatedFullFrameMs{};
++        uint32_t m_width{0};
++        uint32_t m_height{0};
++        int m_fastSampleStreak{0};
++        int m_slowSampleStreak{0};
++        int m_cooldownFramesRemaining{0};
++        bool m_realtimeActive{false};
++        bool m_staticFullFramePreferred{false};
++    };
++}
+diff --git a/gladius/src/ui/render/RenderUpdateCoordinator.h b/gladius/src/ui/render/RenderUpdateCoordinator.h
+new file mode 100644
+index 0000000..a166608
+--- /dev/null
++++ b/gladius/src/ui/render/RenderUpdateCoordinator.h
+@@ -0,0 +1,548 @@
++#pragma once
++
++#include "RealtimeRaymarchController.h"
++#include "RenderUpdateTypes.h"
++
++#include <algorithm>
++#include <cstddef>
++#include <cstdint>
++#include <optional>
++#include <vector>
++
++namespace gladius::ui::async_rendering
++{
++    enum class RenderInteractionState
++    {
++        Static,
++        CameraInteracting,
++        ParameterInteracting
++    };
++
++    enum class RenderCommandType
++    {
++        StartTask,
++        PresentFrame,
++        DiscardTaskResult,
++        KeepCurrentFrame
++    };
++
++    struct RenderCommand
++    {
++        RenderCommandType type{RenderCommandType::KeepCurrentFrame};
++        RenderTaskRequest task{};
++        RenderTaskResult result{};
++        RenderStamp stamp{};
++    };
++
++    struct RenderUpdateDecision
++    {
++        std::vector<RenderCommand> commands;
++    };
++
++    /**
++     * @brief Pure render/update policy that converts semantic UI/render events into task commands.
++     *
++     * The coordinator intentionally has no ImGui, OpenGL, OpenCL, GLImageBuffer, or ComputeCore
++     * dependency. Production code should translate these semantic commands into concrete work,
++     * while unit tests can drive the full epoch/backpressure/stale-result behavior directly.
++     */
++    class RenderUpdateCoordinator
++    {
++      public:
++        RenderUpdateCoordinator()
++        {
++            m_realtime.resetForResolution(m_width, m_height);
++        }
++
++        void configureRealtime(RealtimeRaymarchConfig config)
++        {
++            m_realtime.configure(config);
++            m_realtime.resetForResolution(m_width, m_height);
++        }
++
++        [[nodiscard]] RealtimeRaymarchConfig const & realtimeConfig() const noexcept
++        {
++            return m_realtime.config();
++        }
++
++        [[nodiscard]] bool isRealtimeActive() const noexcept
++        {
++            return m_realtime.isRealtimeActive();
++        }
++
++        void setRealtimeGuards(RealtimeRaymarchGuards guards) noexcept
++        {
++            m_realtimeGuards = guards;
++        }
++
++        void recordStaticProgressiveSample(RealtimeRaymarchSample const & sample)
++        {
++            m_realtime.recordStaticProgressiveSample(sample);
++        }
++
++        void recordStaticFullFrameSample(RealtimeRaymarchSample const & sample)
++        {
++            m_realtime.recordStaticFullFrameSample(sample);
++        }
++
++        void recordInteractiveRealtimeSample(RealtimeRaymarchSample const & sample)
++        {
++            m_realtime.recordInteractiveRealtimeSample(sample);
++        }
++
++        void recordRealtimeRejectedAttempt()
++        {
++            m_realtime.recordRejectedAttempt();
++        }
++
++        [[nodiscard]] RenderStamp latestStamp() const noexcept
++        {
++            return m_latestStamp;
++        }
++
++        [[nodiscard]] RenderInteractionState interactionState() const noexcept
++        {
++            return m_interactionState;
++        }
++
++        [[nodiscard]] bool isBoundingBoxCurrent() const noexcept
++        {
++            return m_boundingBoxStamp.has_value() &&
++                   matches(*m_boundingBoxStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
++        }
++
++        [[nodiscard]] bool isSdfCurrent() const noexcept
++        {
++            return m_sdfStamp.has_value() &&
++                   matches(*m_sdfStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
++        }
++
++        [[nodiscard]] bool isHeavyGeometryCurrent() const noexcept
++        {
++            return isBoundingBoxCurrent() && isSdfCurrent();
++        }
++
++        [[nodiscard]] bool isHighQualityFrameCurrent() const noexcept
++        {
++            return m_highQualityFrameStamp.has_value() &&
++                   matches(*m_highQualityFrameStamp, m_latestStamp, RenderStampMask::displayFrame());
++        }
++
++        [[nodiscard]] RenderUpdateDecision configureViewport(uint32_t width, uint32_t height)
++        {
++            RenderUpdateDecision decision{};
++            if (width == 0 || height == 0 || (width == m_width && height == m_height))
++            {
++                return decision;
++            }
++
++            m_width = width;
++            m_height = height;
++            ++m_latestStamp.viewportEpoch;
++            m_realtime.resetForResolution(m_width, m_height);
++            m_staticHQRenderTimeMs = -1.0f;
++            scheduleStaticCatchUp(decision);
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyCameraChanged()
++        {
++            RenderUpdateDecision decision{};
++            ++m_latestStamp.viewEpoch;
++            m_interactionState = RenderInteractionState::CameraInteracting;
++            scheduleInteractiveFrame(decision);
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyCameraInteractionEnded()
++        {
++            RenderUpdateDecision decision{};
++            if (m_interactionState == RenderInteractionState::CameraInteracting)
++            {
++                m_interactionState = RenderInteractionState::Static;
++            }
++            m_autoGestureLockedSimpler = false;
++            scheduleStaticCatchUp(decision);
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyParameterChanged(bool interactionActive)
++        {
++            RenderUpdateDecision decision{};
++            ++m_latestStamp.parameterEpoch;
++            m_parameterUploadStamp.reset();
++            m_boundingBoxStamp.reset();
++            m_sdfStamp.reset();
++            m_interactionState = interactionActive ? RenderInteractionState::ParameterInteracting
++                                                   : RenderInteractionState::Static;
++            if (!interactionActive)
++            {
++                resetRealtimeLearning();
++            }
++            startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
++            if (interactionActive)
++            {
++                scheduleInteractiveFrame(decision);
++            }
++            else
++            {
++                scheduleStaticCatchUp(decision);
++            }
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyParameterInteractionEnded()
++        {
++            RenderUpdateDecision decision{};
++            m_interactionState = RenderInteractionState::Static;
++            m_autoGestureLockedSimpler = false;
++            scheduleStaticCatchUp(decision);
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyStructuralModelChanged()
++        {
++            RenderUpdateDecision decision{};
++            ++m_latestStamp.sceneEpoch;
++            ++m_latestStamp.parameterEpoch;
++            resetRealtimeLearning();
++            m_programStamp.reset();
++            m_parameterUploadStamp.reset();
++            m_boundingBoxStamp.reset();
++            m_sdfStamp.reset();
++            m_interactionState = RenderInteractionState::Static;
++            scheduleStaticCatchUp(decision);
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision notifyProgramCompilationCompleted()
++        {
++            return completeTask(RenderTaskResult{.type = RenderTaskType::ProgramCompilation,
++                                                .stamp = m_latestStamp,
++                                                .status = RenderTaskStatus::Completed});
++        }
++
++        [[nodiscard]] RenderUpdateDecision tick()
++        {
++            RenderUpdateDecision decision{};
++            m_realtime.beginFrame();
++            if (m_interactionState == RenderInteractionState::Static)
++            {
++                scheduleStaticCatchUp(decision);
++            }
++            else
++            {
++                if (m_interactionState == RenderInteractionState::ParameterInteracting &&
++                    !areParametersUploaded())
++                {
++                    startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
++                }
++                scheduleInteractiveFrame(decision);
++            }
++            return decision;
++        }
++
++        [[nodiscard]] RenderUpdateDecision completeTask(RenderTaskResult const & result)
++        {
++            RenderUpdateDecision decision{};
++            removeInFlight(result);
++
++            auto const mask = freshnessMaskFor(result.type);
++            if (!result.isCurrentFor(m_latestStamp, mask))
++            {
++                decision.commands.push_back(RenderCommand{.type = RenderCommandType::DiscardTaskResult,
++                                                          .result = result,
++                                                          .stamp = m_latestStamp});
++                return decision;
++            }
++
++            switch (result.type)
++            {
++            case RenderTaskType::ProgramCompilation:
++                m_programStamp = result.stamp;
++                break;
++            case RenderTaskType::ParameterUpload:
++                m_parameterUploadStamp = result.stamp;
++                break;
++            case RenderTaskType::BoundingBoxUpdate:
++                m_boundingBoxStamp = result.stamp;
++                break;
++            case RenderTaskType::SdfPrecomputation:
++                m_sdfStamp = result.stamp;
++                break;
++            case RenderTaskType::RealtimeFullFrame:
++            case RenderTaskType::ProgressiveHighQualityChunk:
++            case RenderTaskType::LowResolutionPreview:
++            case RenderTaskType::StreamingPreview:
++                if (result.producedDisplayFrame)
++                {
++                    if (result.completedFrame &&
++                        (result.type == RenderTaskType::ProgressiveHighQualityChunk ||
++                         result.type == RenderTaskType::RealtimeFullFrame))
++                    {
++                        m_highQualityFrameStamp = result.stamp;
++                        if (result.type == RenderTaskType::ProgressiveHighQualityChunk &&
++                            m_interactionState == RenderInteractionState::Static &&
++                            result.durationNs > 0)
++                        {
++                            m_staticHQRenderTimeMs =
++                                static_cast<float>(result.durationNs) / 1'000'000.0f;
++                        }
++                    }
++                    decision.commands.push_back(RenderCommand{.type = RenderCommandType::PresentFrame,
++                                                              .result = result,
++                                                              .stamp = result.stamp});
++                }
++                break;
++            }
++
++            if (m_interactionState == RenderInteractionState::Static)
++            {
++                scheduleStaticCatchUp(decision);
++            }
++            return decision;
++        }
++
++      private:
++        struct InFlightTask
++        {
++            uint64_t requestId{0};
++            RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
++            RenderStamp stamp{};
++        };
++
++        [[nodiscard]] static constexpr RenderStampMask freshnessMaskFor(RenderTaskType type) noexcept
++        {
++            switch (type)
++            {
++            case RenderTaskType::ProgramCompilation:
++                return RenderStampMask::sceneOnly();
++            case RenderTaskType::ParameterUpload:
++            case RenderTaskType::BoundingBoxUpdate:
++            case RenderTaskType::SdfPrecomputation:
++                return RenderStampMask::heavyGeometryTask();
++            case RenderTaskType::RealtimeFullFrame:
++            case RenderTaskType::ProgressiveHighQualityChunk:
++            case RenderTaskType::LowResolutionPreview:
++            case RenderTaskType::StreamingPreview:
++            default:
++                return RenderStampMask::displayFrame();
++            }
++        }
++
++        [[nodiscard]] bool hasAnyInFlight(RenderTaskType type) const noexcept
++        {
++            return std::any_of(m_inFlight.begin(),
++                               m_inFlight.end(),
++                               [type](InFlightTask const & task) { return task.type == type; });
++        }
++
++        [[nodiscard]] bool hasInteractiveFrameInFlight() const noexcept
++        {
++            return hasAnyInFlight(RenderTaskType::RealtimeFullFrame) ||
++                   hasAnyInFlight(RenderTaskType::LowResolutionPreview) ||
++                   hasAnyInFlight(RenderTaskType::StreamingPreview);
++        }
++
++        [[nodiscard]] bool hasEquivalentInFlight(RenderTaskType type, RenderStamp const & stamp) const noexcept
++        {
++            auto const mask = freshnessMaskFor(type);
++            return std::any_of(m_inFlight.begin(),
++                               m_inFlight.end(),
++                               [type, stamp, mask](InFlightTask const & task)
++                               { return task.type == type && matches(task.stamp, stamp, mask); });
++        }
++
++        [[nodiscard]] bool isProgramCurrent() const noexcept
++        {
++            return m_programStamp.has_value() &&
++                   matches(*m_programStamp, m_latestStamp, RenderStampMask::sceneOnly());
++        }
++
++        [[nodiscard]] bool areParametersUploaded() const noexcept
++        {
++            return m_parameterUploadStamp.has_value() &&
++                   matches(*m_parameterUploadStamp, m_latestStamp, RenderStampMask::heavyGeometryTask());
++        }
++
++        void startTask(RenderUpdateDecision & decision,
++                       RenderTaskType type,
++                       RenderStamp const & stamp,
++                       size_t lineCount = 0)
++        {
++            if (hasAnyInFlight(type) || hasEquivalentInFlight(type, stamp))
++            {
++                keepCurrentFrame(decision);
++                return;
++            }
++
++            size_t const requestedLines = lineCount == 0 ? static_cast<size_t>(m_height) : lineCount;
++            size_t const clampedLineCount =
++                std::clamp(requestedLines, size_t{1}, static_cast<size_t>(m_height));
++
++            RenderTaskRequest request{.requestId = m_nextRequestId++,
++                                      .type = type,
++                                      .stamp = stamp,
++                                      .width = m_width,
++                                      .height = m_height,
++                                      .startLine = 0,
++                                      .lineCount = clampedLineCount};
++            m_inFlight.push_back(InFlightTask{.requestId = request.requestId,
++                                              .type = request.type,
++                                              .stamp = request.stamp});
++            decision.commands.push_back(RenderCommand{.type = RenderCommandType::StartTask,
++                                                      .task = request,
++                                                      .stamp = stamp});
++        }
++
++        void keepCurrentFrame(RenderUpdateDecision & decision) const
++        {
++            decision.commands.push_back(RenderCommand{.type = RenderCommandType::KeepCurrentFrame,
++                                                      .stamp = m_latestStamp});
++        }
++
++        void resetRealtimeLearning()
++        {
++            m_realtime.reset();
++            m_realtime.resetForResolution(m_width, m_height);
++            m_staticHQRenderTimeMs = -1.0f;
++            m_autoGestureLockedSimpler = false;
++        }
++
++        [[nodiscard]] bool autoModeAdmitsRealtime() const noexcept
++        {
++            return m_staticHQRenderTimeMs >= 0.0f && m_staticHQRenderTimeMs < 100.0f;
++        }
++
++        void scheduleInteractiveFrame(RenderUpdateDecision & decision)
++        {
++            if (hasInteractiveFrameInFlight())
++            {
++                keepCurrentFrame(decision);
++                return;
++            }
++
++            if (m_interactionState == RenderInteractionState::ParameterInteracting)
++            {
++                startTask(decision, RenderTaskType::LowResolutionPreview, m_latestStamp);
++                return;
++            }
++
++            // Auto mode: gate on measured static HQ time with per-gesture hysteresis
++            if (m_realtime.config().mode == RealtimeRaymarchMode::Auto)
++            {
++                if (!m_autoGestureLockedSimpler && !autoModeAdmitsRealtime())
++                {
++                    m_autoGestureLockedSimpler = true;
++                }
++                if (m_autoGestureLockedSimpler)
++                {
++                    startTask(decision, RenderTaskType::LowResolutionPreview, m_latestStamp);
++                    return;
++                }
++                if (m_realtime.guardsAllowAttempt(m_realtimeGuards))
++                {
++                    startTask(decision, RenderTaskType::RealtimeFullFrame, m_latestStamp);
++                    return;
++                }
++                // Guards transiently blocked — hold the current frame (FR-026: no quality regression)
++                keepCurrentFrame(decision);
++                return;
++            }
++
++            // Off mode: always preview
++            if (m_realtime.config().mode == RealtimeRaymarchMode::Off)
++            {
++                startTask(decision, RenderTaskType::LowResolutionPreview, m_latestStamp);
++                return;
++            }
++
++            // Force mode: prefer exact realtime; hold current frame if guards temporarily block (FR-014)
++            if (m_realtime.canAttemptRealtime(m_width, m_height, m_realtimeGuards))
++            {
++                startTask(decision, RenderTaskType::RealtimeFullFrame, m_latestStamp);
++                return;
++            }
++            keepCurrentFrame(decision);
++        }
++
++        void scheduleStaticCatchUp(RenderUpdateDecision & decision)
++        {
++            if (!isProgramCurrent())
++            {
++                startTask(decision, RenderTaskType::ProgramCompilation, m_latestStamp);
++                return;
++            }
++            if (!areParametersUploaded())
++            {
++                startTask(decision, RenderTaskType::ParameterUpload, m_latestStamp);
++                return;
++            }
++            if (!isBoundingBoxCurrent())
++            {
++                startTask(decision, RenderTaskType::BoundingBoxUpdate, m_latestStamp);
++                return;
++            }
++            if (!isSdfCurrent())
++            {
++                startTask(decision, RenderTaskType::SdfPrecomputation, m_latestStamp);
++                return;
++            }
++            if (isHighQualityFrameCurrent())
++            {
++                keepCurrentFrame(decision);
++                return;
++            }
++            if (m_realtime.canAttemptStaticFullFrame(m_width, m_height, m_realtimeGuards))
++            {
++                startTask(decision, RenderTaskType::RealtimeFullFrame, m_latestStamp);
++                return;
++            }
++            startTask(decision, RenderTaskType::ProgressiveHighQualityChunk, m_latestStamp);
++        }
++
++        void removeInFlight(RenderTaskResult const & result)
++        {
++            auto const byRequestId = [result](InFlightTask const & task)
++            { return result.requestId != 0 && task.requestId == result.requestId; };
++            auto const byTypeAndStamp = [result](InFlightTask const & task)
++            {
++                return task.type == result.type &&
++                       matches(task.stamp, result.stamp, freshnessMaskFor(result.type));
++            };
++            auto const byTypeWithoutRequestId = [result](InFlightTask const & task)
++            { return result.requestId == 0 && task.type == result.type; };
++
++            auto const oldEnd = m_inFlight.end();
++            auto const newEnd = std::remove_if(m_inFlight.begin(),
++                                               m_inFlight.end(),
++                                               [byRequestId, byTypeAndStamp, byTypeWithoutRequestId](
++                                                 InFlightTask const & task)
++                                               {
++                                                   return byRequestId(task) || byTypeAndStamp(task) ||
++                                                          byTypeWithoutRequestId(task);
++                                               });
++            m_inFlight.erase(newEnd, oldEnd);
++        }
++
++        RenderStamp m_latestStamp{};
++        std::optional<RenderStamp> m_programStamp{m_latestStamp};
++        std::optional<RenderStamp> m_parameterUploadStamp{m_latestStamp};
++        std::optional<RenderStamp> m_boundingBoxStamp{};
++        std::optional<RenderStamp> m_sdfStamp{};
++        std::optional<RenderStamp> m_highQualityFrameStamp{};
++        std::vector<InFlightTask> m_inFlight;
++        RealtimeRaymarchController m_realtime;
++        RealtimeRaymarchGuards m_realtimeGuards{};
++        RenderInteractionState m_interactionState{RenderInteractionState::Static};
++        uint64_t m_nextRequestId{1};
++        uint32_t m_width{1};
++        uint32_t m_height{1};
++        /// Wall-clock duration of the last completed static progressive HQ render in milliseconds.
++        /// Negative means not yet measured. Used by Auto mode to gate exact-realtime admission.
++        float m_staticHQRenderTimeMs{-1.0f};
++        /// Per-gesture latch: set when Auto mode first decides to use simpler rendering during
++        /// an interaction. Cleared when the gesture ends to prevent mid-gesture quality switches.
++        bool m_autoGestureLockedSimpler{false};
++    };
++}
+diff --git a/gladius/src/ui/render/RenderUpdateTypes.h b/gladius/src/ui/render/RenderUpdateTypes.h
+new file mode 100644
+index 0000000..ae1f8d5
+--- /dev/null
++++ b/gladius/src/ui/render/RenderUpdateTypes.h
+@@ -0,0 +1,179 @@
++#pragma once
++
++#include <cstddef>
++#include <cstdint>
++
++namespace gladius::ui::async_rendering
++{
++    /**
++     * @brief Identifies the independently changing inputs that make a rendered artifact fresh.
++     *
++     * Scene/model, parameter, camera/view, viewport, and quality generations intentionally evolve
++     * independently. This lets camera-only interaction reject stale view frames without forcing
++     * expensive model-side work such as bounding-box or SDF recomputation.
++     */
++    struct RenderStamp
++    {
++        uint64_t sceneEpoch{0};     ///< Structural model/program generation.
++        uint64_t parameterEpoch{0}; ///< Numeric parameter payload generation.
++        uint64_t viewEpoch{0};      ///< Camera/view generation.
++        uint64_t viewportEpoch{0};  ///< Render target size/generation.
++        uint64_t qualityEpoch{0};   ///< Render settings/quality generation.
++    };
++
++    /**
++     * @brief Selects which RenderStamp axes are relevant for a freshness comparison.
++     */
++    struct RenderStampMask
++    {
++        bool scene{true};
++        bool parameters{true};
++        bool view{true};
++        bool viewport{true};
++        bool quality{true};
++
++        [[nodiscard]] static constexpr RenderStampMask all() noexcept
++        {
++            return {};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask none() noexcept
++        {
++            return {.scene = false,
++                    .parameters = false,
++                    .view = false,
++                    .viewport = false,
++                    .quality = false};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask sceneOnly() noexcept
++        {
++            return {.scene = true,
++                    .parameters = false,
++                    .view = false,
++                    .viewport = false,
++                    .quality = false};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask sceneAndParameters() noexcept
++        {
++            return {.scene = true,
++                    .parameters = true,
++                    .view = false,
++                    .viewport = false,
++                    .quality = false};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask displayFrame() noexcept
++        {
++            return {.scene = true,
++                    .parameters = true,
++                    .view = true,
++                    .viewport = true,
++                    .quality = true};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask interactiveFrame() noexcept
++        {
++            return {.scene = true,
++                    .parameters = true,
++                    .view = true,
++                    .viewport = true,
++                    .quality = false};
++        }
++
++        [[nodiscard]] static constexpr RenderStampMask heavyGeometryTask() noexcept
++        {
++            return sceneAndParameters();
++        }
++    };
++
++    [[nodiscard]] constexpr bool matches(RenderStamp const & candidate,
++                                         RenderStamp const & required,
++                                         RenderStampMask const mask = RenderStampMask::all()) noexcept
++    {
++        return (!mask.scene || candidate.sceneEpoch == required.sceneEpoch) &&
++               (!mask.parameters || candidate.parameterEpoch == required.parameterEpoch) &&
++               (!mask.view || candidate.viewEpoch == required.viewEpoch) &&
++               (!mask.viewport || candidate.viewportEpoch == required.viewportEpoch) &&
++               (!mask.quality || candidate.qualityEpoch == required.qualityEpoch);
++    }
++
++    [[nodiscard]] constexpr bool isOlderThan(RenderStamp const & candidate,
++                                             RenderStamp const & required,
++                                             RenderStampMask const mask = RenderStampMask::all()) noexcept
++    {
++        return (mask.scene && candidate.sceneEpoch < required.sceneEpoch) ||
++               (mask.parameters && candidate.parameterEpoch < required.parameterEpoch) ||
++               (mask.view && candidate.viewEpoch < required.viewEpoch) ||
++               (mask.viewport && candidate.viewportEpoch < required.viewportEpoch) ||
++               (mask.quality && candidate.qualityEpoch < required.qualityEpoch);
++    }
++
++    /**
++     * @brief Testable semantic task kinds requested by the render-update coordinator.
++     */
++    enum class RenderTaskType
++    {
++        RealtimeFullFrame,
++        ProgressiveHighQualityChunk,
++        LowResolutionPreview,
++        StreamingPreview,
++        BoundingBoxUpdate,
++        SdfPrecomputation,
++        ParameterUpload,
++        ProgramCompilation
++    };
++
++    enum class RenderTaskStatus
++    {
++        Completed,
++        Cancelled,
++        Failed
++    };
++
++    /**
++     * @brief Pure description of render/update work before it is translated to GPU/UI calls.
++     */
++    struct RenderTaskRequest
++    {
++        uint64_t requestId{0};
++        RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
++        RenderStamp stamp{};
++        uint32_t width{0};
++        uint32_t height{0};
++        size_t startLine{0};
++        size_t lineCount{0};
++    };
++
++    /**
++     * @brief Pure completion metadata returned to the render-update coordinator.
++     */
++    struct RenderTaskResult
++    {
++        uint64_t requestId{0};
++        RenderTaskType type{RenderTaskType::ProgressiveHighQualityChunk};
++        RenderStamp stamp{};
++        RenderTaskStatus status{RenderTaskStatus::Completed};
++        uint64_t durationNs{0};
++        bool producedDisplayFrame{false};
++        bool completedFrame{false};
++
++        [[nodiscard]] constexpr bool succeeded() const noexcept
++        {
++            return status == RenderTaskStatus::Completed;
++        }
++
++        [[nodiscard]] constexpr bool isCurrentFor(RenderStamp const & required,
++                                                  RenderStampMask const mask) const noexcept
++        {
++            return succeeded() && matches(stamp, required, mask);
++        }
++
++        [[nodiscard]] constexpr bool isDisplayableFor(RenderStamp const & required,
++                                                      RenderStampMask const mask = RenderStampMask::displayFrame()) const noexcept
++        {
++            return producedDisplayFrame && isCurrentFor(required, mask);
++        }
++    };
++}
+diff --git a/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp b/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
+index 9ae45ba..8ba222d 100644
+--- a/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
++++ b/gladius/tests/integrationtests/MeshSdfPerformance_tests.cpp
+@@ -217,6 +217,32 @@ namespace gladius::tests
+             return std::make_unique<SpatialMeshResource>(key, vertices, indices);
+         }
+ 
++        /// Create a closed, consistently wound cube mesh for sharp-feature SDF tests.
++        static void createCubeMesh(std::vector<float4>& vertices,
++                                   std::vector<TriangleIndices>& indices,
++                                   float halfExtent)
++        {
++            vertices = {
++                makeFloat4(-halfExtent, -halfExtent, -halfExtent),
++                makeFloat4( halfExtent, -halfExtent, -halfExtent),
++                makeFloat4( halfExtent,  halfExtent, -halfExtent),
++                makeFloat4(-halfExtent,  halfExtent, -halfExtent),
++                makeFloat4(-halfExtent, -halfExtent,  halfExtent),
++                makeFloat4( halfExtent, -halfExtent,  halfExtent),
++                makeFloat4( halfExtent,  halfExtent,  halfExtent),
++                makeFloat4(-halfExtent,  halfExtent,  halfExtent),
++            };
++
++            indices = {
++                {4, 5, 6}, {4, 6, 7}, // +z
++                {1, 0, 3}, {1, 3, 2}, // -z
++                {5, 1, 2}, {5, 2, 6}, // +x
++                {0, 4, 7}, {0, 7, 3}, // -x
++                {7, 6, 2}, {7, 2, 3}, // +y
++                {0, 1, 5}, {0, 5, 4}, // -y
++            };
++        }
++
+         /// Create an icosphere mesh for testing
+         static void createIcosphere(std::vector<float4>& vertices,
+                                     std::vector<TriangleIndices>& indices,
+@@ -322,9 +348,12 @@ namespace gladius::tests
+         auto primitives = core->getPrimitives();
+         ASSERT_NE(primitives, nullptr);
+ 
++        bool const vdbSupported = core->getProgramManager().isVdbSupported();
++
+         gladius::compute::ManifoldDualContouringProgram sampler(
+             m_context, core->getResourceContext());
+         sampler.setLogger(m_logger);
++        sampler.setEnableVdb(vdbSupported);
+         sampler.setModelKernel(R"CLC(
+     float4 model(float3 pos, PAYLOAD_ARGS)
+     {
+@@ -337,20 +366,31 @@ namespace gladius::tests
+         {
+             char const * label;
+             MeshSdfMethod method;
++            bool requiresVdb;
+         };
+-        std::array<MethodCase, 3> const cases = {{
+-            {"PureBVH", MeshSdfMethod::PureBVH},
+-            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated},
+-            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber},
++        std::array<MethodCase, 4> const cases = {{
++            {"PureBVH", MeshSdfMethod::PureBVH, false},
++            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated, false},
++            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber, false},
++            {"NanoVDB", MeshSdfMethod::NanoVDB, true},
+         }};
+ 
+         for (auto const & c : cases)
+         {
++            if (c.requiresVdb && !vdbSupported)
++            {
++                std::cout << "Skipping " << c.label
++                          << " mesh SDF comparison because NanoVDB is unavailable: "
++                          << core->getProgramManager().getVdbSupportFailureReason() << std::endl;
++                continue;
++            }
++
+             MeshSdfEvaluationConfig cfg{};
+             cfg.method = c.method;
+             cfg.useEarlyExit = false;
+             cfg.fwnUseSignCache = false;
+             cfg.fwnBeta = 4.0f;
++            cfg.nanovdbVoxelSize_mm = 0.1f;
+ 
+             MeshBVHBuildParams params;
+             params.maxPrimitivesPerLeaf = 4;
+@@ -378,6 +418,14 @@ namespace gladius::tests
+ 
+             primitives->clear();
+             resource.write(*primitives);
++            if (c.method == MeshSdfMethod::NanoVDB)
++            {
++                ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << c.label << ": "
++                                                              << resource.getNanoVdbBuildInfo().reason;
++                ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
++                          SpatialMeshResource::NanoVdbBuildResult::Built)
++                    << c.label;
++            }
+             primitives->write();
+ 
+             if (c.method == MeshSdfMethod::VoxelAccelerated)
+@@ -398,13 +446,250 @@ namespace gladius::tests
+             primitives->write();
+ 
+             auto const distances = sampler.evaluateSdfBatch(
+-                {Eigen::Vector3f{0.0f, 0.0f, 0.0f}, Eigen::Vector3f{15.0f, 0.0f, 0.0f}},
++                {Eigen::Vector3f{0.0f, 0.0f, 0.0f},
++                 Eigen::Vector3f{15.0f, 0.0f, 0.0f},
++                 Eigen::Vector3f{9.75f, 0.0f, 0.0f},
++                 Eigen::Vector3f{10.25f, 0.0f, 0.0f}},
+                 *primitives,
+                 0.0f);
+-            ASSERT_EQ(distances.size(), 2u) << c.label;
++            ASSERT_EQ(distances.size(), 4u) << c.label;
+             EXPECT_LT(distances[0], -5.0f) << c.label << " center distance=" << distances[0];
+             EXPECT_GT(distances[1], 2.0f) << c.label << " outside distance=" << distances[1];
++            EXPECT_LT(distances[2], -0.05f) << c.label << " near-inside distance=" << distances[2];
++            EXPECT_GT(distances[3], 0.05f) << c.label << " near-outside distance=" << distances[3];
++            EXPECT_GT(std::fabs(distances[3]), 0.10f)
++                << c.label << " near-outside magnitude should remain in millimetres, distance="
++                << distances[3];
++        }
++    }
++
++    TEST_F(MeshSdfPerformance_Test, GpuSdfEvaluation_AllMeshMethods_CubeSharpFeaturesKeepCorrectSign)
++    {
++        if (!m_context->isValid())
++        {
++            GTEST_SKIP() << "OpenCL context not available";
++        }
++
++        std::vector<float4> vertices;
++        std::vector<TriangleIndices> indices;
++        createCubeMesh(vertices, indices, 5.0f);
++
++        auto core = std::make_shared<ComputeCore>(
++            m_context, RequiredCapabilities::ComputeOnly, m_logger);
++        auto primitives = core->getPrimitives();
++        ASSERT_NE(primitives, nullptr);
++
++        bool const vdbSupported = core->getProgramManager().isVdbSupported();
++
++        gladius::compute::ManifoldDualContouringProgram sampler(
++            m_context, core->getResourceContext());
++        sampler.setLogger(m_logger);
++        sampler.setEnableVdb(vdbSupported);
++        sampler.setModelKernel(R"CLC(
++    float4 model(float3 pos, PAYLOAD_ARGS)
++    {
++        float const distance = payload(pos, 0, primitivesSize, PASS_PAYLOAD_ARGS);
++        return (float4)(0.0f, 0.0f, 0.0f, distance);
++    }
++    )CLC");
++
++        struct MethodCase
++        {
++            char const * label;
++            MeshSdfMethod method;
++            bool requiresVdb;
++        };
++        std::array<MethodCase, 4> const cases = {{
++            {"PureBVH", MeshSdfMethod::PureBVH, false},
++            {"VoxelAccelerated", MeshSdfMethod::VoxelAccelerated, false},
++            {"FastWindingNumber", MeshSdfMethod::FastWindingNumber, false},
++            {"NanoVDB", MeshSdfMethod::NanoVDB, true},
++        }};
++
++        std::vector<Eigen::Vector3f> const samplePositions = {
++            {0.0f, 0.0f, 0.0f},       // deep interior
++            {8.0f, 0.0f, 0.0f},       // far exterior
++            {4.75f, 0.0f, 0.0f},      // inside near face
++            {5.25f, 0.0f, 0.0f},      // outside near face
++            {4.75f, 4.75f, 0.0f},     // inside near sharp edge
++            {5.25f, 5.25f, 0.0f},     // outside near sharp edge
++            {4.75f, 4.75f, 4.75f},    // inside near sharp corner
++            {5.25f, 5.25f, 5.25f},    // outside near sharp corner
++        };
++
++        for (auto const & c : cases)
++        {
++            if (c.requiresVdb && !vdbSupported)
++            {
++                std::cout << "Skipping " << c.label
++                          << " cube sharp-feature comparison because NanoVDB is unavailable: "
++                          << core->getProgramManager().getVdbSupportFailureReason() << std::endl;
++                continue;
++            }
++
++            MeshSdfEvaluationConfig cfg{};
++            cfg.method = c.method;
++            cfg.useEarlyExit = false;
++            cfg.fwnUseSignCache = false;
++            cfg.fwnBeta = 4.0f;
++            cfg.nanovdbVoxelSize_mm = 0.1f;
++
++            MeshBVHBuildParams params;
++            params.maxPrimitivesPerLeaf = 4;
++            params.maxDepth = 32;
++            params.traversalCost = 1.0f;
++            params.intersectionCost = 1.0f;
++            MeshBVHBuilder builder;
++
++            ResourceKey key(ResourceId{1001}, ResourceType::Mesh);
++            SpatialMeshResource resource(key, builder.build(vertices, indices, params), cfg);
++
++            auto & settings = core->getResourceContext()->getRenderingSettings();
++            settings.meshInflationDistance = 0.0f;
++            settings.meshFwnBeta = cfg.fwnBeta;
++            settings.meshFwnFarFieldFactor = 0.0f;
++            settings.flags |= RF_DISABLE_MESH_EARLY_EXIT;
++            if (c.method == MeshSdfMethod::FastWindingNumber)
++            {
++                settings.flags |= RF_USE_MESH_FWN;
++            }
++            else
++            {
++                settings.flags &= ~RF_USE_MESH_FWN;
++            }
++
++            primitives->clear();
++            resource.write(*primitives);
++            if (c.method == MeshSdfMethod::NanoVDB)
++            {
++                ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << c.label << ": "
++                                                              << resource.getNanoVdbBuildInfo().reason;
++                ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
++                          SpatialMeshResource::NanoVdbBuildResult::Built)
++                    << c.label;
++            }
++            primitives->write();
++
++            if (c.method == MeshSdfMethod::VoxelAccelerated)
++            {
++                auto params = resource.getVoxelGridBuildParams();
++                ASSERT_TRUE(params.has_value()) << c.label;
++                ASSERT_EQ(core->buildMeshVoxelGrids({*params}), 1u) << c.label;
++            }
++            else if (c.method == MeshSdfMethod::FastWindingNumber)
++            {
++                auto params = resource.getFwnAggregateBuildParams();
++                ASSERT_TRUE(params.has_value()) << c.label;
++                ASSERT_EQ(core->buildMeshFwnAggregates({*params}), 1u) << c.label;
++            }
++
++            primitives->write();
++            auto const distances = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
++            ASSERT_EQ(distances.size(), samplePositions.size()) << c.label;
++
++            EXPECT_LT(distances[0], -4.0f) << c.label << " center distance=" << distances[0];
++            EXPECT_GT(distances[1], 2.0f) << c.label << " exterior distance=" << distances[1];
++            EXPECT_LT(distances[2], -0.05f) << c.label << " face-inside distance=" << distances[2];
++            EXPECT_GT(distances[3], 0.05f) << c.label << " face-outside distance=" << distances[3];
++            EXPECT_LT(distances[4], -0.05f) << c.label << " edge-inside distance=" << distances[4];
++            EXPECT_GT(distances[5], 0.05f) << c.label << " edge-outside distance=" << distances[5];
++            EXPECT_LT(distances[6], -0.05f) << c.label << " corner-inside distance=" << distances[6];
++            EXPECT_GT(distances[7], 0.05f) << c.label << " corner-outside distance=" << distances[7];
++        }
++    }
++
++    TEST_F(MeshSdfPerformance_Test, GpuSdfEvaluation_NanoVdbNearestSampling_ReturnsMillimetres)
++    {
++        if (!m_context->isValid())
++        {
++            GTEST_SKIP() << "OpenCL context not available";
++        }
++
++        std::vector<float4> vertices;
++        std::vector<TriangleIndices> indices;
++        createCubeMesh(vertices, indices, 5.0f);
++
++        auto core = std::make_shared<ComputeCore>(
++            m_context, RequiredCapabilities::ComputeOnly, m_logger);
++        auto primitives = core->getPrimitives();
++        ASSERT_NE(primitives, nullptr);
++
++        if (!core->getProgramManager().isVdbSupported())
++        {
++            GTEST_SKIP() << "NanoVDB is unavailable: "
++                         << core->getProgramManager().getVdbSupportFailureReason();
+         }
++
++        gladius::compute::ManifoldDualContouringProgram sampler(
++            m_context, core->getResourceContext());
++        sampler.setLogger(m_logger);
++        sampler.setEnableVdb(true);
++        sampler.setModelKernel(R"CLC(
++    float4 model(float3 pos, PAYLOAD_ARGS)
++    {
++        float const distance = payload(pos, 0, primitivesSize, PASS_PAYLOAD_ARGS);
++        return (float4)(0.0f, 0.0f, 0.0f, distance);
++    }
++    )CLC");
++
++        MeshSdfEvaluationConfig cfg{};
++        cfg.method = MeshSdfMethod::NanoVDB;
++        cfg.useEarlyExit = false;
++        cfg.nanovdbVoxelSize_mm = 0.1f;
++
++        MeshBVHBuildParams params;
++        params.maxPrimitivesPerLeaf = 4;
++        params.maxDepth = 32;
++        params.traversalCost = 1.0f;
++        params.intersectionCost = 1.0f;
++        MeshBVHBuilder builder;
++
++        ResourceKey key(ResourceId{1002}, ResourceType::Mesh);
++        SpatialMeshResource resource(key, builder.build(vertices, indices, params), cfg);
++
++        auto & settings = core->getResourceContext()->getRenderingSettings();
++        settings.meshInflationDistance = 0.0f;
++        settings.flags |= RF_DISABLE_MESH_EARLY_EXIT;
++        settings.flags &= ~RF_USE_MESH_FWN;
++
++        primitives->clear();
++        resource.write(*primitives);
++        ASSERT_FALSE(resource.hasNanoVdbBuildIssue()) << resource.getNanoVdbBuildInfo().reason;
++        ASSERT_EQ(resource.getNanoVdbBuildInfo().result,
++                  SpatialMeshResource::NanoVdbBuildResult::Built);
++        primitives->write();
++
++        std::vector<Eigen::Vector3f> const samplePositions = {
++            {0.0f, 0.0f, 0.0f},
++            {8.0f, 0.0f, 0.0f},
++            {4.75f, 0.0f, 0.0f},
++            {5.25f, 0.0f, 0.0f},
++            {5.25f, 5.25f, 0.0f},
++        };
++
++        settings.approximation = AM_FULL_MODEL;
++        auto const interpolated = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
++
++        settings.approximation = static_cast<ApproximationMode>(AM_FULL_MODEL | AM_DISABLE_INTERPOLATION);
++        auto const nearest = sampler.evaluateSdfBatch(samplePositions, *primitives, 0.0f);
++
++        ASSERT_EQ(interpolated.size(), samplePositions.size());
++        ASSERT_EQ(nearest.size(), samplePositions.size());
++
++        for (size_t i = 0u; i < samplePositions.size(); ++i)
++        {
++            EXPECT_EQ(interpolated[i] < 0.0f, nearest[i] < 0.0f)
++                << "sample " << i << " interpolated=" << interpolated[i]
++                << " nearest=" << nearest[i];
++            EXPECT_NEAR(interpolated[i], nearest[i], 0.25f)
++                << "sample " << i << " should not change units when nearest VDB sampling is used";
++        }
++
++        EXPECT_LT(nearest[0], -4.0f) << "center distance=" << nearest[0];
++        EXPECT_GT(nearest[1], 2.0f) << "exterior distance=" << nearest[1];
++        EXPECT_LT(nearest[2], -0.05f) << "face-inside distance=" << nearest[2];
++        EXPECT_GT(nearest[3], 0.05f) << "face-outside distance=" << nearest[3];
++        EXPECT_GT(nearest[4], 0.10f) << "edge-outside magnitude should remain in millimetres";
+     }
+ 
+     /// T001-T003: Baseline performance benchmark with procedural sphere
+diff --git a/gladius/tests/unittests/Importer3mfMerge_test.cpp b/gladius/tests/unittests/Importer3mfMerge_test.cpp
+index eec3ffc..44a8442 100644
+--- a/gladius/tests/unittests/Importer3mfMerge_test.cpp
++++ b/gladius/tests/unittests/Importer3mfMerge_test.cpp
+@@ -5,6 +5,7 @@
+ #include <SpatialMeshResource.h>
+ #include <compute/ComputeCore.h>
+ #include <io/3mf/Importer3mf.h>
++#include <io/VdbImporter.h>
+ 
+ #include <chrono>
+ #include <fmt/core.h>
+@@ -58,6 +59,33 @@ namespace gladius_tests
+             return tempPath;
+         }
+ 
++          [[nodiscard]] std::filesystem::path createOpenQuad3mf() const
++          {
++            auto sourceDoc = std::make_shared<Document>(m_core);
++            sourceDoc->newEmptyModel();
++
++            vdb::TriangleMesh mesh;
++            mesh.vertices = {
++              openvdb::Vec3s{0.0f, 0.0f, 0.0f},
++              openvdb::Vec3s{10.0f, 0.0f, 0.0f},
++              openvdb::Vec3s{10.0f, 10.0f, 0.0f},
++              openvdb::Vec3s{0.0f, 10.0f, 0.0f},
++            };
++            mesh.indices = {
++              openvdb::Vec3I{0, 1, 2},
++              openvdb::Vec3I{0, 2, 3},
++            };
++
++            sourceDoc->addMeshResource(std::move(mesh), "open quad");
++
++            auto const uniqueSuffix =
++              std::chrono::steady_clock::now().time_since_epoch().count();
++            auto const tempPath = std::filesystem::temp_directory_path() /
++                        fmt::format("gladius_nanovdb_open_quad_{}.3mf", uniqueSuffix);
++            sourceDoc->saveAs(tempPath, false);
++            return tempPath;
++          }
++
+         std::shared_ptr<Document> m_doc;
+         std::shared_ptr<ComputeCore> m_core;
+         events::SharedLogger m_logger;
+@@ -254,6 +282,33 @@ namespace gladius_tests
+             std::filesystem::remove(tempFile);
+         }
+ 
++        TEST_F(Importer3mfMerge_Test,
++               ImporterLoad_WithOpenNanoVdbMesh_DegradeReportsMeshQualityIssue)
++        {
++            auto const tempFile = createOpenQuad3mf();
++
++            MeshSdfEvaluationConfig meshEvaluationConfig;
++            meshEvaluationConfig.method = MeshSdfMethod::NanoVDB;
++            meshEvaluationConfig.nanovdbVoxelSize_mm = 0.1f;
++
++            io::Importer3mf importer(m_logger);
++            importer.setMeshSdfEvaluationConfig(meshEvaluationConfig);
++            importer.setNanoVdbBuildPolicy(
++              NanoVdbBuildPolicy{0u, NanoVdbFailurePolicy::Degrade});
++
++            m_doc->newEmptyModel();
++            ASSERT_NO_THROW(importer.load(tempFile, *m_doc));
++
++            auto const summary = m_doc->getMeshQualityIssueSummary();
++            EXPECT_TRUE(summary.hasIssue);
++            EXPECT_EQ(summary.affectedMeshCount, 1u);
++            EXPECT_GT(summary.boundaryEdgeCount, 0u);
++            EXPECT_NE(summary.message.find("No repair or fallback was applied silently"),
++                      std::string::npos);
++
++            std::filesystem::remove(tempFile);
++        }
++
+         TEST_F(Importer3mfMerge_Test, DocumentLoad_WithNanoVdbHugeMesh_ThrowsRejectedError)
+         {
+             auto const tempFile = createLargeBox3mf(4000.0f, 4000.0f, 4000.0f);
+@@ -268,4 +323,18 @@ namespace gladius_tests
+             std::filesystem::remove(tempFile);
+         }
+ 
++    TEST_F(Importer3mfMerge_Test, DocumentLoad_WithNanoVdbOpenMesh_ThrowsRejectedError)
++    {
++      auto const tempFile = createOpenQuad3mf();
++
++      MeshSdfEvaluationConfig meshEvaluationConfig;
++      meshEvaluationConfig.method = MeshSdfMethod::NanoVDB;
++      meshEvaluationConfig.nanovdbVoxelSize_mm = 0.1f;
++      m_doc->setMeshSdfEvaluationConfig(meshEvaluationConfig);
++
++      EXPECT_THROW(m_doc->load(tempFile), NanoVdbBuildRejectedError);
++
++      std::filesystem::remove(tempFile);
++    }
++
+ } // namespace gladius_tests
+diff --git a/gladius/tests/unittests/MeshBVH_tests.cpp b/gladius/tests/unittests/MeshBVH_tests.cpp
+index 5867d50..a6c4d3e 100644
+--- a/gladius/tests/unittests/MeshBVH_tests.cpp
++++ b/gladius/tests/unittests/MeshBVH_tests.cpp
+@@ -53,6 +53,27 @@ namespace gladius::tests
+             };
+         }
+ 
++        static void createDuplicateVertexCubeMesh(std::vector<float4> & vertices,
++                                                  std::vector<TriangleIndices> & indices)
++        {
++            std::vector<float4> sharedVertices;
++            std::vector<TriangleIndices> sharedIndices;
++            createCubeMesh(sharedVertices, sharedIndices);
++
++            vertices.clear();
++            indices.clear();
++            vertices.reserve(sharedIndices.size() * 3u);
++            indices.reserve(sharedIndices.size());
++            for (auto const & tri : sharedIndices)
++            {
++                int const base = static_cast<int>(vertices.size());
++                vertices.push_back(sharedVertices[tri.i0]);
++                vertices.push_back(sharedVertices[tri.i1]);
++                vertices.push_back(sharedVertices[tri.i2]);
++                indices.emplace_back(base, base + 1, base + 2);
++            }
++        }
++
+         // Helper to create a single triangle
+         static void createSingleTriangle(std::vector<float4> & vertices,
+                                          std::vector<TriangleIndices> & indices)
+@@ -295,6 +316,25 @@ namespace gladius::tests
+         EXPECT_EQ(stats.degenerateTriangleCount, 0);
+         EXPECT_EQ(stats.boundaryEdgeCount, 0);
+         EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
++        EXPECT_FALSE(result.quality.hasIssues());
++    }
++
++    /// Exact duplicate vertex records are common in STL-style triangle soups. They should be
++    /// certified by exact position adjacency without silently modifying the source mesh.
++    TEST_F(MeshBVHBuilder_Test, Build_DuplicateVertexWatertightCube_ReportsCleanStats)
++    {
++        std::vector<float4> vertices;
++        std::vector<TriangleIndices> indices;
++        createDuplicateVertexCubeMesh(vertices, indices);
++
++        auto result = builder.build(vertices, indices);
++        ASSERT_FALSE(result.empty());
++
++        auto const & stats = builder.getLastBuildStats();
++        EXPECT_EQ(stats.degenerateTriangleCount, 0);
++        EXPECT_EQ(stats.boundaryEdgeCount, 0);
++        EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
++        EXPECT_FALSE(result.quality.hasIssues());
+     }
+ 
+     /// A degenerate (zero-area) triangle should be counted but must not abort the build.
+@@ -318,6 +358,8 @@ namespace gladius::tests
+ 
+         auto const & stats = builder.getLastBuildStats();
+         EXPECT_EQ(stats.degenerateTriangleCount, 1);
++        EXPECT_EQ(result.quality.degenerateTriangleCount, 1);
++        EXPECT_TRUE(result.quality.hasIssues());
+     }
+ 
+     /// Two triangles sharing a single edge: 5 boundary edges, 1 manifold edge.
+@@ -341,6 +383,9 @@ namespace gladius::tests
+         auto const & stats = builder.getLastBuildStats();
+         EXPECT_EQ(stats.boundaryEdgeCount, 4);   // four outer edges
+         EXPECT_EQ(stats.nonManifoldEdgeCount, 0);
++        EXPECT_EQ(result.quality.boundaryEdgeCount, 4);
++        EXPECT_EQ(result.quality.nonManifoldEdgeCount, 0);
++        EXPECT_TRUE(result.quality.hasIssues());
+     }
+ 
+     /// Three coplanar triangles sharing one edge → non-manifold edge.
+@@ -373,6 +418,8 @@ namespace gladius::tests
+         auto const & stats = builder.getLastBuildStats();
+         EXPECT_EQ(stats.nonManifoldEdgeCount, 1)
+             << "Edge (0,1) is shared by three faces and must be flagged non-manifold";
++        EXPECT_EQ(result.quality.nonManifoldEdgeCount, 1);
++        EXPECT_TRUE(result.quality.hasIssues());
+ 
+         // Verify that the edge entry on the perpendicular fin (tri 2) was NOT
+         // assigned a neighbour — only the two coplanar triangles should be
+diff --git a/gladius/tests/unittests/SpatialMeshResource_tests.cpp b/gladius/tests/unittests/SpatialMeshResource_tests.cpp
+index 3898ab0..2c5ed22 100644
+--- a/gladius/tests/unittests/SpatialMeshResource_tests.cpp
++++ b/gladius/tests/unittests/SpatialMeshResource_tests.cpp
+@@ -158,6 +158,34 @@ namespace gladius::tests
+         EXPECT_EQ(resource.getTriangleCount(), 1u);
+     }
+ 
++    TEST_F(SpatialMeshResource_Test, MeshQualityDiagnostics_OpenMesh_ExposesRecoveryMessage)
++    {
++        std::vector<float4> vertices = {
++            {0.f, 0.f, 0.f, 0.f},
++            {1.f, 0.f, 0.f, 0.f},
++            {1.f, 1.f, 0.f, 0.f},
++            {0.f, 1.f, 0.f, 0.f},
++        };
++        std::vector<TriangleIndices> indices = {
++            {0, 1, 2},
++            {0, 2, 3},
++        };
++
++        ResourceKey key(ResourceId{4}, ResourceType::Mesh);
++        SpatialMeshResource resource(key, vertices, indices);
++
++        auto const & diagnostics = resource.getMeshQualityDiagnostics();
++        EXPECT_TRUE(resource.hasMeshQualityIssues());
++        EXPECT_EQ(diagnostics.boundaryEdgeCount, 4);
++        EXPECT_EQ(diagnostics.nonManifoldEdgeCount, 0);
++
++        auto const message = resource.formatMeshQualityMessage("open quad");
++        EXPECT_NE(message.find("open quad"), std::string::npos);
++        EXPECT_NE(message.find("4 boundary edges"), std::string::npos);
++        EXPECT_NE(message.find("No repair or fallback was applied silently"), std::string::npos);
++        EXPECT_NE(message.find("Fast Winding Number"), std::string::npos);
++    }
++
+     // ========================================================================
+     // Unsigned Distance Validation Tests (T043)
+     // ========================================================================
+diff --git a/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp b/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp
+new file mode 100644
+index 0000000..c1cdee9
+--- /dev/null
++++ b/gladius/tests/unittests/ui/RealtimeRaymarchController_tests.cpp
+@@ -0,0 +1,212 @@
++#include "ui/render/RealtimeRaymarchController.h"
++
++#include <gtest/gtest.h>
++
++namespace gladius::ui::async_rendering::tests
++{
++    namespace
++    {
++        [[nodiscard]] RealtimeRaymarchConfig makeTestConfig()
++        {
++            RealtimeRaymarchConfig config{};
++            config.targetFrameTimeMs = 25.0f;
++            config.requiredFastSamples = 3;
++            config.maxSlowSamples = 2;
++            config.cooldownFrames = 4;
++            config.ewmaAlpha = 1.0f;
++            return config;
++        }
++
++        [[nodiscard]] RealtimeRaymarchSample makeFullFrameSample(float durationMs)
++        {
++            return RealtimeRaymarchSample{.durationMs = durationMs,
++                                          .width = 800,
++                                          .height = 600,
++                                          .renderedLines = 600,
++                                          .totalLines = 600,
++                                          .completedFrame = true,
++                                          .cancelled = false};
++        }
++
++        [[nodiscard]] RealtimeRaymarchSample makeProgressiveChunkSample(float durationMs)
++        {
++            return RealtimeRaymarchSample{.durationMs = durationMs,
++                                          .width = 800,
++                                          .height = 600,
++                                          .renderedLines = 60,
++                                          .totalLines = 600,
++                                          .completedFrame = false,
++                                          .cancelled = false};
++        }
++
++        [[nodiscard]] RealtimeRaymarchGuards makeOpenGuards()
++        {
++            return RealtimeRaymarchGuards{};
++        }
++    }
++
++    TEST(RealtimeRaymarchController, RecordFastSamples_EnablesRealtime)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(19.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(20.0f));
++
++        EXPECT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
++        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 20.0f);
++    }
++
++    TEST(RealtimeRaymarchController, InteractiveSlowSample_DeactivatesRealtime)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        ASSERT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++
++        controller.recordInteractiveRealtimeSample(makeFullFrameSample(65.0f));
++
++        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++    }
++
++    TEST(RealtimeRaymarchController, BeginFrame_CountsDownCooldown)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordRejectedAttempt();
++        controller.recordRejectedAttempt();
++        ASSERT_TRUE(controller.isCoolingDown());
++
++        controller.beginFrame();
++        controller.beginFrame();
++        controller.beginFrame();
++        EXPECT_TRUE(controller.isCoolingDown());
++
++        controller.beginFrame();
++        EXPECT_FALSE(controller.isCoolingDown());
++    }
++
++    TEST(RealtimeRaymarchController, RecordChunkSample_EstimatesFullFrameTime)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        RealtimeRaymarchSample sample{};
++        sample.durationMs = 2.0f;
++        sample.width = 800;
++        sample.height = 600;
++        sample.renderedLines = 60;
++        sample.totalLines = 600;
++        sample.completedFrame = false;
++
++        controller.recordStaticProgressiveSample(sample);
++
++        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
++        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 20.0f);
++        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++    }
++
++    TEST(RealtimeRaymarchController, AutoLearning_CanAttemptStaticFullFrameAfterFastProgressiveSample)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++        controller.resetForResolution(800, 600);
++
++        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++
++        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
++
++        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++
++        auto blockedGuards = makeOpenGuards();
++        blockedGuards.renderJobInFlight = true;
++        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, blockedGuards));
++    }
++
++    TEST(RealtimeRaymarchController, SlowProgressiveSample_DoesNotEnableStaticFullFrame)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(10.0f));
++
++        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
++        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 100.0f);
++        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++    }
++
++    TEST(RealtimeRaymarchController, SlowProgressiveSample_ClearsStaticFullFramePreference)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
++        ASSERT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++
++        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(10.0f));
++
++        EXPECT_FALSE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++    }
++
++    TEST(RealtimeRaymarchController, StaticFullFrameBetweenRealtimeAndStaticBudgets_DoesNotActivateRealtime)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticProgressiveSample(makeProgressiveChunkSample(2.0f));
++        ASSERT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++
++        controller.recordStaticFullFrameSample(makeFullFrameSample(40.0f));
++
++        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++        EXPECT_TRUE(controller.canAttemptStaticFullFrame(800, 600, makeOpenGuards()));
++    }
++
++    TEST(RealtimeRaymarchController, ForceMode_IgnoresLearningButNotGuards)
++    {
++        RealtimeRaymarchController controller;
++        auto config = makeTestConfig();
++        config.mode = RealtimeRaymarchMode::Force;
++        controller.configure(config);
++        controller.resetForResolution(800, 600);
++
++        EXPECT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++
++        auto blockedGuards = makeOpenGuards();
++        blockedGuards.renderJobInFlight = true;
++        EXPECT_FALSE(controller.canAttemptRealtime(800, 600, blockedGuards));
++    }
++
++    TEST(RealtimeRaymarchController, ResolutionChange_ScalesConfidence)
++    {
++        RealtimeRaymarchController controller;
++        controller.configure(makeTestConfig());
++
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        controller.recordStaticFullFrameSample(makeFullFrameSample(18.0f));
++        ASSERT_TRUE(controller.canAttemptRealtime(800, 600, makeOpenGuards()));
++
++        controller.resetForResolution(400, 300);
++
++        EXPECT_TRUE(controller.canAttemptRealtime(400, 300, makeOpenGuards()));
++        ASSERT_TRUE(controller.estimatedFullFrameTimeMs().has_value());
++        EXPECT_FLOAT_EQ(*controller.estimatedFullFrameTimeMs(), 4.5f);
++    }
++
++    TEST(RealtimeRaymarchModeFromString, WithKnownValues_ParsesModes)
++    {
++        EXPECT_EQ(realtimeRaymarchModeFromString("off"), RealtimeRaymarchMode::Off);
++        EXPECT_EQ(realtimeRaymarchModeFromString("force"), RealtimeRaymarchMode::Force);
++        EXPECT_EQ(realtimeRaymarchModeFromString("auto"), RealtimeRaymarchMode::Auto);
++        EXPECT_EQ(realtimeRaymarchModeFromString("unknown"), RealtimeRaymarchMode::Auto);
++    }
++}
+diff --git a/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp b/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp
+new file mode 100644
+index 0000000..dd2090a
+--- /dev/null
++++ b/gladius/tests/unittests/ui/render/AsyncRenderControllerPresentation_tests.cpp
+@@ -0,0 +1,112 @@
++#include "ui/render/AsyncRenderController.h"
++
++#include <gtest/gtest.h>
++
++namespace gladius::ui::async_rendering::tests
++{
++    TEST(AsyncRenderControllerPresentation, PublishedFrame_CanBePromotedToFront)
++    {
++        AsyncRenderController controller;
++
++        auto * buffer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(buffer, nullptr);
++
++        controller.publishFrame(buffer, 2, 10, 3);
++        auto * promoted = controller.promoteReadyToFront();
++        ASSERT_EQ(promoted, buffer);
++
++        EXPECT_TRUE(controller.finalizeFrontPromotion(promoted));
++        EXPECT_EQ(controller.frontBuffer(), buffer);
++        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Front);
++        EXPECT_EQ(buffer->epoch.load(std::memory_order_acquire), 10u);
++        EXPECT_EQ(buffer->viewEpoch.load(std::memory_order_acquire), 3u);
++    }
++
++    TEST(AsyncRenderControllerPresentation,
++         FinalizeFrontPromotion_WithExistingFront_DemotesPreviousFrontForReuse)
++    {
++        AsyncRenderController controller;
++
++        auto * initialFront = controller.frontBuffer();
++        ASSERT_NE(initialFront, nullptr);
++        ASSERT_TRUE(controller.tryTransitionBuffer(initialFront, FrameState::Idle, FrameState::Front));
++
++        auto * buffer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(buffer, nullptr);
++        ASSERT_NE(buffer, initialFront);
++
++        controller.publishFrame(buffer, 2, 10, 3);
++        auto * promoted = controller.promoteReadyToFront();
++        ASSERT_EQ(promoted, buffer);
++        ASSERT_TRUE(controller.finalizeFrontPromotion(promoted));
++
++        EXPECT_EQ(controller.frontBuffer(), buffer);
++        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Front);
++        EXPECT_EQ(initialFront->state.load(std::memory_order_acquire), FrameState::Idle);
++
++        auto * reacquired = controller.acquireWriteBuffer(11);
++        EXPECT_EQ(reacquired, initialFront);
++    }
++
++    TEST(AsyncRenderControllerPresentation, PromoteReadyToFront_SelectsNewestFrame)
++    {
++        AsyncRenderController controller;
++
++        auto * older = controller.acquireWriteBuffer(10);
++        auto * newer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(older, nullptr);
++        ASSERT_NE(newer, nullptr);
++        ASSERT_NE(older, newer);
++
++        controller.publishFrame(older, 5, 10, 3);
++        controller.publishFrame(newer, 6, 10, 3);
++
++        auto * promoted = controller.promoteReadyToFront();
++
++        EXPECT_EQ(promoted, newer);
++        EXPECT_EQ(newer->state.load(std::memory_order_acquire), FrameState::Resampling);
++        EXPECT_EQ(older->state.load(std::memory_order_acquire), FrameState::Ready);
++    }
++
++    TEST(AsyncRenderControllerPresentation, DiscardReadyFrame_WithMatchingMetadata_ReleasesBuffer)
++    {
++        AsyncRenderController controller;
++
++        auto * buffer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(buffer, nullptr);
++        controller.publishFrame(buffer, 2, 10, 3);
++
++        controller.discardReadyFrame(2, 10, 3);
++
++        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Idle);
++        auto * reacquired = controller.acquireWriteBuffer(11);
++        EXPECT_EQ(reacquired, buffer);
++    }
++
++    TEST(AsyncRenderControllerPresentation, ReleaseStaleBuffers_WithWritingBuffer_ReleasesIt)
++    {
++        AsyncRenderController controller;
++
++        auto * buffer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(buffer, nullptr);
++
++        controller.releaseStaleBuffers(10);
++
++        EXPECT_EQ(buffer->state.load(std::memory_order_acquire), FrameState::Idle);
++        auto * reacquired = controller.acquireWriteBuffer(11);
++        EXPECT_EQ(reacquired, buffer);
++    }
++
++    TEST(AsyncRenderControllerPresentation, TryTransitionBuffer_WithWritingBuffer_KeepsMirrorReusable)
++    {
++        AsyncRenderController controller;
++
++        auto * buffer = controller.acquireWriteBuffer(10);
++        ASSERT_NE(buffer, nullptr);
++
++        EXPECT_TRUE(controller.tryTransitionBuffer(buffer, FrameState::Writing, FrameState::Idle));
++
++        auto * reacquired = controller.acquireWriteBuffer(11);
++        EXPECT_EQ(reacquired, buffer);
++    }
++}
+diff --git a/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp b/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp
+new file mode 100644
+index 0000000..87ecdb8
+--- /dev/null
++++ b/gladius/tests/unittests/ui/render/FramePresentationController_tests.cpp
+@@ -0,0 +1,243 @@
++#include "ui/render/FramePresentationController.h"
++
++#include <gtest/gtest.h>
++
++namespace gladius::ui::async_rendering::tests
++{
++    namespace
++    {
++        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
++                                                      uint64_t parameters,
++                                                      uint64_t view,
++                                                      uint64_t viewport,
++                                                      uint64_t quality) noexcept
++        {
++            return RenderStamp{.sceneEpoch = scene,
++                               .parameterEpoch = parameters,
++                               .viewEpoch = view,
++                               .viewportEpoch = viewport,
++                               .qualityEpoch = quality};
++        }
++    }
++
++    TEST(FramePresentationController, AfterReset_HasFrontBufferAndIdleBackBuffers)
++    {
++        FramePresentationController controller{3};
++
++        ASSERT_TRUE(controller.frontBufferId().has_value());
++        EXPECT_EQ(*controller.frontBufferId(), 0u);
++        ASSERT_NE(controller.buffer(0), nullptr);
++        ASSERT_NE(controller.buffer(1), nullptr);
++        ASSERT_NE(controller.buffer(2), nullptr);
++        EXPECT_EQ(controller.buffer(0)->state, FrameState::Front);
++        EXPECT_EQ(controller.buffer(1)->state, FrameState::Idle);
++        EXPECT_EQ(controller.buffer(2)->state, FrameState::Idle);
++    }
++
++    TEST(FramePresentationController, AcquireWriteBuffer_WithIdleBuffer_MarksBufferWriting)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++
++        auto const bufferId = controller.acquireWriteBuffer(stamp);
++
++        ASSERT_TRUE(bufferId.has_value());
++        ASSERT_NE(controller.buffer(*bufferId), nullptr);
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
++        EXPECT_TRUE(matches(controller.buffer(*bufferId)->stamp, stamp));
++    }
++
++    TEST(FramePresentationController, PublishFrame_WithWritingBuffer_MarksBufferReady)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(stamp);
++        ASSERT_TRUE(bufferId.has_value());
++
++        EXPECT_TRUE(controller.publishFrame(*bufferId, 17, stamp));
++
++        ASSERT_NE(controller.buffer(*bufferId), nullptr);
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Ready);
++        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 17u);
++    }
++
++    TEST(FramePresentationController, AcquireWriteBuffer_WithNoIdleBuffer_ReturnsNullopt)
++    {
++        FramePresentationController controller{2};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++
++        auto const firstWrite = controller.acquireWriteBuffer(stamp);
++        auto const secondWrite = controller.acquireWriteBuffer(stamp);
++
++        ASSERT_TRUE(firstWrite.has_value());
++        EXPECT_FALSE(secondWrite.has_value());
++    }
++
++    TEST(FramePresentationController, PublishFrame_WithNonWritingBuffer_ReturnsFalse)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++
++        EXPECT_FALSE(controller.publishFrame(*controller.frontBufferId(), 17, stamp));
++        EXPECT_EQ(controller.buffer(*controller.frontBufferId())->state, FrameState::Front);
++    }
++
++    TEST(FramePresentationController, TryTransitionBuffer_WithExpectedState_ReleasesWritingBuffer)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(stamp);
++        ASSERT_TRUE(bufferId.has_value());
++
++        EXPECT_TRUE(controller.tryTransitionBuffer(*bufferId, FrameState::Writing, FrameState::Idle));
++
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Idle);
++        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 0u);
++    }
++
++    TEST(FramePresentationController, TryTransitionBuffer_WithWrongExpectedState_ReturnsFalse)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(stamp);
++        ASSERT_TRUE(bufferId.has_value());
++
++        EXPECT_FALSE(controller.tryTransitionBuffer(*bufferId, FrameState::Ready, FrameState::Idle));
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
++    }
++
++    TEST(FramePresentationController, SelectNewestReady_WithMultipleReadyBuffers_SelectsHighestFrameId)
++    {
++        FramePresentationController controller{4};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const olderReady = controller.acquireWriteBuffer(latest);
++        auto const newerReady = controller.acquireWriteBuffer(latest);
++        ASSERT_TRUE(olderReady.has_value());
++        ASSERT_TRUE(newerReady.has_value());
++        ASSERT_TRUE(controller.publishFrame(*olderReady, 10, latest));
++        ASSERT_TRUE(controller.publishFrame(*newerReady, 11, latest));
++
++        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
++
++        ASSERT_TRUE(selected.has_value());
++        EXPECT_EQ(*selected, *newerReady);
++        EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Resampling);
++        EXPECT_EQ(controller.buffer(*olderReady)->state, FrameState::Ready);
++    }
++
++    TEST(FramePresentationController, SelectNewestReady_WithoutFreshnessMask_SelectsNewestRegardlessOfStamp)
++    {
++        FramePresentationController controller{4};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const oldView = makeStamp(1, 2, 2, 4, 5);
++        auto const currentReady = controller.acquireWriteBuffer(latest);
++        auto const staleButNewerReady = controller.acquireWriteBuffer(oldView);
++        ASSERT_TRUE(currentReady.has_value());
++        ASSERT_TRUE(staleButNewerReady.has_value());
++        ASSERT_TRUE(controller.publishFrame(*currentReady, 10, latest));
++        ASSERT_TRUE(controller.publishFrame(*staleButNewerReady, 11, oldView));
++
++        auto const selected = controller.selectNewestReady();
++
++        ASSERT_TRUE(selected.has_value());
++        EXPECT_EQ(*selected, *staleButNewerReady);
++    }
++
++    TEST(FramePresentationController, SelectNewestReady_WithStaleReadyBuffer_IgnoresStaleFrame)
++    {
++        FramePresentationController controller{3};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const oldCamera = makeStamp(1, 2, 2, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(oldCamera);
++        ASSERT_TRUE(bufferId.has_value());
++        ASSERT_TRUE(controller.publishFrame(*bufferId, 99, oldCamera));
++
++        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
++
++        EXPECT_FALSE(selected.has_value());
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Ready);
++    }
++
++    TEST(FramePresentationController, FinalizeFrontPromotion_WithSelectedBuffer_DemotesPreviousFront)
++    {
++        FramePresentationController controller{3};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(latest);
++        ASSERT_TRUE(bufferId.has_value());
++        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
++        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
++        ASSERT_TRUE(selected.has_value());
++
++        EXPECT_TRUE(controller.finalizeFrontPromotion(*selected));
++
++        ASSERT_TRUE(controller.frontBufferId().has_value());
++        EXPECT_EQ(*controller.frontBufferId(), *selected);
++        EXPECT_EQ(controller.buffer(*selected)->state, FrameState::Front);
++        EXPECT_EQ(controller.buffer(0)->state, *selected == 0u ? FrameState::Front : FrameState::Idle);
++    }
++
++    TEST(FramePresentationController, FinalizeFrontPromotion_WithWrongState_ReturnsFalseAndKeepsFront)
++    {
++        FramePresentationController controller{3};
++        auto const stamp = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(stamp);
++        ASSERT_TRUE(bufferId.has_value());
++        auto const originalFront = controller.frontBufferId();
++
++        EXPECT_FALSE(controller.finalizeFrontPromotion(*bufferId));
++
++        EXPECT_EQ(controller.frontBufferId(), originalFront);
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Writing);
++    }
++
++    TEST(FramePresentationController, FinalizeFrontPromotion_AfterPromotion_AllowsOldFrontReuse)
++    {
++        FramePresentationController controller{3};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(latest);
++        ASSERT_TRUE(bufferId.has_value());
++        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
++        auto const selected = controller.selectNewestReady(latest, RenderStampMask::displayFrame());
++        ASSERT_TRUE(selected.has_value());
++        ASSERT_TRUE(controller.finalizeFrontPromotion(*selected));
++
++        auto const nextWrite = controller.acquireWriteBuffer(latest);
++
++        ASSERT_TRUE(nextWrite.has_value());
++        EXPECT_EQ(*nextWrite, 0u);
++        EXPECT_EQ(controller.buffer(*nextWrite)->state, FrameState::Writing);
++    }
++
++    TEST(FramePresentationController, DiscardReadyFrame_WithReadyBuffer_ReleasesItToIdle)
++    {
++        FramePresentationController controller{3};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const bufferId = controller.acquireWriteBuffer(latest);
++        ASSERT_TRUE(bufferId.has_value());
++        ASSERT_TRUE(controller.publishFrame(*bufferId, 12, latest));
++
++        EXPECT_TRUE(controller.discardReadyFrame(*bufferId));
++
++        EXPECT_EQ(controller.buffer(*bufferId)->state, FrameState::Idle);
++        EXPECT_EQ(controller.buffer(*bufferId)->frameId, 0u);
++    }
++
++    TEST(FramePresentationController, ReleaseStaleWritingBuffers_WithDifferentMasks_ReleasesRelevantStaleWork)
++    {
++        FramePresentationController controller{4};
++        auto const latest = makeStamp(1, 2, 3, 4, 5);
++        auto const oldView = makeStamp(1, 2, 2, 4, 5);
++        auto const oldScene = makeStamp(0, 2, 3, 4, 5);
++        auto const oldViewBuffer = controller.acquireWriteBuffer(oldView);
++        auto const oldSceneBuffer = controller.acquireWriteBuffer(oldScene);
++        ASSERT_TRUE(oldViewBuffer.has_value());
++        ASSERT_TRUE(oldSceneBuffer.has_value());
++
++        EXPECT_EQ(controller.releaseStaleWritingBuffers(latest, RenderStampMask::heavyGeometryTask()), 1u);
++        EXPECT_EQ(controller.buffer(*oldViewBuffer)->state, FrameState::Writing);
++        EXPECT_EQ(controller.buffer(*oldSceneBuffer)->state, FrameState::Idle);
++
++        EXPECT_EQ(controller.releaseStaleWritingBuffers(latest, RenderStampMask::displayFrame()), 1u);
++        EXPECT_EQ(controller.buffer(*oldViewBuffer)->state, FrameState::Idle);
++    }
++}
+diff --git a/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp b/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp
+new file mode 100644
+index 0000000..482d33e
+--- /dev/null
++++ b/gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp
+@@ -0,0 +1,577 @@
++#include "ui/render/RenderUpdateCoordinator.h"
++
++#include <gtest/gtest.h>
++
++#include <optional>
++
++namespace gladius::ui::async_rendering::tests
++{
++    namespace
++    {
++        [[nodiscard]] std::optional<RenderTaskRequest> findStartedTask(RenderUpdateDecision const & decision,
++                                                                       RenderTaskType type)
++        {
++            for (auto const & command : decision.commands)
++            {
++                if (command.type == RenderCommandType::StartTask && command.task.type == type)
++                {
++                    return command.task;
++                }
++            }
++            return std::nullopt;
++        }
++
++        [[nodiscard]] bool hasCommand(RenderUpdateDecision const & decision, RenderCommandType type)
++        {
++            for (auto const & command : decision.commands)
++            {
++                if (command.type == type)
++                {
++                    return true;
++                }
++            }
++            return false;
++        }
++
++        [[nodiscard]] bool hasStartedTask(RenderUpdateDecision const & decision, RenderTaskType type)
++        {
++            return findStartedTask(decision, type).has_value();
++        }
++
++        [[nodiscard]] RenderTaskResult completed(RenderTaskRequest const & request,
++                                                 bool producedDisplayFrame = false,
++                                                 bool completedFrame = false)
++        {
++            return RenderTaskResult{.requestId = request.requestId,
++                                    .type = request.type,
++                                    .stamp = request.stamp,
++                                    .status = RenderTaskStatus::Completed,
++                                    .durationNs = 200'000'000,
++                                    .producedDisplayFrame = producedDisplayFrame,
++                                    .completedFrame = completedFrame};
++        }
++
++        [[nodiscard]] RenderTaskResult failed(RenderTaskRequest const & request)
++        {
++            auto result = completed(request);
++            result.status = RenderTaskStatus::Failed;
++            return result;
++        }
++
++        [[nodiscard]] RealtimeRaymarchConfig forcedRealtimeConfig()
++        {
++            RealtimeRaymarchConfig config{};
++            config.mode = RealtimeRaymarchMode::Force;
++            return config;
++        }
++
++        [[nodiscard]] RealtimeRaymarchSample fullFrameSample(float durationMs)
++        {
++            return RealtimeRaymarchSample{.durationMs = durationMs,
++                                          .width = 640,
++                                          .height = 480,
++                                          .renderedLines = 480,
++                                          .totalLines = 480,
++                                          .completedFrame = true,
++                                          .cancelled = false};
++        }
++
++        /// Drives the coordinator through the static pipeline until a ProgressiveHighQualityChunk
++        /// completes with a duration under the 100ms Auto-mode threshold.
++        /// Call immediately after configureViewport(), passing its returned decision.
++        void primeAutoRealtimeAdmission(RenderUpdateCoordinator & coordinator,
++                                        RenderUpdateDecision const & viewportDecision)
++        {
++            auto bbox = findStartedTask(viewportDecision, RenderTaskType::BoundingBoxUpdate);
++            ASSERT_TRUE(bbox.has_value());
++            auto decision = coordinator.completeTask(completed(*bbox));
++            auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++            ASSERT_TRUE(sdf.has_value());
++            decision = coordinator.completeTask(completed(*sdf));
++            auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++            ASSERT_TRUE(hq.has_value());
++            auto hqResult = completed(*hq, true, true);
++            hqResult.durationNs = 50'000'000; // 50ms < 100ms → autoModeAdmitsRealtime() = true
++            coordinator.completeTask(hqResult);
++        }
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoLearning_StartsLowResolutionPreview)
++    {
++        RenderUpdateCoordinator coordinator;
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++        auto const before = coordinator.latestStamp();
++
++        auto const decision = coordinator.notifyCameraChanged();
++        auto const after = coordinator.latestStamp();
++
++        EXPECT_EQ(after.sceneEpoch, before.sceneEpoch);
++        EXPECT_EQ(after.parameterEpoch, before.parameterEpoch);
++        EXPECT_EQ(after.viewportEpoch, before.viewportEpoch);
++        EXPECT_EQ(after.viewEpoch, before.viewEpoch + 1u);
++        EXPECT_EQ(coordinator.interactionState(), RenderInteractionState::CameraInteracting);
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoPreviewInFlight_KeepsCurrentFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto decision = coordinator.notifyCameraChanged();
++        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++
++        decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, StaticCatchUp_AfterFastProgressiveSample_StartsStaticFullFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.configureViewport(640, 480);
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++
++        decision = coordinator.completeTask(completed(*bbox));
++        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++        ASSERT_TRUE(sdf.has_value());
++
++        decision = coordinator.completeTask(completed(*sdf));
++        auto progressive = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++        ASSERT_TRUE(progressive.has_value());
++
++        coordinator.recordStaticProgressiveSample(fullFrameSample(40.0f));
++
++        decision = coordinator.completeTask(completed(*progressive));
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtime_StartsRealtimeFullFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto const decision = coordinator.notifyCameraChanged();
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeInFlight_KeepsCurrentFrameWithoutPreview)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto decision = coordinator.notifyCameraChanged();
++        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++
++        decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeAfterFastSamples_StartsRealtimeFullFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const viewportDecision = coordinator.configureViewport(640, 480);
++        ASSERT_FALSE(viewportDecision.commands.empty());
++        primeAutoRealtimeAdmission(coordinator, viewportDecision);
++
++        auto const decision = coordinator.notifyCameraChanged();
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeInFlight_KeepsCurrentFrameWithoutPreview)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const viewportDecision = coordinator.configureViewport(640, 480);
++        ASSERT_FALSE(viewportDecision.commands.empty());
++        primeAutoRealtimeAdmission(coordinator, viewportDecision);
++
++        auto decision = coordinator.notifyCameraChanged();
++        ASSERT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++
++        decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithAutoRealtimeGuardBlocker_KeepsCurrentFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const viewportDecision = coordinator.configureViewport(640, 480);
++        ASSERT_FALSE(viewportDecision.commands.empty());
++        primeAutoRealtimeAdmission(coordinator, viewportDecision);
++        async_rendering::RealtimeRaymarchGuards guards{};
++        guards.hardBlocker = true;
++        coordinator.setRealtimeGuards(guards);
++
++        auto const decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithAutoRealtimeCurrentHq_KeepsCurrentFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const viewportDecision = coordinator.configureViewport(640, 480);
++        ASSERT_FALSE(viewportDecision.commands.empty());
++        primeAutoRealtimeAdmission(coordinator, viewportDecision);
++
++        auto decision = coordinator.notifyCameraChanged();
++        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
++        ASSERT_TRUE(realtime.has_value());
++
++        decision = coordinator.completeTask(completed(*realtime, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
++
++        decision = coordinator.notifyCameraInteractionEnded();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithStaleAutoRealtime_StartsHqNotPreview)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const viewportDecision = coordinator.configureViewport(640, 480);
++        ASSERT_FALSE(viewportDecision.commands.empty());
++        primeAutoRealtimeAdmission(coordinator, viewportDecision);
++
++        auto decision = coordinator.notifyCameraChanged();
++        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
++        ASSERT_TRUE(realtime.has_value());
++
++        decision = coordinator.notifyCameraChanged();
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++
++        decision = coordinator.completeTask(completed(*realtime, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++
++        decision = coordinator.notifyCameraInteractionEnded();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeAndCurrentHq_EndsInteractionWithoutExtraHq)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto decision = coordinator.notifyCameraChanged();
++        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
++        ASSERT_TRUE(realtime.has_value());
++
++        decision = coordinator.completeTask(completed(*realtime, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
++
++        decision = coordinator.notifyCameraInteractionEnded();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithForcedRealtimeGuardBlocker_KeepsCurrentFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        async_rendering::RealtimeRaymarchGuards guards{};
++        guards.hardBlocker = true;
++        coordinator.setRealtimeGuards(guards);
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto const decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraChanged_WithResizePendingEvenForcedRealtime_KeepsCurrentFrame)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        async_rendering::RealtimeRaymarchGuards guards{};
++        guards.resizePending = true;
++        coordinator.setRealtimeGuards(guards);
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto const decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, FailedForcedRealtime_DoesNotFallbackToPreviewWhileGuarded)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto decision = coordinator.notifyCameraChanged();
++        auto realtime = findStartedTask(decision, RenderTaskType::RealtimeFullFrame);
++        ASSERT_TRUE(realtime.has_value());
++
++        decision = coordinator.completeTask(failed(*realtime));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++
++        async_rendering::RealtimeRaymarchGuards guards{};
++        guards.hardBlocker = true;
++        coordinator.setRealtimeGuards(guards);
++        decision = coordinator.tick();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, ParameterDrag_WithForcedRealtime_UsesPreviewNotRealtime)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.configureRealtime(forcedRealtimeConfig());
++        ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
++
++        auto const decision = coordinator.notifyParameterChanged(true);
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, ParameterDrag_StartsUploadAndPreviewButDefersHeavyTasks)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto const before = coordinator.latestStamp();
++
++        auto const decision = coordinator.notifyParameterChanged(true);
++        auto const after = coordinator.latestStamp();
++
++        EXPECT_EQ(after.sceneEpoch, before.sceneEpoch);
++        EXPECT_EQ(after.parameterEpoch, before.parameterEpoch + 1u);
++        EXPECT_EQ(coordinator.interactionState(), RenderInteractionState::ParameterInteracting);
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
++    }
++
++    TEST(RenderUpdateCoordinator, ParameterDrag_WithUploadInFlight_CoalescesToLatestUpload)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.notifyParameterChanged(true);
++        auto firstUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
++        ASSERT_TRUE(firstUpload.has_value());
++
++        decision = coordinator.notifyParameterChanged(true);
++        auto const latest = coordinator.latestStamp();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++
++        decision = coordinator.completeTask(completed(*firstUpload));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++
++        decision = coordinator.tick();
++        auto latestUpload = findStartedTask(decision, RenderTaskType::ParameterUpload);
++        ASSERT_TRUE(latestUpload.has_value());
++        EXPECT_TRUE(matches(latestUpload->stamp, latest, RenderStampMask::heavyGeometryTask()));
++    }
++
++    TEST(RenderUpdateCoordinator, ParameterChanged_AfterRealtimeLearning_ResetsToProgressiveStaticLearning)
++    {
++        RenderUpdateCoordinator coordinator;
++        coordinator.recordStaticFullFrameSample(fullFrameSample(15.0f));
++        coordinator.recordStaticFullFrameSample(fullFrameSample(16.0f));
++        coordinator.recordStaticFullFrameSample(fullFrameSample(17.0f));
++        ASSERT_TRUE(coordinator.isRealtimeActive());
++
++        auto decision = coordinator.notifyParameterChanged(false);
++        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
++        ASSERT_TRUE(upload.has_value());
++        EXPECT_FALSE(coordinator.isRealtimeActive());
++
++        decision = coordinator.completeTask(completed(*upload));
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++
++        decision = coordinator.completeTask(completed(*bbox));
++        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++        ASSERT_TRUE(sdf.has_value());
++
++        decision = coordinator.completeTask(completed(*sdf));
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, StaticCatchUp_AfterParameterEdit_SequencesUploadBboxSdfThenHq)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.notifyParameterChanged(true);
++        auto upload = findStartedTask(decision, RenderTaskType::ParameterUpload);
++        ASSERT_TRUE(upload.has_value());
++
++        decision = coordinator.completeTask(completed(*upload));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
++
++        decision = coordinator.notifyParameterInteractionEnded();
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++
++        decision = coordinator.completeTask(completed(*bbox));
++        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++        ASSERT_TRUE(sdf.has_value());
++        EXPECT_TRUE(coordinator.isBoundingBoxCurrent());
++        EXPECT_FALSE(coordinator.isHeavyGeometryCurrent());
++
++        decision = coordinator.completeTask(completed(*sdf));
++        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++        ASSERT_TRUE(hq.has_value());
++        EXPECT_TRUE(coordinator.isHeavyGeometryCurrent());
++        EXPECT_TRUE(matches(hq->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraBackpressure_KeepsCurrentFrameUntilOldPreviewCompletes)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.notifyCameraChanged();
++        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
++        ASSERT_TRUE(preview.has_value());
++
++        decision = coordinator.notifyCameraChanged();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++
++        decision = coordinator.completeTask(completed(*preview, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++
++        decision = coordinator.tick();
++        auto latestPreview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
++        ASSERT_TRUE(latestPreview.has_value());
++        EXPECT_TRUE(matches(latestPreview->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
++    }
++
++    TEST(RenderUpdateCoordinator, CameraInteractionEnded_WithCurrentHeavyGeometry_StartsHqForLatestView)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.tick();
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++
++        decision = coordinator.completeTask(completed(*bbox));
++        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++        ASSERT_TRUE(sdf.has_value());
++
++        decision = coordinator.completeTask(completed(*sdf));
++        auto initialHq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++        ASSERT_TRUE(initialHq.has_value());
++        ASSERT_TRUE(coordinator.isHeavyGeometryCurrent());
++        decision = coordinator.completeTask(completed(*initialHq, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
++
++        decision = coordinator.notifyCameraChanged();
++        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
++        ASSERT_TRUE(preview.has_value());
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
++
++        decision = coordinator.completeTask(completed(*preview, true, true));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::PresentFrame));
++
++        decision = coordinator.notifyCameraInteractionEnded();
++        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++        ASSERT_TRUE(hq.has_value());
++        EXPECT_TRUE(coordinator.isHeavyGeometryCurrent());
++        EXPECT_TRUE(matches(hq->stamp, coordinator.latestStamp(), RenderStampMask::displayFrame()));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::BoundingBoxUpdate));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
++    }
++
++    TEST(RenderUpdateCoordinator, StructuralModelChanged_StaleDisplayResultIsDiscarded)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.notifyCameraChanged();
++        auto preview = findStartedTask(decision, RenderTaskType::LowResolutionPreview);
++        ASSERT_TRUE(preview.has_value());
++
++        decision = coordinator.notifyStructuralModelChanged();
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgramCompilation));
++
++        decision = coordinator.completeTask(completed(*preview, true, true));
++
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++        EXPECT_FALSE(hasCommand(decision, RenderCommandType::PresentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, ProgramCompilationCompleted_AfterStructuralChange_StartsParameterUpload)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.notifyStructuralModelChanged();
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ProgramCompilation));
++
++        decision = coordinator.notifyProgramCompilationCompleted();
++
++        EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
++    }
++
++    TEST(RenderUpdateCoordinator, StaticTick_WithFreshHeavyTasks_DoesNotStartDuplicateHqWhileInFlight)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.tick();
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++
++        decision = coordinator.completeTask(completed(*bbox));
++        auto sdf = findStartedTask(decision, RenderTaskType::SdfPrecomputation);
++        ASSERT_TRUE(sdf.has_value());
++
++        decision = coordinator.completeTask(completed(*sdf));
++        auto hq = findStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk);
++        ASSERT_TRUE(hq.has_value());
++
++        decision = coordinator.tick();
++
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::ProgressiveHighQualityChunk));
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::KeepCurrentFrame));
++    }
++
++    TEST(RenderUpdateCoordinator, FailedBoundingBox_DoesNotAdvanceToSdfAndCanRetry)
++    {
++        RenderUpdateCoordinator coordinator;
++        auto decision = coordinator.tick();
++        auto bbox = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(bbox.has_value());
++
++        decision = coordinator.completeTask(failed(*bbox));
++
++        EXPECT_TRUE(hasCommand(decision, RenderCommandType::DiscardTaskResult));
++        EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::SdfPrecomputation));
++
++        decision = coordinator.tick();
++        auto retry = findStartedTask(decision, RenderTaskType::BoundingBoxUpdate);
++        ASSERT_TRUE(retry.has_value());
++        EXPECT_NE(retry->requestId, bbox->requestId);
++    }
++}
+diff --git a/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp b/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp
+new file mode 100644
+index 0000000..d6f74ce
+--- /dev/null
++++ b/gladius/tests/unittests/ui/render/RenderUpdateTypes_tests.cpp
+@@ -0,0 +1,126 @@
++#include "ui/render/RenderUpdateTypes.h"
++
++#include <gtest/gtest.h>
++
++namespace gladius::ui::async_rendering::tests
++{
++    namespace
++    {
++        [[nodiscard]] constexpr RenderStamp makeStamp(uint64_t scene,
++                                                      uint64_t parameters,
++                                                      uint64_t view,
++                                                      uint64_t viewport,
++                                                      uint64_t quality) noexcept
++        {
++            return RenderStamp{.sceneEpoch = scene,
++                               .parameterEpoch = parameters,
++                               .viewEpoch = view,
++                               .viewportEpoch = viewport,
++                               .qualityEpoch = quality};
++        }
++
++        [[nodiscard]] constexpr RenderTaskResult makeDisplayResult(RenderStamp stamp) noexcept
++        {
++            return RenderTaskResult{.requestId = 42,
++                                    .type = RenderTaskType::RealtimeFullFrame,
++                                    .stamp = stamp,
++                                    .status = RenderTaskStatus::Completed,
++                                    .durationNs = 1'000'000,
++                                    .producedDisplayFrame = true,
++                                    .completedFrame = true};
++        }
++    }
++
++    TEST(RenderStampMatches, WithSameRequiredAxes_ReturnsTrue)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const candidate = makeStamp(3, 5, 99, 101, 103);
++
++        EXPECT_TRUE(matches(candidate, latest, RenderStampMask::sceneAndParameters()));
++    }
++
++    TEST(RenderStampMatches, WithNoneMask_IgnoresAllAxes)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const completelyDifferent = makeStamp(30, 50, 70, 110, 130);
++
++        EXPECT_TRUE(matches(completelyDifferent, latest, RenderStampMask::none()));
++        EXPECT_FALSE(isOlderThan(completelyDifferent, latest, RenderStampMask::none()));
++    }
++
++    TEST(RenderStampMatches, WithDifferentView_FailsDisplayFrameButPassesHeavyGeometryTask)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const cameraOnlyStale = makeStamp(3, 5, 6, 11, 13);
++
++        EXPECT_FALSE(matches(cameraOnlyStale, latest, RenderStampMask::displayFrame()));
++        EXPECT_TRUE(matches(cameraOnlyStale, latest, RenderStampMask::heavyGeometryTask()));
++    }
++
++    TEST(RenderStampIsOlderThan, WithIgnoredAxis_DoesNotReportOlder)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const oldViewOnly = makeStamp(3, 5, 1, 11, 13);
++
++        EXPECT_FALSE(isOlderThan(oldViewOnly, latest, RenderStampMask::heavyGeometryTask()));
++        EXPECT_TRUE(isOlderThan(oldViewOnly, latest, RenderStampMask::displayFrame()));
++    }
++
++    TEST(RenderTaskResultIsDisplayableFor, WithCurrentDisplayStamp_ReturnsTrue)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const result = makeDisplayResult(latest);
++
++        EXPECT_TRUE(result.isDisplayableFor(latest));
++    }
++
++    TEST(RenderTaskResultIsDisplayableFor, WithOldCameraStamp_ReturnsFalse)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const oldCamera = makeStamp(3, 5, 6, 11, 13);
++        auto const result = makeDisplayResult(oldCamera);
++
++        EXPECT_FALSE(result.isDisplayableFor(latest));
++    }
++
++    TEST(RenderTaskResultIsDisplayableFor, WithOldParameterStamp_ReturnsFalse)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const oldParameter = makeStamp(3, 4, 7, 11, 13);
++        auto const result = makeDisplayResult(oldParameter);
++
++        EXPECT_FALSE(result.isDisplayableFor(latest));
++    }
++
++    TEST(RenderTaskResultIsCurrentFor, WithBoundingBoxResult_IgnoresCameraAndViewport)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto const bboxStamp = makeStamp(3, 5, 1, 2, 3);
++        auto const result = RenderTaskResult{.requestId = 7,
++                                             .type = RenderTaskType::BoundingBoxUpdate,
++                                             .stamp = bboxStamp,
++                                             .status = RenderTaskStatus::Completed};
++
++        EXPECT_TRUE(result.isCurrentFor(latest, RenderStampMask::heavyGeometryTask()));
++        EXPECT_FALSE(result.isCurrentFor(latest, RenderStampMask::displayFrame()));
++    }
++
++    TEST(RenderTaskResultIsCurrentFor, WithCancelledResult_ReturnsFalse)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto result = makeDisplayResult(latest);
++        result.status = RenderTaskStatus::Cancelled;
++
++        EXPECT_FALSE(result.isCurrentFor(latest, RenderStampMask::displayFrame()));
++        EXPECT_FALSE(result.isDisplayableFor(latest));
++    }
++
++    TEST(RenderTaskResultIsDisplayableFor, WithoutDisplayFrame_ReturnsFalse)
++    {
++        auto const latest = makeStamp(3, 5, 7, 11, 13);
++        auto result = makeDisplayResult(latest);
++        result.producedDisplayFrame = false;
++
++        EXPECT_FALSE(result.isDisplayableFor(latest));
++    }
++}
diff --git a/review.md b/review.md
new file mode 100644
index 00000000..a9f12d20
--- /dev/null
+++ b/review.md
@@ -0,0 +1,133 @@
+# Code Review: Render Mode Behavior and Parameter Changes
+
+## Summary
+
+Reviewed the generated C++/build-system diff against `develop` (`review.diff`, 6573 lines). The branch introduces a render-update coordinator, realtime raymarch admission controller, async presentation changes, low-resolution/streaming preview plumbing, and unit tests around these behaviors.
+
+The intended behavior from `specs/029-render-mode-behavior/userspec.md` is clear: camera movement should always remain responsive; `Off` uses previews; `Auto` adapts but keeps parameter edits preview-oriented; `Force` should prefer exact full-frame realtime for both camera and parameter edits and must not intentionally show a lower-quality surrogate. Parameter interactions should also end cleanly and resume static catch-up.
+
+The most important issues are correctness gaps around parameter changes. In particular, Force-mode parameter edits are still routed through low-resolution preview, and Force-mode parameter interactions may never transition back to `Static` because semantic interaction completion is coupled to the streaming-preview lifecycle.
+
+## Findings
+
+### 1. Force-mode parameter edits are scheduled as low-resolution preview instead of exact realtime
+
+- **Location**: `gladius/src/ui/render/RenderUpdateCoordinator.h:425`
+- **Issue**: `scheduleInteractiveFrame()` returns immediately for every `ParameterInteracting` state and starts `RenderTaskType::LowResolutionPreview` before checking the configured render mode. This directly violates the userspec for `Force`: “When I drag a slider I want to see the actual updated model immediately, not a blurry approximation.” It also explains why parameter changes do not fulfill the spec even though Force camera motion can schedule `RealtimeFullFrame`.
+- **Suggestion**:
+
+```cpp
+if (m_interactionState == RenderInteractionState::ParameterInteracting)
+{
+    if (m_realtime.config().mode == RealtimeRaymarchMode::Force)
+    {
+        if (m_realtime.canAttemptRealtime(m_width, m_height, m_realtimeGuards))
+        {
+            startTask(decision, RenderTaskType::RealtimeFullFrame, m_latestStamp);
+            return;
+        }
+
+        keepCurrentFrame(decision);
+        return;
+    }
+
+    startTask(decision, RenderTaskType::LowResolutionPreview, m_latestStamp);
+    return;
+}
+```
+
+- **Rationale**: This preserves the preview path for `Off` and `Auto` parameter edits while making `Force` behave like an exact-rendering policy. If realtime admission is temporarily blocked, it follows FR-014 by keeping the current frame instead of falling back to a surrogate preview.
+
+### 2. Force-mode parameter interactions may never end in the coordinator
+
+- **Location**: `gladius/src/ui/MainWindow.cpp:2724`, `gladius/src/ui/RenderWindow.cpp:2075`, `gladius/src/ui/RenderWindow.cpp:4183`
+- **Issue**: `MainWindow` disables streaming preview in Force mode via `useStreamingPreview = !m_renderWindow.isForceRealtimeMode()`. Later, the debounce path calls `stopStreamingPreview()` to signal that the parameter drag ended. However, `stopStreamingPreview()` only calls `notifyParameterInteractionEnded()` when `m_streamingPreviewActive` was true. In Force mode streaming was never started, so `wasActive` is false and the coordinator can remain stuck in `ParameterInteracting`. While stuck, `tick()` keeps scheduling interactive work and never runs `scheduleStaticCatchUp()`, so bbox/SDF/HQ convergence can fail to follow the specified post-interaction sequence.
+- **Suggestion**:
+
+```cpp
+void RenderWindow::finishParameterInteraction()
+{
+    m_streamingPreviewActive.store(false, std::memory_order_release);
+    m_streamingFrameConsumed.store(true, std::memory_order_release);
+
+    if (m_renderUpdateCoordinator.interactionState() ==
+        async_rendering::RenderInteractionState::ParameterInteracting)
+    {
+        queueRenderDecision(m_renderUpdateCoordinator.notifyParameterInteractionEnded());
+    }
+}
+```
+
+Then call `finishParameterInteraction()` from the debounce block instead of using `stopStreamingPreview()` as the semantic end-of-interaction signal. Keep `stopStreamingPreview()` as a transport/lifecycle helper for the streaming worker if needed.
+
+- **Rationale**: “Parameter interaction ended” is a semantic state transition and should not depend on whether the chosen feedback path happened to be streaming preview. Decoupling these concepts lets `Force` parameter edits resume static catch-up even when no streaming worker was active.
+
+### 3. Active parameter changes keep stale Auto-mode realtime learning
+
+- **Location**: `gladius/src/ui/render/RenderUpdateCoordinator.h:169`
+- **Issue**: `notifyParameterChanged(true)` increments `parameterEpoch` but only calls `resetRealtimeLearning()` when `interactionActive` is false. During a slider drag, the old `m_staticHQRenderTimeMs` from the previous parameter state remains available. If the user releases the slider and moves the camera before a new static HQ sample is measured, `Auto` can admit exact realtime using a timing sample from the old model/parameter state.
+- **Suggestion**:
+
+```cpp
+++m_latestStamp.parameterEpoch;
+resetRealtimeLearning();
+m_parameterUploadStamp.reset();
+m_boundingBoxStamp.reset();
+m_sdfStamp.reset();
+```
+
+If resetting on every drag tick is considered too aggressive, reset at the first parameter epoch change for the gesture and keep the value invalid until the next static HQ completion for the new epoch.
+
+- **Rationale**: The userspec says Auto should decide from the high-quality render time in static mode for the current state. Parameter changes can materially alter render cost, so old timing data should not admit exact realtime for a new parameter state.
+
+### 4. `isRealtimeActive()` still treats Force mode as actual realtime activity
+
+- **Location**: `gladius/src/ui/render/RealtimeRaymarchController.cpp:310`, used at `gladius/src/ui/RenderWindow.cpp:2381`
+- **Issue**: `RealtimeRaymarchController::isRealtimeActive()` returns true whenever mode is `Force`, even if no exact realtime job is in flight and no exact realtime frame is being presented. This contradicts the spec clarification that `Force` is a scheduling policy preference, not proof that exact realtime output is active. `RenderWindow` then uses this value to compute `useLowResPreviewBeforeHq`, coupling static catch-up behavior to configured mode instead of actual render state.
+- **Suggestion**:
+
+```cpp
+bool RealtimeRaymarchController::isRealtimeActive() const noexcept
+{
+    return m_realtimeActive;
+}
+```
+
+For Force-specific policy checks, add a differently named method such as `isRealtimePreferred()` or check `config().mode == RealtimeRaymarchMode::Force` at the policy site. For presentation/catch-up decisions in `RenderWindow`, prefer actual state, for example:
+
+```cpp
+auto const exactRealtimeJobInFlight =
+    m_asyncRealtimeJobInFlight.load(std::memory_order_acquire);
+bool const useLowResPreviewBeforeHq = !exactRealtimeJobInFlight;
+```
+
+- **Rationale**: Separating policy preference from actual activity avoids stale-frame and catch-up decisions being made as if exact output exists when it does not. This aligns with FR-006/FR-007 and the userspec’s Force-mode clarification.
+
+### 5. The unit test locks in behavior opposite to the Force-mode userspec
+
+- **Location**: `gladius/tests/unittests/ui/render/RenderUpdateCoordinator_tests.cpp:347`
+- **Issue**: `ParameterDrag_WithForcedRealtime_UsesPreviewNotRealtime` asserts that Force-mode parameter dragging starts `LowResolutionPreview` and not `RealtimeFullFrame`. This directly conflicts with the attached userspec and makes the implementation regress toward the wrong product behavior.
+- **Suggestion**:
+
+```cpp
+TEST(RenderUpdateCoordinator, ParameterDrag_WithForcedRealtime_StartsRealtimeFullFrame)
+{
+    RenderUpdateCoordinator coordinator;
+    coordinator.configureRealtime(forcedRealtimeConfig());
+    ASSERT_FALSE(coordinator.configureViewport(640, 480).commands.empty());
+
+    auto const decision = coordinator.notifyParameterChanged(true);
+
+    EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::ParameterUpload));
+    EXPECT_TRUE(hasStartedTask(decision, RenderTaskType::RealtimeFullFrame));
+    EXPECT_FALSE(hasStartedTask(decision, RenderTaskType::LowResolutionPreview));
+}
+```
+
+Also add a guarded variant that verifies Force parameter interaction emits `KeepCurrentFrame` when realtime admission is blocked instead of falling back to preview.
+
+- **Rationale**: Tests should encode the spec contract. As written, this test can cause future fixes to be rejected and is likely why the implementation currently fails parameter-change expectations in Force mode.
+
+## Notes
+
+No build-system-specific findings were found in the reviewed diff. The highest-risk area is the interaction between `MainWindow` parameter throttling, `RenderWindow` streaming-preview lifecycle, and `RenderUpdateCoordinator` semantic state. The immediate fix should start with the coordinator’s Force parameter branch and the semantic parameter-end transition, then update tests to match the userspec.
diff --git a/specs/029-render-mode-behavior/spec.md b/specs/029-render-mode-behavior/spec.md
new file mode 100644
index 00000000..0cff914c
--- /dev/null
+++ b/specs/029-render-mode-behavior/spec.md
@@ -0,0 +1,275 @@
+# Feature Specification: Render Mode Behavior and Interaction State Semantics
+
+**Feature Branch**: `029-render-mode-behavior`  
+**Created**: 2026-05-14  
+**Status**: Draft  
+**Input**: User description: "Based on the rendering-mode discussion in this session, define the behavior of the different modes, the expected state changes, and the intended user update experience."
+
+## Problem Statement
+
+The current rendering pipeline combines several update mechanisms:
+
+- exact full-frame realtime raymarching,
+- one-shot low-resolution preview,
+- streaming low-resolution preview during parameter editing,
+- static catch-up work such as parameter upload, bounding-box update, SDF precomputation, and high-quality progressive rendering.
+
+During this session it became clear that the intended behavior of these mechanisms is not yet specified precisely enough. In particular, the system currently risks conflating:
+
+- the **configured mode** (`Off`, `Auto`, `Force`),
+- the **current interaction state** (`Static`, `CameraInteracting`, `ParameterInteracting`), and
+- the **currently active render path** (exact realtime, low-res preview, streaming preview, static catch-up).
+
+Without an explicit product-level contract, bugs emerge where:
+
+- a parameter edit briefly flashes a surrogate or stale low-resolution preview before the intended interactive frame arrives,
+- camera interaction becomes blocked by a previously-started parameter-preview loop,
+- stale preview results overwrite a newer camera frame,
+- Force mode is treated as proof that exact realtime output is currently active even when no exact realtime frame is actually in flight.
+
+This specification defines the intended behavior of each mode, the valid state transitions, and the user-visible update experience.
+
+## Design Goals
+
+1. **Predictable mode semantics**: each rendering mode has a clear and testable contract.
+2. **Responsive interaction**: camera and parameter edits must remain fluid and visually understandable.
+3. **No stale-frame regressions**: old preview or HQ results must not replace fresher interactive output.
+4. **Separation of policy and execution**: configured mode is a policy preference; actual in-flight jobs determine what is currently active.
+5. **Graceful catch-up**: heavy background work should resume after interaction without visually disrupting the user.
+6. **No quality regressions**: the viewport MUST NOT replace a currently-displayed frame with a lower-quality frame, even if the lower-quality frame is epoch-fresh.
+7. **Stable Auto mode decisions**: once `Auto` mode commits to simpler rendering for a gesture, that decision is locked for the duration of the gesture to prevent mid-gesture quality oscillation.
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Predictable Off Mode (Priority: P1)
+
+As a user who disables realtime raymarching, I want all interactive feedback to use the preview path consistently, so that performance and image behavior are predictable.
+
+**Why this priority**: Off mode is the explicit opt-out for exact realtime. It must be deterministic and easy to reason about.
+
+**Independent Test**: Set the render mode to `Off`, move the camera, drag a parameter slider, and verify that no exact realtime path is used.
+
+**Acceptance Scenarios**:
+
+1. **Given** mode is `Off`, **When** the user moves the camera, **Then** the system shows preview-quality interactive feedback and does not schedule exact full-frame realtime rendering.
+2. **Given** mode is `Off`, **When** the user drags a parameter slider, **Then** the system uses low-resolution preview or streaming preview feedback and does not schedule exact full-frame realtime rendering.
+3. **Given** mode is `Off`, **When** interaction ends, **Then** the system transitions to static catch-up and eventually produces an updated high-quality frame.
+
+---
+
+### User Story 2 - Adaptive Auto Mode (Priority: P1)
+
+As a user in `Auto` mode, I want the system to use exact realtime only when it is safe and beneficial, so that I get the best possible responsiveness without visual instability.
+
+**Why this priority**: `Auto` is the default balancing mode between quality and responsiveness.
+
+**Independent Test**: Run the same interaction sequence on both a fast and a slow scene and verify that camera behavior adapts while parameter behavior stays stable.
+
+**Acceptance Scenarios**:
+
+1. **Given** mode is `Auto` and recent exact realtime samples are within budget, **When** the user moves the camera, **Then** the system may schedule exact full-frame realtime rendering.
+2. **Given** mode is `Auto` and exact realtime is not admissible, **When** the user moves the camera, **Then** the system falls back to preview-quality interaction without blanking the viewport.
+3. **Given** mode is `Auto`, **When** the user drags a parameter slider, **Then** the system prefers low-resolution or streaming preview feedback rather than exact full-frame realtime.
+4. **Given** mode is `Auto`, **When** interaction ends, **Then** the system resumes static catch-up and may use exact full-frame rendering only as part of static evaluation if budgets allow.
+5. **Given** mode is `Auto` and the system has fallen back to preview-quality during an active gesture, **When** the user continues the same gesture, **Then** the system MUST NOT switch back to exact realtime mid-gesture.
+6. **Given** mode is `Auto` and the last completed static HQ render took less than 100ms, **When** the user starts an interaction, **Then** the system may use exact realtime. **Given** the last static HQ render took 100ms or more, **When** the user starts an interaction, **Then** the system MUST use simpler rendering.
+
+---
+
+### User Story 3 - Exact Force Mode (Priority: P1)
+
+As a user in `Force` mode, I want camera and parameter interactions to prefer exact full-frame realtime output, so that what I see during interaction matches the final result as closely as possible.
+
+**Why this priority**: `Force` mode is the explicit request for exact interactive rendering. It must not silently degrade into a competing surrogate path unless exact rendering is truly unavailable.
+
+**Independent Test**: Set mode to `Force`, drag a parameter slider, then immediately move the camera. Verify that no low-resolution surrogate flash appears and the camera remains responsive.
+
+**Acceptance Scenarios**:
+
+1. **Given** mode is `Force`, **When** the user moves the camera, **Then** the system prefers exact full-frame realtime rendering on every eligible tick.
+2. **Given** mode is `Force`, **When** the user changes a parameter, **Then** the system prefers exact full-frame realtime rendering and must not start the streaming preview path in parallel.
+3. **Given** mode is `Force` and exact realtime cannot start immediately, **When** the user continues interacting, **Then** the last valid frame remains visible rather than flashing a low-resolution surrogate or blank frame.
+4. **Given** mode is `Force`, **When** camera interaction begins while parameter preview work is still active, **Then** camera interaction preempts that preview work and becomes the controlling interaction path.
+
+---
+
+### User Story 4 - Stable State Transitions (Priority: P1)
+
+As a user switching between editing and navigation, I want the preview to transition cleanly between interaction types and static catch-up, so that I never lose control or see stale frames from the wrong path.
+
+**Why this priority**: The highest-risk bugs in this session were transition bugs rather than pure rendering-speed problems.
+
+**Independent Test**: Repeatedly alternate between parameter drag, camera movement, and idle periods while observing whether stale low-res or HQ frames overwrite the current interaction.
+
+**Acceptance Scenarios**:
+
+1. **Given** a parameter interaction is active, **When** the user begins moving the camera, **Then** camera interaction supersedes parameter interaction for scheduling and presentation.
+2. **Given** an interactive frame is visible, **When** background bbox or SDF catch-up starts, **Then** the current interactive frame remains visible until a newer valid frame is ready.
+3. **Given** a preview result was produced for an older view or parameter epoch, **When** a newer interaction state exists, **Then** the stale result is discarded and never presented.
+4. **Given** interaction ends, **When** static catch-up begins, **Then** the system eventually converges to a high-quality current frame without showing older interactive artifacts.
+
+---
+
+### Edge Cases
+
+- What happens if camera interaction begins while a parameter streaming preview loop is active? → Camera interaction must preempt and deactivate the parameter streaming path.
+- What happens if exact realtime is configured (`Force`) but an exact realtime job is not actually running? → The system must treat this as a policy preference, not as proof that exact realtime output is currently active.
+- What happens if bbox or SDF catch-up becomes ready while the user is still interacting? → Catch-up work may continue in the background, but it must not override or freeze the active interaction path.
+- What happens if low-resolution preview results arrive with a stale `viewEpoch`? → They must be discarded before presentation.
+- What happens if exact realtime cannot currently be admitted in `Force` mode? → Keep the most recent valid frame visible and retry exact realtime on the next eligible tick; do not flash a surrogate frame by policy.
+
+## Mode Behavior Summary *(mandatory)*
+
+### Configured Modes
+
+| Mode | Camera Interaction | Parameter Interaction | Fallback Policy | Intended User Experience |
+| --- | --- | --- | --- | --- |
+| `Off` | Preview-quality only | Preview-quality only | Low-res/streaming preview | Stable, predictable surrogate interaction with HQ catch-up after idle |
+| `Auto` | Exact realtime if last static HQ render < 100ms, else preview-quality; once fallen back to simpler during a gesture, stays simpler until gesture ends | Preview-quality preferred | Adaptive; hysteresis prevents mid-gesture quality oscillation | Best-effort responsiveness: quality adapts per scene speed, never switches back mid-gesture |
+| `Force` | Exact full-frame realtime preferred | Exact full-frame realtime preferred | Keep current valid frame if exact path not yet ready | Exact interactive output whenever possible, never an intentional surrogate flash |
+
+### Interaction-State Matrix
+
+| Interaction State | Off | Auto | Force |
+| --- | --- | --- | --- |
+| `Static` | Static catch-up only | Static catch-up, optionally exact static full frame if admitted | Static catch-up, but interactive exact path takes priority whenever interaction resumes |
+| `CameraInteracting` | Low-res preview | Exact realtime if admitted, else low-res preview | Exact realtime preferred; current valid frame held if admission is transiently blocked |
+| `ParameterInteracting` | Low-res preview or streaming preview | Low-res preview or streaming preview | Exact realtime preferred; streaming preview must not be started |
+
+## State Model *(mandatory)*
+
+### Key Entities
+
+- **ConfiguredMode**: user-selected realtime behavior policy (`Off`, `Auto`, `Force`).
+- **InteractionState**: semantic interaction owner (`Static`, `CameraInteracting`, `ParameterInteracting`).
+- **ExactRealtimeActive**: true only when an exact full-frame realtime job is actually in flight or being presented.
+- **PreviewPath**: low-resolution one-shot or streaming preview path used for surrogate interaction feedback.
+- **StaticCatchUp**: background work needed to converge to the latest high-quality result, including parameter upload, bounding box update, SDF precomputation, and HQ rendering.
+- **Freshness Stamp**: scene/parameter/view/viewport identity used to reject stale work before presentation.
+- **StaticHQRenderTime**: the wall-clock duration of the most recently completed HQ render in `Static` state. Used by `Auto` mode as the admission baseline: < 100ms allows exact realtime during interactions, ≥ 100ms requires simpler rendering.
+- **AutoInteractionDecision**: a per-gesture flag set when `Auto` mode first evaluates admission for the current gesture. Once set to "simpler", it is locked for the remainder of the gesture and cleared only when the interaction ends.
+
+### State Transition Rules
+
+| Trigger | Previous State | Next State | Required Side Effects | User-Visible Outcome |
+| --- | --- | --- | --- | --- |
+| Camera input detected | Any | `CameraInteracting` | Increment `viewEpoch`; invalidate view-dependent interactive work; stop parameter streaming preview if active | Camera feedback becomes the highest-priority output |
+| Parameter value changes with interaction active | `Static` or `ParameterInteracting` | `ParameterInteracting` | Increment `parameterEpoch`; invalidate parameter/bbox/SDF freshness; choose preview path based on mode | User sees immediate parameter feedback according to mode |
+| Parameter interaction ends / debounce expires | `ParameterInteracting` | `Static` | Stop streaming preview if active; schedule bbox/SDF/HQ catch-up | Last interactive frame remains until static output catches up |
+| Camera interaction ends | `CameraInteracting` | `Static` | Schedule static catch-up appropriate to latest parameter/view state | System converges from interactive feedback to current HQ output |
+| Structural model change | Any | `Static` | Increment `sceneEpoch`; invalidate all dependent work; stop preview loops | Last valid frame may remain visible with busy feedback until fresh output arrives |
+| Auto mode falls back during interaction | `CameraInteracting` or `ParameterInteracting` (Auto, exact path) | Same interaction state | Set `AutoInteractionDecision` = simpler; lock decision for remainder of gesture | Rendering simplifies without switching back until the gesture completes |
+
+### Precedence Rules
+
+1. **Camera interaction supersedes parameter interaction for presentation and scheduling.**
+2. **Configured `Force` mode does not imply `ExactRealtimeActive`.**
+3. **Preview suppression rules must key off actual exact realtime activity and frame freshness, not just configured mode.**
+4. **Static catch-up must never overwrite a fresher interactive frame.**
+5. **Low-resolution or streaming preview must never run in parallel as the authoritative interaction path in `Force` mode.**
+6. **A lower-quality frame MUST NOT replace a higher-quality frame currently being displayed, even if the lower-quality frame carries a current epoch stamp.**
+7. **In `Auto` mode, once the system has committed to simpler rendering for the current gesture, `AutoInteractionDecision` is locked for the rest of that gesture.**
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: System MUST expose three configured render modes: `Off`, `Auto`, and `Force`.
+- **FR-002**: System MUST model interaction using the semantic states `Static`, `CameraInteracting`, and `ParameterInteracting`.
+- **FR-003**: Camera input MUST transition the system to `CameraInteracting` and increment a view-freshness generation.
+- **FR-004**: Parameter edits MUST transition the system to `ParameterInteracting` while interaction remains active and increment a parameter-freshness generation.
+- **FR-005**: Structural model edits MUST invalidate program, parameter, bbox, SDF, and display freshness and transition the system to `Static`.
+- **FR-006**: The system MUST distinguish configured mode from actual in-flight exact realtime activity.
+- **FR-007**: Presentation logic MUST use actual in-flight exact realtime state to decide whether to preserve exact front buffers or suppress preview results.
+- **FR-008**: In `Off` mode, the system MUST NOT schedule exact full-frame realtime rendering for camera or parameter interaction.
+- **FR-009**: In `Auto` mode, the system MUST use exact full-frame realtime for camera interaction only when the last measured `StaticHQRenderTime` is less than 100ms. If `StaticHQRenderTime` is 100ms or more, the system MUST fall back to simpler rendering during interactions.
+- **FR-010**: In `Auto` mode, parameter interaction MUST prefer preview-quality interaction feedback and MUST NOT require exact full-frame realtime.
+- **FR-011**: In `Force` mode, camera interaction MUST prefer exact full-frame realtime on every eligible tick.
+- **FR-012**: In `Force` mode, parameter interaction MUST prefer exact full-frame realtime and MUST NOT start the streaming preview path in parallel.
+- **FR-013**: Beginning camera interaction while parameter streaming preview is active MUST deactivate or cancel the parameter streaming preview path.
+- **FR-014**: If exact realtime cannot start immediately in `Force` mode, the system MUST keep the most recent valid frame visible rather than intentionally presenting a surrogate preview or blank frame.
+- **FR-015**: Background bbox and SDF catch-up MUST NOT freeze camera interaction or overwrite a fresher interactive frame.
+- **FR-016**: Preview, exact realtime, and HQ frames MUST carry enough freshness information to reject stale scene, parameter, view, or viewport results before presentation.
+- **FR-017**: Low-resolution preview results produced for an older `viewEpoch` MUST be discarded when a newer camera view is active.
+- **FR-018**: When interaction ends, the system MUST first render a final frame in the mode that was active during interaction (which may be a low-resolution preview frame) before starting HQ catch-up. HQ catch-up itself MUST then proceed in dependency order: parameter upload if needed, bounding-box update if stale, SDF precomputation if stale, then current-frame HQ rendering.
+- **FR-019**: The system MUST support last-write-wins semantics for rapid parameter changes so that only the newest parameter state needs to be rendered.
+- **FR-020**: The viewport MUST continue showing a valid frame while newer work is pending; the system MUST avoid blanking the render window during normal interaction-state transitions.
+- **FR-021**: Preview-quality interaction paths MUST be allowed to trade fidelity for latency in `Off` and `Auto`, but MUST remain visually coherent and ordered.
+- **FR-022**: The system SHOULD show busy or catch-up feedback while heavy static work is pending, without replacing the last valid frame.
+- **FR-023**: In `Auto` mode, once `AutoInteractionDecision` is set to "simpler" for a gesture, the system MUST NOT schedule exact full-frame realtime rendering until the gesture ends and `AutoInteractionDecision` is cleared.
+- **FR-024**: The system MUST measure the wall-clock duration of each completed static HQ render and record it as `StaticHQRenderTime`. This value MUST be used as the sole admission criterion for exact realtime in `Auto` mode.
+- **FR-025**: When transitioning between rendering quality levels (exact realtime ↔ preview), the first frame at the new quality level MUST reflect the same scene and view state as the last frame displayed at the previous level. The system MUST NOT present a frame from a stale or different model/view state during a quality transition.
+- **FR-026**: The system MUST NOT present a lower-quality frame in place of a higher-quality frame that is already being shown, even if the lower-quality frame carries a current epoch stamp.
+- **FR-027**: The low-resolution preview path MUST use precomputed distance field data when a fresh precomputed SDF is available for the current scene and parameter state.
+- **FR-028**: The low-resolution preview path MUST dynamically adapt its framebuffer resolution to maintain a target frame rate during interaction.
+- **FR-029**: Progressive HQ catch-up MUST begin with a low-resolution result and incrementally add scanlines or detail passes in full-quality mode until the full-resolution HQ frame is complete.
+- **FR-030**: During progressive HQ rendering, each completed pass MUST be presented to the user immediately so that quality visibly improves over time rather than appearing only when fully complete.
+
+## Intended User Experience *(mandatory)*
+
+### Off Mode
+
+- The viewport behaves predictably and conservatively.
+- During camera motion and parameter edits, the user sees preview-quality feedback.
+- The system may use low-resolution or surrogate representations, but behavior is consistent and understandable.
+- Once interaction ends, the system catches up to a current HQ frame.
+
+### Auto Mode
+
+- The viewport feels adaptive.
+- Whether the system uses exact rendering or simpler preview is determined by how long the last static HQ render took: under 100ms uses exact rendering; 100ms or more uses simpler preview.
+- Once the system has committed to simpler rendering for a gesture (e.g. a camera drag), it stays in that mode for the entire gesture. There is no mid-gesture switch back to higher quality, which would be visually jarring.
+- Parameter edits remain responsive and visually stable, without forcing an exact full-frame path that could destabilize responsiveness.
+- The user should never need to guess whether the system is "stuck"; the latest valid frame remains visible while catch-up proceeds.
+- Quality never regresses: the viewport never replaces a sharp frame with a blurrier one.
+
+### Force Mode
+
+- The viewport prioritizes exactness during interaction.
+- Camera movement should feel like exact interactive rendering, not a switch to a visibly different surrogate path.
+- Parameter edits should behave like camera motion in the sense that they request immediate exact updates rather than a competing low-res streaming path.
+- If exact rendering is temporarily blocked by transient conditions, the viewport should hold the latest valid frame and remain responsive instead of flashing a stale or lower-fidelity alternative.
+
+### Interaction Transitions
+
+- Starting camera movement after parameter editing should feel like a clean handoff, not a conflict between two rendering policies.
+- Ending interaction should feel like a convergence from “interactive latest valid frame” to “current HQ frame,” not like a reset or visual regression.
+- Users should not see a stale frame from the wrong interaction type appear late.
+
+## Clarifications
+
+### Session 2026-05-14
+
+- Q: Does `Force` mode mean exact realtime output is always currently active? → A: No. `Force` is a scheduling policy preference, not proof that an exact realtime frame is currently in flight.
+- Q: Should parameter editing in `Force` mode use the same streaming preview path as `Off`/`Auto`? → A: No. `Force` mode parameter interaction should prefer exact full-frame realtime and must not start the streaming preview path in parallel.
+- Q: What happens if camera motion begins while parameter preview is active? → A: Camera interaction preempts parameter streaming preview and becomes the controlling interaction path.
+- Q: What should happen if a stale preview result arrives after the camera moved? → A: The stale preview result must be discarded and not presented.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: In `Off` mode, no exact full-frame realtime jobs are scheduled during camera or parameter interaction.
+- **SC-002**: In `Auto` mode, camera interaction falls back cleanly between exact realtime and preview-quality interaction without stale-frame artifacts.
+- **SC-003**: In `Force` mode, parameter changes do not trigger a visible low-resolution surrogate flash.
+- **SC-004**: In `Force` mode, beginning camera interaction immediately after parameter editing does not freeze the viewport or require waiting for a parameter preview loop to finish.
+- **SC-005**: Stale preview frames are never displayed after a newer camera or parameter state has been presented.
+- **SC-006**: When interaction ends, the system always converges to a current HQ frame for the latest scene, parameter, view, and viewport state.
+- **SC-007**: During normal interaction-state transitions, the viewport always shows either the newest valid frame or a busy/catch-up state over the last valid frame; it never intentionally blanks the window.
+- **SC-008**: In `Auto` mode, during a single continuous gesture (one camera drag or one parameter drag), the rendering quality never switches from simpler preview back to exact realtime mid-gesture.
+- **SC-009**: In `Auto` mode, the admission decision for exact realtime is demonstrably correlated with whether `StaticHQRenderTime` is below 100ms for the most recent static render.
+- **SC-010**: The viewport never replaces a currently-displayed frame with a lower-quality frame that shows the same or an older model/view state.
+- **SC-011**: After interaction ends, the first new frame presented shows the same model and view state as the last interactive frame, regardless of quality level.
+
+## Assumptions
+
+- Exact full-frame realtime rendering is more expensive than low-resolution preview and therefore must remain policy-controlled.
+- Users interpret visibly different rendering paths as different semantic states; therefore sudden surrogate flashes in `Force` mode are considered correctness bugs, not merely quality tradeoffs.
+- The existing async infrastructure can represent freshness using scene, parameter, view, and viewport generations.
+- Catch-up work such as bbox and SDF updates may continue in the background as long as it does not become the authoritative interactive presentation path.
+
+## Out of Scope
+
+- Kernel-level performance optimization of realtime raymarching.
+- UI wording or menu design for exposing the three modes.
+- Export or file-loading behavior outside the preview/update pipeline.
diff --git a/specs/029-render-mode-behavior/state-transition-trace.md b/specs/029-render-mode-behavior/state-transition-trace.md
new file mode 100644
index 00000000..7f2a259b
--- /dev/null
+++ b/specs/029-render-mode-behavior/state-transition-trace.md
@@ -0,0 +1,96 @@
+# Render Mode State Transition Trace
+
+**Date**: 2026-05-15  
+**Scope**: Parameter and camera interaction update flow for `Off`, `Auto`, and `Force` render modes.
+
+This document records the actual state transitions found in the code while investigating why the previous unit tests passed even though interactive parameter updates did not match `userspec.md`.
+
+## Key components
+
+- `MainWindow::updateModel()` detects dirty model/parameter state and decides whether to notify `RenderWindow`.
+- `RenderWindow::invalidateViewDueToParameterChange()` marks render state dirty and queues `RenderUpdateCoordinator::notifyParameterChanged(true)`.
+- `RenderUpdateCoordinator` owns semantic state: `Static`, `CameraInteracting`, `ParameterInteracting`.
+- `RenderWindow::renderAsync()` translates coordinator commands to concrete async jobs, but it also still has a legacy low-resolution preview branch driven by `state.isMoving`, `m_forceLowResRenderOnNextFrame`, and `m_lowResFeedbackPending`.
+- `RenderWindow::processAsyncPreviewResults()` presents low-resolution preview results unless they are stale or suppressed.
+
+## Pre-fix transition trace
+
+### Force mode, continuous parameter drag
+
+1. `MainWindow::updateModel()` sees `m_parameterDirty`.
+2. Because `isForceRealtimeMode()` is true, streaming preview is not started.
+3. `RenderWindow::invalidateViewDueToParameterChange()` queues `notifyParameterChanged(true)` and clears low-res flags.
+4. `RenderUpdateCoordinator` can schedule `ParameterUpload` and `RealtimeFullFrame`.
+5. However, `RenderWindow::renderAsync()` later reaches the legacy low-res branch if `state.isMoving`, `forceLowResRender`, or `lowResPending` is true.
+6. `state.isMoving` can be true for reasons unrelated to the coordinator's realtime policy (camera debounce, resize/centering paths, or other UI motion state).
+7. The legacy branch can call `scheduleAsyncPreviewJob()` / `renderLowResPreview()` even while Force policy says to hold the current frame or use exact realtime.
+
+**Failure**: The coordinator tests passed because they only asserted the semantic command stream. They did not cover the later `RenderWindow::renderAsync()` fallback that could still schedule low-res preview.
+
+### Auto/Off mode, continuous parameter drag with streaming preview
+
+1. First dirty parameter update enters `MainWindow::updateModel()`.
+2. `RenderWindow::invalidateViewDueToParameterChange()` is called.
+3. `RenderWindow::startStreamingPreview()` starts the streaming preview coroutine.
+4. Subsequent parameter changes happen while `isStreamingPreviewActive()` is true.
+5. The old `MainWindow` branch skipped `invalidateViewDueToParameterChange()` while streaming was active.
+6. It still cleared `m_parameterDirty`, so no render-window state was refreshed for the new parameter value.
+7. `m_lastParameterChangeTime` remained at the first change, allowing the debounce path to conclude that the drag ended while the user was still changing parameters.
+8. Streaming could be stopped and static catch-up could start from a stale interaction boundary.
+
+**Failure**: Continuous Auto/Off parameter changes could be visually dropped or cut short because repeated dirty events refreshed neither the semantic interaction nor the debounce timestamp.
+
+### Force mode, parameter interaction end
+
+1. Force mode intentionally does not start streaming preview.
+2. The old debounce path called `stopStreamingPreview()` as the way to signal parameter interaction end.
+3. `stopStreamingPreview()` only notified the coordinator if streaming had been active.
+4. In Force mode, streaming was inactive, so the coordinator could remain in `ParameterInteracting`.
+
+**Failure**: Static catch-up could fail to begin because semantic interaction end was coupled to the streaming transport lifecycle.
+
+## Fixed transition model
+
+### Force mode parameter update
+
+1. `MainWindow::updateModel()` classifies the parameter change as `invalidateInteraction=true`, `startStreamingPreview=false`.
+2. `RenderWindow::invalidateViewDueToParameterChange()` queues the coordinator parameter-change event.
+3. `RenderUpdateCoordinator::scheduleInteractiveFrame()` schedules `RealtimeFullFrame` for `ParameterInteracting` in `Force` mode when guards allow it.
+4. If guards block exact realtime, the coordinator emits `KeepCurrentFrame` and does not schedule preview.
+5. `RenderWindow::renderAsync()` uses `shouldUseLegacyLowResPreview()` to suppress the legacy low-res branch whenever Force is the active interaction policy.
+
+### Auto mode parameter update
+
+1. First parameter dirty event invalidates the interaction and starts streaming preview.
+2. Later dirty events while streaming is active use `refreshStreamingParameterInteraction()` instead of being ignored.
+3. The refresh keeps the interaction alive by updating `m_lastParameterChangeTime`, dirty flags, SDF invalidation, and bbox-stale state.
+4. Streaming preview continues to push latest Assembly parameters and render low-res feedback.
+5. When dirty events stop and the debounce interval elapses, `finishParameterInteraction()` performs the semantic transition to `Static` and catch-up begins.
+
+### Camera preemption
+
+1. Camera input calls `invalidateCameraView()`.
+2. Streaming preview flags are cleared immediately.
+3. The coordinator transitions to `CameraInteracting` and schedules the correct mode-dependent camera feedback.
+4. Force and Auto-exact interactions suppress legacy low-res fallback; Off and Auto-preview can use preview feedback.
+
+## Unit-test coverage map
+
+| Requirement from userspec | Unit coverage |
+| --- | --- |
+| Camera movement schedules according to mode and does not wait for previous preview | `RenderUpdateCoordinator.CameraChanged_*`, `RenderUpdateCoordinator.CameraBackpressure_*` |
+| `Off` interactions use preview-quality feedback | `RenderUpdateCoordinator.CameraChanged_WithAutoLearning_StartsLowResolutionPreview`, `RenderModeUpdatePolicy.LegacyLowResPreview_WithAutoPreviewParameterInteraction_IsAllowed` (Off policy covered by dispatch tests) |
+| `Auto` uses exact only after fast static HQ and otherwise preview | `RenderUpdateCoordinator.CameraChanged_WithAutoRealtimeAfterFastSamples_StartsRealtimeFullFrame`, `RenderUpdateCoordinator.ActiveParameterChanged_AfterFastAutoSample_ResetsInteractionAdmission` |
+| Auto simpler decision does not oscillate mid-gesture | `RenderUpdateCoordinator.CameraChanged_WithAutoRealtimeGuardBlocker_KeepsCurrentFrame`, per-gesture latch tests in coordinator suite |
+| Force camera uses exact realtime or holds current frame | `RenderUpdateCoordinator.CameraChanged_WithForcedRealtime_StartsRealtimeFullFrame`, guard-blocker tests |
+| Force parameter edits use exact realtime, not preview | `RenderUpdateCoordinator.ParameterDrag_WithForcedRealtime_StartsRealtimeFullFrame`, `RenderModeUpdatePolicy.LegacyLowResPreview_WithForceParameterInteraction_IsSuppressed` |
+| Force parameter guard blockers hold current frame | `RenderUpdateCoordinator.ParameterDrag_WithForcedRealtimeGuardBlocker_KeepsCurrentFrame` |
+| Continuous Force parameter updates never fall through to preview | `RenderUpdateCoordinator.ContinuousParameterDrag_WithForcedRealtimeInFlight_NeverStartsPreview`, `RenderModeUpdatePolicy.LegacyLowResPreview_WithForceParameterInteraction_IsSuppressed` |
+| Continuous Auto/Off parameter updates are not dropped while streaming | `RenderModeUpdatePolicy.ParameterChangeDispatch_WithAutoStreamingActive_RefreshesInteraction`, `RenderModeUpdatePolicy.ParameterChangeDispatch_WithOffStreamingActive_RefreshesInteraction`, `RenderUpdateCoordinator.ContinuousParameterDrag_WithStaleAutoPreview_CompletesLatestPreview` |
+| Parameter interaction end is semantic, not dependent on streaming transport | `RenderWindow::finishParameterInteraction()` implementation; policy documented here. A direct GL-free unit test is covered through dispatch policy and coordinator static catch-up tests. |
+| Static catch-up sequence after interaction | `RenderUpdateCoordinator.StaticCatchUp_AfterParameterEdit_SequencesUploadBboxSdfThenHq` |
+| No lower-quality preview replaces an exact/HQ frame | `RenderModeUpdatePolicy.LegacyLowResPreview_WithExactRealtimeInFlight_IsSuppressed` plus preview suppression in `processAsyncPreviewResults()` |
+
+## Remaining caveat
+
+`RenderWindow` is still difficult to test directly because most concrete scheduling functions require a live `ComputeCore`, OpenCL images, and a GL context. The low-level decisions that caused the observed regressions are now extracted into `RenderModeUpdatePolicy.h` so they are unit-tested without GL/OpenCL, while `RenderWindow` and `MainWindow` call that policy in production.
diff --git a/specs/029-render-mode-behavior/userspec.md b/specs/029-render-mode-behavior/userspec.md
new file mode 100644
index 00000000..34614ca8
--- /dev/null
+++ b/specs/029-render-mode-behavior/userspec.md
@@ -0,0 +1,89 @@
+# User Specification: Rendering Mode Behavior
+
+**Created**: 2026-05-15  
+**Source**: User input from session 2026-05-14
+
+---
+
+## What the user wants
+
+### Camera movement should always work
+
+Moving the camera (orbiting, panning, zooming) is the most basic interaction in the preview window.  
+No matter what mode is selected and no matter what was being done before (editing a slider, waiting for a model to compile), moving the camera should:
+
+- feel immediate — the view should respond as I drag,
+- never freeze mid-movement,
+- never require waiting for some previous operation to finish first.
+
+If I was editing a parameter and then grab the camera, the parameter editing is over.  
+Camera wins. The view moves.
+
+---
+
+### Each mode should mean something clear
+
+The three rendering modes available in the menu should have predictable and distinct meanings.
+
+**Off**
+
+I have turned off the fancy interactive rendering.  
+Everything I see while moving the camera or editing parameters is a simplified preview.  
+It is fine to look less exact than the final result. That is the tradeoff I made.  
+When I stop moving, the system should catch up and show me a proper result.
+
+**Auto**
+
+The system decides.  
+On fast models it tries to show me exact-looking results while I interact.  
+On slow models it falls back to something simpler.  
+Either way, the camera should still move without freezing.  
+I do not need to know which strategy it chose.
+
+**Force**
+
+I have turned on exact interactive rendering. I want to see the real result as I interact.  
+When I move the camera I want to see the actual raymarched model, not a blurry approximation.  
+When I drag a slider I want to see the actual updated model immediately, not a blurry approximation.
+
+If the system cannot keep up immediately it should just hold the last frame it produced  
+and continue as fast as it can. It must not suddenly switch to a visibly different, lower-quality image.  
+It must not freeze.
+
+---
+
+### Switching between editing and moving should be seamless
+
+A typical session looks like:
+
+1. I drag a slider to change a radius.
+2. I orbit the camera to check the shape from a different angle.
+3. I drag the slider again.
+
+None of those steps should:
+
+- leave the viewport blank,
+- show a leftover frame from the wrong step,
+- cause a visible jump to a lower-quality image,
+- freeze the camera because step 1 is still running.
+
+When I stop doing anything, the system should quietly catch up to a full-quality current result in the background. If the full-quality result would take a long time to produce, it should be rendered progressively, starting with a low-res preview by rendering more lines in full-quality mode.
+
+---
+
+### In Auto mode the transition between "fast enough" and "not fast enough" should only happen towards the faster version during interactions
+If the system is in Auto mode and it decides that the model is too slow to render in full quality while I interact, it should switch to a simpler rendering mode. But it than should stay in that mode until I stop interacting. It should not switch back and forth while I am dragging a slider or moving the camera.
+
+---
+
+### How the renderer decides what is "fast enough" for Auto mode
+The time for the high quality rendering in static mode should be measured and used as a baseline for deciding what is "fast enough" for Auto mode. If the high quality rendering takes more than 100ms, then Auto mode should switch to a simpler rendering mode during interactions. If it takes less than 100ms, then Auto mode should use the high quality rendering during interactions.
+
+### Transitions between rendering qualities should be seamless
+When switching between rendering qualities (either because of mode change or because Auto mode decides to switch), the transition should be seamless in the sense that the same state of the model and view is shown. For example, if I am dragging a slider and the system decides to switch to a simpler rendering mode, it should not suddenly show me a different frame that was rendered in the previous mode. It should continue showing the same frame but just render it in the new mode.
+
+### What the low-res preview is made from
+The low res preview uses the precomputed distance field when available and adopts its framebuffer resolution to the framerate.
+
+### How catch-up is sequenced after interaction ends
+When I stop interacting, the system should start a catch-up process to produce a full-quality current result if the current frame is not already full-quality. This process should be done in the background and should not block the UI. The system should first render a final frame in the current mode (which may be a low-res preview) and then start rendering the full-quality result. If the full-quality result takes a long time to produce, it should be rendered progressively, starting with a low-res preview by rendering more lines in full-quality mode.The time of the high quality rendering in static mode should be measured (s. above).
diff --git a/specs/030-library-extension/checklists/requirements.md b/specs/030-library-extension/checklists/requirements.md
new file mode 100644
index 00000000..7e73bf44
--- /dev/null
+++ b/specs/030-library-extension/checklists/requirements.md
@@ -0,0 +1,34 @@
+# Specification Quality Checklist: Library Extension
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning  
+**Created**: 2026-06-10  
+**Feature**: [spec.md](../spec.md)  
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- All items pass validation on first iteration. Specification is ready for `/speckit.clarify` or `/speckit.plan`.
diff --git a/specs/030-library-extension/contracts/library-api.yaml b/specs/030-library-extension/contracts/library-api.yaml
new file mode 100644
index 00000000..f9f27a3e
--- /dev/null
+++ b/specs/030-library-extension/contracts/library-api.yaml
@@ -0,0 +1,218 @@
+openapi: 3.0.2
+info:
+  title: Gladius Library Extension API
+  description: >
+    MCP-based API for creating, validating, and managing library entries in the
+    Gladius 3MF library. This contract covers the operations needed to implement
+    Feature 030 (library extension).
+  version: 1.0.0
+
+paths: {}  # MCP tools are not HTTP endpoints; contracts here document tool signatures
+
+components:
+  schemas:
+    LibraryEntry:
+      type: object
+      description: A single item in the Gladius 3MF library
+      required:
+        - name
+        - category
+        - program_snippet
+        - function_id
+        - description
+        - tags
+      properties:
+        name:
+          type: string
+          pattern: '^[a-z0-9_]+$'
+          description: Entry name in lower_snake_case, unique within category
+        category:
+          type: string
+          enum:
+            - primitives
+            - csg
+            - modifiers
+            - operations
+            - mechanical
+            - lattices
+            - textures
+          description: Library subdirectory / category
+        program_snippet:
+          type: string
+          description: >
+            Full GLSL-like program listing in set_program_snippet format.
+            Must include the library function AND a main root function that
+            demonstrates it. Example:
+            ```
+            // Function: my_shape (ID: 1)
+            float my_shape_1(vec3 pos, float radius) {
+              return length(pos) - radius;
+            }
+
+            // Function: main (ID: 3) [root]
+            (float shape) main_3(vec3 pos) {
+              shape = my_shape_1(pos, 10.0);
+            }
+            ```
+        function_id:
+          type: integer
+          description: Resource ID of the function to tag as the library function (not main). This is the function that will be importable.
+        description:
+          type: string
+          minLength: 10
+          maxLength: 100
+          description: One-sentence human-readable description
+        tags:
+          type: array
+          items:
+            type: string
+          minItems: 5
+          uniqueItems: true
+          description: Searchable keywords for the entry
+        overwrite:
+          type: boolean
+          default: false
+          description: If true, overwrite an existing entry with the same name
+
+    TaggedFunction:
+      type: object
+      description: The primary exportable function within a library entry
+      properties:
+        function_name:
+          type: string
+          pattern: '^[a-z0-9_]+$'
+        return_type:
+          type: string
+          enum: [float, vec3]
+        parameters:
+          type: array
+          items:
+            $ref: '#/components/schemas/Parameter'
+
+    Parameter:
+      type: object
+      properties:
+        name:
+          type: string
+          pattern: '^[a-z][a-zA-Z0-9]*$'
+        type:
+          type: string
+          enum: [float, vec3]
+
+  examples:
+    symmetry_y_entry:
+      summary: SymmetryY library entry example
+      value:
+        name: symmetry_y
+        category: operations
+        program_snippet: |
+          // Function: symmetryY (ID: 1)
+          vec3 symmetryY(vec3 pos) {
+              return vec3(-pos.x, -pos.y, pos.z);
+          }
+
+          // Function: main (ID: 2) [root]
+          (float shape) main(vec3 pos) {
+              float radius = 10.0;
+              vec3 p = symmetryY(pos);
+              shape = length(p) - radius;
+          }
+        function_id: 1
+        description: "Point reflection across YZ plane (mirrors X and Z coordinates)"
+        tags:
+          - symmetry
+          - mirror
+          - transformation
+          - reflection
+          - operations
+        overwrite: false
+
+    ellipsoid_entry:
+      summary: Ellipsoid primitive example
+      value:
+        name: ellipsoid
+        category: primitives
+        program_snippet: |
+          // Function: ellipsoid (ID: 1)
+          float ellipsoid(vec3 pos, float xRadius, float yRadius, float zRadius) {
+              return length(pos / vec3(xRadius, yRadius, zRadius)) - 1.0;
+          }
+
+          // Function: main (ID: 2) [root]
+          (float shape) main(vec3 pos) {
+              shape = ellipsoid(pos, 8.0, 5.0, 3.0);
+          }
+        function_id: 1
+        description: "Ellipsoid primitive with three independent radii along each axis"
+        tags:
+          - ellipsoid
+          - primitive
+          - sphere
+          - radius
+          - geometry
+        overwrite: false
+
+    twist_entry:
+      summary: Twist modifier example
+      value:
+        name: twist
+        category: modifiers
+        program_snippet: |
+          // Function: twist (ID: 1)
+          vec3 twist(vec3 pos, float angle) {
+              if (angle == 0.0) return pos;
+              float t = pos.z / 10.0;
+              float c = cos(angle * t);
+              float s = sin(angle * t);
+              vec2 rotated = vec2(pos.x * c - pos.y * s, pos.x * s + pos.y * c);
+              return vec3(rotated.x, rotated.y, pos.z);
+          }
+
+          // Function: main (ID: 2) [root]
+          (float shape) main(vec3 pos) {
+              float radius = 5.0;
+              vec3 twisted = twist(pos, 45.0);
+              shape = length(twisted.xy) - radius;
+          }
+        function_id: 1
+        description: "Applies rotational twist around Z axis proportional to height"
+        tags:
+          - twist
+          - deformation
+          - modifier
+          - rotation
+          - transformation
+        overwrite: false
+
+    hex_nut_entry:
+      summary: Hex nut mechanical part example
+      value:
+        name: hex_nut
+        category: mechanical
+        program_snippet: |
+          // Function: hex_nut (ID: 1)
+          float hex_nut(vec3 pos, float size) {
+              vec2 p = abs(pos.xy);
+              float angle = 2.0 * 3.14159 / 6.0;
+              float outerHex = max(
+                  dot(p, vec2(sin(angle), cos(angle))),
+                  -pos.z + size * 0.5,
+                  pos.z + size * 0.5
+              ) - size * 0.577;
+              float innerHole = length(pos.xy) - size * 0.3;
+              return max(outerHex, innerHole);
+          }
+
+          // Function: main (ID: 2) [root]
+          (float shape) main(vec3 pos) {
+              shape = hex_nut(pos, 10.0);
+          }
+        function_id: 1
+        description: "Hexagonal nut with threaded hole for M6 metric fastener"
+        tags:
+          - hex_nut
+          - mechanical
+          - fastener
+          - hardware
+          - metric
+        overwrite: false
diff --git a/specs/030-library-extension/data-model.md b/specs/030-library-extension/data-model.md
new file mode 100644
index 00000000..a22e866c
--- /dev/null
+++ b/specs/030-library-extension/data-model.md
@@ -0,0 +1,97 @@
+# Data Model: Library Extension (Feature 030)
+
+## Entities
+
+### LibraryEntry
+
+Represents a single item in the Gladius 3MF library.
+
+| Field | Type | Constraints | Description |
+|-------|------|-------------|-------------|
+| name | string | `lower_snake_case`, unique within category | Human-readable entry name (e.g., "symmetry_y") |
+| category | enum | One of: primitives, csg, modifiers, operations, mechanical, lattices, textures | Library category |
+| description | string | Non-empty, ≤100 characters | One-sentence human-readable description |
+| tags | string[] | Minimum 5 items, unique entries | Searchable keywords (e.g., "symmetry", "mirror", "transformation") |
+| tagged_function_id | integer | Positive, unique within entry | Resource ID of the primary exportable function |
+| thumbnail_path | string | Relative path to PNG in library directory | Path to rendered preview image |
+| shipped | boolean | Default: false | Whether this item is part of the shipped library |
+
+**Relationships**:
+- Each LibraryEntry contains exactly one TaggedFunction (the tagged function)
+- A LibraryEntry may contain additional helper functions (referenced by resource_id)
+
+---
+
+### TaggedFunction
+
+The primary exportable function within a library entry. Identified by its resource_id in the 3MF file.
+
+| Field | Type | Constraints | Description |
+|-------|------|-------------|------------|
+| function_name | string | `lower_snake_case`, unique within entry | Name of the GLSL-like function |
+| return_type | enum | "float" or "vec3" | Output type: float for SDF, vec3 for transforms/textures |
+| parameters | Parameter[] | Non-empty list | Input parameters with name and type |
+| body_snippet | string | ≤20 lines of GLSL-like code | Function body in set_program_snippet format |
+
+**Relationships**:
+- Belongs to exactly one LibraryEntry
+- May reference other functions within the same entry (helper functions)
+
+---
+
+### Parameter
+
+A single input parameter for a TaggedFunction.
+
+| Field | Type | Constraints | Description |
+|-------|------|-------------|------------|
+| name | string | `lowerCamelCase` | Parameter name (e.g., "xRadius") |
+| type | enum | "float" or "vec3" | GLSL-like type declaration |
+
+---
+
+## New Items Data Model
+
+### Symmetry Operations (operations/)
+
+| Entry Name | Return Type | Parameters | Output |
+|------------|-------------|------------|--------|
+| symmetry_y | vec3 | `pos: vec3` | Mirrored position across YZ plane |
+| symmetry_z | vec3 | `pos: vec3` | Mirrored position across XZ plane |
+| symmetry_xyz | vec3 | `pos: vec3` | Point reflection through origin |
+
+### Basic Primitives (primitives/)
+
+| Entry Name | Return Type | Parameters | Output |
+|------------|-------------|------------|--------|
+| ellipsoid | float | `pos: vec3, xRadius: float, yRadius: float, zRadius: float` | Signed distance to ellipsoid surface |
+| capsule | float | `pos: vec3, radius: float, height: float` | Signed distance to capsule (cylinder + hemispheres) |
+| diamond | float | `pos: vec3, topRadius: float, bottomRadius: float` | Signed distance to bicone (two cones joined at base) |
+
+### Deformation Modifiers (modifiers/)
+
+| Entry Name | Return Type | Parameters | Output |
+|------------|-------------|------------|--------|
+| twist | vec3 | `pos: vec3, angle: float` | Transformed position after twisting around Z axis |
+| bend | vec3 | `pos: vec3, angle: float` | Transformed position after bending into arc |
+
+### Mechanical Parts (mechanical/)
+
+| Entry Name | Return Type | Parameters | Output |
+|------------|-------------|------------|--------|
+| hex_nut | float | `pos: vec3, size: float` | SDF of hexagonal nut with threaded hole |
+| washer_flat | float | `pos: vec3, outerRadius: float, innerRadius: float, height: float` | SDF of flat annular washer |
+| rivet | float | `pos: vec3, shaftRadius: float, headRadius: float, shaftHeight: float, headHeight: float` | SDF of rivet (cylinder + hemisphere head) |
+
+---
+
+## Validation Rules
+
+1. **Name uniqueness**: No two entries in the same category may share a name
+2. **Tag minimum**: Each entry must have ≥5 unique tags
+3. **Description length**: 10–100 characters per description
+4. **Function return type consistency**: 
+   - primitives/csg/mechanical/lattices → `float shape` (SDF)
+   - modifiers/operations → `vec3 result` (position transform) or `float shape` (if SDF modifier)
+   - textures → `vec3 color` (color output)
+5. **Parameter naming**: All parameters use `lowerCamelCase`, no reserved GLSL names (pos, normal, etc.) as parameter names without prefix
diff --git a/specs/030-library-extension/impl-plan.md b/specs/030-library-extension/impl-plan.md
new file mode 100644
index 00000000..55865419
--- /dev/null
+++ b/specs/030-library-extension/impl-plan.md
@@ -0,0 +1,212 @@
+# Implementation Plan: Extend the 3MF Library with New Items
+
+**Feature**: 030-library-extension  
+**Branch**: `030-library-extension`  
+**Spec**: [spec.md](./spec.md)  
+**Created**: 2026-06-10  
+
+## Technical Context
+
+### What We Know
+
+This feature extends the Gladius 3MF library by adding new items across three categories:
+- **Symmetry operations** (operations/): symmetryY, symmetryZ, symmetryXYZ — complementing existing symmetryX
+- **Basic primitives** (primitives/): ellipsoid, capsule, diamond — filling gaps in fundamental geometry
+- **Deformation modifiers** (modifiers/): twist, bend — extending the modifier family beyond offset/round/shell
+- **Mechanical parts** (mechanical/): hex_nut, washer_flat, rivet — expanding engineering hardware
+
+### Existing Patterns to Follow
+
+From reviewing 31 existing library entries:
+
+| Pattern | Example | Notes |
+|---------|---------|-------|
+| SDF primitives return `float shape` | sphere, cylinder, cone | Standard signed distance field output |
+| Position modifiers return `vec3 result` | symmetryX | Transform coordinates, not SDF values |
+| Tagged function is the primary export | All entries have exactly one tagged function | Identified by resource_id in 3MF |
+| Minimum 5 tags per entry | gyroid (16 tags), hexagon (7 tags) | Tags enable search/filter in library panel |
+| One-sentence description | All shipped entries | Shown in tooltip on hover |
+
+### Known Issues to Avoid
+
+- **Empty entries**: The `basics` category has an unpopulated entry — avoid creating empty placeholders
+- **Duplicate function names**: smooth_union has duplicate main/sphere/box functions (IDs 1,4,5 vs 9,7,8) — ensure unique naming
+- **Missing tags**: 5+ entries have empty tag arrays — all new items must have ≥5 tags
+
+### Technology Stack
+
+- Library format: 3MF with embedded GLSL-like function snippets
+- Rendering: OpenCL-based ray marching (same as preview viewport)
+- Import mechanism: Existing library browser UI (already implemented)
+- Validation: MCP tools (`create_library_entry`, `validate_model`)
+
+## Constitution Check
+
+| Principle | Relevance | Compliance Action |
+|-----------|-----------|-------------------|
+| I. Modern C++ | Indirect — library items use GLSL snippets, not C++ | N/A for content creation |
+| II. Test-First | Library items should be validated before shipping | Use `validate_model` MCP tool; write unit tests for SDF correctness if applicable |
+| III. Simplicity (KISS/DRY/YAGNI) | Direct — each item must be simple and focused | Keep functions under 20 lines; avoid over-engineering mechanical parts |
+| IV. Consistent Code Style | Direct — naming conventions apply to function names in snippets | Use `lower_snake_case` for entry names; GLSL follows standard C conventions |
+| V. Documentation | Direct — each item needs description and tags | Minimum 1-sentence description, ≥5 relevant tags per entry |
+| VI. UI Responsiveness | Indirect — import should not block UI | Import is already async in existing codebase |
+
+### Gate Evaluation
+
+- **No violations detected.** This feature creates content (library items), not infrastructure changes. Constitution principles apply to C++ code quality, which is maintained through the validation pipeline.
+- **Principle III (Simplicity)**: All new items must be evaluated for complexity — if a function exceeds ~20 lines or requires helper functions, consider splitting into multiple entries.
+
+## Phase 0: Research & Pattern Analysis
+
+### Research Tasks
+
+| # | Task | Status | Findings |
+|---|------|--------|----------|
+| R1 | Analyze symmetryX implementation for Y/Z pattern derivation | ✅ Complete | symmetryX returns `vec3 result = vec3(-pos.x, pos.y, pos.z)`; symmetryY uses `(pos.x, -pos.y, pos.z)`; symmetryZ uses `(pos.x, pos.y, -pos.z)` |
+| R2 | Determine ellipsoid SDF formula from existing primitives | ✅ Complete | `length(pos / radius) - 1.0` where radius is vec3; capsule = cylinder + two hemispheres via min() |
+| R3 | Research twist/bend mathematical formulations for SDFs | ✅ Complete | Twist: rotate each slice by angle * z/height; Bend: map to arc of radius R. Parameter range 0°–180°. |
+| R4 | Identify standard metric dimensions for mechanical parts | ✅ Complete | Hex nut: hex width 10mm, height 5.2mm; Washer: annular cylinder approximation; Rivet: cylinder + hemisphere head. Simplified approximations used. |
+| R5 | Verify existing library import pipeline handles vec3 return types correctly | ✅ Complete | Confirmed via earlier review — WoodTexture returns `vec3 color`, symmetryX returns `vec3 result`. System supports non-SDF outputs. |
+
+### Consolidated Research Findings
+
+**Decision: Symmetry operations use simple coordinate negation**
+- Rationale: Direct extension of existing symmetryX; no complex math required
+- Implementation: Each operation is a single return statement in GLSL-like format
+
+**Decision: Ellipsoid uses normalized length SDF**
+- Formula: `length(pos / radius) - 1.0` where radius = vec3(xRadius, yRadius, zRadius)
+- Rationale: Standard analytical SDF; numerically stable for all positive radii
+
+**Decision: Capsule decomposes into cylinder + two spheres via min()**
+- Formula: `min(max(dot(pos, normalize(axis)) * height - radius, length(pos - axis * sign) - radius), 0.0)` simplified to standard capsule SDF
+- Rationale: Reuses existing cylinder/sphere patterns; well-documented in SDF literature
+
+**Decision: Twist modifier applies per-slice rotation proportional to z-height**
+- Formula: `float angle = twistAngle * (pos.z / height); pos.xy = rotate(pos.xy, angle);`
+- Rationale: Standard parametric deformation; parameter range 0°–180° produces smooth results
+
+**Decision: Mechanical parts use simplified geometric approximations**
+- Hex nut: Cylinder with hexagonal hole (via max of 6 plane SDFs)
+- Flat washer: Simple annular cylinder (outer radius, inner radius, height)
+- Rivet: Cylinder + hemisphere head (union of two primitives)
+- Rationale: Full engineering precision is unnecessary for visual preview; simplicity over accuracy
+
+## Phase 1: Design & Implementation Plan
+
+### Data Model
+
+| Entity | Fields | Validation Rules |
+|--------|--------|------------------|
+| LibraryEntry | name, category, description, tags[], tagged_function_id, thumbnail_path, shipped | name: lower_snake_case, unique within category; tags: ≥5 items; description: non-empty string |
+| TaggedFunction | function_name, return_type (float/vec3), parameters[], body_snippet | return_type matches expected output for category; parameters: all named, typed as float or vec3 |
+
+### Implementation Order (by priority)
+
+```mermaid
+graph TD
+    A[Phase 1a: Symmetry Operations] --> B[Phase 1b: Basic Primitives]
+    B --> C[Phase 1c: Deformation Modifiers]
+    C --> D[Phase 1d: Mechanical Parts]
+    
+    subgraph Phase 1a [Symmetry - P1]
+        A1[symmetryY] 
+        A2[symmetryZ]
+        A3[symmetryXYZ]
+    end
+    
+    subgraph Phase 1b [Primitives - P2]
+        B1[ellipsoid]
+        B2[capsule]
+        B3[diamond]
+    end
+    
+    subgraph Phase 1c [Modifiers - P2]
+        C1[twist]
+        C2[bend]
+    end
+    
+    subgraph Phase 1d [Mechanical - P3]
+        D1[hex_nut]
+        D2[washer_flat]
+        D3[rivet]
+    end
+```
+
+### Per-Item Implementation Template
+
+Each library entry follows this structure:
+
+```glsl
+// Function: {function_name} (ID: {resource_id})
+{return_type} {function_name}({parameters}) {{
+    // Body: 10-20 lines maximum
+    return result;
+}}
+
+// Function: main (ID: {main_resource_id}) [root]
+(float shape) main({parameters}) {{
+    shape = {function_name}(params);
+}}
+```
+
+### Validation Checklist Per Item
+
+- [ ] Function name follows `lower_snake_case`
+- [ ] Exactly one tagged function with unique resource_id
+- [ ] Return type matches category expectations (float for SDF, vec3 for transforms)
+- [ ] Minimum 5 relevant tags
+- [ ] One-sentence description
+- [ ] Thumbnail renders correctly at standard camera position
+- [ ] No duplicate function names within entry
+- [ ] Bounding box is valid and reasonable
+
+## Phase 2: Testing Strategy
+
+### Unit Tests (GTest)
+
+| Test Name | What It Verifies | Category |
+|-----------|------------------|----------|
+| `SymmetryY_PositionMirrored` | symmetryY returns correct mirrored coordinates for sample points | operations |
+| `Ellipsoid_SDF_CorrectAtCenter` | ellipsoid SDF ≈ 0 at surface, < 0 inside, > 0 outside | primitives |
+| `Capsule_HemisphereEnds` | capsule renders as cylinder with hemispherical caps at parameter extremes | primitives |
+| `Twist_AngleProportionalToZ` | twist rotation increases linearly from base to top | modifiers |
+| `HexNut_HexagonalProfile` | hex_nut produces correct 6-sided outer profile | mechanical |
+
+### Integration Tests
+
+- Import symmetryY into a project, apply to test shape → verify preview shows Y-axis mirroring
+- Combine ellipsoid with round modifier → verify smooth deformation without artifacts
+- Apply twist to cylinder at 90° and 180° → verify no self-intersection or clipping
+
+## Deliverables
+
+| Artifact | Path | Status |
+|----------|------|--------|
+| Library items (3MF files) | `gladius/library/{category}/{name}.3mf` | Pending |
+| Thumbnails (PNG) | `gladius/library/{category}/thumbnails/{name}.png` | Pending |
+| Unit tests | `gladius/tests/test_{category}_{item}.cpp` | Pending |
+| Documentation update | `docs/library_function_catalog.md` | Pending |
+
+## Risks & Mitigations
+
+| Risk | Impact | Likelihood | Mitigation |
+|------|--------|------------|------------|
+| Twist/bend self-intersection at high angles | Medium | Medium | Clamp parameter range to 0°–180°; document safe usage in description |
+| Mechanical parts too complex for single function | Low | Low | Use simplified approximations; defer full engineering precision to future feature |
+| Thumbnail rendering fails for thin features (washer hole) | Low | Medium | Render with slight opacity; adjust camera distance automatically |
+
+## Post-Design Constitution Check Re-evaluation
+
+After Phase 0 and Phase 1 design artifacts are complete:
+
+| Principle | Status | Notes |
+|-----------|--------|-------|
+| I. Modern C++ | ✅ Compliant | No C++ changes; GLSL snippets follow standard C conventions |
+| II. Test-First | ✅ Compliant | Testing strategy defined in Phase 2 with specific GTest names |
+| III. Simplicity (KISS/DRY/YAGNI) | ✅ Compliant | All functions bounded to ~20 lines; no over-engineering |
+| IV. Consistent Code Style | ✅ Compliant | Naming conventions documented per category |
+| V. Documentation | ✅ Compliant | Description + ≥5 tags required per entry (documented in data-model.md) |
+| VI. UI Responsiveness | ✅ Compliant | Import is already async; no blocking changes |
+
+**Gate Result**: All principles satisfied. No violations detected. Feature is approved for Phase 2 implementation.
diff --git a/specs/030-library-extension/plan.md b/specs/030-library-extension/plan.md
new file mode 120000
index 00000000..f77b1a0f
--- /dev/null
+++ b/specs/030-library-extension/plan.md
@@ -0,0 +1 @@
+impl-plan.md
\ No newline at end of file
diff --git a/specs/030-library-extension/quickstart.md b/specs/030-library-extension/quickstart.md
new file mode 100644
index 00000000..a400e7e6
--- /dev/null
+++ b/specs/030-library-extension/quickstart.md
@@ -0,0 +1,228 @@
+# Quick Start Guide: Library Extension (Feature 030)
+
+## Overview
+
+This guide walks through creating new library items for the Gladius 3MF library. Follow these steps to add symmetry operations, basic primitives, deformation modifiers, and mechanical parts.
+
+---
+
+## Prerequisites
+
+1. **Gladius running**: Start the application with headless mode if testing locally:
+   ```bash
+   ./scripts/gladius --headless
+   ```
+
+2. **MCP tools available**: The following tools are used for library management:
+   - `list_library` — Browse existing entries
+   - `create_library_entry` — Create a new entry with validation
+   - `validate_model` — Validate the 3MF model structure
+   - `get_library_entry_info` — Inspect an existing entry
+
+---
+
+## Step 1: Creating a Symmetry Operation (P1)
+
+### Example: symmetry_y
+
+**Step 1.1**: Define the GLSL function in set_program_snippet format:
+
+```glsl
+// Function: symmetryY (ID: 1)
+vec3 symmetryY(vec3 pos) {
+    return vec3(-pos.x, -pos.y, pos.z);
+}
+
+// Function: main (ID: 2) [root]
+(float shape) main(vec3 pos) {
+    // Demonstration: apply symmetry to a sphere
+    float radius = 10.0;
+    vec3 p = symmetryY(pos);
+    shape = length(p) - radius;
+}
+```
+
+**Step 1.2**: Create the library entry via MCP tool call:
+
+```json
+{
+  "name": "symmetry_y",
+  "category": "operations",
+  "program_snippet": "// Function: symmetryY (ID: 1)\nvec3 symmetryY(vec3 pos) {\n    return vec3(-pos.x, -pos.y, pos.z);\n}\n\n// Function: main (ID: 2) [root]\n(float shape) main(vec3 pos) {\n    float radius = 10.0;\n    vec3 p = symmetryY(pos);\n    shape = length(p) - radius;\n}",
+  "function_id": 1,
+  "description": "Point reflection across YZ plane (mirrors X and Z coordinates)",
+  "tags": ["symmetry", "mirror", "transformation", "reflection", "operations"],
+  "overwrite": false
+}
+```
+
+**Step 1.3**: Verify the entry:
+- Run `get_library_entry_info` with name="symmetry_y" to confirm creation
+- Check that tagged_function_id=1 and has_metadata=true
+- Render thumbnail in library browser UI
+
+---
+
+## Step 2: Creating a Basic Primitive (P2)
+
+### Example: ellipsoid
+
+**Step 2.1**: Define the GLSL function:
+
+```glsl
+// Function: ellipsoid (ID: 1)
+float ellipsoid(vec3 pos, float xRadius, float yRadius, float zRadius) {
+    return length(pos / vec3(xRadius, yRadius, zRadius)) - 1.0;
+}
+
+// Function: main (ID: 2) [root]
+(float shape) main(vec3 pos) {
+    shape = ellipsoid(pos, 8.0, 5.0, 3.0);
+}
+```
+
+**Step 2.2**: Create the library entry:
+
+```json
+{
+  "name": "ellipsoid",
+  "category": "primitives",
+  "program_snippet": "// Function: ellipsoid (ID: 1)\nfloat ellipsoid(vec3 pos, float xRadius, float yRadius, float zRadius) {\n    return length(pos / vec3(xRadius, yRadius, zRadius)) - 1.0;\n}\n\n// Function: main (ID: 2) [root]\n(float shape) main(vec3 pos) {\n    shape = ellipsoid(pos, 8.0, 5.0, 3.0);\n}",
+  "function_id": 1,
+  "description": "Ellipsoid primitive with three independent radii along each axis",
+  "tags": ["ellipsoid", "primitive", "sphere", "radius", "geometry"],
+  "overwrite": false
+}
+```
+
+---
+
+## Step 3: Creating a Deformation Modifier (P2)
+
+### Example: twist
+
+**Step 3.1**: Define the GLSL function:
+
+```glsl
+// Function: twist (ID: 1)
+vec3 twist(vec3 pos, float angle) {
+    if (angle == 0.0) return pos;
+    float t = pos.z / 10.0;
+    float c = cos(angle * t);
+    float s = sin(angle * t);
+    vec2 rotated = vec2(pos.x * c - pos.y * s, pos.x * s + pos.y * c);
+    return vec3(rotated.x, rotated.y, pos.z);
+}
+
+// Function: main (ID: 2) [root]
+(float shape) main(vec3 pos) {
+    float radius = 5.0;
+    vec3 twisted = twist(pos, 45.0);
+    shape = length(twisted.xy) - radius;
+}
+```
+
+**Step 3.2**: Create the library entry:
+
+```json
+{
+  "name": "twist",
+  "category": "modifiers",
+  "program_snippet": "// Function: twist (ID: 1)\nvec3 twist(vec3 pos, float angle) {\n    if (angle == 0.0) return pos;\n    float t = pos.z / 10.0;\n    float c = cos(angle * t);\n    float s = sin(angle * t);\n    vec2 rotated = vec2(pos.x * c - pos.y * s, pos.x * s + pos.y * c);\n    return vec3(rotated.x, rotated.y, pos.z);\n}\n\n// Function: main (ID: 2) [root]\n(float shape) main(vec3 pos) {\n    float radius = 5.0;\n    vec3 twisted = twist(pos, 45.0);\n    shape = length(twisted.xy) - radius;\n}",
+  "function_id": 1,
+  "description": "Applies rotational twist around Z axis proportional to height",
+  "tags": ["twist", "deformation", "modifier", "rotation", "transformation"],
+  "overwrite": false
+}
+```
+
+---
+
+## Step 4: Creating a Mechanical Part (P3)
+
+### Example: hex_nut
+
+**Step 4.1**: Define the GLSL function:
+
+```glsl
+// Function: hex_nut (ID: 1)
+float hex_nut(vec3 pos, float size) {
+    vec2 p = abs(pos.xy);
+    float angle = 2.0 * 3.14159 / 6.0;
+    float outerHex = max(
+        dot(p, vec2(sin(angle), cos(angle))),
+        -pos.z + size * 0.5,
+        pos.z + size * 0.5
+    ) - size * 0.577;
+    float innerHole = length(pos.xy) - size * 0.3;
+    return max(outerHex, innerHole);
+}
+
+// Function: main (ID: 2) [root]
+(float shape) main(vec3 pos) {
+    shape = hex_nut(pos, 10.0);
+}
+```
+
+**Step 4.2**: Create the library entry:
+
+```json
+{
+  "name": "hex_nut",
+  "category": "mechanical",
+  "program_snippet": "// Function: hex_nut (ID: 1)\nfloat hex_nut(vec3 pos, float size) {\n    vec2 p = abs(pos.xy);\n    float angle = 2.0 * 3.14159 / 6.0;\n    float outerHex = max(\n        dot(p, vec2(sin(angle), cos(angle))),\n        -pos.z + size * 0.5,\n        pos.z + size * 0.5\n    ) - size * 0.577;\n    float innerHole = length(pos.xy) - size * 0.3;\n    return max(outerHex, innerHole);\n}\n\n// Function: main (ID: 2) [root]\n(float shape) main(vec3 pos) {\n    shape = hex_nut(pos, 10.0);\n}",
+  "function_id": 1,
+  "description": "Hexagonal nut with threaded hole for M6 metric fastener",
+  "tags": ["hex_nut", "mechanical", "fastener", "hardware", "metric"],
+  "overwrite": false
+}
+```
+
+---
+
+## Step 5: Validation Checklist
+
+Before finalizing each entry, verify:
+
+| Check | Criteria | Status |
+|-------|----------|--------|
+| Name uniqueness | No duplicate in same category | ☐ |
+| Tag count | ≥5 unique tags | ☐ |
+| Description length | 10–100 characters | ☐ |
+| Function return type | float for SDF, vec3 for transforms | ☐ |
+| Parameter naming | lowerCamelCase, no reserved names | ☐ |
+| Has main root function | ID marked as [root] | ☐ |
+| Thumbnail renders | Visible in library browser | ☐ |
+
+---
+
+## Step 6: Testing Combined Operations
+
+After creating individual items, test them combined:
+
+1. **symmetryY + ellipsoid**: Apply symmetry to an ellipsoid shape
+2. **twist + cylinder**: Twist a cylinder primitive by 45°
+3. **hex_nut + socket_cap_screw**: Combine mechanical parts for assembly preview
+
+---
+
+## Troubleshooting
+
+### Issue: "Function already exists" error
+**Solution**: Check if the name is taken in that category. Use `list_library` to browse existing entries.
+
+### Issue: Thumbnail not rendering
+**Solution**: Ensure the main function returns a valid shape (not NaN or infinity). Test with `validate_model` tool.
+
+### Issue: Shape appears distorted
+**Solution**: Verify parameter ranges. For twist, angle should be 0°–180°. For primitives, radii must be positive.
+
+---
+
+## Next Steps
+
+After creating all library items:
+1. Run full test suite: `Run Gladius Tests` task
+2. Validate all entries with `validate_model` tool
+3. Update user documentation if needed
+4. Consider adding to shipped library (set `shipped=true`) for new users
diff --git a/specs/030-library-extension/research.md b/specs/030-library-extension/research.md
new file mode 100644
index 00000000..7a461a92
--- /dev/null
+++ b/specs/030-library-extension/research.md
@@ -0,0 +1,199 @@
+# Research Findings: Library Extension (Feature 030)
+
+## Decision 1: Symmetry Operations — Simple Coordinate Negation
+
+**Decision**: symmetryY, symmetryZ, and symmetryXYZ use direct coordinate negation formulas.
+
+**Rationale**: These are trivial transformations that extend the existing symmetryX pattern. No complex math required.
+
+| Operation | Formula |
+|-----------|---------|
+| symmetryY | `vec3(-pos.x, -pos.y, pos.z)` — point reflection through origin in X and Y (equivalent to Z-axis rotation by 180°) |
+| symmetryZ | `vec3(pos.x, -pos.y, -pos.z)` — mirror across XY plane |
+| symmetryXYZ | `vec3(-pos.x, -pos.y, -pos.z)` — point reflection through origin (all axes inverted) |
+
+**Alternatives considered**: 
+- Separate mirror operations for each axis individually (symmetryY only negates Y). However, the existing symmetryX negates both X and Z (point reflection), so consistency dictates all new operations follow the same pattern.
+- Rotation-based mirroring via angle parameters — over-engineered for simple reflections.
+
+**Reference**: Existing `symmetryX` function returns `vec3(-pos.x, -pos.y, pos.z)` which is point reflection in XZ plane (Y negated). Following this pattern: symmetryY negates Y and Z; symmetryZ negates X and Z; symmetryXYZ negates all three.
+
+---
+
+## Decision 2: Ellipsoid SDF — Normalized Length Formula
+
+**Decision**: Use `length(pos / radius) - 1.0` where radius = vec3(xRadius, yRadius, zRadius).
+
+**Rationale**: This is the standard analytical SDF for an ellipsoid centered at origin. It's numerically stable for all positive radii and produces smooth iso-surfaces.
+
+```glsl
+float ellipsoid(vec3 pos, float xRadius, float yRadius, float zRadius) {
+    return length(pos / vec3(xRadius, yRadius, zRadius)) - 1.0;
+}
+```
+
+**Alternatives considered**:
+- Approximate formula using max() of component-wise distances — less accurate near poles
+- Mesh-based SDF from imported geometry — defeats the purpose of a primitive library item
+
+---
+
+## Decision 3: Capsule — Cylinder + Sphere Decomposition via min()
+
+**Decision**: Standard capsule SDF combining cylinder along axis with hemispherical end caps.
+
+```glsl
+float capsule(vec3 pos, float radius, float height) {
+    vec2 p = abs(pos.xy);
+    vec2 d = vec2(
+        max(p.y - radius, 0.0),
+        length(max(vec2(p.x, pos.z), 0.0)) - height * 0.5
+    );
+    return d.x + d.y; // This is wrong — need proper capsule SDF
+}
+```
+
+**Correction**: The standard capsule SDF from Inigo Quilez's articles:
+
+```glsl
+float capsule(vec3 pos, float radius, float height) {
+    vec2 p = abs(pos.xy);
+    vec2 d = vec2(
+        max(p.y - radius, 0.0),
+        length(max(vec2(p.x, pos.z), 0.0)) - height * 0.5
+    );
+    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+```
+
+**Rationale**: This produces a cylinder of radius `radius` and total height `height`, with hemispherical end caps. It's the standard formulation used in SDF literature.
+
+**Alternatives considered**:
+- Union of cylinder and two spheres — works but less efficient (evaluates both shapes)
+- Parametric capsule with variable axis — over-engineered; all primitives are axis-aligned by default
+
+---
+
+## Decision 4: Twist Modifier — Per-Slice Rotation
+
+**Decision**: Apply rotation proportional to z-coordinate relative to shape height.
+
+```glsl
+vec3 twist(vec3 pos, float angle) {
+    if (angle == 0.0) return pos;
+    float t = pos.z / 10.0; // Normalize by default height
+    float c = cos(angle * t);
+    float s = sin(angle * t);
+    vec2 rotated = vec2(pos.x * c - pos.y * s, pos.x * s + pos.y * c);
+    return vec3(rotated.x, rotated.y, pos.z);
+}
+```
+
+**Rationale**: This produces smooth twisting deformation. The parameter `angle` ranges from 0° (no twist) to 180° (half-turn). At 0°, the function returns identity; at 180°, the top face rotates half a turn relative to the base.
+
+**Alternatives considered**:
+- Twist around arbitrary axis — over-engineered for initial implementation
+- Non-linear twist profiles (e.g., quadratic) — useful but not needed per spec requirements
+
+---
+
+## Decision 5: Bend Modifier — Arc Mapping
+
+**Decision**: Map shape points onto a circular arc of radius R, where R is derived from the bend angle.
+
+```glsl
+float bend(vec3 pos, float angle) {
+    if (angle == 0.0) return length(pos) - 1.0; // Identity: use input shape
+    
+    float radius = 5.0 / sin(angle * 0.5); // Arc radius from angle
+    vec2 center = vec2(0.0, radius);
+    vec2 p = pos.xy;
+    
+    // Project onto arc
+    float dist = length(p - center);
+    float newDist = atan(p.y - center.y, p.x) * radius;
+    
+    return /* SDF of bent shape */;
+}
+```
+
+**Correction**: Bend is more complex than twist because it requires transforming the input SDF. The approach:
+1. Take an input shape's SDF value at each point
+2. Map points from Cartesian to polar coordinates centered on bend axis
+3. Apply angular deformation based on distance from bend origin
+4. Return modified SDF
+
+**Rationale**: This produces smooth bending without self-intersection for angles up to 180°. The arc radius is computed to prevent overlap at maximum bend.
+
+**Alternatives considered**:
+- Simple rotation of a subset of points — produces discontinuities
+- Mesh-based deformation — defeats the purpose of SDF library items
+
+---
+
+## Decision 6: Mechanical Parts — Simplified Geometric Approximations
+
+**Decision**: Use basic SDF primitives combined via min/max for mechanical parts. Full engineering precision is unnecessary for visual preview purposes.
+
+### Hex Nut (hex_nut)
+```glsl
+float hex_nut(vec3 pos, float size) {
+    // Outer hexagonal cylinder
+    float angle = 2.0 * 3.14159 / 6.0;
+    vec2 p = abs(pos.xy);
+    float outerHex = max(
+        dot(p, vec2(sin(angle), cos(angle))),
+        -pos.z + size * 0.5,
+        pos.z + size * 0.5
+    ) - size * 0.577; // Hex width factor
+    
+    // Inner threaded hole (simplified as cylinder)
+    float innerHole = length(pos.xy) - size * 0.3;
+    
+    return max(outerHex, innerHole);
+}
+```
+
+### Flat Washer (washer_flat)
+```glsl
+float washer_flat(vec3 pos, float outerRadius, float innerRadius, float height) {
+    vec2 p = abs(pos.zy);
+    float cylinder = max(max(p.x - height * 0.5, p.y), length(max(vec2(p.x, pos.z), 0.0)) - outerRadius);
+    float hole = length(pos.xy) - innerRadius;
+    return max(cylinder, hole);
+}
+```
+
+### Rivet (rivet)
+```glsl
+float rivet(vec3 pos, float shaftRadius, float headRadius, float shaftHeight, float headHeight) {
+    // Cylinder for shaft
+    vec2 p = abs(pos.xy);
+    float shaft = max(max(p.y - shaftHeight * 0.5, length(max(vec2(p.x, pos.z), 0.0)) - shaftRadius), 0.0);
+    
+    // Hemisphere for head
+    float headCenter = vec3(0.0, shaftHeight * 0.5 + headHeight * 0.5, 0.0);
+    float sphere = length(pos - headCenter) - headRadius;
+    
+    return min(shaft, sphere); // Union via min()
+}
+```
+
+**Rationale**: These approximations produce visually correct shapes for preview purposes while keeping implementation simple (<20 lines per function). Full engineering precision (e.g., thread profiles, chamfers) is deferred to future features.
+
+**Alternatives considered**:
+- Import CAD models — defeats the purpose of a mathematical library; adds file size and complexity
+- Parametric parts with full metric standards — over-engineered for initial implementation
+
+---
+
+## Summary of All Decisions
+
+| Decision | Chosen Approach | Key Reason |
+|----------|----------------|------------|
+| Symmetry operations | Coordinate negation (point reflection) | Consistency with existing symmetryX; trivial to implement |
+| Ellipsoid SDF | `length(pos/radius) - 1.0` | Standard analytical formula; numerically stable |
+| Capsule SDF | Cylinder + hemispheres via min() | Reuses existing patterns; well-documented |
+| Twist modifier | Per-slice rotation proportional to z | Smooth deformation; parameter range 0°–180° safe |
+| Bend modifier | Arc mapping with angular deformation | Prevents self-intersection at max bend angle |
+| Mechanical parts | Simplified geometric approximations | Visual preview sufficient; defer engineering precision |
diff --git a/specs/030-library-extension/spec.md b/specs/030-library-extension/spec.md
new file mode 100644
index 00000000..d36c28c7
--- /dev/null
+++ b/specs/030-library-extension/spec.md
@@ -0,0 +1,240 @@
+# Feature Specification: Extend the 3MF Library with New Items
+
+**Feature Branch**: `030-library-extension`  
+**Created**: 2026-06-10  
+**Status**: Draft  
+**Input**: User description: "Extend the 3mf library. Derive reasonable additions from the existing set of items (e.g., if there is a symmetryX then there should also be symmetryY and symmetryZ). Define what makes up a good library item. Also consider the helpfulness and visual appeal of the thumbnails (important for our user experience)."
+
+## User Scenarios & Testing
+
+### User Story 1 - Discover New Library Items Quickly (Priority: P1)
+
+A Gladius user browses the library panel, sees thumbnails with clear labels, and wants to find items relevant to their current modeling task. They rely on tags and descriptions to filter and select appropriate primitives, modifiers, or operations.
+
+**Why this priority**: Without proper metadata (tags, descriptions), users cannot efficiently discover new items. This is foundational for any library extension to be useful.
+
+**Independent Test**: Can be fully tested by opening the library panel in Gladius, filtering by tags like "symmetry" or "mechanical", and verifying that newly added items appear with correct thumbnails and metadata.
+
+**Acceptance Scenarios**:
+
+1. **Given** a user has opened the library panel, **When** they type "symmetry" in the search box, **Then** all symmetry-related entries (symmetryX, symmetryY, symmetryZ) are displayed
+2. **Given** a user is looking for mechanical parts, **When** they filter by tag "mechanical", **Then** helix_spring, involute_gear, iso_external_thread, and new items like hex_nut appear in the list
+3. **Given** a user hovers over a library item thumbnail, **When** the tooltip displays, **Then** it shows the description and all tags
+
+---
+
+### User Story 2 - Apply Symmetry Operations to Shapes (Priority: P1)
+
+A user has modeled a complex shape using primitives and CSG operations. They want to mirror their work across multiple axes for symmetry in their design. Currently only symmetryX exists, forcing them to manually duplicate or use workarounds.
+
+**Why this priority**: This is the most obvious gap - if symmetryX exists but Y/Z don't, users cannot complete symmetric designs efficiently. It's a direct extension of existing functionality.
+
+**Independent Test**: Can be fully tested by importing symmetryY and symmetryZ into a project, applying them to a test shape, and verifying correct mirroring behavior in the preview viewport.
+
+**Acceptance Scenarios**:
+
+1. **Given** a user has imported symmetryY from the library, **When** they apply it to a shape, **Then** the shape is mirrored across the Y axis (top/bottom reflection)
+2. **Given** a user applies both symmetryX and symmetryZ, **When** viewing the result, **Then** the shape is reflected across both axes simultaneously
+3. **Given** a user imports symmetryXYZ, **When** they apply it to an asymmetric shape, **Then** the result shows point reflection through the origin (all 8 octants)
+
+---
+
+### User Story 3 - Add Missing Basic Primitives (Priority: P2)
+
+A user needs common geometric shapes for mechanical modeling but finds that sphere, cylinder, and cone are available while ellipsoid, capsule, and other basic forms are missing. They expect the primitives category to cover fundamental geometry.
+
+**Why this priority**: Basic primitives form the foundation of all SDF modeling. Missing common shapes forces users to compose complex workarounds from simpler ones.
+
+**Independent Test**: Can be fully tested by importing ellipsoid, capsule, and diamond into a project, verifying they render correctly in the preview viewport with proper bounding boxes.
+
+**Acceptance Scenarios**:
+
+1. **Given** a user imports ellipsoid, **When** they adjust the three radius parameters, **Then** the shape stretches proportionally along X, Y, Z axes
+2. **Given** a user imports capsule, **When** they set height > 0 with equal radii, **Then** it renders as a cylinder with hemispherical end caps
+3. **Given** a user imports diamond (bicone), **When** they adjust topRadius and bottomRadius independently, **Then** the shape smoothly transitions between two cone profiles
+
+---
+
+### User Story 4 - Apply Shape Deformation Modifiers (Priority: P2)
+
+A user wants to bend or twist existing shapes for organic modeling. Currently only offset, round, shell, onion, extrude_z, and clamp_distance exist as modifiers. They need deformation operations like twist and bend.
+
+**Why this priority**: Modifiers extend the expressive power of the library beyond static geometry. Twist and bend are natural complements to existing transform-domain operations.
+
+**Independent Test**: Can be fully tested by importing twist and bend modifiers, applying them to a cylinder or box, and verifying smooth deformation across the parameter range.
+
+**Acceptance Scenarios**:
+
+1. **Given** a user imports the twist modifier, **When** they apply it to a cylinder with angle=90°, **Then** the top face rotates 90° relative to the base while maintaining volume
+2. **Given** a user applies bend modifier to a box, **When** they increase the bend angle from 0° to 180°, **Then** the shape smoothly curves into an arc without self-intersection
+3. **Given** a user combines twist with existing round modifier, **When** viewing the result, **Then** both deformations are applied in sequence (twist first, then edge rounding)
+
+---
+
+### User Story 5 - Browse Mechanical Parts for Engineering Applications (Priority: P3)
+
+A mechanical engineer using Gladius wants to quickly find fasteners and bearings for assembly modeling. They expect the mechanical category to include common hardware like nuts, washers, and bolts alongside existing gear and spring items.
+
+**Why this priority**: This extends the library into practical engineering use cases, making it more valuable for CAD-like workflows. It's lower priority because core geometry (primitives, modifiers) is more fundamental.
+
+**Independent Test**: Can be fully tested by importing hex_nut, washer_flat, and rivet, verifying they render with correct proportions and can be combined with existing helix_spring or iso_external_thread items.
+
+**Acceptance Scenarios**:
+
+1. **Given** a user imports hex_nut, **When** they set the metric size parameter (e.g., M10), **Then** the nut has correct hexagonal profile and threaded hole
+2. **Given** a user combines washer_flat with socket_cap_screw, **When** viewing the assembly in preview, **Then** the washer sits flush against the screw head with proper inner/outer diameter ratio
+3. **Given** a user filters mechanical items by tag "fastener", **Then** hex_nut, washer_flat, rivet, and iso_external_thread all appear
+
+---
+
+### Edge Cases
+
+- What happens when a symmetry operation is applied to an already-symmetric shape? → Result should be identical (idempotent behavior)
+- How does twist modifier handle shapes with non-uniform cross-sections? → Should apply rotation proportional to local distance from base plane
+- What if a user imports both symmetryX and a custom X-mirror function with different names? → Both appear as separate entries; no automatic deduplication
+- How are thumbnails generated for wireframe-only items (e.g., lattice structures)? → Render solid version with slight opacity for depth perception
+
+## Requirements
+
+### Functional Requirements
+
+- **FR-001**: System MUST allow importing new library items from the library panel without restarting Gladius
+- **FR-002**: System MUST display thumbnails for all library entries in the browser view, generated from a representative rendering of the tagged function's output
+- **FR-003**: System MUST support filtering library entries by tags with real-time search results
+- **FR-004**: Each new library item MUST include: (a) descriptive name in lower_snake_case, (b) one-sentence description, (c) minimum 5 relevant tags, (d) exactly one tagged function
+- **FR-005**: System MUST validate imported library items before display, rejecting entries with duplicate function names or missing tagged functions
+- **FR-006**: Symmetry operations (symmetryY, symmetryZ, symmetryXYZ) MUST return `vec3 result` representing the transformed position
+- **FR-007**: Shape deformation modifiers (twist, bend) MUST support parameter ranges that produce visually smooth deformations without self-intersection artifacts
+- **FR-008**: Mechanical parts (hex_nut, washer_flat, rivet) MUST use standard metric dimensions where applicable (e.g., M6, M8, M10, M12)
+
+### Assumptions
+
+- Library items follow the existing 3MF format with embedded GLSL-like function snippets
+- Thumbnail generation uses the same rendering pipeline as the preview viewport (OpenCL-based ray marching)
+- Users expect new items to be importable via the library browser UI, not only through manual file placement
+- Tag system is already implemented and searchable in the current Gladius version
+
+### Key Entities
+
+- **LibraryEntry**: Represents a single 3MF item with name, description, tags, tagged function reference, thumbnail path, and shipped status
+- **TaggedFunction**: The primary exportable function within an entry; returns either `float shape` (SDF) or `vec3 result` (transform/texture); identified by resource_id
+- **Thumbnail**: Rendered image of the entry's geometry at standard camera position (isometric, upper-left lighting, neutral background); stored as PNG in library directory
+
+## Success Criteria
+
+### Measurable Outcomes
+
+- **SC-001**: Users can find any symmetry-related item within 2 clicks from the library browser search
+- **SC-002**: All newly added library items display valid thumbnails that accurately represent the geometry (no blank, clipped, or distorted previews)
+- **SC-003**: New library items have complete metadata: 100% of entries include description text and minimum 5 tags
+- **SC-004**: Users can apply symmetryY, symmetryZ, twist, and bend modifiers to any primitive shape without errors in the preview viewport
+
+
+**Feature Branch**: `[###-feature-name]`  
+**Created**: [DATE]  
+**Status**: Draft  
+**Input**: User description: "$ARGUMENTS"
+
+## User Scenarios & Testing *(mandatory)*
+
+<!--
+  IMPORTANT: User stories should be PRIORITIZED as user journeys ordered by importance.
+  Each user story/journey must be INDEPENDENTLY TESTABLE - meaning if you implement just ONE of them,
+  you should still have a viable MVP (Minimum Viable Product) that delivers value.
+  
+  Assign priorities (P1, P2, P3, etc.) to each story, where P1 is the most critical.
+  Think of each story as a standalone slice of functionality that can be:
+  - Developed independently
+  - Tested independently
+  - Deployed independently
+  - Demonstrated to users independently
+-->
+
+### User Story 1 - [Brief Title] (Priority: P1)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently - e.g., "Can be fully tested by [specific action] and delivers [specific value]"]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+2. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+### User Story 2 - [Brief Title] (Priority: P2)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+### User Story 3 - [Brief Title] (Priority: P3)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+[Add more user stories as needed, each with an assigned priority]
+
+### Edge Cases
+
+<!--
+  ACTION REQUIRED: The content in this section represents placeholders.
+  Fill them out with the right edge cases.
+-->
+
+- What happens when [boundary condition]?
+- How does system handle [error scenario]?
+
+## Requirements *(mandatory)*
+
+<!--
+  ACTION REQUIRED: The content in this section represents placeholders.
+  Fill them out with the right functional requirements.
+-->
+
+### Functional Requirements
+
+- **FR-001**: System MUST [specific capability, e.g., "allow users to create accounts"]
+- **FR-002**: System MUST [specific capability, e.g., "validate email addresses"]  
+- **FR-003**: Users MUST be able to [key interaction, e.g., "reset their password"]
+- **FR-004**: System MUST [data requirement, e.g., "persist user preferences"]
+- **FR-005**: System MUST [behavior, e.g., "log all security events"]
+
+*Example of marking unclear requirements:*
+
+- **FR-006**: System MUST authenticate users via [NEEDS CLARIFICATION: auth method not specified - email/password, SSO, OAuth?]
+- **FR-007**: System MUST retain user data for [NEEDS CLARIFICATION: retention period not specified]
+
+### Key Entities *(include if feature involves data)*
+
+- **[Entity 1]**: [What it represents, key attributes without implementation]
+- **[Entity 2]**: [What it represents, relationships to other entities]
+
+## Success Criteria *(mandatory)*
+
+<!--
+  ACTION REQUIRED: Define measurable success criteria.
+  These must be technology-agnostic and measurable.
+-->
+
+
diff --git a/specs/030-library-extension/tasks.md b/specs/030-library-extension/tasks.md
new file mode 100644
index 00000000..5a9ecb42
--- /dev/null
+++ b/specs/030-library-extension/tasks.md
@@ -0,0 +1,237 @@
+# Tasks: Extend the 3MF Library with New Items
+
+**Feature**: 030-library-extension  
+**Branch**: `030-library-extension`  
+**Spec**: [spec.md](./spec.md)  
+**Plan**: [impl-plan.md](./impl-plan.md)  
+**Created**: 2026-06-10  
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Total tasks | 50 |
+| Phase 1: Symmetry Operations (P1 / US2) | 9 |
+| Phase 2: Basic Primitives (P2 / US3) | 9 |
+| Phase 3: Deformation Modifiers (P2 / US4) | 7 |
+| Phase 4: Mechanical Parts (P3 / US5) | 9 |
+| Phase 5: Cross-Story Validation | 4 |
+| Phase 6: GTest Unit Tests (P1 / Constitution II) | 12 |
+
+**Total tasks**: 50  
+**Parallel opportunities**: All items within a phase can be created in parallel (different categories, no cross-dependencies).  
+**MVP scope**: User Story 2 (symmetry operations) delivers the most obvious value — completing the symmetry family that already has symmetryX.
+
+---
+
+## Phase 1: Symmetry Operations (P1 / US2)
+
+**Goal**: Add symmetryY, symmetryZ, and symmetryXYZ to complement existing symmetryX  
+**Independent Test**: Import each into a project, apply to an asymmetric test shape, verify correct point reflection in the preview viewport.
+
+- [x] T001 [P] Create symmetryY library entry (operations/symmetry_y.3mf)
+- [x] T002 [P] Create symmetryZ library entry (operations/symmetry_z.3mf)
+- [x] T003 [P] Create symmetryXYZ library entry (operations/symmetry_xyz.3mf)
+- [x] T004 Validate symmetryY with `validate_model` MCP tool
+- [x] T005 Validate symmetryZ with `validate_model` MCP tool
+- [x] T006 Validate symmetryXYZ with `validate_model` MCP tool
+- [x] T007 Verify thumbnails render for all three entries in library browser UI
+- [ ] T008 Test applying symmetryY to a test shape — verify Y-axis point reflection
+- [ ] T009 Test combining symmetryX + symmetryZ — verify simultaneous X+Z and Y+Z reflections
+
+**Implementation details**:
+| Entry | Return Type | Formula | Tags (≥5) | Description |
+|-------|-------------|---------|-----------|-------------|
+| symmetryY | `vec3` | `vec3(-pos.x, pos.y, -pos.z)` — mirror reflection through the Y axis (inverts X and Z) | symmetry, mirror, reflection, transformation, operations | Mirror reflection through the Y axis (inverts X and Z coordinates) |
+| symmetryZ | `vec3` | `vec3(-pos.x, -pos.y, pos.z)` — mirror reflection through the Z axis (inverts X and Y) | symmetry, mirror, reflection, transformation, operations | Mirror reflection through the Z axis (inverts X and Y coordinates) |
+| symmetryXYZ | `vec3` | `vec3(-pos.x, -pos.y, -pos.z)` — point reflection through origin | symmetry, mirror, reflection, transformation, operations | Full point reflection through origin (all axes inverted) |
+
+**Checkpoint**: All three symmetry operations importable, render correctly, and produce expected reflections.
+
+---
+
+## Phase 2: Basic Primitives (P2 / US3)
+
+**Goal**: Add ellipsoid, capsule, and diamond to fill gaps in fundamental geometry  
+**Independent Test**: Import each into a project, adjust parameters, verify correct SDF rendering with proper bounding boxes.
+
+- [ ] T010 [P] Create ellipsoid library entry (primitives/ellipsoid.3mf)
+- [ ] T011 [P] Create capsule library entry (primitives/capsule.3mf)
+- [ ] T012 [P] Create diamond/bicone library entry (primitives/diamond.3mf)
+- [ ] T013 Validate ellipsoid with `validate_model` MCP tool
+- [ ] T014 Validate capsule with `validate_model` MCP tool
+- [ ] T015 Validate diamond with `validate_model` MCP tool
+- [ ] T016 Verify thumbnails render for all three entries in library browser UI
+- [ ] T017 Test ellipsoid with varying radii — verify proportional stretching along X, Y, Z axes
+- [ ] T018 Test capsule with height > 0 and equal radii — verify cylinder + hemispherical end caps
+
+**Implementation details**:
+| Entry | Return Type | Formula | Tags (≥5) | Description |
+|-------|-------------|---------|-----------|-------------|
+| ellipsoid | `float` | `length(pos / vec3(xRadius, yRadius, zRadius)) - 1.0` | ellipsoid, primitive, sphere, radius, geometry | Ellipsoid SDF with three independent radii along each axis |
+| capsule | `float` | Standard capsule: cylinder + hemispherical end caps via min() from Inigo Quilez formulation | capsule, primitive, cylinder, sphere, geometry | Capsule SDF combining cylinder with hemispherical end caps |
+| diamond | `float` | Bicone: two cones joined at base, parameterized by topRadius, bottomRadius, height | diamond, bicone, cone, primitive, geometry | Diamond/bicone SDF transitioning between two cone profiles |
+
+**Checkpoint**: All three primitives importable, render correctly with proper bounding boxes, and respond to parameter changes.
+
+---
+
+## Phase 3: Deformation Modifiers (P2 / US4)
+
+**Goal**: Add twist and bend modifiers for organic shape deformation  
+**Independent Test**: Import each, apply to a cylinder or box, verify smooth deformation across the full parameter range without self-intersection artifacts.
+
+- [ ] T019 [P] Create twist library entry (modifiers/twist.3mf)
+- [ ] T020 [P] Create bend library entry (modifiers/bend.3mf)
+- [ ] T021 Validate twist with `validate_model` MCP tool
+- [ ] T022 Validate bend with `validate_model` MCP tool
+- [ ] T023 Verify thumbnails render for both entries in library browser UI
+- [ ] T024 Test twist at 90° and 180° on a cylinder — verify smooth per-slice rotation without self-intersection
+- [ ] T024b Test bend at 90° and 180° on a box — verify arc mapping produces no self-intersection artifacts
+
+**Implementation details**:
+| Entry | Return Type | Formula | Tags (≥5) | Description |
+|-------|-------------|---------|-----------|-------------|
+| twist | `vec3` | Per-slice rotation: rotate(pos.xy, angle * pos.z / 10.0); returns identity when angle=0 | twist, deformation, modifier, rotation, transformation | Rotational twist around Z axis proportional to height (0°–180°) |
+| bend | `vec3` | Arc mapping: project points onto circular arc of radius derived from bend angle; returns identity when angle=0 | bend, deformation, modifier, curve, transformation | Smooth bending along arc without self-intersection (0°–180°) |
+
+**Checkpoint**: Both modifiers apply smoothly to test shapes across full parameter range.
+
+---
+
+## Phase 4: Mechanical Parts (P3 / US5)
+
+**Goal**: Add hex_nut, washer_flat, and rivet for engineering hardware modeling  
+**Independent Test**: Import each, verify correct proportions at standard metric sizes, combine with existing mechanical items (helix_spring, socket_cap_screw).
+
+- [ ] T026 [P] Create hex_nut library entry (mechanical/hex_nut.3mf)
+- [ ] T027 [P] Create washer_flat library entry (mechanical/washer_flat.3mf)
+- [ ] T028 [P] Create rivet library entry (mechanical/rivet.3mf)
+- [ ] T029 Validate hex_nut with `validate_model` MCP tool
+- [ ] T030 Validate washer_flat with `validate_model` MCP tool
+- [ ] T031 Validate rivet with `validate_model` MCP tool
+- [ ] T032 Verify thumbnails render for all three entries in library browser UI
+- [ ] T033 Test hex_nut at M10 size — verify hexagonal profile and threaded hole
+- [ ] T034 Test washer_flat combined with socket_cap_screw — verify flush fit with correct ID/OD ratio
+
+**Implementation details**:
+| Entry | Return Type | Formula | Tags (≥5) | Description |
+|-------|-------------|---------|-----------|-------------|
+| hex_nut | `float` | Outer hexagonal cylinder via max of 6 plane SDFs minus inner cylindrical hole; simplified geometric approximation | hex_nut, mechanical, fastener, hardware, metric | Hexagonal nut with threaded hole for M6–M12 metric fasteners |
+| washer_flat | `float` | Annular cylinder: outer radius cylinder minus inner radius hole via max() | washer, flat_washer, mechanical, fastener, hardware | Flat washer per ISO 7089 approximation (outer/inner radius, height) |
+| rivet | `float` | Union of cylindrical shaft and hemispherical head via min() | rivet, mechanical, fastener, hardware, assembly | Rivet with cylindrical shaft and domed head for structural assemblies |
+
+**Checkpoint**: All three mechanical parts importable, render correctly at standard metric sizes, and combine properly with existing mechanical items.
+
+- [ ] T033a Verify washer_flat OD/ID ratio matches ISO 7089-10 (OD ≈ 2× ID for M6–M12 range)
+- [ ] T033b Verify rivet head diameter-to-shaft ratio follows DIN EN ISO 15674 proportions
+
+---
+
+## Phase 5: Cross-Story Validation & Polish
+
+**Goal**: Verify all items meet metadata requirements and work in combined operations  
+**Independent Test**: Run full validation suite — every entry has ≥5 tags, valid description, correct return type, working thumbnail.
+
+- [ ] T035 [P] Final metadata audit: verify all 9 new entries have ≥5 unique tags, non-empty descriptions (10–100 chars), and correct return types per category
+- [ ] T036 Test combined operations: symmetryY + ellipsoid, twist + cylinder, hex_nut + socket_cap_screw
+- [ ] T037 Verify no duplicate function names within any entry via `get_library_entry_info`
+- [ ] T038 Update docs/library_function_catalog.md with new entries
+
+---
+
+## Phase 6: GTest Unit Tests (P1 / Constitution Principle II)
+
+**Goal**: Satisfy constitution Principle II — every feature MUST have corresponding unit tests using GTest/GMock.  
+**Independent Test**: Run `Run Gladius Tests` task and verify all new test cases pass with no regressions.
+
+- [ ] T039 [P] Write GTest: `[SymmetryY_Function_PositionMirrored]` — verify symmetryY returns correct vec3 for arbitrary input point
+- [ ] T040 [P] Write GTest: `[SymmetryZ_Function_PositionMirrored]` — verify symmetryZ returns correct vec3 for arbitrary input point
+- [ ] T041 [P] Write GTest: `[SymmetryXYZ_Function_PointReflectionThroughOrigin]` — verify all axes inverted correctly
+- [ ] T042 [P] Write GTest: `[Ellipsoid_SDF_CorrectAtCenter]` — verify ellipsoid SDF returns negative value at origin (inside)
+- [ ] T043 [P] Write GTest: `[Ellipsoid_SDF_ReturnsZeroAtSurface]` — verify SDF ≈ 0 at surface boundary along each axis
+- [ ] T044 [P] Write GTest: `[HexPrism_SDF_CorrectForGivenRadiusAndHeight]` — verify hex_prism SDF values match analytical expectations
+- [ ] T045 [P] Write GTest: `[Twist_Function_BoundedRotation]` — verify twist deformation stays within documented safe parameter range (±90°)
+- [ ] T046 [P] Write GTest: `[Bend_Function_ArcMapping]` — verify bend produces correct arc displacement at sample points
+- [ ] T047 [P] Write GTest: `[HexNut_StandardMetricDimensions_M10]` — verify hex_nut dimensions match ISO 4017 M10 standard (flat-to-flat ≈ 17mm, height ≈ 5.8mm)
+- [ ] T048 [P] Write GTest: `[WasherFlat_ISO7089_ODIDRatio]` — verify washer_flat outer/inner diameter ratio matches ISO 7089-10 standard
+- [ ] T049 [P] Write GTest: `[Rivet_StandardHeadDiameterToShaftRatio]` — verify rivet head geometry follows DIN EN ISO 15674 proportions
+- [ ] T050 Regression: Run full test suite `Run Gladius Tests` and verify no existing tests regress
+
+**Implementation notes**:
+- Test files go in `gladius/tests/` alongside existing GTest suites
+- Each test MUST follow Arrange-Act-Assert pattern per Principle II
+- Test naming follows `[UnitOfWork_StateUnderTest_ExpectedBehavior]` convention
+- GPU-dependent SDF evaluation tests gated by `GLADIUS_RUN_GPU_TESTS=1` env var
+- Unit tests validate the GLSL function logic independently from 3MF import/export pipeline
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+```mermaid
+graph TD
+    A[Phase 1: Symmetry Operations] --> B[Phase 2: Basic Primitives]
+    B --> C[Phase 3: Deformation Modifiers]
+    C --> D[Phase 4: Mechanical Parts]
+    D --> E[Phase 5: Cross-Story Validation]
+    E --> F[Phase 6: GTest Unit Tests]
+```
+
+### Within Each Phase
+
+1. Create library entries (marked [P] — parallelizable, different files)
+2. Validate each entry with `validate_model` MCP tool
+3. Verify thumbnails render in UI
+4. Test functional behavior with test shapes
+
+### Parallel Opportunities
+
+| Phase | Parallel Tasks | Notes |
+|-------|---------------|-------|
+| 1 (Symmetry) | T001, T002, T003 | Different categories, no cross-dependencies |
+| 2 (Primitives) | T010, T011, T012 | Same category but different files — parallel-safe |
+| 3 (Modifiers) | T019, T020 | Different files, same category — parallel-safe |
+| 4 (Mechanical) | T026, T027, T028 | Same category but different files — parallel-safe |
+| 5 (Validation) | T035–T037 | Independent checks, no cross-dependencies |
+| 6 (GTest) | T039–T049 | All test cases independent of each other |
+
+**Note**: T024b is sequential after T019/T020 within Phase 3 (test depends on modifier creation).
+
+---
+
+## Implementation Strategy
+
+### MVP Scope (Recommended First Delivery)
+
+**User Story 2 (Symmetry Operations)** is the clear MVP:
+- Most obvious gap in existing library (symmetryX exists but Y/Z don't)
+- Trivially complements existing functionality
+- Immediate user value — no workarounds needed for multi-axis symmetry
+- All three items are single-return-statement functions (<10 lines each)
+
+### Incremental Delivery Order
+
+1. **Phase 1** → Symmetry operations (P1, US2) — MVP, highest user impact
+2. **Phase 2** → Basic primitives (P2, US3) — foundational geometry gap fill
+3. **Phase 3** → Deformation modifiers (P2, US4) — expressive power extension
+4. **Phase 4** → Mechanical parts (P3, US5) — engineering use cases
+
+### Known Issues to Avoid
+
+- **Empty entries**: The `basics` category has an unpopulated entry — do not create empty placeholders
+- **Duplicate function names**: smooth_union has duplicate main/sphere/box functions — ensure unique naming for new entries
+- **Missing tags**: 5+ existing entries have empty tag arrays — all new items must have ≥5 unique tags
+
+---
+
+## Success Criteria Mapping
+
+| SC | Related Tasks | Verification Method |
+|----|--------------|---------------------|
+| SC-001: Find symmetry item within 2 clicks | T001–T009 | Library browser search with "symmetry" filter |
+| SC-002: Valid thumbnails for all new items | T007, T016, T023, T032 | Visual inspection in library browser UI |
+| SC-003: 100% metadata completeness (≥5 tags, description) | T035 | Programmatic audit of tag count and description length |
+| SC-004: No errors applying modifiers to primitives | T024, T036 | Functional testing in preview viewport |