v1.7.3: clock controls on graph load + visibleWhen pin extension

Two minor UI bugs fixed:

1. Clock node loaded from a saved graph was missing its play/pause
   button and progress bar. EffectNode::isClock is derived from the
   ShaderLab descriptor at node-creation and isn't serialized; the
   ResetAfterGraphLoad restore loop ran AFTER SetGraph triggered a
   RebuildLayout, so the layout was computed with isClock=false. Move
   the restore before SetGraph.

2. Conditionally-visible input pins (e.g. ICtCp Gamut Map's
   TargetRedPrimary when TargetGamut=Custom) didn't appear on the
   canvas after a Properties-panel dropdown change. Two fixes:
     - UI markDirty enqueue priority Low -> Normal + SetNeedsRedraw()
       + m_forceRender = true so the canvas paint follows the rebuild.
     - GuiEngineCommandSink::OnNodeChanged also rebuilds layout when
       the node has any visibleWhen-conditional parameters, so MCP
       /graph/set-property gets the same behaviour. Direct call (no
       UI marshalling) since the hook already runs on the render
       thread inside the dispatch closure.

Bump Version.h, Package.appxmanifest, copilot-instructions to 1.7.3.

Tests 183/183 pass; headless smoke ratio 2.500.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Spruill-1

.github/copilot-instructions.md

