graphs.html: real template build latency, conditional label

Measure actual build_template() time in TemplateBuilder (was hardcoded 0
for embedded mode). Store in stat log as work_latency, exposed via
getwork_latency graph source.

Label adapts to mode via currency_info.embedded/has_rpc flags:
- Embedded only: "Embedded Template Build Latency"
- RPC + Embedded: "GetBlockTemplate Latency (RPC + Embedded)"
- RPC only: "GetBlockTemplate Latency (RPC)"

Author: frstrtr

src/core/web_server.cpp

@@ -2121,6 +2121,7 @@ void MiningInterface::refresh_work()
         m_last_work_update_time   = std::chrono::duration_cast<std::chrono::seconds>(
             std::chrono::steady_clock::now().time_since_epoch()).count();
 
+        m_last_work_latency.store(static_cast<double>(wd.m_latency), std::memory_order_relaxed);
         LOG_INFO << "[LTC] refresh_work: height=" << wd.m_data.value("height", 0)
                  << " txs=" << wd.m_hashes.size()
                  << " latency=" << wd.m_latency << "ms"
@@ -4287,6 +4288,10 @@ nlohmann::json MiningInterface::rest_web_currency_info()
     if (m_explorer_enabled && !m_explorer_url.empty())
         result["explorer_url"] = m_explorer_url;
 
+    // Mode indicators for conditional UI
+    result["embedded"] = (m_embedded_node != nullptr);
+    result["has_rpc"]  = (m_coin_rpc != nullptr);
+
     return result;
 }
 
@@ -5871,7 +5876,7 @@ nlohmann::json MiningInterface::rest_web_graph_data(const std::string& source, c
             result.push_back({entry.time, nullptr, bin_width, 0});
         }
         else if (source == "getwork_latency") {
-            result.push_back({entry.time, 0.0, bin_width, 0});
+            result.push_back({entry.time, entry.work_latency, bin_width, 0});
         }
         else if (source == "memory_usage") {
             result.push_back({entry.time, entry.memory_usage, bin_width, 0});
@@ -6072,6 +6077,9 @@ void MiningInterface::update_stat_log()
         }
     }
 
+    // Work latency (template build time in seconds, matching p2pool getwork_latency)
+    entry.work_latency = m_last_work_latency.load(std::memory_order_relaxed) / 1000.0;
+
     {
         std::lock_guard<std::mutex> lock(m_stat_log_mutex);
         m_stat_log.push_back(entry);

src/core/web_server.hpp

@@ -860,6 +860,7 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
     std::atomic<bool>       m_work_valid{false};
     std::atomic<uint64_t>   m_work_generation{0};       // incremented on each refresh_work()
     std::atomic<int64_t>    m_last_work_update_time{0}; // monotonic seconds since epoch
+    std::atomic<double>     m_last_work_latency{0};    // template build latency (ms)
     nlohmann::json          m_cached_template;
 
 public:
@@ -1216,6 +1217,7 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
         double attempts_to_block;
         double block_value;
         double memory_usage{0};           // RSS in bytes
+        double work_latency{0};           // template build latency (ms)
     };
     std::vector<StatLogEntry> m_stat_log;
     mutable std::mutex m_stat_log_mutex;

src/impl/ltc/coin/template_builder.hpp

@@ -163,6 +163,7 @@ class TemplateBuilder {
         const MWEBTracker* mweb_tracker = nullptr)
     {
         (void)is_testnet;  // reserved for future per-network rules
+        auto t0 = std::chrono::steady_clock::now();
 
         auto tip_opt = chain.tip();
         if (!tip_opt)
@@ -304,7 +305,9 @@ class TemplateBuilder {
                  << " tip_ts=" << tip.header.m_timestamp
                  << " now=" << now_ts
                  << " synced=" << chain.is_synced();
-        return rpc::WorkData{std::move(data), std::move(tx_objects), std::move(tx_hashes), 0};
+        auto t1 = std::chrono::steady_clock::now();
+        auto latency_ms = std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count();
+        return rpc::WorkData{std::move(data), std::move(tx_objects), std::move(tx_hashes), latency_ms};
     }
 
 };

web-static/graphs.html

@@ -80,7 +80,7 @@ <h2>Desired version rates</h2>
         <h2>Traffic rate</h2>
         <svg id="traffic_rate"></svg>
 
-        <h2>Bitcoind GetBlockTemplate Latency</h2>
+        <h2 id="latency_title">Template Build Latency</h2>
         <svg id="getwork_latency"></svg>
 
         <h2>Memory Usage</h2>
@@ -559,8 +559,14 @@ <h2>Memory Usage</h2>
                     plot(d3.select('#traffic_rate'), 'B/s', 'B', data_to_lines(data, function(line){ return parseInt(line.label) }), true);
                 });
 
+                var latencyLabel = currency_info.embedded ? "Template Build" :
+                                   currency_info.has_rpc ? "GetBlockTemplate (RPC)" : "Template Build";
+                d3.select("#latency_title").text(currency_info.embedded ?
+                    "Embedded Template Build Latency" :
+                    currency_info.has_rpc ? "GetBlockTemplate Latency (RPC + Embedded)" :
+                    "Template Build Latency");
                 plot_later(d3.select("#getwork_latency"), "s", null, [
-                    {"url": "../web/graph_data/getwork_latency/last_" + lowerperiod, "color": "#FF0000", "label": "Getwork Latency"}
+                    {"url": "../web/graph_data/getwork_latency/last_" + lowerperiod, "color": "#FF0000", "label": latencyLabel}
                 ], false);
 
                 plot_later(d3.select("#memory_usage"), "B", null, [