diff --git a/CMakeLists.txt b/CMakeLists.txt
index c1e3f5d25..13f95e409 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,14 @@ endif()
 # ON by default with on-demand mode - zero overhead until a profiler connects.
 option(FW_PROFILING "Enable Tracy profiler instrumentation" ON)
 
+set(FW_METRICS_BACKEND "prometheus" CACHE STRING "Metrics backend")
+set_property(CACHE FW_METRICS_BACKEND PROPERTY STRINGS prometheus none)
+string(TOLOWER "${FW_METRICS_BACKEND}" FW_METRICS_BACKEND)
+if(NOT FW_METRICS_BACKEND STREQUAL "prometheus" AND NOT FW_METRICS_BACKEND STREQUAL "none")
+    message(FATAL_ERROR "Unsupported FW_METRICS_BACKEND: ${FW_METRICS_BACKEND}")
+endif()
+message(STATUS "Metrics backend: ${FW_METRICS_BACKEND}")
+
 if (WIN32)
     if (MSVC)
         add_compile_options(
diff --git a/code/framework/CMakeLists.txt b/code/framework/CMakeLists.txt
index b7d261357..f352ea3fe 100644
--- a/code/framework/CMakeLists.txt
+++ b/code/framework/CMakeLists.txt
@@ -1,6 +1,14 @@
 include(UpdateGitHash)
 update_git_version(FW "${CMAKE_CURRENT_SOURCE_DIR}/src/utils/version.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/version.cpp")
 
+if(FW_METRICS_BACKEND STREQUAL "prometheus")
+    set(FRAMEWORK_METRICS_BACKEND_SOURCE src/metrics/backends/prometheus.cpp)
+elseif(FW_METRICS_BACKEND STREQUAL "none")
+    set(FRAMEWORK_METRICS_BACKEND_SOURCE src/metrics/backends/none.cpp)
+else()
+    message(FATAL_ERROR "Unsupported FW_METRICS_BACKEND: ${FW_METRICS_BACKEND}")
+endif()
+
 # List the source files
 set(FRAMEWORK_SRC
     src/logging/logger.cpp
@@ -54,6 +62,9 @@ set(FRAMEWORK_SRC
 
     src/jobs/job_system.cpp
     src/jobs/io_tasks.cpp
+
+    src/metrics/registry.cpp
+    ${FRAMEWORK_METRICS_BACKEND_SOURCE}
 )
 
 set(FRAMEWORK_SERVER_SRC
@@ -303,6 +314,9 @@ target_compile_features(FrameworkV8Engine PRIVATE cxx_std_20)
 # Link the solutions based on the platform
 link_shared_deps(Framework)
 target_link_libraries(Framework v8 v8pp)
+if(FW_METRICS_BACKEND STREQUAL "prometheus")
+    target_link_libraries(Framework prometheus-cpp-lite)
+endif()
 if(LIBNODE_AVAILABLE)
     target_link_libraries(Framework libnode)
 endif()
diff --git a/code/framework/src/http/webserver.cpp b/code/framework/src/http/webserver.cpp
index c32c55c3e..760caeff7 100644
--- a/code/framework/src/http/webserver.cpp
+++ b/code/framework/src/http/webserver.cpp
@@ -10,8 +10,60 @@
 
 #include <httplib.h>
 #include <logging/logger.h>
+#include <metrics/registry.h>
+
+#include <chrono>
 
 namespace Framework::HTTP {
+    namespace {
+        Metrics::Counter *RouteStatusCounter(const std::string &route, const char *method, const char *codeClass) {
+            return Metrics::Registry::Get().RegisterCounter("fw_http_requests_total", "HTTP requests by route, method, and status class", {{"route", route}, {"method", method}, {"code", codeClass}});
+        }
+
+        struct RouteMetrics {
+            Metrics::Counter *c2xx       = nullptr;
+            Metrics::Counter *c4xx       = nullptr;
+            Metrics::Counter *c5xx       = nullptr;
+            Metrics::Counter *cother     = nullptr;
+            Metrics::Histogram *duration = nullptr;
+            Metrics::Gauge *inFlight     = nullptr;
+        };
+
+        RouteMetrics MakeRouteMetrics(const std::string &route, const char *method) {
+            auto &reg = Metrics::Registry::Get();
+            RouteMetrics metrics {
+                RouteStatusCounter(route, method, "2xx"),
+                RouteStatusCounter(route, method, "4xx"),
+                RouteStatusCounter(route, method, "5xx"),
+                RouteStatusCounter(route, method, "other"),
+                reg.RegisterHistogram("fw_http_request_duration_seconds", "HTTP route handler duration", Metrics::Buckets::Exponential(0.0005, 2.0, 13), {{"route", route}, {"method", method}}),
+                reg.RegisterGauge("fw_http_requests_in_flight", "HTTP requests currently executing a route handler", {{"route", route}, {"method", method}}),
+            };
+            return metrics;
+        }
+
+        void RecordRouteStatus(const RouteMetrics &c, int status) {
+            Metrics::Counter *sel = status >= 200 && status < 300 ? c.c2xx : status >= 400 && status < 500 ? c.c4xx : status >= 500 && status < 600 ? c.c5xx : c.cother;
+            if (sel) {
+                sel->Inc();
+            }
+        }
+
+        int EffectiveStatus(const httplib::Response &res) {
+            return res.status == -1 ? 200 : res.status;
+        }
+
+        void FinishRoute(const RouteMetrics &metrics, std::chrono::steady_clock::time_point startedAt, int status) {
+            RecordRouteStatus(metrics, status);
+            if (metrics.duration) {
+                metrics.duration->Observe(std::chrono::duration<double>(std::chrono::steady_clock::now() - startedAt).count());
+            }
+            if (metrics.inFlight) {
+                metrics.inFlight->Add(-1.0);
+            }
+        }
+    }
+
     Webserver::Webserver() {
         _server = std::make_shared<httplib::Server>();
     }
@@ -77,17 +129,51 @@ namespace Framework::HTTP {
     void Webserver::RegisterRequest(const std::string &path, const RequestCallback &callback) const {
         if (!_running)
             return;
-        if (!path.empty() && callback) {
-            _server->Get(path, callback);
-        }
+        if (path.empty() || !callback)
+            return;
+
+        const RouteMetrics metrics = MakeRouteMetrics(path, "GET");
+        RequestCallback userCb     = callback;
+        auto wrapped               = [userCb, metrics](const httplib::Request &req, httplib::Response &res) {
+            const auto startedAt = std::chrono::steady_clock::now();
+            if (metrics.inFlight) {
+                metrics.inFlight->Add(1.0);
+            }
+            try {
+                userCb(req, res);
+                FinishRoute(metrics, startedAt, EffectiveStatus(res));
+            }
+            catch (...) {
+                FinishRoute(metrics, startedAt, 500);
+                throw;
+            }
+        };
+        _server->Get(path, wrapped);
     }
 
     void Webserver::RegisterPostRequest(const std::string &path, const PostCallback &callback) const {
         if (!_running)
             return;
-        if (!path.empty() && callback) {
-            _server->Post(path, callback);
-        }
+        if (path.empty() || !callback)
+            return;
+
+        const RouteMetrics metrics = MakeRouteMetrics(path, "POST");
+        PostCallback userCb        = callback;
+        auto wrapped               = [userCb, metrics](const httplib::Request &req, httplib::Response &res, const httplib::ContentReader &reader) {
+            const auto startedAt = std::chrono::steady_clock::now();
+            if (metrics.inFlight) {
+                metrics.inFlight->Add(1.0);
+            }
+            try {
+                userCb(req, res, reader);
+                FinishRoute(metrics, startedAt, EffectiveStatus(res));
+            }
+            catch (...) {
+                FinishRoute(metrics, startedAt, 500);
+                throw;
+            }
+        };
+        _server->Post(path, wrapped);
     }
 
     void Webserver::ServeDirectory(const std::string &dir) {
diff --git a/code/framework/src/integrations/server/instance.cpp b/code/framework/src/integrations/server/instance.cpp
index 8819f293d..4e870ba24 100644
--- a/code/framework/src/integrations/server/instance.cpp
+++ b/code/framework/src/integrations/server/instance.cpp
@@ -9,8 +9,8 @@
 #include "instance.h"
 
 #include <filesystem>
-#include <set>
 #include <fstream>
+#include <set>
 #include <sstream>
 
 #include "core_modules.h"
@@ -37,8 +37,8 @@
 #include "utils/command_processor.h"
 #include "utils/path.h"
 #include "utils/profiler.h"
-#include "utils/version.h"
 #include "utils/time.h"
+#include "utils/version.h"
 
 #include "cxxopts.hpp"
 #include <cppfs/FileHandle.h>
@@ -48,6 +48,7 @@
 namespace Framework::Integrations::Server {
 
     Instance::Instance(): _shuttingDown(false) {
+        _processStart     = std::chrono::steady_clock::now();
         _networkingEngine = std::make_unique<Networking::Engine>();
         _webServer        = std::make_unique<HTTP::Webserver>();
         _fileConfig       = std::make_unique<Utils::Config>();
@@ -187,6 +188,8 @@ namespace Framework::Integrations::Server {
         // Register the default endpoints
         InitEndpoints();
 
+        InitMetrics();
+
         // Initialize default messages
         InitNetworkingMessages();
 
@@ -195,7 +198,7 @@ namespace Framework::Integrations::Server {
 
         // Initialize mod subsystems
         PostInit();
-    
+
         const auto sdkCallback = [this](Framework::Scripting::Engine *engine) {
             this->RegisterScriptingBuiltins(engine);
         };
@@ -281,6 +284,63 @@ namespace Framework::Integrations::Server {
         Logging::GetLogger(FRAMEWORK_INNER_HTTP)->debug("All core endpoints have been registered!");
     }
 
+    void Instance::InitMetrics() {
+        auto &reg = Metrics::Registry::Get();
+
+        const std::string configLabel =
+#ifdef NDEBUG
+            "Release"
+#else
+            "Debug"
+#endif
+            ;
+        auto *buildInfo = reg.RegisterGauge("fw_build_info", "Framework build version and configuration", {{"version", Utils::Version::rel}, {"config", configLabel}});
+        buildInfo->Set(1.0);
+
+        _uptimeGauge = reg.RegisterGauge("fw_uptime_seconds", "Process uptime in seconds");
+        _uptimeGauge->Set(0.0);
+
+        _tickDurationHist = reg.RegisterHistogram("fw_server_tick_duration_seconds", "Server tick wall-clock duration in seconds", Metrics::Buckets::Exponential(0.0005, 2.0, 10));
+        _tickLatenessHist    = reg.RegisterHistogram("fw_server_tick_lateness_seconds", "Delay between the scheduled and actual tick start", Metrics::Buckets::Exponential(0.0001, 2.0, 12));
+        _tickIntervalHist    = reg.RegisterHistogram("fw_server_tick_interval_seconds", "Elapsed wall time between consecutive tick starts", Metrics::Buckets::Exponential(0.001, 2.0, 11));
+        _tickRateGauge       = reg.RegisterGauge("fw_server_tick_rate_hz", "Instantaneous achieved server tick rate");
+        _tickTargetRateGauge = reg.RegisterGauge("fw_server_tick_target_hz", "Configured target server tick rate");
+        _tickRateGauge->Set(0.0);
+        _tickTargetRateGauge->Set(_opts.worldConfig.tickInterval > 0.0f ? 1.0 / static_cast<double>(_opts.worldConfig.tickInterval) : 0.0);
+
+        _tickOverrunsCounter = reg.RegisterCounter("fw_server_tick_budget_overruns_total", "Ticks whose duration exceeded the configured tick interval");
+
+        _connFailAuth = reg.RegisterCounter("fw_net_connection_failures_total", "Connection failures by handshake stage", {{"stage", "auth"}});
+
+        _masterlistUpdates      = reg.RegisterCounter("fw_masterlist_connector_updates_total", "Server-info updates submitted to the masterlist connector");
+        _masterlistUpdateErrors = reg.RegisterCounter("fw_masterlist_connector_update_errors_total", "Synchronous masterlist connector update failures");
+
+        if (_opts.metrics.enabled && reg.HasExporter() && _opts.webServerEnabled && _webServer) {
+            const std::string token       = _opts.metrics.token;
+            const std::string path        = _opts.metrics.path.empty() ? std::string("/metrics") : _opts.metrics.path;
+            const std::string contentType(reg.ContentType());
+            _webServer->RegisterRequest(path, [token, contentType](const httplib::Request &req, httplib::Response &res) {
+                if (!token.empty()) {
+                    const std::string auth = req.get_header_value("Authorization");
+                    if (auth != "Bearer " + token) {
+                        res.status = 401;
+                        res.set_content("unauthorized\n", "text/plain");
+                        return;
+                    }
+                }
+                thread_local std::string buf;
+                Metrics::Registry::Get().Render(buf);
+                res.set_content(buf, contentType);
+                res.status = 200;
+            });
+            if (token.empty()) {
+                Logging::GetLogger(FRAMEWORK_INNER_HTTP)->warn("Metrics exporter mounted at {} without authentication", path);
+            }
+            else {
+                Logging::GetLogger(FRAMEWORK_INNER_HTTP)->info("Metrics exporter mounted at {}", path);
+            }
+        }
+    }
 
     bool Instance::LoadConfigFromJSON() {
         const auto configHandle = cppfs::fs::open(_opts.modConfigFile);
@@ -307,6 +367,19 @@ namespace Framework::Integrations::Server {
             _opts.bindMapName   = _fileConfig->Get<std::string>("map");
             _opts.maxPlayers    = _fileConfig->Get<int>("maxplayers");
             _opts.bindSecretKey = _fileConfig->Get<std::string>("server-token");
+
+            if (const auto *doc = _fileConfig->GetDocument(); doc && doc->contains("metrics") && (*doc)["metrics"].is_object()) {
+                const auto &m = (*doc)["metrics"];
+                if (m.contains("enabled") && m["enabled"].is_boolean()) {
+                    _opts.metrics.enabled = m["enabled"].get<bool>();
+                }
+                if (m.contains("path") && m["path"].is_string()) {
+                    _opts.metrics.path = m["path"].get<std::string>();
+                }
+                if (m.contains("token") && m["token"].is_string()) {
+                    _opts.metrics.token = m["token"].get<std::string>();
+                }
+            }
         }
         catch (const std::exception &ex) {
             Logging::GetLogger(FRAMEWORK_INNER_SERVER)->critical("JSON config has missing fields: {}", ex.what());
@@ -357,10 +430,13 @@ namespace Framework::Integrations::Server {
             const auto guid = packet->guid;
             if (!net->IsAuthenticated(guid)) {
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->warn("Ignoring identity from unauthenticated peer {}", guid.g);
+                if (_connFailAuth) {
+                    _connFailAuth->Inc();
+                }
                 return;
             }
 
-            auto *replication = net->GetReplicationManager();
+            auto *replication   = net->GetReplicationManager();
             const auto peerGuid = MafiaNet::ToPeerGuid(guid);
             if (replication && (replication->GetConnectionByGUID(guid) || replication->GetViewer(peerGuid))) {
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->warn("Ignoring duplicate identity from {}", guid.g);
@@ -397,6 +473,7 @@ namespace Framework::Integrations::Server {
 
             // Gate opens: this connection now starts receiving the replicated world.
             net->PushReplicationConnection(guid);
+            net->MarkClientReady(guid);
 
             // Arm our half of the spawn barrier (the client armed its half before sending identity).
             const int eventId = Framework::Networking::NetworkServer::ReadyEventId(guid);
@@ -488,8 +565,7 @@ namespace Framework::Integrations::Server {
             v8::TryCatch tryCatch(isolate);
             v8::Local<v8::String> jsonStr;
             v8::Local<v8::Value> parsed;
-            if (!v8::String::NewFromUtf8(isolate, payloadJson.c_str()).ToLocal(&jsonStr) ||
-                !v8::JSON::Parse(context, jsonStr).ToLocal(&parsed)) {
+            if (!v8::String::NewFromUtf8(isolate, payloadJson.c_str()).ToLocal(&jsonStr) || !v8::JSON::Parse(context, jsonStr).ToLocal(&parsed)) {
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->warn("Dropping client event '{}' from {}: malformed JSON payload", eventName, senderNetworkId);
                 return;
             }
@@ -509,8 +585,8 @@ namespace Framework::Integrations::Server {
         const auto net      = GetNetworkingEngine()->GetNetworkServer();
         const auto streamer = net->GetAssetStreamer();
 
-        const auto scripting     = GetScriptingModule();
-        const auto resourcesPath = scripting->GetResourcesPath();
+        const auto scripting         = GetScriptingModule();
+        const auto resourcesPath     = scripting->GetResourcesPath();
         const std::string assetsPath = Framework::Utils::GetAbsolutePathA(resourcesPath);
         Logging::GetLogger(FRAMEWORK_INNER_SERVER)->debug("Resources directory: {}", assetsPath);
 
@@ -521,11 +597,13 @@ namespace Framework::Integrations::Server {
         if (resourceManager) {
             for (const auto &resourceName : resourceManager->GetAllResourceNames()) {
                 const auto resource = resourceManager->GetResource(resourceName);
-                if (!resource) continue;
+                if (!resource)
+                    continue;
 
                 // Only process resources with client entry points
                 const auto &clientEntryRelative = resource->GetManifest().GetMafiaHubConfig().client;
-                if (clientEntryRelative.empty()) continue;
+                if (clientEntryRelative.empty())
+                    continue;
 
                 const auto resourcePath = resource->GetPath();
 
@@ -635,11 +713,11 @@ namespace Framework::Integrations::Server {
 
     void Instance::InitCommandListener() {
         Logging::GetLogger(FRAMEWORK_INNER_SERVER)->debug("Setting up command listener and processor...");
-        
+
         _commandListener->SetCommandCallback([this](const std::string &command) {
             this->HandleCommand(command);
         });
-        
+
         _commandProcessor->RegisterCommand(
             "help", {},
             [this](cxxopts::ParseResult &) {
@@ -650,7 +728,7 @@ namespace Framework::Integrations::Server {
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("Available commands:\n{}", ss.str());
             },
             "Show this help message");
-            
+
         _commandProcessor->RegisterCommand(
             "quit", {},
             [this](cxxopts::ParseResult &) {
@@ -676,7 +754,8 @@ namespace Framework::Integrations::Server {
                 auto res = rm->StopResource(args[0]);
                 if (res) {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("Stopped resource '{}'", args[0]);
-                } else {
+                }
+                else {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Failed to stop '{}': {}", args[0], res.GetError());
                 }
             },
@@ -688,9 +767,9 @@ namespace Framework::Integrations::Server {
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("Server status:");
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("  Name: {}", _opts.modName);
                 Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("  Host: {}:{}", _opts.bindHost, _opts.bindPort);
-                
+
                 if (_networkingEngine) {
-                    const auto net = _networkingEngine->GetNetworkServer();
+                    const auto net  = _networkingEngine->GetNetworkServer();
                     const auto peer = net->GetPeer();
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("  Players: {}/{}", peer->NumberOfConnections(), _opts.maxPlayers);
                 }
@@ -713,35 +792,36 @@ namespace Framework::Integrations::Server {
                 auto res = op(rm, args[0]);
                 if (res) {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("{}: '{}'", verb, args[0]);
-                } else {
+                }
+                else {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Failed to {} '{}': {}", verb, args[0], res.GetError());
                 }
             };
         };
 
-        _commandProcessor->RegisterCommand(
-            "start", {},
-            resourceCommand("start", [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
-                return rm->StartResource(n);
-            }),
+        _commandProcessor->RegisterCommand("start", {},
+            resourceCommand("start",
+                [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
+                    return rm->StartResource(n);
+                }),
             "Start a resource: start <resource>");
 
-        _commandProcessor->RegisterCommand(
-            "restart", {},
-            resourceCommand("restart", [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
-                if (!rm->IsResourceRunning(n)) {
-                    return Framework::Scripting::ResourceOperationResult(std::string("resource is not running (use start)"));
-                }
-                return rm->RestartResource(n);
-            }),
+        _commandProcessor->RegisterCommand("restart", {},
+            resourceCommand("restart",
+                [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
+                    if (!rm->IsResourceRunning(n)) {
+                        return Framework::Scripting::ResourceOperationResult(std::string("resource is not running (use start)"));
+                    }
+                    return rm->RestartResource(n);
+                }),
             "Reload a running resource's code: restart <resource>");
 
         // Start-or-reload — the canonical verb FiveM/MTASA operators expect.
-        _commandProcessor->RegisterCommand(
-            "ensure", {},
-            resourceCommand("ensure", [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
-                return rm->IsResourceRunning(n) ? rm->RefreshResource(n) : rm->StartResource(n);
-            }),
+        _commandProcessor->RegisterCommand("ensure", {},
+            resourceCommand("ensure",
+                [](Framework::Scripting::ResourceManager *rm, const std::string &n) {
+                    return rm->IsResourceRunning(n) ? rm->RefreshResource(n) : rm->StartResource(n);
+                }),
             "Start or reload a resource: ensure <resource>");
 
         // Re-scan for new/changed resources (manifests), without restarting.
@@ -767,7 +847,8 @@ namespace Framework::Integrations::Server {
                 auto res = rm->RefreshAll();
                 if (res) {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("Refreshed all resources ({} affected)", res.GetValue().size());
-                } else {
+                }
+                else {
                     Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Failed to refresh all resources: {}", res.GetError());
                 }
             },
@@ -781,28 +862,21 @@ namespace Framework::Integrations::Server {
             auto result = _commandProcessor->ProcessCommand(command);
             if (result.GetError() != Utils::CommandProcessorError::COMMAND_NONE) {
                 switch (result.GetError()) {
-                    case Utils::CommandProcessorError::COMMAND_PRINT_HELP:
-                        Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("{}", result.GetValue());
-                        break;
-                    case Utils::CommandProcessorError::COMMAND_UNKNOWN: {
-                        // Not a built-in command; hand it to the mod override and the scripting layer.
-                        std::vector<std::string> tokens = Utils::CommandProcessor::Tokenize(command);
-                        if (!tokens.empty()) {
-                            const std::string name = std::move(tokens.front());
-                            tokens.erase(tokens.begin());
-                            OnConsoleCommand(std::string(command), name, tokens);
-                            EmitConsoleCommand(name, tokens);
-                        }
-                        break;
+                case Utils::CommandProcessorError::COMMAND_PRINT_HELP: Logging::GetLogger(FRAMEWORK_INNER_SERVER)->info("{}", result.GetValue()); break;
+                case Utils::CommandProcessorError::COMMAND_UNKNOWN: {
+                    // Not a built-in command; hand it to the mod override and the scripting layer.
+                    std::vector<std::string> tokens = Utils::CommandProcessor::Tokenize(command);
+                    if (!tokens.empty()) {
+                        const std::string name = std::move(tokens.front());
+                        tokens.erase(tokens.begin());
+                        OnConsoleCommand(std::string(command), name, tokens);
+                        EmitConsoleCommand(name, tokens);
                     }
-                    case Utils::CommandProcessorError::COMMAND_EMPTY_INPUT:
-                        break;
-                    case Utils::CommandProcessorError::COMMAND_INTERNAL_ERROR:
-                        Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Error processing command ({}): {}", command, result.GetValue());
-                        break;
-                    default:
-                        Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Error processing command ({}): {}", command, static_cast<int>(result.GetError()));
-                        break;
+                    break;
+                }
+                case Utils::CommandProcessorError::COMMAND_EMPTY_INPUT: break;
+                case Utils::CommandProcessorError::COMMAND_INTERNAL_ERROR: Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Error processing command ({}): {}", command, result.GetValue()); break;
+                default: Logging::GetLogger(FRAMEWORK_INNER_SERVER)->error("Error processing command ({}): {}", command, static_cast<int>(result.GetError())); break;
                 }
             }
         }
@@ -885,10 +959,25 @@ namespace Framework::Integrations::Server {
     }
 
     void Instance::Update() {
-        const auto start = std::chrono::high_resolution_clock::now();
+        const auto start = std::chrono::steady_clock::now();
         if (_nextTick <= start) {
             FW_PROFILE_SCOPE_N("Server::Tick");
 
+            if (_hasLastTickStart && _tickLatenessHist) {
+                _tickLatenessHist->Observe(std::chrono::duration<double>(start - _nextTick).count());
+            }
+            if (_hasLastTickStart) {
+                const double intervalSeconds = std::chrono::duration<double>(start - _lastTickStart).count();
+                if (_tickIntervalHist) {
+                    _tickIntervalHist->Observe(intervalSeconds);
+                }
+                if (_tickRateGauge && intervalSeconds > 0.0) {
+                    _tickRateGauge->Set(1.0 / intervalSeconds);
+                }
+            }
+            _lastTickStart    = start;
+            _hasLastTickStart = true;
+
             if (_networkingEngine) {
                 FW_PROFILE_SCOPE_N("Server::Networking");
                 _networkingEngine->Update();
@@ -912,17 +1001,40 @@ namespace Framework::Integrations::Server {
                 info.version        = Utils::Version::rel;
                 info.maxPlayers     = _opts.maxPlayers;
                 info.currentPlayers = _networkingEngine->GetNetworkServer()->GetPeer()->NumberOfConnections();
-                _masterlist->Ping(info);
+                try {
+                    _masterlist->Ping(info);
+                    if (_masterlistUpdates) {
+                        _masterlistUpdates->Inc();
+                    }
+                }
+                catch (...) {
+                    if (_masterlistUpdateErrors) {
+                        _masterlistUpdateErrors->Inc();
+                    }
+                    Logging::GetLogger(FRAMEWORK_INNER_SERVER)->warn("Masterlist connector update failed");
+                }
             }
 
             {
                 FW_PROFILE_SCOPE_N("Server::PostUpdate");
                 PostUpdate();
             }
+            
+            const auto tickEnd       = std::chrono::steady_clock::now();
+            const double tickSeconds = std::chrono::duration<double>(tickEnd - start).count();
+            if (_uptimeGauge) {
+                _uptimeGauge->Set(std::chrono::duration<double>(tickEnd - _processStart).count());
+            }
+            if (_tickDurationHist) {
+                _tickDurationHist->Observe(tickSeconds);
+            }
+            if (_tickOverrunsCounter && tickSeconds > _opts.worldConfig.tickInterval) {
+                _tickOverrunsCounter->Inc();
+            }
 
             FW_PROFILE_FRAME();
 
-            _nextTick = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(static_cast<int64_t>(Utils::Time::SecondsToMs(_opts.worldConfig.tickInterval)));
+            _nextTick = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(_opts.worldConfig.tickInterval));
         }
         else {
             std::this_thread::sleep_for(std::chrono::milliseconds(1));
diff --git a/code/framework/src/integrations/server/instance.h b/code/framework/src/integrations/server/instance.h
index dd49b79bc..e2440a637 100644
--- a/code/framework/src/integrations/server/instance.h
+++ b/code/framework/src/integrations/server/instance.h
@@ -15,16 +15,17 @@
 
 #include "http/webserver.h"
 #include "logging/logger.h"
+#include "metrics/registry.h"
 #include "networking/engine.h"
 #include "scripting/module.h"
 
 #include <external/sentry/wrapper.h>
 
-#include <mafianet/types.h>
 #include "services/masterlist.h"
-#include "utils/config.h"
 #include "utils/command_listener.h"
 #include "utils/command_processor.h"
+#include "utils/config.h"
+#include <mafianet/types.h>
 
 #include <utils/lifecycle.h>
 
@@ -46,7 +47,6 @@ namespace v8 {
 
 namespace Framework::Integrations::Server {
     struct InstanceOptions {
-
         std::string modSlug;
         std::string modHelpText;
         std::string modName;
@@ -83,7 +83,7 @@ namespace Framework::Integrations::Server {
 
         // MafiaHub Services
         struct Services {
-            std::string apiUrl = "https://api.mafiahub.dev";
+            std::string apiUrl        = "https://api.mafiahub.dev";
             std::string masterlistUrl = "";
         } services;
 
@@ -94,6 +94,12 @@ namespace Framework::Integrations::Server {
         int32_t maxPlayers;
         std::string httpServeDir;
 
+        struct MetricsConfig {
+            bool enabled = false;
+            std::string path = "/metrics";
+            std::string token;
+        } metrics;
+
         bool enableSignals;
 
         // update intervals and streaming
@@ -111,7 +117,6 @@ namespace Framework::Integrations::Server {
         // args
         int argc;
         char **argv;
-
     };
 
     // Connection metadata handed to the player-connect callback so the game can create and fully
@@ -126,12 +131,26 @@ namespace Framework::Integrations::Server {
         std::string discordId;
     };
 
-    class Instance : public Framework::Lifecycle {
+    class Instance: public Framework::Lifecycle {
       private:
         std::atomic<bool> _shuttingDown;
         // Set after the initial StartAll; gates runtime broadcasts to clients.
         bool _resourcesBooted = false;
-        std::chrono::time_point<std::chrono::high_resolution_clock> _nextTick;
+        std::chrono::time_point<std::chrono::steady_clock> _nextTick;
+        std::chrono::time_point<std::chrono::steady_clock> _processStart;
+        std::chrono::time_point<std::chrono::steady_clock> _lastTickStart;
+        bool _hasLastTickStart = false;
+
+        Metrics::Histogram *_tickDurationHist     = nullptr;
+        Metrics::Histogram *_tickLatenessHist     = nullptr;
+        Metrics::Histogram *_tickIntervalHist     = nullptr;
+        Metrics::Gauge *_tickRateGauge            = nullptr;
+        Metrics::Gauge *_tickTargetRateGauge      = nullptr;
+        Metrics::Gauge *_uptimeGauge              = nullptr;
+        Metrics::Counter *_tickOverrunsCounter    = nullptr;
+        Metrics::Counter *_connFailAuth           = nullptr;
+        Metrics::Counter *_masterlistUpdates      = nullptr;
+        Metrics::Counter *_masterlistUpdateErrors = nullptr;
 
         InstanceOptions _opts;
 
@@ -145,6 +164,7 @@ namespace Framework::Integrations::Server {
         std::unique_ptr<External::Sentry::Wrapper> _crashReporter;
 
         void InitEndpoints();
+        void InitMetrics();
         void InitNetworkingMessages();
         void InitAssetStreamer();
         // Re-sync a hot-reloaded/started client resource to connected clients.
@@ -154,7 +174,7 @@ namespace Framework::Integrations::Server {
         void InitCommandListener();
         bool LoadConfigFromJSON();
         void RegisterScriptingBuiltins(Framework::Scripting::Engine *);
-        
+
         void HandleCommand(std::string_view command);
         void EmitConsoleCommand(const std::string &command, const std::vector<std::string> &args);
 
diff --git a/code/framework/src/jobs/job_system.cpp b/code/framework/src/jobs/job_system.cpp
index 6d1a50e98..062527bf1 100644
--- a/code/framework/src/jobs/job_system.cpp
+++ b/code/framework/src/jobs/job_system.cpp
@@ -10,38 +10,143 @@
 
 #include <spdlog/spdlog.h>
 
+#include <chrono>
+
 namespace Framework::Jobs {
+    namespace {
+        Metrics::Counter *g_jobsSchedHigh    = nullptr;
+        Metrics::Counter *g_jobsSchedNormal  = nullptr;
+        Metrics::Counter *g_jobsExceptions   = nullptr;
+        Metrics::Gauge *g_jobsQueueHigh      = nullptr;
+        Metrics::Gauge *g_jobsQueueNormal    = nullptr;
+        Metrics::Gauge *g_jobsActive         = nullptr;
+        Metrics::Histogram *g_jobsWaitHigh   = nullptr;
+        Metrics::Histogram *g_jobsWaitNormal = nullptr;
+        Metrics::Histogram *g_jobsExecHigh   = nullptr;
+        Metrics::Histogram *g_jobsExecNormal = nullptr;
+        std::once_flag g_jobMetricsOnce;
+
+        void EnsureJobCounters() {
+            std::call_once(g_jobMetricsOnce, [] {
+                auto &reg         = Metrics::Registry::Get();
+                g_jobsSchedHigh   = reg.RegisterCounter("fw_jobs_scheduled_total", "Jobs scheduled", {{"priority", "high"}});
+                g_jobsSchedNormal = reg.RegisterCounter("fw_jobs_scheduled_total", "Jobs scheduled", {{"priority", "normal"}});
+                g_jobsExceptions  = reg.RegisterCounter("fw_jobs_exceptions_total", "Jobs that threw an uncaught exception");
+                g_jobsQueueHigh   = reg.RegisterGauge("fw_jobs_queue_depth", "Jobs queued but not yet executing", {{"priority", "high"}});
+                g_jobsQueueNormal = reg.RegisterGauge("fw_jobs_queue_depth", "Jobs queued but not yet executing", {{"priority", "normal"}});
+                g_jobsActive      = reg.RegisterGauge("fw_jobs_active", "Jobs that have begun but not yet completed");
+                g_jobsWaitHigh    = reg.RegisterHistogram("fw_jobs_queue_wait_duration_seconds", "Time from scheduling until execution begins", Metrics::Buckets::Exponential(0.00005, 4.0, 9), {{"priority", "high"}});
+                g_jobsWaitNormal  = reg.RegisterHistogram("fw_jobs_queue_wait_duration_seconds", "Time from scheduling until execution begins", Metrics::Buckets::Exponential(0.00005, 4.0, 9), {{"priority", "normal"}});
+                g_jobsExecHigh    = reg.RegisterHistogram("fw_jobs_execution_duration_seconds", "Job execution wall time", Metrics::Buckets::Exponential(0.00005, 4.0, 9), {{"priority", "high"}});
+                g_jobsExecNormal  = reg.RegisterHistogram("fw_jobs_execution_duration_seconds", "Job execution wall time", Metrics::Buckets::Exponential(0.00005, 4.0, 9), {{"priority", "normal"}});
+                g_jobsQueueHigh->Set(0.0);
+                g_jobsQueueNormal->Set(0.0);
+                g_jobsActive->Set(0.0);
+            });
+        }
+
+        Metrics::Gauge *QueueGauge(ftl::TaskPriority priority) {
+            return priority == ftl::TaskPriority::High ? g_jobsQueueHigh : g_jobsQueueNormal;
+        }
+
+        Metrics::Histogram *WaitHistogram(ftl::TaskPriority priority) {
+            return priority == ftl::TaskPriority::High ? g_jobsWaitHigh : g_jobsWaitNormal;
+        }
+
+        Metrics::Histogram *ExecutionHistogram(ftl::TaskPriority priority) {
+            return priority == ftl::TaskPriority::High ? g_jobsExecHigh : g_jobsExecNormal;
+        }
+    } // namespace
+
+    namespace Detail {
+        void RecordTaskScheduled(ftl::TaskPriority priority) noexcept {
+            auto *counter = priority == ftl::TaskPriority::High ? g_jobsSchedHigh : g_jobsSchedNormal;
+            if (counter) {
+                counter->Inc();
+            }
+            if (auto *queue = QueueGauge(priority)) {
+                queue->Add(1.0);
+            }
+        }
+
+        void RecordTaskStarted(ftl::TaskPriority priority, std::chrono::steady_clock::time_point enqueuedAt, std::chrono::steady_clock::time_point startedAt) noexcept {
+            if (auto *queue = QueueGauge(priority)) {
+                queue->Add(-1.0);
+            }
+            if (g_jobsActive) {
+                g_jobsActive->Add(1.0);
+            }
+            if (auto *wait = WaitHistogram(priority)) {
+                wait->Observe(std::chrono::duration<double>(startedAt - enqueuedAt).count());
+            }
+        }
+
+        void RecordTaskFinished(ftl::TaskPriority priority, std::chrono::steady_clock::time_point startedAt) noexcept {
+            if (auto *execution = ExecutionHistogram(priority)) {
+                execution->Observe(std::chrono::duration<double>(std::chrono::steady_clock::now() - startedAt).count());
+            }
+            if (g_jobsActive) {
+                g_jobsActive->Add(-1.0);
+            }
+        }
+
+        void ReportTaskException(const std::exception &exception) {
+            if (g_jobsExceptions) {
+                g_jobsExceptions->Inc();
+            }
+            spdlog::error("Task threw exception: {}", exception.what());
+        }
+
+        void ReportUnknownTaskException() {
+            if (g_jobsExceptions) {
+                g_jobsExceptions->Inc();
+            }
+            spdlog::error("Task threw unknown exception");
+        }
+    } // namespace Detail
 
     // Helper struct to wrap fu2::function for FTL's C-style function pointer
     struct TaskWrapper {
         fu2::function<void()> func;
+        ftl::TaskPriority priority = ftl::TaskPriority::Normal;
+        std::chrono::steady_clock::time_point enqueuedAt;
     };
 
     static void TaskWrapperFunc(ftl::TaskScheduler * /*scheduler*/, void *arg) {
-        auto *wrapper = static_cast<TaskWrapper *>(arg);
+        auto *wrapper        = static_cast<TaskWrapper *>(arg);
+        const auto startedAt = std::chrono::steady_clock::now();
+        Detail::RecordTaskStarted(wrapper->priority, wrapper->enqueuedAt, startedAt);
         try {
             wrapper->func();
-        } catch (const std::exception &e) {
-            spdlog::error("Task threw exception: {}", e.what());
-        } catch (...) {
-            spdlog::error("Task threw unknown exception");
         }
+        catch (const std::exception &e) {
+            Detail::ReportTaskException(e);
+        }
+        catch (...) {
+            Detail::ReportUnknownTaskException();
+        }
+        Detail::RecordTaskFinished(wrapper->priority, startedAt);
         delete wrapper;
     }
 
-    JobSystem::JobSystem(const JobSystemConfig &config) : _profilingEnabled(config.enableProfiling), _config(config) {
+    JobSystem::JobSystem(const JobSystemConfig &config): _profilingEnabled(config.enableProfiling), _config(config) {
         _scheduler = std::make_unique<ftl::TaskScheduler>();
     }
 
     JobSystemError JobSystem::Init() {
         ftl::TaskSchedulerInitOptions options;
-        options.FiberPoolSize = _config.fiberPoolSize;
+        options.FiberPoolSize  = _config.fiberPoolSize;
         options.ThreadPoolSize = _config.workerThreadCount;
-        options.Behavior = _config.emptyQueueBehavior;
+        options.Behavior       = _config.emptyQueueBehavior;
+
+        EnsureJobCounters();
+        _blockingCalls      = Metrics::Registry::Get().RegisterCounter("fw_jobs_blocking_calls_total", "BlockingCall invocations (detached-thread pressure indicator)");
+        _callbackQueueDepth = Metrics::Registry::Get().RegisterGauge("fw_jobs_callback_queue_depth", "Pending completed-callback queue depth");
+        _callbackQueueDepth->Set(0.0);
 
         if (_config.enableProfiling) {
             // Profiling callbacks can be added here for Tracy/Remotery integration
-            options.Callbacks.Context = this;
+            options.Callbacks.Context         = this;
             options.Callbacks.OnFiberAttached = [](void * /*context*/, unsigned /*fiberIndex*/) {
                 // Hook for profiler: fiber attached to thread
             };
@@ -73,12 +178,13 @@ namespace Framework::Jobs {
     }
 
     void JobSystem::Schedule(fu2::function<void()> task, ftl::TaskPriority priority) {
-        auto *wrapper = new TaskWrapper{std::move(task)};
+        auto *wrapper = new TaskWrapper {std::move(task), priority, std::chrono::steady_clock::now()};
 
         ftl::Task ftlTask;
         ftlTask.Function = TaskWrapperFunc;
-        ftlTask.ArgData = wrapper;
+        ftlTask.ArgData  = wrapper;
 
+        Detail::RecordTaskScheduled(priority);
         _scheduler->AddTask(ftlTask, priority);
     }
 
@@ -89,21 +195,29 @@ namespace Framework::Jobs {
     }
 
     void JobSystem::Schedule(ftl::WaitGroup *waitGroup, fu2::function<void()> task, ftl::TaskPriority priority) {
-        auto *wrapper = new TaskWrapper{std::move(task)};
+        auto *wrapper = new TaskWrapper {std::move(task), priority, std::chrono::steady_clock::now()};
 
         ftl::Task ftlTask;
         ftlTask.Function = TaskWrapperFunc;
-        ftlTask.ArgData = wrapper;
+        ftlTask.ArgData  = wrapper;
 
+        Detail::RecordTaskScheduled(priority);
         _scheduler->AddTask(ftlTask, priority, waitGroup);
     }
 
+    void JobSystem::RecordBlockingCall() {
+        if (_blockingCalls) {
+            _blockingCalls->Inc();
+        }
+    }
+
     void JobSystem::ScheduleWithCallback(fu2::function<void()> task, fu2::function<void()> onSuccess, fu2::function<void(std::exception_ptr)> onError, ftl::TaskPriority priority) {
         auto wrappedTask = [this, task = std::move(task), onSuccess = std::move(onSuccess), onError = std::move(onError)]() mutable {
             std::exception_ptr exception;
             try {
                 task();
-            } catch (...) {
+            }
+            catch (...) {
                 exception = std::current_exception();
             }
 
@@ -112,16 +226,20 @@ namespace Framework::Jobs {
                     QueueCallback([onError = std::move(onError), exception]() mutable {
                         onError(exception);
                     });
-                } else {
+                }
+                else {
                     try {
                         std::rethrow_exception(exception);
-                    } catch (const std::exception &e) {
+                    }
+                    catch (const std::exception &e) {
                         spdlog::error("Task failed with unhandled exception: {}", e.what());
-                    } catch (...) {
+                    }
+                    catch (...) {
                         spdlog::error("Task failed with unknown exception");
                     }
                 }
-            } else if (onSuccess) {
+            }
+            else if (onSuccess) {
                 QueueCallback(std::move(onSuccess));
             }
         };
@@ -135,15 +253,20 @@ namespace Framework::Jobs {
         {
             std::scoped_lock lock(_callbackMutex);
             std::swap(callbacks, _completedCallbacks);
+            if (_callbackQueueDepth) {
+                _callbackQueueDepth->Set(0.0);
+            }
         }
 
         while (!callbacks.empty()) {
             auto &cb = callbacks.front();
             try {
                 cb.callback();
-            } catch (const std::exception &e) {
+            }
+            catch (const std::exception &e) {
                 spdlog::error("Callback threw exception: {}", e.what());
-            } catch (...) {
+            }
+            catch (...) {
                 spdlog::error("Callback threw unknown exception");
             }
             callbacks.pop();
@@ -152,7 +275,10 @@ namespace Framework::Jobs {
 
     void JobSystem::QueueCallback(fu2::function<void()> callback) {
         std::scoped_lock lock(_callbackMutex);
-        _completedCallbacks.push(CompletedCallback{std::move(callback)});
+        _completedCallbacks.push(CompletedCallback {std::move(callback)});
+        if (_callbackQueueDepth) {
+            _callbackQueueDepth->Set(static_cast<double>(_completedCallbacks.size()));
+        }
     }
 
 } // namespace Framework::Jobs
diff --git a/code/framework/src/jobs/job_system.h b/code/framework/src/jobs/job_system.h
index 4fab24955..f85338a9f 100644
--- a/code/framework/src/jobs/job_system.h
+++ b/code/framework/src/jobs/job_system.h
@@ -10,13 +10,16 @@
 
 #include "errors.h"
 
+#include <ftl/fibtex.h>
 #include <ftl/task_scheduler.h>
 #include <ftl/wait_group.h>
-#include <ftl/fibtex.h>
-#include <ftl/parallel_for.h>
 
 #include <function2.hpp>
+#include <metrics/registry.h>
 
+#include <algorithm>
+#include <chrono>
+#include <exception>
 #include <memory>
 #include <mutex>
 #include <queue>
@@ -54,11 +57,11 @@ namespace Framework::Jobs {
         bool success = true;
 
         static TaskResult Success(T val) {
-            return TaskResult{std::move(val), "", true};
+            return TaskResult {std::move(val), "", true};
         }
 
         static TaskResult Failure(std::string err) {
-            return TaskResult{T{}, std::move(err), false};
+            return TaskResult {T {}, std::move(err), false};
         }
     };
 
@@ -68,11 +71,11 @@ namespace Framework::Jobs {
         bool success = true;
 
         static TaskResult Success() {
-            return TaskResult{"", true};
+            return TaskResult {"", true};
         }
 
         static TaskResult Failure(std::string err) {
-            return TaskResult{std::move(err), false};
+            return TaskResult {std::move(err), false};
         }
     };
 
@@ -83,6 +86,14 @@ namespace Framework::Jobs {
         fu2::function<void()> callback;
     };
 
+    namespace Detail {
+        void RecordTaskScheduled(ftl::TaskPriority priority) noexcept;
+        void RecordTaskStarted(ftl::TaskPriority priority, std::chrono::steady_clock::time_point enqueuedAt, std::chrono::steady_clock::time_point startedAt) noexcept;
+        void RecordTaskFinished(ftl::TaskPriority priority, std::chrono::steady_clock::time_point startedAt) noexcept;
+        void ReportTaskException(const std::exception &exception);
+        void ReportUnknownTaskException();
+    } // namespace Detail
+
     /**
      * @brief Fiber-based job system built on FTL (Fiber Tasking Library)
      *
@@ -111,7 +122,7 @@ namespace Framework::Jobs {
          * @brief Construct a new JobSystem
          * @param config Configuration options
          */
-        explicit JobSystem(const JobSystemConfig &config = JobSystemConfig{});
+        explicit JobSystem(const JobSystemConfig &config = JobSystemConfig {});
 
         ~JobSystem();
 
@@ -121,10 +132,10 @@ namespace Framework::Jobs {
          */
         [[nodiscard]] JobSystemError Init();
 
-        JobSystem(const JobSystem &) = delete;
+        JobSystem(const JobSystem &)            = delete;
         JobSystem &operator=(const JobSystem &) = delete;
-        JobSystem(JobSystem &&) = delete;
-        JobSystem &operator=(JobSystem &&) = delete;
+        JobSystem(JobSystem &&)                 = delete;
+        JobSystem &operator=(JobSystem &&)      = delete;
 
         /**
          * @brief Schedule a task to run on a worker fiber
@@ -169,7 +180,58 @@ namespace Framework::Jobs {
          */
         template <typename T, typename Func>
         void ScheduleBatch(std::vector<T> &items, Func &&func, size_t batchSize = 1, ftl::TaskPriority priority = ftl::TaskPriority::Normal) {
-            ftl::ParallelFor(_scheduler.get(), items.begin(), items.end(), batchSize, std::forward<Func>(func), priority);
+            if (items.empty()) {
+                return;
+            }
+            if (batchSize == 0) {
+                batchSize = 1;
+            }
+
+            using Callable = std::remove_reference_t<Func>;
+            struct BatchTask {
+                T *items                   = nullptr;
+                size_t count               = 0;
+                Callable *func             = nullptr;
+                ftl::TaskPriority priority = ftl::TaskPriority::Normal;
+                std::chrono::steady_clock::time_point enqueuedAt;
+            };
+
+            const size_t batchCount = ((items.size() - 1) / batchSize) + 1;
+            std::vector<BatchTask> batches(batchCount);
+            ftl::WaitGroup waitGroup(_scheduler.get());
+            for (size_t batchIndex = 0; batchIndex < batchCount; ++batchIndex) {
+                const size_t begin = batchIndex * batchSize;
+                auto &batch        = batches[batchIndex];
+                batch.items        = items.data() + begin;
+                batch.count        = std::min(batchSize, items.size() - begin);
+                batch.func         = std::addressof(func);
+                batch.priority     = priority;
+                batch.enqueuedAt   = std::chrono::steady_clock::now();
+
+                ftl::Task task {};
+                task.ArgData  = &batch;
+                task.Function = [](ftl::TaskScheduler *scheduler, void *arg) {
+                    auto *batchTask      = static_cast<BatchTask *>(arg);
+                    const auto startedAt = std::chrono::steady_clock::now();
+                    Detail::RecordTaskStarted(batchTask->priority, batchTask->enqueuedAt, startedAt);
+                    try {
+                        for (size_t i = 0; i < batchTask->count; ++i) {
+                            (*batchTask->func)(scheduler, &batchTask->items[i]);
+                        }
+                    }
+                    catch (const std::exception &e) {
+                        Detail::ReportTaskException(e);
+                    }
+                    catch (...) {
+                        Detail::ReportUnknownTaskException();
+                    }
+                    Detail::RecordTaskFinished(batchTask->priority, startedAt);
+                };
+
+                Detail::RecordTaskScheduled(priority);
+                _scheduler->AddTask(task, priority, &waitGroup);
+            }
+            waitGroup.Wait();
         }
 
         /**
@@ -185,8 +247,9 @@ namespace Framework::Jobs {
          * FOOTGUN: detached thread, no timeout; capture owned types by value, not refs to locals.
          */
         template <typename Func, typename ReturnType = decltype(std::declval<Func>()())>
-            requires (!std::is_void_v<ReturnType>)
+            requires(!std::is_void_v<ReturnType>)
         ReturnType BlockingCall(Func &&func) {
+            RecordBlockingCall();
             // For blocking I/O, we use a WaitGroup to yield the fiber
             ftl::WaitGroup wg(_scheduler.get());
             wg.Add(1);
@@ -198,7 +261,8 @@ namespace Framework::Jobs {
             std::thread([&]() {
                 try {
                     result = func();
-                } catch (...) {
+                }
+                catch (...) {
                     exception = std::current_exception();
                 }
                 wg.Done();
@@ -220,6 +284,7 @@ namespace Framework::Jobs {
         template <typename Func, typename ReturnType = decltype(std::declval<Func>()())>
             requires std::is_void_v<ReturnType>
         void BlockingCall(Func &&func) {
+            RecordBlockingCall();
             // For blocking I/O, we use a WaitGroup to yield the fiber
             ftl::WaitGroup wg(_scheduler.get());
             wg.Add(1);
@@ -230,7 +295,8 @@ namespace Framework::Jobs {
             std::thread([&]() {
                 try {
                     func();
-                } catch (...) {
+                }
+                catch (...) {
                     exception = std::current_exception();
                 }
                 wg.Done();
@@ -292,6 +358,11 @@ namespace Framework::Jobs {
             return std::make_unique<ftl::Fibtex>(_scheduler.get());
         }
 
+      private:
+        Metrics::Counter *_blockingCalls    = nullptr;
+        Metrics::Gauge *_callbackQueueDepth = nullptr;
+        void RecordBlockingCall();
+
       private:
         std::unique_ptr<ftl::TaskScheduler> _scheduler;
 
diff --git a/code/framework/src/metrics/backend.h b/code/framework/src/metrics/backend.h
new file mode 100644
index 000000000..ae3d1627d
--- /dev/null
+++ b/code/framework/src/metrics/backend.h
@@ -0,0 +1,48 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#pragma once
+
+#include "metrics/registry.h"
+
+#include <memory>
+
+namespace Framework::Metrics::Detail {
+
+    struct CounterHandle {
+        void *impl                                        = nullptr;
+        void (*increment)(void *, std::uint64_t) noexcept = nullptr;
+    };
+
+    struct GaugeHandle {
+        void *impl                           = nullptr;
+        void (*set)(void *, double) noexcept = nullptr;
+        void (*add)(void *, double) noexcept = nullptr;
+    };
+
+    struct HistogramHandle {
+        void *impl                               = nullptr;
+        void (*observe)(void *, double) noexcept = nullptr;
+    };
+
+    class Backend {
+      public:
+        virtual ~Backend() = default;
+
+        virtual CounterHandle RegisterCounter(std::string_view name, std::string_view help, std::initializer_list<Label> labels)                                         = 0;
+        virtual GaugeHandle RegisterGauge(std::string_view name, std::string_view help, std::initializer_list<Label> labels)                                             = 0;
+        virtual HistogramHandle RegisterHistogram(std::string_view name, std::string_view help, const std::vector<double> &buckets, std::initializer_list<Label> labels) = 0;
+
+        virtual bool HasExporter() const noexcept             = 0;
+        virtual std::string_view ContentType() const noexcept = 0;
+        virtual void Render(std::string &out) const           = 0;
+    };
+
+    std::unique_ptr<Backend> CreateBackend();
+
+} // namespace Framework::Metrics::Detail
diff --git a/code/framework/src/metrics/backends/none.cpp b/code/framework/src/metrics/backends/none.cpp
new file mode 100644
index 000000000..61ba87d99
--- /dev/null
+++ b/code/framework/src/metrics/backends/none.cpp
@@ -0,0 +1,46 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#include "metrics/backend.h"
+
+namespace Framework::Metrics::Detail {
+
+    namespace {
+        class NoneBackend final: public Backend {
+          public:
+            CounterHandle RegisterCounter(std::string_view, std::string_view, std::initializer_list<Label>) override {
+                return {};
+            }
+
+            GaugeHandle RegisterGauge(std::string_view, std::string_view, std::initializer_list<Label>) override {
+                return {};
+            }
+
+            HistogramHandle RegisterHistogram(std::string_view, std::string_view, const std::vector<double> &, std::initializer_list<Label>) override {
+                return {};
+            }
+
+            bool HasExporter() const noexcept override {
+                return false;
+            }
+
+            std::string_view ContentType() const noexcept override {
+                return {};
+            }
+
+            void Render(std::string &out) const override {
+                out.clear();
+            }
+        };
+    } // namespace
+
+    std::unique_ptr<Backend> CreateBackend() {
+        return std::make_unique<NoneBackend>();
+    }
+
+} // namespace Framework::Metrics::Detail
diff --git a/code/framework/src/metrics/backends/prometheus.cpp b/code/framework/src/metrics/backends/prometheus.cpp
new file mode 100644
index 000000000..94a836297
--- /dev/null
+++ b/code/framework/src/metrics/backends/prometheus.cpp
@@ -0,0 +1,94 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#include "metrics/backend.h"
+
+#include <charconv>
+#include <ostream>
+#include <stdexcept>
+#include <system_error>
+
+#include <prometheus/core.h>
+#include <prometheus/counter.h>
+#include <prometheus/gauge.h>
+#include <prometheus/histogram.h>
+
+#include <sstream>
+
+namespace Framework::Metrics::Detail {
+
+    namespace {
+        prometheus::labels_t ToLabels(std::initializer_list<Label> labels) {
+            prometheus::labels_t result;
+            for (const auto &label : labels) {
+                result.emplace(std::string(label.name), std::string(label.value));
+            }
+            return result;
+        }
+
+        void IncrementCounter(void *impl, std::uint64_t value) noexcept {
+            static_cast<prometheus::counter_t<std::uint64_t> *>(impl)->Increment(value);
+        }
+
+        void SetGauge(void *impl, double value) noexcept {
+            static_cast<prometheus::gauge_t<double> *>(impl)->Set(value);
+        }
+
+        void AddGauge(void *impl, double value) noexcept {
+            static_cast<prometheus::gauge_t<double> *>(impl)->Increment(value);
+        }
+
+        void ObserveHistogram(void *impl, double value) noexcept {
+            static_cast<prometheus::histogram_t<double> *>(impl)->Observe(value);
+        }
+
+        class PrometheusBackend final: public Backend {
+          public:
+            CounterHandle RegisterCounter(std::string_view name, std::string_view help, std::initializer_list<Label> labels) override {
+                auto &family = _registry.Add<prometheus::counter_t<std::uint64_t>>(std::string(name), std::string(help), {});
+                auto &metric = family.Add(ToLabels(labels));
+                return {&metric, IncrementCounter};
+            }
+
+            GaugeHandle RegisterGauge(std::string_view name, std::string_view help, std::initializer_list<Label> labels) override {
+                auto &family = _registry.Add<prometheus::gauge_t<double>>(std::string(name), std::string(help), {});
+                auto &metric = family.Add(ToLabels(labels));
+                return {&metric, SetGauge, AddGauge};
+            }
+
+            HistogramHandle RegisterHistogram(std::string_view name, std::string_view help, const std::vector<double> &buckets, std::initializer_list<Label> labels) override {
+                const prometheus::BucketBoundaries boundaries(buckets.begin(), buckets.end());
+                auto &family = _registry.Add<prometheus::histogram_t<double>>(std::string(name), std::string(help), {});
+                auto &metric = family.Add(ToLabels(labels), boundaries);
+                return {&metric, ObserveHistogram};
+            }
+
+            bool HasExporter() const noexcept override {
+                return true;
+            }
+
+            std::string_view ContentType() const noexcept override {
+                return "text/plain; version=0.0.4";
+            }
+
+            void Render(std::string &out) const override {
+                std::ostringstream stream;
+                _registry.serialize(stream);
+                out = stream.str();
+            }
+
+          private:
+            mutable prometheus::Registry _registry;
+        };
+    } // namespace
+
+    std::unique_ptr<Backend> CreateBackend() {
+        return std::make_unique<PrometheusBackend>();
+    }
+
+} // namespace Framework::Metrics::Detail
diff --git a/code/framework/src/metrics/registry.cpp b/code/framework/src/metrics/registry.cpp
new file mode 100644
index 000000000..446b05bb9
--- /dev/null
+++ b/code/framework/src/metrics/registry.cpp
@@ -0,0 +1,113 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#include "metrics/registry.h"
+
+#include "metrics/backend.h"
+
+#include <utility>
+
+namespace Framework::Metrics {
+
+    void Counter::Inc(std::uint64_t n) noexcept {
+        if (_increment) {
+            _increment(_impl, n);
+        }
+    }
+
+    void Gauge::Set(double v) noexcept {
+        if (_set) {
+            _set(_impl, v);
+        }
+    }
+
+    void Gauge::Add(double v) noexcept {
+        if (_add) {
+            _add(_impl, v);
+        }
+    }
+
+    void Histogram::Observe(double v) noexcept {
+        if (_observe) {
+            _observe(_impl, v);
+        }
+    }
+
+    Buckets Buckets::Exponential(double start, double factor, int count) {
+        Buckets buckets;
+        if (count <= 0) {
+            return buckets;
+        }
+
+        buckets._bounds.reserve(static_cast<std::size_t>(count));
+        double value = start;
+        for (int i = 0; i < count; ++i) {
+            buckets._bounds.push_back(value);
+            value *= factor;
+        }
+        return buckets;
+    }
+
+    Buckets Buckets::Explicit(std::initializer_list<double> bounds) {
+        Buckets buckets;
+        buckets._bounds.assign(bounds.begin(), bounds.end());
+        return buckets;
+    }
+
+    struct Registry::Impl {
+        Impl(): backend(Detail::CreateBackend()) {}
+
+        std::unique_ptr<Detail::Backend> backend;
+        std::vector<std::unique_ptr<Counter>> counters;
+        std::vector<std::unique_ptr<Gauge>> gauges;
+        std::vector<std::unique_ptr<Histogram>> histograms;
+    };
+
+    Registry &Registry::Get() {
+        static Registry instance;
+        return instance;
+    }
+
+    Registry::Registry(): _impl(std::make_unique<Impl>()) {}
+
+    Registry::~Registry() = default;
+
+    Counter *Registry::RegisterCounter(std::string_view name, std::string_view help, std::initializer_list<Label> labels) {
+        const auto backendHandle = _impl->backend->RegisterCounter(name, help, labels);
+        auto handle              = std::unique_ptr<Counter>(new Counter(backendHandle.impl, backendHandle.increment));
+        _impl->counters.push_back(std::move(handle));
+        return _impl->counters.back().get();
+    }
+
+    Gauge *Registry::RegisterGauge(std::string_view name, std::string_view help, std::initializer_list<Label> labels) {
+        const auto backendHandle = _impl->backend->RegisterGauge(name, help, labels);
+        auto handle              = std::unique_ptr<Gauge>(new Gauge(backendHandle.impl, backendHandle.set, backendHandle.add));
+        _impl->gauges.push_back(std::move(handle));
+        return _impl->gauges.back().get();
+    }
+
+    Histogram *Registry::RegisterHistogram(std::string_view name, std::string_view help, Buckets buckets, std::initializer_list<Label> labels) {
+        const auto backendHandle = _impl->backend->RegisterHistogram(name, help, buckets.Bounds(), labels);
+        auto handle              = std::unique_ptr<Histogram>(new Histogram(backendHandle.impl, backendHandle.observe));
+        _impl->histograms.push_back(std::move(handle));
+        return _impl->histograms.back().get();
+    }
+
+    bool Registry::HasExporter() const noexcept {
+        return _impl->backend->HasExporter();
+    }
+
+    std::string_view Registry::ContentType() const noexcept {
+        return _impl->backend->ContentType();
+    }
+
+    void Registry::Render(std::string &out) const {
+        _impl->backend->Render(out);
+    }
+
+} // namespace Framework::Metrics
diff --git a/code/framework/src/metrics/registry.h b/code/framework/src/metrics/registry.h
new file mode 100644
index 000000000..6e648a9bd
--- /dev/null
+++ b/code/framework/src/metrics/registry.h
@@ -0,0 +1,119 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace Framework::Metrics {
+
+    struct Label {
+        std::string_view name;
+        std::string_view value;
+    };
+
+    class Counter final {
+      public:
+        Counter() = default;
+
+        void Inc(std::uint64_t n = 1) noexcept;
+
+      private:
+        friend class Registry;
+
+        using IncrementFn = void (*)(void *, std::uint64_t) noexcept;
+
+        Counter(void *impl, IncrementFn increment) noexcept: _impl(impl), _increment(increment) {}
+
+        void *_impl            = nullptr;
+        IncrementFn _increment = nullptr;
+    };
+
+    class Gauge final {
+      public:
+        Gauge() = default;
+
+        void Set(double v) noexcept;
+        void Add(double v) noexcept;
+
+      private:
+        friend class Registry;
+
+        using UpdateFn = void (*)(void *, double) noexcept;
+
+        Gauge(void *impl, UpdateFn set, UpdateFn add) noexcept: _impl(impl), _set(set), _add(add) {}
+
+        void *_impl   = nullptr;
+        UpdateFn _set = nullptr;
+        UpdateFn _add = nullptr;
+    };
+
+    class Histogram final {
+      public:
+        Histogram() = default;
+
+        void Observe(double v) noexcept;
+
+      private:
+        friend class Registry;
+
+        using ObserveFn = void (*)(void *, double) noexcept;
+
+        Histogram(void *impl, ObserveFn observe) noexcept: _impl(impl), _observe(observe) {}
+
+        void *_impl        = nullptr;
+        ObserveFn _observe = nullptr;
+    };
+
+    class Buckets final {
+      public:
+        Buckets() = default;
+
+        static Buckets Exponential(double start, double factor, int count);
+        static Buckets Explicit(std::initializer_list<double> bounds);
+
+        const std::vector<double> &Bounds() const noexcept {
+            return _bounds;
+        }
+
+      private:
+        std::vector<double> _bounds;
+    };
+
+    class Registry final {
+      public:
+        static Registry &Get();
+
+        ~Registry();
+
+        Registry(const Registry &)            = delete;
+        Registry &operator=(const Registry &) = delete;
+        Registry(Registry &&)                 = delete;
+        Registry &operator=(Registry &&)      = delete;
+
+        Counter *RegisterCounter(std::string_view name, std::string_view help, std::initializer_list<Label> labels = {});
+        Gauge *RegisterGauge(std::string_view name, std::string_view help, std::initializer_list<Label> labels = {});
+        Histogram *RegisterHistogram(std::string_view name, std::string_view help, Buckets buckets, std::initializer_list<Label> labels = {});
+
+        bool HasExporter() const noexcept;
+        std::string_view ContentType() const noexcept;
+        void Render(std::string &out) const;
+
+      private:
+        Registry();
+
+        struct Impl;
+        std::unique_ptr<Impl> _impl;
+    };
+
+} // namespace Framework::Metrics
diff --git a/code/framework/src/networking/network_peer.cpp b/code/framework/src/networking/network_peer.cpp
index 38b7a1859..6a92ec46f 100644
--- a/code/framework/src/networking/network_peer.cpp
+++ b/code/framework/src/networking/network_peer.cpp
@@ -11,8 +11,12 @@
 #include "errors.h"
 #include "replication/replication_manager.h"
 
+#include <mafianet/GetTime.h>
+#include <mafianet/statistics.h>
 #include <logging/logger.h>
 
+#include <unordered_set>
+
 namespace Framework::Networking {
     NetworkPeer::NetworkPeer() {
         _peer = MafiaNet::RakPeerInterface::GetInstance();
@@ -26,6 +30,114 @@ namespace Framework::Networking {
         _statisticsHistory.SetTrackConnections(true, 0, true);
 
         _replicationManager = std::make_unique<Replication::ReplicationManager>();
+
+        InitMetrics();
+    }
+
+    void NetworkPeer::InitMetrics() {
+        auto &reg = Metrics::Registry::Get();
+        _netBytesRx = reg.RegisterCounter("fw_net_bytes_total", "Network bytes transferred", {{"direction", "rx"}});
+        _netBytesTx = reg.RegisterCounter("fw_net_bytes_total", "Network bytes transferred", {{"direction", "tx"}});
+        _netPacketsRx = reg.RegisterCounter("fw_net_packets_received_total", "Valid transport packets received");
+        _netRpcSignalsTx = reg.RegisterCounter("fw_net_rpc_signals_total", "RPC4 Signal calls initiated");
+        _netUnknownPackets = reg.RegisterCounter("fw_net_unknown_packets_total", "Unknown packet IDs received");
+        _netPingSeconds = reg.RegisterHistogram("fw_net_ping_seconds", "Per-connection round-trip time in seconds", Metrics::Buckets::Exponential(0.005, 2.0, 9));
+        _netPacketLoss  = reg.RegisterGauge("fw_net_packet_loss_ratio", "Mean packet-loss ratio across connections");
+        _netPendingResend = reg.RegisterGauge("fw_net_pending_bytes", "Transport queued bytes", {{"buffer", "resend"}});
+        _netPendingSend   = reg.RegisterGauge("fw_net_pending_bytes", "Transport queued bytes", {{"buffer", "send"}});
+        _netConnections   = reg.RegisterGauge("fw_net_connections", "Active connection count");
+        _netConnections->Set(0.0);
+    }
+
+    void NetworkPeer::SampleTransportStats() {
+        DataStructures::List<MafiaNet::SystemAddress> addresses;
+        DataStructures::List<MafiaNet::RakNetGUID>    guids;
+        DataStructures::List<MafiaNet::RakNetStatistics> stats;
+        _peer->GetStatisticsList(addresses, guids, stats);
+
+        const unsigned n = stats.Size();
+        if (n == 0) {
+            _lastBytesRx.clear();
+            _lastBytesTx.clear();
+            if (_netConnections) {
+                _netConnections->Set(0.0);
+            }
+            if (_netPacketLoss) {
+                _netPacketLoss->Set(0.0);
+            }
+            if (_netPendingResend) {
+                _netPendingResend->Set(0.0);
+            }
+            if (_netPendingSend) {
+                _netPendingSend->Set(0.0);
+            }
+            return;
+        }
+
+        if (_netConnections) {
+            _netConnections->Set(static_cast<double>(n));
+        }
+
+        uint64_t pendingReliable   = 0;
+        uint64_t pendingUnreliable = 0;
+        double   lossSum           = 0.0;
+        std::unordered_set<uint64_t> live;
+        live.reserve(n);
+
+        for (unsigned i = 0; i < n; ++i) {
+            const auto &s    = stats[i];
+            const auto  guid = guids[i].g;
+            live.insert(guid);
+
+            const uint64_t curRx = s.runningTotal[MafiaNet::ACTUAL_BYTES_RECEIVED];
+            const uint64_t curTx = s.runningTotal[MafiaNet::ACTUAL_BYTES_SENT];
+            const auto rxIt = _lastBytesRx.find(guid);
+            const uint64_t rxDelta = rxIt == _lastBytesRx.end() ? curRx : curRx >= rxIt->second ? curRx - rxIt->second : curRx;
+            if (rxDelta && _netBytesRx) {
+                _netBytesRx->Inc(rxDelta);
+            }
+            _lastBytesRx[guid] = curRx;
+            const auto txIt = _lastBytesTx.find(guid);
+            const uint64_t txDelta = txIt == _lastBytesTx.end() ? curTx : curTx >= txIt->second ? curTx - txIt->second : curTx;
+            if (txDelta && _netBytesTx) {
+                _netBytesTx->Inc(txDelta);
+            }
+            _lastBytesTx[guid] = curTx;
+
+            pendingReliable += s.bytesInResendBuffer;
+            for (int p = 0; p < MafiaNet::NUMBER_OF_PRIORITIES; ++p) {
+                pendingUnreliable += static_cast<uint64_t>(s.bytesInSendBuffer[p]);
+            }
+            lossSum += static_cast<double>(s.packetlossLastSecond);
+        }
+
+        for (auto it = _lastBytesRx.begin(); it != _lastBytesRx.end();) {
+            it = live.contains(it->first) ? std::next(it) : _lastBytesRx.erase(it);
+        }
+        for (auto it = _lastBytesTx.begin(); it != _lastBytesTx.end();) {
+            it = live.contains(it->first) ? std::next(it) : _lastBytesTx.erase(it);
+        }
+
+        if (_netPacketLoss) {
+            _netPacketLoss->Set(lossSum / static_cast<double>(n));
+        }
+        if (_netPendingResend) {
+            _netPendingResend->Set(static_cast<double>(pendingReliable));
+        }
+        if (_netPendingSend) {
+            _netPendingSend->Set(static_cast<double>(pendingUnreliable));
+        }
+
+        const MafiaNet::Time nowMs = MafiaNet::GetTime();
+        if (_netPingSeconds && nowMs - _lastPingSampleMs >= 1000) {
+            _lastPingSampleMs = nowMs;
+            for (unsigned i = 0; i < n; ++i) {
+                const int pingMs = GetPing(guids[i]);
+                if (pingMs >= 0) {
+                    _netPingSeconds->Observe(static_cast<double>(pingMs) / 1000.0);
+                }
+            }
+        }
     }
 
     NetworkPeer::~NetworkPeer() = default;
@@ -70,6 +182,8 @@ namespace Framework::Networking {
             _replicationManager->RebuildInterest();
         }
 
+        SampleTransportStats();
+
         for (_packet = _peer->Receive(); _packet; _peer->DeallocatePacket(_packet), _packet = _peer->Receive()) {
             if (_packet->length == 0) {
                 continue;
@@ -81,11 +195,18 @@ namespace Framework::Networking {
             _packetDataOffset = offset;
             uint8_t packetID = _packet->data[_packetDataOffset];
 
+            if (_netPacketsRx) {
+                _netPacketsRx->Inc();
+            }
+
             if (!HandlePacket(packetID, _packet)) {
                 if (IsReplicationPacket(packetID)) {
                     continue;
                 }
                 Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->trace("Received unknown packet {}", packetID);
+                if (_netUnknownPackets) {
+                    _netUnknownPackets->Inc();
+                }
                 if (_onUnknownPacketCallback) {
                     _onUnknownPacketCallback(_packet);
                 }
diff --git a/code/framework/src/networking/network_peer.h b/code/framework/src/networking/network_peer.h
index b0d708317..5200c954a 100644
--- a/code/framework/src/networking/network_peer.h
+++ b/code/framework/src/networking/network_peer.h
@@ -22,9 +22,11 @@
 #include <mafianet/TwoWayAuthentication.h>
 #include <mafianet/NetworkIDManager.h>
 #include <logging/logger.h>
+#include <metrics/registry.h>
 #include <utils/lifecycle.h>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <utils/hashing.h>
 #include <vector>
@@ -78,6 +80,11 @@ namespace Framework::Networking {
         }
 
         bool RegisterBuildToken();
+        void RecordRpcSignal() noexcept {
+            if (_netRpcSignalsTx) {
+                _netRpcSignalsTx->Inc();
+            }
+        }
 
       public:
         // TwoWayAuthentication identifier under which the build token is registered/challenged.
@@ -116,6 +123,7 @@ namespace Framework::Networking {
             MafiaNet::BitStream bs;
             payload.Serialize(&bs, true);
             _rpc.Signal(T::kIdentifier, &bs, priority, reliability, 0, except, true, false);
+            RecordRpcSignal();
         }
 
         // Send an RPC payload to a single system.
@@ -124,6 +132,7 @@ namespace Framework::Networking {
             MafiaNet::BitStream bs;
             payload.Serialize(&bs, true);
             _rpc.Signal(T::kIdentifier, &bs, priority, reliability, 0, guid, false, false);
+            RecordRpcSignal();
         }
 
         // Raw variant of RegisterRPC for handlers that decode the bitstream themselves (e.g. a
@@ -140,6 +149,7 @@ namespace Framework::Networking {
         // Send a pre-encoded bitstream under a raw identifier (pairs with RegisterRawRPC).
         void SendRawRPC(const char *identifier, MafiaNet::BitStream &bs, MafiaNet::RakNetGUID guid, MafiaNet::Priority priority = MafiaNet::Priority::High, MafiaNet::Reliability reliability = MafiaNet::Reliability::ReliableOrdered) {
             _rpc.Signal(identifier, &bs, priority, reliability, 0, guid, false, false);
+            RecordRpcSignal();
         }
 
         void Update() override;
@@ -224,5 +234,20 @@ namespace Framework::Networking {
         Replication::ReplicationManager *GetReplicationManager() const noexcept {
             return _replicationManager.get();
         }
+
+      private:
+        void InitMetrics();
+        void SampleTransportStats();
+
+        Metrics::Counter   *_netBytesRx = nullptr, *_netBytesTx = nullptr;
+        Metrics::Counter   *_netPacketsRx = nullptr, *_netRpcSignalsTx = nullptr;
+        Metrics::Counter   *_netUnknownPackets = nullptr;
+        Metrics::Histogram *_netPingSeconds = nullptr;
+        Metrics::Gauge     *_netPacketLoss = nullptr, *_netConnections = nullptr;
+        Metrics::Gauge     *_netPendingResend = nullptr, *_netPendingSend = nullptr;
+
+        std::unordered_map<uint64_t, uint64_t> _lastBytesRx;
+        std::unordered_map<uint64_t, uint64_t> _lastBytesTx;
+        MafiaNet::Time _lastPingSampleMs = 0;
     };
 } // namespace Framework::Networking
diff --git a/code/framework/src/networking/network_server.cpp b/code/framework/src/networking/network_server.cpp
index 2a16aa0a3..9119e2725 100644
--- a/code/framework/src/networking/network_server.cpp
+++ b/code/framework/src/networking/network_server.cpp
@@ -10,16 +10,33 @@
 
 #include "replication/replication_manager.h"
 
+#include <logging/logger.h>
 #include <mafianet/BitStream.h>
 #include <mafianet/MessageIdentifiers.h>
 #include <mafianet/guid_util.h>
-#include <logging/logger.h>
 
 namespace Framework::Networking {
     namespace {
         // How long Shutdown() blocks to flush the disconnection notification to connected peers, in
         // ms. Larger than the client's because the server broadcasts to every connection.
         constexpr unsigned int kShutdownBlockDurationMs = 1000;
+
+        const char *DisconnectionReasonName(DisconnectionReason r) {
+            switch (r) {
+            case DisconnectionReason::NO_FREE_SLOT: return "no_free_slot";
+            case DisconnectionReason::GRACEFUL_SHUTDOWN: return "graceful_shutdown";
+            case DisconnectionReason::LOST: return "lost";
+            case DisconnectionReason::FAILED: return "failed";
+            case DisconnectionReason::INVALID_PASSWORD: return "invalid_password";
+            case DisconnectionReason::WRONG_VERSION: return "wrong_version";
+            case DisconnectionReason::BANNED: return "banned";
+            case DisconnectionReason::KICKED: return "kicked";
+            case DisconnectionReason::KICKED_CUSTOM: return "kicked_custom";
+            case DisconnectionReason::KICKED_INVALID_PACKET: return "kicked_invalid_packet";
+            case DisconnectionReason::UNKNOWN: return "unknown";
+            }
+            return "unknown";
+        }
     } // namespace
 
     Utils::Result<void, Error> NetworkServer::Init(const std::string &host, int32_t port, int32_t maxPlayers, const std::string &password) {
@@ -29,7 +46,7 @@ namespace Framework::Networking {
         if (maxPlayers <= 0 || maxPlayers > 65535) {
             return Error("Invalid maxPlayers: " + std::to_string(maxPlayers));
         }
-        auto newSocketSd                  = MafiaNet::SocketDescriptor((uint16_t)port, host.c_str());
+        auto newSocketSd                     = MafiaNet::SocketDescriptor((uint16_t)port, host.c_str());
         const MafiaNet::StartupResult result = _peer->Startup(maxPlayers, &newSocketSd, 1);
         if (result != MafiaNet::RAKNET_STARTED) {
             return Error(std::string("Failed to start networking peer: ") + GetStartupResultString((uint8_t)result));
@@ -54,14 +71,48 @@ namespace Framework::Networking {
         // PushReplicationConnection). autoDestroy stays on so dropped peers are torn down.
         _replicationManager->SetAutoManageConnections(false, true);
 
+        InitMetrics();
+
         _initialized = true;
         return {};
     }
 
+    void NetworkServer::InitMetrics() {
+        auto &reg = Metrics::Registry::Get();
+        static constexpr DisconnectionReason kAllReasons[] = {
+            DisconnectionReason::NO_FREE_SLOT,
+            DisconnectionReason::GRACEFUL_SHUTDOWN,
+            DisconnectionReason::LOST,
+            DisconnectionReason::FAILED,
+            DisconnectionReason::INVALID_PASSWORD,
+            DisconnectionReason::WRONG_VERSION,
+            DisconnectionReason::BANNED,
+            DisconnectionReason::KICKED,
+            DisconnectionReason::KICKED_CUSTOM,
+            DisconnectionReason::KICKED_INVALID_PACKET,
+            DisconnectionReason::UNKNOWN,
+        };
+        for (const DisconnectionReason r : kAllReasons) {
+            _kickCounters[r]   = reg.RegisterCounter("fw_net_kicks_total", "Players kicked, by reason", {{"reason", DisconnectionReasonName(r)}});
+            _closedCounters[r] = reg.RegisterCounter("fw_net_connections_closed_total", "Accepted connections closed, by reason", {{"reason", DisconnectionReasonName(r)}});
+        }
+        _connFailVersion          = reg.RegisterCounter("fw_net_connection_failures_total", "Connection failures by handshake stage", {{"stage", "version"}});
+        _connFailReady            = reg.RegisterCounter("fw_net_connection_failures_total", "Connection failures by handshake stage", {{"stage", "ready"}});
+        _connectionsAccepted      = reg.RegisterCounter("fw_net_connections_accepted_total", "Transport connections accepted by the server");
+        _connectionsReady         = reg.RegisterCounter("fw_net_connections_ready_total", "Connections that completed authentication, assets, and identity");
+        _authenticatedConnections = reg.RegisterGauge("fw_net_authenticated_connections", "Currently connected peers that passed build authentication");
+        _readyConnections         = reg.RegisterGauge("fw_net_ready_connections", "Currently connected peers that completed the ready handshake");
+        _authenticatedConnections->Set(0.0);
+        _readyConnections->Set(0.0);
+    }
+
     bool NetworkServer::HandlePacket(uint8_t packetID, MafiaNet::Packet *packet) {
         switch (packetID) {
         case ID_NEW_INCOMING_CONNECTION: {
             Framework::Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->debug("Incoming connection request {}", MafiaNet::to_string(packet->guid));
+            if (_acceptedClients.insert(packet->guid.g).second && _connectionsAccepted) {
+                _connectionsAccepted->Inc();
+            }
             if (_onPlayerConnectCallback) {
                 _onPlayerConnectCallback(packet);
             }
@@ -71,17 +122,17 @@ namespace Framework::Networking {
         case ID_DISCONNECTION_NOTIFICATION: {
             Framework::Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->debug("Disconnection from {}", MafiaNet::to_string(packet->guid));
             if (_onPlayerDisconnectCallback) {
-                _onPlayerDisconnectCallback(_packet, DisconnectionReason::GRACEFUL_SHUTDOWN, "");
+                _onPlayerDisconnectCallback(packet, DisconnectionReason::GRACEFUL_SHUTDOWN, "");
             }
-            ClearClientState(packet->guid);
+            RecordConnectionClosed(packet->guid, DisconnectionReason::GRACEFUL_SHUTDOWN);
             return true;
         };
         case ID_CONNECTION_LOST: {
             Framework::Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->debug("Connection lost for {}", MafiaNet::to_string(packet->guid));
             if (_onPlayerDisconnectCallback) {
-                _onPlayerDisconnectCallback(_packet, DisconnectionReason::LOST, "");
+                _onPlayerDisconnectCallback(packet, DisconnectionReason::LOST, "");
             }
-            ClearClientState(packet->guid);
+            RecordConnectionClosed(packet->guid, DisconnectionReason::LOST);
             return true;
         };
 
@@ -90,6 +141,9 @@ namespace Framework::Networking {
         case ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_SUCCESS: {
             Framework::Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->debug("Build verified for {}", MafiaNet::to_string(packet->guid));
             _authenticatedClients.insert(packet->guid.g);
+            if (_authenticatedConnections) {
+                _authenticatedConnections->Set(static_cast<double>(_authenticatedClients.size()));
+            }
             if (_onClientAuthenticatedCallback) {
                 _onClientAuthenticatedCallback(packet->guid);
             }
@@ -97,6 +151,10 @@ namespace Framework::Networking {
         };
         case ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_FAILURE: {
             Framework::Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->warn("Build mismatch from {}, dropping peer", MafiaNet::to_string(packet->guid));
+            if (_connFailVersion) {
+                _connFailVersion->Inc();
+            }
+            RecordConnectionClosed(packet->guid, DisconnectionReason::WRONG_VERSION);
             _peer->CloseConnection(packet->guid, true);
             return true;
         };
@@ -107,8 +165,7 @@ namespace Framework::Networking {
         case ID_READY_EVENT_UNSET:
         case ID_READY_EVENT_ALL_SET:
         case ID_READY_EVENT_QUERY:
-        case ID_READY_EVENT_FORCE_ALL_SET:
-            return true;
+        case ID_READY_EVENT_FORCE_ALL_SET: return true;
 
         default: break;
         }
@@ -120,6 +177,19 @@ namespace Framework::Networking {
             return;
         }
 
+        if (const auto it = _closedCounters.find(DisconnectionReason::GRACEFUL_SHUTDOWN); it != _closedCounters.end() && it->second && !_acceptedClients.empty()) {
+            it->second->Inc(static_cast<uint64_t>(_acceptedClients.size()));
+        }
+        _acceptedClients.clear();
+        _authenticatedClients.clear();
+        _readyClients.clear();
+        if (_authenticatedConnections) {
+            _authenticatedConnections->Set(0.0);
+        }
+        if (_readyConnections) {
+            _readyConnections->Set(0.0);
+        }
+
         _peer->Shutdown(kShutdownBlockDurationMs);
         MafiaNet::RakPeerInterface::DestroyInstance(_peer);
         _peer = nullptr;
@@ -142,6 +212,7 @@ namespace Framework::Networking {
         // When broadcasting, the system identifier is the peer to exclude, so a single Signal reaches
         // everyone but the sender.
         _rpc.Signal(identifier, &bs, priority, reliability, 0, excludeGUID, true, false);
+        RecordRpcSignal();
     }
 
     void NetworkServer::PushReplicationConnection(MafiaNet::RakNetGUID guid) {
@@ -157,7 +228,23 @@ namespace Framework::Networking {
         }
     }
 
+    void NetworkServer::MarkClientReady(MafiaNet::RakNetGUID guid) {
+        if (!_acceptedClients.contains(guid.g) || !_authenticatedClients.contains(guid.g)) {
+            return;
+        }
+        if (_readyClients.insert(guid.g).second && _connectionsReady) {
+            _connectionsReady->Inc();
+        }
+        if (_readyConnections) {
+            _readyConnections->Set(static_cast<double>(_readyClients.size()));
+        }
+    }
+
     void NetworkServer::KickPlayer(MafiaNet::RakNetGUID guid, DisconnectionReason reason, const std::string &customReason) {
+        if (const auto it = _kickCounters.find(reason); it != _kickCounters.end() && it->second) {
+            it->second->Inc();
+        }
+
         DisconnectPayload payload;
         payload.reason       = static_cast<uint32_t>(reason);
         payload.customReason = customReason;
@@ -165,13 +252,33 @@ namespace Framework::Networking {
         // Reason rides the disconnect notification, so no separate message races the close.
         MafiaNet::BitStream reasonData;
         payload.Serialize(&reasonData, true);
+        RecordConnectionClosed(guid, reason);
         _peer->CloseConnection(guid, true, 0, MafiaNet::Priority::Low, &reasonData);
+    }
+
+    void NetworkServer::RecordConnectionClosed(MafiaNet::RakNetGUID guid, DisconnectionReason reason) {
+        if (!_acceptedClients.erase(guid.g)) {
+            return;
+        }
+        if (_authenticatedClients.contains(guid.g) && !_readyClients.contains(guid.g) && _connFailReady) {
+            _connFailReady->Inc();
+        }
+        if (const auto it = _closedCounters.find(reason); it != _closedCounters.end() && it->second) {
+            it->second->Inc();
+        }
         ClearClientState(guid);
     }
 
     void NetworkServer::ClearClientState(MafiaNet::RakNetGUID guid) {
         _authenticatedClients.erase(guid.g);
+        _readyClients.erase(guid.g);
         _peerIdentities.erase(guid.g);
         _readyEvent.DeleteEvent(ReadyEventId(guid)); // recycle the slot for reconnects
+        if (_authenticatedConnections) {
+            _authenticatedConnections->Set(static_cast<double>(_authenticatedClients.size()));
+        }
+        if (_readyConnections) {
+            _readyConnections->Set(static_cast<double>(_readyClients.size()));
+        }
     }
 } // namespace Framework::Networking
diff --git a/code/framework/src/networking/network_server.h b/code/framework/src/networking/network_server.h
index e202eddce..00b662eff 100644
--- a/code/framework/src/networking/network_server.h
+++ b/code/framework/src/networking/network_server.h
@@ -10,8 +10,8 @@
 
 #include <cstdint>
 
-#include "errors.h"
 #include "connection.h"
+#include "errors.h"
 #include "network_peer.h"
 #include "rpc/client_identity.h"
 #include "rpc/rpc.h"
@@ -19,8 +19,8 @@
 #include <utils/error.h>
 #include <utils/result.h>
 
-#include <mafianet/types.h>
 #include <mafianet/peerinterface.h>
+#include <mafianet/types.h>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ -38,11 +38,24 @@ namespace Framework::Networking {
 
         // Guids whose build challenge passed — the gate keeping unverified peers out of replication.
         std::unordered_set<uint64_t> _authenticatedClients;
+        std::unordered_set<uint64_t> _acceptedClients;
+        std::unordered_set<uint64_t> _readyClients;
 
         // Identities announced via ClientIdentity, kept for the connection's lifetime.
         std::unordered_map<uint64_t, RPC::ClientIdentity> _peerIdentities;
 
+        std::unordered_map<DisconnectionReason, Metrics::Counter *> _kickCounters;
+        std::unordered_map<DisconnectionReason, Metrics::Counter *> _closedCounters;
+        Metrics::Counter *_connFailVersion        = nullptr;
+        Metrics::Counter *_connFailReady          = nullptr;
+        Metrics::Counter *_connectionsAccepted    = nullptr;
+        Metrics::Counter *_connectionsReady       = nullptr;
+        Metrics::Gauge *_authenticatedConnections = nullptr;
+        Metrics::Gauge *_readyConnections         = nullptr;
+
+        void InitMetrics();
         void ClearClientState(MafiaNet::RakNetGUID guid);
+        void RecordConnectionClosed(MafiaNet::RakNetGUID guid, DisconnectionReason reason);
 
       public:
         NetworkServer(): NetworkPeer() {}
@@ -64,6 +77,8 @@ namespace Framework::Networking {
             return _authenticatedClients.contains(guid.g);
         }
 
+        void MarkClientReady(MafiaNet::RakNetGUID guid);
+
         // Start replicating to an authenticated peer (idempotent). Replication begins for no peer
         // until this is called — connections are not auto-managed (see Init).
         void PushReplicationConnection(MafiaNet::RakNetGUID guid);
diff --git a/code/framework/src/networking/replication/interest_grid.cpp b/code/framework/src/networking/replication/interest_grid.cpp
index 2d926ea16..b285f203d 100644
--- a/code/framework/src/networking/replication/interest_grid.cpp
+++ b/code/framework/src/networking/replication/interest_grid.cpp
@@ -112,8 +112,11 @@ namespace Framework::Networking::Replication {
         return it != _ownedByGuid.end() ? &it->second : nullptr;
     }
 
-    void InterestGrid::CollectVisible(NetworkEntity *viewer, MafiaNet::PeerGuid viewerGUID, std::unordered_set<NetworkEntity *> &out) {
+    void InterestGrid::CollectVisible(NetworkEntity *viewer, MafiaNet::PeerGuid viewerGUID, std::unordered_set<NetworkEntity *> &out, size_t *candidatesOut) {
         if (!viewer) {
+            if (candidatesOut) {
+                *candidatesOut = 0;
+            }
             return;
         }
         if (!_ready) {
@@ -121,6 +124,9 @@ namespace Framework::Networking::Replication {
                 _warnedNotReady = true;
                 Logging::GetLogger(FRAMEWORK_INNER_NETWORKING)->error("InterestGrid queried before its first RebuildInterest(); no entities will replicate. Call ReplicationManager::RebuildInterest() once per server tick.");
             }
+            if (candidatesOut) {
+                *candidatesOut = 0;
+            }
             return;
         }
         const auto observerWorld = viewer->GetVirtualWorld();
@@ -128,6 +134,16 @@ namespace Framework::Networking::Replication {
         _inRange.clear();
         QueryRadius(viewer->position, viewer->streaming.range, _inRange);
 
+        if (candidatesOut) {
+            size_t candidates = _inRange.size();
+            if (const auto *owned = OwnedBy(viewerGUID)) {
+                candidates += owned->size();
+            }
+            candidates += AlwaysVisible().size();
+            candidates += 1;
+            *candidatesOut = candidates;
+        }
+
         // A private entity (targetGUID set) is only ever relevant to its target connection, and for
         // that viewer the target stands in for the dimension gate.
         const auto targetMatch = [viewerGUID](const NetworkEntity *entity) {
diff --git a/code/framework/src/networking/replication/interest_grid.h b/code/framework/src/networking/replication/interest_grid.h
index 621a63906..73512d088 100644
--- a/code/framework/src/networking/replication/interest_grid.h
+++ b/code/framework/src/networking/replication/interest_grid.h
@@ -61,7 +61,7 @@ namespace Framework::Networking::Replication {
 
         // Fill `out` with the entities relevant to `viewer`: in range and dimension, owned, or
         // always-visible. The home of the server's relevance rule.
-        void CollectVisible(NetworkEntity *viewer, MafiaNet::PeerGuid viewerGUID, std::unordered_set<NetworkEntity *> &out);
+        void CollectVisible(NetworkEntity *viewer, MafiaNet::PeerGuid viewerGUID, std::unordered_set<NetworkEntity *> &out, size_t *candidatesOut = nullptr);
 
       private:
         // Range query on the configured ground plane; the set dedupes per-cell hits.
diff --git a/code/framework/src/networking/replication/network_entity.cpp b/code/framework/src/networking/replication/network_entity.cpp
index f76a37d34..7507cc5b8 100644
--- a/code/framework/src/networking/replication/network_entity.cpp
+++ b/code/framework/src/networking/replication/network_entity.cpp
@@ -13,6 +13,8 @@
 #include <mafianet/GetTime.h>
 #include <utils/time.h>
 
+#include <chrono>
+
 namespace Framework::Networking::Replication {
     namespace {
         // Serialize channel split: the pose rides an unreliable-sequenced channel (a dropped frame is
@@ -151,6 +153,7 @@ namespace Framework::Networking::Replication {
     }
 
     MafiaNet::RM3SerializationResult NetworkEntity::Serialize(MafiaNet::SerializeParameters *serializeParameters) {
+        const auto serializeStart             = std::chrono::steady_clock::now();
         serializeParameters->messageTimestamp = MafiaNet::GetTime();
 
         // The epoch rides raw at the head of each channel: it must be present in every update (a VDS
@@ -174,9 +177,14 @@ namespace Framework::Networking::Replication {
         SerializeBaseFields(fields);
         SerializeFields(fields);
         _vds.EndSerialize(&ctx);
-        serializeParameters->pro[kStateChannel].reliability    = MafiaNet::Reliability::ReliableOrdered;
+        serializeParameters->pro[kStateChannel].reliability     = MafiaNet::Reliability::ReliableOrdered;
         serializeParameters->pro[kStateChannel].orderingChannel = kStateChannel;
 
+        if (auto *manager = Manager()) {
+            const uint64_t bytes = static_cast<uint64_t>(serializeParameters->outputBitstream[kTransformChannel].GetNumberOfBytesUsed()) + static_cast<uint64_t>(serializeParameters->outputBitstream[kStateChannel].GetNumberOfBytesUsed());
+            manager->RecordSerialization(std::chrono::duration<double>(std::chrono::steady_clock::now() - serializeStart).count(), bytes);
+        }
+
         // Both channels carry recipient-identical bytes, so broadcast-identically: ReplicaManager3
         // serializes once per tick, reuses the bytes for every connection, and suppresses each channel
         // whose bytes are unchanged. Per-connection filtering (owner exclusion) still happens upstream
@@ -188,6 +196,9 @@ namespace Framework::Networking::Replication {
         // Server authority gate (applies to both channels): only accept updates from the entity's
         // current owner, rejecting a stale owner whose in-flight packets land after a handover.
         if (IsServerPeer() && deserializeParameters->sourceConnection && MafiaNet::ToPeerGuid(deserializeParameters->sourceConnection->GetRakNetGUID()) != ownerGUID) {
+            if (auto *mgr = Manager()) {
+                mgr->RecordRejectedNonOwnerUpdate();
+            }
             return;
         }
 
@@ -203,6 +214,9 @@ namespace Framework::Networking::Replication {
                 SerializeTransform(transform);
                 transformUpdated = true;
             }
+            else if (auto *mgr = Manager()) {
+                mgr->RecordStaleEpochDrop(kTransformChannel);
+            }
         }
 
         // Channel 1 — state.
@@ -217,6 +231,9 @@ namespace Framework::Networking::Replication {
                 SerializeFields(fields);
                 _vds.EndDeserialize(&ctx);
             }
+            else if (auto *mgr = Manager()) {
+                mgr->RecordStaleEpochDrop(kStateChannel);
+            }
         }
 
         // Already shifted to our local clock by RakPeer; do not subtract GetClockDifferential.
diff --git a/code/framework/src/networking/replication/replication_manager.cpp b/code/framework/src/networking/replication/replication_manager.cpp
index ecf378568..9980546cb 100644
--- a/code/framework/src/networking/replication/replication_manager.cpp
+++ b/code/framework/src/networking/replication/replication_manager.cpp
@@ -12,6 +12,8 @@
 #include "entity_registry.h"
 #include "replication_connection.h"
 
+#include <chrono>
+
 namespace Framework::Networking::Replication {
     namespace {
         // Raw RPC: the tail is the entity's polymorphic SerializeForcedState payload.
@@ -34,7 +36,7 @@ namespace Framework::Networking::Replication {
         };
     } // namespace
 
-    ReplicationManager::ReplicationManager() = default;
+    ReplicationManager::ReplicationManager()  = default;
     ReplicationManager::~ReplicationManager() = default;
 
     void ReplicationManager::ConfigureGrid(float cellSize, float worldMin, float worldMax) {
@@ -72,6 +74,63 @@ namespace Framework::Networking::Replication {
             });
             _clientRPCsRegistered = true;
         }
+
+        InitMetrics();
+    }
+
+    void ReplicationManager::InitMetrics() {
+        auto &reg           = Metrics::Registry::Get();
+        _replCreated        = reg.RegisterCounter("fw_repl_entities_created_total", "Replicated entities created");
+        _replDestroyed      = reg.RegisterCounter("fw_repl_entities_destroyed_total", "Replicated entities destroyed");
+        _interestCandidates = reg.RegisterCounter("fw_repl_interest_candidates_total", "Entities evaluated for interest per query (pre-filter)");
+        _interestSelected   = reg.RegisterCounter("fw_repl_interest_selected_total", "Entities added to an interest set per query (post-filter)");
+        _interestRebuildDur        = reg.RegisterHistogram("fw_repl_interest_rebuild_duration_seconds", "Interest index rebuild duration", Metrics::Buckets::Exponential(0.00005, 2.0, 8));
+        _forcedStates              = reg.RegisterCounter("fw_repl_forced_states_total", "Server->owner forced-state overrides sent");
+        _ownerChanges              = reg.RegisterCounter("fw_repl_owner_changes_total", "Entity ownership changes");
+        _staleEpochTransform       = reg.RegisterCounter("fw_repl_stale_epoch_drops_total", "Owner updates dropped for stale state epoch", {{"channel", "transform"}});
+        _staleEpochState           = reg.RegisterCounter("fw_repl_stale_epoch_drops_total", "Owner updates dropped for stale state epoch", {{"channel", "state"}});
+        _rejectedNonOwner          = reg.RegisterCounter("fw_repl_rejected_nonowner_updates_total", "Updates rejected by the server authority gate (non-owner sender)");
+        _serializeDuration         = reg.RegisterHistogram("fw_repl_serialize_duration_seconds", "Per-entity replication serializer wall time", Metrics::Buckets::Exponential(0.00001, 4.0, 9));
+        _serializedEntities        = reg.RegisterCounter("fw_repl_serialized_entities_total", "Entity serializer invocations");
+        _serializedBytes           = reg.RegisterCounter("fw_repl_serialized_bytes_total", "Replication payload bytes produced before transport processing");
+        _serializedEntitiesPerTick = reg.RegisterHistogram("fw_repl_serialized_entities_per_tick", "Entity serializer invocations between network ticks", Metrics::Buckets::Explicit({1, 4, 16, 64, 256, 1024, 4096, 16384}));
+        _serializedBytesPerTick    = reg.RegisterHistogram("fw_repl_serialized_bytes_per_tick", "Replication payload bytes produced between network ticks", Metrics::Buckets::Explicit({64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304}));
+        _replEntities = reg.RegisterGauge("fw_repl_entities", "Live replicated entities");
+        _replEntities->Set(0.0);
+    }
+
+    void ReplicationManager::RecordStaleEpochDrop(int channel) {
+        if (channel == 0) {
+            if (_staleEpochTransform) {
+                _staleEpochTransform->Inc();
+            }
+        }
+        else if (_staleEpochState) {
+            _staleEpochState->Inc();
+        }
+    }
+
+    void ReplicationManager::RecordRejectedNonOwnerUpdate() {
+        if (_rejectedNonOwner) {
+            _rejectedNonOwner->Inc();
+        }
+    }
+
+    void ReplicationManager::RecordSerialization(double durationSeconds, uint64_t bytes) {
+        if (!_isServer) {
+            return;
+        }
+        if (_serializeDuration) {
+            _serializeDuration->Observe(durationSeconds);
+        }
+        if (_serializedEntities) {
+            _serializedEntities->Inc();
+        }
+        if (bytes && _serializedBytes) {
+            _serializedBytes->Inc(bytes);
+        }
+        _serializedEntitiesThisTick.fetch_add(1, std::memory_order_relaxed);
+        _serializedBytesThisTick.fetch_add(bytes, std::memory_order_relaxed);
     }
 
     void ReplicationManager::ForceState(NetworkEntity *entity) {
@@ -80,6 +139,9 @@ namespace Framework::Networking::Replication {
         if (!entity || !_owner || !_isServer || entity->ownerGUID == MafiaNet::UNASSIGNED_PEER_GUID) {
             return;
         }
+        if (_forcedStates) {
+            _forcedStates->Inc();
+        }
         // The epoch fences the override: the owner echoes the new value back in its updates, and
         // Deserialize drops owner state still carrying the old one — in-flight packets sent before
         // the owner saw this override can no longer revert it.
@@ -98,6 +160,9 @@ namespace Framework::Networking::Replication {
         if (!entity) {
             return;
         }
+        if (_ownerChanges) {
+            _ownerChanges->Inc();
+        }
         entity->ownerGUID = guid;
         // Serialize to an owner is withheld, so the grant can't ride normal replication: tell the new
         // owner directly. Other peers (and any prior owner) pick it up through serialize.
@@ -123,6 +188,12 @@ namespace Framework::Networking::Replication {
         if (_onEntityCreated) {
             _onEntityCreated(entity->GetNetworkID());
         }
+        if (_replCreated) {
+            _replCreated->Inc();
+        }
+        if (_replEntities) {
+            _replEntities->Set(static_cast<double>(GetReplicaCount()));
+        }
         return entity;
     }
 
@@ -130,6 +201,9 @@ namespace Framework::Networking::Replication {
         if (!entity) {
             return;
         }
+        if (_replDestroyed) {
+            _replDestroyed->Inc();
+        }
         // Erase by value, not by ownerGUID: the owner key may have been reassigned since SetViewer,
         // and on a respawn flow (SetViewer(newAvatar) then DestroyEntity(oldAvatar)) an erase by key
         // would take out the replacement's mapping and silence that connection's streaming.
@@ -149,6 +223,9 @@ namespace Framework::Networking::Replication {
         // BroadcastDestruction must precede deletion; ~Replica3 dereferences automatically.
         entity->BroadcastDestruction();
         delete entity;
+        if (_replEntities) {
+            _replEntities->Set(static_cast<double>(GetReplicaCount()));
+        }
     }
 
     NetworkEntity *ReplicationManager::GetEntityByNetworkID(MafiaNet::NetworkID networkId) const {
@@ -201,14 +278,42 @@ namespace Framework::Networking::Replication {
         if (!_isServer) {
             return;
         }
+        const uint64_t entitiesLastTick = _serializedEntitiesThisTick.exchange(0, std::memory_order_relaxed);
+        const uint64_t bytesLastTick    = _serializedBytesThisTick.exchange(0, std::memory_order_relaxed);
+        if (_hasSerializationWindow) {
+            if (_serializedEntitiesPerTick) {
+                _serializedEntitiesPerTick->Observe(static_cast<double>(entitiesLastTick));
+            }
+            if (_serializedBytesPerTick) {
+                _serializedBytesPerTick->Observe(static_cast<double>(bytesLastTick));
+            }
+        }
+        _hasSerializationWindow = true;
+
+        const auto start = std::chrono::steady_clock::now();
         _interest.BeginRebuild();
         ForEachEntity([this](NetworkEntity *entity) {
             _interest.Insert(entity);
         });
+        if (_replEntities) {
+            _replEntities->Set(static_cast<double>(GetReplicaCount()));
+        }
+        if (_interestRebuildDur) {
+            const double secs = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+            _interestRebuildDur->Observe(secs);
+        }
     }
 
     void ReplicationManager::CollectInterest(NetworkEntity *viewer, MafiaNet::PeerGuid viewerGUID, std::unordered_set<NetworkEntity *> &out) {
-        _interest.CollectVisible(viewer, viewerGUID, out);
+        const size_t before = out.size();
+        size_t candidates   = 0;
+        _interest.CollectVisible(viewer, viewerGUID, out, &candidates);
+        if (_interestCandidates) {
+            _interestCandidates->Inc(static_cast<uint64_t>(candidates));
+        }
+        if (_interestSelected) {
+            _interestSelected->Inc(static_cast<uint64_t>(out.size() - before));
+        }
     }
 
     void ReplicationManager::OnClosedConnection(const MafiaNet::SystemAddress &systemAddress, MafiaNet::RakNetGUID rakNetGUID, MafiaNet::PI2_LostConnectionReason lostConnectionReason) {
diff --git a/code/framework/src/networking/replication/replication_manager.h b/code/framework/src/networking/replication/replication_manager.h
index 0902216cf..a7b714fcc 100644
--- a/code/framework/src/networking/replication/replication_manager.h
+++ b/code/framework/src/networking/replication/replication_manager.h
@@ -17,9 +17,11 @@
 #include <mafianet/ReplicaManager3.h>
 #include <mafianet/peerinterface.h>
 
-#include <glm/glm.hpp>
 #include <function2.hpp>
+#include <glm/glm.hpp>
+#include <metrics/registry.h>
 
+#include <atomic>
 #include <cstdint>
 #include <unordered_map>
 #include <unordered_set>
@@ -35,7 +37,7 @@ namespace Framework::Networking::Replication {
     // creates/destroys entities, resolves them by NetworkID, tracks each connection's "viewer"
     // entity, and drives an InterestGrid that ReplicationConnection::QueryReplicaList reads for
     // interest management.
-    class ReplicationManager final : public MafiaNet::ReplicaManager3 {
+    class ReplicationManager final: public MafiaNet::ReplicaManager3 {
       public:
         ReplicationManager();
         ~ReplicationManager();
@@ -141,19 +143,45 @@ namespace Framework::Networking::Replication {
         MafiaNet::Connection_RM3 *AllocConnection(const MafiaNet::SystemAddress &systemAddress, MafiaNet::RakNetGUID rakNetGUID) const override;
         void DeallocConnection(MafiaNet::Connection_RM3 *connection) const override;
 
+        void RecordStaleEpochDrop(int channel);
+        void RecordRejectedNonOwnerUpdate();
+        void RecordSerialization(double durationSeconds, uint64_t bytes);
+
       private:
-        bool _isServer    = false;
-        MafiaNet::PeerGuid _myGUID  = MafiaNet::UNASSIGNED_PEER_GUID;
+        bool _isServer             = false;
+        MafiaNet::PeerGuid _myGUID = MafiaNet::UNASSIGNED_PEER_GUID;
         // Server-side monotonic NetworkID allocator. Starts at 1 (0 reads as "none" in game code) and
         // stays well within JavaScript's safe-integer range so scripting can hold ids as plain numbers.
         // Bumped only from CreateEntity on the sim thread, so it needs no synchronization.
-        uint64_t _nextNetworkId = 0;
-        NetworkPeer *_owner = nullptr;
+        uint64_t _nextNetworkId    = 0;
+        NetworkPeer *_owner        = nullptr;
         bool _clientRPCsRegistered = false;
         InterestGrid _interest;
         std::unordered_map<MafiaNet::PeerGuid, NetworkEntity *> _viewers;
         fu2::function<void(MafiaNet::PeerGuid) const> _onClientDisconnect;
         fu2::function<void(uint64_t) const> _onEntityCreated;
         fu2::function<void(uint64_t) const> _onEntityDestroyed;
+
+        Metrics::Counter *_replCreated                 = nullptr;
+        Metrics::Counter *_replDestroyed               = nullptr;
+        Metrics::Gauge *_replEntities                  = nullptr;
+        Metrics::Counter *_interestCandidates          = nullptr;
+        Metrics::Counter *_interestSelected            = nullptr;
+        Metrics::Histogram *_interestRebuildDur        = nullptr;
+        Metrics::Counter *_forcedStates                = nullptr;
+        Metrics::Counter *_ownerChanges                = nullptr;
+        Metrics::Counter *_staleEpochTransform         = nullptr;
+        Metrics::Counter *_staleEpochState             = nullptr;
+        Metrics::Counter *_rejectedNonOwner            = nullptr;
+        Metrics::Histogram *_serializeDuration         = nullptr;
+        Metrics::Counter *_serializedEntities          = nullptr;
+        Metrics::Counter *_serializedBytes             = nullptr;
+        Metrics::Histogram *_serializedEntitiesPerTick = nullptr;
+        Metrics::Histogram *_serializedBytesPerTick    = nullptr;
+        std::atomic<uint64_t> _serializedEntitiesThisTick {0};
+        std::atomic<uint64_t> _serializedBytesThisTick {0};
+        bool _hasSerializationWindow = false;
+
+        void InitMetrics();
     };
 } // namespace Framework::Networking::Replication
diff --git a/code/framework/src/scripting/builtins/events.cpp b/code/framework/src/scripting/builtins/events.cpp
index d1d8ff8a8..3a5fd153e 100644
--- a/code/framework/src/scripting/builtins/events.cpp
+++ b/code/framework/src/scripting/builtins/events.cpp
@@ -14,9 +14,30 @@
 #include <core_modules.h>
 #include <integrations/shared/rpc/emit_script_event.h>
 #include <logging/logger.h>
+#include <metrics/registry.h>
 #include <networking/network_peer.h>
 
-namespace Framework::Scripting::Builtins {
+#include <chrono>
+#include <mutex>
+
+namespace Framework::Scripting {
+    namespace {
+        Metrics::Counter   *g_scriptEventsIn  = nullptr;
+        Metrics::Counter   *g_scriptEventsOut = nullptr;
+        Metrics::Histogram *g_scriptEventDur  = nullptr;
+        Metrics::Counter   *g_scriptErrors    = nullptr;
+        std::once_flag g_scriptMetricsOnce;
+
+        void EnsureScriptMetrics() {
+            std::call_once(g_scriptMetricsOnce, [] {
+                auto &reg = Metrics::Registry::Get();
+                g_scriptEventsIn  = reg.RegisterCounter("fw_script_events_total", "Script events dispatched", {{"direction", "inbound"}});
+                g_scriptEventsOut = reg.RegisterCounter("fw_script_events_total", "Script events dispatched", {{"direction", "outbound"}});
+                g_scriptEventDur  = reg.RegisterHistogram("fw_script_event_duration_seconds", "Synchronous script event handler dispatch duration", Metrics::Buckets::Exponential(0.00005, 4.0, 6));
+                g_scriptErrors    = reg.RegisterCounter("fw_script_errors_total", "Script event handlers that threw");
+            });
+        }
+    } // namespace
 
     // Context for AllSettled callback - holds resolver, error message, and owner for cleanup
     // Defined early so destructor can access it
@@ -47,12 +68,15 @@ namespace Framework::Scripting::Builtins {
     }
 
     void Events::Register(v8::Isolate *isolate, v8::Local<v8::Context> context, v8::Local<v8::Object> target, ResourceManager *resourceManager, bool isClient) {
+        EnsureScriptMetrics();
+
         // Reuse the context across repeated Register() calls; never reallocate. Its address is
         // baked into non-owning v8::Externals (template data and on() unsubscribe closures) that
         // outlive this call, so replacing it would dangle them. Contents are invariant anyway.
         if (!_callbackContext) {
             _callbackContext = std::make_unique<CallbackContext>();
         }
+
         _callbackContext->events          = this;
         _callbackContext->resourceManager = resourceManager;
         _callbackContext->valid.store(true, std::memory_order_release);
@@ -233,6 +257,9 @@ namespace Framework::Scripting::Builtins {
         Framework::Integrations::Shared::RPC::EmitScriptEvent ev;
         ev.FromParameters(eventName, payload);
         peer->BroadcastRPC(ev);
+        if (g_scriptEventsOut) {
+            g_scriptEventsOut->Inc();
+        }
     }
 
     void Events::RegisterHandler(v8::Isolate *isolate, ResourceManager *manager, std::string_view eventName, v8::Local<v8::Function> handler, bool once, HandlerScope scope) {
@@ -479,6 +506,10 @@ namespace Framework::Scripting::Builtins {
                 std::string errorStr = FormatV8Exception(isolate, tryCatch, "Unknown error in event handler");
                 Logging::GetLogger(FRAMEWORK_INNER_SCRIPTING)->error("[{}] Event '{}' handler error: {}", logContext, eventName, errorStr);
 
+                if (g_scriptErrors) {
+                    g_scriptErrors->Inc();
+                }
+
                 // Create rejected promise for this handler
                 v8::Local<v8::Promise::Resolver> errResolver = v8::Promise::Resolver::New(context).ToLocalChecked();
                 errResolver->Reject(context, tryCatch.Exception()).Check();
@@ -680,6 +711,11 @@ namespace Framework::Scripting::Builtins {
     v8::Local<v8::Promise> Events::EmitInternal(v8::Isolate *isolate, v8::Local<v8::Context> context, const std::string &eventName, const std::vector<v8::Local<v8::Value>> &args, const std::string &targetResource, HandlerScope scope) {
         v8::EscapableHandleScope handleScope(isolate);
 
+        if (scope == HandlerScope::Client) {
+            if (g_scriptEventsIn) {
+                g_scriptEventsIn->Inc();
+            }
+        }
         // Create Promise resolver
         v8::Local<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(context).ToLocalChecked();
         v8::Local<v8::Promise> promise            = resolver->GetPromise();
@@ -724,7 +760,11 @@ namespace Framework::Scripting::Builtins {
         }
 
         // Invoke handlers and collect results as promises
+        const auto invokeStart = std::chrono::steady_clock::now();
         v8::Local<v8::Array> promises = InvokeHandlersToPromiseArray(isolate, context, handlersToCall, args, eventName);
+        if (g_scriptEventDur) {
+            g_scriptEventDur->Observe(std::chrono::duration<double>(std::chrono::steady_clock::now() - invokeStart).count());
+        }
 
         // Aggregate results using Promise.allSettled
         AggregateWithAllSettled(isolate, context, promises, resolver, "One or more event handlers failed");
@@ -899,7 +939,11 @@ namespace Framework::Scripting::Builtins {
         }
 
         // Invoke handlers and collect results as promises
+        const auto invokeStart = std::chrono::steady_clock::now();
         v8::Local<v8::Array> promises = InvokeHandlersToPromiseArray(isolate, context, handlersToCall, eventArgs, eventName);
+        if (g_scriptEventDur) {
+            g_scriptEventDur->Observe(std::chrono::duration<double>(std::chrono::steady_clock::now() - invokeStart).count());
+        }
 
         // Aggregate results using Promise.allSettled
         events->AggregateWithAllSettled(isolate, context, promises, resolver, "One or more local event handlers failed");
diff --git a/code/framework/src/scripting/resource/resource_manager.cpp b/code/framework/src/scripting/resource/resource_manager.cpp
index 9b5f519ac..56dc5c09c 100644
--- a/code/framework/src/scripting/resource/resource_manager.cpp
+++ b/code/framework/src/scripting/resource/resource_manager.cpp
@@ -11,16 +11,28 @@
 #include "../builtins/events.h"
 #include "../builtins/messages.h"
 
+#include <metrics/registry.h>
+
 #include <algorithm>
 #include <cctype>
 #include <chrono>
 #include <cstdint>
 #include <filesystem>
+#include <mutex>
 #include <queue>
 #include <stack>
 
 namespace Framework::Scripting {
     namespace {
+        Metrics::Counter *g_scriptRestarts  = nullptr;
+        std::once_flag g_scriptRestartOnce;
+
+        void EnsureScriptRestartCounter() {
+            std::call_once(g_scriptRestartOnce, [] {
+                g_scriptRestarts = Metrics::Registry::Get().RegisterCounter("fw_script_resource_restarts_total", "Script resource restarts (manual, auto, and hot-reload)");
+            });
+        }
+
         bool IsPathInsideRoot(const std::filesystem::path &path, const std::filesystem::path &root) {
             auto canonicalRoot = std::filesystem::weakly_canonical(root);
             auto canonicalPath = std::filesystem::weakly_canonical(path);
@@ -85,6 +97,7 @@ namespace Framework::Scripting {
     ResourceManager::ResourceManager(Engine *jsEngine, const ResourceManagerConfig &config)
         : _config(config)
         , _jsEngine(jsEngine) {
+        EnsureScriptRestartCounter();
         if (_jsEngine) {
             _jsEngine->SetResourceManager(this);
         }
@@ -460,6 +473,9 @@ namespace Framework::Scripting {
                 affected.insert(affected.end(), a.begin(), a.end());
             }
         }
+        if (!affected.empty() && g_scriptRestarts) {
+            g_scriptRestarts->Inc(affected.size());
+        }
         return ResourceOperationResult::Ok(affected);
     }
 
@@ -539,6 +555,9 @@ namespace Framework::Scripting {
                 affected.insert(affected.end(), a.begin(), a.end());
             }
         }
+        if (!affected.empty() && g_scriptRestarts) {
+            g_scriptRestarts->Inc(affected.size());
+        }
         return ResourceOperationResult::Ok(affected);
     }
 
diff --git a/code/tests/CMakeLists.txt b/code/tests/CMakeLists.txt
index b2baca9a1..c3e1493c7 100644
--- a/code/tests/CMakeLists.txt
+++ b/code/tests/CMakeLists.txt
@@ -3,6 +3,9 @@ add_executable(FrameworkTests framework_ut.cpp)
 target_include_directories(FrameworkTests PRIVATE . ../framework/src)
 target_link_libraries(FrameworkTests Framework FrameworkServer libnode)
 
+if(FW_METRICS_BACKEND STREQUAL "prometheus")
+    target_compile_definitions(FrameworkTests PRIVATE FW_METRICS_BACKEND_PROMETHEUS=1)
+endif()
 
 # Tests use Node.js APIs through the scripting engine
 target_compile_definitions(FrameworkTests PRIVATE NODE_WANT_INTERNALS=1)
diff --git a/code/tests/framework_ut.cpp b/code/tests/framework_ut.cpp
index d88e1017e..317c9a1af 100644
--- a/code/tests/framework_ut.cpp
+++ b/code/tests/framework_ut.cpp
@@ -18,6 +18,7 @@
 #include "modules/state_machine_ut.h"
 #include "modules/persistent_config_ut.h"
 #include "modules/snapshot_buffer_ut.h"
+#include "modules/metrics_ut.h"
 
 // Scripting tests
 #include "modules/engine_ut.h"
@@ -38,6 +39,7 @@ int main() {
     UNIT_MODULE(state_machine);
     UNIT_MODULE(persistent_config);
     UNIT_MODULE(snapshot_buffer);
+    UNIT_MODULE(metrics);
 
     // Scripting tests
     UNIT_MODULE(engine);
diff --git a/code/tests/modules/metrics_ut.h b/code/tests/modules/metrics_ut.h
new file mode 100644
index 000000000..74b0b44d6
--- /dev/null
+++ b/code/tests/modules/metrics_ut.h
@@ -0,0 +1,220 @@
+/*
+ * MafiaHub OSS license
+ * Copyright (c) 2021-2026, MafiaHub. All rights reserved.
+ *
+ * This file comes from MafiaHub, hosted at https://github.com/MafiaHub/Framework.
+ * See LICENSE file in the source repository for information regarding licensing.
+ */
+
+#pragma once
+
+#include "jobs/job_system.h"
+#include "metrics/registry.h"
+
+#include <atomic>
+#include <string>
+#include <vector>
+
+namespace {
+    bool RunScheduleBatchTest(size_t batchSize) {
+        Framework::Jobs::JobSystemConfig config;
+        config.workerThreadCount = 2;
+        config.fiberPoolSize     = 32;
+        Framework::Jobs::JobSystem jobs(config);
+        if (jobs.Init() != Framework::Jobs::JobSystemError::JOB_SYSTEM_NONE) {
+            return false;
+        }
+
+        std::vector<int> values {1, 2, 3, 4, 5};
+        std::atomic<bool> receivedScheduler = true;
+        jobs.ScheduleBatch(
+            values,
+            [&receivedScheduler](ftl::TaskScheduler *scheduler, int *value) {
+                if (!scheduler) {
+                    receivedScheduler.store(false, std::memory_order_relaxed);
+                }
+                *value *= 2;
+            },
+            batchSize, ftl::TaskPriority::High);
+
+        const std::vector<int> expected {2, 4, 6, 8, 10};
+        return receivedScheduler.load(std::memory_order_relaxed) && values == expected;
+    }
+} // namespace
+
+#if defined(FW_METRICS_BACKEND_PROMETHEUS)
+
+MODULE(metrics, {
+    using Framework::Metrics::Buckets;
+    using Framework::Metrics::Counter;
+    using Framework::Metrics::Gauge;
+    using Framework::Metrics::Histogram;
+    using Framework::Metrics::Registry;
+
+    auto &reg = Registry::Get();
+
+    IT("reports exporter capability", {
+        EQUALS(reg.HasExporter(), true);
+        EQUALS(reg.ContentType(), "text/plain; version=0.0.4");
+    });
+
+    IT("renders a counter with HELP/TYPE and its value", {
+        Counter *c = reg.RegisterCounter("ut_exposition_counter_total", "exposition test counter");
+        c->Inc(5);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("# TYPE ut_exposition_counter_total counter") != std::string::npos, true);
+        EQUALS(out.find("# HELP ut_exposition_counter_total exposition test counter") != std::string::npos, true);
+        EQUALS(out.find("ut_exposition_counter_total 5") != std::string::npos, true);
+    });
+
+    IT("renders a labeled counter child with its label set", {
+        Counter *c = reg.RegisterCounter("ut_labeled_counter_total", "labeled test counter", {{"stage", "auth"}});
+        c->Inc();
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("ut_labeled_counter_total{stage=\"auth\"} 1") != std::string::npos, true);
+    });
+
+    IT("re-registering the same name+labels aliases the same underlying child", {
+        Counter *a = reg.RegisterCounter("ut_idempotent_counter_total", "idempotent test counter", {{"k", "v"}});
+        Counter *b = reg.RegisterCounter("ut_idempotent_counter_total", "idempotent test counter", {{"k", "v"}});
+        a->Inc(3);
+        b->Inc(2);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("ut_idempotent_counter_total{k=\"v\"} 5") != std::string::npos, true);
+    });
+
+    IT("renders a gauge value set via Set", {
+        Gauge *g = reg.RegisterGauge("ut_exposition_gauge", "exposition test gauge");
+        g->Set(42.0);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("# TYPE ut_exposition_gauge gauge") != std::string::npos, true);
+        EQUALS(out.find("ut_exposition_gauge 42") != std::string::npos, true);
+    });
+
+    IT("renders concurrent-style gauge increments and decrements", {
+        Gauge *g = reg.RegisterGauge("ut_additive_gauge", "additive gauge test");
+        g->Set(0.0);
+        g->Add(3.0);
+        g->Add(-1.0);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("ut_additive_gauge 2") != std::string::npos, true);
+    });
+
+    IT("renders a histogram with TYPE, +Inf bucket, count and sum", {
+        Histogram *h = reg.RegisterHistogram("ut_exposition_hist_seconds", "exposition test histogram", Buckets::Exponential(0.00005, 4.0, 6));
+        h->Observe(0.001);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("# TYPE ut_exposition_hist_seconds histogram") != std::string::npos, true);
+        EQUALS(out.find("ut_exposition_hist_seconds_bucket{le=\"+Inf\"} 1") != std::string::npos, true);
+        EQUALS(out.find("ut_exposition_hist_seconds_count 1") != std::string::npos, true);
+        const std::string needle = "ut_exposition_hist_seconds_bucket{le=\"";
+        size_t pos = 0, finite = 0;
+        while ((pos = out.find(needle, pos)) != std::string::npos) {
+            if (out.compare(pos + needle.size(), 4, "+Inf") != 0) {
+                ++finite;
+            }
+            pos += needle.size();
+        }
+        EQUALS(finite, 6);
+    });
+
+    IT("keeps labeled histogram children in one family", {
+        const auto buckets = Buckets::Explicit({0.001, 0.01, 0.1});
+        Histogram *high    = reg.RegisterHistogram("ut_labeled_hist_seconds", "labeled histogram test", buckets, {{"priority", "high"}});
+        Histogram *normal  = reg.RegisterHistogram("ut_labeled_hist_seconds", "labeled histogram test", buckets, {{"priority", "normal"}});
+        high->Observe(0.002);
+        normal->Observe(0.02);
+        std::string out;
+        reg.Render(out);
+        EQUALS(out.find("ut_labeled_hist_seconds_count{priority=\"high\"} 1") != std::string::npos, true);
+        EQUALS(out.find("ut_labeled_hist_seconds_count{priority=\"normal\"} 1") != std::string::npos, true);
+    });
+
+    IT("records job queue, active, wait, and execution metrics", {
+        Framework::Jobs::JobSystemConfig config;
+        config.workerThreadCount = 2;
+        config.fiberPoolSize     = 32;
+        Framework::Jobs::JobSystem jobs(config);
+        EQUALS(jobs.Init() == Framework::Jobs::JobSystemError::JOB_SYSTEM_NONE, true);
+
+        std::atomic<bool> ran = false;
+        auto waitGroup        = jobs.CreateWaitGroup();
+        jobs.Schedule(
+            waitGroup.get(),
+            [&ran]() {
+                ran.store(true, std::memory_order_relaxed);
+            },
+            ftl::TaskPriority::High);
+        waitGroup->Wait();
+        EQUALS(ran.load(std::memory_order_relaxed), true);
+
+        std::string out;
+        reg.Render(out);
+        const auto metricValue = [&out](const std::string &metric) {
+            const size_t metricStart = out.find(metric);
+            return metricStart == std::string::npos ? -1.0 : std::stod(out.substr(metricStart + metric.size()));
+        };
+        EQUALS(out.find("fw_jobs_queue_depth{priority=\"high\"}") != std::string::npos, true);
+        EQUALS(metricValue("fw_jobs_queue_depth{priority=\"high\"} ") >= 0.0, true);
+        EQUALS(out.find("fw_jobs_active ") != std::string::npos, true);
+        EQUALS(metricValue("fw_jobs_active ") >= 0.0, true);
+        EQUALS(out.find("fw_jobs_queue_wait_duration_seconds_count{priority=\"high\"}") != std::string::npos, true);
+        EQUALS(metricValue("fw_jobs_queue_wait_duration_seconds_count{priority=\"high\"} ") >= 1.0, true);
+        EQUALS(out.find("fw_jobs_execution_duration_seconds_count{priority=\"high\"}") != std::string::npos, true);
+        EQUALS(metricValue("fw_jobs_execution_duration_seconds_count{priority=\"high\"} ") >= 1.0, true);
+    });
+
+    IT("processes batched jobs", {
+        EQUALS(RunScheduleBatchTest(2), true);
+        EQUALS(RunScheduleBatchTest(0), true);
+    });
+
+    IT("is null-safe on a default-constructed handle", {
+        Counter nullCounter;
+        nullCounter.Inc();
+        nullCounter.Inc(10);
+        Gauge nullGauge;
+        nullGauge.Set(1.0);
+        nullGauge.Add(1.0);
+        Histogram nullHist;
+        nullHist.Observe(1.0);
+    });
+});
+
+#else
+
+MODULE(metrics, {
+    using Framework::Metrics::Buckets;
+    using Framework::Metrics::Registry;
+
+    auto &reg = Registry::Get();
+
+    IT("disables pull export", {
+        EQUALS(reg.HasExporter(), false);
+        EQUALS(reg.ContentType().empty(), true);
+        std::string out = "stale";
+        reg.Render(out);
+        EQUALS(out.empty(), true);
+    });
+
+    IT("returns safe no-op handles", {
+        reg.RegisterCounter("ut_none_counter_total", "none backend counter")->Inc();
+        auto *gauge = reg.RegisterGauge("ut_none_gauge", "none backend gauge");
+        gauge->Set(1.0);
+        gauge->Add(-1.0);
+        reg.RegisterHistogram("ut_none_histogram", "none backend histogram", Buckets::Explicit({1.0}))->Observe(1.0);
+    });
+
+    IT("processes batched jobs", {
+        EQUALS(RunScheduleBatchTest(2), true);
+        EQUALS(RunScheduleBatchTest(0), true);
+    });
+});
+
+#endif
diff --git a/vendors/CMakeLists.txt b/vendors/CMakeLists.txt
index 0c97ab274..fa33711cc 100644
--- a/vendors/CMakeLists.txt
+++ b/vendors/CMakeLists.txt
@@ -73,6 +73,10 @@ add_subdirectory(sfd)
 # Build lua
 add_subdirectory(lua-5.4.4)
 
+if(FW_METRICS_BACKEND STREQUAL "prometheus")
+    add_subdirectory(prometheus-cpp-lite EXCLUDE_FROM_ALL)
+endif()
+
 # Build Tracy (profiler client)
 # TRACY_ENABLE follows FW_PROFILING; the TracyClient target is always available
 # so Framework can link it unconditionally - it compiles to no-ops when disabled.
diff --git a/vendors/prometheus-cpp-lite/.gitignore b/vendors/prometheus-cpp-lite/.gitignore
new file mode 100644
index 000000000..ed7a2abcc
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/.gitignore
@@ -0,0 +1,4 @@
+.vs
+bin/
+out/
+CMakeSettings.json
\ No newline at end of file
diff --git a/vendors/prometheus-cpp-lite/CMakeLists.txt b/vendors/prometheus-cpp-lite/CMakeLists.txt
new file mode 100644
index 000000000..a74e44c62
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/CMakeLists.txt
@@ -0,0 +1,83 @@
+
+cmake_minimum_required(VERSION 3.12)
+project(prometheus-cpp-lite)
+
+# =============================================================================
+# Output directories
+# =============================================================================
+
+# for initialise variables: CMAKE_INSTALL_INCLUDEDIR, CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR	
+include(GNUInstallDirs)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/bin)
+
+if(WIN32)
+  foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+    string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${PROJECT_SOURCE_DIR}/bin)
+  endforeach()
+endif()
+
+# =============================================================================
+# Collect header files
+# =============================================================================
+# include all header files from header directory
+#file(GLOB PROMETHEUS_CPP_LITE_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/*.h")
+# manual include header files
+file(GLOB PROMETHEUS_CORE_HEADERS
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/core.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/atomic_floating.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/counter.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/gauge.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/histogram.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/summary.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/benchmark.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/info.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/file_saver.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/include/prometheus/simpleapi.h"
+)
+
+set(PROMETHEUS_CPP_LITE_HEADERS ${PROMETHEUS_CORE_HEADERS} ${PROMETHEUS_NETWORK_HEADERS})
+
+# =============================================================================
+# Primary target: prometheus-cpp-lite (always header-only)
+# =============================================================================
+
+add_library               (${PROJECT_NAME} INTERFACE)
+target_sources            (${PROJECT_NAME} INTERFACE ${PROMETHEUS_CPP_LITE_HEADERS})
+target_include_directories(${PROJECT_NAME} INTERFACE $<BUILD_INTERFACE:  ${CMAKE_CURRENT_SOURCE_DIR}/include>
+                                                     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+# =============================================================================
+# Secondary target: prometheus-cpp-lite-simpleapi (static, with global objects)
+# =============================================================================
+
+add_library               (${PROJECT_NAME}-full STATIC "src/simpleapi.cpp" "include/prometheus/prometheus.h")
+target_link_libraries     (${PROJECT_NAME}-full PUBLIC ${PROJECT_NAME})
+
+# =============================================================================
+# Legacy aliases (v1.0 compatibility)
+# =============================================================================
+
+if(NOT TARGET prometheus-cpp-lite-core)
+  add_library(prometheus-cpp-lite-core ALIAS ${PROJECT_NAME})
+endif()
+
+if(NOT TARGET prometheus-cpp-simpleapi)
+  add_library(prometheus-cpp-simpleapi ALIAS ${PROJECT_NAME}-full)
+endif()
+
+# it need for file_saver_t, http_pusher_t, http_puller_t
+if(NOT WIN32)
+  find_package(Threads)
+  target_link_libraries     (${PROJECT_NAME} INTERFACE Threads::Threads)
+endif()
+
+# =============================================================================
+# Install
+# =============================================================================
+
+install(TARGETS ${PROJECT_NAME})
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
diff --git a/vendors/prometheus-cpp-lite/LICENSE b/vendors/prometheus-cpp-lite/LICENSE
new file mode 100644
index 000000000..266f827c8
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 biaks (ianiskr@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendors/prometheus-cpp-lite/README.md b/vendors/prometheus-cpp-lite/README.md
new file mode 100644
index 000000000..5a0e01ec5
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/README.md
@@ -0,0 +1,861 @@
+# prometheus-cpp-lite
+
+[![Build examples](https://github.com/biaks/prometheus-cpp-lite/actions/workflows/cmake.yml/badge.svg)](https://github.com/biaks/prometheus-cpp-lite/actions/workflows/cmake.yml)
+[![Build multi-platform](https://github.com/biaks/prometheus-cpp-lite/actions/workflows/cmake-multi-platform.yml/badge.svg)](https://github.com/biaks/prometheus-cpp-lite/actions/workflows/cmake-multi-platform.yml)
+
+
+**Crossplatform header-only C++ library for quickly adding metrics (and profiling) functionality to C++ projects — simple, fast, dependency-free.**
+
+**Simplest usage — global registry, no boilerplate:**
+
+```cpp
+#include <prometheus/prometheus.h>
+
+int main() {
+  prometheus::gauge_metric_t   conn ("connections",   "Open connections");
+  prometheus::counter_metric_t get  ("http_requests", "HTTP requests", {{"method", "GET"}});
+  prometheus::counter_metric_t post ("http_requests", "HTTP requests", {{"method", "POST"}});
+  prometheus::http_server.start ("127.0.0.1:9100"); // default all metrics are exposed at /metrics
+
+  for (;;) {
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    conn  = 10 + std::rand() % 50;
+    get  += 1;
+    post += 2;
+  }
+}
+```
+
+**Full control — registry, families, labels, custom value types, multi endpoints and more (see below):**
+
+```cpp
+#include <prometheus/prometheus.h>
+using namespace prometheus;
+
+int main() {
+  registry_t          registry;
+  gauge_metric_t      conn   (registry, "connections",   "Open connections", {{"host", "web01"}});
+  family_t            reqs   (registry, "http_requests", "HTTP requests",    {{"host", "web01"}});
+  counter_t<double&>  get    (reqs,     {{"method", "GET"},  {"status", "200"}});
+  counter_t<double&>  post   (reqs,     {{"method", "POST"}, {"status", "201"}});
+  http_server_t       server (registry, "127.0.0.1:9100", "/metrics/app", log_e::info);
+
+  registry_t          registry2;
+  server.add_endpoint(registry2, "/metrics/sys");
+
+  for (;;) {
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    conn  = 10 + std::rand() % 50;
+    get  += 1.5;
+    post += 0.75;
+  }
+}
+```
+
+---
+
+
+
+## Why another Prometheus library for C++?
+
+The main C++ Prometheus library - [jupp0r/prometheus-cpp](https://github.com/jupp0r/prometheus-cpp) - is mature and battle-tested, but it was designed with a Java mindset:
+
+|                     | **prometheus-cpp**                 | **prometheus-cpp-lite**                                           |
+|---------------------|------------------------------------|-------------------------------------------------------------------|
+| Architecture        | Split into 3 libraries (`core`, `pull`, `push`) with separate `.h`/`.cpp` pairs per class | Single header-only library - just copy the headers |
+| Dependencies        | zlib, libcurl, civetweb (or beast) | **None**                                                          |
+| Build system        | Bazel (primary) + CMake            | CMake or **just copy files**                                      |
+| Minimum boilerplate | ~20 lines to create one counter    | **2 lines** to create a counter and expose it (with global registry, see below) |
+| Value types         | `double` only                      | `uint64_t` (default), `double`, `int64_t`, or any arithmetic type |
+| Metric types        | `counter`, `gauge`, `histogram`, `summary`, `info` | [`counter`](examples/test_counter.cpp), [`gauge`](examples/test_gauge.cpp), [`histogram`](examples/test_histogram.cpp), [`summary`](examples/test_summary.cpp), `info`, **[`benchmark`](examples/test_benchmark.cpp)** - or [make your own](examples/add_custom_metric_class.cpp) |
+| C++ standard        | C++11                              | C++11                                                             |
+| Thread-safe         | Yes                                | Yes                                                               |
+
+**prometheus-cpp-lite is not a fork.** It is a ground-up rewrite focused on C++ idioms:
+operators instead of `.Increment()`, RAII instead of manual registration, zero-copy
+reference handles instead of raw pointers.
+
+**Full prometheus-cpp compatibility.** The library supports the same API style
+used by prometheus-cpp (`BuildCounter()`, `Family`, `Registry`, `Add()`, raw
+references). If you are migrating from prometheus-cpp, your existing patterns
+will work.
+
+---
+
+
+
+## Features
+
+- **Header-only**                       - no libraries to build, no linker flags, no package manager required
+- **Cross-platform**                    - works on Linux and Windows with any C++11 and higher compiler
+- **Zero dependencies**                 - pure C++ standard library (networking uses a bundled copy of [ip-sockets-cpp-lite](https://github.com/biaks/ip-sockets-cpp-lite))
+- **Low entry barrier**                 - a working counter with HTTP export is 2 lines of code (with global registry, see below)
+- **Gradual complexity**                - start simple, add families/labels/registries/custom types when needed
+- **Multiple value types**              - `uint64_t` (fast integer), `double` (Prometheus-compatible), `int64_t`, or custom
+- **Six metric types**                  - [`counter`](examples/test_counter.cpp), [`gauge`](examples/test_gauge.cpp), [`histogram`](examples/test_histogram.cpp), [`summary`](examples/test_summary.cpp), `info`, [`benchmark`](examples/test_benchmark.cpp)
+- **Three export modes**                - HTTP pull server, HTTP push (Pushgateway), file (node_exporter textfile)
+- **Simplest way with global_registry** - add metrics anywhere in your code without passing registry references
+- **prometheus-cpp compatible**         - supports the same Builder/Family/Registry API style
+- **Extensible**                        - each metric type is self-contained in one header; **you can [add your own](examples/add_custom_metric_class.cpp) metric by following the same pattern**
+- **Detailed examples**                 - see the [examples](examples) folder for usage patterns
+
+---
+
+
+
+## Quick start
+
+### Installation
+
+**Option A - Copy headers (simplest):**
+
+Copy the `include/prometheus` directory into your project and add it to
+include paths. If you need HTTP pull or push support, also copy the headers
+from `3rdparty/ip-sockets-cpp-lite/include/`.
+
+**Option B - CMake subdirectory:**
+
+```cmake
+add_subdirectory(prometheus-cpp-lite)
+
+# Header-only (you define global_registry yourself if you need it):
+target_link_libraries(your_target prometheus-cpp-lite)
+
+# Or with pre-defined global objects (global_registry, file_saver, http_pusher, http_server):
+target_link_libraries(your_target prometheus-cpp-lite-full)
+```
+
+**Option C - CMake FetchContent:**
+
+```cmake
+include(FetchContent)
+FetchContent_Declare(
+  prometheus-cpp-lite
+  GIT_REPOSITORY https://github.com/biaks/prometheus-cpp-lite.git
+  GIT_TAG        main
+)
+FetchContent_MakeAvailable(prometheus-cpp-lite)
+target_link_libraries(your_target prometheus-cpp-lite)
+```
+
+### All metric types at a glance
+
+```cpp
+#include <prometheus/prometheus.h>
+
+using namespace prometheus;
+
+int main() {
+  registry_t         registry;
+
+  counter_metric_t   requests (registry, "http_requests_total",  "Total requests");
+  gauge_metric_t     active   (registry, "active_connections",   "Open connections");
+  histogram_metric_t latency  (registry, "request_duration_sec", "Request latency", {}, {0.01, 0.05, 0.1, 0.5, 1.0});
+  summary_metric_t   response (registry, "response_time_sec",    "Response time",   {}, {{0.5,0.05},{0.9,0.01},{0.99,0.001}});
+  benchmark_metric_t uptime   (registry, "uptime_sec",           "Process uptime");
+  info_metric_t      info     (registry, "build_info",           "Build information", {{"version", "1.0.0"}, {"commit", "abc123"}});
+
+  http_server_t      server   (registry, {{127,0,0,1}, 9100});
+
+  // curl http://localhost:9100/metrics
+
+  uptime.start();
+  for (int i = 0; i < 60; ++i) {
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    requests++;
+    active.Set      (10    +  std::rand() % 50);
+    latency.Observe (0.001 * (std::rand() % 1000));
+    response.Observe(0.001 * (std::rand() % 500));
+  }
+  uptime.stop();
+}
+```
+
+---
+
+
+
+## Three ways to export metrics
+
+### 1. HTTP pull (recommended for long-running services)
+
+The application runs an HTTP server. Prometheus scrapes it periodically ([example](examples/provide_via_http_pull_simple.cpp)).
+
+```cpp
+#include <prometheus/prometheus.h>
+
+prometheus::registry_t       registry;
+prometheus::counter_metric_t metric (registry, "my_counter", "Example counter");
+prometheus::http_server_t    server (registry, "127.0.0.1:9100");
+// → http://localhost:9100/metrics
+```
+
+**Multiple endpoints** for different metric domains ([example](examples/provide_via_http_pull_advanced.cpp)):
+
+```cpp
+using namespace prometheus;
+auto app_registry = std::make_shared<registry_t>();
+auto sys_registry = std::make_shared<registry_t>();
+
+http_server_t server;
+server.add_endpoint(app_registry, "/metrics/app");
+server.add_endpoint(sys_registry, "/metrics/sys");
+server.start({{127,0,0,1}, 9200});
+// → http://localhost:9200/metrics/app
+// → http://localhost:9200/metrics/sys
+```
+
+### 2. HTTP push (for short-lived jobs, edge devices)
+
+Metrics are POSTed to a Pushgateway or VictoriaMetrics at a fixed interval ([example](examples/provide_via_http_push_simple.cpp)).
+
+```cpp
+#include <prometheus/prometheus.h>
+
+prometheus::registry_t       registry;
+prometheus::counter_metric_t metric (registry, "my_counter", "Example counter");
+prometheus::http_pusher_t    pusher (registry, std::chrono::seconds(5),
+                                               "http://localhost:9091/metrics/job/myapp");
+```
+
+### 3. File export (for node_exporter textfile collector)
+
+Metrics are written to a `.prom` file at a fixed interval ([example](examples/provide_via_textfile.cpp)).
+
+```cpp
+#include <prometheus/prometheus.h>
+
+prometheus::registry_t       registry;
+prometheus::counter_metric_t metric (registry, "my_counter", "Example counter");
+prometheus::file_saver_t     saver  (registry, std::chrono::seconds(5), "./metrics.prom");
+```
+
+---
+
+## Labels (dimensional data)
+
+### Directly on a metric:
+
+```cpp
+registry_t       registry;
+counter_metric_t get_count  (registry, "requests", "Requests by", {{"host", "dev"}, {"method",  "GET"}});
+counter_metric_t post_count (registry, "requests", "Requests by", {{"host", "dev"}, {"method", "POST"}});
+
+get_count++;
+post_count += 5;
+```
+
+### Using a family
+
+```cpp
+registry_t       registry;
+family_t         requests   (registry, "requests", "Requests by", {{"host", "dev"}});
+counter_metric_t get_count  (requests, {{"method",  "GET"}});
+counter_metric_t post_count (requests, {{"method", "POST"}});
+
+get_count++;
+post_count += 5;
+```
+
+Output is same:
+
+```
+# HELP http_requests HTTP requests by method
+# TYPE http_requests counter
+http_requests{host="dev", method="GET"} 1
+http_requests{host="dev", method="POST"} 5
+```
+
+---
+
+
+
+## Choosing a value type
+
+The default counter uses `uint64_t` for maximum performance.
+The default gauge uses `int64_t`.
+Both can be overridden with `double` or any other arithmetic type.
+
+**Why `uint64_t` is faster than `double` for atomics:**
+`std::atomic<uint64_t>` supports lock-free `fetch_add` on most platforms -
+a single CPU instruction.
+`std::atomic<double>` typically lacks native `fetch_add`, so every increment
+requires a compare-and-swap (CAS) loop: load the current value, compute the
+new value, attempt to store it, and retry if another thread modified it in
+between. Under contention this can be significantly slower.
+
+prometheus-cpp uses `double` for all metric types. prometheus-cpp-lite
+defaults to integer atomics where it makes sense (counters, gauges) and
+uses `double` where fractional values are required (histograms, summaries,
+benchmarks).
+
+```cpp
+// Default: uint64_t - lock-free fetch_add, fastest for integer counters
+counter_metric_t integer_counter (registry, "requests_total", "Total requests");
+integer_counter++;
+
+// Floating-point counter - CAS loop, use when you need fractional values
+counter_t<double&> fp_counter (registry, "duration_seconds_total", "Total duration");
+fp_counter += 0.42;
+```
+
+---
+
+
+
+## Global registry — add metrics to existing code in seconds
+
+The global registry is designed for the most common real-world scenario:
+**you already have a large codebase and want to add metrics without
+restructuring it.**
+
+Normally, adding metrics to existing code is painful. You need to figure out
+how to pass a registry or metric objects through your class hierarchy,
+modify constructors, add member variables, and thread references through
+layers of code that were never designed for observability.
+
+With prometheus-cpp-lite's global registry approach, none of that is
+necessary. The `prometheus-cpp-lite-full` CMake target provides ready-made
+global objects — `global_registry`, `file_saver`, `http_pusher`, and
+`http_server` — so you can create metrics anywhere in your code and start
+exposing them with a single call from any place ([example](examples/check_global_objects.cpp)).
+No plumbing required.
+
+### The workflow
+
+**1. Link against `prometheus-cpp-lite-full` in your CMakeLists.txt:**
+
+```cmake
+target_link_libraries(your_target prometheus-cpp-lite-full)
+```
+
+**2. Sprinkle metrics anywhere in your codebase — any file, any class, any function:**
+
+```cpp
+#include <prometheus/counter.h>
+
+void handle_request() {
+  prometheus::counter_metric_t requests ("http_requests_total", "Total requests");
+  requests++;
+}
+
+void handle_error() {
+  prometheus::counter_metric_t errors   ("http_errors_total",   "Total errors");
+  prometheus::counter_metric_t requests ("http_requests_total", "Total requests");
+  // ^ same metric as in handle_request() — same name, same global registry
+  errors++;
+  requests++;
+}
+```
+
+Metrics with the same name automatically refer to the same underlying
+metric in the global registry. No constructor changes, no member
+variables, no passing references around.
+
+**3. Start exposing metrics — one line, anywhere in your code:**
+
+```cpp
+#include <prometheus/prometheus.h>
+
+// Call this once at startup, e.g. in main():
+prometheus::http_server.start("127.0.0.1:9100");
+// → http://localhost:9100/metrics — all metrics from all files are here
+```
+
+That's it. Every metric you created in step 2 is automatically available
+at the HTTP endpoint ([example](examples/use_metrics_in_class_simple.cpp)).
+You can also use the other pre-defined global
+exporters:
+
+```cpp
+#include <prometheus/prometheus.h>
+
+// Write metrics to a .prom file every 5 seconds:
+prometheus::file_saver.start(std::chrono::seconds(5), "./metrics.prom");
+
+// Push metrics to Pushgateway every 10 seconds:
+prometheus::http_pusher.start(std::chrono::seconds(10), "http://pushgateway:9091/metrics/job/myapp");
+```
+
+### If you prefer pure header-only (no extra .cpp files)
+
+If you don't want any pre-compiled translation units in your project, link
+against the header-only target instead:
+
+```cmake
+target_link_libraries(your_target prometheus-cpp-lite)
+```
+
+In this case, define the global objects yourself — once, in any `.cpp` file:
+
+```cpp
+#include <prometheus/prometheus.h>
+
+// Define once, in a single .cpp file:
+namespace prometheus {
+  registry_t    global_registry;
+  http_server_t http_server (global_registry);
+}
+
+int main() {
+  prometheus::http_server.start("127.0.0.1:9100");
+  // ... rest of your application ...
+}
+```
+
+After that, metrics created anywhere via the two-argument constructor
+(`counter_metric_t m ("name", "help")`) automatically use `global_registry`,
+and the behavior is identical to `prometheus-cpp-lite-full`.
+
+---
+
+### Quick profiling with benchmark metrics
+
+The `benchmark_t` metric is especially powerful with the global registry.
+You can wrap any function call or code block with `start()`/`stop()` to
+measure its wall-clock time — without touching the function's signature,
+class hierarchy, or build dependencies. Just add two lines around the code
+you want to profile:
+
+```cpp
+#include <prometheus/benchmark.h>
+
+void process_order(const Order& order) {
+  prometheus::benchmark_metric_t timer ("process_order_seconds", "Time spent in process_order");
+  timer.start();
+
+  // ... existing code, unchanged ...
+
+  timer.stop();
+}
+```
+
+The accumulated elapsed time is immediately available at your `/metrics`
+endpoint — no separate profiling tool, no recompilation with special flags,
+no post-hoc analysis. You get real production latency data from live traffic
+([example](examples/use_benchmark_in_class_simple.cpp)).
+
+**Best practice for multithreaded code:** the `start()`/`stop()` state
+machine is local to each metric instance and is intentionally not
+thread-safe — this avoids lock overhead in hot paths. When multiple threads
+execute the same function, give each thread its own metric instance by
+adding a distinguishing label (e.g. thread index or thread name):
+
+```cpp
+#include <prometheus/benchmark.h>
+
+// Shared family — defined once (e.g. at file scope or in a class).
+prometheus::family_t worker_time ("worker_duration_seconds", "Per-thread processing time");
+
+void worker_thread_func(int thread_id) {
+  // Each thread owns its own metric — no start/stop contention.
+  prometheus::benchmark_metric_t my_timer (worker_time, {{"thread", std::to_string(thread_id)}});
+  for (;;) {
+    my_timer.start();
+    // ... do work ...
+    my_timer.stop();
+  }
+}
+```
+
+This produces separate time series per thread, which you can aggregate in
+PromQL (`sum`, `avg`, `max`) or inspect individually in Grafana:
+
+```
+# HELP worker_duration_seconds Per-thread processing time
+# TYPE worker_duration_seconds counter
+worker_duration_seconds{thread="0"} 12.345
+worker_duration_seconds{thread="1"} 11.892
+worker_duration_seconds{thread="2"} 13.017
+```
+
+This is invaluable when instrumenting legacy code — from personal
+experience, it turns a multi-day refactoring task into a few minutes of
+work.
+
+---
+
+## Info metric - expose build metadata
+
+The `info_t` metric is a gauge permanently set to `1` whose labels carry
+metadata such as version, commit hash, or build date. This is a standard
+Prometheus pattern for exposing build information that can be joined with
+other metrics in PromQL or Grafana.
+
+```cpp
+#include <prometheus/info.h>
+prometheus::info_metric_t build_info (registry, "build_info", "Build information",
+                          {{"version", "1.0.0"}, {"commit", "abc123"}, {"branch", "main"}});
+```
+
+Output:
+
+```
+# HELP build_info Build information
+# TYPE build_info gauge
+build_info{branch="main",commit="abc123",version="1.0.0"} 1
+```
+
+---
+
+
+
+## Drop-in compatibility with `prometheus-cpp`
+
+prometheus-cpp-lite ships shim headers and class aliases that make it
+**a transparent replacement** for [jupp0r/prometheus-cpp](https://github.com/jupp0r/prometheus-cpp).
+Code written for prometheus-cpp compiles and works **without any changes** —
+not even the `#include` lines need to be modified.
+
+| prometheus-cpp                                  | prometheus-cpp-lite       | Shim header                               |
+|-------------------------------------------------|---------------------------|-------------------------------------------|
+| `#include <prometheus/exposer.h>`               | ✔ provided                | redirects to `<prometheus/http_puller.h>` |
+| `#include <prometheus/gateway.h>`               | ✔ provided                | redirects to `<prometheus/http_pusher.h>` |
+| `#include <prometheus/family.h>`                | ✔ provided                | redirects to `<prometheus/core.h>`        |
+| `#include <prometheus/registry.h>`              | ✔ provided                | redirects to `<prometheus/core.h>`        |
+| `#include <prometheus/text_serializer.h>`       | ✔ provided                | redirects to `<prometheus/core.h>`        |
+| `#include <prometheus/client_metric.h>`         | ✔ provided                | redirects to `<prometheus/core.h>`        |
+| `prometheus::Exposer`                           | alias for `http_server_t` | defined in `<prometheus/http_puller.h>`   |
+| `prometheus::Gateway`                           | alias for `http_pusher_t` | defined in `<prometheus/http_pusher.h>`   |
+| `prometheus::Registry`                          | same class                | defined in `<prometheus/core.h>`          |
+| `prometheus::Family`                            | same class                | defined in `<prometheus/core.h>`          |
+| `prometheus::BuildCounter()`                    | same function             | defined in `<prometheus/counter.h>`       |
+| `prometheus::BuildGauge()`                      | same function             | defined in `<prometheus/gauge.h>`         |
+| `prometheus::BuildHistogram()`                  | same function             | defined in `<prometheus/histogram.h>`     |
+| `prometheus::BuildSummary()`                    | same function             | defined in `<prometheus/summary.h>`       |
+| `Add()`, `Increment()`, `RegisterCollectable()` | same API                  |                                           |
+
+### Example 1: Exposer (HTTP pull)
+
+The code below is **[valid prometheus-cpp code](examples/legacy_prometheus_cpp.cpp)**. It compiles and runs with
+prometheus-cpp-lite without touching a single line — just swap the library
+in your build system:
+
+```cpp
+#include <prometheus/counter.h>
+#include <prometheus/exposer.h>
+#include <prometheus/registry.h>
+
+int main() {
+  prometheus::Exposer exposer{"127.0.0.1:8080"};
+  auto registry = std::make_shared<prometheus::Registry>();
+
+  auto& family = prometheus::BuildCounter()
+                   .Name("http_reqs")
+                   .Help("HTTP requests")
+                   .Register(*registry);
+
+  auto& counter = family.Add({{"method", "GET"}});
+  exposer.RegisterCollectable(registry);
+
+  counter.Increment();
+}
+```
+
+**The same thing in prometheus-cpp-lite native API — 6 lines instead of 13:**
+
+```cpp
+#include <prometheus/prometheus.h>
+
+int main() {
+  prometheus::registry_t       registry;
+  prometheus::http_server_t    server  (registry, "127.0.0.1:8080");
+  prometheus::counter_metric_t counter (registry, "http_reqs", "HTTP requests", {{"method","GET"}});
+
+  counter++;
+}
+```
+
+### Example 2: Gateway (HTTP push)
+
+Again — **unmodified prometheus-cpp code**, works as-is:
+
+```cpp
+#include <prometheus/counter.h>
+#include <prometheus/gateway.h>
+#include <prometheus/registry.h>
+
+int main() {
+  prometheus::Gateway gateway{"localhost", "9091", "my_job", {{"instance", "host1"}}};
+  auto registry = std::make_shared<prometheus::Registry>();
+
+  auto& family = prometheus::BuildGauge()
+                   .Name("cpu_usage_percent")
+                   .Help("CPU usage")
+                   .Register(*registry);
+
+  auto& cpu_usage = family.Add({{"core", "0"}});
+  gateway.RegisterCollectable(registry);
+
+  cpu_usage.Set(0.54);
+  cpu_usage.Increment(0.09);
+  gateway.Push();
+}
+```
+
+**The same thing in prometheus-cpp-lite native API:**
+
+```cpp
+#include <prometheus/prometheus.h>
+
+int main() {
+  prometheus::registry_t       registry;
+  prometheus::http_pusher_t    pusher    (registry, std::chrono::seconds(5), "localhost", "9091", "my_job", {{"instance", "host1"}});
+  prometheus::gauge_t<double&> cpu_usage (registry, "cpu_usage_percent", "CPU usage", {{"core", "0"}});
+
+  cpu_usage  = 0.54;
+  cpu_usage += 0.09;
+}
+```
+
+Both styles can coexist in the same project — all metrics end up in the same
+registry and are serialized identically.
+
+---
+
+
+
+## API levels
+
+prometheus-cpp-lite supports several API styles. Start with the simplest and
+move to more explicit forms only when you need fine-grained control:
+
+| Level                              | Description                                         | Example                                                            |
+|------------------------------------|-----------------------------------------------------|--------------------------------------------------------------------|
+| **Simple** with `global_registry`  | Global registry, implicit family, operator syntax   | `counter_metric_t m ("name", "help", {{"k","v"}});`<br>`m++;` |
+| **Simple** with explicit `registry`| Explicit registry, implicit family, operator syntax | `registry_t r;`<br>`counter_metric_t m (r, "name", "help", {{"k","v"}});`<br>`m++;` |
+| **Family** with `global_registry`  | Global registry, explicit family with family labels | `family_t f ("name", "help", {{"k","v"}});`<br>`counter_metric_t m (f, {{"k","v"}});`<br>`m++;` |
+| **Family** with explicit `registry`| Explicit registry and family with family labels     | `registry_t r;`<br>`family_t f (r, "name", "help", {{"k","v"}});`<br>`counter_metric_t m (f, {{"k","v"}});`<br>`m++;` |
+| **Custom family**                  | Compile-time type safety for families               | `counter_family_t f ("name", "help", {{"k","v"}});`<br>`counter_metric_t m (f, {{"k","v"}});`<br>`m++;` |
+| **Custom types of metric values**  | Customisation values types of metrics               | `counter_t<double&> m ("name", "help", {{"k","v"}});`<br>`m++;` |
+| **`prometheus-cpp` compatible**    | Builder pattern, raw references                     | `auto  r = std::make_shared<prometheus::Registry>();`<br>`auto& f = BuildCounter().Name("nm").Help("hlp").Labels({{"k","v"}}).Register(r)`<br>`auto& m = f.Add({{"k","v"}});`<br>`m.Increment();` |
+
+All levels are interoperable - metrics created with any style end up in the
+same registry and are serialized together.
+
+See the [`examples/`](examples/) directory for complete working programs
+demonstrating every API level (`test_*` files).
+
+---
+
+
+
+
+## Migrating from prometheus-cpp-lite v1.0
+
+prometheus-cpp-lite v2.0 is a major update that simplifies the project
+structure, unifies the API, and adds new features — while preserving full
+backward compatibility. **Your existing v1.0 code will compile and work
+without changes.** You will only see deprecation warnings guiding you
+toward the updated API.
+
+### Structural changes
+
+|                           | v1.0                                                          | v2.0                                                   |
+|---------------------------|---------------------------------------------------------------|--------------------------------------------------------|
+| Directory layout          | `core/include/`, `simpleapi/`, `3rdpatry/`                    | `include/`, `src/`, `3rdparty/`                        |
+| CMake targets             | `prometheus-cpp-lite-core` (header-only)                      | `prometheus-cpp-lite` (header-only, simpleapi)         |
+|                           | `prometheus-cpp-simpleapi` (simpleapi, static, with globals)  | `prometheus-cpp-lite-full` (static, with globals)      |
+| Core headers              | Split: `registry.h`, `family.h`, `metric.h`, `builder.h`, …   | Unified: `core.h` (one header for all core types)      |
+| Metric headers            | Same                                                          | Same (`counter.h`, `gauge.h`, etc.)                    |
+| Umbrella header           | `simpleapi.h` (includes + global objects + simpleapi aliases) | `prometheus.h` (includes + global object declarations) |
+| Networking                | separate `Gateway` and `PushToServer`,<br> no HTTP pull server    | rewritten `http_pusher_t` (POST/PUT/DELETE,<br>sync + async, periodic + on-demand, `Gateway`-compatible)<br>+ new `http_server_t` (HTTP pull, multi-endpoint, index page, `Exposer`-compatible) |
+| Networking library        | `http-client-lite` (bundled)                                  | `ip-sockets-cpp-lite` (bundled)                        |
+| Networking headers        | `save_to_file.h`, `push_to_server.h`, `gateway.h`             | `file_saver.h`, `http_pusher.h`, `http_puller.h`       |
+| Collect values            | standalone classes for storing and serializing metric values  | each metric collects and serializes values itself      |
+| Metric ownership model    | separate classes for owning metrics and referencing them      | single template: `metric_t<T>` owns the value, `metric_t<T&>`<br> is a zero-copy reference — same class, same API |
+| Add custom metric classes | not possible                                                  | support users custom metric classes — follow the existing metric pattern  |
+
+### API changes
+
+|                            | v1.0                                                 | v2.0                                                                      |
+|----------------------------|------------------------------------------------------|---------------------------------------------------------------------------|
+| simpleAPI primary namespace| `prometheus::simpleapi::`                            | `prometheus::`                                                            |
+| Creating a family          | `simpleapi::counter_family_t f {"name", "help", {{"k","v"}}};` | `family_t f {"name", "help", {{"k","v"}}};`<br>`family_t f {registry, "name", "help", {{"k","v"}}};`<br>`counter_family_t f {"name", "help", {{"k","v"}}};`<br>`counter_family_t f {registry, "name", "help", {{"k","v"}}};` |
+| Creating a metric (simple) | `simpleapi::counter_metric_t m {"name", "help", {{"k","v"}}};` | `counter_metric_t m {"name", "help", {{"k","v"}}};`<br>`counter_metric_t m {registry, "name", "help", {{"k","v"}}};` |
+| Creating a metric in family| `simpleapi::counter_metric_t m {family.Add(l)};`     | `counter_metric_t m {family, {{"k","v"}}};`<br>`counter_metric_t m {family.Add({{"k","v"}})};` |
+| Networking classes         | `SaveToFile`, `PushToServer`                         | `file_saver_t`, `http_pusher_t`                                           |
+| HTTP pull server           | not available                                        | `http_server_t` (new)                                                     |
+| `prometheus-cpp` compat    | partial                                              | full (added `Exposer` and `Gateway` aliases)                              |
+| New metric types           | —                                                    | `info_t`                                                                  |
+
+### What stayed the same (backward compatibility)
+
+Everything below continues should to work in v2.0 — no code changes required:
+
+- **Old CMake target names.** `prometheus-cpp-lite-core` and
+  `prometheus-cpp-simpleapi` are aliases for the new targets.
+- **Old header names.** Shim headers (`registry.h`, `family.h`, `metric.h`,
+  `builder.h`, `hash.h`, `collectable.h`, `client_metric.h`,
+  `metric_family.h`, `text_serializer.h`, `save_to_file.h`,
+  `push_to_server.h`, `gateway.h`) redirect to the new headers with a
+  one-time `#pragma message` deprecation notice.
+- **Old class names.** `SaveToFile` → `file_saver_t`, `PushToServer` →
+  `http_pusher_t`, `Gateway` → `http_pusher_t` — all available as
+  `[[deprecated]]` type aliases.
+- **`prometheus::simpleapi::` namespace.** All type aliases (`counter_metric_t`,
+  `counter_family_t`, `gauge_metric_t`, etc.) are preserved with
+  `[[deprecated]]` attributes pointing to the `prometheus::` equivalents.
+- **`#include <prometheus/simpleapi.h>`** still works. It includes the new
+  umbrella header `<prometheus/prometheus.h>` (which pulls in all metric
+  headers, networking headers, and global object declarations) and provides
+  the deprecated `prometheus::simpleapi::` aliases. A `#pragma message`
+  notice suggests switching to `<prometheus/prometheus.h>`.
+
+### Step-by-step migration guide
+
+All steps are optional. Your code compiles without them — these changes
+only silence deprecation warnings and modernize your codebase.
+
+#### Step 1 — Update CMakeLists.txt
+
+Replace:
+
+```cmake
+# v1.0
+add_subdirectory("prometheus-cpp-lite")
+
+# If you need SimpleAPI and pre-defined global objects (global_registry, file_saver, etc.):
+target_link_libraries(your_target prometheus-cpp-simpleapi)
+
+# If you use only ComplexAPI or Java liked legacy API from prometheus-cpp and use local registries:
+target_link_libraries(your_target prometheus-cpp-lite-core)
+```
+
+With:
+
+```cmake
+# v2.0
+add_subdirectory("prometheus-cpp-lite")
+
+# If you need pre-defined global objects (global_registry, file_saver, http_pusher, http_server):
+target_link_libraries(your_target prometheus-cpp-lite-full)
+
+# If you need any type of API and you define global_registry yourself or use local registries only:
+target_link_libraries(your_target prometheus-cpp-lite)
+```
+
+#### Step 2 — Update `#include` directives
+
+| Old (v1.0)                       | New (v2.0)                   | Notes                                                                  |
+|----------------------------------|------------------------------|------------------------------------------------------------------------|
+| `<prometheus/simpleapi.h>`       | `<prometheus/prometheus.h>`  | Umbrella header: all metrics + networking + global object declarations |
+| `<prometheus/registry.h>`        | `<prometheus/core.h>`        | Or just include a metric header — it pulls in `core.h` automatically   |
+| `<prometheus/family.h>`          | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/metric.h>`          | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/builder.h>`         | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/hash.h>`            | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/collectable.h>`     | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/client_metric.h>`   | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/metric_family.h>`   | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/text_serializer.h>` | `<prometheus/core.h>`        |                                                                        |
+| `<prometheus/save_to_file.h>`    | `<prometheus/file_saver.h>`  |                                                                        |
+| `<prometheus/push_to_server.h>`  | `<prometheus/http_pusher.h>` |                                                                        |
+| `<prometheus/gateway.h>`         | `<prometheus/http_pusher.h>` |                                                                        |
+
+> **Tip:** You don't need to include `<prometheus/core.h>` explicitly —
+> every metric header (e.g. `<prometheus/counter.h>`) already includes it.
+> If you want everything at once, use `<prometheus/prometheus.h>`.
+
+#### Step 3 — Update namespace and class names
+
+```cpp
+// v1.0 SimpleAPI style:
+prometheus::simpleapi::counter_family_t family  { "name", "help" };
+prometheus::simpleapi::counter_metric_t metric1 { family.Add(labels) };
+prometheus::simpleapi::counter_metric_t metric2 { "standalone", "help", labels };
+
+// v2.0 (with global_registry)
+prometheus::family_t         family  ("name", "help");
+prometheus::counter_metric_t metric1 (family, labels);
+prometheus::counter_metric_t metric2 ("standalone", "help", labels);
+
+// v2.0 (with explicit registry)
+prometheus::registry_t       registry;
+prometheus::family_t         family  (registry, "name", "help");
+prometheus::counter_metric_t metric1 (family, labels);
+prometheus::counter_metric_t metric2 (registry, "standalone", "help", labels);
+```
+
+### Quick reference: v1.0 → v2.0 name mapping
+
+| v1.0                                      | v2.0                                 | Notes                                        |
+|-------------------------------------------|--------------------------------------|----------------------------------------------|
+| `#include <prometheus/simpleapi.h>`       | `#include <prometheus/prometheus.h>` | Umbrella header                              |
+| `prometheus::simpleapi::counter_metric_t` | `prometheus::counter_metric_t`       | All metrics moved to main namespace          |
+| `prometheus::simpleapi::counter_metric_t` | `prometheus::counter_t<uint64_t&>`   | Fast template to use custom type             |
+| `prometheus::simpleapi::counter_family_t` | `prometheus::counter_family_t`       | All metrics families moved to main namespace |
+| `prometheus::simpleapi::counter_family_t` | `prometheus::family_t`               | New simple class with check type in runtime  |
+| `prometheus::SaveToFile`                  | `prometheus::file_saver_t`           | Change class name                            |
+| `prometheus::PushToServer`                | `prometheus::http_pusher_t`          | Change class name                            |
+| `prometheus::Gateway`                     | `prometheus::http_pusher_t`          | `prometheus-cpp` compat alias also available |
+
+---
+
+
+
+## Examples
+
+All examples are in the [`examples/`](examples/) directory. Build them with:
+
+```
+cmake -B build -G Ninja -DPROMETHEUS_BUILD_EXAMPLES=ON
+cmake --build build
+```
+
+
+| Example | Description |
+|---------|-------------|
+| **Quick start** | |
+| [`quick_start.cpp`](examples/quick_start.cpp) | All metric types + HTTP server in one file. The code from the README "All metric types at a glance" section. |
+| **Export modes** | |
+| [`provide_via_http_pull_simple.cpp`](examples/provide_via_http_pull_simple.cpp) | Shortest HTTP pull server — 3 lines of setup, `curl http://localhost:9100/metrics`. |
+| [`provide_via_http_pull_advanced.cpp`](examples/provide_via_http_pull_advanced.cpp) | Single-registry and multi-path (multiple registries at different URLs) HTTP pull examples. |
+| [`provide_via_http_push_simple.cpp`](examples/provide_via_http_push_simple.cpp) | Shortest periodic push to Pushgateway — 3 lines of setup. |
+| [`provide_via_http_push_advanced.cpp`](examples/provide_via_http_push_advanced.cpp) | Periodic push, on-demand Push/PushAdd/Delete (Gateway API), and async push examples. |
+| [`provide_via_textfile.cpp`](examples/provide_via_textfile.cpp) | Periodic save to `.prom` file for node_exporter textfile collector. |
+| **Metric types — all API levels** | |
+| [`test_counter.cpp`](examples/test_counter.cpp) | Counter (`uint64_t`) — every way to create: global/explicit registry, untyped/typed family, all legacy APIs. |
+| [`test_gauge.cpp`](examples/test_gauge.cpp) | Gauge (`int64_t`) — same full set of API variants. |
+| [`test_histogram.cpp`](examples/test_histogram.cpp) | Histogram (`double`) — buckets, custom boundaries, same full set of API variants. |
+| [`test_summary.cpp`](examples/test_summary.cpp) | Summary (`double`) — quantiles, custom quantile definitions, same full set of API variants. |
+| [`test_benchmark.cpp`](examples/test_benchmark.cpp) | Benchmark (`double`) — profile method execution time, same full set of API variants. |
+| **Global objects** | |
+| [`check_global_objects.cpp`](examples/check_global_objects.cpp) | Uses `prometheus-cpp-lite-full` cmake target with pre-defined globals: `global_registry`, `file_saver`, `http_server`, `http_pusher`. |
+| **Using metrics in classes** | |
+| [`use_metrics_in_class_simple.cpp`](examples/use_metrics_in_class_simple.cpp) | Simplest way to add metrics to a class — declare as members, increment in methods, expose via `http_server.start()`. |
+| [`use_benchmark_in_class_simple.cpp`](examples/use_benchmark_in_class_simple.cpp) | Profile method execution time with `benchmark_metric_t` — `start()`/`stop()` around code phases. |
+| [`use_metrics_in_class_advanced.cpp`](examples/use_metrics_in_class_advanced.cpp) | Dynamic per-instance metrics with labels — connection pool where each connection creates metrics at runtime via `make_metric<>()` without storing families. |
+| **Compatibility** | |
+| [`legacy_prometheus_cpp.cpp`](examples/legacy_prometheus_cpp.cpp) |  Unmodified prometheus-cpp code (`Exposer`, `BuildCounter`, `Registry`) — compiles as-is with prometheus-cpp-lite. |
+| **Extensibility** | |
+| [`add_custom_metric_class.cpp`](examples/add_custom_metric_class.cpp) | How to create your own metric type (`min_max_t` — tracks min/max of observed values). Demonstrates owning/reference forms, all family wrappers, and the Builder API. |
+
+
+
+
+---
+
+## Networking
+
+HTTP pull and push functionality uses
+[ip-sockets-cpp-lite](https://github.com/biaks/ip-sockets-cpp-lite) - a
+header-only, dependency-free, cross-platform C++ sockets library by the same
+author. A copy of its headers is bundled in
+[`3rdparty/ip-sockets-cpp-lite/`](3rdparty/ip-sockets-cpp-lite/) so that
+prometheus-cpp-lite remains self-contained with zero external dependencies.
+
+If you only need the core metrics and serialization (e.g. you have your own
+HTTP server or use file export only), the socket headers are not required.
+
+---
+
+## Supported exposition format
+
+Prometheus Text Exposition Format (`text/plain; version=0.0.4`).
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/atomic_floating.h b/vendors/prometheus-cpp-lite/include/prometheus/atomic_floating.h
new file mode 100644
index 000000000..e303d062a
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/atomic_floating.h
@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include <type_traits>
+#include <atomic>
+
+namespace prometheus {
+
+  template <typename FloatingType>
+  inline std::atomic<FloatingType>& atomic_add_for_floating_types(std::atomic<FloatingType>& value, const FloatingType& add) {
+    FloatingType desired;
+    FloatingType expected = value.load(std::memory_order_relaxed);
+    do {
+      desired = expected + add;
+    } while (!value.compare_exchange_weak(expected, desired));
+    return value;
+  }
+
+
+  template <typename FloatingType, class = typename std::enable_if<std::is_floating_point<FloatingType>::value, int>::type>
+  inline std::atomic<FloatingType>& operator++(std::atomic<FloatingType>& value) {
+    return atomic_add_for_floating_types(value, 1.0);
+  }
+
+  template <typename FloatingType, class = typename std::enable_if<std::is_floating_point<FloatingType>::value, int>::type>
+  inline std::atomic<FloatingType>& operator+=(std::atomic<FloatingType>& value, const FloatingType& val) {
+    return atomic_add_for_floating_types(value, val);
+  }
+
+  template <typename FloatingType, class = typename std::enable_if<std::is_floating_point<FloatingType>::value, int>::type>
+  inline std::atomic<FloatingType>& operator--(std::atomic<FloatingType>& value) {
+    return atomic_add_for_floating_types(value, -1.0);
+  }
+
+  template <typename FloatingType, class = typename std::enable_if<std::is_floating_point<FloatingType>::value, int>::type>
+  inline std::atomic<FloatingType>& operator-=(std::atomic<FloatingType>& value, const FloatingType& val) {
+    return atomic_add_for_floating_types(value, -val);
+  }
+
+}  // namespace prometheus
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/benchmark.h b/vendors/prometheus-cpp-lite/include/prometheus/benchmark.h
new file mode 100644
index 000000000..0195c3b88
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/benchmark.h
@@ -0,0 +1,242 @@
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+#include <chrono>
+
+namespace prometheus {
+
+  // =============================================================================
+  // benchmark_t — Prometheus-compatible metric for measuring elapsed time
+  //
+  // Accumulates wall-clock time between start()/stop() pairs into an atomic
+  // double value (seconds).  Exposes the result as a Prometheus "counter"
+  // (monotonically increasing elapsed time).
+  //
+  // Supports two ownership modes controlled by MetricValue:
+  //
+  //   benchmark_t<double>   — owning:    holds its own std::atomic<double>.
+  //   benchmark_t<double&>  — reference: binds to the atomic of an owning benchmark.
+  //
+  // The reference form enables zero-copy metric handles (see modify_t<>).
+  //
+  // Note: start_point and the running flag are local to each instance and are
+  // NOT shared between owning and reference forms.  Only the accumulated
+  // elapsed_seconds value is shared.
+  // =============================================================================
+
+  /// @brief Prometheus-compatible metric for measuring elapsed wall-clock time.
+  ///
+  /// @tparam MetricValue Value type. Use a plain type (e.g. `double`) for an
+  ///         owning benchmark, or a reference type (e.g. `double&`) for a
+  ///         zero-copy reference handle.
+  template <typename MetricValue = double>
+  class benchmark_t : public Metric {
+
+  public:
+    using storage_type = typename atomic_storage<MetricValue>::storage_type;
+    using value_type   = typename atomic_storage<MetricValue>::value_type;
+    using Family       = CustomFamily<benchmark_t<value_type> >; ///< Legacy alias for backward compatibility.
+
+  private:
+    using duration_t   = std::chrono::high_resolution_clock::duration;
+    using time_point_t = std::chrono::time_point<std::chrono::high_resolution_clock>;
+
+    /// Shared atomic accumulator storing total elapsed seconds.
+    storage_type elapsed_seconds;
+
+    /// Local measurement state (always owning, never shared between instances).
+    time_point_t start_point;
+    #ifndef NDEBUG
+    bool         running = false;
+    #endif
+
+    /// Frozen snapshot for consistent serialization.
+    value_type snapshot_value { 0 };
+
+    /// Grant access to internals so the reference form can bind to the owning form.
+    friend benchmark_t<value_type&>;
+
+  public:
+    using Value = value_type;
+
+    // --- Owning constructor (benchmark_t<value_type>) ---------------------------
+
+    /// @brief Constructs an owning benchmark initialized to zero elapsed seconds.
+    /// @param labels Per-metric dimensional labels (copied and owned).
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit benchmark_t(const labels_t& labels)
+      : Metric(labels), elapsed_seconds(0) {}
+
+    // --- SimpleAPI: easy to use from the user's side, non-trivial internally.
+    // --- Reference constructors (benchmark_t<value_type&>) ----------------------
+
+    /// @brief Constructs a reference benchmark that binds to an existing owning benchmark.
+    /// @param other Owning benchmark whose atomic elapsed_seconds and labels are referenced.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(benchmark_t<value_type>& other)
+      // benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : Metric(other.labels_ptr), elapsed_seconds(other.elapsed_seconds), snapshot_value(other.snapshot_value) {}
+
+    /// @brief Constructs a reference benchmark by adding an owning benchmark to the given family.
+    /// The metric value type compatibility with the family is checked at runtime.
+    /// @param family Family to add the owning benchmark to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(family_t& family, const labels_t& labels = {})
+      // family_t::Add<>() -> Family::Add<>() -> benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : benchmark_t(family.Add<benchmark_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference benchmark by adding an owning benchmark to the given typed family.
+    /// The metric value type compatibility with the family is enforced at compile time.
+    /// @param family Family to add the owning benchmark to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(custom_family_t<benchmark_t<value_type> >& family, const labels_t& labels = {})
+      // custom_family_t<>::Add() -> CustomFamily<>::Add() -> benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : benchmark_t(family.Add(labels)) {}
+
+    /// @brief Constructs a reference benchmark, creating both family and metric in the given registry.
+    /// @param registry Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<benchmark_t<value_type>>() -> benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : benchmark_t(registry.Add(name, help, labels).Add<benchmark_t<value_type> >({})) {}
+
+    /// @brief Constructs a reference benchmark, creating both family and metric in the given registry.
+    /// @param registry Shared pointer to Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<benchmark_t<value_type>>() -> benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : benchmark_t(registry->Add(name, help, labels).Add<benchmark_t<value_type> >({})) {}
+
+    /// @brief Constructs a reference benchmark using the global registry.
+    /// @param name   Metric family name.
+    /// @param help   Help/description string.
+    /// @param labels Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    benchmark_t(const std::string& name, const std::string& help, const labels_t& labels = {})
+      // global_registry::Add() -> Family::Add<benchmark_t<value_type>>() -> benchmark_t<value_type>& -> benchmark_t<value_type&>
+      : benchmark_t(global_registry.Add(name, help, labels).Add<benchmark_t<value_type>>({})) {}
+
+    // --- Conversion: owning → reference -----------------------------------------
+
+    /// @brief Implicit conversion from an owning benchmark to a reference benchmark.
+    /// @return A reference benchmark bound to this owning benchmark.
+    //template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    //operator benchmark_t<value_type&>() {
+    //  return benchmark_t<value_type&>(*this);
+    //}
+
+    // --- Non-copyable (owning form only) ----------------------------------------
+
+    /// @brief Owning benchmarks are non-copyable to prevent accidental duplication.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    benchmark_t(const benchmark_t&) = delete;
+
+    /// @brief Owning benchmarks are non-copy-assignable.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    benchmark_t& operator=(const benchmark_t&) = delete;
+
+    // --- Public API (shared by both owning and reference forms) -----------------
+
+    /// @brief Starts a time measurement.
+    ///
+    /// Records the current high-resolution clock time point.
+    /// In debug builds, throws if a measurement is already in progress.
+    ///
+    /// @throws std::runtime_error (debug only) if called while already running.
+    void start() {
+      #ifndef NDEBUG
+      if (running)
+        throw std::runtime_error("try to start already started benchmark");
+      running = true;
+      #endif
+      start_point = std::chrono::high_resolution_clock::now();
+    }
+
+    /// @brief Stops the current time measurement and adds the elapsed time to the accumulator.
+    ///
+    /// Computes the duration since the last start() call and atomically adds it
+    /// (in seconds) to the shared elapsed_seconds value using a CAS loop.
+    /// In debug builds, throws if no measurement is in progress.
+    ///
+    /// @throws std::runtime_error (debug only) if called while not running.
+    void stop() {
+      #ifndef NDEBUG
+      if (!running)
+        throw std::runtime_error("try to stop already stopped benchmark");
+      running = false;
+      #endif
+      auto   now   = std::chrono::high_resolution_clock::now();
+      double delta = std::chrono::duration_cast<std::chrono::duration<double>>(
+        now - start_point).count();
+
+      // Atomic add via compare-and-swap loop (std::atomic<double> may lack fetch_add).
+      value_type current = elapsed_seconds.load();
+      while (!elapsed_seconds.compare_exchange_weak(
+        current, current + static_cast<value_type>(delta),
+        std::memory_order_release, std::memory_order_relaxed))
+        ;
+    }
+
+    /// @brief Returns the total elapsed time accumulated so far (in seconds).
+    /// @return Atomically loaded elapsed seconds.
+    value_type Get() const { return elapsed_seconds.load(); }
+
+    // --- Metric interface overrides ---------------------------------------------
+
+    /// @brief Returns the Prometheus type name for this metric.
+    ///
+    /// Exposed as "counter" because elapsed time is monotonically increasing.
+    ///
+    /// @return "counter".
+    const char* type_name() const override { return "counter"; }
+
+    /// @brief Freezes the current value into a snapshot for consistent serialization.
+    void collect() override {
+      snapshot_value = elapsed_seconds.load();
+    }
+
+    /// @brief Writes this benchmark's data line in the Prometheus text exposition format.
+    /// @param out         Output stream.
+    /// @param family_name Metric family name (line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    void serialize(std::ostream& out, const std::string& family_name,
+                   const labels_t& base_labels) const override {
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(), snapshot_value);
+    }
+  };
+
+  // =============================================================================
+  // Convenience aliases
+  // =============================================================================
+
+  /// @brief Generic benchmark alias with configurable value type.
+  template <typename T = double>
+  using Benchmark = benchmark_t<T>;
+
+  /// @brief Fluent builder alias for the default benchmark type.
+  using BuildBenchmark = Builder<benchmark_t<double>>;
+
+  /// @brief Zero-copy reference handle to a default benchmark (SimpleAPI).
+  using benchmark_metric_t = typename modify_t<benchmark_t<>>::metric_ref;
+
+  /// @brief Typed family alias for default benchmarks (SimpleAPI).
+  using benchmark_family_t = custom_family_t<benchmark_t<>>;
+
+} // namespace prometheus
\ No newline at end of file
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/core.h b/vendors/prometheus-cpp-lite/include/prometheus/core.h
new file mode 100644
index 000000000..5bce1c9cd
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/core.h
@@ -0,0 +1,924 @@
+
+/*	
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+* 
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+// =============================================================================
+// prometheus/core.h — Core classes for Prometheus metrics library
+//
+// Class map:
+//
+//   Registry (registry_t)
+//   ├── Stores a set of Family objects, keyed by metric name.
+//   ├── Provides serialization of all registered families.
+//   └── Thread-safe.
+//
+//   Family
+//   ├── Stores a set of Metric objects sharing the same name, help, and base labels.
+//   ├── Each metric is keyed by its own label set.
+//   ├── Enforces that all metrics in one family have the same concrete type.
+//   └── Thread-safe.
+//
+//   CustomFamily<MetricType> : Family
+//   └── Compile-time typed wrapper around Family.
+//       Provides type-safe Add() without explicit template argument.
+//
+//   Metric (abstract)
+//   ├── Base class for all concrete metric types (Counter, Gauge, Histogram, etc.).
+//   ├── Supports two ownership modes for labels:
+//   │   ├── Owning: copies labels into owned_labels (used when created by Family).
+//   │   └── Reference: points to externally-owned labels (zero-copy "ref" metrics).
+//   └── Defines interface: collect(), serialize(), type_name().
+//
+//   TextSerializer
+//   └── Utility class for Prometheus text exposition format serialization.
+//       Provides static helpers for writing values, labels, and full metric lines.
+//       RAII guard that switches stream locale to "C" and restores on destruction.
+//
+//   Builder<MetricType>
+//   └── Fluent builder for registering a CustomFamily in a Registry.
+//
+//   SimpleAPI wrappers:
+//
+//   family_t / custom_family_t<MetricType>
+//   └── Lightweight wrappers (SimpleAPI) around Family for convenient usage
+//       with a global or user-supplied registry.
+//
+//   atomic_storage<V>
+//   └── Type trait: selects between owning std::atomic<T> and
+//       reference std::atomic<T>& depending on whether V is a reference type.
+//
+//   make_ref<MetricTemplate<V>>
+//   └── Type trait: maps MetricTemplate<V> → MetricTemplate<V&>,
+//       enabling zero-copy "reference" metric handles.
+//
+// =============================================================================
+
+#include <map>
+#include <unordered_map>
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <typeindex>
+#include <stdexcept>
+#include <iostream>
+#include <mutex>
+#include <functional>
+#include <sstream>
+#include <array>
+#include <charconv>
+#include <cmath>
+#include <cstdio>
+#include <limits>
+
+#include "prometheus/atomic_floating.h"
+
+namespace prometheus {
+
+  /// @brief Ordered map of label name-value pairs used throughout the library.
+  using labels_t = std::map<std::string, std::string>;
+
+  /// @brief Alias kept for compatibility with prometheus-cpp naming conventions.
+  using Labels = labels_t;
+
+} // namespace prometheus
+
+// =============================================================================
+// std::hash specialization for labels_t
+// Uses boost-style hash combining to produce a hash from all key-value pairs.
+// =============================================================================
+template<>
+struct std::hash<prometheus::labels_t> {
+  /// @brief Computes a combined hash over every key-value pair in the label set.
+  /// @param labels Label set to hash.
+  /// @return Combined hash value.
+  inline size_t operator()(const prometheus::labels_t& labels) const noexcept {
+    std::hash<std::string> hasher;
+    size_t                 hash = 0;
+    for (const typename prometheus::labels_t::value_type& pair : labels) {
+      hash ^= hasher(pair.first)  + 0x9e3779b97f4a7c15ULL + (hash << 6) + (hash >> 2);
+      hash ^= hasher(pair.second) + 0x9e3779b97f4a7c15ULL + (hash << 6) + (hash >> 2);
+    }
+    return hash;
+  }
+};
+
+namespace prometheus {
+
+  // =============================================================================
+  // TextSerializer — RAII serialization context for Prometheus text exposition
+  // =============================================================================
+
+  /// @brief RAII helper for writing metrics in the Prometheus text exposition format.
+  ///
+  /// On construction, switches the stream locale to "C" (locale-independent
+  /// numeric formatting). On destruction, restores the original locale.
+  /// All static methods can also be used independently of the RAII guard.
+  class TextSerializer {
+    std::ostream& out;
+    std::locale   saved_locale;
+
+  public:
+
+    /// @brief Constructs the serializer, switching the stream to the classic "C" locale.
+    /// @param os Output stream to write to.
+    explicit TextSerializer(std::ostream& os)
+      : out(os), saved_locale(os.getloc()) {
+      out.imbue(std::locale::classic());
+    }
+
+    /// @brief Restores the original locale on the stream.
+    ~TextSerializer() {
+      out.imbue(saved_locale);
+    }
+
+    // --- Value writers --------------------------------------------------------
+
+    /// @brief Writes a double value, handling NaN and +/-Inf as required by the exposition format.
+    /// @param out Output stream.
+    /// @param value Value to write.
+    static void WriteValue(std::ostream& out, double value) {
+      if (std::isnan(value)) {
+        out << "NaN";
+      } else if (std::isinf(value)) {
+        out << (value < 0 ? "-Inf" : "+Inf");
+      } else {
+        std::array<char, 128> buffer;
+        #if __cpp_lib_to_chars >= 201611L
+        auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), value);
+        if (ec != std::errc())
+          throw std::runtime_error("Could not convert double to string: " + std::make_error_code(ec).message());
+        out.write(buffer.data(), ptr - buffer.data());
+        #else
+        int n = std::snprintf(buffer.data(), buffer.size(), "%.*g",
+                              std::numeric_limits<double>::max_digits10 - 1, value);
+        if (n <= 0 || static_cast<std::size_t>(n) >= buffer.size())
+          throw std::runtime_error("Could not convert double to string");
+        out.write(buffer.data(), n);
+        #endif
+      }
+    }
+
+    /// @brief Writes an unsigned 64-bit integer value.
+    /// @param out Output stream.
+    /// @param value Value to write.
+    static void WriteValue(std::ostream& out, uint64_t value) {
+      out << value;
+    }
+
+    /// @brief Writes a signed 64-bit integer value.
+    /// @param out Output stream.
+    /// @param value Value to write.
+    static void WriteValue(std::ostream& out, int64_t value) {
+      out << value;
+    }
+
+    // --- String / label helpers -----------------------------------------------
+
+    /// @brief Writes a string with characters escaped according to the exposition format.
+    /// @param out Output stream.
+    /// @param value String to escape and write.
+    static void WriteEscapedString(std::ostream& out, const std::string& value) {
+      for (char c : value) {
+        switch (c) {
+          case '\n': out << '\\' << 'n'; break;
+          case '\\': out << '\\' << c;   break;
+          case '"':  out << '\\' << c;   break;
+          default:   out << c;           break;
+        }
+      }
+    }
+
+    /// @brief Writes the label set in Prometheus exposition format: {name="value",...}.
+    ///
+    /// Merges base labels, per-metric labels, and an optional extra label
+    /// (used, for example, for histogram bucket boundaries: le="...").
+    /// Writes nothing if all label sources are empty.
+    ///
+    /// @param out               Output stream.
+    /// @param base_labels       Constant labels attached to the whole family.
+    /// @param metric_labels     Per-metric dimensional labels.
+    /// @param extra_label_name  Optional additional label name (e.g. "le").
+    /// @param extra_label_value Optional additional label value (e.g. "0.5").
+    static void WriteLabels(std::ostream&      out,
+                            const labels_t&    base_labels,
+                            const labels_t&    metric_labels,
+                            const std::string& extra_label_name  = "",
+                            const std::string& extra_label_value = "") {
+      bool has_any = !base_labels.empty() || !metric_labels.empty() || !extra_label_name.empty();
+      if (!has_any) return;
+
+      out << "{";
+      const char* prefix = "";
+
+      for (labels_t::const_iterator it = base_labels.begin(); it != base_labels.end(); ++it) {
+        out << prefix << it->first << "=\"";
+        WriteEscapedString(out, it->second);
+        out << "\"";
+        prefix = ",";
+      }
+      for (labels_t::const_iterator it = metric_labels.begin(); it != metric_labels.end(); ++it) {
+        out << prefix << it->first << "=\"";
+        WriteEscapedString(out, it->second);
+        out << "\"";
+        prefix = ",";
+      }
+      if (!extra_label_name.empty()) {
+        out << prefix << extra_label_name << "=\"";
+        WriteEscapedString(out, extra_label_value);
+        out << "\"";
+      }
+      out << "}";
+    }
+
+    // --- High-level line writer -----------------------------------------------
+
+    /// @brief Writes a single metric line in the Prometheus text exposition format.
+    ///
+    /// Produces a line of the form:
+    ///   name[suffix]{labels} value\n
+    ///
+    /// @tparam T              Type of the metric value (double, uint64_t, int64_t).
+    /// @param out              Output stream.
+    /// @param name             Metric family name.
+    /// @param base_labels      Constant labels attached to the whole family.
+    /// @param metric_labels    Per-metric dimensional labels.
+    /// @param value            Metric value to write.
+    /// @param suffix           Optional name suffix (e.g. "_total", "_bucket").
+    /// @param extra_label_name  Optional additional label name.
+    /// @param extra_label_value Optional additional label value.
+    template <typename T>
+    static void WriteLine(std::ostream&      out,
+                          const std::string& name,
+                          const labels_t&    base_labels,
+                          const labels_t&    metric_labels,
+                          const T&           value,
+                          const std::string& suffix            = "",
+                          const std::string& extra_label_name  = "",
+                          const std::string& extra_label_value = "") {
+      out << name << suffix;
+      WriteLabels(out, base_labels, metric_labels, extra_label_name, extra_label_value);
+      out << " ";
+      WriteValue(out, value);
+      out << "\n";
+    }
+  };
+
+
+  // =============================================================================
+  // Metric — abstract base class for all concrete metric types
+  // =============================================================================
+
+  /// @brief Abstract base class for all Prometheus metric types.
+  ///
+  /// Supports two label ownership modes:
+  /// - **Owning**: labels are copied into `owned_labels`; `labels_ptr` points
+  ///   to the internal copy.  Used when the metric is created by a Family.
+  /// - **Reference**: labels are not copied; `labels_ptr` points to an
+  ///   externally-owned label set.  Used for zero-copy "ref" metrics.
+  class Metric {
+  protected:
+    labels_t        owned_labels; ///< Internal storage for owning mode.
+    const labels_t* labels_ptr;   ///< Pointer used for all label access (owning or reference).
+
+  public:
+
+    /// @brief Constructs an owning metric that copies the given labels.
+    /// @param labels Labels to copy and own.
+    explicit Metric(const labels_t& labels)
+      : owned_labels(labels), labels_ptr(&owned_labels) {}
+
+    /// @brief Constructs a reference metric that points to externally-owned labels.
+    /// @param labels_ptr Pointer to labels owned elsewhere (must outlive this metric).
+    explicit Metric(const labels_t* labels_ptr)
+      : owned_labels(), labels_ptr(labels_ptr) {}
+
+    virtual ~Metric() = default;
+
+    /// @brief Returns the label set associated with this metric.
+    /// @return Const reference to the labels (owned or external).
+    const labels_t& get_labels() const { return *labels_ptr; }
+
+    /// @brief Returns the Prometheus type name string (e.g. "counter", "gauge").
+    /// @return Null-terminated type name.
+    virtual const char* type_name() const = 0;
+
+    /// @brief Freezes the current metric value so it can be serialized consistently.
+    virtual void collect() = 0;
+
+    /// @brief Writes this metric's data lines to the output stream.
+    /// @param out         Output stream.
+    /// @param family_name The metric family name (used as the line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    virtual void serialize(std::ostream& out, const std::string& family_name, const labels_t& base_labels) const = 0;
+  };
+
+
+  // =============================================================================
+  // Family — container for a set of same-typed metrics sharing name and help
+  // =============================================================================
+
+  /// @brief Stores a set of Metric objects that share the same name, help text,
+  ///        and base (constant) labels.
+  ///
+  /// All metrics within a single Family must be of the same concrete type.
+  /// Thread-safe: all public methods acquire an internal mutex.
+  class Family {
+
+    using Metrics = std::unordered_map<labels_t, std::unique_ptr<Metric>>;
+
+    std::string        name;
+    std::string        help;
+    labels_t           base_labels;
+    Metrics            metrics;
+    mutable std::mutex mutex;  ///< Mutable so const methods can lock.
+    std::type_index    metric_type = typeid(void);
+
+    /// Reverse lookup: metric pointer → labels key, used by Remove().
+    std::unordered_map<Metric*, labels_t> labels_reverse_lookup;
+
+    // --- Name / label validation helpers (locale-independent) -----------------
+
+    /// @brief Checks if the character is an ASCII digit ('0'-'9').
+    inline bool isLocaleIndependentDigit(char c) {
+      return '0' <= c && c <= '9';
+    }
+
+    /// @brief Checks if the character is an ASCII letter or digit.
+    inline bool isLocaleIndependentAlphaNumeric(char c) {
+      return isLocaleIndependentDigit(c) || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
+    }
+
+    /// @brief Checks common prefix rules: non-empty, no leading digit, no "__" prefix.
+    inline bool nameStartsValid(const std::string& name) {
+      if (name.empty())                           return false;
+      if (isLocaleIndependentDigit(name.front()))  return false;
+      if (name.compare(0, 2, "__") == 0)           return false;
+      return true;
+    }
+
+    /// @brief Validates a metric name against the Prometheus data model.
+    ///
+    /// Allowed pattern: [a-zA-Z_:][a-zA-Z0-9_:]*
+    /// @see https://prometheus.io/docs/concepts/data_model/
+    /// @param name Metric name to validate.
+    /// @return true if the name is valid.
+    inline bool CheckMetricName(const std::string& name) {
+      if (!nameStartsValid(name))
+        return false;
+      for (char c : name)
+        if (!isLocaleIndependentAlphaNumeric(c) && c != '_' && c != ':')
+          return false;
+      return true;
+    }
+
+    /// @brief Validates a label name against the Prometheus data model.
+    ///
+    /// Allowed pattern: [a-zA-Z_][a-zA-Z0-9_]*
+    /// @see https://prometheus.io/docs/concepts/data_model/
+    /// @param name Label name to validate.
+    /// @return true if the name is valid.
+    inline bool CheckLabelName(const std::string& name) {
+      if (!nameStartsValid(name))
+        return false;
+      for (char c : name)
+        if (!isLocaleIndependentAlphaNumeric(c) && c != '_')
+          return false;
+      return true;
+    }
+
+  public:
+
+    /// @brief Constructs a metric family with the given name, help text, and base labels.
+    /// @param name_        Metric name (must satisfy Prometheus naming rules).
+    /// @param help_        Human-readable help/description string.
+    /// @param base_labels_ Constant labels applied to every metric in this family.
+    /// @throws std::invalid_argument if the metric name or any label name is invalid.
+    Family(const std::string& name_, const std::string& help_, const labels_t& base_labels_ = labels_t())
+      : name(name_), help(help_), base_labels(base_labels_) {
+      if (!CheckMetricName(name_))
+        throw std::invalid_argument("Invalid metric name: '" + name_ + "'");
+      for (const labels_t::value_type& label_pair : base_labels_) {
+        if (!CheckLabelName(label_pair.first))
+          throw std::invalid_argument("Invalid label name: '" + label_pair.first + "'");
+      }
+    }
+
+    ~Family() = default;
+
+    Family(const Family&) = delete;
+    Family& operator=(const Family&) = delete;
+
+    /// @brief Returns the constant (base) labels of this family.
+    /// @return Const reference to the base label set.
+    const labels_t& get_base_labels() const { return base_labels; }
+
+    /// @brief Creates or retrieves a metric with the given per-metric labels.
+    ///
+    /// If a metric with identical labels already exists, returns a reference
+    /// to the existing one.  All metrics in the family must have the same
+    /// concrete MetricType; mixing types causes a runtime exception.
+    ///
+    /// @tparam MetricType Concrete metric class (must derive from Metric).
+    /// @tparam Args       Additional constructor arguments forwarded to MetricType.
+    /// @param metric_labels Per-metric dimensional labels.
+    /// @param args          Extra arguments forwarded to the MetricType constructor.
+    /// @return Reference to the (possibly new) metric instance.
+    /// @throws std::runtime_error      if a metric of a different type already exists.
+    /// @throws std::invalid_argument   if a label name is invalid or duplicates a base label.
+    template <typename MetricType, typename... Args>
+    MetricType& Add(const labels_t& metric_labels, Args&&... args) {
+      static_assert(std::is_base_of<Metric, MetricType>::value, "MetricType must derive from Metric");
+      std::lock_guard<std::mutex> lock(mutex);
+
+      // Ensure all metrics in this family share the same concrete type.
+      if (metric_type != typeid(void) && metric_type != typeid(MetricType))
+        throw std::runtime_error("family '" + name + "': metric exists with different type");
+
+      // Return existing metric if labels match.
+      typename Metrics::iterator it = metrics.find(metric_labels);
+      if (it != metrics.end())
+        return *static_cast<MetricType*>(it->second.get());
+
+      // Validate label names before creating a new metric.
+      for (const labels_t::value_type& label_pair : metric_labels) {
+        if (!CheckLabelName(label_pair.first))
+          throw std::invalid_argument("Invalid label name: '" + label_pair.first + "'");
+        if (base_labels.count(label_pair.first))
+          throw std::invalid_argument("Label name '" + label_pair.first + "' already present in constant labels");
+      }
+
+      // Record the concrete type on first insertion.
+      if (metric_type == typeid(void))
+        metric_type = typeid(MetricType);
+
+      MetricType* result = new MetricType (metric_labels, std::forward<Args>(args)...);
+      std::unique_ptr<Metric> new_metric(result);
+      labels_reverse_lookup.emplace(result, metric_labels);
+      metrics.emplace(metric_labels, std::move(new_metric));
+      return *result;
+    }
+
+    /// @brief Removes a previously added metric from this family.
+    ///
+    /// Does nothing if the given pointer was not returned by Add().
+    ///
+    /// @param metric Pointer to the metric to remove.
+    void Remove(Metric* metric) {
+      std::lock_guard<std::mutex> lock(mutex);
+      auto reverse_it = labels_reverse_lookup.find(metric);
+      if (reverse_it == labels_reverse_lookup.end())
+        return;
+      const labels_t& metric_labels = reverse_it->second;
+      metrics.erase(metric_labels);
+      labels_reverse_lookup.erase(reverse_it);
+    }
+
+    /// @brief Checks whether a metric with the given labels exists in this family.
+    /// @param metric_labels Labels to look up.
+    /// @return true if such a metric is present.
+    bool Has(const labels_t& metric_labels) const {
+      std::lock_guard<std::mutex> lock(mutex);
+      return metrics.find(metric_labels) != metrics.end();
+    }
+
+    /// @brief Serializes all metrics in this family to the output stream.
+    ///
+    /// First calls collect() on every metric to freeze values, then writes
+    /// the HELP / TYPE header lines followed by each metric's data lines.
+    ///
+    /// @param out Output stream to write to.
+    void serialize(std::ostream& out) {
+      std::lock_guard<std::mutex> lock(mutex);
+
+      if (metrics.empty()) return;
+
+      // Freeze current values so serialization is consistent.
+      for (const typename Metrics::value_type& metric : metrics)
+        metric.second->collect();
+
+      const char* type_str = metrics.begin()->second->type_name();
+
+      // Write HELP and TYPE header lines.
+      if (!help.empty())
+        out << "# HELP " << name << " " << help << "\n";
+      out << "# TYPE " << name << " " << type_str << "\n";
+
+      #if 1 // Collect pointers sorted by labels.
+
+      std::map<labels_t, Metric*> sorted;
+      for (const typename Metrics::value_type& metric : metrics)
+        sorted.emplace(metric.first, metric.second.get());
+
+      for (const typename std::map<labels_t, Metric*>::value_type& entry : sorted)
+        entry.second->serialize(out, name, base_labels);
+
+      #else // Write in arbitrary order.
+      for (const typename Metrics::value_type& metric : metrics)
+        metric.second->serialize(out, name, base_labels);
+      #endif
+    }
+  };
+
+  // Forward declaration for CustomFamily::Build().
+  class Registry;
+
+  // =============================================================================
+  // CustomFamily<MetricType> — compile-time typed wrapper around Family
+  // =============================================================================
+
+  /// @brief Compile-time typed wrapper around Family.
+  ///
+  /// Stores the MetricType at the type level so that Add() does not require
+  /// an explicit template argument at the call site.
+  ///
+  /// @tparam MetricType Concrete metric class (must derive from Metric).
+  template <typename MetricType>
+  class CustomFamily : public Family {
+  public:
+
+    /// @brief Creates or retrieves a metric with the given per-metric labels.
+    /// @tparam Args Additional constructor arguments forwarded to MetricType.
+    /// @param metric_labels Per-metric dimensional labels.
+    /// @param args          Extra arguments forwarded to the MetricType constructor.
+    /// @return Reference to the (possibly new) metric instance.
+    template <typename... Args>
+    MetricType& Add(const labels_t& metric_labels, Args&&... args) {
+      return Family::Add<MetricType>(metric_labels, std::forward<Args>(args)...);
+    }
+
+    /// @brief Registers (or retrieves) a CustomFamily in the given registry.
+    ///
+    /// Defined after Registry so that Registry is a complete type.
+    ///
+    /// @param registry Registry to register in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels.
+    /// @return Reference to the registered CustomFamily.
+    static CustomFamily<MetricType>& Build(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels = labels_t());
+  };
+
+  // =============================================================================
+  // Registry — top-level container for metric families
+  // =============================================================================
+
+  /// @brief Top-level store for metric families, keyed by metric name.
+  ///
+  /// Thread-safe: all public methods acquire an internal mutex.
+  class Registry {
+
+    using Families = std::unordered_map<std::string, std::unique_ptr<Family>>;
+
+    Families           families;
+    mutable std::mutex mutex;  ///< Mutable so const methods can lock.
+
+  public:
+
+    Registry() = default;
+    Registry(Registry&& other) : families(std::move(other.families)) {};
+
+    Registry& operator=(Registry&& other) {
+      families = std::move(other.families);
+      return *this;
+    }
+
+    /// @brief Registers a new family or returns an existing one with the same name.
+    ///
+    /// If a family with the given name already exists, its base labels must match;
+    /// otherwise a runtime exception is thrown.  The help text is not compared.
+    ///
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant labels applied to every metric in this family.
+    /// @return Reference to the (possibly new) Family.
+    /// @throws std::runtime_error if the family already exists with different base labels.
+    Family& Add(const std::string& name, const std::string& help, const labels_t& base_labels = labels_t()) {
+      std::lock_guard<std::mutex> lock(mutex);
+
+      typename Families::iterator it = families.find(name);
+      if (it != families.end()) {
+        if (it->second->get_base_labels() != base_labels)
+          throw std::runtime_error("registry: family '" + name + "' already exists with different base_labels");
+        return *(it->second.get());
+      }
+
+      Family* created = new Family(name, help, base_labels);
+      std::unique_ptr<Family> up(created);
+      families[name] = std::move(up);
+      return *created;
+    }
+
+    /// @brief Registers a new typed family or returns an existing one.
+    ///
+    /// Delegates to the untyped Add() and then reinterpret_casts the result
+    /// to CustomFamily<MetricType>.
+    ///
+    /// @note This is technically UB via reinterpret_cast, but is safe in
+    ///       practice because CustomFamily adds no data members and is
+    ///       layout-compatible with Family.
+    ///
+    /// @tparam MetricType Concrete metric class.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant labels.
+    /// @return Reference to the CustomFamily.
+    template <typename MetricType>
+    CustomFamily<MetricType>& Add(const std::string& name, const std::string& help, const labels_t& base_labels = labels_t()) {
+      Family& family = this->Add(name, help, base_labels);
+      return *reinterpret_cast<CustomFamily<MetricType>*>(&family);
+    }
+
+    /// @brief Removes the family with the given name from the registry.
+    ///
+    /// Does nothing if no family with this name exists.
+    ///
+    /// @param name Metric family name to remove.
+    /// @return true if the family was found and removed.
+    bool Remove(const std::string& name) {
+      std::lock_guard<std::mutex> lock(mutex);
+      return families.erase(name) > 0;
+    }
+
+    /// @brief Removes all families from the registry.
+    void RemoveAll() {
+      std::lock_guard<std::mutex> lock(mutex);
+      families.clear();
+    }
+
+    /// @brief Serializes all registered families to the given output stream.
+    /// @param out Output stream.
+    void serialize(std::ostream& out) {
+      std::lock_guard<std::mutex> lock(mutex);
+
+      // Switch to the classic locale for locale-independent number formatting.
+      std::locale saved = out.getloc();
+      out.imbue(std::locale::classic());
+
+      #if 1 // Collect pointers sorted by family name.
+      
+      std::map<std::string, Family*> sorted;
+      for (const typename Families::value_type& entry : families)
+        sorted.emplace(entry.first, entry.second.get());
+
+      for (const typename std::map<std::string, Family*>::value_type& entry : sorted)
+        entry.second->serialize(out);
+
+      #else // Serialize in arbitrary order without sorting.
+
+      for (const typename Families::value_type& family : families)
+        family.second->serialize(out);
+      #endif
+
+      out.imbue(saved);
+    }
+
+    /// @brief Serializes all registered families and returns the result as a string.
+    /// @return Serialized text in Prometheus exposition format.
+    std::string serialize() {
+      std::ostringstream oss;
+      serialize(oss);
+      return oss.str();
+    }
+  };
+
+  // --- Deferred definition of CustomFamily<MetricType>::Build() ---------------
+
+  /// @brief Registers (or retrieves) a CustomFamily in the given registry.
+  template <typename MetricType>
+  CustomFamily<MetricType>& CustomFamily<MetricType>::Build(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels) {
+    return registry.Add<MetricType>(name, help, labels);
+  }
+
+  // =============================================================================
+  // Builder<MetricType> — fluent builder for registering a CustomFamily
+  // =============================================================================
+
+  /// @brief Fluent builder that accumulates name, help, and labels,
+  ///        then registers a CustomFamily in one call to Register().
+  ///
+  /// @tparam MetricType Concrete metric class.
+  template <typename MetricType>
+  class Builder {
+    std::string name_;
+    std::string help_;
+    labels_t    labels_;
+
+  public:
+    Builder() = default;
+
+    /// @brief Sets the metric family name.
+    /// @param name Metric name.
+    /// @return Reference to this builder for chaining.
+    Builder& Name(const std::string& name)   { name_   = name;   return *this; }
+
+    /// @brief Sets the help/description string.
+    /// @param help Help text.
+    /// @return Reference to this builder for chaining.
+    Builder& Help(const std::string& help)   { help_   = help;   return *this; }
+
+    /// @brief Sets the constant base labels.
+    /// @param labels Base label set.
+    /// @return Reference to this builder for chaining.
+    Builder& Labels(const labels_t& labels)  { labels_ = labels; return *this; }
+
+    /// @brief Registers the family in the given registry and returns it.
+    /// @param registry Registry to register in.
+    /// @return Reference to the registered CustomFamily.
+    CustomFamily<MetricType>& Register(Registry& registry) {
+      return registry.Add<MetricType>(name_, help_, labels_);
+    }
+  };
+
+
+
+
+  // =============================================================================
+  // SimpleAPI — lightweight wrappers for convenient everyday use
+  //
+  // Metrics are assumed to be created once and never removed, so references
+  // returned by Add() remain valid for the lifetime of the registry.
+  // =============================================================================
+
+  /// @brief Alias for Registry used in the SimpleAPI layer.
+  using registry_t = Registry;
+
+  /// @brief Global default registry used when no explicit registry is provided.
+  extern registry_t global_registry;
+
+  // =============================================================================
+  // atomic_storage<V> — type trait for atomic storage selection
+  // =============================================================================
+
+  /// @brief Selects the appropriate atomic storage type based on whether V is a reference.
+  ///
+  /// - If V is a non-reference type, `storage_type` is `std::atomic<V>` (owning).
+  /// - If V is a reference type `T&`, `storage_type` is `std::atomic<T>&` (non-owning reference).
+  ///
+  /// @tparam V Value type; may be `T` (owning) or `T&` (reference).
+  template <typename MetricValue>
+  struct atomic_storage {
+    using value_type   = std::remove_reference_t<MetricValue>;
+    using storage_type = std::conditional_t<
+      std::is_reference<MetricValue>::value,
+      std::atomic<value_type>&,
+      std::atomic<value_type>
+    >;
+  };
+
+  // =============================================================================
+  // modify_t — type trait mapping MetricTemplate<V> → MetricTemplate<V&>
+  // =============================================================================
+
+  /// @brief Maps a metric type `MetricTemplate<V>` to its reference counterpart
+  ///        `MetricTemplate<V&>`, enabling zero-copy "reference" metric handles.
+  ///
+  /// Works for any single-type-parameter metric template without per-type
+  /// specialization.
+  ///
+  /// @tparam MetricType The owning metric type to derive the reference form from.
+  template <typename MetricType>
+  struct modify_t;
+
+  /// @brief Partial specialization that deduces the template and value type.
+  ///
+  /// Given `MetricTemplate<V>`:
+  /// - `value_type` is `std::remove_reference_t<V>`.
+  /// - `metric_own` is the owning form `MetricTemplate<value_type>`.
+  /// - `metric_ref` is the reference form `MetricTemplate<value_type&>`.
+  ///
+  /// @tparam MetricTemplate Single-type-parameter metric class template.
+  /// @tparam V              Value type (possibly already a reference).
+  template <template<typename> class MetricTemplate, typename MetricValue>
+  struct modify_t<MetricTemplate<MetricValue>> {
+    using value_type = std::remove_reference_t<MetricValue>;
+    using metric_own = MetricTemplate<value_type>;
+    using metric_ref = MetricTemplate<value_type&>;
+    static_assert(std::is_base_of<Metric, metric_own>::value, "modify_t: MetricTemplate must be derived from Metric");
+  };
+
+  // =============================================================================
+  // family_t — untyped SimpleAPI wrapper around Family
+  // =============================================================================
+
+  /// @brief Lightweight wrapper that binds a Family reference to a registry.
+  ///
+  /// Can be constructed with an explicit registry or with the global one.
+  class family_t {
+  protected:
+    Family& ref;  ///< Reference to the underlying Family.
+
+  public:
+
+    /// @brief Constructs a family_t bound to the specified registry.
+    /// @param registry    Registry to register the family in.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    family_t(registry_t& registry, const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : ref(registry.Add(name, help, base_labels)) {}
+
+    /// @brief Constructs a family_t bound to the specified registry.
+    /// @param registry    Shared ptr to registry to register the family in.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    family_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : ref(registry->Add(name, help, base_labels)) {}
+
+    /// @brief Constructs a family_t bound to the global registry.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    family_t(const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : ref(global_registry.Add(name, help, base_labels)) {}
+
+    /// @brief Implicit conversion to the underlying Family reference.
+    //operator Family&() { return ref; }
+
+    /// @brief Implicit conversion to the underlying const Family reference.
+    //operator const Family&() const { return ref; }
+
+    /// @brief Creates or retrieves a metric of the given type with the specified labels.
+    /// @tparam MetricType   Concrete metric class.
+    /// @tparam Args         Additional constructor arguments forwarded to MetricType.
+    /// @param metric_labels Per-metric dimensional labels.
+    /// @param args          Extra arguments forwarded to the MetricType constructor.
+    /// @return Reference to the metric instance.
+    template <typename MetricType, typename... Args>
+    typename modify_t<MetricType>::metric_own& Add(const labels_t& metric_labels, Args&&... args) {
+      return ref.Add<typename modify_t<MetricType>::metric_own>(metric_labels, std::forward<Args>(args)...  );
+    }
+  };
+
+  // =============================================================================
+  // custom_family_t<MetricType> — typed SimpleAPI wrapper around Family
+  // =============================================================================
+
+  /// @brief Typed SimpleAPI wrapper that stores MetricType at the type level,
+  ///        providing an Add() that doesn't require an explicit template argument.
+  ///
+  /// @tparam MetricType Concrete metric class.
+  template <typename MetricType>
+  class custom_family_t : family_t {
+  public:
+
+    /// @brief Constructs a typed family wrapper bound to the specified registry.
+    /// @param registry    Registry to register the family in.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    custom_family_t(registry_t& registry, const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : family_t(registry, name, help, base_labels) {}
+
+    /// @brief Constructs a typed family wrapper bound to the specified registry.
+    /// @param registry    Shared ptr to registry to register the family in.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    custom_family_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : family_t(registry, name, help, base_labels) {}
+
+    /// @brief Constructs a typed family wrapper bound to the global registry.
+    /// @param name        Metric family name.
+    /// @param help        Help/description string.
+    /// @param base_labels Constant base labels.
+    custom_family_t(const std::string& name, const std::string& help, const labels_t& base_labels = {})
+      : family_t(name, help, base_labels) {}
+
+    /// @brief Implicit conversion to the underlying Family reference.
+    //operator CustomFamily<MetricType>&() { return *reinterpret_cast<CustomFamily<MetricType>*>(&ref); }
+
+    /// @brief Implicit conversion to the underlying const Family reference.
+    //operator const CustomFamily<MetricType>&() const { return *reinterpret_cast<CustomFamily<MetricType>*>(&ref); }
+
+    /// @brief Creates or retrieves a metric with the given per-metric labels.
+    /// @tparam Args         Additional constructor arguments forwarded to MetricType.
+    /// @param metric_labels Per-metric dimensional labels.
+    /// @param args          Extra arguments forwarded to the MetricType constructor.
+    /// @return Reference to the metric instance.
+    template <typename... Args>
+    typename modify_t<MetricType>::metric_own& Add(const labels_t& metric_labels, Args&&... args) {
+      CustomFamily<typename modify_t<MetricType>::metric_own>& typed_ref = *reinterpret_cast<CustomFamily<typename modify_t<MetricType>::metric_own>*>(&ref);
+      return typed_ref.Add (metric_labels, std::forward<Args>(args)...);
+    }
+  };
+
+  /// @brief Wraps a reference to a registry into a shared_ptr with a no-op deleter.
+  ///
+  /// The resulting shared_ptr will never delete the pointee, making it safe
+  /// to use with stack-allocated or otherwise externally-owned registries.
+  ///
+  /// @param registry Registry reference to wrap.
+  /// @return Non-owning shared_ptr to the registry.
+  inline std::shared_ptr<registry_t> make_non_owning(registry_t& registry) {
+    return std::shared_ptr<registry_t>(&registry, [](registry_t*) noexcept {});
+  }
+
+} // namespace prometheus
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/counter.h b/vendors/prometheus-cpp-lite/include/prometheus/counter.h
new file mode 100644
index 000000000..932cf3949
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/counter.h
@@ -0,0 +1,207 @@
+
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+namespace prometheus {
+
+  // =============================================================================
+  // counter_t — Prometheus counter metric
+  //
+  // A counter is a cumulative metric that can only increase (or be reset to zero
+  // on process restart).  Supports two ownership modes controlled by MetricValue:
+  //
+  //   counter_t<uint64_t>   — owning:    holds its own std::atomic<uint64_t>.
+  //   counter_t<uint64_t&>  — reference: binds to the atomic of an owning counter.
+  //
+  // The reference form enables zero-copy metric handles (see make_ref<>).
+  // =============================================================================
+
+  /// @brief Prometheus counter metric — monotonically increasing value.
+  ///
+  /// @tparam MetricValue Value type. Use a plain type (e.g. `uint64_t`) for an
+  ///         owning counter, or a reference type (e.g. `uint64_t&`) for a
+  ///         zero-copy reference handle.
+  template <typename MetricValue = uint64_t>
+  class counter_t : public Metric {
+
+  public:
+    using storage_type = typename atomic_storage<MetricValue>::storage_type;
+    using value_type   = typename atomic_storage<MetricValue>::value_type;
+    using Family       = CustomFamily<counter_t<value_type> >; ///< Legacy alias for backward compatibility.
+
+  private:
+    storage_type value;
+    value_type   snapshot_value { 0 };
+
+    friend counter_t<value_type&>; ///< Grant access to internals so the reference form can bind to the owning form.
+
+  public:
+
+    // --- Owning constructor (counter_t<value_type>) -----------------------------
+
+    /// @brief Constructs an owning counter initialized to zero.
+    /// @param labels Per-metric dimensional labels (copied and owned).
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit counter_t(const labels_t& labels)
+      : Metric(labels), value(0) {}
+
+    // --- SimpleAPI: easy to use from the user's side, non-trivial internally.
+    // --- Reference constructors (counter_t<value_type&>) ------------------------
+
+    /// @brief Constructs a reference counter that binds to an existing owning counter.
+    /// @param other Owning counter whose atomic value and labels are referenced.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(counter_t<value_type>& other)
+      // counter_t<value_type>& -> counter_t<value_type&>
+      : Metric(other.labels_ptr), value(other.value), snapshot_value(other.snapshot_value) {}
+
+    /// @brief Constructs a reference counter by adding an owning counter to the given family.
+    /// The metric value type compatibility with the family is checked at runtime.
+    /// @param family Family to add the owning counter to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(family_t& family, const labels_t& labels = {})
+      // family_t::Add<>() -> Family::Add<>() -> counter_t<value_type>& -> counter_t<value_type&>
+      : counter_t(family.Add<counter_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference counter by adding an owning counter to the given family.
+    /// The metric value type compatibility with the family is enforced at compile time.
+    /// @param family Family to add the owning counter to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(custom_family_t<counter_t<value_type> >& family, const labels_t& labels = {})
+      // custom_family_t<>::Add() -> CustomFamily<>::Add() -> counter_t<value_type>& -> counter_t<value_type&>
+      : counter_t(family.Add (labels)) {}
+
+    /// @brief Constructs a reference counter, creating both family and metric in the given registry.
+    /// @param registry Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<counter_t<value_type>>() -> counter_t<value_type>& -> counter_t<value_type&>
+      : counter_t(registry.Add(name, help).Add<counter_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference counter, creating both family and metric in the given registry.
+    /// @param registry Shared pointer to Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<counter_t<value_type>>() -> counter_t<value_type>& -> counter_t<value_type&>
+      : counter_t(registry->Add(name, help).Add<counter_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference counter using the global registry.
+    /// @param name   Metric family name.
+    /// @param help   Help/description string.
+    /// @param labels Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    counter_t(const std::string& name, const std::string& help, const labels_t& labels = {})
+      // global_registry::Add() -> Family::Add<counter_t<value_type>>() -> counter_t<value_type>& -> counter_t<value_type&>
+      : counter_t(global_registry.Add(name, help).Add<counter_t<value_type> >(labels)) {}
+
+    // --- Conversion: owning → reference -----------------------------------------
+
+    /// @brief Implicit conversion from an owning counter to a reference counter.
+    /// @return A reference counter bound to this owning counter.
+    //template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    //operator counter_t<value_type&>() {
+    //  return counter_t<value_type&>(*this);
+    //}
+
+    // --- Non-copyable (owning form only) ----------------------------------------
+
+    /// @brief Owning counters are non-copyable to prevent accidental duplication.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    counter_t(const counter_t&) = delete;
+
+    /// @brief Owning counters are non-copy-assignable.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    counter_t& operator=(const counter_t&) = delete;
+
+    // --- Public API (shared by both owning and reference forms) -----------------
+
+    /// @brief Increments the counter by one.
+    void Increment() { ++value; }
+
+    /// @brief Increments the counter by the given non-negative value.
+    ///
+    /// In debug builds, throws if `val` is negative (for signed integral types).
+    /// Zero and negative values are silently ignored in release builds.
+    ///
+    /// @param val Amount to add (must be > 0).
+    /// @throws std::invalid_argument (debug only) if val is negative and integral.
+    void Increment(const value_type& val) {
+      #ifndef NDEBUG
+      if (std::is_integral<value_type>::value && val < 0)
+        throw std::invalid_argument("counter increment must be non-negative");
+      #endif
+      if (val > 0)
+        value += val;
+    }
+
+    /// @brief Returns the current counter value.
+    /// @return Atomically loaded counter value.
+    value_type Get() const { return value.load(); }
+
+    /// @brief Pre-increment operator (increments by one).
+    /// @return Reference to this counter.
+    counter_t& operator++()                    { ++value;      return *this; }
+
+    /// @brief Post-increment operator (increments by one, returns reference — not previous value).
+    /// @return Reference to this counter.
+    counter_t& operator++(int)                 { ++value;      return *this; }
+
+    /// @brief Compound addition operator.
+    /// @param v Value to add.
+    /// @return Reference to this counter.
+    counter_t& operator+=(const value_type& v) { Increment(v); return *this; }
+
+    // --- Metric interface overrides ---------------------------------------------
+
+    /// @brief Returns the Prometheus type name for this metric.
+    /// @return "counter".
+    const char* type_name() const override { return "counter"; }
+
+    /// @brief Freezes the current value into a snapshot for consistent serialization.
+    void collect() override { snapshot_value = value.load(); }
+
+    /// @brief Writes this counter's data line in the Prometheus text exposition format.
+    /// @param out         Output stream.
+    /// @param family_name Metric family name (line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    void serialize(std::ostream& out, const std::string& family_name,
+                   const labels_t& base_labels) const override {
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(), snapshot_value);
+    }
+  };
+
+  // =============================================================================
+  // Convenience aliases
+  // =============================================================================
+
+  /// @brief Generic counter alias with configurable value type.
+  template <typename MetricType = uint64_t>
+  using Counter = counter_t<MetricType>;
+
+  /// @brief Builder alias for the default counter type (legacy from prometheus-cpp, should by double).
+  using BuildCounter = Builder<counter_t<double>>;
+
+  /// @brief Zero-copy reference handle to a default counter (SimpleAPI).
+  using counter_metric_t = typename modify_t<counter_t<>>::metric_ref;
+
+  /// @brief Typed family alias for default counters (SimpleAPI).
+  using counter_family_t = custom_family_t<counter_t<>>;
+
+} // namespace prometheus
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/file_saver.h b/vendors/prometheus-cpp-lite/include/prometheus/file_saver.h
new file mode 100644
index 000000000..4ccf13b72
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/file_saver.h
@@ -0,0 +1,189 @@
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+#include <thread>
+#include <chrono>
+#include <string>
+#include <fstream>
+#include <memory>
+
+namespace prometheus {
+
+  /// @brief Periodically serializes a Registry to a file in Prometheus text exposition format.
+  ///
+  /// Useful for environments where a Prometheus node_exporter textfile collector
+  /// reads `.prom` files from a directory.
+  ///
+  /// Typical usage:
+  /// @code
+  ///   std::shared_ptr<registry_t> registry = std::make_shared<registry_t>();
+  ///   file_saver_t saver(registry, std::chrono::seconds(10), "./metrics.prom");
+  ///   // metrics are now written to ./metrics.prom every 10 seconds
+  /// @endcode
+  class file_saver_t {
+
+    std::shared_ptr<registry_t> registry_ptr  { nullptr };
+    std::thread                 worker_thread;
+    std::atomic<bool>           must_die      { false };
+
+    std::chrono::seconds        period        { 10 };
+    std::string                 filename      { "./metrics.prom" };
+
+  public:
+
+    // =========================================================================
+    // Construction / Destruction
+    // =========================================================================
+
+    /// @brief Default constructor.  Registry, period, and filename must be set before calling start().
+    file_saver_t() = default;
+
+    /// @brief Constructs with a shared registry.  Call start() to begin saving.
+    /// @param registry_ Shared pointer to the registry to serialize.
+    explicit file_saver_t(std::shared_ptr<registry_t> registry_)
+      : registry_ptr(std::move(registry_)) {}
+
+    /// @brief Constructs with a shared registry.  Call start() to begin saving.
+    /// @param registry_ Registry to serialize.
+    explicit file_saver_t(registry_t& registry_)
+      : registry_ptr(make_non_owning(registry_)) {}
+
+    /// @brief Constructs with a shared registry, save period, and output filename.  Starts immediately.
+    /// @param registry_ Shared pointer to the registry to serialize.
+    /// @param period_   Interval between file writes.
+    /// @param filename_ Path to the output file.
+    file_saver_t(std::shared_ptr<registry_t> registry_, const std::chrono::seconds& period_, const std::string& filename_)
+      : registry_ptr(std::move(registry_)), period(period_), filename(filename_) {
+      start();
+    }
+
+    /// @brief Constructs with a shared registry, save period, and output filename.  Starts immediately.
+    /// @param registry_ registry to serialize.
+    /// @param period_   Interval between file writes.
+    /// @param filename_ Path to the output file.
+    file_saver_t(registry_t& registry_, const std::chrono::seconds& period_, const std::string& filename_)
+      : registry_ptr(make_non_owning(registry_)), period(period_), filename(filename_) {
+      start();
+    }
+
+    /// @brief Stops the saver and joins the worker thread.
+    ~file_saver_t() {
+      stop();
+    }
+
+    // Non-copyable (owns a thread).
+    file_saver_t(const file_saver_t&) = delete;
+    file_saver_t& operator=(const file_saver_t&) = delete;
+
+    // =========================================================================
+    // Configuration
+    // =========================================================================
+
+    /// @brief Replaces the registry to serialize.
+    /// @param registry_ New shared pointer to a registry.
+    void set_registry(std::shared_ptr<registry_t> registry_) {
+      registry_ptr = std::move(registry_);
+    }
+
+    /// @brief Sets the save interval.
+    /// @param new_period Interval between file writes.
+    void set_delay(const std::chrono::seconds& new_period) {
+      period = new_period;
+    }
+
+    /// @brief Sets the output filename and verifies that it can be opened for writing.
+    /// @param filename_ Path to the output file.
+    /// @return true if the file was successfully opened (and closed) for writing.
+    bool set_out_file(const std::string& filename_) {
+      filename = filename_;
+      std::fstream out_file_stream;
+      out_file_stream.open(filename, std::fstream::out | std::fstream::binary);
+      bool open_success = out_file_stream.is_open();
+      out_file_stream.close();
+      return open_success;
+    }
+
+    // =========================================================================
+    // Control
+    // =========================================================================
+
+    /// @brief Sets the save period and filename, then starts the worker thread.
+    /// @param period_   Interval between file writes.
+    /// @param filename_ Path to the output file.
+    void start(const std::chrono::seconds& period_, const std::string& filename_) {
+      set_delay(period_);
+      set_out_file(filename_);
+      start();
+    }
+
+    /// @brief Starts the file saver worker thread.
+    void start() {
+      must_die = false;
+      worker_thread = std::thread{ &file_saver_t::worker_function, this };
+    }
+
+    /// @brief Stops the file saver and joins the worker thread.
+    void stop() {
+      must_die = true;
+      if (worker_thread.joinable())
+        worker_thread.join();
+    }
+
+  private:
+
+    // =========================================================================
+    // Worker
+    // =========================================================================
+
+    /// @brief Worker loop: periodically serializes the registry to the output file.
+    ///
+    /// The sleep interval is divided into small fractions so that stop() is
+    /// responsive even with a long save period.
+    void worker_function() {
+      // Divide the period into small fractions for responsive shutdown.
+      const uint64_t divider  = 100;
+      uint64_t       fraction = divider;
+
+      while (true) {
+        std::chrono::milliseconds period_ms = std::chrono::duration_cast<std::chrono::milliseconds>(period);
+        std::this_thread::sleep_for(period_ms / divider);
+
+        if (must_die || --fraction == 0) {
+          fraction = divider;
+
+          if (registry_ptr)
+            save_once();
+
+          if (must_die)
+            return;
+        }
+      }
+    }
+
+    /// @brief Performs a single save: serializes the registry to the output file.
+    ///
+    /// Opens the file, writes the serialized metrics, and closes it.
+    /// The file is overwritten on each save (not appended).
+    void save_once() {
+      std::fstream out_file_stream;
+      out_file_stream.open(filename, std::fstream::out | std::fstream::binary);
+      if (out_file_stream.is_open()) {
+        registry_ptr->serialize(out_file_stream);
+        out_file_stream.close();
+      }
+    }
+  };
+
+  /// @brief Alias for backward compatibility.
+  using SaveToFile = file_saver_t;
+
+} // namespace prometheus
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/gauge.h b/vendors/prometheus-cpp-lite/include/prometheus/gauge.h
new file mode 100644
index 000000000..ed8cf774c
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/gauge.h
@@ -0,0 +1,228 @@
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+namespace prometheus {
+
+  // =============================================================================
+  // gauge_t — Prometheus gauge metric
+  //
+  // A gauge is a metric that represents a single numerical value that can
+  // arbitrarily go up and down (e.g. temperature, memory usage, active requests).
+  // Supports two ownership modes controlled by MetricValue:
+  //
+  //   gauge_t<int64_t>   — owning:    holds its own std::atomic<int64_t>.
+  //   gauge_t<int64_t&>  — reference: binds to the atomic of an owning gauge.
+  //
+  // The reference form enables zero-copy metric handles (see modify_t<>).
+  // =============================================================================
+
+  /// @brief Prometheus gauge metric — a value that can go up and down.
+  ///
+  /// @tparam MetricValue Value type. Use a plain type (e.g. `int64_t`) for an
+  ///         owning gauge, or a reference type (e.g. `int64_t&`) for a
+  ///         zero-copy reference handle.
+  template <typename MetricValue = int64_t>
+  class gauge_t : public Metric {
+
+  public:
+    using storage_type = typename atomic_storage<MetricValue>::storage_type;
+    using value_type   = typename atomic_storage<MetricValue>::value_type;
+    using Family       = CustomFamily<gauge_t<value_type> >; ///< Legacy alias for backward compatibility.
+
+  private:
+    storage_type value;
+    value_type   snapshot_value { 0 };
+
+    /// Grant access to internals so the reference form can bind to the owning form.
+    friend gauge_t<value_type&>;
+
+  public:
+    using Value = value_type;
+
+    // --- Owning constructor (gauge_t<value_type>) -------------------------------
+
+    /// @brief Constructs an owning gauge initialized to zero.
+    /// @param labels Per-metric dimensional labels (copied and owned).
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit gauge_t(const labels_t& labels)
+      : Metric(labels), value(0) {}
+
+    // --- SimpleAPI: easy to use from the user's side, non-trivial internally.
+    // --- Reference constructors (gauge_t<value_type&>) --------------------------
+
+    /// @brief Constructs a reference gauge that binds to an existing owning gauge.
+    /// @param other Owning gauge whose atomic value and labels are referenced.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(gauge_t<value_type>& other)
+      // gauge_t<value_type>& -> gauge_t<value_type&>
+      : Metric(other.labels_ptr), value(other.value), snapshot_value(other.snapshot_value) {}
+
+    /// @brief Constructs a reference gauge by adding an owning gauge to the given family.
+    /// The metric value type compatibility with the family is checked at runtime.
+    /// @param family Family to add the owning gauge to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(family_t& family, const labels_t& labels = {})
+      // family_t::Add<>() -> Family::Add<>() -> gauge_t<value_type>& -> gauge_t<value_type&>
+      : gauge_t(family.Add<gauge_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference gauge by adding an owning gauge to the given family.
+    /// The metric value type compatibility with the family is enforced at compile time.
+    /// @param family Family to add the owning gauge to.
+    /// @param labels Per-metric dimensional labels.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(custom_family_t<gauge_t<value_type> >& family, const labels_t& labels = {})
+      // custom_family_t<>::Add() -> CustomFamily<>::Add() -> gauge_t<value_type>& -> gauge_t<value_type&>
+      : gauge_t(family.Add(labels)) {}
+
+    /// @brief Constructs a reference gauge, creating both family and metric in the given registry.
+    /// @param registry Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<gauge_t<value_type>>() -> gauge_t<value_type>& -> gauge_t<value_type&>
+      : gauge_t(registry.Add(name, help).Add<gauge_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference gauge, creating both family and metric in the given registry.
+    /// @param registry Shared pointer to Registry to register the family in.
+    /// @param name     Metric family name.
+    /// @param help     Help/description string.
+    /// @param labels   Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      // registry::Add() -> Family::Add<gauge_t<value_type>>() -> gauge_t<value_type>& -> gauge_t<value_type&>
+      : gauge_t(registry->Add(name, help).Add<gauge_t<value_type> >(labels)) {}
+
+    /// @brief Constructs a reference gauge using the global registry.
+    /// @param name   Metric family name.
+    /// @param help   Help/description string.
+    /// @param labels Constant base labels for the family.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    gauge_t(const std::string& name, const std::string& help, const labels_t& labels = {})
+      // global_registry::Add() -> Family::Add<gauge_t<value_type>>() -> gauge_t<value_type>& -> gauge_t<value_type&>
+      : gauge_t(global_registry.Add(name, help).Add<gauge_t<value_type>>(labels)) {}
+
+    // --- Conversion: owning → reference -----------------------------------------
+
+    /// @brief Implicit conversion from an owning gauge to a reference gauge.
+    /// @return A reference gauge bound to this owning gauge.
+    //template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    //operator gauge_t<value_type&>() {
+    //  return gauge_t<value_type&>(*this);
+    //}
+
+    // --- Non-copyable (owning form only) ----------------------------------------
+
+    /// @brief Owning gauges are non-copyable to prevent accidental duplication.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    gauge_t(const gauge_t&) = delete;
+
+    /// @brief Owning gauges are non-copy-assignable.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    gauge_t& operator=(const gauge_t&) = delete;
+
+    // --- Public API (shared by both owning and reference forms) -----------------
+
+    /// @brief Increments the gauge by one.
+    void Increment() { ++value; }
+
+    /// @brief Increments the gauge by the given value.
+    /// @param val Amount to add (may be negative).
+    void Increment(const value_type& val) { value += val; }
+
+    /// @brief Decrements the gauge by one.
+    void Decrement() { --value; }
+
+    /// @brief Decrements the gauge by the given value.
+    /// @param val Amount to subtract (may be negative).
+    void Decrement(const value_type& val) { value -= val; }
+
+    /// @brief Sets the gauge to the specified value.
+    /// @param val New value.
+    void Set(const value_type& val) { value.store(val); }
+
+    /// @brief Sets the gauge to the current Unix timestamp (seconds since epoch).
+    void SetToCurrentTime() { value.store(static_cast<value_type>(std::time(nullptr))); }
+
+    /// @brief Returns the current gauge value.
+    /// @return Atomically loaded gauge value.
+    value_type Get() const { return value.load(); }
+
+    /// @brief Pre-increment operator (increments by one).
+    /// @return Reference to this gauge.
+    gauge_t& operator++()                    { ++value;    return *this; }
+
+    /// @brief Post-increment operator (increments by one, returns reference — not previous value).
+    /// @return Reference to this gauge.
+    gauge_t& operator++(int)                 { ++value;    return *this; }
+
+    /// @brief Pre-decrement operator (decrements by one).
+    /// @return Reference to this gauge.
+    gauge_t& operator--()                    { --value;    return *this; }
+
+    /// @brief Post-decrement operator (decrements by one, returns reference — not previous value).
+    /// @return Reference to this gauge.
+    gauge_t& operator--(int)                 { --value;    return *this; }
+
+    /// @brief Compound addition operator.
+    /// @param v Value to add.
+    /// @return Reference to this gauge.
+    gauge_t& operator+=(const value_type& v) { value += v; return *this; }
+
+    /// @brief Compound subtraction operator.
+    /// @param v Value to subtract.
+    /// @return Reference to this gauge.
+    gauge_t& operator-=(const value_type& v) { value -= v; return *this; }
+
+    /// @brief Sets the gauge to the specified value.
+    /// @param val New value.
+    gauge_t& operator=(const value_type& v) { value.store(v); return *this; }
+
+    // --- Metric interface overrides ---------------------------------------------
+
+    /// @brief Returns the Prometheus type name for this metric.
+    /// @return "gauge".
+    const char* type_name() const override { return "gauge"; }
+
+    /// @brief Freezes the current value into a snapshot for consistent serialization.
+    void collect() override { snapshot_value = value.load(); }
+
+    /// @brief Writes this gauge's data line in the Prometheus text exposition format.
+    /// @param out         Output stream.
+    /// @param family_name Metric family name (line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    void serialize(std::ostream& out, const std::string& family_name,
+                   const labels_t& base_labels) const override {
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(), snapshot_value);
+    }
+  };
+
+  // =============================================================================
+  // Convenience aliases
+  // =============================================================================
+
+  /// @brief Generic gauge alias with configurable value type.
+  template <typename T = int64_t>
+  using Gauge = gauge_t<T>;
+
+  /// @brief Fluent builder alias for the default gauge type (legacy from prometheus-cpp, should be double).
+  using BuildGauge = Builder<gauge_t<double>>;
+
+  /// @brief Zero-copy reference handle to a default gauge (SimpleAPI).
+  using gauge_metric_t = typename modify_t<gauge_t<>>::metric_ref;
+
+  /// @brief Typed family alias for default gauges (SimpleAPI).
+  using gauge_family_t = custom_family_t<gauge_t<>>;
+
+} // namespace prometheus
\ No newline at end of file
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/histogram.h b/vendors/prometheus-cpp-lite/include/prometheus/histogram.h
new file mode 100644
index 000000000..61f125aff
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/histogram.h
@@ -0,0 +1,349 @@
+
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+#include <vector>
+#include <limits>
+
+namespace prometheus {
+
+  // =============================================================================
+  // BucketBoundaries — sorted list of upper-bound values for histogram buckets
+  // =============================================================================
+
+  /// @brief Ordered list of upper-bound values that define histogram buckets.
+  ///
+  /// Values must be strictly increasing and must not contain NaN.
+  /// An implicit +Inf bucket is always appended automatically by histogram_t.
+  using BucketBoundaries = std::vector<double>;
+
+  // =============================================================================
+  // HistogramBucket — single histogram bucket (shared across all histogram_t<> instantiations)
+  // =============================================================================
+
+  /// @brief Single histogram bucket with an upper bound and a cumulative count.
+  ///
+  /// Defined outside histogram_t so that histogram_t<double>::Bucket and
+  /// histogram_t<double&>::Bucket are the same type, allowing the reference
+  /// form to bind to the owning form's std::vector<HistogramBucket>.
+  struct HistogramBucket {
+    double                upper_bound;
+    std::atomic<uint64_t> cumulative_count{0};
+
+    HistogramBucket() : upper_bound(0) {}
+    explicit HistogramBucket(double ub) : upper_bound(ub) {}
+    HistogramBucket(HistogramBucket&& other) noexcept
+      : upper_bound(other.upper_bound)
+      , cumulative_count(other.cumulative_count.load()) {}
+  };
+
+  // =============================================================================
+  // HistogramBucketSnapshot — frozen copy of a single bucket for serialization
+  // =============================================================================
+
+  /// @brief Frozen copy of a single bucket for consistent serialization.
+  struct HistogramBucketSnapshot {
+    double   upper_bound      = 0.0;
+    uint64_t cumulative_count = 0;
+  };
+
+  // =============================================================================
+  // histogram_t — Prometheus histogram metric
+  //
+  // A histogram samples observations (e.g. request durations, response sizes)
+  // and counts them in configurable buckets.  It also provides a sum of all
+  // observed values and the total observation count.
+  //
+  // Supports two ownership modes controlled by MetricValue:
+  //
+  //   histogram_t<double>   — owning:    holds its own buckets, count, and sum.
+  //   histogram_t<double&>  — reference: binds to the storage of an owning histogram.
+  //
+  // The reference form enables zero-copy metric handles (see modify_t<>).
+  // =============================================================================
+
+  /// @brief Prometheus histogram metric — samples observations into buckets.
+  ///
+  /// @tparam MetricValue Value type. Use a plain type (e.g. `double`) for an
+  ///         owning histogram, or a reference type (e.g. `double&`) for a
+  ///         zero-copy reference handle.
+  template <typename MetricValue = double>
+  class histogram_t : public Metric {
+
+  public:
+    using value_type       = typename atomic_storage<MetricValue>::value_type;
+    using BucketBoundaries = prometheus::BucketBoundaries; ///< Re-exported for backward compatibility.
+    using Family           = CustomFamily<histogram_t<value_type> >; ///< Legacy alias for backward compatibility.
+    using Bucket           = HistogramBucket;         ///< Re-exported for backward compatibility.
+    using BucketSnapshot   = HistogramBucketSnapshot; ///< Re-exported for backward compatibility.
+
+    /// @brief Returns the default bucket boundaries recommended by Prometheus.
+    /// @return Vector of default upper-bound values.
+    static BucketBoundaries DefaultBoundaries() {
+      return { 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0 };
+    }
+
+  private:
+
+    // Storage types depend on whether this is an owning or reference histogram.
+    // Owning form holds vectors/atomics directly; reference form holds references.
+
+    using buckets_storage_type = std::conditional_t<
+      std::is_reference<MetricValue>::value,
+      std::vector<Bucket>&,
+      std::vector<Bucket>>;
+
+    using count_storage_type = std::conditional_t<
+      std::is_reference<MetricValue>::value,
+      std::atomic<uint64_t>&,
+      std::atomic<uint64_t>>;
+
+    using sum_storage_type = typename atomic_storage<MetricValue>::storage_type;
+
+    // --- Live data (shared between owning and reference forms) ------------------
+
+    buckets_storage_type buckets;
+    count_storage_type   sample_count;
+    sum_storage_type     sample_sum;
+
+    // --- Snapshot (always owning, used for consistent serialization) ------------
+
+    std::vector<BucketSnapshot> snapshot_buckets {};
+    uint64_t                    snapshot_count = 0;
+    value_type                  snapshot_sum   = 0;
+
+    /// Grant access to internals so the reference form can bind to the owning form.
+    friend histogram_t<value_type&>;
+
+  public:
+    using Value = value_type;
+
+    // --- Owning constructor (histogram_t<value_type>) ---------------------------
+
+    /// @brief Constructs an owning histogram with the given bucket boundaries.
+    ///
+    /// An implicit +Inf bucket is always appended as the last bucket.
+    /// Boundaries must be strictly increasing and must not contain NaN.
+    ///
+    /// @param labels     Per-metric dimensional labels (copied and owned).
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    /// @throws std::invalid_argument if boundaries are not strictly increasing or contain NaN.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit histogram_t(const labels_t& labels, const BucketBoundaries& boundaries = DefaultBoundaries())
+      : Metric(labels), sample_count(0), sample_sum(0) {
+      // Validate that boundaries are strictly increasing.
+      for (size_t i = 1; i < boundaries.size(); ++i)
+        if (boundaries[i] <= boundaries[i - 1])
+          throw std::invalid_argument("Bucket boundaries must be strictly increasing");
+
+      buckets.reserve(boundaries.size() + 1);
+      for (double b : boundaries) {
+        if (std::isnan(b))
+          throw std::invalid_argument("Bucket boundary must not be NaN");
+        buckets.emplace_back(b);
+      }
+      // Always add the implicit +Inf bucket.
+      buckets.emplace_back(std::numeric_limits<double>::infinity());
+    }
+
+    // --- SimpleAPI: easy to use from the user's side, non-trivial internally.
+    // --- Reference constructors (histogram_t<value_type&>) ----------------------
+
+    /// @brief Constructs a reference histogram that binds to an existing owning histogram.
+    /// @param other Owning histogram whose buckets, count, and sum are referenced.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(histogram_t<value_type>& other)
+      // histogram_t<value_type>& -> histogram_t<value_type&>
+      : Metric(other.labels_ptr)
+      , buckets(other.buckets)
+      , sample_count(other.sample_count)
+      , sample_sum(other.sample_sum) {}
+
+    /// @brief Constructs a reference histogram by adding an owning histogram to the given family.
+    /// The metric value type compatibility with the family is checked at runtime.
+    /// @param family     Family to add the owning histogram to.
+    /// @param labels     Per-metric dimensional labels.
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(family_t& family, const labels_t& labels = {}, const BucketBoundaries& boundaries = DefaultBoundaries())
+      // family_t::Add<>() -> Family::Add<>() -> histogram_t<value_type>& -> histogram_t<value_type&>
+      : histogram_t(family.Add<histogram_t<value_type> >(labels, boundaries)) {}
+
+    /// @brief Constructs a reference histogram by adding an owning histogram to the given typed family.
+    /// The metric value type compatibility with the family is enforced at compile time.
+    /// @param family     Family to add the owning histogram to.
+    /// @param labels     Per-metric dimensional labels.
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(custom_family_t<histogram_t<value_type> >& family, const labels_t& labels = {}, const BucketBoundaries& boundaries = DefaultBoundaries())
+      // custom_family_t<>::Add() -> CustomFamily<>::Add() -> histogram_t<value_type>& -> histogram_t<value_type&>
+      : histogram_t(family.Add(labels, boundaries)) {}
+
+    /// @brief Constructs a reference histogram, creating both family and metric in the given registry.
+    /// @param registry   Registry to register the family in.
+    /// @param name       Metric family name.
+    /// @param help       Help/description string.
+    /// @param labels     Constant base labels for the family.
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(Registry& registry, const std::string& name, const std::string& help,
+                const labels_t& labels = {}, const BucketBoundaries& boundaries = DefaultBoundaries())
+      // registry::Add() -> Family::Add<histogram_t<value_type>>() -> histogram_t<value_type>& -> histogram_t<value_type&>
+      : histogram_t(registry.Add(name, help).Add<histogram_t<value_type>>(labels, boundaries)) {}
+
+    /// @brief Constructs a reference histogram, creating both family and metric in the given registry.
+    /// @param registry   Shared pointer to Registry to register the family in.
+    /// @param name       Metric family name.
+    /// @param help       Help/description string.
+    /// @param labels     Constant base labels for the family.
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help,
+                const labels_t& labels = {}, const BucketBoundaries& boundaries = DefaultBoundaries())
+      // registry::Add() -> Family::Add<histogram_t<value_type>>() -> histogram_t<value_type>& -> histogram_t<value_type&>
+      : histogram_t(registry->Add(name, help).Add<histogram_t<value_type>>(labels, boundaries)) {}
+
+    /// @brief Constructs a reference histogram using the global registry.
+    /// @param name       Metric family name.
+    /// @param help       Help/description string.
+    /// @param labels     Constant base labels for the family.
+    /// @param boundaries Sorted upper-bound values for the buckets.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    histogram_t(const std::string& name, const std::string& help,
+                const labels_t& labels = {}, const BucketBoundaries& boundaries = DefaultBoundaries())
+      // global_registry::Add() -> Family::Add<histogram_t<value_type>>() -> histogram_t<value_type>& -> histogram_t<value_type&>
+      : histogram_t(global_registry.Add(name, help).Add<histogram_t<value_type>>(labels, boundaries)) {}
+
+    // --- Conversion: owning → reference -----------------------------------------
+
+    /// @brief Implicit conversion from an owning histogram to a reference histogram.
+    /// @return A reference histogram bound to this owning histogram.
+    //template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    //operator histogram_t<value_type&>() {
+    //  return histogram_t<value_type&>(*this);
+    //}
+
+    // --- Non-copyable (owning form only) ----------------------------------------
+
+    /// @brief Owning histograms are non-copyable to prevent accidental duplication.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    histogram_t(const histogram_t&) = delete;
+
+    /// @brief Owning histograms are non-copy-assignable.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    histogram_t& operator=(const histogram_t&) = delete;
+
+    // --- Public API (shared by both owning and reference forms) -----------------
+
+    /// @brief Records an observation.
+    ///
+    /// Finds the first bucket whose upper bound is >= val, then increments
+    /// that bucket and all subsequent buckets (cumulative counts).
+    /// Also adds val to the running sum and increments the total count.
+    ///
+    /// @param val Observed value.
+    void Observe(value_type val) {
+      double dval = static_cast<double>(val);
+
+      // Find the first bucket whose upper bound covers this value.
+      size_t i = 0;
+      for (; i < buckets.size(); ++i)
+        if (dval <= buckets[i].upper_bound)
+          break;
+
+      // Increment all buckets from the found one to the end (cumulative).
+      for (; i < buckets.size(); ++i)
+        ++buckets[i].cumulative_count;
+
+      sample_sum += val;
+      ++sample_count;
+    }
+
+    /// @brief Returns the total number of observations.
+    /// @return Atomically loaded observation count.
+    uint64_t GetCount() const { return sample_count.load(); }
+
+    /// @brief Returns the sum of all observed values.
+    /// @return Atomically loaded sum.
+    value_type GetSum() const { return sample_sum.load(); }
+
+    // --- Metric interface overrides ---------------------------------------------
+
+    /// @brief Returns the Prometheus type name for this metric.
+    /// @return "histogram".
+    const char* type_name() const override { return "histogram"; }
+
+    /// @brief Freezes the current values into snapshots for consistent serialization.
+    ///
+    /// Copies the current count, sum, and all bucket cumulative counts into
+    /// local snapshot fields so that serialization reads a consistent set.
+    void collect() override {
+      snapshot_count = sample_count.load();
+      snapshot_sum   = sample_sum.load();
+      snapshot_buckets.resize(buckets.size());
+      for (size_t i = 0; i < buckets.size(); ++i) {
+        snapshot_buckets[i].upper_bound     = buckets[i].upper_bound;
+        snapshot_buckets[i].cumulative_count = buckets[i].cumulative_count.load();
+      }
+    }
+
+    /// @brief Writes this histogram's data lines in the Prometheus text exposition format.
+    ///
+    /// Emits one `_bucket{le="..."}` line per bucket, followed by `_count` and `_sum` lines.
+    ///
+    /// @param out         Output stream.
+    /// @param family_name Metric family name (line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    void serialize(std::ostream& out, const std::string& family_name,
+                   const labels_t& base_labels) const override {
+      // Write one line per bucket with the "le" (less-or-equal) extra label.
+      for (size_t i = 0; i < snapshot_buckets.size(); ++i) {
+        const BucketSnapshot& b = snapshot_buckets[i];
+
+        // Format the upper bound: "+Inf" for infinity, numeric otherwise.
+        std::ostringstream bound_oss;
+        if (std::isinf(b.upper_bound))
+          bound_oss << "+Inf";
+        else
+          TextSerializer::WriteValue(bound_oss, b.upper_bound);
+        std::string bound_str = bound_oss.str();
+
+        TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                  b.cumulative_count, "_bucket", "le", bound_str);
+      }
+
+      // Write the total count and sum lines.
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                snapshot_count, "_count");
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                snapshot_sum, "_sum");
+    }
+  };
+
+  // =============================================================================
+  // Convenience aliases
+  // =============================================================================
+
+  /// @brief Generic histogram alias with configurable value type.
+  template <typename T = double>
+  using Histogram = histogram_t<T>;
+
+  /// @brief Fluent builder alias for the default histogram type.
+  using BuildHistogram = Builder<histogram_t<double>>;
+
+  /// @brief Zero-copy reference handle to a default histogram (SimpleAPI).
+  using histogram_metric_t = typename modify_t<histogram_t<>>::metric_ref;
+
+  /// @brief Typed family alias for default histograms (SimpleAPI).
+  using histogram_family_t = custom_family_t<histogram_t<>>;
+
+} // namespace prometheus
\ No newline at end of file
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/info.h b/vendors/prometheus-cpp-lite/include/prometheus/info.h
new file mode 100644
index 000000000..7a01f97d3
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/info.h
@@ -0,0 +1,83 @@
+
+#pragma once
+
+#include "prometheus/gauge.h"
+
+namespace prometheus {
+
+  /// @brief Info metric — a gauge fixed at 1 whose labels carry metadata.
+  ///
+  /// Common use case: exposing build version, commit hash, etc.
+  ///
+  /// @code
+  ///   info_metric_t build_info(registry, "build_info", "Build information",
+  ///                            {{"version", "1.2.3"}, {"commit", "abc123"}});
+  /// @endcode
+  ///
+  /// Produces:
+  ///   # HELP build_info Build information
+  ///   # TYPE build_info gauge
+  ///   build_info{version="1.2.3",commit="abc123"} 1
+  template <typename MetricValue = double>
+  class info_t : public Metric {
+
+  public:
+    using storage_type = typename atomic_storage<MetricValue>::storage_type;
+    using value_type   = typename atomic_storage<MetricValue>::value_type;
+
+  private:
+    storage_type value;
+
+    friend info_t<value_type&>;
+
+  public:
+
+    // --- Owning constructor ---
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit info_t(const labels_t& labels)
+      : Metric(labels), value(1) {}
+
+    // --- Reference constructors ---
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(info_t<value_type>& other)
+      : Metric(other.labels_ptr), value(other.value) {}
+
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(family_t& family, const labels_t& labels = {})
+      : info_t(family.Add<info_t<value_type> >(labels)) {}
+
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(custom_family_t<info_t<value_type> >& family, const labels_t& labels = {})
+      : info_t(family.Add(labels)) {}
+
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(Registry& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      : info_t(registry.Add(name, help).Add<info_t<value_type>>(labels)) {}
+
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help, const labels_t& labels = {})
+      : info_t(registry->Add(name, help).Add<info_t<value_type>>(labels)) {}
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    info_t(const std::string& name, const std::string& help, const labels_t& labels = {})
+      : info_t(global_registry.Add(name, help).Add<info_t<value_type>>(labels)) {}
+
+    // Non-copyable (owning form)
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    info_t(const info_t&) = delete;
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    info_t& operator=(const info_t&) = delete;
+
+    /// @brief Always returns 1.
+    value_type Get() const { return value.load(); }
+
+    // --- Metric interface ---
+    const char* type_name() const override { return "gauge"; }
+    void collect() override {}
+    void serialize(std::ostream& out, const std::string& family_name, const labels_t& base_labels) const override {
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(), static_cast<value_type>(1));
+    }
+  };
+
+  using info_metric_t = typename modify_t<info_t<>>::metric_ref;
+
+} // namespace prometheus
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/prometheus.h b/vendors/prometheus-cpp-lite/include/prometheus/prometheus.h
new file mode 100644
index 000000000..58de7ca55
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/prometheus.h
@@ -0,0 +1,14 @@
+
+#include "prometheus/counter.h"
+#include "prometheus/gauge.h"
+#include "prometheus/summary.h"
+#include "prometheus/histogram.h"
+#include "prometheus/benchmark.h"
+#include "prometheus/info.h"
+
+#include <prometheus/file_saver.h>
+
+namespace prometheus {
+  extern Registry      global_registry;
+  extern file_saver_t  file_saver;
+}
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/simpleapi.h b/vendors/prometheus-cpp-lite/include/prometheus/simpleapi.h
new file mode 100644
index 000000000..dfce0c7da
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/simpleapi.h
@@ -0,0 +1,21 @@
+
+// Compatibility shim — v1.0 header name.
+// In v2.0 all core classes are in core.h.
+#pragma once
+#pragma message("warning: <prometheus/simpleapi.h> is deprecated in v2.0, use <prometheus/prometheus.h> instead")
+#include "prometheus/prometheus.h"
+
+namespace prometheus {
+  namespace simpleapi {
+    using counter_family_t   [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::counter_family_t;
+    using counter_metric_t   [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::counter_metric_t;
+    using gauge_family_t     [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::gauge_family_t;
+    using gauge_metric_t     [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::gauge_metric_t;
+    using summary_family_t   [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::summary_family_t;
+    using summary_metric_t   [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::summary_metric_t;
+    using histogram_family_t [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::histogram_family_t;
+    using histogram_metric_t [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::histogram_metric_t;
+    using benchmark_family_t [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::benchmark_family_t;
+    using benchmark_metric_t [[deprecated("Use prometheus namespace instead of prometheus::simpleapi")]] = prometheus::benchmark_metric_t;
+  }
+}
diff --git a/vendors/prometheus-cpp-lite/include/prometheus/summary.h b/vendors/prometheus-cpp-lite/include/prometheus/summary.h
new file mode 100644
index 000000000..ae4b41c12
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/include/prometheus/summary.h
@@ -0,0 +1,416 @@
+/*
+* prometheus-cpp-lite — header-only C++ library for exposing Prometheus metrics
+* https://github.com/biaks/prometheus-cpp-lite
+*
+* Copyright (c) 2026 Yan Kryukov ianiskr@gmail.com
+* Licensed under the MIT License
+*/
+
+#pragma once
+
+#include "prometheus/core.h"
+
+#include <vector>
+#include <algorithm>
+
+namespace prometheus {
+
+  // =============================================================================
+  // SummaryQuantile / SummaryQuantiles — quantile definitions for summary metrics
+  // =============================================================================
+
+  /// @brief Definition of a single quantile target with an allowed error.
+  struct SummaryQuantile {
+    double quantile;  ///< Target quantile, e.g. 0.5, 0.9, 0.99.
+    double error;     ///< Allowed error, e.g. 0.05, 0.01, 0.001.
+  };
+
+  /// @brief Ordered list of quantile/error pairs that define summary targets.
+  using SummaryQuantiles = std::vector<SummaryQuantile>;
+
+  // =============================================================================
+  // SummaryLiveData<T> — thread-safe observation buffer (shared across instantiations)
+  //
+  // Defined outside summary_t so that summary_t<double>::LiveData and
+  // summary_t<double&>::LiveData are the same type, allowing the reference
+  // form to bind to the owning form's buffer.
+  // =============================================================================
+
+  /// @brief Thread-safe observation buffer holding raw samples, sum, and count.
+  ///
+  /// @tparam T Value type for observations and sum (typically `double`).
+  template <typename T>
+  struct SummaryLiveData {
+    std::vector<T> observations;
+    T              sample_sum   = 0;
+    uint64_t       sample_count = 0;
+    mutable std::mutex mutex;
+
+    /// @brief Records a single observation.
+    /// @param val Observed value.
+    void Observe(T val) {
+      std::lock_guard<std::mutex> lock(mutex);
+      observations.push_back(val);
+      sample_sum += val;
+      ++sample_count;
+    }
+
+    /// @brief Takes a consistent snapshot, retaining only the newest observations.
+    /// @param out_obs   Output: copy of the observation buffer.
+    /// @param out_sum   Output: current sum.
+    /// @param out_count Output: current count.
+    void Snapshot(std::vector<T>& out_obs, T& out_sum, uint64_t& out_count, size_t max_observations) {
+      std::lock_guard<std::mutex> lock(mutex);
+      if (observations.size() > max_observations) {
+        observations.erase(observations.begin(), observations.begin() + static_cast<ptrdiff_t>(observations.size() - max_observations));
+      }
+      out_obs   = observations;
+      out_sum   = sample_sum;
+      out_count = sample_count;
+    }
+
+    /// @brief Resets all observations (used for sliding-window semantics).
+    void Reset() {
+      std::lock_guard<std::mutex> lock(mutex);
+      observations.clear();
+      sample_sum   = 0;
+      sample_count = 0;
+    }
+  };
+
+  // =============================================================================
+  // SummaryQuantileSnapshot — frozen quantile value for serialization
+  // =============================================================================
+
+  /// @brief Frozen quantile value for consistent serialization.
+  ///
+  /// @tparam T Value type (typically `double`).
+  template <typename T>
+  struct SummaryQuantileSnapshot {
+    double quantile = 0.0;
+    T      value    = 0;
+  };
+
+  // =============================================================================
+  // summary_t — Prometheus summary metric
+  //
+  // A summary computes configurable quantiles over a sliding window of
+  // observations.  Uses a simplified approach: all observations are stored
+  // in a buffer, sorted at collect() time, and quantiles are computed via
+  // linear interpolation.
+  //
+  // For production workloads a full CKMS or t-digest algorithm is recommended.
+  //
+  // Supports two ownership modes controlled by MetricValue:
+  //
+  //   summary_t<double>   — owning:    holds its own observation buffer.
+  //   summary_t<double&>  — reference: binds to the buffer of an owning summary.
+  //
+  // The reference form enables zero-copy metric handles (see modify_t<>).
+  // =============================================================================
+
+  /// @brief Prometheus summary metric — computes quantiles over observations.
+  ///
+  /// @tparam MetricValue Value type. Use a plain type (e.g. `double`) for an
+  ///         owning summary, or a reference type (e.g. `double&`) for a
+  ///         zero-copy reference handle.
+  template <typename MetricValue = double>
+  class summary_t : public Metric {
+
+  public:
+    using value_type       = typename atomic_storage<MetricValue>::value_type;
+    using Family           = CustomFamily<summary_t<value_type> >; ///< Legacy alias for backward compatibility.
+    using Quantile         = SummaryQuantile;          ///< Re-exported for backward compatibility.
+    using Quantiles        = SummaryQuantiles;         ///< Re-exported for backward compatibility.
+    using LiveData         = SummaryLiveData<value_type>;          ///< Re-exported for backward compatibility.
+    using QuantileSnapshot = SummaryQuantileSnapshot<value_type>;  ///< Re-exported for backward compatibility.
+
+    /// @brief Returns the default quantile definitions (p50, p90, p95, p99).
+    /// @return Vector of default quantile/error pairs.
+    static Quantiles DefaultQuantiles() {
+      return {
+        {0.5,  0.05},
+        {0.9,  0.01},
+        {0.95, 0.005},
+        {0.99, 0.001}
+      };
+    }
+
+  private:
+
+    // Owning form holds LiveData directly; reference form holds a reference.
+    using live_data_storage_type = std::conditional_t<
+      std::is_reference<MetricValue>::value,
+      LiveData&,
+      LiveData>;
+
+    live_data_storage_type live_data;
+    Quantiles              quantile_defs;
+
+    // --- Snapshot (always owning, used for consistent serialization) ------------
+
+    std::vector<QuantileSnapshot> snapshot_quantiles {};
+    uint64_t                      snapshot_count = 0;
+    value_type                    snapshot_sum   = 0;
+
+    /// Maximum number of observations kept in the buffer (sliding window).
+    /// When exceeded, the oldest observations are discarded during collect().
+    size_t max_observations;
+
+    /// Grant access to internals so the reference form can bind to the owning form.
+    friend summary_t<value_type&>;
+
+    // --- Quantile computation helper -------------------------------------------
+
+    /// @brief Computes a quantile from a sorted observation vector using linear interpolation.
+    /// @param sorted Sorted vector of observations.
+    /// @param q      Target quantile in [0, 1].
+    /// @return Interpolated quantile value, or 0 if the vector is empty.
+    static value_type ComputeQuantile(const std::vector<value_type>& sorted, double q) {
+      if (sorted.empty()) return 0;
+      if (q <= 0.0)       return sorted.front();
+      if (q >= 1.0)       return sorted.back();
+
+      double idx  = q * static_cast<double>(sorted.size() - 1);
+      size_t lo   = static_cast<size_t>(idx);
+      size_t hi   = lo + 1;
+      double frac = idx - static_cast<double>(lo);
+
+      if (hi >= sorted.size())
+        return sorted.back();
+
+      // Linear interpolation between the two surrounding elements.
+      return static_cast<value_type>(
+        static_cast<double>(sorted[lo]) * (1.0 - frac) +
+        static_cast<double>(sorted[hi]) * frac);
+    }
+
+  public:
+    using Value = value_type;
+
+    // --- Owning constructor (summary_t<value_type>) -----------------------------
+
+    /// @brief Constructs an owning summary with the given quantile definitions.
+    ///
+    /// @param labels    Per-metric dimensional labels (copied and owned).
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs   Maximum observations to keep in the buffer (sliding window).
+    /// @throws std::invalid_argument if any quantile or error is outside [0, 1],
+    ///         or if the quantile list is empty.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    explicit summary_t(const labels_t& labels,
+                       const Quantiles& quantiles = DefaultQuantiles(),
+                       size_t max_obs = 500000)
+      : Metric(labels), quantile_defs(quantiles), max_observations(max_obs) {
+      for (const Quantile& q : quantile_defs) {
+        if (q.quantile < 0.0 || q.quantile > 1.0)
+          throw std::invalid_argument("Quantile must be in [0, 1], got: " + std::to_string(q.quantile));
+        if (q.error < 0.0 || q.error > 1.0)
+          throw std::invalid_argument("Quantile error must be in [0, 1], got: " + std::to_string(q.error));
+      }
+      if (quantile_defs.empty())
+        throw std::invalid_argument("Summary must have at least one quantile definition");
+    }
+
+    // --- SimpleAPI: easy to use from the user's side, non-trivial internally.
+    // --- Reference constructors (summary_t<value_type&>) ------------------------
+
+    /// @brief Constructs a reference summary that binds to an existing owning summary.
+    /// @param other Owning summary whose live data and definitions are referenced.
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(summary_t<value_type>& other)
+      // summary_t<value_type>& -> summary_t<value_type&>
+      : Metric(other.labels_ptr)
+      , live_data(other.live_data)
+      , quantile_defs(other.quantile_defs)
+      , max_observations(other.max_observations) {}
+
+    /// @brief Constructs a reference summary by adding an owning summary to the given family.
+    /// The metric value type compatibility with the family is checked at runtime.
+    /// @param family   Family to add the owning summary to.
+    /// @param labels   Per-metric dimensional labels.
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs  Maximum observations to keep in the buffer (sliding window).
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(family_t& family, const labels_t& labels = {},
+              const Quantiles& quantiles = DefaultQuantiles(), size_t max_obs = 500000)
+      // family_t::Add<>() -> Family::Add<>() -> summary_t<value_type>& -> summary_t<value_type&>
+      : summary_t(family.Add<summary_t<value_type> >(labels, quantiles, max_obs)) {}
+
+    /// @brief Constructs a reference summary by adding an owning summary to the given typed family.
+    /// The metric value type compatibility with the family is enforced at compile time.
+    /// @param family   Family to add the owning summary to.
+    /// @param labels   Per-metric dimensional labels.
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs  Maximum observations to keep in the buffer (sliding window).
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(custom_family_t<summary_t<value_type> >& family, const labels_t& labels = {},
+              const Quantiles& quantiles = DefaultQuantiles(), size_t max_obs = 500000)
+      // custom_family_t<>::Add() -> CustomFamily<>::Add() -> summary_t<value_type>& -> summary_t<value_type&>
+      : summary_t(family.Add(labels, quantiles, max_obs)) {}
+
+    /// @brief Constructs a reference summary, creating both family and metric in the given registry.
+    /// @param registry  Registry to register the family in.
+    /// @param name      Metric family name.
+    /// @param help      Help/description string.
+    /// @param labels    Constant base labels for the family.
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs   Maximum observations to keep in the buffer (sliding window).
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(Registry& registry, const std::string& name, const std::string& help,
+              const labels_t& labels = {}, const Quantiles& quantiles = DefaultQuantiles(),
+              size_t max_obs = 500000)
+      // registry::Add() -> Family::Add<summary_t<value_type>>() -> summary_t<value_type>& -> summary_t<value_type&>
+      : summary_t(registry.Add(name, help).Add<summary_t<value_type>>(labels, quantiles, max_obs)) {}
+
+    /// @brief Constructs a reference summary, creating both family and metric in the given registry.
+    /// @param registry  Shared pointer to Registry to register the family in.
+    /// @param name      Metric family name.
+    /// @param help      Help/description string.
+    /// @param labels    Constant base labels for the family.
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs   Maximum observations to keep in the buffer (sliding window).
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(std::shared_ptr<registry_t>& registry, const std::string& name, const std::string& help,
+              const labels_t& labels = {}, const Quantiles& quantiles = DefaultQuantiles(),
+              size_t max_obs = 500000)
+      // registry::Add() -> Family::Add<summary_t<value_type>>() -> summary_t<value_type>& -> summary_t<value_type&>
+      : summary_t(registry->Add(name, help).Add<summary_t<value_type>>(labels, quantiles, max_obs)) {}
+
+    /// @brief Constructs a reference summary using the global registry.
+    /// @param name      Metric family name.
+    /// @param help      Help/description string.
+    /// @param labels    Constant base labels for the family.
+    /// @param quantiles Quantile/error pairs to compute.
+    /// @param max_obs   Maximum observations to keep in the buffer (sliding window).
+    template <typename U = MetricValue, std::enable_if_t<std::is_reference<U>::value, int> = 0>
+    summary_t(const std::string& name, const std::string& help,
+              const labels_t& labels = {}, const Quantiles& quantiles = DefaultQuantiles(),
+              size_t max_obs = 500000)
+      // global_registry::Add() -> Family::Add<summary_t<value_type>>() -> summary_t<value_type>& -> summary_t<value_type&>
+      : summary_t(global_registry.Add(name, help).Add<summary_t<value_type>>(labels, quantiles, max_obs)) {}
+
+    // --- Conversion: owning → reference -----------------------------------------
+
+    /// @brief Implicit conversion from an owning summary to a reference summary.
+    /// @return A reference summary bound to this owning summary.
+    //template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    //operator summary_t<value_type&>() {
+    //  return summary_t<value_type&>(*this);
+    //}
+
+    // --- Non-copyable (owning form only) ----------------------------------------
+
+    /// @brief Owning summaries are non-copyable to prevent accidental duplication.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    summary_t(const summary_t&) = delete;
+
+    /// @brief Owning summaries are non-copy-assignable.
+    template <typename U = MetricValue, std::enable_if_t<!std::is_reference<U>::value, int> = 0>
+    summary_t& operator=(const summary_t&) = delete;
+
+    // --- Public API (shared by both owning and reference forms) -----------------
+
+    /// @brief Records a single observation.
+    /// @param val Observed value.
+    void Observe(value_type val) {
+      live_data.Observe(val);
+    }
+
+    /// @brief Returns the total number of observations recorded so far.
+    /// @return Observation count (read under mutex).
+    uint64_t GetCount() const {
+      std::lock_guard<std::mutex> lock(live_data.mutex);
+      return live_data.sample_count;
+    }
+
+    /// @brief Returns the sum of all observed values.
+    /// @return Observation sum (read under mutex).
+    value_type GetSum() const {
+      std::lock_guard<std::mutex> lock(live_data.mutex);
+      return live_data.sample_sum;
+    }
+
+    // --- Metric interface overrides ---------------------------------------------
+
+    /// @brief Returns the Prometheus type name for this metric.
+    /// @return "summary".
+    const char* type_name() const override { return "summary"; }
+
+    /// @brief Freezes the current values into snapshots for consistent serialization.
+    ///
+    /// Takes a snapshot of the observation buffer, trims it to max_observations
+    /// (sliding window), sorts it, and computes all configured quantiles.
+    void collect() override {
+      std::vector<value_type> observations;
+      value_type              sum;
+      uint64_t                count;
+
+      live_data.Snapshot(observations, sum, count, max_observations);
+
+      snapshot_count = count;
+      snapshot_sum   = sum;
+
+      // Sort observations for quantile computation.
+      std::sort(observations.begin(), observations.end());
+
+      // Compute each configured quantile from the sorted buffer.
+      snapshot_quantiles.resize(quantile_defs.size());
+      for (size_t i = 0; i < quantile_defs.size(); ++i) {
+        snapshot_quantiles[i].quantile = quantile_defs[i].quantile;
+        snapshot_quantiles[i].value    = ComputeQuantile(observations, quantile_defs[i].quantile);
+      }
+    }
+
+    /// @brief Writes this summary's data lines in the Prometheus text exposition format.
+    ///
+    /// Emits one line per quantile with a "quantile" extra label, followed by
+    /// `_count` and `_sum` lines.
+    ///
+    /// @param out         Output stream.
+    /// @param family_name Metric family name (line prefix).
+    /// @param base_labels Constant labels from the owning family.
+    void serialize(std::ostream& out, const std::string& family_name,
+                   const labels_t& base_labels) const override {
+      // Write one line per quantile with the "quantile" extra label.
+      for (size_t i = 0; i < snapshot_quantiles.size(); ++i) {
+        const QuantileSnapshot& q = snapshot_quantiles[i];
+
+        // Format the quantile value as a compact string.
+        std::string quantile_str;
+        {
+          std::array<char, 64> buf;
+          int n = std::snprintf(buf.data(), buf.size(), "%g", q.quantile);
+          quantile_str.assign(buf.data(), static_cast<size_t>(n));
+        }
+
+        TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                  q.value, "", "quantile", quantile_str);
+      }
+
+      // Write the total count and sum lines.
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                snapshot_count, "_count");
+      TextSerializer::WriteLine(out, family_name, base_labels, this->get_labels(),
+                                snapshot_sum, "_sum");
+    }
+  };
+
+  // =============================================================================
+  // Convenience aliases
+  // =============================================================================
+
+  /// @brief Generic summary alias with configurable value type.
+  template <typename T = double>
+  using Summary = summary_t<T>;
+
+  /// @brief Fluent builder alias for the default summary type.
+  using BuildSummary = Builder<summary_t<double>>;
+
+  /// @brief Zero-copy reference handle to a default summary (SimpleAPI).
+  using summary_metric_t = typename modify_t<summary_t<>>::metric_ref;
+
+  /// @brief Typed family alias for default summaries (SimpleAPI).
+  using summary_family_t = custom_family_t<summary_t<>>;
+
+} // namespace prometheus
\ No newline at end of file
diff --git a/vendors/prometheus-cpp-lite/src/simpleapi.cpp b/vendors/prometheus-cpp-lite/src/simpleapi.cpp
new file mode 100644
index 000000000..4bb3a92e8
--- /dev/null
+++ b/vendors/prometheus-cpp-lite/src/simpleapi.cpp
@@ -0,0 +1,8 @@
+
+#include "prometheus/core.h"
+#include "prometheus/file_saver.h"
+
+namespace prometheus {
+  Registry       global_registry;
+  file_saver_t   file_saver  {global_registry};
+}