@@ -134,7 +134,7 @@ Active development centers on **tone-mapping and color-correction effects author
 - **Effect registry**: Singleton with 40+ built-in D2D effects across 9 categories. Case-insensitive name lookup.
 - **ShaderLab effects library**: 33 built-in effects in `Effects/ShaderLabEffects.h/.cpp` across categories: Analysis (Heatmaps + Scopes + Statistics + Tone-Mapping), Color Processing (Gamut Map + ICtCp Gamut Map + Scale), Source / Generator, Composition (Split Comparison), and the data-only Parameter / Clock / Numeric Expression / Random / Working Space nodes. Embedded HLSL with shared color math from `Effects/ColorMath.cpp`. Auto-compiled at first use; bytecode cached on disk under `%LOCALAPPDATA%\ShaderLab\bytecode\` (decision #58 catalog → see [builtin-catalog.md](../docs/effects/builtin-catalog.md) for the full per-effect type table).
 - **MCP server**: JSON-RPC 2.0 server on port 47808 (47809 for headless to avoid shared-machine conflicts). The server itself + 20 engine-pure routes live in `Engine/Mcp/{McpHttpServer,EngineMcpRoutes}.{h,cpp}`; 16 UI-coupled / host-specific routes stay in `MainWindow.McpRoutes.cpp`. Both hosts register the same engine-side route set through the same `IEngineCommandSink` interface (decision #58). Engine-side routes are uniform: pure mutation closures dispatched via `sink.Dispatch`, with 8 event hooks (`OnNodeAdded`, `OnNodeRemoved`, `OnNodeChanged`, `OnGraphCleared`, `OnGraphLoaded`, `OnGraphStructureChanged`, `OnCustomEffectRecompiled`, `OnDisplayProfileChanged`) the GUI overrides to keep its UI in sync.
-- **Versioning**: `Version.h` defines app version (currently **1.7.2**) and graph format version (2). Both are stored in saved graphs. Forward compatibility check on load. `EngineExport.h::SHADERLAB_ENGINE_ABI_VERSION` is independent — bumped manually on engine ABI breaks; mismatch between header and DLL aborts startup with a friendly message-box.
+- **Versioning**: `Version.h` defines app version (currently **1.7.3**) and graph format version (2). Both are stored in saved graphs. Forward compatibility check on load. `EngineExport.h::SHADERLAB_ENGINE_ABI_VERSION` is independent — bumped manually on engine ABI breaks; mismatch between header and DLL aborts startup with a friendly message-box.
 - **Refresh-rate-driven render loop on the worker thread**: the render worker `std::jthread` runs the graph evaluate at the active monitor's refresh rate (clamped to 60–240 Hz). Dirty-gated: skips evaluate when no nodes changed, no output window is open, and `m_forceRender` is false. The UI thread runs a `DispatcherQueueTimer` at the same rate, but its body is just "drain dispatcher + blit offscreen + Present1" — sub-ms cost. The interval is re-applied on every display change so dragging the window across monitors picks up the new rate.
 - **`ProcessDeferredCompute` requires an active D2D draw session**: it calls `dc->DrawImage` internally to pre-render the upstream chain into an FP32 bitmap, and outside `BeginDraw`/`EndDraw` that DrawImage silently no-ops. The GUI's `RenderFrame`, the headless host's `runEval` / `RunRender`, and the test bench all wrap accordingly.
 - **Ctrl+Enter** compiles shader from the editor TextBox.

CHANGELOG.md

@@ -5,6 +5,13 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
 
 ## [Unreleased]
 
+## [1.7.3] - 2026-05-10
+
+### Fixed
+
+- **Clock node controls missing after loading a saved graph.** `EffectNode::isClock` is derived from the ShaderLab effect descriptor at node-creation time and is intentionally not serialized. `MainWindow::ResetAfterGraphLoad` was restoring the flag *after* `m_nodeGraphController.SetGraph(&m_graph)` triggered a layout pass, so `RebuildLayout` saw `isClock=false` for every freshly-deserialized Clock node and computed a regular-parameter-shaped visual without the play/pause button or progress bar. Move the restore loop to run *before* `SetGraph` so the layout sees the correct flag the first time.
+- **Conditionally-visible input pins (e.g. `TargetRedPrimary` on `ICtCp Gamut Map` when `TargetGamut == Custom`) didn't appear on the canvas after a Properties-panel dropdown change.** Two fixes: (1) the Properties-panel `markDirty` handler bumped its post-edit `RebuildLayout` enqueue from `DispatcherQueuePriority::Low` to `Normal` and explicitly calls `SetNeedsRedraw()` + sets `m_forceRender` so the canvas repaint follows the rebuild instead of being starved behind the 60 Hz render tick; (2) the engine `GuiEngineCommandSink::OnNodeChanged` hook now also rebuilds the layout when the changed node has any `visibleWhen`-conditional parameters, so MCP-driven `/graph/set-property` calls get the same node-extension behaviour as the Properties-panel dropdown. The hook is already running inside a render-dispatcher closure so it touches `m_nodeGraphController` directly without re-marshalling.
+
 ## [1.7.2] - 2026-05-10
 
 ### Removed

MainWindow.GraphFileIo.cpp

@@ -888,10 +888,14 @@ namespace winrt::ShaderLab::implementation
         // Close all existing output windows.
         m_outputWindows.clear();
 
-        m_nodeGraphController.SetGraph(&m_graph);
-
-        // Restore isClock flag from ShaderLab effect descriptors
-        // (not serialized in JSON, derived from effect definition).
+        // Restore isClock flag from ShaderLab effect descriptors BEFORE
+        // SetGraph triggers a layout pass. The flag isn't serialized in
+        // JSON (it's derived from the effect definition), so a freshly-
+        // deserialized Clock node has isClock=false. RebuildLayout reads
+        // node.isClock to decide whether to allocate space for the
+        // play/pause button + progress bar; if it runs first the visual
+        // ends up sized as a regular parameter node and the controls
+        // never appear until something else triggers another layout.
         {
             auto& lib = ::ShaderLab::Effects::ShaderLabEffects::Instance();
             for (auto& node : const_cast<std::vector<::ShaderLab::Graph::EffectNode>&>(m_graph.Nodes()))
@@ -905,6 +909,8 @@ namespace winrt::ShaderLab::implementation
             }
         }
 
+        m_nodeGraphController.SetGraph(&m_graph);
+
         m_graph.MarkAllDirty();
         PopulatePreviewNodeSelector();
 

MainWindow.McpRoutes.cpp

@@ -203,9 +203,34 @@ namespace winrt::ShaderLab::implementation
         });
     }
 
-    void MainWindow::GuiEngineCommandSink::OnNodeChanged(uint32_t /*nodeId*/)
+    void MainWindow::GuiEngineCommandSink::OnNodeChanged(uint32_t nodeId)
     {
         window->m_forceRender = true;
+
+        // If the changed node has any visibleWhen-conditional parameters,
+        // a property change might flip a pin's visibility. Rebuild the
+        // node-graph layout so new input pins materialize on the canvas.
+        //
+        // OnNodeChanged is already running inside a render-dispatcher
+        // closure (the /graph/set-property route DispatchSync's into the
+        // worker before invoking this hook), so it is safe to touch
+        // m_graph and m_nodeGraphController here directly -- the worker
+        // is paused for the duration. We just need to tell the controller
+        // to repaint via m_needsRedraw (set by RebuildLayout itself).
+        if (auto* n = window->m_graph.FindNode(nodeId))
+        {
+            if (n->customEffect.has_value())
+            {
+                for (const auto& p : n->customEffect->parameters)
+                {
+                    if (!p.visibleWhen.empty())
+                    {
+                        window->m_nodeGraphController.RebuildLayout();
+                        break;
+                    }
+                }
+            }
+        }
     }
 
     void MainWindow::GuiEngineCommandSink::OnGraphCleared()

MainWindow.xaml.cpp

@@ -3514,13 +3514,22 @@ namespace winrt::ShaderLab::implementation
                     if (hasVisibleWhen || isParameterNode || (n && n->effectClsid.has_value() &&
                         IsEqualGUID(n->effectClsid.value(), CLSID_D2D1Histogram)))
                     {
+                        // Normal priority (was Low) so the panel + node-graph
+                        // rebuild doesn't get starved behind the 60 Hz UI tick
+                        // when the user flips a visibleWhen trigger. With Low
+                        // priority the rebuild could sit in the queue
+                        // indefinitely on a busy render path -- the user sees
+                        // the Properties panel reflect their change but the
+                        // canvas pins don't materialize.
                         this->DispatcherQueue().TryEnqueue(
-                            winrt::Microsoft::UI::Dispatching::DispatcherQueuePriority::Low,
+                            winrt::Microsoft::UI::Dispatching::DispatcherQueuePriority::Normal,
                             [this]() {
                                 if (!m_isShuttingDown)
                                 {
                                     UpdatePropertiesPanel();
                                     m_nodeGraphController.RebuildLayout();
+                                    m_nodeGraphController.SetNeedsRedraw();
+                                    m_forceRender = true;
                                 }
                             });
                     }

Package.appxmanifest

@@ -9,7 +9,7 @@
   <Identity
     Name="ShaderLab"
     Publisher="CN=ShaderLab"
-    Version="1.7.2.0" />
+    Version="1.7.3.0" />
 
   <mp:PhoneIdentity PhoneProductId="a1b2c3d4-e5f6-7890-abcd-ef1234567890" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
 

Version.h

@@ -14,10 +14,10 @@ namespace ShaderLab
 {
     constexpr uint32_t VersionMajor = 1;
     constexpr uint32_t VersionMinor = 7;
-    constexpr uint32_t VersionPatch = 2;
+    constexpr uint32_t VersionPatch = 3;
 
     // Human-readable version string.
-    constexpr const wchar_t* VersionString = L"1.7.2";
+    constexpr const wchar_t* VersionString = L"1.7.3";
 
     // Graph format version. Increment when serialization format changes.
     // Graphs saved with a higher format version cannot be loaded by older apps.