URI decoding, process env, compiler info, httpasio strands, regex route removal (#841)

- Percent-decode URIs in ASIO HTTP server to match http.sys CookedUrl behavior, ensuring consistent decoded paths across backends
- Add Environment field to CreateProcOptions for passing extra env vars to child processes (Windows: merged into Unicode environment block; Unix: setenv in fork)
- Add GetCompilerName() and include it in build options startup logging
- Suppress Windows CRT error dialogs in test harness for headless/CI runs
- Fix mimalloc package: pass CMAKE_BUILD_TYPE, skip cfuncs test for cross-compile
- Add virtual destructor to SentryAssertImpl to fix debug-mode warning
- Simplify object store path handling now that URIs arrive pre-decoded
- Add URI decoding test coverage for percent-encoded paths and query params
- Simplify httpasio request handling by using strands (guarantees no parallel handlers per connection)
- Removed deprecated regex-based route matching support
- Fix full GC never triggering after cross-toolchain builds: The `gc_state` file stores `system_clock` ticks, but the tick resolution differs between toolchains (nanoseconds on GCC/standard clang, microseconds on UE clang). A nanosecond timestamp misinterpreted as microseconds appears far in the future (~year 58,000), bypassing the staleness check and preventing time-based full GC from ever running. Fixed by also resetting when the stored timestamp is in the future.
- Clamp GC countdown display to configured interval: Prevents nonsensical log output (e.g. "Full GC in 492128002h") caused by the above or any other clock anomaly. The clamp applies to both the scheduler log and the status API.

1 files changed, 47 insertions, 239 deletions

diff --git a/src/zenhttp/httpserver.cpp b/src/zenhttp/httpserver.cpp
index 672467f56..4d98e9650 100644
--- a/src/zenhttp/httpserver.cpp
+++ b/src/zenhttp/httpserver.cpp
@@ -700,15 +700,6 @@ HttpServerRequest::ReadPayloadPackage()
 //////////////////////////////////////////////////////////////////////////
 
 void
-HttpRequestRouter::AddPattern(const char* Id, const char* Regex)
-{
-	ZEN_ASSERT(m_PatternMap.find(Id) == m_PatternMap.end());
-	ZEN_ASSERT(!m_IsFinalized);
-
-	m_PatternMap.insert({Id, Regex});
-}
-
-void
 HttpRequestRouter::AddMatcher(const char* Id, std::function<bool(std::string_view)>&& Matcher)
 {
 	ZEN_ASSERT(m_MatcherNameMap.find(Id) == m_MatcherNameMap.end());
@@ -724,170 +715,77 @@ HttpRequestRouter::RegisterRoute(const char* UriPattern, HttpRequestRouter::Hand
 {
 	ZEN_ASSERT(!m_IsFinalized);
 
-	if (ExtendableStringBuilder<128> ExpandedRegex; ProcessRegexSubstitutions(UriPattern, ExpandedRegex))
-	{
-		// Regex route
-		m_RegexHandlers.emplace_back(ExpandedRegex.c_str(), SupportedVerbs, std::move(HandlerFunc), UriPattern);
-	}
-	else
-	{
-		// New-style regex-free route. More efficient and should be used for everything eventually
+	int RegexLen = gsl::narrow_cast<int>(strlen(UriPattern));
 
-		int RegexLen = gsl::narrow_cast<int>(strlen(UriPattern));
+	int i = 0;
 
-		int i = 0;
+	std::vector<int> MatcherIndices;
 
-		std::vector<int> MatcherIndices;
-
-		while (i < RegexLen)
+	while (i < RegexLen)
+	{
+		if (UriPattern[i] == '{')
 		{
-			if (UriPattern[i] == '{')
+			bool IsComplete	  = false;
+			int	 PatternStart = i + 1;
+			while (++i < RegexLen)
 			{
-				bool IsComplete	  = false;
-				int	 PatternStart = i + 1;
-				while (++i < RegexLen)
+				if (UriPattern[i] == '}')
 				{
-					if (UriPattern[i] == '}')
+					if (i == PatternStart)
 					{
-						if (i == PatternStart)
-						{
-							throw std::runtime_error(fmt::format("matcher pattern is empty in URI pattern '{}'", UriPattern));
-						}
-						std::string_view Pattern(&UriPattern[PatternStart], i - PatternStart);
-						if (auto it = m_MatcherNameMap.find(std::string(Pattern)); it != m_MatcherNameMap.end())
-						{
-							// It's a match
-							MatcherIndices.push_back(it->second);
-							IsComplete = true;
-							++i;
-							break;
-						}
-						else
-						{
-							throw std::runtime_error(fmt::format("unknown matcher pattern '{}' in URI pattern '{}'", Pattern, UriPattern));
-						}
+						throw std::runtime_error(fmt::format("matcher pattern is empty in URI pattern '{}'", UriPattern));
 					}
-				}
-				if (!IsComplete)
-				{
-					throw std::runtime_error(fmt::format("unterminated matcher pattern in URI pattern '{}'", UriPattern));
-				}
-			}
-			else
-			{
-				if (UriPattern[i] == '/')
-				{
-					throw std::runtime_error(fmt::format("unexpected '/' in literal segment of URI pattern '{}'", UriPattern));
-				}
-
-				int SegmentStart = i;
-				while (++i < RegexLen && UriPattern[i] != '/')
-					;
-
-				std::string_view Segment(&UriPattern[SegmentStart], (i - SegmentStart));
-				int				 LiteralIndex = gsl::narrow_cast<int>(m_Literals.size());
-				m_Literals.push_back(std::string(Segment));
-				MatcherIndices.push_back(-1 - LiteralIndex);
-			}
-
-			if (i < RegexLen && UriPattern[i] == '/')
-			{
-				++i;  // skip slash
-			}
-		}
-
-		m_MatcherEndpoints.emplace_back(std::move(MatcherIndices), SupportedVerbs, std::move(HandlerFunc), UriPattern);
-	}
-}
-
-std::string_view
-HttpRouterRequest::GetCapture(uint32_t Index) const
-{
-	if (!m_CapturedSegments.empty())
-	{
-		ZEN_ASSERT(Index < m_CapturedSegments.size());
-		return m_CapturedSegments[Index];
-	}
-
-	ZEN_ASSERT(Index < m_Match.size());
-
-	const auto& Match = m_Match[Index];
-
-	return std::string_view(&*Match.first, Match.second - Match.first);
-}
-
-bool
-HttpRequestRouter::ProcessRegexSubstitutions(const char* Regex, StringBuilderBase& OutExpandedRegex)
-{
-	size_t RegexLen = strlen(Regex);
-
-	bool HasRegex = false;
-
-	std::vector<std::string> UnknownPatterns;
-
-	for (size_t i = 0; i < RegexLen;)
-	{
-		bool matched = false;
-
-		if (Regex[i] == '{' && ((i == 0) || (Regex[i - 1] != '\\')))
-		{
-			// Might have a pattern reference - find closing brace
-
-			for (size_t j = i + 1; j < RegexLen; ++j)
-			{
-				if (Regex[j] == '}')
-				{
-					std::string Pattern(&Regex[i + 1], j - i - 1);
-
-					if (auto it = m_PatternMap.find(Pattern); it != m_PatternMap.end())
+					std::string_view Pattern(&UriPattern[PatternStart], i - PatternStart);
+					if (auto it = m_MatcherNameMap.find(std::string(Pattern)); it != m_MatcherNameMap.end())
 					{
-						OutExpandedRegex.Append(it->second.c_str());
-						HasRegex = true;
+						// It's a match
+						MatcherIndices.push_back(it->second);
+						IsComplete = true;
+						++i;
+						break;
 					}
 					else
 					{
-						UnknownPatterns.push_back(Pattern);
+						throw std::runtime_error(fmt::format("unknown matcher pattern '{}' in URI pattern '{}'", Pattern, UriPattern));
 					}
-
-					// skip ahead
-					i = j + 1;
-
-					matched = true;
-
-					break;
 				}
 			}
+			if (!IsComplete)
+			{
+				throw std::runtime_error(fmt::format("unterminated matcher pattern in URI pattern '{}'", UriPattern));
+			}
 		}
-
-		if (!matched)
-		{
-			OutExpandedRegex.Append(Regex[i++]);
-		}
-	}
-
-	if (HasRegex)
-	{
-		if (UnknownPatterns.size() > 0)
+		else
 		{
-			std::string UnknownList;
-			for (const auto& Pattern : UnknownPatterns)
+			if (UriPattern[i] == '/')
 			{
-				if (!UnknownList.empty())
-				{
-					UnknownList += ", ";
-				}
-				UnknownList += "'";
-				UnknownList += Pattern;
-				UnknownList += "'";
+				throw std::runtime_error(fmt::format("unexpected '/' in literal segment of URI pattern '{}'", UriPattern));
 			}
 
-			throw std::runtime_error(fmt::format("unknown pattern(s) {} in regex route '{}'", UnknownList, Regex));
+			int SegmentStart = i;
+			while (++i < RegexLen && UriPattern[i] != '/')
+				;
+
+			std::string_view Segment(&UriPattern[SegmentStart], (i - SegmentStart));
+			int				 LiteralIndex = gsl::narrow_cast<int>(m_Literals.size());
+			m_Literals.push_back(std::string(Segment));
+			MatcherIndices.push_back(-1 - LiteralIndex);
 		}
 
-		return true;
+		if (i < RegexLen && UriPattern[i] == '/')
+		{
+			++i;  // skip slash
+		}
 	}
 
-	return false;
+	m_MatcherEndpoints.emplace_back(std::move(MatcherIndices), SupportedVerbs, std::move(HandlerFunc), UriPattern);
+}
+
+std::string_view
+HttpRouterRequest::GetCapture(uint32_t Index) const
+{
+	ZEN_ASSERT(Index < m_CapturedSegments.size());
+	return m_CapturedSegments[Index];
 }
 
 bool
@@ -903,8 +801,6 @@ HttpRequestRouter::HandleRequest(zen::HttpServerRequest& Request)
 	std::string_view  Uri = Request.RelativeUri();
 	HttpRouterRequest RouterRequest(Request);
 
-	// First try new-style matcher routes
-
 	for (const MatcherEndpoint& Handler : m_MatcherEndpoints)
 	{
 		if ((Handler.Verbs & Verb) == Verb)
@@ -1002,28 +898,6 @@ HttpRequestRouter::HandleRequest(zen::HttpServerRequest& Request)
 		}
 	}
 
-	// Old-style regex routes
-
-	for (const auto& Handler : m_RegexHandlers)
-	{
-		if ((Handler.Verbs & Verb) == Verb && regex_match(begin(Uri), end(Uri), RouterRequest.m_Match, Handler.RegEx))
-		{
-#if ZEN_WITH_OTEL
-			if (otel::Span* ActiveSpan = otel::Span::GetCurrentSpan())
-			{
-				ExtendableStringBuilder<128> RoutePath;
-				RoutePath.Append(Request.Service().BaseUri());
-				RoutePath.Append(Handler.Pattern);
-				ActiveSpan->AddAttribute("http.route"sv, RoutePath.ToView());
-			}
-#endif
-
-			Handler.Handler(RouterRequest);
-
-			return true;  // Route matched
-		}
-	}
-
 	return false;  // No route matched
 }
 
@@ -1422,72 +1296,6 @@ TEST_CASE("http.common")
 		virtual uint32_t ParseRequestId() const override { return 0; }
 	};
 
-	SUBCASE("router-regex")
-	{
-		bool					 HandledA  = false;
-		bool					 HandledAA = false;
-		std::vector<std::string> Captures;
-		auto					 Reset = [&] {
-			Captures.clear();
-			HandledA = HandledAA = false;
-		};
-
-		TestHttpService Service;
-
-		HttpRequestRouter r;
-		r.AddPattern("a", "([[:alpha:]]+)");
-		r.RegisterRoute(
-			"{a}",
-			[&](auto& Req) {
-				HandledA = true;
-				Captures = {std::string(Req.GetCapture(0))};
-			},
-			HttpVerb::kGet);
-
-		r.RegisterRoute(
-			"{a}/{a}",
-			[&](auto& Req) {
-				HandledAA = true;
-				Captures  = {std::string(Req.GetCapture(1)), std::string(Req.GetCapture(2))};
-			},
-			HttpVerb::kGet);
-
-		{
-			Reset();
-			TestHttpServerRequest req(Service, "abc"sv);
-			r.HandleRequest(req);
-			CHECK(HandledA);
-			CHECK(!HandledAA);
-			REQUIRE_EQ(Captures.size(), 1);
-			CHECK_EQ(Captures[0], "abc"sv);
-		}
-
-		{
-			Reset();
-			TestHttpServerRequest req{Service, "abc/def"sv};
-			r.HandleRequest(req);
-			CHECK(!HandledA);
-			CHECK(HandledAA);
-			REQUIRE_EQ(Captures.size(), 2);
-			CHECK_EQ(Captures[0], "abc"sv);
-			CHECK_EQ(Captures[1], "def"sv);
-		}
-
-		{
-			Reset();
-			TestHttpServerRequest req{Service, "123"sv};
-			r.HandleRequest(req);
-			CHECK(!HandledA);
-		}
-
-		{
-			Reset();
-			TestHttpServerRequest req{Service, "a123"sv};
-			r.HandleRequest(req);
-			CHECK(!HandledA);
-		}
-	}
-
 	SUBCASE("router-matcher")
 	{
 		bool					 HandledA		 = false;